Update PosableState.kt

Signed-off-by: Polymeta <4726322-polymeta@users.noreply.gitlab.com>

.gitlab-ci.yml

@@ -157,6 +157,9 @@ build:
     paths:
       - neoforge/build/libs
       - fabric/build/libs
+    exclude:
+      - neoforge/build/libs/*-dev-shadow.jar
+      - fabric/build/libs/*-dev-shadow.jar
 
 publish:
   stage: deploy

CHANGELOG.md

@@ -13,6 +13,8 @@
   - Galarica Wreath, Cleanse Tag, Spell Tag, Sharp Beak, Covert Cloak, Shell Helmet, and Never-Melt Ice.
 - Wearable items can now be equipped by a player by holding it and right-clicking (or rebound use/interact)
   - Wearable items that can be placed down are exempt from this behaviour.
+- The evolution tree can now be viewed on the Pokédex, showing a Pokémon's full family line and what's needed to evolve into each stage.
+- Added custom sounds to a bunch of items that can be placed as blocks: liquid bottles, pill bottles, powders and dice.
 
 ### Pokémon Added
 #### Generation 4
@@ -82,10 +84,17 @@
 - Updated various recipes to display in Recipe Groups within the Recipe Book
 - Updated most recipes to display more logically/consistently within the Recipe Book's categories
 - Make ride rotations less jittery in multiplayer.
+- Changes tm shelf discs to use textures instead of tinting and overlays to line up with item display
+- Blank TM can now be inserted into the Disc Shelf
+- Recall animation now renders ball in hand with the player arm raised.
 - Made regional and Vivillon split-evo locations now mutually exclusive
+- Item evolutions now unlock **all** locked evolutions whose requirements are met instead of stopping after the first.
+  - Exceptions being "forced" evolutions which will continue to stop after the first one
 
 ### Fixes
 - Correctly grants "They're Minerals!" advancement when planting a type gem
+- Shoulder mounted Pokémon now follow player body animations, improving their positioning with custom player animations and default actions.
+- Shoulder mounted Pokémon now sit slightly higher with chest armor equipped for better alignment, with a configurable blacklist.
 - Type Gem Blocks now have advancements to give you the recipe in the recipe book (the data for the advancements were inside the recipes somehow??)
 - Some other recipes without advancements have also been corrected
 - Corrected the TM Recipes for Charge Beam and Payday
@@ -107,8 +116,22 @@
 - Fixed Alolan Diglett's cry not playing
 - Fixed shiny alpha Snorlax using the non-shiny texture
 - Various Structure fixes
+- Fixed shiny Pokémon under certain circumstances forgetting taught TMs
+- Fixed certain Pokémon sounds sometimes being doubled when played at specific times in their animations
+- Fixed ball capture beam origin coming from behind the ball.
+- Fixed Safari Ball catch rate outside of battle
 
 ### Developer
+- Evolution requirements can now set `pokedexIcon` and `pokedexTooltip` directly in their JSON to control how they're shown on the Pokédex's evolution tree, for example:
+  ```json
+  {
+    "variant": "attack_defence_ratio",
+    "pokedexIcon": "minecraft:diamond_sword",
+    "pokedexTooltip": "cobblemon.ui.pokedex.requirement.attack_defence_ratio.tooltip"
+  }
+  ```
+- Fixed wrong order of operations in the code flow prior to the `FOSSIL_REVIVED` event causing pokemon to appear without entity link
+- Fixed TestPartySlot command not correctly comparing the provided spec with the target Pokémon
 
 ### Molang & Datapacks
 - A new `negate` variant for evolution requirements has been added, which will negate (invert) the provided inner condition.
@@ -119,4 +142,4 @@
 #### New Move Animations
 
 ### Localization
-- Updated translations for:
+- Updated translations for:

build.gradle.kts

@@ -1,3 +1,6 @@
+import utilities.gitBranch
+import utilities.gitShortCommit
+
 plugins {
     id("cobblemon.root-conventions")
 }
@@ -6,6 +9,6 @@ version = "${project.property("mod_version")}+${project.property("mc_version")}"
 
 val isSnapshot = project.property("snapshot")?.equals("true") == true
 if (isSnapshot) {
-    val fixedBranchName = versioning.info.branch.substringAfter("/")
-    version = "$version-${fixedBranchName}-${versioning.info.build}"
+    val fixedBranchName = gitBranch().substringAfter("/")
+    version = "$version-${fixedBranchName}-${gitShortCommit()}"
 }

common/build.gradle.kts

@@ -1,9 +1,8 @@
 
 import utilities.isSnapshot
 import utilities.version
-import java.time.OffsetDateTime
-import java.time.ZoneOffset
-import java.time.format.DateTimeFormatter
+import utilities.gitBranch
+import utilities.gitCommit
 
 /*
  *
@@ -72,6 +71,14 @@ tasks.withType<Test> {
     }
 }
 
+// Git info lives in its own output dir (not processResources) so a new commit only rewrites this one file.
+val writeGitInfo by tasks.registering(WriteProperties::class) {
+    destinationFile = layout.buildDirectory.file("generated/gitInfo/cobblemon-git.properties")
+    property("commit", gitCommit())
+    property("branch", gitBranch())
+}
+sourceSets.main { output.dir(mapOf("builtBy" to writeGitInfo), layout.buildDirectory.dir("generated/gitInfo")) }
+
 tasks.processResources {
     exclude("data/**/README.md")
 }
@@ -98,11 +105,13 @@ sourceSets {
                 property("modid", "cobblemon")
                 property("version", project.version())
                 property("isSnapshot", if(rootProject.isSnapshot()) "true" else "false")
-                property("gitCommit", versioning.info.commit)
-                property("branch", versioning.info.branch)
                 System.getProperty("buildNumber")?.let { property("buildNumber", it) }
-                property("timestamp", OffsetDateTime.now(ZoneOffset.UTC).format(DateTimeFormatter.ofPattern("MM/dd/yyyy hh:mm:ss")) + " UTC")
             }
         }
     }
 }
+
+// The platform jars are built from :common:jar, so the remapped common jars are only needed by `publish`
+tasks.assemble {
+    setDependsOn(dependsOn.filterNot { (it as? TaskProvider<*>)?.name in setOf("remapJar", "remapSourcesJar") })
+}

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

@@ -10,11 +10,13 @@ package com.cobblemon.mod.common.mixin.client;
 
 import com.cobblemon.mod.common.OrientationControllable;
 import com.cobblemon.mod.common.client.render.player.MountedPlayerRenderer;
+import com.cobblemon.mod.common.client.render.player.RecallArmAnimationTracker;
 import com.cobblemon.mod.common.duck.RidePassenger;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
 import net.minecraft.client.model.HumanoidModel;
 import net.minecraft.client.model.geom.ModelPart;
 import net.minecraft.client.player.AbstractClientPlayer;
+import net.minecraft.util.Mth;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.entity.LivingEntity;
 import org.spongepowered.asm.mixin.Final;
@@ -96,4 +98,14 @@ public class HumanoidModelMixin {
             MountedPlayerRenderer.INSTANCE.animate((HumanoidModel<AbstractClientPlayer>)(Object)this, pokemonEntity, player, netHeadYaw, headPitch, ageInTicks, limbSwing, limbSwingAmount);
         }
     }
+
+    @Inject(method = "setupAnim*", at = @At("TAIL"))
+    public void cobblemon$poseRecallArm(LivingEntity entity, float limbSwing, float limbSwingAmount, float ageInTicks, float netHeadYaw, float headPitch, CallbackInfo ci) {
+        if (!(entity instanceof AbstractClientPlayer) || entity.getVehicle() instanceof PokemonEntity) return;
+        float raise = RecallArmAnimationTracker.INSTANCE.raiseFactor(entity.getUUID());
+        if (raise <= 0f) return;
+        this.rightArm.xRot = Mth.lerp(raise, this.rightArm.xRot, (float) (-Math.PI / 2.0));
+        this.rightArm.yRot = Mth.lerp(raise, this.rightArm.yRot, 0f);
+        this.rightArm.zRot = Mth.lerp(raise, this.rightArm.zRot, 0f);
+    }
 }

common/src/main/java/com/cobblemon/mod/common/mixin/client/ItemInHandLayerMixin.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.client;
+
+import com.cobblemon.mod.common.client.render.player.RecallArmAnimationTracker;
+import com.mojang.blaze3d.vertex.PoseStack;
+import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.client.renderer.entity.layers.ItemInHandLayer;
+import net.minecraft.world.entity.HumanoidArm;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.item.ItemDisplayContext;
+import net.minecraft.world.item.ItemStack;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(ItemInHandLayer.class)
+public class ItemInHandLayerMixin {
+    @Inject(method = "renderArmWithItem", at = @At("HEAD"), cancellable = true)
+    private void cobblemon$hideRecallHandItem(LivingEntity entity, ItemStack itemStack, ItemDisplayContext itemDisplayContext, HumanoidArm humanoidArm, PoseStack poseStack, MultiBufferSource multiBufferSource, int light, CallbackInfo ci) {
+        if (humanoidArm == HumanoidArm.RIGHT && RecallArmAnimationTracker.INSTANCE.isRecalling(entity.getUUID())) {
+            ci.cancel();
+        }
+    }
+}

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

@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.mixin.client;
 
 import com.cobblemon.mod.common.OrientationControllable;
+import com.cobblemon.mod.common.client.render.player.FirstPersonRecallBallRenderer;
 import com.cobblemon.mod.common.item.PokedexItem;
 import com.mojang.blaze3d.vertex.PoseStack;
 import net.minecraft.client.Minecraft;
@@ -31,6 +32,9 @@ public class ItemInHandRendererMixin {
         if (abstractClientPlayer.isUsingItem() && abstractClientPlayer.getUseItem().getItem() instanceof PokedexItem) {
             ci.cancel();
         }
+        else if (interactionHand == InteractionHand.MAIN_HAND && FirstPersonRecallBallRenderer.INSTANCE.render(poseStack, multiBufferSource, j, f)) {
+            ci.cancel();
+        }
         else if (abstractClientPlayer instanceof OrientationControllable controllable && controllable.getOrientationController().isActive()) {
 
         }

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

@@ -8,8 +8,12 @@ object CobblemonBuildDetails {
     const val VERSION = "{{ version }}"
     const val SNAPSHOT = {{ isSnapshot }}
 
-    const val GIT_COMMIT = "{{ gitCommit | default("Not Specified") }}"
-    const val BRANCH = "{{ branch | default("Not Specified") }}"
+    // Read at runtime rather than templated in, so a new commit doesn't invalidate compiled code.
+    private val git = java.util.Properties().apply {
+        CobblemonBuildDetails::class.java.getResourceAsStream("/cobblemon-git.properties")?.use(::load)
+    }
+    @JvmField val GIT_COMMIT: String = git.getProperty("commit", "Not Specified")
+    @JvmField val BRANCH: String = git.getProperty("branch", "Not Specified")
 
     fun smallCommitHash(): String {
         return this.GIT_COMMIT.substring(0, 7)

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

@@ -657,11 +657,11 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     @JvmField
     val SACHET = create("sachet", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.WOOL).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.POUCH))
     @JvmField
-    val METAL_POWDER = create("metal_powder", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.WOOL).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.POUCH))
+    val METAL_POWDER = create("metal_powder", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_POWDER_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.POUCH))
     @JvmField
-    val QUICK_POWDER = create("quick_powder", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.WOOL).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.POUCH))
+    val QUICK_POWDER = create("quick_powder", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_POWDER_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.POUCH))
     @JvmField
-    val BRIGHT_POWDER = create("bright_powder", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.WOOL).mapColor(MapColor.NONE).noOcclusion().lightLevel{3}, DecorativeItemBlock.DecorativeItemBlockType.POUCH))
+    val BRIGHT_POWDER = create("bright_powder", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_POWDER_SOUNDS).mapColor(MapColor.NONE).noOcclusion().lightLevel{3}, DecorativeItemBlock.DecorativeItemBlockType.POUCH))
 
     @JvmField
     val NEVER_MELT_ICE = create("never_melt_ice", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.GLASS).mapColor(MapColor.NONE).noOcclusion().friction(0.989F), DecorativeItemBlock.DecorativeItemBlockType.NEVERMELT))
@@ -691,7 +691,7 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     val EJECT_BUTTON = create("eject_button", EjectButtonBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.NONE).pushReaction(PushReaction.DESTROY).noOcclusion().strength(0.125f), 40))
 
     @JvmField
-    val LOADED_DICE = create("loaded_dice", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.DICE))
+    val LOADED_DICE = create("loaded_dice", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_DICE_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.DICE))
     @JvmField
     val IRON_BALL = create("iron_ball", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.IRON_BALL))
     @JvmField
@@ -702,40 +702,40 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     val DUBIOUS_DISC = create("dubious_disc", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.UPGRADE))
 
     @JvmField
-    val THROAT_SPRAY = create("throat_spray", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.THROAT_SPRAY))
+    val THROAT_SPRAY = create("throat_spray", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.THROAT_SPRAY))
 
     @JvmField
-    val FULL_HEAL = create("full_heal", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
+    val FULL_HEAL = create("full_heal", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
     @JvmField
-    val ANTIDOTE = create("antidote", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
+    val ANTIDOTE = create("antidote", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
     @JvmField
-    val AWAKENING = create("awakening", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
+    val AWAKENING = create("awakening", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
     @JvmField
-    val BURN_HEAL = create("burn_heal", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
+    val BURN_HEAL = create("burn_heal", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
     @JvmField
-    val ICE_HEAL = create("ice_heal", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
+    val ICE_HEAL = create("ice_heal", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
     @JvmField
-    val PARALYZE_HEAL = create("paralyze_heal", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
+    val PARALYZE_HEAL = create("paralyze_heal", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
 
     @JvmField
-    val ETHER = create("ether", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.ETHER))
+    val ETHER = create("ether", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.ETHER))
     @JvmField
-    val MAX_ETHER = create("max_ether", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.ETHER))
+    val MAX_ETHER = create("max_ether", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.ETHER))
     @JvmField
-    val ELIXIR = create("elixir", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.ETHER))
+    val ELIXIR = create("elixir", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.ETHER))
     @JvmField
-    val MAX_ELIXIR = create("max_elixir", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.ETHER))
+    val MAX_ELIXIR = create("max_elixir", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.ETHER))
 
     @JvmField
-    val POTION = create("potion", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.POTION))
+    val POTION = create("potion", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.POTION))
     @JvmField
-    val SUPER_POTION = create("super_potion", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.POTION))
+    val SUPER_POTION = create("super_potion", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.POTION))
     @JvmField
-    val HYPER_POTION = create("hyper_potion", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.POTION))
+    val HYPER_POTION = create("hyper_potion", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.POTION))
     @JvmField
-    val MAX_POTION = create("max_potion", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.MAX_POTION))
+    val MAX_POTION = create("max_potion", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.MAX_POTION))
     @JvmField
-    val FULL_RESTORE = create("full_restore", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.MAX_POTION))
+    val FULL_RESTORE = create("full_restore", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.MAX_POTION))
 
     @JvmField
     val DIRE_HIT = create("dire_hit", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.BATTLE_ITEM))
@@ -755,21 +755,21 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     val X_SPEED = create("x_${Stats.SPEED.identifier.path}", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.BATTLE_ITEM))
 
     @JvmField
-    val HP_UP = create("hp_up", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
+    val HP_UP = create("hp_up", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_PILLS_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
     @JvmField
-    val PROTEIN = create("protein", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
+    val PROTEIN = create("protein", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_PILLS_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
     @JvmField
-    val IRON = create("iron", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
+    val IRON = create("iron", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_PILLS_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
     @JvmField
-    val CARBOS = create("carbos", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
+    val CARBOS = create("carbos", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_PILLS_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
     @JvmField
-    val CALCIUM = create("calcium", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
+    val CALCIUM = create("calcium", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_PILLS_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
     @JvmField
-    val ZINC = create("zinc", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
+    val ZINC = create("zinc", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_PILLS_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
     @JvmField
-    val PP_UP = create("pp_up", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
+    val PP_UP = create("pp_up", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_PILLS_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
     @JvmField
-    val PP_MAX = create("pp_max", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
+    val PP_MAX = create("pp_max", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_PILLS_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
 
     @JvmField
     val MONITOR = create("monitor", MonitorBlock(BlockBehaviour.Properties.of().mapColor(MapColor.METAL).sound(SoundType.METAL).pushReaction(PushReaction.BLOCK).requiresCorrectToolForDrops().strength(5.0F, 6.0F).lightLevel { if (it.getValue(MonitorBlock.SCREEN) != MonitorBlock.MonitorScreen.OFF) 13 else 0 }))

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

@@ -12,6 +12,7 @@ import com.cobblemon.mod.common.api.net.NetworkPacket
 import com.mojang.brigadier.arguments.ArgumentType
 import kotlin.reflect.KClass
 import net.minecraft.commands.synchronization.ArgumentTypeInfo
+import net.minecraft.core.HolderLookup
 import net.minecraft.resources.ResourceKey
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.MinecraftServer
@@ -168,12 +169,16 @@ interface CobblemonImplementation {
      * TODO
      *
      * @param identifier
-     * @param reloader
+     * @param reloaderFactory
      * @param type
      * @param dependencies
      */
-    fun registerResourceReloader(identifier: ResourceLocation, reloader: PreparableReloadListener, type: PackType, dependencies: Collection<ResourceLocation>)
-
+    fun registerResourceReloader(
+        identifier: ResourceLocation,
+        type: PackType,
+        dependencies: Collection<ResourceLocation>,
+        reloaderFactory: (HolderLookup.Provider) -> PreparableReloadListener
+    )
     /**
      * TODO
      *

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

@@ -425,6 +425,7 @@ object CobblemonNetwork {
         list.add(PacketRegisterInfo(MovesRegistrySyncPacket.ID, MovesRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(BerryRegistrySyncPacket.ID, BerryRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(SpeciesRegistrySyncPacket.ID, SpeciesRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
+        list.add(PacketRegisterInfo(SpeciesEvolutionSyncPacket.ID, SpeciesEvolutionSyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(PropertiesCompletionRegistrySyncPacket.ID, PropertiesCompletionRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(StandardSpeciesFeatureSyncPacket.ID, StandardSpeciesFeatureSyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(GlobalSpeciesFeatureSyncPacket.ID, GlobalSpeciesFeatureSyncPacket::decode, DataRegistrySyncPacketHandler()))

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

@@ -657,5 +657,65 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
         SoundEvents.WOOL_FALL
     )
 
+    @JvmField
+    val ITEM_BLOCK_POWDER_PLACE = this.create("block.item_block.powder.place")
+    @JvmField
+    val ITEM_BLOCK_POWDER_BREAK = this.create("block.item_block.powder.break")
+    @JvmField
+    val ITEM_BLOCK_POWDER_STEP = this.create("block.item_block.powder.step")
+    @JvmField
+    val ITEM_BLOCK_POWDER_SOUNDS = SoundType(1f, 1.1f,
+        ITEM_BLOCK_POWDER_BREAK,
+        ITEM_BLOCK_POWDER_STEP,
+        ITEM_BLOCK_POWDER_PLACE,
+        ITEM_BLOCK_POWDER_STEP,
+        ITEM_BLOCK_POWDER_STEP
+    )
+
+    @JvmField
+    val ITEM_BLOCK_BOTTLE_LIQUID_PLACE = this.create("block.item_block.bottle_liquid.place")
+    @JvmField
+    val ITEM_BLOCK_BOTTLE_LIQUID_BREAK = this.create("block.item_block.bottle_liquid.break")
+    @JvmField
+    val ITEM_BLOCK_BOTTLE_LIQUID_STEP = this.create("block.item_block.bottle_liquid.step")
+    @JvmField
+    val ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS = SoundType(1f, 1.1f,
+        ITEM_BLOCK_BOTTLE_LIQUID_BREAK,
+        ITEM_BLOCK_BOTTLE_LIQUID_STEP,
+        ITEM_BLOCK_BOTTLE_LIQUID_PLACE,
+        ITEM_BLOCK_BOTTLE_LIQUID_PLACE,
+        ITEM_BLOCK_BOTTLE_LIQUID_PLACE
+    )
+
+    @JvmField
+    val ITEM_BLOCK_BOTTLE_PILLS_PLACE = this.create("block.item_block.bottle_pills.place")
+    @JvmField
+    val ITEM_BLOCK_BOTTLE_PILLS_BREAK = this.create("block.item_block.bottle_pills.break")
+    @JvmField
+    val ITEM_BLOCK_BOTTLE_PILLS_STEP = this.create("block.item_block.bottle_pills.step")
+    @JvmField
+    val ITEM_BLOCK_BOTTLE_PILLS_SOUNDS = SoundType(1f, 1.1f,
+        ITEM_BLOCK_BOTTLE_PILLS_BREAK,
+        ITEM_BLOCK_BOTTLE_PILLS_STEP,
+        ITEM_BLOCK_BOTTLE_PILLS_PLACE,
+        ITEM_BLOCK_BOTTLE_PILLS_PLACE,
+        ITEM_BLOCK_BOTTLE_PILLS_PLACE
+    )
+
+    @JvmField
+    val ITEM_BLOCK_DICE_PLACE = this.create("block.item_block.dice.place")
+    @JvmField
+    val ITEM_BLOCK_DICE_BREAK = this.create("block.item_block.dice.break")
+    @JvmField
+    val ITEM_BLOCK_DICE_STEP = this.create("block.item_block.dice.step")
+    @JvmField
+    val ITEM_BLOCK_DICE_SOUNDS = SoundType(1f, 1.1f,
+        ITEM_BLOCK_DICE_BREAK,
+        ITEM_BLOCK_DICE_STEP,
+        ITEM_BLOCK_DICE_PLACE,
+        ITEM_BLOCK_DICE_STEP,
+        ITEM_BLOCK_DICE_STEP
+    )
+
     private fun create(name: String): SoundEvent = this.create(name, SoundEvent.createVariableRangeEvent(cobblemonResource(name)))
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/conditional/RegistryLikeAdapter.kt

@@ -11,6 +11,9 @@ package com.cobblemon.mod.common.api.conditional
 import com.google.gson.JsonDeserializationContext
 import com.google.gson.JsonDeserializer
 import com.google.gson.JsonElement
+import com.google.gson.JsonPrimitive
+import com.google.gson.JsonSerializationContext
+import com.google.gson.JsonSerializer
 import java.lang.reflect.Type
 
 /**
@@ -21,11 +24,19 @@ import java.lang.reflect.Type
  * @author Hiroku
  * @since July 17th, 2022
  */
-interface RegistryLikeAdapter<B> : JsonDeserializer<RegistryLikeCondition<B>> {
+interface RegistryLikeAdapter<B> : JsonDeserializer<RegistryLikeCondition<B>>, JsonSerializer<RegistryLikeCondition<B>> {
     val registryLikeConditions: MutableList<(JsonElement) -> RegistryLikeCondition<B>?>
 
     override fun deserialize(json: JsonElement, type: Type, ctx: JsonDeserializationContext): RegistryLikeCondition<B> {
         return registryLikeConditions.firstNotNullOfOrNull { it(json) }
             ?: throw IllegalArgumentException("Unable to deserialize $json")
     }
+
+    override fun serialize(src: RegistryLikeCondition<B>, typeOfSrc: Type, ctx: JsonSerializationContext): JsonElement {
+        return when (src) {
+            is RegistryLikeTagCondition<B> -> JsonPrimitive(RegistryLikeTagCondition.PREFIX + src.tag.location())
+            is RegistryLikeIdentifierCondition<B> -> JsonPrimitive(src.identifier.toString())
+            else -> throw IllegalArgumentException("Unable to serialize $src")
+        }
+    }
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/data/ServerJsonDataRegistry.kt

@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of 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.data
+
+import com.cobblemon.mod.common.util.endsWith
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+import net.minecraft.core.HolderLookup
+import java.io.BufferedReader
+import java.io.File
+import java.util.concurrent.ExecutionException
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.server.packs.PackType
+import net.minecraft.server.packs.resources.ResourceManager
+
+/**
+ * A [DataRegistry] that consumes JSON files.
+ * Every deserialized instance is attached to an [Identifier].
+ * For example a file under data/mymod/[resourcePath]/entry.json would be backed by the identifier modid:entry.
+ *
+ * @param T The type of the data consumed by this registry.
+ *
+ * @author Licious
+ * @since August 5th, 2022
+ */
+interface ServerJsonDataRegistry<T> : DataRegistry {
+
+    /**
+     * The [TypeToken] of type [T].
+     */
+    val typeToken: TypeToken<T>
+
+    /**
+     * The folder location for the data this registry will consume.
+     */
+    val resourcePath: String
+
+    override val type: PackType
+        get() = PackType.SERVER_DATA
+
+    override fun reload(manager: ResourceManager) {
+        //NO-OP, handled by reload(manager, registry)
+    }
+
+    fun reload(manager: ResourceManager, registry: HolderLookup.Provider) {
+        val gson = setupParser(registry)
+        val data = hashMapOf<ResourceLocation, T>()
+        manager.listResources(resourcePath) { path -> path.endsWith(JSON_EXTENSION) }.forEach { (identifier, resource) ->
+            if (identifier.namespace == "pixelmon") {
+                return@forEach
+            }
+
+            resource.open().use { stream ->
+                stream.bufferedReader().use { reader ->
+                    val resolvedIdentifier = ResourceLocation.fromNamespaceAndPath(identifier.namespace, File(identifier.path).nameWithoutExtension)
+                    data[resolvedIdentifier] = parse(reader, resolvedIdentifier, gson)
+                }
+            }
+        }
+
+        reload(data, registry)
+    }
+
+    fun parse(reader: BufferedReader, identifier: ResourceLocation, gson: Gson): T {
+        return try {
+            gson.fromJson(reader, typeToken.type)
+        } catch (exception: Exception) {
+            throw ExecutionException("Error loading JSON for data: $identifier", exception)
+        }
+    }
+
+    /**
+     * Allows the creation of [Gson] instances which have adapters that are registry-aware, e.g. [com.cobblemon.mod.common.pokemon.evolution.adapters.LegacyItemConditionWrapperAdapter]
+     */
+    fun setupParser(registry: HolderLookup.Provider): Gson
+
+    /**
+     * Reloads this registry from the deserialized data.
+     *
+     * @param data A map of the data associating an instance to the respective identifier from the [ResourceManager].
+     */
+    fun reload(data: Map<ResourceLocation, T>, registry: HolderLookup.Provider)
+
+    companion object {
+        const val JSON_EXTENSION = ".json"
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/fossil/Fossils.kt

@@ -40,7 +40,7 @@ object Fossils: JsonDataRegistry<Fossil> {
         .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
         .registerTypeAdapter(PokemonProperties::class.java, pokemonPropertiesShortAdapter)
         .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Item::class.java).type, ItemLikeConditionAdapter)
-        .registerTypeAdapter(ItemPredicate::class.java, LegacyItemConditionWrapperAdapter)
+        .registerTypeAdapter(ItemPredicate::class.java, LegacyItemConditionWrapperAdapter())
         .create()
 
     override val typeToken: TypeToken<Fossil> = TypeToken.get(Fossil::class.java)

common/src/main/kotlin/com/cobblemon/mod/common/api/gui/ParentWidget.kt

@@ -10,7 +10,6 @@ package com.cobblemon.mod.common.api.gui
 
 import com.cobblemon.mod.common.client.gui.CobblemonRenderable
 import net.minecraft.client.gui.components.AbstractWidget
-import net.minecraft.client.gui.components.Renderable
 import net.minecraft.client.gui.components.events.GuiEventListener
 import net.minecraft.client.gui.narration.NarrationElementOutput
 import net.minecraft.network.chat.Component
@@ -55,6 +54,8 @@ abstract class ParentWidget(
     }
 
     override fun mouseClicked(pMouseX: Double, pMouseY: Double, pButton: Int): Boolean {
+        if (!active) return false
+
         return children.any {
             it.mouseClicked(pMouseX, pMouseY, pButton)
         }

common/src/main/kotlin/com/cobblemon/mod/common/api/gui/TreeDrawingUtils.kt

@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of 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.gui
+
+import kotlin.math.max
+import kotlin.math.min
+
+interface TreeNode<T> {
+    val children: List<TreeNode<T>>
+}
+
+class TreeDrawingNode<T>(
+    val value: T,
+    val children: List<TreeDrawingNode<T>>,
+) {
+    var x = 0
+    var y = 0
+    var offset = 0
+}
+
+fun <T> createDrawingTree(treeNode: TreeNode<T>): TreeDrawingNode<T> {
+    val root = setup(treeNode, 0, mutableListOf<Int>(), mutableListOf<Int>())
+    addMods(root, 0)
+
+    return root
+}
+
+@Suppress("UNCHECKED_CAST")
+private fun <T> setup(
+    treeNode: TreeNode<T>,
+    depth: Int,
+    nexts: MutableList<Int>,
+    offset: MutableList<Int>,
+): TreeDrawingNode<T> {
+    val children = treeNode.children.map { child ->
+        setup(child, depth + 1, nexts, offset)
+    }
+
+    val treeDrawingNode = TreeDrawingNode<T>(treeNode as T, children)
+    treeDrawingNode.y = depth
+
+    while (nexts.size <= depth) {
+        nexts.add(0)
+    }
+
+    while (offset.size <= depth) {
+        offset.add(0)
+    }
+
+    var place =
+        if (children.isEmpty()) {
+            nexts[depth]
+        } else if (children.size == 1) {
+//            children.first().x - 1
+            children.first().x
+        } else {
+//            (children[0].x + children[1].x) / 2
+            (children.first().x + children.last().x) / 2
+        }
+
+    offset[depth] = max(offset[depth], nexts[depth] - place)
+
+    if (children.isEmpty()) {
+        treeDrawingNode.x = place
+    } else {
+        treeDrawingNode.x = place + offset[depth]
+    }
+
+    nexts[depth] += 2
+    treeDrawingNode.offset = offset[depth]
+
+    return treeDrawingNode
+}
+
+private fun <T> addMods(
+    treeNode: TreeDrawingNode<T>,
+    modSum: Int,
+) {
+    treeNode.x += modSum
+    val newModSum = modSum + treeNode.offset
+
+    treeNode.children.forEach { child ->
+        addMods(child, newModSum)
+    }
+}
+
+data class TreeDrawingBounds(val minX: Int, val maxX: Int, val minY: Int, val maxY: Int) {
+    val width = maxX - minX
+    val height = maxY - minY
+    val xCenter = (maxX + minX) / 2.0
+    val yCenter = (maxY + minY) / 2.0
+}
+
+fun <T> calculateBounds(treeDrawingNode: TreeDrawingNode<T>): TreeDrawingBounds {
+    var minX = treeDrawingNode.x
+    var maxX = treeDrawingNode.x
+    var minY = treeDrawingNode.y
+    var maxY = treeDrawingNode.y
+
+    for (child in treeDrawingNode.children) {
+        val childBounds = calculateBounds(child)
+
+        minX = min(minX, childBounds.minX)
+        maxX = max(maxX, childBounds.maxX)
+        minY = min(minY, childBounds.minY)
+        maxY = max(maxY, childBounds.maxY)
+    }
+
+    return TreeDrawingBounds(minX, maxX, minY, maxY)
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/interaction/PokemonInteractions.kt

@@ -10,7 +10,7 @@ package com.cobblemon.mod.common.api.interaction
 
 import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.api.conditional.RegistryLikeCondition
-import com.cobblemon.mod.common.api.data.JsonDataRegistry
+import com.cobblemon.mod.common.api.data.ServerJsonDataRegistry
 import com.cobblemon.mod.common.api.molang.ExpressionLike
 import com.cobblemon.mod.common.api.pokemon.PokemonProperties
 import com.cobblemon.mod.common.api.pokemon.requirement.Requirement
@@ -26,6 +26,7 @@ import com.google.gson.Gson
 import com.google.gson.GsonBuilder
 import com.google.gson.reflect.TypeToken
 import net.minecraft.advancements.critereon.ItemPredicate
+import net.minecraft.core.HolderLookup
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.server.packs.PackType
@@ -36,28 +37,31 @@ import net.minecraft.world.level.block.Block
 import net.minecraft.world.level.levelgen.structure.Structure
 import net.minecraft.world.level.material.Fluid
 
-object PokemonInteractions : JsonDataRegistry<PokemonInteractionSet> {
+object PokemonInteractions : ServerJsonDataRegistry<PokemonInteractionSet> {
     override val id = cobblemonResource("pokemon_interactions")
     override val type = PackType.SERVER_DATA
+    override fun setupParser(registry: HolderLookup.Provider): Gson {
+        return GsonBuilder()
+            .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
+            .registerTypeAdapter(PokemonProperties::class.java, pokemonPropertiesShortAdapter)
+            .registerTypeAdapter(ItemPredicate::class.java, LegacyItemConditionWrapperAdapter(registry))
+            .registerTypeAdapter(Requirement::class.java, CobblemonRequirementAdapter)
+            .registerTypeAdapter(InteractionEffect::class.java, InteractionEffectAdapter)
+            .registerTypeAdapter(ExpressionLike::class.java, ExpressionLikeAdapter)
+            .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Biome::class.java).type, BiomeLikeConditionAdapter)
+            .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Block::class.java).type, BlockLikeConditionAdapter)
+            .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Item::class.java).type, ItemLikeConditionAdapter)
+            .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Structure::class.java).type, StructureLikeConditionAdapter)
+            .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Fluid::class.java).type, FluidLikeConditionAdapter)
+            .registerTypeAdapter(IntRange::class.java, IntRangeAdapter)
+            .registerTypeAdapterFactory(LowerCaseEnumTypeAdapterFactory())
+            .setPrettyPrinting()
+            .create()
+    }
+
     override val observable = SimpleObservable<PokemonInteractions>()
     override val typeToken: TypeToken<PokemonInteractionSet> = TypeToken.get(PokemonInteractionSet::class.java)
     override val resourcePath = "pokemon_interactions"
-    override val gson: Gson = GsonBuilder()
-        .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
-        .registerTypeAdapter(PokemonProperties::class.java, pokemonPropertiesShortAdapter)
-        .registerTypeAdapter(ItemPredicate::class.java, LegacyItemConditionWrapperAdapter)
-        .registerTypeAdapter(Requirement::class.java, CobblemonRequirementAdapter)
-        .registerTypeAdapter(InteractionEffect::class.java, InteractionEffectAdapter)
-        .registerTypeAdapter(ExpressionLike::class.java, ExpressionLikeAdapter)
-        .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Biome::class.java).type, BiomeLikeConditionAdapter)
-        .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Block::class.java).type, BlockLikeConditionAdapter)
-        .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Item::class.java).type, ItemLikeConditionAdapter)
-        .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Structure::class.java).type, StructureLikeConditionAdapter)
-        .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Fluid::class.java).type, FluidLikeConditionAdapter)
-        .registerTypeAdapter(IntRange::class.java, IntRangeAdapter)
-        .registerTypeAdapterFactory(LowerCaseEnumTypeAdapterFactory())
-        .setPrettyPrinting()
-        .create()
 
     val interactions = mutableListOf<PokemonInteractionSet>()
 
@@ -65,7 +69,7 @@ object PokemonInteractions : JsonDataRegistry<PokemonInteractionSet> {
         PokemonInteractionsSyncPacket(interactions).sendToPlayer(player)
     }
 
-    override fun reload(data: Map<ResourceLocation, PokemonInteractionSet>) {
+    override fun reload(data: Map<ResourceLocation, PokemonInteractionSet>, registry: HolderLookup.Provider) {
         interactions.clear()
         val split = data.entries
             .partition {
@@ -87,4 +91,4 @@ object PokemonInteractions : JsonDataRegistry<PokemonInteractionSet> {
             .flatMap { it.interactions }
             .firstOrNull(interactionCheck)
     }
-}
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/pokeball/catching/modifiers/CatchRateModifiers.kt

@@ -108,7 +108,7 @@ object CatchRateModifiers {
      * Used by [PokeBalls.SAFARI_BALL].
      * Checks if the target is not battling, if true boost by *1.5
      */
-    val SAFARI = WorldStateModifier { _, entity -> if (!entity.isBattling) 1.5F else 1F }
+    val SAFARI = MultiplierModifier(1.5f) { _, poke -> !poke.entity?.isBattling!! }
 
     /**
      * Used by [PokeBalls.PARK_BALL].

common/src/main/kotlin/com/cobblemon/mod/common/api/pokedex/AbstractPokedexManager.kt

@@ -13,6 +13,10 @@ import com.cobblemon.mod.common.api.molang.MoLangFunctions.addStandardFunctions
 import com.cobblemon.mod.common.api.molang.ObjectValue
 import com.cobblemon.mod.common.api.pokedex.entry.PokedexEntry
 import com.cobblemon.mod.common.api.pokedex.entry.PokedexForm
+import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
+import com.cobblemon.mod.common.api.pokemon.feature.ChoiceSpeciesFeatureProvider
+import com.cobblemon.mod.common.api.pokemon.feature.SpeciesFeatures
+import com.cobblemon.mod.common.api.pokemon.feature.WeightedChoiceSpeciesFeatureProvider
 import com.cobblemon.mod.common.pokedex.scanner.PokedexEntityData
 import com.cobblemon.mod.common.pokemon.Gender
 import net.minecraft.resources.ResourceLocation
@@ -72,6 +76,57 @@ abstract class AbstractPokedexManager {
         } ?: PokedexEntryProgress.UNREGISTERED
     }
 
+    fun getHighestKnowledgeFor(entry: PokedexEntry, form: PokedexForm?): PokedexEntryProgress {
+        if (form == null) return getHighestKnowledgeFor(entry)
+
+        val speciesRecord = getSpeciesRecord(entry.speciesId) ?: return PokedexEntryProgress.UNREGISTERED
+        val hasAllAspects = entry.conditionAspects.all(speciesRecord::hasAspect)
+        if (!hasAllAspects) {
+            return PokedexEntryProgress.UNREGISTERED
+        }
+
+        return speciesRecord.getFormRecord(form.displayForm)?.knowledge ?: PokedexEntryProgress.UNREGISTERED
+    }
+
+    fun getHighestKnowledgeFor(entry: PokedexEntry, form: PokedexForm?, aspects: Iterable<String>): PokedexEntryProgress {
+        val formKnowledge = getHighestKnowledgeFor(entry, form)
+
+        if (formKnowledge == PokedexEntryProgress.UNREGISTERED) return PokedexEntryProgress.UNREGISTERED
+
+        val seenAspects = getSeenAspects(entry)
+
+        // Aspects that select one of the species' own forms are already covered by the form knowledge check above,
+        // so exempt them (and every other value of the same feature, since defaults like "phony" never appear on a form directly).
+        val species = PokemonSpecies.getByIdentifier(entry.speciesId)
+        val formAspects = species?.forms?.flatMapTo(hashSetOf()) { it.aspects } ?: emptySet()
+        val formSelectingFeatureAspects = species?.let(SpeciesFeatures::getFeaturesFor).orEmpty()
+            .mapNotNull { provider ->
+                val allAspects: Collection<String> = when (provider) {
+                    is ChoiceSpeciesFeatureProvider -> provider.getAllAspects()
+                    is WeightedChoiceSpeciesFeatureProvider -> provider.getAllAspects().keys
+                    else -> return@mapNotNull null
+                }
+                allAspects.takeIf { it.any { aspect -> aspect in formAspects } }
+            }
+            .flatten()
+            .toHashSet()
+
+        val allSeenAspects = aspects
+            .filter { aspect ->
+                if (Dexes.equivalentFormsLookup[aspect] != null) return@filter false
+                if (aspect in formAspects || aspect in formSelectingFeatureAspects) return@filter false
+                if (aspect.uppercase() in setOf(Gender.MALE.name, Gender.FEMALE.name, Gender.GENDERLESS.name)) return@filter false
+                if ("shiny".equals(aspect, ignoreCase = true)) return@filter false
+
+                return@filter true
+            }
+            .all { aspect -> seenAspects.contains(aspect) }
+
+        if (!allSeenAspects) return PokedexEntryProgress.UNREGISTERED
+
+        return formKnowledge
+    }
+
     fun getEncounteredForms(entry: PokedexEntry) : List<PokedexForm> {
         return getFormsWithKnowledge(entry, PokedexEntryProgress.SEEN)
     }

common/src/main/kotlin/com/cobblemon/mod/common/api/pokedex/Dexes.kt

@@ -10,6 +10,9 @@ package com.cobblemon.mod.common.api.pokedex
 
 import com.cobblemon.mod.common.api.data.JsonDataRegistry
 import com.cobblemon.mod.common.api.pokedex.def.PokedexDef
+import com.cobblemon.mod.common.api.pokedex.entry.PokedexEntry
+import com.cobblemon.mod.common.api.pokedex.entry.PokedexForm
+import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
 import com.cobblemon.mod.common.api.reactive.SimpleObservable
 import com.cobblemon.mod.common.net.messages.client.data.PokedexDexSyncPacket
 import com.cobblemon.mod.common.util.adapters.CodecBackedAdapter
@@ -40,6 +43,17 @@ object Dexes : JsonDataRegistry<PokedexDef> {
     //Maps a dex id to its PokedexDef
     val dexEntryMap = linkedMapOf<ResourceLocation, PokedexDef>()
 
+    val equivalentForms = mapOf(
+        "galar" to listOf("region-bias-galar", "bias-galar", "galar-bias", "galarian", "galar"),
+        "alola" to listOf("region-bias-alola", "bias-alola", "alola-bias", "alolan", "alola"),
+        "hisui" to listOf("region-bias-hisui", "bias-hisui", "hisui-bias", "hisuian", "hisui"),
+        "paldea" to listOf("region-bias-paldea", "bias-paldea", "paldea-bias", "paldean", "paldea"),
+    )
+
+    val equivalentFormsLookup = equivalentForms.flatMap { (key, values) ->
+        values.map { it to key }
+    }.toMap()
+
     override fun reload(data: Map<ResourceLocation, PokedexDef>) {
         dexEntryMap.clear()
         data.entries.sortedBy { it.value.sortOrder }.forEach { (id, def) -> dexEntryMap[id] = def }
@@ -49,4 +63,41 @@ object Dexes : JsonDataRegistry<PokedexDef> {
     override fun sync(player: ServerPlayer) {
         PokedexDexSyncPacket(dexEntryMap.values).sendToPlayer(player)
     }
+
+    fun findDexEntryBySpeciesId(regionId: ResourceLocation, speciesId: ResourceLocation): PokedexEntry? {
+        return dexEntryMap[regionId]?.getEntries()?.firstOrNull { it -> it.speciesId == speciesId }
+    }
+
+    fun findDexEntryBySpeciesId(speciesId: ResourceLocation): PokedexEntry? {
+        return findDexEntryBySpeciesId(cobblemonResource("national"), speciesId)
+    }
+
+    fun findRootDexEntryBySpeciesId(speciesId: ResourceLocation, formName: String): Pair<PokedexEntry, PokedexForm> {
+        var rootSpecies = PokemonSpecies.getByIdentifier(speciesId)!!
+        val initialFormEquivalents = getFormEquivalents(formName)
+        var rootForm = rootSpecies.forms.firstOrNull { initialFormEquivalents.contains(it.name.lowercase()) }
+            ?: rootSpecies.standardForm
+
+        var preEvolution = rootForm.preEvolution
+        while (preEvolution != null) {
+            rootSpecies = preEvolution.species
+            rootForm = preEvolution.resolveForm(rootForm.aspects.toSet())
+            preEvolution = rootForm.preEvolution
+        }
+
+        val entry = findDexEntryBySpeciesId(rootSpecies.resourceIdentifier)
+            ?: throw RuntimeException("Root dex entry not found")
+
+        val formEquivalents = getFormEquivalents(rootForm.name)
+        val form =
+            entry.forms.firstOrNull { formEquivalents.contains(it.displayForm.lowercase()) } ?:
+            entry.forms.first { it.displayForm.equals("Normal", ignoreCase = true) }
+
+        return entry to form
+    }
+
+    fun getFormEquivalents(formName: String): List<String> {
+        val key = equivalentFormsLookup[formName.lowercase()]
+        return equivalentForms[key] ?: listOf(formName.lowercase())
+    }
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/pokedex/SpeciesDexRecord.kt

@@ -121,6 +121,7 @@ class SpeciesDexRecord {
 
     fun addAspects(addedAspects: Set<String>) {
         aspects.addAll(addedAspects)
+        pokedexManager.onSpeciesRecordUpdated(this)
     }
 
     /** Returns true if the given Pokémon contains new information. Internal because it's only to be called from [FormDexRecord.wouldBeDifferent]. */

common/src/main/kotlin/com/cobblemon/mod/common/api/pokemon/PokemonSpecies.kt

@@ -44,6 +44,9 @@ import com.cobblemon.mod.common.api.riding.sound.RideSoundSettingsList
 import com.cobblemon.mod.common.api.spawning.TimeRange
 import com.cobblemon.mod.common.api.types.ElementalType
 import com.cobblemon.mod.common.api.types.adapters.ElementalTypeAdapter
+import com.cobblemon.mod.common.net.messages.client.data.FormEvolutionOverride
+import com.cobblemon.mod.common.net.messages.client.data.SpeciesEvolutionEntry
+import com.cobblemon.mod.common.net.messages.client.data.SpeciesEvolutionSyncPacket
 import com.cobblemon.mod.common.net.messages.client.data.SpeciesRegistrySyncPacket
 import com.cobblemon.mod.common.pokemon.FormData
 import com.cobblemon.mod.common.pokemon.Species
@@ -128,7 +131,7 @@ object PokemonSpecies : JsonDataRegistry<Species> {
         .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Fluid::class.java).type, FluidLikeConditionAdapter)
         .registerTypeAdapter(EggGroup::class.java, EggGroupAdapter)
         .registerTypeAdapter(MobEffect::class.java, RegistryElementAdapter<MobEffect>(BuiltInRegistries::MOB_EFFECT))
-        .registerTypeAdapter(ItemPredicate::class.java, LegacyItemConditionWrapperAdapter)
+        .registerTypeAdapter(ItemPredicate::class.java, LegacyItemConditionWrapperAdapter())
         .registerTypeAdapter(RidingBehaviourSettings::class.java, RidingBehaviourSettingsAdapter)
         .registerTypeAdapter(RideSoundSettingsList::class.java, RideSoundSettingsListAdapter)
         .registerTypeAdapter(ObtainableItemCondition::class.java, ObtainableItemConditionAdapter)
@@ -243,6 +246,18 @@ object PokemonSpecies : JsonDataRegistry<Species> {
 
     override fun sync(player: ServerPlayer) {
         SpeciesRegistrySyncPacket(species.toList()).sendToPlayer(player)
+        // Sent after the species themselves so every species is already registered by the time this is decoded.
+        val evolutionEntries = species.map { singleSpecies ->
+            val formOverrides = singleSpecies.forms.mapNotNull { form ->
+                if (form.ownEvolutions == null && form.ownPreEvolution == null) {
+                    null
+                } else {
+                    FormEvolutionOverride(form.name, form.ownEvolutions, form.ownPreEvolution)
+                }
+            }
+            SpeciesEvolutionEntry(singleSpecies.resourceIdentifier, singleSpecies.evolutions, singleSpecies.preEvolution, formOverrides)
+        }
+        SpeciesEvolutionSyncPacket(evolutionEntries).sendToPlayer(player)
     }
 
     /**

common/src/main/kotlin/com/cobblemon/mod/common/api/pokemon/evolution/PreEvolution.kt

@@ -25,6 +25,8 @@ interface PreEvolution {
 
     val form: FormData
 
+    fun resolveForm(extraAspects: Set<String> = emptySet()): FormData = form
+
     companion object {
 
         fun of(species: Species, form: FormData = species.standardForm): PreEvolution = StandardPreEvolution(species, form)

common/src/main/kotlin/com/cobblemon/mod/common/api/pokemon/requirement/Requirement.kt

@@ -11,6 +11,8 @@ package com.cobblemon.mod.common.api.pokemon.requirement
 import com.cobblemon.mod.common.api.pokemon.evolution.ContextEvolution
 import com.cobblemon.mod.common.api.pokemon.evolution.Evolution
 import com.cobblemon.mod.common.pokemon.Pokemon
+import net.minecraft.resources.ResourceLocation
+import java.util.WeakHashMap
 
 /**
  * Represents a universal requirement suitable for various checks on pokemon..
@@ -32,4 +34,11 @@ fun interface Requirement {
      */
     fun check(pokemon: Pokemon): Boolean
 
+    val pokedexIcon: ResourceLocation? get() = pokedexIconOverrides[this]
+    val pokedexTooltip: String? get() = pokedexTooltipOverrides[this]
+
+    companion object {
+        val pokedexIconOverrides = WeakHashMap<Requirement, ResourceLocation>()
+        val pokedexTooltipOverrides = WeakHashMap<Requirement, String>()
+    }
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/TimeRange.kt

@@ -10,6 +10,8 @@ package com.cobblemon.mod.common.api.spawning
 
 import com.cobblemon.mod.common.api.spawning.TimeRange.Companion.timeRanges
 import com.cobblemon.mod.common.api.spawning.condition.SpawningCondition
+import com.cobblemon.mod.common.util.lang
+import net.minecraft.network.chat.MutableComponent
 import com.cobblemon.mod.common.util.adapters.IntRangesAdapter
 
 /**
@@ -49,4 +51,25 @@ class TimeRange : IntRanges {
 
     constructor() : super()
     constructor(vararg ranges: IntRange) : super(*ranges)
+
+    fun displayName(): MutableComponent? {
+        val key = timeRanges.entries.firstOrNull { entry -> this == entry.value }?.key ?: return null
+        return lang("ui.time_range.$key")
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other !is TimeRange) return false
+
+        if (other.ranges.size != this.ranges.size) return false
+        other.ranges.forEachIndexed { index, otherRange ->
+            if (this.ranges[index] != otherRange) return false
+        }
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        return ranges.hashCode()
+    }
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/condition/MoonPhase.kt

@@ -8,6 +8,8 @@
 
 package com.cobblemon.mod.common.api.spawning.condition
 
+import com.cobblemon.mod.common.util.lang
+import net.minecraft.network.chat.MutableComponent
 import net.minecraft.world.level.Level
 
 /**
@@ -42,4 +44,7 @@ enum class MoonPhase {
         fun ofWorld(world: Level): MoonPhase = VALUES[world.moonPhase]
     }
 
+    fun displayName(): MutableComponent {
+        return lang("ui.moon_phase.${this.name.lowercase()}")
+    }
 }

common/src/main/kotlin/com/cobblemon/mod/common/block/entity/DiscShelfBlockEntity.kt

@@ -128,6 +128,7 @@ class DiscShelfBlockEntity(pos: BlockPos, state: BlockState) : BlockEntity(Cobbl
 
     fun isValidItem(stack: ItemStack): Boolean {
         return stack.item is TechnicalMachineItem
+                || stack.item == CobblemonItems.BLANK_TM
                 || stack.item == CobblemonItems.UPGRADE
                 || stack.item == CobblemonItems.DUBIOUS_DISC
                 || stack.has(DataComponents.JUKEBOX_PLAYABLE)

common/src/main/kotlin/com/cobblemon/mod/common/block/multiblock/FossilMultiblockStructure.kt

@@ -31,6 +31,7 @@ import com.cobblemon.mod.common.client.sound.instances.CancellableSoundInstance
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.item.PokeBallItem
 import com.cobblemon.mod.common.pokemon.Pokemon
+import com.cobblemon.mod.common.pokemon.activestate.SentOutState
 import com.cobblemon.mod.common.util.DataKeys
 import com.cobblemon.mod.common.util.giveOrDropItemStack
 import com.cobblemon.mod.common.util.lang
@@ -235,6 +236,7 @@ class FossilMultiblockStructure (
                 entity.setPos(fixedPosition.center.subtract(0.0, 0.5, 0.0))
                 // TODO: Find a correct way to set the new entity's Yaw rotation. (Face away from the machine)
                 if (world.addFreshEntity(entity)) {
+                    pokemon.state = SentOutState(entity)
                     CobblemonEvents.FOSSIL_REVIVED.post(FossilRevivedEvent(pokemon, null))
                     return true
                 } else {

common/src/main/kotlin/com/cobblemon/mod/common/client/CobblemonClient.kt

@@ -45,6 +45,7 @@ import com.cobblemon.mod.common.client.render.entity.PokeBobberEntityRenderer
 import com.cobblemon.mod.common.client.render.generic.GenericBedrockRenderer
 import com.cobblemon.mod.common.client.render.item.CobblemonBuiltinItemRendererRegistry
 import com.cobblemon.mod.common.client.render.item.PokemonItemRenderer
+import com.cobblemon.mod.common.client.render.layer.PlayerRecallBallRenderer
 import com.cobblemon.mod.common.client.render.layer.PokemonOnShoulderRenderer
 import com.cobblemon.mod.common.client.render.models.blockbench.bedrock.animation.BedrockAnimationRepository
 import com.cobblemon.mod.common.client.render.models.blockbench.repository.BerryModelRepository
@@ -436,8 +437,10 @@ object CobblemonClient {
         var renderer: LivingEntityRenderer<Player, PlayerModel<Player>>? =
             skinMap?.get(PlayerSkin.Model.WIDE) as LivingEntityRenderer<Player, PlayerModel<Player>>
         renderer?.addLayer(PokemonOnShoulderRenderer(renderer))
+        renderer?.addLayer(PlayerRecallBallRenderer(renderer))
         renderer = skinMap[PlayerSkin.Model.SLIM] as LivingEntityRenderer<Player, PlayerModel<Player>>?
         renderer?.addLayer(PokemonOnShoulderRenderer(renderer))
+        renderer?.addLayer(PlayerRecallBallRenderer(renderer))
     }
 
     private fun registerMenuScreens() {

common/src/main/kotlin/com/cobblemon/mod/common/client/entity/PokemonClientDelegate.kt

@@ -32,6 +32,7 @@ import com.cobblemon.mod.common.client.render.models.blockbench.PosableState
 import com.cobblemon.mod.common.client.render.models.blockbench.animation.ActiveAnimation
 import com.cobblemon.mod.common.client.render.models.blockbench.animation.PrimaryAnimation
 import com.cobblemon.mod.common.client.render.models.blockbench.repository.VaryingModelRepository
+import com.cobblemon.mod.common.client.render.player.RecallArmAnimationTracker
 import com.cobblemon.mod.common.client.render.pokemon.PokemonRenderer.Companion.ease
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.net.messages.server.pokemon.update.ServerboundUpdateRidingStatePacket
@@ -320,6 +321,7 @@ class PokemonClientDelegate : PosableState(), PokemonSideDelegate {
                         ballOffset = 0f
                         ballRotOffset = 0f
                         sendOutPosition = null
+                        currentEntity.ownerUUID?.let { RecallArmAnimationTracker.start(it, currentEntity.exposedBall) }
                         afterOnClient(seconds = BEAM_EXTEND_TIME) {
                             activeSendoutScale = 1F
 

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/pokedex/PokedexGUI.kt

@@ -36,32 +36,33 @@ import com.cobblemon.mod.common.client.gui.handleProfileDebugKeys
 import com.cobblemon.mod.common.client.gui.logProfileTranslations
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.BASE_HEIGHT
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.BASE_WIDTH
+import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.HALF_OVERLAY_HEIGHT
+import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.HALF_OVERLAY_WIDTH
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.HALF_OVERLAY_WIDTH
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.HEADER_BAR_HEIGHT
+import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.ICONS_ARROW_PADDING_AROUND
+import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.ICONS_PADDING_AROUND
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.SCALE
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.TAB_ABILITIES
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.TAB_DESCRIPTION
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.TAB_DROPS
+import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.TAB_EVOLUTION_TREE
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.TAB_ICON_SIZE
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.TAB_MOVES
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.TAB_SIZE
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.TAB_STATS
-import com.cobblemon.mod.common.client.gui.pokedex.widgets.AbilitiesWidget
-import com.cobblemon.mod.common.client.gui.pokedex.widgets.DescriptionWidget
-import com.cobblemon.mod.common.client.gui.pokedex.widgets.DropsScrollingWidget
-import com.cobblemon.mod.common.client.gui.pokedex.widgets.EntriesScrollingWidget
-import com.cobblemon.mod.common.client.gui.pokedex.widgets.MovesLearnsetWidget
-import com.cobblemon.mod.common.client.gui.pokedex.widgets.PokemonInfoWidget
-import com.cobblemon.mod.common.client.gui.pokedex.widgets.SearchWidget
-import com.cobblemon.mod.common.client.gui.pokedex.widgets.SizeWidget
-import com.cobblemon.mod.common.client.gui.pokedex.widgets.StatsWidget
+import com.cobblemon.mod.common.client.gui.pokedex.widgets.*
+import com.cobblemon.mod.common.client.gui.pokedex.widgets.evolutiontree.EvolutionTreeWidget
+import com.cobblemon.mod.common.client.gui.pokedex.widgets.evolutiontree.debugEvolutionRequirementRendering
 import com.cobblemon.mod.common.client.pokedex.PokedexType
 import com.cobblemon.mod.common.client.render.drawScaledText
 import com.cobblemon.mod.common.net.messages.server.block.AdjustBlockEntityViewerCountPacket
+import com.cobblemon.mod.common.pokemon.Gender
 import com.cobblemon.mod.common.pokemon.abilities.HiddenAbility
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.cobblemon.mod.common.util.isInventoryKeyPressed
 import com.cobblemon.mod.common.util.lang
+import com.mojang.blaze3d.platform.InputConstants
 import net.minecraft.client.Minecraft
 import net.minecraft.client.gui.GuiGraphics
 import net.minecraft.client.gui.components.EditBox
@@ -94,6 +95,10 @@ class PokedexGUI private constructor(
 
         private val categoryBarOverlay = cobblemonResource("textures/gui/pokedex/pokedex_screen_bar_category.png")
 
+        // TODO: separate into smaller components / widgets?
+        private val backgroundOverlay = cobblemonResource("textures/gui/pokedex/pokedex_screen_info_overlay.png")
+        private val expandedBackgroundOverlay = cobblemonResource("textures/gui/pokedex/pokedex_screen_info_overlay_expanded.png")
+
         private val tabSelectArrow = cobblemonResource("textures/gui/pokedex/select_arrow.png")
         private val tabIcons = arrayOf(
             cobblemonResource("textures/gui/pokedex/tab_info.png"),
@@ -101,7 +106,8 @@ class PokedexGUI private constructor(
             cobblemonResource("textures/gui/pokedex/tab_size.png"),
             cobblemonResource("textures/gui/pokedex/tab_stats.png"),
             cobblemonResource("textures/gui/pokedex/tab_drops.png"),
-            cobblemonResource("textures/gui/pokedex/tab_moves.png")
+            cobblemonResource("textures/gui/pokedex/tab_moves.png"),
+            cobblemonResource("textures/gui/pokedex/tab_evolution_tree.png"),
         )
 
         val arrowUpIcon = cobblemonResource("textures/gui/pokedex/arrow_up.png")
@@ -114,6 +120,8 @@ class PokedexGUI private constructor(
             TAB_MOVES
         )
 
+        private val ICONS_PADDING_BETWEEN = (BASE_WIDTH / 2 - ICONS_PADDING_AROUND * 2) / tabIcons.size
+
         /**
          * Attempts to open this screen for a client.
          */
@@ -132,6 +140,7 @@ class PokedexGUI private constructor(
 
     var oldDragPosX = 0.0
     var canDragRender = false
+    private var activeDragableElement: GuiEventListener? = null
 
     private var filteredPokedex: Collection<PokedexDef> = mutableListOf()
     private var seenCount = "0000"
@@ -155,13 +164,29 @@ class PokedexGUI private constructor(
     private lateinit var scrollScreen: EntriesScrollingWidget
     private lateinit var pokemonInfoWidget: PokemonInfoWidget
     private lateinit var searchWidget: SearchWidget
+    private lateinit var pokemonNameWidget: PokemonNameWidget
 
     private var selectedSearchByType: SearchByType = SearchByType.SPECIES
     private var selectedCategoryFilter: PokedexCategoryFilterType = PokedexCategoryFilterType.ALL
     private val tabButtons: MutableList<ScaledButton> = mutableListOf()
 
+    var seenShinyStates = setOf<String>()
+    var shiny = false
+    var maleRatio = -1F
+    var gender = Gender.GENDERLESS
+    var aspects = mutableSetOf<String>()
+
     lateinit var tabInfoElement: GuiEventListener
     var tabInfoIndex = TAB_DESCRIPTION
+    var evolutionTreeExpanded = false
+        set(value) {
+            field = value
+
+            if (::pokemonInfoWidget.isInitialized) {
+                pokemonInfoWidget.active = !value
+                pokemonInfoWidget.visible = !value
+            }
+        }
 
     override fun renderBlurredBackground(delta: Float) {}
     override fun renderMenuBackground(context: GuiGraphics) {}
@@ -180,7 +205,7 @@ class PokedexGUI private constructor(
 
         //Info Widget
         if (::pokemonInfoWidget.isInitialized) removeWidget(pokemonInfoWidget)
-        pokemonInfoWidget = PokemonInfoWidget(x + 180, y + 28) { newForm -> updateSelectedForm(newForm) }
+        pokemonInfoWidget = PokemonInfoWidget(this, x + 180, y + 28) { newForm -> updateSelectedForm(newForm) }
         addRenderableWidget(pokemonInfoWidget)
 
         setUpTabs()
@@ -192,6 +217,10 @@ class PokedexGUI private constructor(
         searchWidget = SearchWidget(x + 26, y + 28, 120, HEADER_BAR_HEIGHT, update = ::updateFilters)
         addRenderableWidget(searchWidget)
 
+        if (::pokemonNameWidget.isInitialized) removeWidget(pokemonNameWidget)
+        pokemonNameWidget = PokemonNameWidget(this, x + 180, y + 28)
+        addRenderableWidget(pokemonNameWidget)
+
         if (::regionSelectWidgetUp.isInitialized) removeWidget(regionSelectWidgetUp)
         regionSelectWidgetUp = ScaledButton(
             buttonX = (x + 95).toFloat(),
@@ -367,6 +396,14 @@ class PokedexGUI private constructor(
             shadow = true
         )
 
+        blitk(
+            matrixStack = matrices,
+            texture = if (evolutionTreeExpanded) expandedBackgroundOverlay else backgroundOverlay,
+            x = pokemonInfoWidget.x, y = pokemonInfoWidget.y,
+            width = HALF_OVERLAY_WIDTH,
+            height = HALF_OVERLAY_HEIGHT
+        )
+
         // Category filter
         blitk(
             matrixStack = matrices,
@@ -402,7 +439,7 @@ class PokedexGUI private constructor(
             blitk(
                 matrixStack = matrices,
                 texture = tabSelectArrow,
-                x = (x + 191.5F + (22F * tabInfoIndex)) / SCALE,
+                x = (x + BASE_WIDTH / 2 + ICONS_ARROW_PADDING_AROUND + tabInfoIndex * ICONS_PADDING_BETWEEN) / SCALE,
                 y = (y + 177) / SCALE,
                 width = 12,
                 height = 6,
@@ -441,6 +478,7 @@ class PokedexGUI private constructor(
         val canDisplayEntry = true //selectedForm?.unlockForms
 
         if (::pokemonInfoWidget.isInitialized
+            && pokemonInfoWidget.active
             && !pokemonInfoWidget.suppressViewport
             && pokemonInfoWidget.isWithinPortraitSpace(mouseX, mouseY)
             && canDisplayEntry == true
@@ -449,6 +487,12 @@ class PokedexGUI private constructor(
             isDragging = true
             oldDragPosX = mouseX
             playSound(CobblemonSounds.POKEDEX_CLICK_SHORT)
+            activeDragableElement = pokemonInfoWidget
+        } else if (tabInfoIndex == TAB_EVOLUTION_TREE &&
+            ::tabInfoElement.isInitialized &&
+            (tabInfoElement as EvolutionTreeWidget).isHovered(mouseX, mouseY)
+        ) {
+            activeDragableElement = tabInfoElement
         }
         return try {
             super.mouseClicked(mouseX, mouseY, button)
@@ -460,14 +504,18 @@ class PokedexGUI private constructor(
     override fun mouseReleased(pMouseX: Double, pMouseY: Double, pButton: Int): Boolean {
         if (canDragRender) canDragRender = false
         if (isDragging) isDragging = false
+        activeDragableElement = null
         return super.mouseReleased(pMouseX, pMouseY, pButton)
     }
 
     override fun mouseDragged(mouseX: Double, mouseY: Double, button: Int, deltaX: Double, deltaY: Double): Boolean {
-        if (isDragging && canDragRender) {
+        if (isDragging && canDragRender && activeDragableElement == pokemonInfoWidget) {
             val dragOffsetY = (oldDragPosX - mouseX).toFloat()
             pokemonInfoWidget.rotationY = (((pokemonInfoWidget.rotationY + dragOffsetY) % 360 + 360) % 360)
+        } else if (activeDragableElement == tabInfoElement) {
+            tabInfoElement.mouseDragged(mouseX, mouseY, button, deltaX, deltaY)
         }
+
         oldDragPosX = mouseX
         return super.mouseDragged(mouseX, mouseY, button, deltaX, deltaY)
     }
@@ -558,6 +606,8 @@ class PokedexGUI private constructor(
         selectedForm = CobblemonClient.clientPokedexData.getEncounteredForms(newSelectedEntry).firstOrNull()
 
         pokemonInfoWidget.setDexEntry(selectedEntry!!)
+        pokemonNameWidget.update(selectedEntry!!)
+
         displaytabInfoElement(tabInfoIndex)
     }
 
@@ -569,7 +619,7 @@ class PokedexGUI private constructor(
 
         for (i in tabIcons.indices) {
             tabButtons.add(ScaledButton(
-                x + 190.5F + (i * 22F),
+                x + BASE_WIDTH / 2 + ICONS_PADDING_AROUND + i * ICONS_PADDING_BETWEEN,
                 y + 181.5F,
                 TAB_ICON_SIZE,
                 TAB_ICON_SIZE,
@@ -582,6 +632,8 @@ class PokedexGUI private constructor(
     }
 
     fun displaytabInfoElement(tabIndex: Int, update: Boolean = true) {
+        if (tabIndex != TAB_EVOLUTION_TREE) evolutionTreeExpanded = false
+
         val showActiveTab = selectedEntry?.let { selectedForm in getSufficientlyKnownForms(it, tabIndex) } == true
         var statSubIndex = 0
 
@@ -633,6 +685,9 @@ class PokedexGUI private constructor(
             TAB_MOVES -> {
                 tabInfoElement = MovesLearnsetWidget(x + 180, y + 28)
             }
+            TAB_EVOLUTION_TREE -> {
+                tabInfoElement = EvolutionTreeWidget(this, x, y)
+            }
         }
         val element = tabInfoElement
         if (element is Renderable && element is NarratableEntry) {
@@ -707,6 +762,9 @@ class PokedexGUI private constructor(
                         selectedForm = fallbackForm
                     ) { next -> cycleSelectedForm(next) }
                 }
+                TAB_EVOLUTION_TREE -> {
+                    (tabInfoElement as EvolutionTreeWidget).setup(selectedEntry, selectedForm)
+                }
             }
         } else {
             if (tabInfoIndex != TAB_DESCRIPTION) displaytabInfoElement(TAB_DESCRIPTION)
@@ -770,6 +828,10 @@ class PokedexGUI private constructor(
             }
         }
 
+        if (tabInfoIndex == TAB_EVOLUTION_TREE && keyCode == InputConstants.KEY_SEMICOLON) {
+            debugEvolutionRequirementRendering()
+        }
+
         return super.keyPressed(keyCode, scanCode, modifiers)
     }
 

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/pokedex/PokedexGUIConstants.kt

@@ -16,6 +16,8 @@ object PokedexGUIConstants {
     const val HEADER_BAR_HEIGHT = 11
     const val POKEMON_DESCRIPTION_HEIGHT = 42
     const val POKEMON_DESCRIPTION_PADDING = 9
+    const val ICONS_PADDING_AROUND = 18.5f
+    const val ICONS_ARROW_PADDING_AROUND = ICONS_PADDING_AROUND + 1
 
     const val TAB_ICON_SIZE = 16
 
@@ -36,6 +38,7 @@ object PokedexGUIConstants {
     const val TAB_STATS = 3
     const val TAB_DROPS = 4
     const val TAB_MOVES = 5
+    const val TAB_EVOLUTION_TREE = 6
 
     // RowScrollingWidget
     const val SCROLL_BASE_HEIGHT = 141

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/pokedex/PokedexTooltip.kt

@@ -13,38 +13,101 @@ import com.cobblemon.mod.common.api.text.font
 import com.cobblemon.mod.common.client.CobblemonResources
 import com.cobblemon.mod.common.client.render.drawScaledText
 import com.cobblemon.mod.common.util.cobblemonResource
+import com.mojang.blaze3d.vertex.PoseStack
 import net.minecraft.client.Minecraft
 import net.minecraft.client.gui.GuiGraphics
 import net.minecraft.network.chat.MutableComponent
+import net.minecraft.resources.ResourceLocation
 
 private val tooltipEdge = cobblemonResource("textures/gui/pokedex/tooltip_edge.png")
 private val tooltipBackground = cobblemonResource("textures/gui/pokedex/tooltip_background.png")
 
-fun renderTooltip(context: GuiGraphics, text: MutableComponent, posX: Int, posY: Int, delta: Float, offsetY: Int = 0) {
+private const val TOOLTIP_SLICE_SIZE = 11
+
+fun renderTooltip(
+    context: GuiGraphics,
+    text: MutableComponent,
+    posX: Int,
+    posY: Int,
+    delta: Float,
+    offsetY: Int = 0,
+) {
+    renderTooltip(
+        context,
+        listOf(text),
+        posX,
+        posY,
+        delta,
+        offsetY,
+    )
+}
+
+fun renderTooltip(
+    context: GuiGraphics,
+    text: List<MutableComponent>,
+    posX: Int,
+    posY: Int,
+    delta: Float,
+    offsetY: Int = 0,
+) {
     val poseStack = context.pose()
-    val textWidth = Minecraft.getInstance().font.width(text.font(CobblemonResources.DEFAULT_LARGE))
-    val tooltipWidth = textWidth + 6
-    val tooltipHeight = 11
+    val textWidth = text.maxOf { Minecraft.getInstance().font.width(it.font(CobblemonResources.DEFAULT_LARGE)) }
+    val tooltipPadding = 6
+    val tooltipWidth = textWidth + tooltipPadding
     val tooltipTop = posY + offsetY
 
     poseStack.pushPose()
     poseStack.translate(0.0, 0.0, 1000.0)
+
     Minecraft.getInstance().let {
         it.mainRenderTarget.bindWrite(false)
         context.enableScissor(
             posX - (tooltipWidth / 2),
             tooltipTop + 1,
             (posX - (tooltipWidth / 2)) + tooltipWidth,
-            tooltipTop + 10
+            tooltipTop + TOOLTIP_SLICE_SIZE * text.size - 1
         )
         it.gameRenderer.processBlurEffect(delta)
         context.disableScissor()
         it.mainRenderTarget.bindWrite(true)
     }
 
-    blitk(matrixStack = poseStack, texture = tooltipEdge, x = posX - (tooltipWidth / 2) - 1, y = tooltipTop, width = 1, height = tooltipHeight)
-    blitk(matrixStack = poseStack, texture = tooltipBackground, x = posX - (tooltipWidth / 2), y = tooltipTop, width = tooltipWidth, height = tooltipHeight)
-    blitk(matrixStack = poseStack, texture = tooltipEdge, x = posX + (tooltipWidth / 2), y = tooltipTop, width = 1, height = tooltipHeight)
-    drawScaledText(context = context, font = CobblemonResources.DEFAULT_LARGE, text = text, x = posX, y = tooltipTop + 1, shadow = true, centered = true)
+    val totalHeight = TOOLTIP_SLICE_SIZE * text.size
+
+    blitSlicedVertical(poseStack, tooltipEdge, posX - (tooltipWidth / 2) - 1, tooltipTop, 1, totalHeight)
+    blitSlicedVertical(poseStack, tooltipBackground, posX - (tooltipWidth / 2), tooltipTop, tooltipWidth, totalHeight)
+    blitSlicedVertical(poseStack, tooltipEdge, posX + (tooltipWidth / 2), tooltipTop, 1, totalHeight)
+
+    val centered = text.size == 1
+
+    text.forEachIndexed { index, it ->
+        drawScaledText(
+            context = context,
+            font = CobblemonResources.DEFAULT_LARGE,
+            text = it,
+            x = if (centered) posX else posX - tooltipWidth / 2 + tooltipPadding / 2,
+            y = tooltipTop + 1 + TOOLTIP_SLICE_SIZE * index,
+            shadow = true,
+            centered = centered
+        )
+    }
+
     poseStack.popPose()
 }
+
+// Stretching the whole 11px image over an arbitrary height thickens the caps as more lines are added, so
+// instead the caps are drawn 1:1 and only the flat fill row is stretched to cover the remaining height
+private fun blitSlicedVertical(
+    poseStack: PoseStack,
+    texture: ResourceLocation,
+    x: Number,
+    y: Int,
+    width: Number,
+    totalHeight: Int,
+) {
+    val middleHeight = totalHeight - 2
+
+    blitk(matrixStack = poseStack, texture = texture, x = x, y = y, width = width, height = 1, vOffset = 0, textureHeight = TOOLTIP_SLICE_SIZE)
+    blitk(matrixStack = poseStack, texture = texture, x = x, y = y + 1, width = width, height = middleHeight, vOffset = middleHeight, textureHeight = TOOLTIP_SLICE_SIZE * middleHeight)
+    blitk(matrixStack = poseStack, texture = texture, x = x, y = y + 1 + middleHeight, width = width, height = 1, vOffset = TOOLTIP_SLICE_SIZE - 1, textureHeight = TOOLTIP_SLICE_SIZE)
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/pokedex/ScaledButton.kt

@@ -20,8 +20,8 @@ import net.minecraft.client.sounds.SoundManager
 import net.minecraft.resources.ResourceLocation
 
 class ScaledButton(
-    var buttonX: Float,
-    var buttonY: Float,
+    buttonX: Float,
+    buttonY: Float,
     val buttonWidth: Number,
     val buttonHeight: Number,
     var resource: ResourceLocation? = null,
@@ -30,6 +30,18 @@ class ScaledButton(
     val clickAction: Button.OnPress
 ): Button(buttonX.toInt(), buttonY.toInt(), buttonWidth.toInt(), buttonHeight.toInt(), "".text(), clickAction, DEFAULT_NARRATION), CobblemonRenderable {
 
+    var buttonX: Float = buttonX
+        set(value) {
+            field = value
+            this.x = value.toInt()
+        }
+
+    var buttonY: Float = buttonY
+        set(value) {
+            field = value
+            this.y = value.toInt()
+        }
+
     var isWidgetActive = false
     var isVisible = true
 

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/pokedex/widgets/EntriesScrollingWidget.kt

@@ -12,14 +12,13 @@ import com.bedrockk.molang.runtime.MoLangRuntime
 import com.cobblemon.mod.common.CobblemonSounds
 import com.cobblemon.mod.common.api.gui.blitk
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.setup
-import com.cobblemon.mod.common.api.pokedex.entry.PokedexEntry
 import com.cobblemon.mod.common.api.pokedex.PokedexEntryProgress
+import com.cobblemon.mod.common.api.pokedex.entry.PokedexEntry
 import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
 import com.cobblemon.mod.common.api.text.text
 import com.cobblemon.mod.common.client.ClientMoLangFunctions.setupClient
 import com.cobblemon.mod.common.client.CobblemonClient
 import com.cobblemon.mod.common.client.gui.ScrollingWidget
-import com.cobblemon.mod.common.client.gui.drawProfilePokemon
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.SCALE
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.SCROLL_BAR_WIDTH
@@ -27,19 +26,14 @@ import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.SCROLL_BA
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.SCROLL_SLOT_SIZE
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.SCROLL_SLOT_SPACING
 import com.cobblemon.mod.common.client.gui.pokedex.widgets.EntriesScrollingWidget.PokemonScrollSlotRow
-import com.cobblemon.mod.common.client.render.drawScaledText
-import com.cobblemon.mod.common.client.render.models.blockbench.FloatingState
 import com.cobblemon.mod.common.pokemon.Gender
 import com.cobblemon.mod.common.pokemon.RenderablePokemon
 import com.cobblemon.mod.common.util.cobblemonResource
-import com.cobblemon.mod.common.util.math.fromEulerXYZDegrees
 import net.minecraft.client.Minecraft
 import net.minecraft.client.gui.GuiGraphics
 import net.minecraft.client.resources.sounds.SimpleSoundInstance
 import net.minecraft.network.chat.Component
 import net.minecraft.util.Mth
-import org.joml.Quaternionf
-import org.joml.Vector3f
 
 class EntriesScrollingWidget(val pX: Int, val pY: Int, val setPokedexEntry: (PokedexEntry) -> (Unit)): ScrollingWidget<PokemonScrollSlotRow>(
     width = PokedexGUIConstants.HALF_OVERLAY_WIDTH,
@@ -135,13 +129,6 @@ class EntriesScrollingWidget(val pX: Int, val pY: Int, val setPokedexEntry: (Pok
         val discoveryLevelList: MutableList<PokedexEntryProgress>,
         val setPokedexEntry : (PokedexEntry) -> (Unit)
     ): Slot<PokemonScrollSlotRow>() {
-        companion object {
-            private val slotResource = cobblemonResource("textures/gui/pokedex/pokedex_slot.png")
-            private val slotHighlight = cobblemonResource("textures/gui/pokedex/slot_select.png")
-            private val caughtIcon = cobblemonResource("textures/gui/pokedex/caught_icon_small.png")
-            private val unknownIcon = cobblemonResource("textures/gui/pokedex/pokedex_slot_unknown.png")
-            private val unimplementedIcon = cobblemonResource("textures/gui/pokedex/pokedex_slot_unimplemented.png")
-        }
         val runtime = MoLangRuntime().setupClient().setup().also {
             it.environment.query.addFunction("get_pokedex") { CobblemonClient.clientPokedexData.struct }
         }
@@ -161,128 +148,42 @@ class EntriesScrollingWidget(val pX: Int, val pY: Int, val setPokedexEntry: (Pok
             hovered: Boolean,
             tickDelta: Float
         ) {
-            dexDataList.forEachIndexed { index, dexData ->
-                val state = FloatingState()
-                val species = PokemonSpecies.getByIdentifier(dexData.speciesId)
-                //FIXME: This may not work properly when accounting for custom pokemon with the same dex number
-                val pokemonNumber = (species?.nationalPokedexNumber?.toString() ?: "0").padStart(4, '0')
-
-                val speciesNumber = pokemonNumber.text()
+            dexDataList.forEachIndexed { index, pokedexEntry ->
+                val species = PokemonSpecies.getByIdentifier(pokedexEntry.speciesId)
                 val discoveryLevel = discoveryLevelList[index]
-                val firstVisibleForm = CobblemonClient.clientPokedexData.getEncounteredForms(dexData).firstOrNull()
-                val shouldDrawMon = firstVisibleForm != null
+                val firstVisibleForm = CobblemonClient.clientPokedexData.getEncounteredForms(pokedexEntry).firstOrNull()
 
                 if (species == null) {
                     return@forEachIndexed
                 }
 
-                val matrices = context.pose()
+                val renderablePokemon =
+                    if (firstVisibleForm != null) {
+                        val firstVisibleGender = CobblemonClient.clientPokedexData.getSeenGenders(pokedexEntry, firstVisibleForm).firstOrNull()
+                        val shinyStates = CobblemonClient.clientPokedexData.getSeenShinyStates(pokedexEntry, firstVisibleForm)
+                        val firstVisibleShiny = shinyStates.count() == 1 && shinyStates.first() == "shiny"
+                        val formAspects = species.forms.firstOrNull { it.name.equals(firstVisibleForm.displayForm, ignoreCase = true) }?.aspects ?: species.standardForm.aspects
+                        val seenAspects = CobblemonClient.clientPokedexData.getSeenAspects(pokedexEntry)
+                        val variationAspects = pokedexEntry.variations.mapNotNull { it.aspects.firstOrNull { it in seenAspects } }
+                        val aspectsToDraw = (pokedexEntry.displayAspects + variationAspects + formAspects + (firstVisibleGender ?: Gender.GENDERLESS).name.lowercase()).toMutableSet()
+                        if (firstVisibleShiny) {
+                            aspectsToDraw.add("shiny")
+                        }
 
-                val startPosX = x + ((SCROLL_SLOT_SPACING + SCROLL_SLOT_SIZE) * index)
-                val startPosY = y + SCROLL_SLOT_SPACING + 1
-
-                blitk(
-                    matrixStack = matrices,
-                    texture = slotResource,
-                    x = startPosX,
-                    y = startPosY,
-                    width = SCROLL_SLOT_SIZE,
-                    height = SCROLL_SLOT_SIZE
-                )
-
-                if (getHoveredSlotIndex(mouseX, mouseY) == index) {
-                    blitk(
-                        matrixStack = matrices,
-                        texture = slotHighlight,
-                        x = startPosX,
-                        y = startPosY,
-                        width = SCROLL_SLOT_SIZE,
-                        height = SCROLL_SLOT_SIZE,
-                        vOffset = SCROLL_SLOT_SIZE,
-                        textureHeight = SCROLL_SLOT_SIZE * 2
-                    )
-                }
-
-                if (shouldDrawMon) {
-                    val firstVisibleGender = CobblemonClient.clientPokedexData.getSeenGenders(dexData, firstVisibleForm).firstOrNull()
-                    val shinyStates = CobblemonClient.clientPokedexData.getSeenShinyStates(dexData, firstVisibleForm)
-                    val firstVisibleShiny = shinyStates.count() == 1 && shinyStates.first() == "shiny"
-                    val formAspects = species.forms.firstOrNull { it.name.equals(firstVisibleForm.displayForm, ignoreCase = true) }?.aspects ?: species.standardForm.aspects
-                    val seenAspects = CobblemonClient.clientPokedexData.getSeenAspects(dexData)
-                    val variationAspects = dexData.variations.mapNotNull { it.aspects.firstOrNull { it in seenAspects } }
-                    context.enableScissor(
-                        startPosX + 1,
-                        startPosY + 1,
-                        startPosX + SCROLL_SLOT_SIZE - 1,
-                        startPosY + SCROLL_SLOT_SIZE - 2
-                    )
-                    val aspectsToDraw = (dexData.displayAspects + variationAspects + formAspects + (firstVisibleGender ?: Gender.GENDERLESS).name.lowercase()).toMutableSet()
-                    if (firstVisibleShiny) {
-                        aspectsToDraw.add("shiny")
+                        RenderablePokemon(species, aspectsToDraw)
+                    } else {
+                        null
                     }
-                    state.currentAspects = aspectsToDraw
-                    matrices.pushPose()
-                    matrices.translate(startPosX + (SCROLL_SLOT_SIZE / 2.0), startPosY + 1.0, 0.0)
-                    matrices.scale(2.5F, 2.5F, 1F)
-                    drawProfilePokemon(
-                        renderablePokemon = RenderablePokemon(species, aspectsToDraw),
-                        matrixStack = matrices,
-                        rotation = Quaternionf().fromEulerXYZDegrees(Vector3f(13F, 35F, 0F)),
-                        state = state,
-                        partialTicks = 0F,
-                        scale = 4.5F
-                    )
-                    matrices.popPose()
-                    context.disableScissor()
-                } else {
-                    blitk(
-                        matrixStack = matrices,
-                        texture = unknownIcon,
-                        x = startPosX + 8.5,
-                        y = startPosY + 9,
-                        width = 8,
-                        height = 10
-                    )
 
-                    if (!species.implemented) {
-                        blitk(
-                            matrixStack = matrices,
-                            texture = unimplementedIcon,
-                            x = (startPosX + 14) / SCALE,
-                            y = (startPosY + 15.5) / SCALE,
-                            width = 7,
-                            height = 7,
-                            scale = SCALE
-                        )
-                    }
-                }
-
-                // Ensure elements are not hidden behind Pokémon render
-                matrices.pushPose()
-                matrices.translate(0.0, 0.0, 100.0)
-
-                drawScaledText(
-                    context = context,
-                    text = speciesNumber,
-                    x = startPosX + 1.5,//2,
-                    y = startPosY + 2.5,//2
-                    shadow = true,
-                    scale = SCALE
+                PokemonSlotWidget.render(
+                    context,
+                    x = x + (SCROLL_SLOT_SPACING + SCROLL_SLOT_SIZE) * index,
+                    y = y + SCROLL_SLOT_SPACING + 1,
+                    getHoveredSlotIndex(mouseX, mouseY) == index,
+                    species,
+                    renderablePokemon,
+                    discoveryLevel,
                 )
-
-                if (discoveryLevel == PokedexEntryProgress.OWNED) {
-                    blitk(
-                        matrixStack = matrices,
-                        texture = caughtIcon,
-                        x = (startPosX + 18) / SCALE,
-                        y = (startPosY + 1.5) / SCALE,
-                        width = 11,
-                        height = 11,
-                        scale = SCALE
-                    )
-                }
-
-                matrices.popPose()
             }
         }
 

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/pokedex/widgets/PokemonInfoWidget.kt

@@ -10,10 +10,10 @@ package com.cobblemon.mod.common.client.gui.pokedex.widgets
 
 import com.bedrockk.molang.runtime.MoLangRuntime
 import com.cobblemon.mod.common.api.gui.blitk
-import com.cobblemon.mod.common.api.pokedex.entry.PokedexEntry
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.setup
 import com.cobblemon.mod.common.api.pokedex.PokedexEntryProgress
 import com.cobblemon.mod.common.api.pokedex.entry.PokedexCosmeticVariation
+import com.cobblemon.mod.common.api.pokedex.entry.PokedexEntry
 import com.cobblemon.mod.common.api.pokedex.entry.PokedexForm
 import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
 import com.cobblemon.mod.common.api.text.bold
@@ -25,8 +25,9 @@ import com.cobblemon.mod.common.client.CobblemonResources
 import com.cobblemon.mod.common.client.gui.ProfileTransformType
 import com.cobblemon.mod.common.client.gui.TypeIcon
 import com.cobblemon.mod.common.client.gui.drawProfilePokemon
-import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.HALF_OVERLAY_HEIGHT
+import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUI
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.HALF_OVERLAY_WIDTH
+import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.HALF_OVERLAY_HEIGHT
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.POKEMON_PORTRAIT_HEIGHT
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.POKEMON_PORTRAIT_WIDTH
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.PORTRAIT_POKE_BALL_HEIGHT
@@ -52,15 +53,13 @@ import com.cobblemon.mod.common.util.math.fromEulerXYZDegrees
 import net.minecraft.client.Minecraft
 import net.minecraft.client.gui.GuiGraphics
 import net.minecraft.client.resources.sounds.SimpleSoundInstance
-import net.minecraft.network.chat.Component
-import net.minecraft.network.chat.MutableComponent
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.sounds.SoundEvent
 import org.joml.Quaternionf
 import org.joml.Vector3f
 import java.io.FileNotFoundException
 
-class PokemonInfoWidget(val pX: Int, val pY: Int, val updateForm: (PokedexForm) -> (Unit)) : SoundlessWidget(
+class PokemonInfoWidget(val parent: PokedexGUI, val pX: Int, val pY: Int, val updateForm: (PokedexForm) -> (Unit)) : SoundlessWidget(
     pX,
     pY,
     POKEMON_PORTRAIT_WIDTH,
@@ -82,7 +81,6 @@ class PokemonInfoWidget(val pX: Int, val pY: Int, val updateForm: (PokedexForm)
         private val arrowFormLeft = cobblemonResource("textures/gui/pokedex/forms_arrow_left.png")
         private val arrowFormRight = cobblemonResource("textures/gui/pokedex/forms_arrow_right.png")
 
-        private val caughtIcon = cobblemonResource("textures/gui/pokedex/caught_icon.png")
         private val typeBar = cobblemonResource("textures/gui/pokedex/type_bar.png")
         private val typeBarDouble = cobblemonResource("textures/gui/pokedex/type_bar_double.png")
 
@@ -100,9 +98,6 @@ class PokemonInfoWidget(val pX: Int, val pY: Int, val updateForm: (PokedexForm)
 
     var currentEntry : PokedexEntry? = null
 
-    var speciesName: MutableComponent = Component.translatable("")
-    var speciesNumber: MutableComponent = "0000".text()
-
     val runtime = MoLangRuntime().setupClient().setup().also {
         it.environment.query.addFunction("get_pokedex") { CobblemonClient.clientPokedexData.struct }
     }
@@ -111,10 +106,6 @@ class PokemonInfoWidget(val pX: Int, val pY: Int, val updateForm: (PokedexForm)
     var selectedFormIndex: Int = 0
 
     var type: Array<ElementalType?> = arrayOf(null, null)
-    var seenShinyStates: Set<String> = setOf()
-    var shiny = false
-    var maleRatio = -1F
-    var gender: Gender = Gender.GENDERLESS
 
     var renderablePokemon : RenderablePokemon? = null
 
@@ -195,7 +186,10 @@ class PokemonInfoWidget(val pX: Int, val pY: Int, val updateForm: (PokedexForm)
         20,
         resource = buttonGenderMale,
         clickAction = {
-            if (maleRatio > 0 && maleRatio < 1) gender = if (gender == Gender.MALE) Gender.FEMALE else Gender.MALE
+            val maleRatio = parent.maleRatio
+            if (maleRatio > 0 && maleRatio < 1) {
+                parent.gender = if (parent.gender == Gender.MALE) Gender.FEMALE else Gender.MALE
+            }
             updateAspects()
         }
     ).apply { addWidget(this) }
@@ -207,8 +201,8 @@ class PokemonInfoWidget(val pX: Int, val pY: Int, val updateForm: (PokedexForm)
         20,
         buttonNone,
         clickAction = {
-            if (seenShinyStates.size > 1) {
-                shiny = !shiny
+            if (parent.seenShinyStates.size > 1) {
+                parent.shiny = !parent.shiny
                 updateAspects()
             }
         }
@@ -263,8 +257,7 @@ class PokemonInfoWidget(val pX: Int, val pY: Int, val updateForm: (PokedexForm)
     override fun renderWidget(context: GuiGraphics, mouseX: Int, mouseY: Int, delta: Float) {
         val currentEntry = this.currentEntry ?: return
 
-        val hasKnowledge =
-            CobblemonClient.clientPokedexData.getKnowledgeForSpecies(currentEntry.speciesId) != PokedexEntryProgress.UNREGISTERED
+        val hasKnowledge = CobblemonClient.clientPokedexData.getKnowledgeForSpecies(currentEntry.speciesId) != PokedexEntryProgress.UNREGISTERED
         val species = currentEntry.speciesId.let { PokemonSpecies.getByIdentifier(it) } ?: return
 
         val matrices = context.pose()
@@ -277,37 +270,6 @@ class PokemonInfoWidget(val pX: Int, val pY: Int, val updateForm: (PokedexForm)
             height = HALF_OVERLAY_HEIGHT
         )
 
-        drawScaledText(
-            context = context,
-            font = CobblemonResources.DEFAULT_LARGE,
-            text = speciesNumber.bold(),
-            x = pX + 3,
-            y = pY + 1,
-            shadow = true
-        )
-
-        drawScaledText(
-            context = context,
-            font = CobblemonResources.DEFAULT_LARGE,
-            text = (if (hasKnowledge) speciesName else lang("ui.generic.question_marks")).bold(),
-            x = pX + 26,
-            y = pY + 1,
-            colour = 0x606B6E
-        )
-
-        // Caught icon
-        if (isSelectedPokemonOwned()) {
-            blitk(
-                matrixStack = matrices,
-                texture = caughtIcon,
-                x = (pX + 129) / SCALE,
-                y = (pY + 2) / SCALE,
-                width = 14,
-                height = 14,
-                scale = SCALE
-            )
-        }
-
         if (!suppressViewport) {
             blitk(
                 matrixStack = matrices,
@@ -571,8 +533,6 @@ class PokemonInfoWidget(val pX: Int, val pY: Int, val updateForm: (PokedexForm)
 
         if (species != null) {
             this.visibleForms = CobblemonClient.clientPokedexData.getEncounteredForms(pokedexEntry).toMutableList()
-            this.speciesNumber = species.nationalPokedexNumber.toString().padStart(4, '0').text()
-            this.speciesName = species.translatedName
 
             if (forms.isNotEmpty()) {
                 formLeftButton.active = true
@@ -598,23 +558,23 @@ class PokemonInfoWidget(val pX: Int, val pY: Int, val updateForm: (PokedexForm)
         variationButtons.forEach { removeWidget(it.getWidget()) }
         variationButtons.clear()
 
-        seenShinyStates = CobblemonClient.clientPokedexData.getSeenShinyStates(pokedexEntry, pokedexForm)
-        shiny = seenShinyStates.count() == 1 && seenShinyStates.first() == "shiny"
-        shinyButton.resource = if (shiny) buttonShiny else buttonNone
-        shinyButton.visible = shiny || seenShinyStates.size > 1
-        shinyButton.active = seenShinyStates.size > 1
+        parent.seenShinyStates = CobblemonClient.clientPokedexData.getSeenShinyStates(pokedexEntry, pokedexForm)
+        parent.shiny = parent.seenShinyStates.count() == 1 && parent.seenShinyStates.first() == "shiny"
+        shinyButton.resource = if (parent.shiny) buttonShiny else buttonNone
+        shinyButton.visible = parent.shiny || parent.seenShinyStates.size > 1
+        shinyButton.active = parent.seenShinyStates.size > 1
 
         val form = species.forms.find { it.name.equals(pokedexForm.displayForm, ignoreCase = true) } ?: species.standardForm
-        maleRatio = form.maleRatio
+        parent.maleRatio = form.maleRatio
 
         val seenGenders = CobblemonClient.clientPokedexData.getSeenGenders(pokedexEntry, pokedexForm)
         val visibleGenders = seenGenders.filter { it != Gender.GENDERLESS }
         if (visibleGenders.isEmpty()) {
-            gender = Gender.GENDERLESS
+            parent.gender = Gender.GENDERLESS
             genderButton.visible = false
             genderButton.active = false
         } else {
-            gender = visibleGenders.first()
+            parent.gender = visibleGenders.first()
             genderButton.visible = true
             genderButton.active = visibleGenders.size > 1
         }
@@ -693,8 +653,8 @@ class PokemonInfoWidget(val pX: Int, val pY: Int, val updateForm: (PokedexForm)
             return
         }
 
-        genderButton.resource = if (gender == Gender.FEMALE) buttonGenderFemale else buttonGenderMale
-        shinyButton.resource = if (shiny) buttonShiny else buttonNone
+        genderButton.resource = if (parent.gender == Gender.FEMALE) buttonGenderFemale else buttonGenderMale
+        shinyButton.resource = if (parent.shiny) buttonShiny else buttonNone
 
         val species = currentEntry?.speciesId?.let { PokemonSpecies.getByIdentifier(it) }
         if (species != null) {
@@ -703,12 +663,14 @@ class PokemonInfoWidget(val pX: Int, val pY: Int, val updateForm: (PokedexForm)
 
             updateType(species, form)
 
-            val aspects = mutableSetOf<String>()
-            if (shiny) aspects.add(SHINY_ASPECT.aspect)
+            val aspects = parent.aspects
+            aspects.clear()
 
-            if (gender == Gender.FEMALE) {
+            if (parent.shiny) aspects.add(SHINY_ASPECT.aspect)
+
+            if (parent.gender == Gender.FEMALE) {
                 aspects.add("female")
-            } else if (gender == Gender.MALE) {
+            } else if (parent.gender == Gender.MALE) {
                 aspects.add("male")
             }
 

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/pokedex/widgets/PokemonNameWidget.kt

@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.client.gui.pokedex.widgets
+
+import com.cobblemon.mod.common.api.gui.blitk
+import com.cobblemon.mod.common.api.pokedex.PokedexEntryProgress
+import com.cobblemon.mod.common.api.pokedex.entry.PokedexEntry
+import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
+import com.cobblemon.mod.common.api.text.bold
+import com.cobblemon.mod.common.api.text.text
+import com.cobblemon.mod.common.client.CobblemonClient
+import com.cobblemon.mod.common.client.CobblemonResources
+import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUI
+import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.POKEMON_PORTRAIT_HEIGHT
+import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.POKEMON_PORTRAIT_WIDTH
+import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.SCALE
+import com.cobblemon.mod.common.client.gui.summary.widgets.SoundlessWidget
+import com.cobblemon.mod.common.client.render.drawScaledText
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.cobblemon.mod.common.util.lang
+import net.minecraft.client.gui.GuiGraphics
+import net.minecraft.network.chat.Component
+import net.minecraft.network.chat.MutableComponent
+
+class PokemonNameWidget(
+    val parent: PokedexGUI,
+    val pX: Int,
+    val pY: Int,
+) : SoundlessWidget(
+    pX,
+    pY,
+    POKEMON_PORTRAIT_WIDTH,
+    POKEMON_PORTRAIT_HEIGHT,
+    lang("ui.pokedex.pokemon_name"),
+) {
+
+    companion object {
+        private val caughtIcon = cobblemonResource("textures/gui/pokedex/caught_icon.png")
+    }
+
+    var hasKnowledge: Boolean = false
+    var isOwned: Boolean = false
+    var speciesName: MutableComponent = Component.translatable("")
+    var speciesNumber: MutableComponent = "0000".text()
+
+    override fun renderWidget(
+        context: GuiGraphics,
+        mouseX: Int,
+        mouseY: Int,
+        partialTick: Float
+    ) {
+        drawScaledText(
+            context = context,
+            font = CobblemonResources.DEFAULT_LARGE,
+            text = speciesNumber.bold(),
+            x = pX + 3,
+            y = pY + 1,
+            shadow = true
+        )
+
+        if (hasKnowledge) {
+            drawScaledText(
+                context = context,
+                font = CobblemonResources.DEFAULT_LARGE,
+                text = speciesName.bold(),
+                x = pX + 26,
+                y = pY + 1,
+                colour = 0x606B6E
+            )
+        }
+
+        if (isOwned) {
+            blitk(
+                matrixStack = context.pose(),
+                texture = caughtIcon,
+                x = (pX + 129) / SCALE,
+                y = (pY + 2) / SCALE,
+                width = 14,
+                height = 14,
+                scale = SCALE
+            )
+        }
+    }
+
+    fun update(pokedexEntry: PokedexEntry) {
+        val species = PokemonSpecies.getByIdentifier(pokedexEntry.speciesId) ?: return
+
+        val progress = CobblemonClient.clientPokedexData.getKnowledgeForSpecies(pokedexEntry.speciesId)
+        this.hasKnowledge =  progress != PokedexEntryProgress.UNREGISTERED
+        this.isOwned = progress == PokedexEntryProgress.OWNED
+        this.speciesNumber = species.nationalPokedexNumber.toString().padStart(4, '0').text()
+        this.speciesName = species.translatedName
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/pokedex/widgets/PokemonSlotWidget.kt

@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of 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.gui.pokedex.widgets
+
+import com.cobblemon.mod.common.api.gui.blitk
+import com.cobblemon.mod.common.api.pokedex.PokedexEntryProgress
+import com.cobblemon.mod.common.api.text.text
+import com.cobblemon.mod.common.client.gui.drawProfilePokemon
+import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.SCALE
+import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.SCROLL_SLOT_SIZE
+import com.cobblemon.mod.common.client.render.drawScaledText
+import com.cobblemon.mod.common.client.render.models.blockbench.FloatingState
+import com.cobblemon.mod.common.pokemon.RenderablePokemon
+import com.cobblemon.mod.common.pokemon.Species
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.cobblemon.mod.common.util.math.fromEulerXYZDegrees
+import net.minecraft.client.gui.GuiGraphics
+import org.joml.Quaternionf
+import org.joml.Vector3f
+
+abstract class PokemonSlotWidget {
+    companion object {
+        private val slotResource = cobblemonResource("textures/gui/pokedex/pokedex_slot.png")
+        private val slotHighlight = cobblemonResource("textures/gui/pokedex/slot_select.png")
+        private val caughtIcon = cobblemonResource("textures/gui/pokedex/caught_icon_small.png")
+        private val unknownIcon = cobblemonResource("textures/gui/pokedex/pokedex_slot_unknown.png")
+        private val unimplementedIcon = cobblemonResource("textures/gui/pokedex/pokedex_slot_unimplemented.png")
+
+        fun render(
+            context: GuiGraphics,
+            x: Int,
+            y: Int,
+            isHovered: Boolean,
+            species: Species,
+            renderablePokemon: RenderablePokemon?,
+            discoveryLevel: PokedexEntryProgress,
+        ) {
+            val shouldDrawMon = renderablePokemon != null
+
+            // FIXME: This may not work properly when accounting for custom pokemon with the same dex number
+            val pokemonNumber = species.nationalPokedexNumber.toString().padStart(4, '0')
+            val speciesNumber = pokemonNumber.text()
+
+            val matrices = context.pose()
+
+            blitk(
+                matrixStack = matrices,
+                texture = slotResource,
+                x = x,
+                y = y,
+                width = SCROLL_SLOT_SIZE,
+                height = SCROLL_SLOT_SIZE,
+            )
+
+            if (isHovered) {
+                blitk(
+                    matrixStack = matrices,
+                    texture = slotHighlight,
+                    x = x,
+                    y = y,
+                    width = SCROLL_SLOT_SIZE,
+                    height = SCROLL_SLOT_SIZE,
+                    vOffset = SCROLL_SLOT_SIZE,
+                    textureHeight = SCROLL_SLOT_SIZE * 2,
+                )
+            }
+
+            if (shouldDrawMon && discoveryLevel != PokedexEntryProgress.UNREGISTERED) {
+                context.enableScissor(
+                    x + 1,
+                    y + 1,
+                    x + SCROLL_SLOT_SIZE - 1,
+                    y + SCROLL_SLOT_SIZE - 2,
+                )
+
+                matrices.pushPose()
+                matrices.translate(x + SCROLL_SLOT_SIZE / 2.0, y + 1.0, 0.0)
+                matrices.scale(2.5F, 2.5F, 1F)
+
+                val state = FloatingState()
+                state.currentAspects = renderablePokemon.aspects
+
+                drawProfilePokemon(
+                    renderablePokemon = renderablePokemon,
+                    matrixStack = matrices,
+                    rotation = Quaternionf().fromEulerXYZDegrees(Vector3f(13F, 35F, 0F)),
+                    state = state,
+                    partialTicks = 0F,
+                    scale = 4.5F
+                )
+
+                matrices.popPose()
+                context.disableScissor()
+            } else {
+                blitk(
+                    matrixStack = matrices,
+                    texture = unknownIcon,
+                    x = x + 8.5,
+                    y = y + 9,
+                    width = 8,
+                    height = 10
+                )
+
+                if (!species.implemented) {
+                    blitk(
+                        matrixStack = matrices,
+                        texture = unimplementedIcon,
+                        x = (x + 14) / SCALE,
+                        y = (y + 15.5) / SCALE,
+                        width = 7,
+                        height = 7,
+                        scale = SCALE
+                    )
+                }
+            }
+
+            // Ensure elements are not hidden behind Pokémon render
+            matrices.pushPose()
+            matrices.translate(0.0, 0.0, 100.0)
+
+            drawScaledText(
+                context = context,
+                text = speciesNumber,
+                x = x + 1.5,
+                y = y + 2.5,
+                shadow = true,
+                scale = SCALE
+            )
+
+            if (discoveryLevel == PokedexEntryProgress.OWNED) {
+                blitk(
+                    matrixStack = matrices,
+                    texture = caughtIcon,
+                    x = (x + 18) / SCALE,
+                    y = (y + 1.5) / SCALE,
+                    width = 11,
+                    height = 11,
+                    scale = SCALE
+                )
+            }
+
+            matrices.popPose()
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/pokedex/widgets/evolutiontree/EvolutionPokemonPropertiesRenderer.kt

@@ -0,0 +1,143 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of 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.gui.pokedex.widgets.evolutiontree
+
+import com.cobblemon.mod.common.api.pokemon.Natures
+import com.cobblemon.mod.common.api.pokemon.PokemonProperties
+import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
+import com.cobblemon.mod.common.api.pokemon.feature.IntSpeciesFeature
+import com.cobblemon.mod.common.api.pokemon.feature.IntSpeciesFeatureProvider
+import com.cobblemon.mod.common.api.pokemon.feature.SpeciesFeatures
+import com.cobblemon.mod.common.api.pokemon.feature.StringSpeciesFeature
+import com.cobblemon.mod.common.api.properties.CustomPokemonProperty
+import com.cobblemon.mod.common.api.text.add
+import com.cobblemon.mod.common.api.text.green
+import com.cobblemon.mod.common.api.types.ElementalTypes
+import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
+import com.cobblemon.mod.common.util.asTranslated
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.cobblemon.mod.common.util.lang
+import net.minecraft.core.registries.BuiltInRegistries
+import net.minecraft.locale.Language
+import net.minecraft.network.chat.Component
+import net.minecraft.network.chat.MutableComponent
+import net.minecraft.world.item.Items
+
+internal fun describePokemonProperties(properties: PokemonProperties): MutableComponent? {
+    if (hasUndescribedProperty(properties)) {
+        return null
+    }
+
+    val descriptors = mutableListOf<MutableComponent>()
+
+    properties.species?.let { PokemonSpecies.getByIdentifier(cobblemonResource(it)) }?.let {
+        descriptors.add(it.translatedName.plainCopy().green())
+    }
+    properties.gender?.let {
+        descriptors.add(lang("gender.${it.name.lowercase()}").green())
+    }
+    properties.nickname?.let {
+        descriptors.add(lang("ui.pokedex.requirement.properties.nickname", it.plainCopy().green()))
+    }
+    properties.type?.let {
+        val typeName = ElementalTypes.get(it)?.displayName?.plainCopy() ?: Component.literal(it)
+        descriptors.add(lang("ui.pokedex.requirement.properties.type", typeName.green()))
+    }
+    properties.nature?.let {
+        val natureName = Natures.getNature(it.asIdentifierDefaultingNamespace())?.displayName?.asTranslated() ?: Component.literal(it)
+        descriptors.add(lang("ui.pokedex.requirement.properties.nature", natureName.green()))
+    }
+    properties.customProperties.forEach { customProperty ->
+        describeCustomProperty(customProperty)?.let { descriptors.add(it) }
+    }
+
+    val heldItemDescriptor = properties.heldItem?.let { heldItem ->
+        val itemId = heldItem.substringBefore('[').trim().asIdentifierDefaultingNamespace()
+        val item = BuiltInRegistries.ITEM.get(itemId)
+        if (item == Items.AIR) null else lang("ui.pokedex.requirement.properties.held_item", item.description.plainCopy().green())
+    }
+
+    if (descriptors.isEmpty() && heldItemDescriptor == null) {
+        return null
+    }
+
+    val mainDescriptor = when {
+        descriptors.isEmpty() -> null
+        descriptors.size == 1 -> descriptors[0]
+        else -> {
+            val allButLast = descriptors.dropLast(1).reduce { acc, next -> acc.add(", ").add(next) }
+            lang("ui.pokedex.requirement.properties.and", allButLast, descriptors.last())
+        }
+    }
+
+    return when {
+        mainDescriptor != null && heldItemDescriptor != null -> mainDescriptor.add(" ").add(heldItemDescriptor)
+        mainDescriptor != null -> mainDescriptor
+        else -> heldItemDescriptor
+    }
+}
+
+private fun hasUndescribedProperty(properties: PokemonProperties): Boolean {
+    return properties.form != null ||
+            properties.shiny != null ||
+            properties.level != null ||
+            properties.friendship != null ||
+            properties.fullness != null ||
+            properties.pokeball != null ||
+            properties.ability != null ||
+            properties.status != null ||
+            properties.teraType != null ||
+            properties.dmaxLevel != null ||
+            properties.gmaxFactor != null ||
+            properties.tradeable != null ||
+            properties.originalTrainerType != null ||
+            properties.originalTrainer != null ||
+            properties.moves != null ||
+            properties.movesetBuilders != null ||
+            properties.cosmeticItem != null ||
+            properties.scaleModifier != null ||
+            properties.isAlpha != null ||
+            properties.minPerfectIVs != null ||
+            properties.customProperties.any { describeCustomProperty(it) == null }
+}
+
+private fun describeCustomProperty(property: CustomPokemonProperty): MutableComponent? {
+    return when (property) {
+        is IntSpeciesFeature -> describeIntSpeciesFeature(property)
+        is StringSpeciesFeature -> describeStringSpeciesFeature(property)
+        else -> null
+    }
+}
+
+private fun describeIntSpeciesFeature(property: IntSpeciesFeature): MutableComponent? {
+    val value = Component.literal(property.value.toString())
+
+    val overrideKey = "ui.pokedex.requirement.properties.custom.${property.name}"
+    if (Language.getInstance().has("cobblemon.$overrideKey")) {
+        return lang(overrideKey, value.green())
+    }
+
+    val displayName = (SpeciesFeatures.getFeature(property.name) as? IntSpeciesFeatureProvider)
+        ?.display?.name?.takeIf { it.isNotBlank() }
+        ?: return null
+
+    return lang("ui.pokedex.requirement.properties.int_feature", value.green(), displayName.asTranslated().green())
+}
+
+private fun describeStringSpeciesFeature(property: StringSpeciesFeature): MutableComponent? {
+    val key = "ui.pokedex.requirement.properties.custom.${property.name}"
+    if (!Language.getInstance().has("cobblemon.$key")) {
+        return null
+    }
+
+    val value = PokemonSpecies.getByIdentifier(cobblemonResource(property.value))?.translatedName?.plainCopy()
+        ?: Component.literal(property.value)
+
+    return lang(key, value.green())
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/pokedex/widgets/evolutiontree/EvolutionRendererDebug.kt

@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.client.gui.pokedex.widgets.evolutiontree
+
+import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
+import net.minecraft.client.Minecraft
+import net.minecraft.network.chat.Component
+
+fun debugEvolutionRequirementRendering() {
+    if (!Cobblemon.config.enableDebugKeys) {
+        return
+    }
+
+    val gaps = mutableListOf<Pair<String, String>>()
+
+    for (species in PokemonSpecies.implemented) {
+        val evolutions = species.evolutions + species.forms.flatMap { it.evolutions }
+        for (evolution in evolutions) {
+            if (renderEvolutionData(evolution) == null) {
+                gaps.add("Evolution: ${evolution::class.simpleName}" to species.showdownId())
+            }
+            for (requirement in evolution.requirements) {
+                if (resolveRequirementData(requirement) == null) {
+                    gaps.add("Requirement: ${requirement::class.simpleName}" to species.showdownId())
+                }
+            }
+        }
+    }
+
+    val player = Minecraft.getInstance().player
+    if (gaps.isEmpty()) {
+        player?.sendSystemMessage(Component.literal("Evolution render debug: no gaps found."))
+        return
+    }
+
+    val byType = gaps.groupBy({ it.first }, { it.second })
+    println("Evolution render debug found ${gaps.size} gap(s) across ${byType.size} type(s):")
+    byType.forEach { (type, species) -> println("  $type: ${species.distinct().joinToString(", ")}") }
+
+    player?.sendSystemMessage(Component.literal("Evolution render debug: ${gaps.size} gap(s) across ${byType.size} type(s), see log for details."))
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/pokedex/widgets/evolutiontree/EvolutionTreeEvolutionRenderer.kt

@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of 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.gui.pokedex.widgets.evolutiontree
+
+import com.cobblemon.mod.common.CobblemonItems
+import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
+import com.cobblemon.mod.common.api.pokemon.evolution.Evolution
+import com.cobblemon.mod.common.api.pokemon.requirement.Requirement
+import com.cobblemon.mod.common.api.text.green
+import com.cobblemon.mod.common.pokemon.evolution.variants.BlockClickEvolution
+import com.cobblemon.mod.common.pokemon.evolution.variants.DummyEvolution
+import com.cobblemon.mod.common.pokemon.evolution.variants.ItemInteractionEvolution
+import com.cobblemon.mod.common.pokemon.evolution.variants.LevelUpEvolution
+import com.cobblemon.mod.common.pokemon.evolution.variants.TradeEvolution
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.cobblemon.mod.common.util.itemRegistry
+import com.cobblemon.mod.common.util.lang
+import net.minecraft.client.Minecraft
+import net.minecraft.network.chat.Component
+import net.minecraft.network.chat.MutableComponent
+import net.minecraft.world.item.Item
+
+data class RenderEvolutionData(
+    val icons: List<Item>,
+    val tooltips: List<MutableComponent>,
+)
+
+internal fun resolveRequirementData(requirement: Requirement): RenderRequirementData? {
+    val icon = requirement.pokedexIcon?.let {
+        Minecraft.getInstance()?.player?.level()?.itemRegistry?.get(it)
+    }
+
+    val tooltip = requirement.pokedexTooltip?.let {
+        Component.translatable(it)
+    }
+
+    if (icon != null && tooltip != null) {
+        return RenderRequirementData(icon, tooltip)
+    }
+
+    return renderRequirementData(requirement)
+}
+
+fun renderEvolutionData(evolution: Evolution): RenderEvolutionData? {
+    when (evolution) {
+        is BlockClickEvolution -> return renderBlockClickEvolution(evolution)
+        is DummyEvolution -> return renderDummyEvolution(evolution)
+        is ItemInteractionEvolution -> return renderItemInteractionEvolution(evolution)
+        is LevelUpEvolution -> return renderLevelUpEvolution(evolution)
+        is TradeEvolution -> return renderTradeEvolution(evolution)
+    }
+
+    return null
+}
+
+fun renderBlockClickEvolution(blockClickEvolution: BlockClickEvolution): RenderEvolutionData? {
+    return null
+}
+
+// TODO: Use dummyEvolution?
+fun renderDummyEvolution(evolution: Evolution): RenderEvolutionData? {
+    return null
+}
+
+fun renderItemInteractionEvolution(itemInteractionEvolution: ItemInteractionEvolution): RenderEvolutionData? {
+    val item = itemInteractionEvolution.requiredContext.items.get().first().value()
+    val icons = mutableListOf(item)
+    val tooltips =
+        mutableListOf(lang("ui.pokedex.evolution.item_interact.tooltip", item.description.plainCopy().green()))
+
+    val requirementsDataList = itemInteractionEvolution.requirements.mapNotNull { requirement ->
+        resolveRequirementData(requirement)
+    }
+
+    requirementsDataList.forEach { requirement ->
+        icons.add(requirement.icon)
+        tooltips.add(requirement.tooltip)
+    }
+
+    return RenderEvolutionData(icons, tooltips)
+}
+
+fun renderLevelUpEvolution(levelUpEvolution: LevelUpEvolution): RenderEvolutionData? {
+    val requirementsDataList = levelUpEvolution.requirements.map { requirement ->
+        resolveRequirementData(requirement)
+    }
+
+    val icons = requirementsDataList.mapNotNull { requirementData -> requirementData?.icon }
+    val tooltips = requirementsDataList.mapNotNull { requirementData -> requirementData?.tooltip }
+
+    return RenderEvolutionData(icons, tooltips)
+}
+
+fun renderTradeEvolution(tradeEvolution: TradeEvolution): RenderEvolutionData? {
+    val icons = mutableListOf<Item>(CobblemonItems.LINK_CABLE)
+    val tooltips = mutableListOf<MutableComponent>()
+
+    val species = tradeEvolution.requiredContext.species
+    if (species == null) {
+        tooltips.add(lang("ui.pokedex.evolution.trade.tooltip.with_any_species"))
+    } else {
+        PokemonSpecies.getByIdentifier(cobblemonResource(species))?.let {
+            tooltips.add(lang("ui.pokedex.evolution.trade.tooltip.with_species", it.translatedName.green()))
+        }
+    }
+
+    val requirementsDataList = tradeEvolution.requirements.mapNotNull { requirement ->
+        resolveRequirementData(requirement)
+    }
+
+    requirementsDataList.forEach { requirement ->
+        icons.add(requirement.icon)
+        tooltips.add(requirement.tooltip)
+    }
+
+    return RenderEvolutionData(icons, tooltips)
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/pokedex/widgets/evolutiontree/EvolutionTreeRequirementRenderer.kt

@@ -0,0 +1,379 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of 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.gui.pokedex.widgets.evolutiontree
+
+import com.cobblemon.mod.common.CobblemonItems
+import com.cobblemon.mod.common.api.conditional.RegistryLikeCondition
+import com.cobblemon.mod.common.api.conditional.RegistryLikeIdentifierCondition
+import com.cobblemon.mod.common.api.conditional.RegistryLikeTagCondition
+import com.cobblemon.mod.common.api.pokemon.feature.IntSpeciesFeatureProvider
+import com.cobblemon.mod.common.api.pokemon.feature.SpeciesFeatures
+import com.cobblemon.mod.common.api.pokemon.requirement.Requirement
+import com.cobblemon.mod.common.api.pokemon.stats.Stats
+import com.cobblemon.mod.common.api.text.add
+import com.cobblemon.mod.common.api.text.green
+import com.cobblemon.mod.common.api.text.red
+import com.cobblemon.mod.common.api.types.ElementalTypes
+import com.cobblemon.mod.common.pokemon.requirements.*
+import com.cobblemon.mod.common.util.asTranslated
+import com.cobblemon.mod.common.util.lang
+import net.minecraft.client.Minecraft
+import net.minecraft.core.registries.BuiltInRegistries
+import net.minecraft.network.chat.Component
+import net.minecraft.network.chat.MutableComponent
+import net.minecraft.world.item.Item
+import net.minecraft.world.item.Items
+import net.minecraft.world.level.biome.Biome
+import net.minecraft.world.level.levelgen.structure.Structure
+
+data class RenderRequirementData(
+    val icon: Item,
+    val tooltip: MutableComponent,
+)
+
+fun renderRequirementData(requirement: Requirement): RenderRequirementData? {
+    when (requirement) {
+        is AdvancementRequirement -> return renderAdvancementRequirement(requirement)
+        is AnyRequirement -> return renderAnyRequirement(requirement)
+        is AreaRequirement -> return renderAreaRequirement(requirement)
+        is AttackDefenceRatioRequirement -> return renderAttackDefenceRatioRequirement(requirement)
+        is BattleCriticalHitsRequirement -> return renderBattleCriticalHitsRequirement(requirement)
+        is BiomeRequirement -> return renderBiomeRequirement(requirement)
+        is BlocksTraveledRequirement -> return renderBlocksTraveledRequirement(requirement)
+        is DamageTakenRequirement -> return renderDamageTakenRequirement(requirement)
+        is DefeatRequirement -> return renderDefeatRequirement(requirement)
+        is FriendshipRequirement -> return renderFriendshipRequirement(requirement)
+        is HeldItemRequirement -> return renderHeldItemRequirement(requirement)
+        is LevelRequirement -> return renderLevelRequirement(requirement)
+        is MoonPhaseRequirement -> return renderMoonPhaseRequirement(requirement)
+        is MoveSetRequirement -> return renderMoveSetRequirement(requirement)
+        is MoveTypeRequirement -> return renderMoveTypeRequirement(requirement)
+        is OwnerHoldsItemRequirement -> return renderOwnerHoldsItemRequirement(requirement)
+        is PartyMemberRequirement -> return renderPartyMemberRequirement(requirement)
+        is PokemonPropertiesRequirement -> return renderPokemonPropertiesRequirement(requirement)
+        is PropertyRangeRequirement -> return renderPropertyRangeRequirement(requirement)
+        is RecoilRequirement -> return renderRecoilRequirement(requirement)
+        is StatCompareRequirement -> return renderStatCompareRequirement(requirement)
+        is StatEqualRequirement -> return renderStatEqualRequirement(requirement)
+        is StructureRequirement -> return renderStructureRequirement(requirement)
+        is TimeRangeRequirement -> return renderTimeRangeRequirement(requirement)
+        is UseMoveRequirement -> return renderUseMoveRequirement(requirement)
+        is WeatherRequirement -> return renderWeatherRequirement(requirement)
+        is WorldRequirement -> return renderWorldRequirement(requirement)
+    }
+
+    return null
+}
+
+fun renderAdvancementRequirement(advancementRequirement: AdvancementRequirement): RenderRequirementData? {
+    val icon = Items.BOOK
+    val identifier = advancementRequirement.requiredAdvancement
+    val advancementLanguageKey = "${identifier.namespace}.${identifier.path.substringAfterLast('/')}"
+    val advancementComponent = Component.translatable("advancements.$advancementLanguageKey").green()
+    val tooltip = lang("ui.pokedex.requirement.advancement.tooltip", advancementComponent)
+
+    return RenderRequirementData(icon, tooltip)
+}
+
+fun renderAnyRequirement(anyRequirement: AnyRequirement): RenderRequirementData? {
+    return null
+}
+
+fun renderAreaRequirement(areaRequirement: AreaRequirement): RenderRequirementData? {
+    return null
+}
+
+fun renderAttackDefenceRatioRequirement(attackDefenceRatioRequirement: AttackDefenceRatioRequirement): RenderRequirementData? {
+    return null
+}
+
+fun renderBattleCriticalHitsRequirement(battleCriticalHitsRequirement: BattleCriticalHitsRequirement): RenderRequirementData? {
+    val icon = CobblemonItems.MEDICINAL_LEEK
+    val criticalsComponent = Component.literal(battleCriticalHitsRequirement.amount.toString()).green()
+    val tooltip = lang("ui.pokedex.requirement.battle_critical_hits.tooltip", criticalsComponent)
+
+    return RenderRequirementData(icon, tooltip)
+}
+
+fun renderBiomeRequirement(biomeRequirement: BiomeRequirement): RenderRequirementData? {
+    val condition = biomeRequirement.biomeCondition
+    val anticondition = biomeRequirement.biomeAnticondition
+    if (condition == null && anticondition == null) {
+        return null
+    }
+
+    val icon = Items.COMPASS
+    val displayName: (RegistryLikeCondition<Biome>) -> MutableComponent = {
+        when (it) {
+            is RegistryLikeTagCondition -> Component.literal(it.tag.location().path.substringAfterLast('/').split('_').joinToString(" ") { part -> part.replaceFirstChar(Char::titlecase) })
+            is RegistryLikeIdentifierCondition -> Component.translatable("biome.${it.identifier.namespace}.${it.identifier.path}")
+            else -> Component.literal(it.toString())
+        }
+    }
+    val tooltip = if (condition != null && anticondition != null) {
+        lang("ui.pokedex.requirement.biome.both.tooltip", displayName(condition).green(), displayName(anticondition).green())
+    } else if (condition != null) {
+        lang("ui.pokedex.requirement.biome.tooltip", displayName(condition).green())
+    } else {
+        lang("ui.pokedex.requirement.biome.anticondition.tooltip", displayName(anticondition!!).green())
+    }
+
+    val playerBiome = Minecraft.getInstance()?.player?.let { it.level().getBiome(it.blockPosition()) }
+    if (playerBiome != null) {
+        val isMet = (condition == null || condition.fits(playerBiome)) && (anticondition == null || !anticondition.fits(playerBiome))
+        tooltip.add(if (isMet) Component.literal(" ✔").green() else Component.literal(" ✘").red())
+    }
+
+    return RenderRequirementData(icon, tooltip)
+}
+
+fun renderBlocksTraveledRequirement(blocksTraveledRequirement: BlocksTraveledRequirement): RenderRequirementData? {
+    val icon = Items.LEATHER_BOOTS
+    val blocksComponent = Component.literal(blocksTraveledRequirement.amount.toString()).green()
+    val tooltip = lang("ui.pokedex.requirement.blocks_traveled.tooltip", blocksComponent)
+
+    return RenderRequirementData(icon, tooltip)
+}
+
+fun renderDamageTakenRequirement(damageTakenRequirement: DamageTakenRequirement): RenderRequirementData? {
+    val icon = CobblemonItems.PUNCHING_GLOVE
+    val blocksComponent = Component.literal(damageTakenRequirement.amount.toString()).green()
+    val tooltip = lang("ui.pokedex.requirement.damage_taken.tooltip", blocksComponent)
+
+    return RenderRequirementData(icon, tooltip)
+}
+
+fun renderDefeatRequirement(defeatRequirement: DefeatRequirement): RenderRequirementData? {
+    val description = describePokemonProperties(defeatRequirement.target) ?: return null
+    val icon = CobblemonItems.PUNCHING_GLOVE
+    val defeatedAmount = defeatRequirement.amount
+
+    val descriptionComponent = Component.literal(defeatedAmount.toString()).green().add(" ").add(description)
+    val tooltip = lang("ui.pokedex.requirement.defeat.tooltip", descriptionComponent)
+
+    return RenderRequirementData(icon, tooltip)
+}
+
+fun renderFriendshipRequirement(friendshipRequirement: FriendshipRequirement): RenderRequirementData? {
+    val icon = CobblemonItems.SOOTHE_BELL
+    val friendshipAmountComponent = Component.literal(friendshipRequirement.amount.toString()).green()
+    val tooltip = lang("ui.pokedex.requirement.friendship.tooltip", friendshipAmountComponent)
+
+    return RenderRequirementData(icon, tooltip)
+}
+
+fun renderHeldItemRequirement(heldItemRequirement: HeldItemRequirement): RenderRequirementData? {
+    val item = heldItemRequirement.itemCondition.items.get().first().value()
+    val tooltip = lang("ui.pokedex.requirement.held_item.tooltip", item.description.plainCopy().green())
+
+    return RenderRequirementData(item, tooltip)
+}
+
+fun renderLevelRequirement(levelRequirement: LevelRequirement): RenderRequirementData? {
+    val minLevel = levelRequirement.minLevel
+    val maxLevel = levelRequirement.maxLevel
+
+    val icon = CobblemonItems.RARE_CANDY
+    val tooltip =
+        if (minLevel == maxLevel || maxLevel == Int.MAX_VALUE)
+            lang("ui.pokedex.requirement.level.tooltip.min", Component.literal(minLevel.toString()).green())
+        else
+            lang("ui.pokedex.requirement.level.tooltip.between", Component.literal(minLevel.toString()).green(), Component.literal(maxLevel.toString()).green())
+
+    return RenderRequirementData(icon, tooltip)
+}
+
+fun renderMoonPhaseRequirement(moonPhaseRequirement: MoonPhaseRequirement): RenderRequirementData? {
+    val icon = Items.CLOCK
+    val moonPhaseComponent = moonPhaseRequirement.moonPhase.displayName().green()
+    val tooltip = lang("ui.pokedex.requirement.moon_phase.tooltip", moonPhaseComponent)
+
+    return RenderRequirementData(icon, tooltip)
+}
+
+fun renderMoveSetRequirement(moveSetRequirement: MoveSetRequirement): RenderRequirementData? {
+    val icon = CobblemonItems.TECHNICAL_MACHINE
+    val tooltip = lang("ui.pokedex.requirement.has_move.tooltip", moveSetRequirement.move.displayName.green())
+
+    return RenderRequirementData(icon, tooltip)
+}
+
+fun renderMoveTypeRequirement(moveTypeRequirement: MoveTypeRequirement): RenderRequirementData? {
+    val type = ElementalTypes.get(moveTypeRequirement.type.name)
+    val icon = when (type) {
+        ElementalTypes.NORMAL -> CobblemonItems.NORMAL_GEM
+        ElementalTypes.FIRE -> CobblemonItems.FIRE_GEM
+        ElementalTypes.WATER -> CobblemonItems.WATER_GEM
+        ElementalTypes.GRASS -> CobblemonItems.GRASS_GEM
+        ElementalTypes.ELECTRIC -> CobblemonItems.ELECTRIC_GEM
+        ElementalTypes.ICE -> CobblemonItems.ICE_GEM
+        ElementalTypes.FIGHTING -> CobblemonItems.FIGHTING_GEM
+        ElementalTypes.POISON -> CobblemonItems.POISON_GEM
+        ElementalTypes.GROUND -> CobblemonItems.GROUND_GEM
+        ElementalTypes.FLYING -> CobblemonItems.FLYING_GEM
+        ElementalTypes.PSYCHIC -> CobblemonItems.PSYCHIC_GEM
+        ElementalTypes.BUG -> CobblemonItems.BUG_GEM
+        ElementalTypes.ROCK -> CobblemonItems.ROCK_GEM
+        ElementalTypes.GHOST -> CobblemonItems.GHOST_GEM
+        ElementalTypes.DRAGON -> CobblemonItems.DRAGON_GEM
+        ElementalTypes.DARK -> CobblemonItems.DARK_GEM
+        ElementalTypes.STEEL -> CobblemonItems.STEEL_GEM
+        ElementalTypes.FAIRY -> CobblemonItems.FAIRY_GEM
+        else -> CobblemonItems.NORMAL_GEM
+    }
+
+    val tooltip = lang("ui.pokedex.requirement.has_move_type.tooltip", moveTypeRequirement.type.displayName.green())
+
+    return RenderRequirementData(icon, tooltip)
+}
+
+fun renderOwnerHoldsItemRequirement(ownerHoldsItemRequirement: OwnerHoldsItemRequirement): RenderRequirementData? {
+    val item = ownerHoldsItemRequirement.itemCondition.items.get().first().value()
+    val tooltip = lang("ui.pokedex.requirement.owner_held_item.tooltip", item.description.plainCopy().green())
+
+    return RenderRequirementData(item, tooltip)
+}
+
+fun renderPartyMemberRequirement(partyMemberRequirement: PartyMemberRequirement): RenderRequirementData? {
+    val description = describePokemonProperties(partyMemberRequirement.target) ?: return null
+    val icon = CobblemonItems.POKE_BALL
+    val tooltip = if (partyMemberRequirement.contains) {
+        lang("ui.pokedex.requirement.party_member.tooltip", description)
+    } else {
+        lang("ui.pokedex.requirement.party_member.anticondition.tooltip", description)
+    }
+
+    return RenderRequirementData(icon, tooltip)
+}
+
+fun renderPokemonPropertiesRequirement(pokemonPropertiesRequirement: PokemonPropertiesRequirement): RenderRequirementData? {
+    val description = describePokemonProperties(pokemonPropertiesRequirement.target) ?: return null
+    val icon = Items.NAME_TAG
+    val tooltip = lang("ui.pokedex.requirement.pokemon_properties.tooltip", description)
+
+    return RenderRequirementData(icon, tooltip)
+}
+
+fun renderPropertyRangeRequirement(propertyRangeRequirement: PropertyRangeRequirement): RenderRequirementData? {
+    val provider = SpeciesFeatures.getFeature(propertyRangeRequirement.feature) as? IntSpeciesFeatureProvider ?: return null
+    val displayName = provider.display?.name?.takeIf { it.isNotBlank() }?.asTranslated()?.green() ?: return null
+    val icon = provider.itemPoints.keys.firstOrNull()?.let { BuiltInRegistries.ITEM.get(it) } ?: Items.NAME_TAG
+
+    val range = propertyRangeRequirement.range
+    val tooltip = lang(
+        "ui.pokedex.requirement.property_range.tooltip",
+        displayName,
+        Component.literal(range.first.toString()).green(),
+        Component.literal(range.last.toString()).green()
+    )
+
+    return RenderRequirementData(icon, tooltip)
+}
+
+fun renderRecoilRequirement(recoilRequirement: RecoilRequirement): RenderRequirementData? {
+    val icon = CobblemonItems.LIFE_ORB
+    val recoilComponent = Component.literal(recoilRequirement.amount.toString()).green()
+    val tooltip = lang("ui.pokedex.requirement.recoil.tooltip", recoilComponent)
+
+    return RenderRequirementData(icon, tooltip)
+}
+
+fun renderStatCompareRequirement(statCompareRequirement: StatCompareRequirement): RenderRequirementData? {
+    val highStat = Stats.getStat(statCompareRequirement.highStat)
+    val lowStat = Stats.getStat(statCompareRequirement.lowStat)
+
+    val icon = when (highStat) {
+        Stats.HP, Stats.EVASION, Stats.ACCURACY -> CobblemonItems.HEALTH_MOCHI
+        Stats.ATTACK -> CobblemonItems.MUSCLE_MOCHI
+        Stats.DEFENCE -> CobblemonItems.RESIST_MOCHI
+        Stats.SPECIAL_ATTACK -> CobblemonItems.GENIUS_MOCHI
+        Stats.SPECIAL_DEFENCE -> CobblemonItems.CLEVER_MOCHI
+        Stats.SPEED -> CobblemonItems.SWIFT_MOCHI
+    }
+
+    val highStatComponent = highStat.displayName.plainCopy().green()
+    val lowStatComponent = lowStat.displayName.plainCopy().green()
+    val tooltip = lang("ui.pokedex.requirement.stat_compare.tooltip", highStatComponent, lowStatComponent)
+
+    return RenderRequirementData(icon, tooltip)
+}
+
+fun renderStatEqualRequirement(statEqualRequirement: StatEqualRequirement): RenderRequirementData? {
+    val statOne = Stats.getStat(statEqualRequirement.statOne)
+    val statTwo = Stats.getStat(statEqualRequirement.statTwo)
+
+    val statOneComponent = statOne.displayName.plainCopy().green()
+    val statTwoComponent = statTwo.displayName.plainCopy().green()
+
+    val icon = CobblemonItems.FRESH_START_MOCHI
+    val tooltip = lang("ui.pokedex.requirement.stat_equal.tooltip", statOneComponent, statTwoComponent)
+
+    return RenderRequirementData(icon, tooltip)
+}
+
+fun renderStructureRequirement(structureRequirement: StructureRequirement): RenderRequirementData? {
+    val condition = structureRequirement.structureCondition
+    val anticondition = structureRequirement.structureAnticondition
+    if (condition == null && anticondition == null) {
+        return null
+    }
+
+    val icon = Items.STRUCTURE_BLOCK
+    val displayName: (RegistryLikeCondition<Structure>) -> MutableComponent = {
+        val path = when (it) {
+            is RegistryLikeTagCondition -> it.tag.location().path
+            is RegistryLikeIdentifierCondition -> it.identifier.path
+            else -> it.toString()
+        }
+        Component.literal(path.substringAfterLast('/').split('_').joinToString(" ") { part -> part.replaceFirstChar(Char::titlecase) })
+    }
+    val tooltip = if (condition != null && anticondition != null) {
+        lang("ui.pokedex.requirement.structure.both.tooltip", displayName(condition).green(), displayName(anticondition).green())
+    } else if (condition != null) {
+        lang("ui.pokedex.requirement.structure.tooltip", displayName(condition).green())
+    } else {
+        lang("ui.pokedex.requirement.structure.anticondition.tooltip", displayName(anticondition!!).green())
+    }
+
+    return RenderRequirementData(icon, tooltip)
+}
+
+fun renderTimeRangeRequirement(timeRangeRequirement: TimeRangeRequirement): RenderRequirementData? {
+    val icon = Items.CLOCK
+    val timeRangeComponent = timeRangeRequirement.range.displayName() ?: return null
+    val tooltip = lang("ui.pokedex.requirement.time_range.tooltip", timeRangeComponent.green())
+
+    return RenderRequirementData(icon, tooltip)
+}
+
+fun renderUseMoveRequirement(useMoveRequirement: UseMoveRequirement): RenderRequirementData? {
+    val icon = CobblemonItems.CHOICE_BAND
+    val tooltip = lang("ui.pokedex.requirement.use_move.tooltip", useMoveRequirement.move.displayName.green())
+
+    return RenderRequirementData(icon, tooltip)
+}
+
+fun renderWeatherRequirement(weatherRequirement: WeatherRequirement): RenderRequirementData? {
+    val icon: Item
+    val tooltip: MutableComponent
+
+    if (weatherRequirement.isThundering == true) {
+        icon = Items.LIGHTNING_ROD
+        tooltip = lang("ui.pokedex.requirement.weather.tooltip.thundering")
+    } else {
+        icon = Items.WATER_BUCKET
+        tooltip = lang("ui.pokedex.requirement.weather.tooltip.raining")
+    }
+
+    return RenderRequirementData(icon, tooltip)
+}
+
+fun renderWorldRequirement(worldRequirement: WorldRequirement): RenderRequirementData? {
+    return null
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/pokedex/widgets/evolutiontree/EvolutionTreeWidget.kt

@@ -0,0 +1,571 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of 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.gui.pokedex.widgets.evolutiontree
+
+import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.CobblemonItems
+import com.cobblemon.mod.common.api.gui.*
+import com.cobblemon.mod.common.api.pokedex.Dexes
+import com.cobblemon.mod.common.api.pokedex.PokedexEntryProgress
+import com.cobblemon.mod.common.api.pokedex.entry.PokedexEntry
+import com.cobblemon.mod.common.api.pokedex.entry.PokedexForm
+import com.cobblemon.mod.common.api.pokemon.PokemonProperties
+import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
+import com.cobblemon.mod.common.api.pokemon.evolution.Evolution
+import com.cobblemon.mod.common.api.text.add
+import com.cobblemon.mod.common.api.text.bold
+import com.cobblemon.mod.common.client.CobblemonClient
+import com.cobblemon.mod.common.client.CobblemonResources
+import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUI
+import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants
+import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.HALF_OVERLAY_WIDTH
+import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.POKEMON_DESCRIPTION_HEIGHT
+import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.SCROLL_SLOT_SIZE
+import com.cobblemon.mod.common.client.gui.pokedex.ScaledButton
+import com.cobblemon.mod.common.client.gui.pokedex.renderTooltip
+import com.cobblemon.mod.common.client.gui.pokedex.widgets.PokemonSlotWidget
+import com.cobblemon.mod.common.client.gui.summary.widgets.SoundlessWidget
+import com.cobblemon.mod.common.client.render.drawScaledText
+import com.cobblemon.mod.common.client.render.renderScaledGuiItemIcon
+import com.cobblemon.mod.common.pokemon.Gender
+import com.cobblemon.mod.common.pokemon.RenderablePokemon
+import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.cobblemon.mod.common.util.lang
+import net.minecraft.client.gui.GuiGraphics
+import net.minecraft.network.chat.Component
+import net.minecraft.network.chat.MutableComponent
+
+class EvolutionTreeWidget(
+    val parent: PokedexGUI,
+    val pX: Int,
+    val pY: Int,
+) : SoundlessWidget(
+    pX, pY,
+    HALF_OVERLAY_WIDTH,
+    POKEMON_DESCRIPTION_HEIGHT,
+    lang("ui.pokedex.pokemon_info")
+) {
+    companion object {
+        private val slotResource = cobblemonResource("textures/gui/pokedex/pokedex_slot.png")
+        private val expandResource = cobblemonResource("textures/gui/pokedex/expand.png")
+        private val minimizeResource = cobblemonResource("textures/gui/pokedex/minimize.png")
+
+        const val X_MARGIN = 180
+        const val Y_MARGIN_MINIMIZED = 135
+        const val Y_MARGIN_EXPANDED = 53
+        const val EXPANDED_HEIGHT = 125
+
+        const val HORIZONTAL_PADDING = 38
+        const val VERTICAL_PADDING = 2
+        const val TREE_FORK_LENGTH = 4
+
+        const val ICON_X_PADDING = -4.0
+        const val ICON_Y_PADDING = -4.0
+        const val MILLIS_BETWEEN_ICONS_CYCLE = 1000
+
+        const val ICON_SLOT_BACKGROUND_SIZE = 8
+        const val ICON_SLOT_PADDING = 4
+        const val ICON_SLOT_HALF_PADDING = ICON_SLOT_PADDING / 2
+
+        const val LINE_COLOR = 0xff1d6b85.toInt()
+
+        const val EXPAND_BUTTON_X_MARGIN = 127f
+        const val EXPAND_BUTTON_Y_MARGIN = -10.5f
+        const val EXPAND_BUTTON_SIZE = 20
+
+        private var previousRootPokedexEntry: PokedexEntry? = null
+        private var previousRootPokedexForm: PokedexForm? = null
+    }
+
+    private var rootTreeDrawingNode: TreeDrawingNode<EvolutionNode>? = null
+    private var treeDrawingBounds: TreeDrawingBounds? = null
+    private var zoomLevel: Double = 0.0
+    private var panningX: Double = 0.0
+    private var panningY: Double = 0.0
+
+    private var hoveredTooltips: List<MutableComponent>? = null
+
+    private val expandButton: ScaledButton = ScaledButton(
+        0f,
+        0f,
+        EXPAND_BUTTON_SIZE,
+        EXPAND_BUTTON_SIZE,
+        resource = expandResource,
+        clickAction = {
+            parent.evolutionTreeExpanded = !parent.evolutionTreeExpanded
+            expandButton.resource = if (parent.evolutionTreeExpanded) minimizeResource else expandResource
+            updatePositioning()
+        }
+    ).apply { addWidget(this) }
+
+    override fun renderWidget(
+        guiGraphics: GuiGraphics,
+        mouseX: Int,
+        mouseY: Int,
+        partialTick: Float,
+    ) {
+        drawScaledText(
+            context = guiGraphics,
+            font = CobblemonResources.DEFAULT_LARGE,
+            text = Component.translatable("cobblemon.ui.pokedex.info.evolution_tree").bold(),
+            x = x + 9,
+            y = y - 10,
+            shadow = true
+        )
+
+        expandButton.render(guiGraphics, mouseX, mouseY, partialTick)
+
+        rootTreeDrawingNode?.let {
+            enableScissors(guiGraphics)
+            renderTreeDrawingNode(guiGraphics, it, mouseX, mouseY, partialTick)
+            guiGraphics.disableScissor()
+
+            hoveredTooltips?.let { tooltips ->
+                renderTooltip(
+                    guiGraphics,
+                    tooltips,
+                    mouseX,
+                    mouseY,
+                    partialTick,
+                    4,
+                )
+            }
+
+            hoveredTooltips = null
+        }
+    }
+
+    fun setup(pokedexEntry: PokedexEntry?, pokedexForm: PokedexForm?) {
+        if (pokedexEntry == null || pokedexForm == null) return
+
+        updatePositioning()
+
+        val (rootPokedexEntry, rootPokedexForm) = Dexes.findRootDexEntryBySpeciesId(pokedexEntry.speciesId, pokedexForm.displayForm)
+        val rootEvolutionNode = buildEvolutionTree(rootPokedexEntry, rootPokedexForm, null)
+
+//        val isSameEntry = previousRootPokedexEntry != null && pokedexEntry?.id == previousRootPokedexEntry?.id
+//        val isSameForm =
+//            previousRootPokedexForm != null && pokedexForm?.displayForm == previousRootPokedexForm?.displayForm
+
+        // TODO: figure out how to prevent pokedex from resetting all the widgets state
+        // if (isSameEntry && isSameForm) {
+        //    return
+        // }
+
+        previousRootPokedexEntry = pokedexEntry
+        previousRootPokedexForm = pokedexForm
+
+        createDrawingTree(rootEvolutionNode).also {
+            rootTreeDrawingNode = it
+            treeDrawingBounds = calculateBounds<EvolutionNode>(it)
+        }
+
+        zoomLevel = 0.0
+        panningX = 0.0
+        panningY = 0.0
+    }
+
+    fun updatePositioning() {
+        x = pX + X_MARGIN
+        y = pY + if (parent.evolutionTreeExpanded) Y_MARGIN_EXPANDED else Y_MARGIN_MINIMIZED
+        height = if (parent.evolutionTreeExpanded) EXPANDED_HEIGHT else POKEMON_DESCRIPTION_HEIGHT
+
+        panningX = 0.0
+        panningY = 0.0
+
+        expandButton.buttonX = x + EXPAND_BUTTON_X_MARGIN
+        expandButton.buttonY = y + EXPAND_BUTTON_Y_MARGIN
+    }
+
+    private fun buildEvolutionTree(
+        pokedexEntry: PokedexEntry,
+        pokedexForm: PokedexForm,
+        evolution: Evolution? = null,
+        resultProperties: PokemonProperties? = evolution?.result,
+        renderData: RenderEvolutionData? = evolution?.let { renderEvolutionData(it) }
+    ): EvolutionNode {
+        val species = PokemonSpecies.getByIdentifier(pokedexEntry.speciesId)!!
+
+        val formEquivalents = Dexes.getFormEquivalents(pokedexForm.displayForm)
+        val form = species.forms.firstOrNull { formEquivalents.contains(it.name.lowercase()) }
+        val parentSpecies = Dexes.findDexEntryBySpeciesId(species.resourceIdentifier)!!
+        val parentPokedexForm = parentSpecies.forms.first { formEquivalents.contains(it.displayForm.lowercase()) }
+
+        val aspects = resultProperties?.aspects?.toMutableSet() ?: mutableSetOf()
+        form?.aspects?.let { aspects.addAll(it) }
+
+        val discoveryLevel = CobblemonClient.clientPokedexData.getHighestKnowledgeFor(pokedexEntry, pokedexForm, aspects)
+
+        val evolutions = form?.evolutions ?: species.evolutions
+
+        // Avoid evolution.result.create() here: it builds a full battle-ready Pokemon (initializeMovesetFromDefault
+        // etc.) which relies on server-only data like CobblemonMovesetBuilders and crashes on the client
+        val children = evolutions.flatMap { evolution ->
+            val baseRenderData = renderEvolutionData(evolution)
+
+            listOfNotNull(evolution.result, evolution.shedder).mapNotNull { resultProperties ->
+                val resultSpecies = resultProperties.species
+                    ?.let { PokemonSpecies.getByIdentifier(it.asIdentifierDefaultingNamespace()) }
+                    ?: return@mapNotNull null
+                
+                val resultForm = resultSpecies.getForm(aspects + resultProperties.aspects)
+
+                val speciesId = resultSpecies.resourceIdentifier
+                val childPokedexEntry = Dexes.findDexEntryBySpeciesId(speciesId)
+
+                if (childPokedexEntry == null) {
+                    Cobblemon.LOGGER.warn("Dex entry not found for species: $speciesId")
+                    return@mapNotNull null
+                }
+
+                val formEquivalents = Dexes.getFormEquivalents(resultForm.name.lowercase())
+                val childPokedexForm = childPokedexEntry.forms.first { formEquivalents.contains(it.displayForm.lowercase()) }
+
+                val childRenderData = if (resultProperties === evolution.shedder) {
+                    RenderEvolutionData(
+                        icons = (baseRenderData?.icons ?: emptyList()) + CobblemonItems.POKE_BALL,
+                        tooltips = (baseRenderData?.tooltips ?: emptyList()) + lang("ui.pokedex.evolution.shedder.tooltip"),
+                    )
+                } else {
+                    baseRenderData
+                }
+
+                return@mapNotNull buildEvolutionTree(childPokedexEntry, childPokedexForm, evolution, resultProperties, childRenderData)
+            }
+        }
+
+        return EvolutionNode(pokedexEntry, parentPokedexForm, aspects, discoveryLevel, children, renderData)
+    }
+
+    private fun renderTreeDrawingNode(
+        guiGraphics: GuiGraphics,
+        treeDrawingNode: TreeDrawingNode<EvolutionNode>,
+        mouseX: Int,
+        mouseY: Int,
+        delta: Float,
+    ) {
+        val (treeX, treeY) = getDrawingCoordinates(treeDrawingNode)
+
+        if (treeDrawingNode.children.size == 1) {
+            val child = treeDrawingNode.children.first()
+            val (childX, _) = getDrawingCoordinates(child)
+
+            val lineStartX = treeX + SCROLL_SLOT_SIZE
+            val lineEndX = childX
+            val lineY = treeY + SCROLL_SLOT_SIZE / 2
+
+            child.value.renderData?.let { renderData ->
+                drawEvolutionInfo(
+                    guiGraphics,
+                    renderData,
+                    lineStartX,
+                    lineEndX,
+                    lineY,
+                    mouseX,
+                    mouseY,
+                    delta,
+                )
+            }
+        } else if (treeDrawingNode.children.size > 1) {
+            val treeForkStart = treeX + SCROLL_SLOT_SIZE
+            val treeForkEnd = treeX + SCROLL_SLOT_SIZE + TREE_FORK_LENGTH
+            val middleStart = treeY + SCROLL_SLOT_SIZE / 2
+
+            val (_, firstChildY) = getDrawingCoordinates(treeDrawingNode.children.first())
+            val (_, lastChildY) = getDrawingCoordinates(treeDrawingNode.children.last())
+
+            guiGraphics.hLine(
+                treeForkStart,
+                treeForkEnd,
+                middleStart,
+                LINE_COLOR,
+            )
+
+            guiGraphics.vLine(
+                treeForkEnd,
+                firstChildY + SCROLL_SLOT_SIZE / 2,
+                lastChildY + SCROLL_SLOT_SIZE / 2,
+                LINE_COLOR,
+            )
+
+            treeDrawingNode.children.forEach { child ->
+                val (childX, childY) = getDrawingCoordinates(child)
+
+                val lineStartX = treeForkEnd
+                val lineEndX = childX
+                val lineY = childY + SCROLL_SLOT_SIZE / 2
+
+                child.value.renderData?.let { renderData ->
+                    drawEvolutionInfo(
+                        guiGraphics,
+                        renderData,
+                        lineStartX,
+                        lineEndX,
+                        lineY,
+                        mouseX,
+                        mouseY,
+                        delta,
+                    )
+                }
+            }
+        }
+
+        treeDrawingNode.children.forEach { child ->
+            renderTreeDrawingNode(guiGraphics, child, mouseX, mouseY, delta)
+        }
+
+        val isVisible =
+            treeX >= x - SCROLL_SLOT_SIZE &&
+                    treeX <= x + width &&
+                    treeY >= y - SCROLL_SLOT_SIZE &&
+                    treeY <= y + height
+
+        if (!isVisible) return
+
+        val evolutionNode = treeDrawingNode.value
+        val isSlotHovered =
+            isElementHovered(mouseX, mouseY, treeX, treeX + SCROLL_SLOT_SIZE, treeY, treeY + SCROLL_SLOT_SIZE)
+
+        val discoveryLevel = evolutionNode.pokedexEntryProgress
+        if (isSlotHovered) {
+            val text =
+                if (discoveryLevel == PokedexEntryProgress.UNREGISTERED) {
+                    lang("ui.pokedex.unknown")
+                } else {
+                    val species = PokemonSpecies.getByIdentifier(evolutionNode.pokedexEntry.speciesId)!!
+                    val speciesComponent = species.translatedName
+                    val formName = evolutionNode.pokedexForm.displayForm.lowercase()
+                    val formComponent =
+                        if (formName == "normal") null
+                        else lang("ui.pokedex.info.form.${species}-${formName.replace("-", "")}")
+
+                    formComponent?.add(" ")?.add(speciesComponent) ?: speciesComponent
+                }
+
+            guiGraphics.disableScissor()
+            renderTooltip(
+                context = guiGraphics,
+                text = text,
+                posX = mouseX,
+                posY = mouseY,
+                delta,
+                4,
+            )
+            enableScissors(guiGraphics)
+        }
+
+
+        val pokedexEntry = evolutionNode.pokedexEntry
+        val pokedexForm = evolutionNode.pokedexForm
+        val species = PokemonSpecies.getByIdentifier(evolutionNode.pokedexEntry.speciesId)!!
+        val encounteredForms = CobblemonClient.clientPokedexData.getEncounteredForms(pokedexEntry)
+        val formToRender = encounteredForms.firstOrNull { it.displayForm.equals(pokedexForm.displayForm, ignoreCase = true) }
+
+        val renderablePokemon =
+            if (formToRender != null) {
+                val seenGenders = CobblemonClient.clientPokedexData.getSeenGenders(pokedexEntry, formToRender)
+                val seenShinyStates = CobblemonClient.clientPokedexData.getSeenShinyStates(pokedexEntry, formToRender)
+
+                val aspectsToDraw = (pokedexEntry.displayAspects + evolutionNode.aspects).toMutableSet()
+
+                val formAspects = species.forms.firstOrNull { it.name.equals(formToRender.displayForm, ignoreCase = true) }?.aspects
+                if (formAspects != null) {
+                    aspectsToDraw.addAll(formAspects)
+                }
+
+                if (seenGenders.contains(parent.gender)) {
+                    aspectsToDraw.add(parent.gender.name.lowercase())
+                } else {
+                    aspectsToDraw.add((seenGenders.firstOrNull() ?: Gender.GENDERLESS).name.lowercase())
+                }
+
+                if (parent.shiny && seenShinyStates.contains("shiny")) {
+                    aspectsToDraw.add("shiny")
+                }
+
+                RenderablePokemon(species, aspectsToDraw)
+            } else {
+                null
+            }
+
+        PokemonSlotWidget.render(
+            context = guiGraphics,
+            x = treeX,
+            y = treeY,
+            isHovered = isSlotHovered,
+            species = species,
+            renderablePokemon = renderablePokemon,
+            discoveryLevel = discoveryLevel,
+        )
+    }
+
+    private fun drawEvolutionInfo(
+        guiGraphics: GuiGraphics,
+        renderData: RenderEvolutionData,
+        lineStartX: Int,
+        lineEndX: Int,
+        lineY: Int,
+        mouseX: Int,
+        mouseY: Int,
+        delta: Float,
+    ) {
+        val lineXMiddle = (lineStartX + lineEndX) / 2
+        val iconX = (lineXMiddle + ICON_X_PADDING - ICON_SLOT_HALF_PADDING).toInt()
+        val iconY = (lineY + ICON_Y_PADDING - ICON_SLOT_HALF_PADDING).toInt()
+        val iconSize = ICON_SLOT_BACKGROUND_SIZE + ICON_SLOT_PADDING
+
+        val isVisible =
+            iconX >= x - iconSize &&
+            iconX <= x + width &&
+            iconY >= y - iconSize &&
+            iconY <= y + height
+
+        if (!isVisible) {
+            return
+        }
+
+        if (renderData.icons.isEmpty()) {
+            guiGraphics.hLine(
+                lineStartX,
+                lineEndX,
+                lineY,
+                LINE_COLOR,
+            )
+        } else {
+            guiGraphics.hLine(
+                lineStartX,
+                iconX - 1,
+                lineY,
+                LINE_COLOR,
+            )
+
+            guiGraphics.hLine(
+                iconX + iconSize,
+                lineEndX,
+                lineY,
+                LINE_COLOR,
+            )
+
+            blitk(
+                matrixStack = guiGraphics.pose(),
+                texture = slotResource,
+                x = iconX,
+                y = iconY,
+                width = iconSize,
+                height = iconSize,
+            )
+
+            val index = (System.currentTimeMillis() / MILLIS_BETWEEN_ICONS_CYCLE) % renderData.icons.size
+            val item = renderData.icons[index.toInt()]
+
+            renderScaledGuiItemIcon(
+                itemStack = item.defaultInstance,
+                x = lineXMiddle + ICON_X_PADDING,
+                y = lineY + ICON_Y_PADDING,
+                matrixStack = guiGraphics.pose(),
+                scale = PokedexGUIConstants.SCALE.toDouble(),
+            )
+        }
+
+        val isLineHovered = isElementHovered(mouseX, mouseY, lineStartX, lineEndX, lineY - 1, lineY + 1)
+        val isIconHovered = isElementHovered(
+            mouseX,
+            mouseY,
+            iconX.toInt(),
+            iconX.toInt() + iconSize,
+            iconY.toInt(),
+            iconY.toInt() + iconSize,
+        )
+
+        if (renderData.tooltips.isNotEmpty() &&
+            (isLineHovered || isIconHovered) &&
+            this.isHovered(mouseX.toDouble(), mouseY.toDouble())
+        ) {
+            hoveredTooltips = renderData.tooltips
+        }
+    }
+
+    private fun getDrawingCoordinates(node: TreeDrawingNode<EvolutionNode>): Pair<Int, Int> {
+        val halfSlot = SCROLL_SLOT_SIZE / 2f
+
+        val xStep = halfSlot + HORIZONTAL_PADDING
+        val yStep = halfSlot + VERTICAL_PADDING
+
+        // Swaps the x and y to draw the tree horizontally
+        val xDislocation = (node.y - treeDrawingBounds!!.yCenter) * xStep
+        val yDislocation = (node.x - treeDrawingBounds!!.xCenter) * yStep
+
+        val xCenter = width / 2f - halfSlot
+        val yCenter = height / 2f - halfSlot
+
+        val screenX = (xCenter.toInt() + xDislocation.toInt() + panningX.toInt() + x)
+        val screenY = (yCenter.toInt() + yDislocation.toInt() + panningY.toInt() + y)
+
+        return screenX to screenY
+    }
+
+    private fun isElementHovered(
+        mouseX: Int,
+        mouseY: Int,
+        startX: Int,
+        endX: Int,
+        startY: Int,
+        endY: Int,
+    ): Boolean {
+        return mouseX >= startX && mouseX <= endX && mouseY >= startY && mouseY <= endY
+    }
+
+    override fun mouseDragged(
+        mouseX: Double,
+        mouseY: Double,
+        button: Int,
+        deltaX: Double,
+        deltaY: Double
+    ): Boolean {
+        panningX += deltaX
+        panningY += deltaY
+
+        val bounds = treeDrawingBounds ?: return super.mouseDragged(mouseX, mouseY, button, deltaX, deltaY)
+        val treeHeight = bounds.height.coerceAtLeast(1)
+        val treeWidth = bounds.width.coerceAtLeast(1)
+
+        val xStep = HORIZONTAL_PADDING + SCROLL_SLOT_SIZE / 2.0
+        val yStep = VERTICAL_PADDING + SCROLL_SLOT_SIZE / 2.0
+
+        val minPanningX = (treeHeight - 1) * -xStep / 2.0 - (width + SCROLL_SLOT_SIZE) / 2.0
+        val maxPanningX = (treeHeight - 1) * xStep / 2.0 + (width + SCROLL_SLOT_SIZE) / 2.0
+
+        val divideBy = if (treeWidth % 2 == 0) 4.0 else 2.0
+        val minPanningY = (treeWidth - 1) * -yStep / 2.0 - height / 2.0 + SCROLL_SLOT_SIZE / divideBy
+        val maxPanningY = (treeWidth - 1) * yStep / 2.0 + height / 2.0 - SCROLL_SLOT_SIZE / divideBy
+
+        panningX = panningX.coerceIn(minPanningX, maxPanningX)
+        panningY = panningY.coerceIn(minPanningY, maxPanningY)
+
+        return super.mouseDragged(mouseX, mouseY, button, deltaX, deltaY)
+    }
+
+    fun isHovered(mouseX: Double, mouseY: Double): Boolean {
+        return mouseX.toInt() in x..(x + width) && mouseY.toInt() in y..(y + height)
+    }
+
+    fun enableScissors(guiGraphics: GuiGraphics) {
+        guiGraphics.enableScissor(x + 1, y, x + width - 1, y + height)
+    }
+
+    private class EvolutionNode(
+        val pokedexEntry: PokedexEntry,
+        val pokedexForm: PokedexForm,
+        val aspects: Set<String>,
+        val pokedexEntryProgress: PokedexEntryProgress,
+        override val children: List<EvolutionNode>,
+        val renderData: RenderEvolutionData?,
+    ) : TreeNode<EvolutionNode>
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/block/DiscShelfBlockEntityRenderer.kt

@@ -8,9 +8,9 @@
 
 package com.cobblemon.mod.common.client.render.block
 
+import com.cobblemon.mod.common.CobblemonItemComponents
 import com.cobblemon.mod.common.block.entity.DiscShelfBlockEntity
 import com.cobblemon.mod.common.CobblemonItems
-import com.cobblemon.mod.common.client.render.color.TechnicalMachineItemColorProvider
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.mojang.blaze3d.vertex.PoseStack
 import com.mojang.blaze3d.vertex.VertexConsumer
@@ -37,15 +37,15 @@ class DiscShelfBlockEntityRenderer(ctx: BlockEntityRendererProvider.Context) :
     private val slotHeightPixels = 2
     private val textureSize = 16f
 
+    private val slotUMax = slotWidthPixels / textureSize
+    private val slotVMax = slotHeightPixels / textureSize
+
     private val leftMargin = 1f
     private val rightMargin = 1f
     private val topMargin = 1f
     private val interRowSpacing = 0f
-    private val tmOverlayDepthOffset = -0.0002f
     private val slotBrightnessMultiplier = 0.65f
 
-    private val tmBaseTexture = cobblemonResource("textures/block/disc_shelf/technical_machine_base.png")
-    private val tmOverlayTexture = cobblemonResource("textures/block/disc_shelf/technical_machine_overlay.png")
     private val musicDiscUnknownTexture = cobblemonResource("textures/block/disc_shelf/music_disc_unknown.png")
 
     override fun render(
@@ -98,35 +98,19 @@ class DiscShelfBlockEntityRenderer(ctx: BlockEntityRendererProvider.Context) :
                 poseStack.translate(posX, posY, -0.001f)
 
                 if (item.item == CobblemonItems.TECHNICAL_MACHINE) {
-                    val baseColor = TechnicalMachineItemColorProvider.getColor(item, 0)
-                    val overlayColor = TechnicalMachineItemColorProvider.getColor(item, 1)
-
+                    val elementId = item.components.get(CobblemonItemComponents.TM_MOVE)!!.move.elementalType.showdownId
+                    val texture = cobblemonResource("textures/block/disc_shelf/${elementId}_tm.png")
                     renderSlotQuad(
                             poseStack,
                             buffer,
-                            tmBaseTexture,
-                            baseColor,
+                            texture,
+                            0xFFFFFF,
                             packedLight,
                             slotWidth,
                             slotHeight,
                             tint = true,
                             useTextRenderType = true
                     )
-
-                    poseStack.pushPose()
-                    poseStack.translate(0.0, 0.0, tmOverlayDepthOffset.toDouble())
-                    renderSlotQuad(
-                            poseStack,
-                            buffer,
-                            tmOverlayTexture,
-                            overlayColor,
-                            packedLight,
-                            slotWidth,
-                            slotHeight,
-                            tint = true,
-                            useTextRenderType = true
-                    )
-                    poseStack.popPose()
                 } else {
                     val tex = getItemTexture(item)
                     renderSlotQuad(
@@ -176,13 +160,15 @@ class DiscShelfBlockEntityRenderer(ctx: BlockEntityRendererProvider.Context) :
         val g = (gBase * slotBrightnessMultiplier).coerceIn(0f, 1f)
         val b = (bBase * slotBrightnessMultiplier).coerceIn(0f, 1f)
 
-        consumer.addVertex(matrix, 0f, 0f, 0f).setColor(r, g, b, a).setUv(0f, 1f)
+        // The quad faces -Z, so a viewer looking at it sees +X on their left.
+        // U runs from slotUMax at x = 0 to 0 at x = width so the art is not mirrored.
+        consumer.addVertex(matrix, 0f, 0f, 0f).setColor(r, g, b, a).setUv(slotUMax, slotVMax)
                 .setUv1(0, 0).setUv2(light and 0xFFFF, light shr 16).setNormal(0f, 0f, -1f)
-        consumer.addVertex(matrix, 0f, height, 0f).setColor(r, g, b, a).setUv(0f, 0f)
+        consumer.addVertex(matrix, 0f, height, 0f).setColor(r, g, b, a).setUv(slotUMax, 0f)
                 .setUv1(0, 0).setUv2(light and 0xFFFF, light shr 16).setNormal(0f, 0f, -1f)
-        consumer.addVertex(matrix, width, height, 0f).setColor(r, g, b, a).setUv(1f, 0f)
+        consumer.addVertex(matrix, width, height, 0f).setColor(r, g, b, a).setUv(0f, 0f)
                 .setUv1(0, 0).setUv2(light and 0xFFFF, light shr 16).setNormal(0f, 0f, -1f)
-        consumer.addVertex(matrix, width, 0f, 0f).setColor(r, g, b, a).setUv(1f, 1f)
+        consumer.addVertex(matrix, width, 0f, 0f).setColor(r, g, b, a).setUv(0f, slotVMax)
                 .setUv1(0, 0).setUv2(light and 0xFFFF, light shr 16).setNormal(0f, 0f, -1f)
     }
 

common/src/main/kotlin/com/cobblemon/mod/common/client/render/color/TechnicalMachineItemColorProvider.kt

@@ -1,27 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.client.render.color
-
-import com.cobblemon.mod.common.api.types.ElementalTypes
-import com.cobblemon.mod.common.item.components.TMMoveComponent.Companion.getTMMove
-import net.minecraft.client.color.item.ItemColor
-import net.minecraft.util.FastColor
-import net.minecraft.world.item.ItemStack
-
-object TechnicalMachineItemColorProvider : ItemColor {
-    override fun getColor(itemStack: ItemStack, layer: Int): Int {
-        val moveType = getTMMove(itemStack)?.elementalType ?: ElementalTypes.NORMAL
-        val color = when (layer) {
-            0 -> moveType.primaryColor
-            1 -> moveType.secondaryColor
-            else -> 0xFFFFFF
-        }
-        return FastColor.ARGB32.opaque(color)
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/layer/PlayerRecallBallRenderer.kt

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of 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.layer
+
+import com.cobblemon.mod.common.client.render.player.RecallArmAnimationTracker
+import com.mojang.blaze3d.vertex.PoseStack
+import com.mojang.math.Axis
+import net.minecraft.client.Minecraft
+import net.minecraft.client.model.PlayerModel
+import net.minecraft.client.renderer.MultiBufferSource
+import net.minecraft.client.renderer.entity.RenderLayerParent
+import net.minecraft.client.renderer.entity.layers.RenderLayer
+import net.minecraft.world.entity.HumanoidArm
+import net.minecraft.world.entity.player.Player
+import net.minecraft.world.phys.Vec3
+import org.joml.Vector3f
+
+class PlayerRecallBallRenderer<T : Player>(
+    renderLayerParent: RenderLayerParent<T, PlayerModel<T>>
+) : RenderLayer<T, PlayerModel<T>>(renderLayerParent) {
+
+    override fun render(
+        matrixStack: PoseStack,
+        buffer: MultiBufferSource,
+        packedLight: Int,
+        player: T,
+        limbSwing: Float,
+        limbSwingAmount: Float,
+        partialTicks: Float,
+        ageInTicks: Float,
+        netHeadYaw: Float,
+        headPitch: Float
+    ) {
+        val anim = RecallArmAnimationTracker.get(player.uuid) ?: return
+        val mc = Minecraft.getInstance()
+        if (player === mc.player && mc.options.cameraType.isFirstPerson) return
+
+        matrixStack.pushPose()
+        getParentModel().translateToHand(HumanoidArm.RIGHT, matrixStack)
+        matrixStack.mulPose(Axis.XP.rotationDegrees(-90F))
+        matrixStack.mulPose(Axis.YP.rotationDegrees(180F))
+        matrixStack.translate(0.0625, 0.125, -0.625)
+        matrixStack.scale(0.54F, -0.54F, -0.54F)
+        matrixStack.translate(0.0, 0.5, 0.0)
+        matrixStack.mulPose(Axis.YP.rotationDegrees(180F))
+
+        RecallArmAnimationTracker.renderBall(anim, matrixStack, buffer, packedLight, partialTicks)
+
+        anim.ballState.locatorStates["beam"]?.let { beam ->
+            matrixStack.pushPose()
+            matrixStack.mulPose(beam.matrix)
+            val offset = matrixStack.last().pose().transformPosition(Vector3f(0F, 0.18F, -0.3F))
+            matrixStack.popPose()
+            anim.beamOrigin = mc.gameRenderer.mainCamera.position.add(Vec3(offset))
+        }
+        matrixStack.popPose()
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/layer/PokemonOnShoulderRenderer.kt

@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.client.render.layer
 
 import com.bedrockk.molang.runtime.value.DoubleValue
+import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
 import com.cobblemon.mod.common.api.tags.CobblemonItemTags
 import com.cobblemon.mod.common.client.render.item.HeldItemRenderer
@@ -23,7 +24,6 @@ import com.cobblemon.mod.common.pokemon.Species
 import com.cobblemon.mod.common.util.DataKeys
 import com.cobblemon.mod.common.util.isPokemonEntity
 import com.mojang.blaze3d.vertex.PoseStack
-import com.mojang.math.Axis
 import java.util.UUID
 import net.minecraft.client.Minecraft
 import net.minecraft.client.model.PlayerModel
@@ -33,11 +33,14 @@ import net.minecraft.client.renderer.entity.LivingEntityRenderer
 import net.minecraft.client.renderer.entity.RenderLayerParent
 import net.minecraft.client.renderer.entity.layers.RenderLayer
 import net.minecraft.client.renderer.texture.OverlayTexture
+import net.minecraft.core.registries.BuiltInRegistries
 import net.minecraft.nbt.CompoundTag
 import net.minecraft.nbt.NbtOps
 import net.minecraft.nbt.Tag
 import net.minecraft.resources.ResourceLocation
+import net.minecraft.world.entity.EquipmentSlot
 import net.minecraft.world.entity.player.Player
+import net.minecraft.world.item.ArmorItem
 import net.minecraft.world.item.ItemStack
 
 class PokemonOnShoulderRenderer<T : Player>(renderLayerParent: RenderLayerParent<T, PlayerModel<T>>) :
@@ -165,16 +168,16 @@ class PokemonOnShoulderRenderer<T : Player>(renderLayerParent: RenderLayerParent
             val width = shoulderData.form.hitbox.width
             val heightOffset = -1.5 * scale
             val widthOffset = width / 2 - 0.7
-            // If they're sneaking, the pokemon needs to rotate a little bit and push forward
-            // Shoulders move a bit when sneaking which is why the translation is necessary.
-            // Shoulder exact rotation according to testing (miasmus) is 0.4 radians, the -0.15 is eyeballed though.
-            if (livingEntity.isCrouching) {
-                matrixStack.mulPose(Axis.XP.rotation(0.4F))
-                matrixStack.translate(0F, 0F, -0.15F)
+            val chestItem = livingEntity.getItemBySlot(EquipmentSlot.CHEST)
+            val armorHeightOffset = if (chestItem.item is ArmorItem && !isArmorOffsetBlacklisted(chestItem)) {
+                ARMOR_HEIGHT_OFFSET
+            } else {
+                0F
             }
+            parentModel.body.translateAndRotate(matrixStack)
             matrixStack.translate(
                 if (pLeftShoulder) -widthOffset else widthOffset,
-                (if (livingEntity.isCrouching) heightOffset + 0.2 else heightOffset),
+                heightOffset - armorHeightOffset,
                 0.0
             )
 
@@ -263,8 +266,14 @@ class PokemonOnShoulderRenderer<T : Player>(renderLayerParent: RenderLayerParent
 
     companion object {
 
+        private const val ARMOR_HEIGHT_OFFSET = 1F / 16F
         private val playerCache = hashMapOf<UUID, ShoulderCache>()
 
+        private fun isArmorOffsetBlacklisted(itemStack: ItemStack): Boolean {
+            val itemIdentifier = BuiltInRegistries.ITEM.getKey(itemStack.item)
+            return itemIdentifier in Cobblemon.config.shoulderMountArmorOffsetBlacklist
+        }
+
         private fun extractUuid(shoulderNbt: CompoundTag): UUID {
             if (!shoulderNbt.contains(DataKeys.SHOULDER_UUID)) {
                 return shoulderNbt.getCompound(DataKeys.POKEMON).getUUID(DataKeys.POKEMON_UUID)

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/PosableState.kt

@@ -545,11 +545,12 @@ abstract class PosableState : Schedulable {
         primaryAnimation?.animation?.applyEffects(entity, this, previousSeconds, newSeconds)
         currentModel?.let { model ->
             val pose = currentPose?.let { model.poses[it] }
-            // Effects start playing from pose animations as long as the intensity is above 0.5. Pretty sloppy honestly.
             pose?.animations
                 ?.asSequence()
-                ?.filter { shouldIdleRun(it, 0.5F) && it.condition(this) }
-                ?.forEach { it.applyEffects(entity, this, previousSeconds, newSeconds) }
+                ?.filter { it.condition(this) }
+                ?.forEach {
+                    it.applyEffects(entity, this, previousSeconds, newSeconds)
+                }
         }
     }
 

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/bedrock/animation/BedrockAnimation.kt

@@ -262,9 +262,9 @@ data class BedrockAnimation(
     fun applyEffects(entity: Entity?, state: PosableState, previousSeconds: Float, newSeconds: Float) {
         val effectCondition: (effectKeyframe: BedrockEffectKeyframe) -> Boolean =
             if (previousSeconds > newSeconds) {
-                { it.seconds >= previousSeconds || it.seconds <= newSeconds }
+                { it.seconds >= previousSeconds || it.seconds < newSeconds }
             } else {
-                { it.seconds in previousSeconds..newSeconds }
+                { it.seconds >= previousSeconds && it.seconds < newSeconds }
             }
 
         effects.filter(effectCondition).forEach { it.run(entity, state) }

common/src/main/kotlin/com/cobblemon/mod/common/client/render/player/FirstPersonRecallBallRenderer.kt

@@ -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.client.render.player
+
+import com.mojang.blaze3d.vertex.PoseStack
+import com.mojang.math.Axis
+import net.minecraft.client.Minecraft
+import net.minecraft.client.renderer.MultiBufferSource
+
+object FirstPersonRecallBallRenderer {
+    fun render(poseStack: PoseStack, buffer: MultiBufferSource, packedLight: Int, partialTicks: Float): Boolean {
+        val player = Minecraft.getInstance().player ?: return false
+        val anim = RecallArmAnimationTracker.get(player.uuid) ?: return false
+        val rise = RecallArmAnimationTracker.raiseFactor(player.uuid)
+
+        poseStack.pushPose()
+        poseStack.translate(0.45, -0.55 - 0.6 * (1.0 - rise), -0.6)
+        poseStack.scale(0.45F, -0.45F, -0.45F)
+        poseStack.mulPose(Axis.YP.rotationDegrees(180F))
+        poseStack.mulPose(Axis.XP.rotationDegrees(15F))
+        RecallArmAnimationTracker.renderBall(anim, poseStack, buffer, packedLight, partialTicks)
+        poseStack.popPose()
+        return true
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/player/RecallArmAnimationTracker.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.client.render.player
+
+import com.cobblemon.mod.common.client.battle.ClientBallDisplay
+import com.cobblemon.mod.common.client.render.models.blockbench.repository.RenderContext
+import com.cobblemon.mod.common.client.render.models.blockbench.repository.VaryingModelRepository
+import com.cobblemon.mod.common.pokeball.PokeBall
+import com.mojang.blaze3d.vertex.PoseStack
+import java.util.UUID
+import net.minecraft.client.renderer.MultiBufferSource
+import net.minecraft.client.renderer.RenderType
+import net.minecraft.client.renderer.entity.ItemRenderer
+import net.minecraft.client.renderer.texture.OverlayTexture
+import net.minecraft.util.Mth
+import net.minecraft.world.phys.Vec3
+
+object RecallArmAnimationTracker {
+    private const val HOLD_SECONDS = 0.8
+    private const val EASE_SECONDS = 0.15
+
+    class RecallAnim(val ball: PokeBall, val startTimeMs: Long) {
+        val ballState = ClientBallDisplay(ball, emptySet())
+        var beamOrigin: Vec3? = null
+    }
+
+    private val activeRecalls = mutableMapOf<UUID, RecallAnim>()
+    private val ballContext = RenderContext().also { it.put(RenderContext.RENDER_STATE, RenderContext.RenderState.WORLD) }
+
+    fun start(playerUuid: UUID, ball: PokeBall) {
+        activeRecalls[playerUuid] = RecallAnim(ball, System.currentTimeMillis())
+    }
+
+    fun get(playerUuid: UUID): RecallAnim? {
+        val anim = activeRecalls[playerUuid] ?: return null
+        if (secondsSince(anim) > HOLD_SECONDS) {
+            activeRecalls.remove(playerUuid)
+            return null
+        }
+        return anim
+    }
+
+    fun isRecalling(playerUuid: UUID) = get(playerUuid) != null
+
+    fun raiseFactor(playerUuid: UUID): Float {
+        val anim = get(playerUuid) ?: return 0F
+        val elapsed = secondsSince(anim)
+        val riseIn = Mth.clamp((elapsed / EASE_SECONDS).toFloat(), 0F, 1F)
+        val fallOut = Mth.clamp(((HOLD_SECONDS - elapsed) / EASE_SECONDS).toFloat(), 0F, 1F)
+        return minOf(riseIn, fallOut)
+    }
+
+    fun renderBall(anim: RecallAnim, poseStack: PoseStack, buffer: MultiBufferSource, packedLight: Int, partialTicks: Float) {
+        val state = anim.ballState
+        val model = VaryingModelRepository.getPoser(anim.ball.name, state)
+        val texture = VaryingModelRepository.getTexture(anim.ball.name, state)
+        state.updatePartialTicks(partialTicks)
+        model.context = ballContext
+        ballContext.put(RenderContext.ASPECTS, state.aspects)
+        ballContext.put(RenderContext.POSABLE_STATE, state)
+        model.applyAnimations(null, state, 0F, 0F, 0F, 0F, 0F)
+        val consumer = ItemRenderer.getFoilBufferDirect(buffer, RenderType.entityCutout(texture), false, false)
+        model.render(ballContext, poseStack, consumer, packedLight, OverlayTexture.NO_OVERLAY, -0x1)
+        model.resetLayerContext()
+    }
+
+    private fun secondsSince(anim: RecallAnim) = (System.currentTimeMillis() - anim.startTimeMs) / 1000.0
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/pokemon/PokemonRenderer.kt

@@ -26,6 +26,7 @@ import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PosableP
 import com.cobblemon.mod.common.client.render.models.blockbench.repository.MiscModelRepository
 import com.cobblemon.mod.common.client.render.models.blockbench.repository.RenderContext
 import com.cobblemon.mod.common.client.render.models.blockbench.repository.VaryingModelRepository
+import com.cobblemon.mod.common.client.render.player.RecallArmAnimationTracker
 import com.cobblemon.mod.common.client.render.pokeball.PokeBallPosableState
 import com.cobblemon.mod.common.client.render.renderBeaconBeam
 import com.cobblemon.mod.common.client.settings.ServerSettings
@@ -60,6 +61,7 @@ import net.minecraft.network.chat.Style
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.util.Mth
 import net.minecraft.world.entity.Entity
+import net.minecraft.world.entity.player.Player
 import net.minecraft.world.phys.Vec3
 import org.joml.*
 import kotlin.math.*
@@ -316,8 +318,11 @@ class PokemonRenderer(
     fun renderBeam(matrixStack: PoseStack, partialTicks: Float, entity: PokemonEntity, beamTarget: Entity, buffer: MultiBufferSource, offset: Vec3) {
         val clientDelegate = entity.delegate as PokemonClientDelegate
         val pokemonPosition = entity.position().add(0.0, entity.bbHeight / 2.0 * clientDelegate.activeSendoutScale.toDouble(), 0.0)
-        var beamSourcePosition = if (beamTarget is EmptyPokeBallEntity) {
-            (beamTarget.delegate as PokeBallPosableState).locatorStates["beam"]?.getOrigin() ?: beamTarget.position()
+        val recallBallOrigin = (beamTarget as? Player)?.let { RecallArmAnimationTracker.get(it.uuid)?.beamOrigin }
+        var beamSourcePosition = if (recallBallOrigin != null) {
+            recallBallOrigin
+        } else if (beamTarget is EmptyPokeBallEntity) {
+            (beamTarget.delegate as PokeBallPosableState).locatorStates["beam"]?.transformPosition(Vec3(0.0, 0.2, 0.45)) ?: beamTarget.position()
         } else {
             if (beamTarget.uuid == Minecraft.getInstance().player?.uuid) {
                 val lookVec = beamTarget.lookAngle.yRot((PI / 2).toFloat()).multiply(1.0, 0.0, 1.0).normalize()

common/src/main/kotlin/com/cobblemon/mod/common/command/TestPartySlotCommand.kt

@@ -9,7 +9,6 @@
 package com.cobblemon.mod.common.command
 
 import com.cobblemon.mod.common.api.permission.CobblemonPermissions
-import com.cobblemon.mod.common.api.pokemon.PokemonPropertyExtractor
 import com.cobblemon.mod.common.command.argument.PokemonPropertiesArgumentType
 import com.cobblemon.mod.common.util.party
 import com.cobblemon.mod.common.util.permission
@@ -45,7 +44,7 @@ object TestPartySlotCommand {
         val player = context.player(PLAYER)
         val slot = IntegerArgumentType.getInteger(context, SLOT)
         val properties = PokemonPropertiesArgumentType.getPokemonProperties(context, PROPERTIES)
-        return if (player.party().get(slot - 1)?.createPokemonProperties(PokemonPropertyExtractor.ALL)
-                ?.let { properties.isSubSetOf(it) } == true) Command.SINGLE_SUCCESS else NO_SUCCESS
+        val target = player.party().get(slot - 1) ?: return NO_SUCCESS
+        return if (properties.matches(target)) Command.SINGLE_SUCCESS else NO_SUCCESS
     }
 }

common/src/main/kotlin/com/cobblemon/mod/common/config/CobblemonConfig.kt

@@ -216,6 +216,9 @@ class CobblemonConfig {
     @CobblemonConfigField(Category.Pokemon, lang = "display_entity_labels_when_crouching_only", CLIENT)
     var displayEntityLabelsWhenCrouchingOnly = false
 
+    @CobblemonConfigField(Category.Pokemon, lang = "shoulder_mount_armor_offset_blacklist", CLIENT)
+    var shoulderMountArmorOffsetBlacklist = mutableSetOf<ResourceLocation>()
+
     @CobblemonConfigField(Category.Spawning, lang = "shiny_rate", SERVER)
     var shinyRate = 8192F
 

common/src/main/kotlin/com/cobblemon/mod/common/data/CobblemonDataProvider.kt

@@ -15,6 +15,7 @@ import com.cobblemon.mod.common.api.berry.Berries
 import com.cobblemon.mod.common.api.cooking.Seasonings
 import com.cobblemon.mod.common.api.data.DataProvider
 import com.cobblemon.mod.common.api.data.DataRegistry
+import com.cobblemon.mod.common.api.data.ServerJsonDataRegistry
 import com.cobblemon.mod.common.api.dialogue.Dialogues
 import com.cobblemon.mod.common.api.events.CobblemonEvents
 import com.cobblemon.mod.common.api.fishing.PokeRods
@@ -51,6 +52,7 @@ import com.cobblemon.mod.common.pokemon.properties.PropertiesCompletionProvider
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.cobblemon.mod.common.util.ifClient
 import com.cobblemon.mod.common.util.server
+import net.minecraft.core.HolderLookup
 import java.util.UUID
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerPlayer
@@ -71,8 +73,7 @@ object CobblemonDataProvider : DataProvider {
 
     // client is public only so we can use it cross-module. maybe a more elegant solution exists, but this works
     @ApiStatus.Internal
-    val clientResourceReloader: PreparableReloadListener = SimpleResourceReloader(PackType.CLIENT_RESOURCES)
-    private val serverResourceReloader: PreparableReloadListener = SimpleResourceReloader(PackType.SERVER_DATA)
+    val clientResourceReloader: PreparableReloadListener = ClientResourceReloader()
 
     fun registerDefaults() {
         this.register(CobblemonScripts, reloadable = true)
@@ -126,9 +127,9 @@ object CobblemonDataProvider : DataProvider {
         }
 
         ifClient {
-            Cobblemon.implementation.registerResourceReloader(cobblemonResource("client_resources"), clientResourceReloader, PackType.CLIENT_RESOURCES, emptyList())
+            Cobblemon.implementation.registerResourceReloader(cobblemonResource("client_resources"), PackType.CLIENT_RESOURCES, emptyList()) { clientResourceReloader }
         }
-        Cobblemon.implementation.registerResourceReloader(cobblemonResource("data_resources"), serverResourceReloader, PackType.SERVER_DATA, emptyList())
+        Cobblemon.implementation.registerResourceReloader(cobblemonResource("data_resources"), PackType.SERVER_DATA, emptyList()) { ServerResourceReloader(it) }
     }
 
     override fun <T : DataRegistry> register(registry: T, reloadable: Boolean): T {
@@ -167,12 +168,25 @@ object CobblemonDataProvider : DataProvider {
         }
     }
 
-    private class SimpleResourceReloader(private val type: PackType) : ResourceManagerReloadListener {
+    private class ClientResourceReloader : ResourceManagerReloadListener {
+        override fun onResourceManagerReload(manager: ResourceManager) {
+            registries.filter { it.type == PackType.CLIENT_RESOURCES }.forEach { it.reload(manager) }
+        }
+    }
+
+    private class ServerResourceReloader(private val registryAccess: HolderLookup.Provider) : ResourceManagerReloadListener {
         override fun onResourceManagerReload(manager: ResourceManager) {
             // Check for a server running, this is due to the create a world screen triggering datapack reloads, these are fine to happen as many times as needed as players may be in the process of adding their datapacks.
             val reloadAllowed = server()?.isReady != true
-            registries.filter { it.type == this.type && (reloadAllowed || it in reloadableRegistries) }
-                .forEach { it.reload(manager) }
+            registries
+                .filter { it.type == PackType.SERVER_DATA && (reloadAllowed || it in reloadableRegistries) }
+                .forEach {
+                    if (it is ServerJsonDataRegistry<*>) {
+                        it.reload(manager, registryAccess)
+                    } else {
+                        it.reload(manager)
+                    }
+                }
         }
     }
 }

common/src/main/kotlin/com/cobblemon/mod/common/entity/pokemon/PokemonEntity.kt

@@ -1483,19 +1483,31 @@ open class PokemonEntity(
 
         // Evolution item logic
         if (pokemon.getOwnerPlayer() == player) {
+            fun evolutionUnlocked(): Boolean {
+                stack.consume(1, player)
+                this.level().playSoundServer(
+                    position = this.position(),
+                    sound = CobblemonSounds.ITEM_USE,
+                    volume = 1F,
+                    pitch = 1F
+                )
+                return true
+            }
             val context = ItemInteractionEvolution.ItemInteractionContext(stack, player.level())
-            pokemon.lockedEvolutions
-                    .filterIsInstance<ItemInteractionEvolution>()
-                    .forEach { evolution ->
-                        if (evolution.attemptEvolution(pokemon, context)) {
-                            stack.consume(1, player)
-                            this.level().playSoundServer(
-                                    position = this.position(),
-                                    sound = CobblemonSounds.ITEM_USE,
-                                    volume = 1F,
-                                    pitch = 1F
-                            )
-                            return true
+            val lockedItemEvolutions = pokemon.lockedEvolutions.filterIsInstance<ItemInteractionEvolution>()
+            // forced evolutions > check those first and do ONLY one if there's multiple
+            lockedItemEvolutions.filter { !it.optional }.forEach {
+                if (it.attemptEvolution(pokemon, context)) {
+                   return evolutionUnlocked()
+                }
+            }
+            // optional evolutions > unlock all with single item use
+            lockedItemEvolutions.filter { it.optional }
+                    // we unlock all evolutions that depend on this single item
+                    .map { evolution -> return@map evolution.attemptEvolution(pokemon, context) }
+                    .let {
+                        if (it.contains(true)) { // if any of the evolutions were unlocked, we take the item
+                            return evolutionUnlocked()
                         }
                     }
         }

common/src/main/kotlin/com/cobblemon/mod/common/net/messages/client/data/SpeciesEvolutionSyncPacket.kt

@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.net.messages.client.data
+
+import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
+import com.cobblemon.mod.common.api.pokemon.evolution.Evolution
+import com.cobblemon.mod.common.api.pokemon.evolution.PreEvolution
+import com.cobblemon.mod.common.pokemon.FormData
+import com.cobblemon.mod.common.pokemon.Species
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.cobblemon.mod.common.util.readIdentifier
+import com.cobblemon.mod.common.util.readString
+import com.cobblemon.mod.common.util.writeIdentifier
+import com.cobblemon.mod.common.util.writeString
+import com.google.gson.reflect.TypeToken
+import net.minecraft.network.RegistryFriendlyByteBuf
+import net.minecraft.resources.ResourceLocation
+
+/**
+ * Carries the evolutions/preEvolution of every [Species] (and any [FormData] overrides), sent right after
+ * [SpeciesRegistrySyncPacket] so that every species is already registered by the time this is decoded. This avoids
+ * the cross-species lookup ordering hazards that come with resolving evolutions during the species sync itself.
+ */
+class SpeciesEvolutionSyncPacket(entries: Collection<SpeciesEvolutionEntry>) : DataRegistrySyncPacket<SpeciesEvolutionEntry, SpeciesEvolutionSyncPacket>(entries) {
+
+    override val id = ID
+
+    override fun encodeEntry(buffer: RegistryFriendlyByteBuf, entry: SpeciesEvolutionEntry) {
+        try {
+            buffer.writeIdentifier(entry.speciesIdentifier)
+            buffer.writeString(PokemonSpecies.gson.toJson(entry.evolutions, EVOLUTION_SET_TYPE))
+            buffer.writeNullable(entry.preEvolution) { _, preEvolution -> buffer.writeString(PokemonSpecies.gson.toJson(preEvolution, PreEvolution::class.java)) }
+            buffer.writeCollection(entry.formOverrides) { _, override ->
+                buffer.writeString(override.formName)
+                buffer.writeNullable(override.evolutions) { _, evolutions -> buffer.writeString(PokemonSpecies.gson.toJson(evolutions, EVOLUTION_SET_TYPE)) }
+                buffer.writeNullable(override.preEvolution) { _, preEvolution -> buffer.writeString(PokemonSpecies.gson.toJson(preEvolution, PreEvolution::class.java)) }
+            }
+        } catch (e: Exception) {
+            Cobblemon.LOGGER.error("Caught exception encoding evolution data for species {}", entry.speciesIdentifier, e)
+        }
+    }
+
+    override fun decodeEntry(buffer: RegistryFriendlyByteBuf): SpeciesEvolutionEntry? {
+        val identifier = buffer.readIdentifier()
+        return try {
+            val evolutions: MutableSet<Evolution> = PokemonSpecies.gson.fromJson(buffer.readString(), EVOLUTION_SET_TYPE)
+            val preEvolution = buffer.readNullable { _ -> PokemonSpecies.gson.fromJson(buffer.readString(), PreEvolution::class.java) }
+            val formOverrides = buffer.readList { _ ->
+                val formName = buffer.readString()
+                val formEvolutions = buffer.readNullable { _ -> PokemonSpecies.gson.fromJson<MutableSet<Evolution>>(buffer.readString(), EVOLUTION_SET_TYPE) }
+                val formPreEvolution = buffer.readNullable { _ -> PokemonSpecies.gson.fromJson(buffer.readString(), PreEvolution::class.java) }
+                FormEvolutionOverride(formName, formEvolutions, formPreEvolution)
+            }
+            SpeciesEvolutionEntry(identifier, evolutions, preEvolution, formOverrides)
+        } catch (e: Exception) {
+            Cobblemon.LOGGER.error("Caught exception decoding evolution data for species {}", identifier, e)
+            null
+        }
+    }
+
+    override fun synchronizeDecoded(entries: Collection<SpeciesEvolutionEntry>) {
+        entries.forEach { entry ->
+            val species = PokemonSpecies.getByIdentifier(entry.speciesIdentifier)
+            if (species == null) {
+                Cobblemon.LOGGER.error("Received evolution data for unknown species {}", entry.speciesIdentifier)
+                return@forEach
+            }
+            species.applyEvolutionData(entry.evolutions, entry.preEvolution)
+            entry.formOverrides.forEach { override ->
+                species.getFormByName(override.formName).applyEvolutionData(override.evolutions, override.preEvolution)
+            }
+        }
+    }
+
+    companion object {
+        val ID = cobblemonResource("species_evolution_sync")
+        private val EVOLUTION_SET_TYPE = TypeToken.getParameterized(MutableSet::class.java, Evolution::class.java).type
+        fun decode(buffer: RegistryFriendlyByteBuf): SpeciesEvolutionSyncPacket = SpeciesEvolutionSyncPacket(emptyList()).apply { decodeBuffer(buffer) }
+    }
+}
+
+class SpeciesEvolutionEntry(
+    val speciesIdentifier: ResourceLocation,
+    val evolutions: MutableSet<Evolution>,
+    val preEvolution: PreEvolution?,
+    val formOverrides: List<FormEvolutionOverride>
+)
+
+class FormEvolutionOverride(
+    val formName: String,
+    val evolutions: MutableSet<Evolution>?,
+    val preEvolution: PreEvolution?
+)

common/src/main/kotlin/com/cobblemon/mod/common/pokemon/FormData.kt

@@ -76,7 +76,7 @@ class FormData(
     @SerializedName("moves")
     private var _moves: Learnset? = null,
     @SerializedName("evolutions")
-    private val _evolutions: MutableSet<Evolution>? = null,
+    private var _evolutions: MutableSet<Evolution>? = null,
     @SerializedName("abilities")
     private var _abilities: AbilityPool? = null,
     @SerializedName("drops")
@@ -84,7 +84,7 @@ class FormData(
     @SerializedName("pokedex")
     private var _pokedex: MutableList<String>? = null,
     @SerializedName("preEvolution")
-    private val _preEvolution: PreEvolution? = null,
+    private var _preEvolution: PreEvolution? = null,
     private var standingEyeHeight: Float? = null,
     private var swimmingEyeHeight: Float? = null,
     private var flyingEyeHeight: Float? = null,
@@ -210,6 +210,14 @@ class FormData(
     val evolutions: MutableSet<Evolution>
         get() = _evolutions ?: mutableSetOf()
 
+    /** The evolutions explicitly set on this form, as opposed to [evolutions] which falls back to an empty set. Used to tell whether this form overrides the species' evolutions when syncing. */
+    internal val ownEvolutions: MutableSet<Evolution>?
+        get() = this._evolutions
+
+    /** The preEvolution explicitly set on this form, as opposed to [preEvolution] which falls back to the species'. Used to tell whether this form overrides the species' preEvolution when syncing. */
+    internal val ownPreEvolution: PreEvolution?
+        get() = this._preEvolution
+
     val battleTheme: ResourceLocation
         get() = _battleTheme ?: species.battleTheme
 
@@ -261,15 +269,24 @@ class FormData(
         this.species = species
         this.behaviour.parent = species.behaviour
         Cobblemon.statProvider.provide(this)
-        // These properties are lazy, these need all species to be reloaded but SpeciesAdditions is what will eventually trigger this after all species have been loaded
-        this.preEvolution?.species
-        this.preEvolution?.form
-        this.evolutions.size
         this._lightingData?.let { this._lightingData = it.copy(lightLevel = it.lightLevel.coerceIn(0, 15)) }
         behaviour.herd.initialize()
         return this
     }
 
+    /**
+     * Applies decoded evolution data onto this form, received separately via [com.cobblemon.mod.common.net.messages.client.data.SpeciesEvolutionSyncPacket]
+     * after every species has already been registered.
+     */
+    internal fun applyEvolutionData(evolutions: MutableSet<Evolution>?, preEvolution: PreEvolution?) {
+        this._evolutions = evolutions
+        this._preEvolution = preEvolution
+        // These properties are lazy, force resolution now that every species is guaranteed to be registered
+        this.preEvolution?.species
+        this.preEvolution?.form
+        this.evolutions.size
+    }
+
     internal fun resolveEvolutionMoves() {
         this.evolutions.forEach { evolution ->
             if (evolution.learnableMoves.isNotEmpty() && evolution.result.species != null) {

common/src/main/kotlin/com/cobblemon/mod/common/pokemon/Species.kt

@@ -181,11 +181,20 @@ class Species : ShowdownIdentifiable {
             this.forms.add(0, this.standardForm)
         }
         this.lightingData?.let { this.lightingData = it.copy(lightLevel = it.lightLevel.coerceIn(0, 15)) }
-        // These properties are lazy, these need all species to be reloaded but SpeciesAdditions is what will eventually trigger this after all species have been loaded
+        behaviour.herd.initialize()
+    }
+
+    /**
+     * Applies decoded evolution data onto this species, received separately via [com.cobblemon.mod.common.net.messages.client.data.SpeciesEvolutionSyncPacket]
+     * after every species has already been registered.
+     */
+    internal fun applyEvolutionData(evolutions: MutableSet<Evolution>, preEvolution: PreEvolution?) {
+        // Mutate in place rather than reassign: standardForm may have already captured this.evolutions by reference.
+        this.evolutions.clear()
+        this.evolutions.addAll(evolutions)
+        this.preEvolution = preEvolution
         this.preEvolution?.species
         this.preEvolution?.form
-        this.evolutions.size
-        behaviour.herd.initialize()
     }
 
     // Ran after initialize due to us creating a Pokémon here which requires all the properties in #initialize to be present for both this and the results, this is the easiest way to quickly resolve species + form

common/src/main/kotlin/com/cobblemon/mod/common/pokemon/adapters/CobbledRequirementAdapter.kt

@@ -36,6 +36,8 @@ import kotlin.reflect.KClass
 object CobblemonRequirementAdapter : RequirementAdapter {
 
     private const val VARIANT = "variant"
+    private const val POKEDEX_ICON = "pokedexIcon"
+    private const val POKEDEX_TOOLTIP = "pokedexTooltip"
 
     private val types = HashBiMap.create<String, KClass<out Requirement>>()
 
@@ -75,7 +77,7 @@ object CobblemonRequirementAdapter : RequirementAdapter {
         GsonBuilder()
             .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
             .registerTypeAdapter(PokemonProperties::class.java, pokemonPropertiesShortAdapter)
-            .registerTypeAdapter(ItemPredicate::class.java, LegacyItemConditionWrapperAdapter)
+            .registerTypeAdapter(ItemPredicate::class.java, LegacyItemConditionWrapperAdapter())
             .registerTypeAdapter(Requirement::class.java, CobblemonRequirementAdapter)
             .registerTypeAdapter(InteractionEffect::class.java, InteractionEffectAdapter)
             .registerTypeAdapter(ExpressionLike::class.java, ExpressionLikeAdapter)
@@ -90,15 +92,26 @@ object CobblemonRequirementAdapter : RequirementAdapter {
     }
 
     override fun deserialize(json: JsonElement, typeOfT: Type, context: JsonDeserializationContext): Requirement {
-        val variant = json.asJsonObject.get(VARIANT).asString.lowercase()
+        val obj = json.asJsonObject
+        val variant = obj.get(VARIANT).asString.lowercase()
         val type = getRequirementType(variant)
-        return context.deserialize(json, type.java)
+        val requirement = context.deserialize<Requirement>(json, type.java)
+
+        obj.get(POKEDEX_ICON)?.takeIf { !it.isJsonNull }
+            ?.let { context.deserialize<ResourceLocation>(it, ResourceLocation::class.java) }
+            ?.let { Requirement.pokedexIconOverrides[requirement] = it }
+        obj.get(POKEDEX_TOOLTIP)?.takeIf { !it.isJsonNull }?.asString
+            ?.let { Requirement.pokedexTooltipOverrides[requirement] = it }
+
+        return requirement
     }
 
     override fun serialize(requirement: Requirement, typeOfSrc: Type, context: JsonSerializationContext): JsonElement {
         val json = context.serialize(requirement, requirement::class.java).asJsonObject
         val variant = getVariant(requirement)
         json.addProperty(VARIANT, variant)
+        Requirement.pokedexIconOverrides[requirement]?.let { json.add(POKEDEX_ICON, context.serialize(it, ResourceLocation::class.java)) }
+        Requirement.pokedexTooltipOverrides[requirement]?.let { json.addProperty(POKEDEX_TOOLTIP, it) }
         return json
     }
 

common/src/main/kotlin/com/cobblemon/mod/common/pokemon/evolution/CobblemonLazyPreEvolution.kt

@@ -25,12 +25,20 @@ internal class CobblemonLazyPreEvolution(private val rawData: String) : PreEvolu
         this.properties.species?.asIdentifierDefaultingNamespace()?.let { PokemonSpecies.getByIdentifier(it) } ?: throw IllegalArgumentException("A PreEvolution needs a valid species")
     }
 
-    private val lazyForm: FormData by lazy {
-        this.properties.form?.let { formId -> this.species.forms.firstOrNull { it.formOnlyShowdownId().equals(formId, true) } } ?: this.species.standardForm
+    private fun computeForm(extraAspects: Set<String>): FormData {
+        val properties = this.properties
+        return properties.form?.let { formId -> this.species.forms.firstOrNull { it.formOnlyShowdownId().equals(formId, true) } }
+            ?: this.species.getForm(properties.aspects + this.rawData.split(" ").map { it.lowercase() }.toSet() + extraAspects)
     }
 
+    private val lazyForm: FormData by lazy { computeForm(emptySet()) }
+
     override val species: Species
         get() = this.lazySpecies
     override val form: FormData
         get() = this.lazyForm
+
+    override fun resolveForm(extraAspects: Set<String>): FormData {
+        return if (extraAspects.isEmpty()) this.form else computeForm(extraAspects)
+    }
 }

common/src/main/kotlin/com/cobblemon/mod/common/pokemon/evolution/adapters/LegacyItemConditionWrapperAdapter.kt

@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.pokemon.evolution.adapters
 
 import com.cobblemon.mod.common.util.adapters.CodecBackedAdapter
+import com.cobblemon.mod.common.util.adapters.RegistryAccessResolver
 import com.google.gson.JsonDeserializationContext
 import com.google.gson.JsonDeserializer
 import com.google.gson.JsonElement
@@ -19,6 +20,7 @@ import net.minecraft.advancements.critereon.ItemCustomDataPredicate
 import net.minecraft.advancements.critereon.ItemPredicate
 import net.minecraft.advancements.critereon.ItemSubPredicates
 import net.minecraft.advancements.critereon.NbtPredicate
+import net.minecraft.core.HolderLookup
 import net.minecraft.core.registries.BuiltInRegistries
 import net.minecraft.core.registries.Registries
 import net.minecraft.resources.ResourceLocation
@@ -26,13 +28,16 @@ import net.minecraft.tags.TagKey
 import java.lang.reflect.Type
 
 // This is an ugly adapter because breaking changes are scary and people would ;(
-object LegacyItemConditionWrapperAdapter : JsonDeserializer<ItemPredicate>, JsonSerializer<ItemPredicate> {
+class LegacyItemConditionWrapperAdapter(val registryAccess: HolderLookup.Provider = RegistryAccessResolver.getAccess())
+    : JsonDeserializer<ItemPredicate>, JsonSerializer<ItemPredicate> {
 
-    private const val TAG_PREFIX = "#"
-    private const val LEGACY_ITEM = "item"
-    private const val LEGACY_NBT = "nbt"
+    companion object {
+        private const val TAG_PREFIX = "#"
+        private const val LEGACY_ITEM = "item"
+        private const val LEGACY_NBT = "nbt"
+    }
 
-    private val codecAdapter = CodecBackedAdapter(ItemPredicate.CODEC)
+    private val codecAdapter = CodecBackedAdapter(ItemPredicate.CODEC, registryAccess)
 
     override fun deserialize(json: JsonElement, typeOfT: Type, context: JsonDeserializationContext): ItemPredicate {
         if (json.isJsonPrimitive) {
@@ -64,7 +69,9 @@ object LegacyItemConditionWrapperAdapter : JsonDeserializer<ItemPredicate>, Json
                 { id ->
                     if (isTag) {
                         val tag = TagKey.create(Registries.ITEM, id)
-                        builder.of(tag)
+                        registryAccess.lookup(Registries.ITEM)
+                            .map { builder.of(tag) }
+                            .orElseGet { builder }
                     } else {
                         BuiltInRegistries.ITEM.getOptional(id)
                             .map { builder.of(it) }
@@ -75,4 +82,4 @@ object LegacyItemConditionWrapperAdapter : JsonDeserializer<ItemPredicate>, Json
             )
     }
 
-}
+}

common/src/main/kotlin/com/cobblemon/mod/common/util/adapters/BoxAdapter.kt

@@ -12,10 +12,12 @@ import com.google.gson.JsonDeserializationContext
 import com.google.gson.JsonDeserializer
 import com.google.gson.JsonElement
 import com.google.gson.JsonObject
+import com.google.gson.JsonSerializationContext
+import com.google.gson.JsonSerializer
 import java.lang.reflect.Type
 import net.minecraft.world.phys.AABB
 
-object BoxAdapter : JsonDeserializer<AABB> {
+object BoxAdapter : JsonDeserializer<AABB>, JsonSerializer<AABB> {
     override fun deserialize(json: JsonElement, type: Type, ctx: JsonDeserializationContext): AABB {
         json as JsonObject
         return AABB(
@@ -27,4 +29,15 @@ object BoxAdapter : JsonDeserializer<AABB> {
             json.get("maxZ")?.asDouble ?: 9999999.0
         )
     }
+
+    override fun serialize(src: AABB, typeOfSrc: Type, ctx: JsonSerializationContext): JsonElement {
+        val json = JsonObject()
+        json.addProperty("minX", src.minX)
+        json.addProperty("minY", src.minY)
+        json.addProperty("minZ", src.minZ)
+        json.addProperty("maxX", src.maxX)
+        json.addProperty("maxY", src.maxY)
+        json.addProperty("maxZ", src.maxZ)
+        return json
+    }
 }

common/src/main/kotlin/com/cobblemon/mod/common/util/adapters/CodecBackedAdapter.kt

@@ -10,16 +10,19 @@ package com.cobblemon.mod.common.util.adapters
 
 import com.google.gson.*
 import com.mojang.serialization.Codec
+import com.mojang.serialization.JsonOps
+import net.minecraft.core.HolderLookup
+import net.minecraft.resources.RegistryOps
 import java.lang.reflect.Type
 
-class CodecBackedAdapter<T>(val codec: Codec<T>) : JsonDeserializer<T>, JsonSerializer<T> {
+class CodecBackedAdapter<T>(val codec: Codec<T>, val registryAccess: HolderLookup.Provider = RegistryAccessResolver.getAccess()) : JsonDeserializer<T>, JsonSerializer<T> {
 
     override fun deserialize(
         jElement: JsonElement,
         typeOfT: Type,
         context: JsonDeserializationContext
     ): T {
-        val ops = RegistryOpsProvider.getOpsWithDefaultFallback()
+        val ops = RegistryOps.create(JsonOps.INSTANCE, registryAccess)
         val result = ops.withDecoder(codec).apply(jElement)
         return result.result().orElseThrow {
             IllegalStateException("Failed to deserialize $jElement: ${result.error().orElse(null)}")
@@ -31,7 +34,7 @@ class CodecBackedAdapter<T>(val codec: Codec<T>) : JsonDeserializer<T>, JsonSeri
         typeOfSrc: Type?,
         context: JsonSerializationContext?
     ): JsonElement {
-        val ops = RegistryOpsProvider.getOpsWithDefaultFallback()
+        val ops = RegistryOps.create(JsonOps.INSTANCE, registryAccess)
         val result = ops.withEncoder(codec).apply(src)
         return result.result().orElseThrow {
             IllegalStateException("Failed to serialize $src: ${result.error().orElse(null)}")

common/src/main/kotlin/com/cobblemon/mod/common/util/adapters/DropEntryAdapter.kt

@@ -13,6 +13,8 @@ import com.google.gson.JsonDeserializationContext
 import com.google.gson.JsonDeserializer
 import com.google.gson.JsonElement
 import com.google.gson.JsonObject
+import com.google.gson.JsonSerializationContext
+import com.google.gson.JsonSerializer
 import java.lang.reflect.Type
 
 /**
@@ -22,7 +24,7 @@ import java.lang.reflect.Type
  * @author Hiroku
  * @since July 24th, 2022
  */
-object DropEntryAdapter : JsonDeserializer<DropEntry> {
+object DropEntryAdapter : JsonDeserializer<DropEntry>, JsonSerializer<DropEntry> {
     override fun deserialize(json: JsonElement, type: Type, ctx: JsonDeserializationContext): DropEntry {
         json as JsonObject
         val entryClass = json.get("type")?.asString
@@ -30,4 +32,12 @@ object DropEntryAdapter : JsonDeserializer<DropEntry> {
             ?: DropEntry.defaultType
         return ctx.deserialize(json, entryClass)
     }
+
+    override fun serialize(src: DropEntry, typeOfSrc: Type, ctx: JsonSerializationContext): JsonElement {
+        val json = ctx.serialize(src, src::class.java).asJsonObject
+        val name = DropEntry.entryTypes.entries.find { it.value == src::class.java }?.key
+            ?: throw IllegalArgumentException("Cannot resolve drop entry type for ${src::class.qualifiedName}")
+        json.addProperty("type", name)
+        return json
+    }
 }

common/src/main/kotlin/com/cobblemon/mod/common/util/adapters/ExpressionAdapter.kt

@@ -10,13 +10,21 @@ package com.cobblemon.mod.common.util.adapters
 
 import com.bedrockk.molang.Expression
 import com.bedrockk.molang.MoLang
+import com.cobblemon.mod.common.util.getString
 import com.google.gson.JsonDeserializationContext
 import com.google.gson.JsonDeserializer
 import com.google.gson.JsonElement
+import com.google.gson.JsonPrimitive
+import com.google.gson.JsonSerializationContext
+import com.google.gson.JsonSerializer
 import java.lang.reflect.Type
 
-object ExpressionAdapter : JsonDeserializer<Expression> {
+object ExpressionAdapter : JsonDeserializer<Expression>, JsonSerializer<Expression> {
     override fun deserialize(json: JsonElement, typeOfT: Type, ctx: JsonDeserializationContext): Expression {
         return MoLang.createParser(json.asString).parseExpression()
     }
+
+    override fun serialize(src: Expression, typeOfSrc: Type, ctx: JsonSerializationContext): JsonElement {
+        return JsonPrimitive(src.getString())
+    }
 }

common/src/main/kotlin/com/cobblemon/mod/common/util/adapters/ExpressionLikeAdapter.kt

@@ -13,6 +13,9 @@ import com.cobblemon.mod.common.util.asExpressionLike
 import com.google.gson.JsonDeserializationContext
 import com.google.gson.JsonDeserializer
 import com.google.gson.JsonElement
+import com.google.gson.JsonPrimitive
+import com.google.gson.JsonSerializationContext
+import com.google.gson.JsonSerializer
 import java.lang.reflect.Type
 
 /**
@@ -22,7 +25,7 @@ import java.lang.reflect.Type
  * @author Hiroku
  * @since October 22nd, 2023
  */
-object ExpressionLikeAdapter : JsonDeserializer<ExpressionLike> {
+object ExpressionLikeAdapter : JsonDeserializer<ExpressionLike>, JsonSerializer<ExpressionLike> {
     override fun deserialize(json: JsonElement, type: Type, ctx: JsonDeserializationContext): ExpressionLike {
         return if (json.isJsonPrimitive) {
             json.asString.asExpressionLike()
@@ -32,4 +35,8 @@ object ExpressionLikeAdapter : JsonDeserializer<ExpressionLike> {
             throw IllegalArgumentException("Invalid expression JSON: $json")
         }
     }
+
+    override fun serialize(src: ExpressionLike, typeOfSrc: Type, ctx: JsonSerializationContext): JsonElement {
+        return JsonPrimitive(src.getString())
+    }
 }

common/src/main/kotlin/com/cobblemon/mod/common/util/adapters/RegistryOpsProvider.kt

@@ -15,27 +15,33 @@ import com.google.gson.JsonElement
 import com.mojang.serialization.DynamicOps
 import com.mojang.serialization.JsonOps
 import net.minecraft.client.Minecraft
+import net.minecraft.core.RegistryAccess
 import net.minecraft.resources.RegistryOps
 
 /**
- * Utility for obtaining RegistryOps with the correct client/server registry access.
- * Used when manually encoding/decoding registry-backed values (e.g., items, predicates).
+ * Utility for getting RegistryAccess with the correct client/server registry access.
+ * Used when as a fallback when manually encoding/decoding registry-backed values (e.g., items, predicates).
  */
-object RegistryOpsProvider {
-    fun getOpsWithDefaultFallback(): DynamicOps<JsonElement> {
+object RegistryAccessResolver {
+    fun getAccess(): RegistryAccess {
+        try {
+            Cobblemon.implementation
+        } catch (e: UninitializedPropertyAccessException) {
+            return RegistryAccess.EMPTY
+        }
         if (Cobblemon.implementation.environment() == Environment.CLIENT) {
             val minecraft = Minecraft.getInstance()
             if (minecraft != null && minecraft.level != null)
-                return RegistryOps.create(JsonOps.INSTANCE, minecraft.level!!.registryAccess())
+                return minecraft.level!!.registryAccess()
         }
 
 
         if (Cobblemon.implementation.environment() == Environment.SERVER) {
             val server = server()
             if (server != null)
-                return RegistryOps.create(JsonOps.INSTANCE, server.registryAccess())
+                return server.registryAccess()
         }
 
-        return JsonOps.INSTANCE
+        return RegistryAccess.EMPTY
     }
 }

common/src/main/kotlin/com/cobblemon/mod/common/util/codec/internal/PokemonP1.kt

@@ -13,6 +13,7 @@ import com.cobblemon.mod.common.api.abilities.Abilities
 import com.cobblemon.mod.common.api.abilities.Ability
 import com.cobblemon.mod.common.api.moves.BenchedMoves
 import com.cobblemon.mod.common.api.moves.MoveSet
+import com.cobblemon.mod.common.api.pokemon.feature.SpeciesFeatures
 import com.cobblemon.mod.common.pokemon.EVs
 import com.cobblemon.mod.common.pokemon.FormData
 import com.cobblemon.mod.common.pokemon.Gender
@@ -21,20 +22,22 @@ import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.pokemon.Species
 import com.cobblemon.mod.common.util.DataKeys
 import com.cobblemon.mod.common.util.codec.CodecUtils
+import com.cobblemon.mod.common.util.codec.internal.ClientPokemonP1.Companion.FEATURES
+import com.cobblemon.mod.common.util.codec.internal.ClientPokemonP1.Companion.FEATURE_ID
 import com.mojang.serialization.Codec
 import com.mojang.serialization.MapCodec
 import com.mojang.serialization.codecs.RecordCodecBuilder
-import java.util.Optional
 import java.util.UUID
 import net.minecraft.core.UUIDUtil
-import net.minecraft.network.chat.Component
-import net.minecraft.network.chat.ComponentSerialization
+import net.minecraft.nbt.CompoundTag
+import net.minecraft.nbt.StringTag
+import net.minecraft.nbt.Tag
 
 internal class PokemonP1(
     val uuid: UUID,
     val species: Species,
     val form: FormData,
-    val nickname: Optional<Component>,
+    val features: List<CompoundTag>,
     val level: Int,
     val experience: Int,
     val friendship: Int,
@@ -55,7 +58,22 @@ internal class PokemonP1(
         other.ability = this.ability
         other.species = this.species
         other.form = this.form
-        this.nickname.ifPresent { other.nickname = it.copy() }
+        this.features.forEach { featureNbt ->
+            val featureId = featureNbt.getString(FEATURE_ID)
+            if (featureId.isEmpty()) {
+                return@forEach
+            }
+            val speciesFeatureProviders = SpeciesFeatures.getFeaturesFor(other.species)
+            val feature = speciesFeatureProviders.firstNotNullOfOrNull { provider -> provider(featureNbt) } ?: return@forEach
+            if (
+                featureNbt.contains("keys", Tag.TAG_STRING.toInt()) &&
+                !featureNbt.getList("keys", Tag.TAG_STRING.toInt()).contains(StringTag.valueOf(featureId))
+            ) {
+                return@forEach
+            }
+            other.features.removeIf { it.name == feature.name }
+            other.features.add(feature)
+        }
         other.level = this.level
         other.experience = this.experience
         other.setFriendship(this.friendship)
@@ -91,7 +109,7 @@ internal class PokemonP1(
                 UUIDUtil.LENIENT_CODEC.fieldOf(DataKeys.POKEMON_UUID).forGetter(PokemonP1::uuid),
                 Species.BY_IDENTIFIER_CODEC.fieldOf(DataKeys.POKEMON_SPECIES_IDENTIFIER).forGetter(PokemonP1::species),
                 Codec.STRING.fieldOf(DataKeys.POKEMON_FORM_ID).forGetter { pokemon -> pokemon.form.formOnlyShowdownId() },
-                ComponentSerialization.CODEC.optionalFieldOf(DataKeys.POKEMON_NICKNAME).forGetter(PokemonP1::nickname),
+                Codec.list(CompoundTag.CODEC).optionalFieldOf(FEATURES, emptyList()).forGetter(PokemonP1::features),
                 CodecUtils.dynamicIntRange(1) { Cobblemon.config.maxPokemonLevel }.fieldOf(DataKeys.POKEMON_LEVEL).forGetter(PokemonP1::level),
                 Codec.intRange(0, Int.MAX_VALUE).fieldOf(DataKeys.POKEMON_EXPERIENCE).forGetter(PokemonP1::experience),
                 CodecUtils.dynamicIntRange(0) { Cobblemon.config.maxPokemonFriendship }.fieldOf(DataKeys.POKEMON_FRIENDSHIP).forGetter(PokemonP1::friendship),
@@ -104,9 +122,9 @@ internal class PokemonP1(
                 Codec.FLOAT.fieldOf(DataKeys.POKEMON_SCALE_MODIFIER).forGetter(PokemonP1::scaleModifier),
                 Codec.BOOL.fieldOf(DataKeys.POKEMON_SHINY).forGetter(PokemonP1::shiny),
                 Ability.CODEC.fieldOf(DataKeys.POKEMON_ABILITY).forGetter(PokemonP1::ability)
-            ).apply(instance) { uuid, species, formId, nickname, level, experience, friendship, currentHealth, gender, ivs, evs, moveSet, benchedMoves, scaleModifier, shiny, ability ->
+            ).apply(instance) { uuid, species, formId, features, level, experience, friendship, currentHealth, gender, ivs, evs, moveSet, benchedMoves, scaleModifier, shiny, ability ->
                 val form = species.forms.firstOrNull { it.formOnlyShowdownId() == formId } ?: species.standardForm
-                PokemonP1(uuid, species, form, nickname, level, experience, friendship, currentHealth, gender, ivs, evs, moveSet, benchedMoves, scaleModifier, shiny, ability)
+                PokemonP1(uuid, species, form, features, level, experience, friendship, currentHealth, gender, ivs, evs, moveSet, benchedMoves, scaleModifier, shiny, ability)
             }
         }
 
@@ -114,7 +132,11 @@ internal class PokemonP1(
             pokemon.uuid,
             pokemon.species,
             pokemon.form,
-            Optional.ofNullable(pokemon.nickname),
+            pokemon.features.map { feature ->
+                val nbt = CompoundTag()
+                nbt.putString(FEATURE_ID, feature.name)
+                feature.saveToNBT(nbt)
+            },
             pokemon.level,
             pokemon.experience,
             pokemon.friendship,

common/src/main/kotlin/com/cobblemon/mod/common/util/codec/internal/PokemonP3.kt

@@ -14,15 +14,12 @@ import com.cobblemon.mod.common.api.riding.stats.RidingStat
 import com.cobblemon.mod.common.pokemon.OriginalTrainerType
 import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.util.DataKeys
-import com.cobblemon.mod.common.util.codec.internal.ClientPokemonP1.Companion.FEATURES
-import com.cobblemon.mod.common.util.codec.internal.ClientPokemonP1.Companion.FEATURE_ID
 import com.cobblemon.mod.common.util.codec.optionalFieldOfWithDefault
 import com.mojang.serialization.Codec
 import com.mojang.serialization.MapCodec
 import com.mojang.serialization.codecs.RecordCodecBuilder
-import net.minecraft.nbt.CompoundTag
-import net.minecraft.nbt.StringTag
-import net.minecraft.nbt.Tag
+import net.minecraft.network.chat.Component
+import net.minecraft.network.chat.ComponentSerialization
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.world.item.ItemStack
 import java.util.*
@@ -31,7 +28,7 @@ internal data class PokemonP3(
     val originalTrainerType: OriginalTrainerType,
     val originalTrainer: Optional<String>,
     val forcedAspects: Set<String>,
-    val features: List<CompoundTag>,
+    val nickname: Optional<Component>,
     val heldItemVisible: Optional<Boolean>,
     val canDropHeldItem: Optional<Boolean>,
     val cosmeticItem: ItemStack,
@@ -51,22 +48,7 @@ internal data class PokemonP3(
         this.originalTrainer.ifPresent { other.originalTrainer = it }
         other.refreshOriginalTrainer()
         other.forcedAspects = this.forcedAspects
-        this.features.forEach { featureNbt ->
-            val featureId = featureNbt.getString(FEATURE_ID)
-            if (featureId.isEmpty()) {
-                return@forEach
-            }
-            val speciesFeatureProviders = SpeciesFeatures.getFeaturesFor(other.species)
-            val feature = speciesFeatureProviders.firstNotNullOfOrNull { provider -> provider(featureNbt) } ?: return@forEach
-            if (
-                featureNbt.contains("keys", Tag.TAG_STRING.toInt()) &&
-                !featureNbt.getList("keys", Tag.TAG_STRING.toInt()).contains(StringTag.valueOf(featureId))
-            ) {
-                return@forEach
-            }
-            other.features.removeIf { it.name == feature.name }
-            other.features.add(feature)
-        }
+        this.nickname.ifPresent { other.nickname = it.copy() }
         this.heldItemVisible.ifPresent { other.heldItemVisible = it }
         this.canDropHeldItem.ifPresent { other.canDropHeldItem = it }
         this.cosmeticItem.let { other.cosmeticItem = it }
@@ -92,7 +74,7 @@ internal data class PokemonP3(
                 OriginalTrainerType.CODEC.optionalFieldOfWithDefault(DataKeys.POKEMON_ORIGINAL_TRAINER_TYPE, OriginalTrainerType.NONE).forGetter(PokemonP3::originalTrainerType),
                 Codec.STRING.optionalFieldOf(DataKeys.POKEMON_ORIGINAL_TRAINER).forGetter(PokemonP3::originalTrainer),
                 Codec.list(Codec.STRING).optionalFieldOf(DataKeys.POKEMON_FORCED_ASPECTS, emptyList()).forGetter { it.forcedAspects.toMutableList() },
-                Codec.list(CompoundTag.CODEC).optionalFieldOf(FEATURES, emptyList()).forGetter(PokemonP3::features),
+                ComponentSerialization.CODEC.optionalFieldOf(DataKeys.POKEMON_NICKNAME).forGetter(PokemonP3::nickname),
                 Codec.BOOL.optionalFieldOf(DataKeys.HELD_ITEM_VISIBLE).forGetter(PokemonP3::heldItemVisible),
                 Codec.BOOL.optionalFieldOf(DataKeys.HELD_ITEM_AI_DROPPABLE).forGetter(PokemonP3::canDropHeldItem),
                 ItemStack.CODEC.optionalFieldOf(DataKeys.POKEMON_COSMETIC_ITEM).forGetter { Optional.ofNullable(it.cosmeticItem.takeIf { !it.isEmpty }) },
@@ -109,7 +91,7 @@ internal data class PokemonP3(
               originalTrainerType,
               originalTrainer,
               forcedAspects,
-              features,
+              nickname,
               heldItemVisible,
               canDropHeldItem,
               cosmeticItem,
@@ -125,7 +107,7 @@ internal data class PokemonP3(
                 originalTrainerType,
                 originalTrainer,
                 forcedAspects.toSet(),
-                features,
+                nickname,
                 heldItemVisible,
                 canDropHeldItem,
                 cosmeticItem.orElse(ItemStack.EMPTY),
@@ -146,11 +128,7 @@ internal data class PokemonP3(
             pokemon.originalTrainerType,
             Optional.ofNullable(pokemon.originalTrainer),
             pokemon.forcedAspects,
-            pokemon.features.map { feature ->
-                val nbt = CompoundTag()
-                nbt.putString(FEATURE_ID, feature.name)
-                feature.saveToNBT(nbt)
-            },
+            Optional.ofNullable(pokemon.nickname),
             Optional.ofNullable(pokemon.heldItemVisible),
             Optional.ofNullable(pokemon.canDropHeldItem),
             pokemon.cosmeticItem,

common/src/main/resources/assets/cobblemon/lang/en_us.json

@@ -1350,6 +1350,8 @@
   "cobblemon.ui.pokedex.info.drops_range": "%1$s-%2$s×",
   "cobblemon.ui.pokedex.info.drops_percentage": "%1$s%%",
   "cobblemon.ui.pokedex.info.drops_empty": "No drops available.",
+  "cobblemon.ui.pokedex.info.evolution_tree": "Evolution Tree",
+
   "cobblemon.ui.pokedex.info.variation": "Variation",
   "cobblemon.ui.pokedex.info.form": "Form",
   "cobblemon.ui.pokedex.info.form.normal": "Standard",
@@ -1461,6 +1463,71 @@
   "cobblemon.ui.pokedex.unknown": "???",
   "cobblemon.ui.pokedex.weight": "Weight: %1$skg",
   "cobblemon.ui.pokedex.height": "Height: %1$sm",
+
+  "cobblemon.ui.pokedex.evolution.item_interact.tooltip": "Needs %1$s item to evolve",
+  "cobblemon.ui.pokedex.evolution.trade.tooltip.with_species": "Evolves when traded with %1$s",
+  "cobblemon.ui.pokedex.evolution.trade.tooltip.with_any_species": "Evolves when traded",
+  "cobblemon.ui.pokedex.evolution.shedder.tooltip": "Also requires a spare Poké Ball and an empty party slot",
+
+  "cobblemon.ui.pokedex.requirement.advancement.tooltip": "Player must have %1$s advancement",
+  "cobblemon.ui.pokedex.requirement.battle_critical_hits.tooltip": "Must hit %1$s critical-hits in battle",
+  "cobblemon.ui.pokedex.requirement.biome.anticondition.tooltip": "Must not be in the %1$s biome to evolve",
+  "cobblemon.ui.pokedex.requirement.biome.both.tooltip": "Must be in the %1$s biome and not in the %2$s biome to evolve",
+  "cobblemon.ui.pokedex.requirement.biome.tooltip": "Must be in the %1$s biome to evolve",
+  "cobblemon.ui.pokedex.requirement.blocks_traveled.tooltip": "Must travel %1$s blocks",
+  "cobblemon.ui.pokedex.requirement.damage_taken.tooltip": "Must take %1$s damage in battle without fainting",
+  "cobblemon.ui.pokedex.requirement.defeat.tooltip": "Must defeat %1$s in battle to evolve",
+  "cobblemon.ui.pokedex.requirement.friendship.tooltip": "Requires at least %1$s friendship",
+  "cobblemon.ui.pokedex.requirement.has_move.tooltip": "Must know move %1$s",
+  "cobblemon.ui.pokedex.requirement.has_move_type.tooltip": "Must know a move of type %1$s",
+  "cobblemon.ui.pokedex.requirement.held_item.tooltip": "Must be holding %1$s",
+  "cobblemon.ui.pokedex.requirement.level.tooltip.min": "Evolves starting at level %1$s",
+  "cobblemon.ui.pokedex.requirement.level.tooltip.between": "Evolves between levels %1$s and %2$s",
+  "cobblemon.ui.pokedex.requirement.moon_phase.tooltip": "Must evolve in %1$s moon phase",
+  "cobblemon.ui.pokedex.requirement.party_member.anticondition.tooltip": "Party must not have a Pokémon with %1$s",
+  "cobblemon.ui.pokedex.requirement.party_member.tooltip": "Party must have a Pokémon with %1$s",
+  "cobblemon.ui.pokedex.requirement.pokemon_properties.tooltip": "Must be %1$s",
+  "cobblemon.ui.pokedex.requirement.properties.and": "%1$s and %2$s",
+  "cobblemon.ui.pokedex.requirement.properties.custom.cocoon_species": "%1$s cocoon",
+  "cobblemon.ui.pokedex.requirement.properties.held_item": "holding %1$s",
+  "cobblemon.ui.pokedex.requirement.properties.int_feature": "%1$s %2$s",
+  "cobblemon.ui.pokedex.requirement.properties.nature": "%1$s nature",
+  "cobblemon.ui.pokedex.requirement.properties.nickname": "named %1$s",
+  "cobblemon.ui.pokedex.requirement.properties.type": "%1$s type",
+  "cobblemon.ui.pokedex.requirement.property_range.tooltip": "Requires %1$s between %2$s and %3$s",
+  "cobblemon.ui.pokedex.requirement.recoil.tooltip": "Must suffer %1$s units of recoil in battle",
+  "cobblemon.ui.pokedex.requirement.stat_compare.tooltip": "Must have its %1$s higher than its %2$s",
+  "cobblemon.ui.pokedex.requirement.stat_equal.tooltip": "Must have its %1$s equals to its %2$s",
+  "cobblemon.ui.pokedex.requirement.structure.anticondition.tooltip": "Must not be in the %1$s structure to evolve",
+  "cobblemon.ui.pokedex.requirement.structure.both.tooltip": "Must be in the %1$s structure and not in the %2$s structure to evolve",
+  "cobblemon.ui.pokedex.requirement.structure.tooltip": "Must be in the %1$s structure to evolve",
+  "cobblemon.ui.pokedex.requirement.time_range.tooltip": "Must evolve during the %1$s",
+  "cobblemon.ui.pokedex.requirement.use_move.tooltip": "Must use move %1$s in battle",
+  "cobblemon.ui.pokedex.requirement.weather.tooltip.raining": "Must be in rain to evolve",
+  "cobblemon.ui.pokedex.requirement.weather.tooltip.thundering": "Must be in a thunderstorm to evolve",
+
+  "cobblemon.ui.moon_phase.full_moon": "Full Moon",
+  "cobblemon.ui.moon_phase.waning_gibbous": "Waning Gibbous",
+  "cobblemon.ui.moon_phase.third_quarter": "Third Quarter",
+  "cobblemon.ui.moon_phase.waning_crescent": "Waning Crescent",
+  "cobblemon.ui.moon_phase.new_moon": "New Moon",
+  "cobblemon.ui.moon_phase.waxing_crescent": "Waxing Crescent",
+  "cobblemon.ui.moon_phase.first_quarter": "First Quarter",
+  "cobblemon.ui.moon_phase.waxing_gibbous": "Waxing Gibbous",
+
+  "cobblemon.ui.time_range.any": "Any",
+  "cobblemon.ui.time_range.day": "Day",
+  "cobblemon.ui.time_range.night": "Night",
+  "cobblemon.ui.time_range.noon": "Noon",
+  "cobblemon.ui.time_range.midnight": "Midnight",
+  "cobblemon.ui.time_range.dawn": "Dawn",
+  "cobblemon.ui.time_range.dusk": "Dusk",
+  "cobblemon.ui.time_range.twilight": "Twilight",
+  "cobblemon.ui.time_range.morning": "Morning",
+  "cobblemon.ui.time_range.afternoon": "Afternoon",
+  "cobblemon.ui.time_range.predawn": "Predawn",
+  "cobblemon.ui.time_range.evening": "Evening",
+
   "cobblemon.pokedex.variation.cream": "Cream",
   "cobblemon.pokedex.variation.decoration": "Decoration",
   "cobblemon.pokedex.variation.flower": "Flower",

common/src/main/resources/assets/cobblemon/sounds.json

@@ -977,6 +977,102 @@
       { "name": "cobblemon:block/item_block/paper_large_break_3", "volume": 0.6 }
     ]
   },
+  "block.item_block.bottle_liquid.place": {
+    "subtitle": "subtitles.block.generic.place",
+    "sounds": [
+      { "name": "cobblemon:block/item_block/bottle_liquid_place_1", "volume": 0.4 },
+      { "name": "cobblemon:block/item_block/bottle_liquid_place_2", "volume": 0.4 },
+      { "name": "cobblemon:block/item_block/bottle_liquid_place_3", "volume": 0.4 }
+    ]
+  },
+  "block.item_block.bottle_liquid.break": {
+    "subtitle": "subtitles.block.generic.break",
+    "sounds": [
+      { "name": "cobblemon:block/item_block/bottle_liquid_break_1", "volume": 0.5 },
+      { "name": "cobblemon:block/item_block/bottle_liquid_break_2", "volume": 0.5 },
+      { "name": "cobblemon:block/item_block/bottle_liquid_break_3", "volume": 0.5 }
+    ]
+  },
+  "block.item_block.bottle_liquid.step": {
+    "subtitle": "subtitles.block.generic.footsteps",
+    "sounds": [
+      { "name": "cobblemon:block/item_block/bottle_liquid_step_1", "volume": 0.2 },
+      { "name": "cobblemon:block/item_block/bottle_liquid_step_2", "volume": 0.2 },
+      { "name": "cobblemon:block/item_block/bottle_liquid_step_3", "volume": 0.2 }
+    ]
+  },
+  "block.item_block.bottle_pills.place": {
+    "subtitle": "subtitles.block.generic.place",
+    "sounds": [
+      { "name": "cobblemon:block/item_block/bottle_pills_place_1", "volume": 0.4 },
+      { "name": "cobblemon:block/item_block/bottle_pills_place_2", "volume": 0.4 },
+      { "name": "cobblemon:block/item_block/bottle_pills_place_3", "volume": 0.4 }
+    ]
+  },
+  "block.item_block.bottle_pills.break": {
+    "subtitle": "subtitles.block.generic.break",
+    "sounds": [
+      { "name": "cobblemon:block/item_block/bottle_pills_break_1", "volume": 0.5 },
+      { "name": "cobblemon:block/item_block/bottle_pills_break_2", "volume": 0.5 },
+      { "name": "cobblemon:block/item_block/bottle_pills_break_3", "volume": 0.5 }
+    ]
+  },
+  "block.item_block.bottle_pills.step": {
+    "subtitle": "subtitles.block.generic.footsteps",
+    "sounds": [
+      { "name": "cobblemon:block/item_block/bottle_pills_step_1", "volume": 0.2 },
+      { "name": "cobblemon:block/item_block/bottle_pills_step_2", "volume": 0.2 },
+      { "name": "cobblemon:block/item_block/bottle_pills_step_3", "volume": 0.2 }
+    ]
+  },
+  "block.item_block.powder.place": {
+    "subtitle": "subtitles.block.generic.place",
+    "sounds": [
+      { "name": "cobblemon:block/item_block/powder_place_1", "volume": 0.3 },
+      { "name": "cobblemon:block/item_block/powder_place_2", "volume": 0.3 },
+      { "name": "cobblemon:block/item_block/powder_place_3", "volume": 0.3 }
+    ]
+  },
+  "block.item_block.powder.break": {
+    "subtitle": "subtitles.block.generic.break",
+    "sounds": [
+      { "name": "cobblemon:block/item_block/powder_break_1", "volume": 0.4 },
+      { "name": "cobblemon:block/item_block/powder_break_2", "volume": 0.4 },
+      { "name": "cobblemon:block/item_block/powder_break_3", "volume": 0.4 }
+    ]
+  },
+  "block.item_block.powder.step": {
+    "subtitle": "subtitles.block.generic.footsteps",
+    "sounds": [
+      { "name": "cobblemon:block/item_block/powder_step_1", "volume": 0.2 },
+      { "name": "cobblemon:block/item_block/powder_step_2", "volume": 0.2 },
+      { "name": "cobblemon:block/item_block/powder_step_3", "volume": 0.2 }
+    ]
+  },
+  "block.item_block.dice.place": {
+    "subtitle": "subtitles.block.generic.place",
+    "sounds": [
+      { "name": "cobblemon:block/item_block/dice_place_1", "volume": 0.3 },
+      { "name": "cobblemon:block/item_block/dice_place_2", "volume": 0.3 },
+      { "name": "cobblemon:block/item_block/dice_place_3", "volume": 0.3 }
+    ]
+  },
+  "block.item_block.dice.break": {
+    "subtitle": "subtitles.block.generic.break",
+    "sounds": [
+      { "name": "cobblemon:block/item_block/dice_break_1", "volume": 0.4 },
+      { "name": "cobblemon:block/item_block/dice_break_2", "volume": 0.4 },
+      { "name": "cobblemon:block/item_block/dice_break_3", "volume": 0.4 }
+    ]
+  },
+  "block.item_block.dice.step": {
+    "subtitle": "subtitles.block.generic.footsteps",
+    "sounds": [
+      { "name": "cobblemon:block/item_block/dice_step_1", "volume": 0.2 },
+      { "name": "cobblemon:block/item_block/dice_step_2", "volume": 0.2 },
+      { "name": "cobblemon:block/item_block/dice_step_3", "volume": 0.2 }
+    ]
+  },
   "move.absorb.actor": {
     "sounds": [ { "name": "cobblemon:move/absorb/absorb_actor", "volume": 0.3 } ]
   },