docs: detail multi-Pokémon trading and trade UI changes in the changelog

Resolve conflicts with the trade dupe fix and per-OT trade friendship
caching by applying both to every Pokémon in a multi-Pokémon trade.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.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

@@ -3,8 +3,8 @@
 
 ### Additions
 - The following items can now be placed on the ground as blocks:
-  - King's Rock, Galarica Cuff, Unremarkable Teacup, Masterpiece Teacup, Chipped Pot, Cracked Pot, Sachet, Metal Powder, Quick Powder, Bright Powder, Icy Rock, Heat Rock, Smooth Rock, Damp Rock, Destiny Knot, Luminous Moss, Never-Melt Ice, Wide Lens, Scope Lens, and Zoom Lens.
-  - Iron Ball, Metal Coat, Throat Spray, HP Up, Protein, Iron, Carbos, Calcium, Zinc, PP Up, PP Max, Upgrade, Dubious Disc, and Loaded Dice.
+  - King's Rock, Galarica Cuff, Unremarkable Teacup, Masterpiece Teacup, Chipped Pot, Cracked Pot, Sachet, Metal Powder, Quick Powder, Bright Powder, Soft Sand, Electirizer, Magmarizer, Icy Rock, Heat Rock, Smooth Rock, Damp Rock, Destiny Knot, Luminous Moss, Never-Melt Ice, Wide Lens, Scope Lens, and Zoom Lens.
+  - Iron Ball, Metal Coat, Throat Spray, Terrain Extender, Medicinal Brew, Moomoo Milk, HP Up, Protein, Iron, Carbos, Calcium, Zinc, PP Up, PP Max, Upgrade, Dubious Disc, and Loaded Dice.
 - The following items can now be placed on various surfaces:
   - Galarica Wreath, Magnet, Flame Orb, Life Orb, Toxic Orb, Light Ball, and Smoke Ball.
 - The following items can now be placed as blocks and have additional functionality:
@@ -13,6 +13,12 @@
   - 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.
+- Mint Leaves can now be placed on the ground as Leaf Litter, or in Flower Pots
+- Added Oricorio Flowers
+- Added Terrain Plants
+- Berries can now be placed in Flower Pots
+- 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
@@ -35,12 +41,18 @@
 - Grubbin
 - Charjabug
 - Vikavolt
+- Minior
+
+#### Generation 8
+- Eternatus
 
 #### Generation 9
 - Greavard
 - Houndstone
 
 ### Model updates for the following Pokémon
+- Sudowoodo
+- Spheal
 - Cacnea
 - Cacturne
 - Binacle
@@ -50,18 +62,60 @@
 - Deerling
 - Sawsbuck (All forms)
 - Absol
+- Poliwag
+- Politoed
+- Ekans
+- Oddish
+- Gloom
+- Vileplume
+- Bellossom
+- Shroomish
 
 ### Animation updates for the following Pokémon
+- Treecko (New Shoulder Mount!)
+- Bonsly (New Shoulder Mount!)
+- Sudowoodo
 - Cacnea
 - Cacturne
+- Ekans
+- Arbok
+- Oddish
+- Gloom
+- Vileplume
+- Bellossom
 
 ### Changes
+- Restructured Botany Pots integration folder structure
+- Decrease default pastured mon wander radius to 32.
+- Factor in the weight of pokemon when calculating pushing forces between hitboxes.
+- Remade the Starter Selection Screen with new assets
+- Refactored berry trees to be less impactful on TPS (more performant)
+- Trading has been overhauled to allow offering multiple Pokémon, up to the entire party, in a single trade
+  - Selected Pokémon are now highlighted in both parties with new party slot assets
+  - Hovering an offered Pokémon now shows its summary, and clicking the active Pokémon no longer exits the summary view
+  - The trade animation now moves the offered Pokémon towards the Poké Ball
+  - Parties are compacted after a trade so no empty slots are left between Pokémon
+- Terrain Seeds can now be planted
+- Terrain Seeds are now consumed during PvP and NPC battles
+- Glow Item Frames can be crafted using Bright Powder as an alternative to Glow Ink Sacs
+- Bright Powder can be used on Signs and Hanging Signs to make text glow, as an alternative to Glow Ink Sacs
 - 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
+- Updated the following recipes
+  - Never-Melt Ice, Focus Sash, Blunder Policy, Weakness Policy, Blank TM
 - Make ride rotations less jittery in multiplayer.
+- Changes Disc Shelf TMs to use textures instead of tinting and overlays to line up with item display
+- Blank TM can now be inserted into the Disc Shelf
+- Added TM creative tab
+- 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
@@ -80,9 +134,30 @@
 - Fixed Duraludon line not having any sleep animations
 - Fixed Diglett line not having their faint animations
 - Fixed Kingambit moving its legs while walking
+- 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
+- Added `PokeSnackSpawnerFactory` which allows influence registration on PokeSnack encounters
+- Added `FishingSpawnerFactory` which allows influence registration on fishing encounters
+- Added `BattleFleeAttemptEvent` fired from `PokemonBattle.checkFleeAttempt`, allowing developers to intercept and control flee attempts
+- Trade network packets (`TradeUpdatedPacket`, `UpdateTradeOfferPacket`, and `TradeCompletedPacket`) now receive an array of Pokémon instead of a single Pokémon to execute trades
+- `TradeEvent.Pre` and `TradeEvent.Post` now expose every Pokémon each participant receives (`tradeParticipant1Pokemon` and `tradeParticipant2Pokemon` are now lists), and their Molang context includes `trade_participant_1_pokemon_list` and `trade_participant_2_pokemon_list`
+- 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.
@@ -93,4 +168,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/CobblemonBlockEntities.kt

@@ -109,4 +109,21 @@ object CobblemonBlockEntities : PlatformRegistry<Registry<BlockEntityType<*>>, R
         "poke_snack",
         BlockEntityType.Builder.of(::PokeSnackBlockEntity, CobblemonBlocks.POKE_SNACK, CobblemonBlocks.POKE_CAKE).build(null)
     )
+
+    @JvmField
+    val TERRAIN_PLANT: BlockEntityType<TerrainPlantBlockEntity> = this.create(
+        "terrain_plant",
+        BlockEntityType.Builder.of(::TerrainPlantBlockEntity,
+            CobblemonBlocks.VOLTACONIA,
+            CobblemonBlocks.LUCIBELL,
+            CobblemonBlocks.VERDROOT
+        ).build(null)
+    )
+    @JvmField
+    val MISTLEAF_FLOWER: BlockEntityType<MistleafFlowerBlockEntity> = this.create(
+        "mistleaf",
+        BlockEntityType.Builder.of(::MistleafFlowerBlockEntity,
+            CobblemonBlocks.MISTLEAF
+        ).build(null)
+    )
 }

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

@@ -16,8 +16,7 @@ import com.cobblemon.mod.common.block.MintBlock.MintType
 import com.cobblemon.mod.common.block.campfirepot.CampfireBlock
 import com.cobblemon.mod.common.block.campfirepot.CampfirePotBlock
 import com.cobblemon.mod.common.block.chest.GildedChestBlock
-import com.cobblemon.mod.common.block.decor.ActivatableDecorationBlock
-import com.cobblemon.mod.common.block.decor.RingTargetBlock
+import com.cobblemon.mod.common.block.decor.*
 import com.cobblemon.mod.common.block.general.BaleBlock
 import com.cobblemon.mod.common.block.general.HorizontalRotationCarpetBlock
 import com.cobblemon.mod.common.block.general.HorizontalRotationalBlock
@@ -28,6 +27,7 @@ import com.cobblemon.mod.common.block.sign.CobblemonSignBlock
 import com.cobblemon.mod.common.block.sign.CobblemonWallHangingSignBlock
 import com.cobblemon.mod.common.block.sign.CobblemonWallSignBlock
 import com.cobblemon.mod.common.block.tmmachine.TMMachineBlock
+import com.cobblemon.mod.common.block.general.MintLitterBlock
 import com.cobblemon.mod.common.mixin.invoker.BlocksInvoker
 import com.cobblemon.mod.common.mixin.invoker.DoorBlockInvoker
 import com.cobblemon.mod.common.mixin.invoker.FireBlockInvoker
@@ -653,15 +653,21 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     val CHIPPED_POT = create("chipped_pot", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.DECORATED_POT).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.TEAPOT))
     @JvmField
     val CRACKED_POT = create("cracked_pot", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.DECORATED_POT).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.TEAPOT))
+    @JvmField
+    val ELECTIRIZER = create("electirizer", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.IZER))
+    @JvmField
+    val MAGMARIZER = create("magmarizer", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.IZER))
 
     @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 SOFT_SAND = create("soft_sand", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_POWDER_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), 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 +697,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 +708,46 @@ 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 TERRAIN_EXTENDER = create("terrain_extender", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.EXTENDER))
+    @JvmField
+    val MOOMOO_MILK = create("moomoo_milk", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.GLASS_BOTTLE))
+    @JvmField
+    val MEDICINAL_BREW = create("medicinal_brew", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.GLASS_BOTTLE))
 
     @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 +767,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 }))
@@ -857,6 +869,64 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     @JvmField
     val POTTED_SACCHARINE_SAPLING = this.create("potted_saccharine_sapling", BlocksInvoker.createFlowerPotBlock(SACCHARINE_SAPLING))
 
+    @JvmField
+    val RED_MINT_LEAF_LITTER = this.mintLitter("red_mint_leaf_litter", MapColor.COLOR_RED)
+    @JvmField
+    val POTTED_RED_MINT = this.pottedPlant("potted_red_mint", RED_MINT_LEAF_LITTER)
+    @JvmField
+    val BLUE_MINT_LEAF_LITTER = this.mintLitter("blue_mint_leaf_litter", MapColor.COLOR_BLUE)
+    @JvmField
+    val POTTED_BLUE_MINT = this.pottedPlant("potted_blue_mint", BLUE_MINT_LEAF_LITTER)
+    @JvmField
+    val CYAN_MINT_LEAF_LITTER = this.mintLitter("cyan_mint_leaf_litter", MapColor.COLOR_CYAN)
+    @JvmField
+    val POTTED_CYAN_MINT = this.pottedPlant("potted_cyan_mint", CYAN_MINT_LEAF_LITTER)
+    @JvmField
+    val PINK_MINT_LEAF_LITTER = this.mintLitter("pink_mint_leaf_litter", MapColor.COLOR_PINK)
+    @JvmField
+    val POTTED_PINK_MINT = this.pottedPlant("potted_pink_mint", PINK_MINT_LEAF_LITTER)
+    @JvmField
+    val GREEN_MINT_LEAF_LITTER = this.mintLitter("green_mint_leaf_litter", MapColor.COLOR_GREEN)
+    @JvmField
+    val POTTED_GREEN_MINT = this.pottedPlant("potted_green_mint", GREEN_MINT_LEAF_LITTER)
+    @JvmField
+    val WHITE_MINT_LEAF_LITTER = this.mintLitter("white_mint_leaf_litter", MapColor.SNOW)
+    @JvmField
+    val POTTED_WHITE_MINT = this.pottedPlant("potted_white_mint", WHITE_MINT_LEAF_LITTER)
+
+    @JvmField
+    val LOBAILA = this.create("lobaila", LobailaFlowerBlock(BlockBehaviour.Properties.of().mapColor(MapColor.PLANT).noCollission().instabreak().sound(SoundType.GRASS).offsetType(BlockBehaviour.OffsetType.XZ).ignitedByLava().pushReaction(PushReaction.DESTROY)))
+    @JvmField
+    val POMOHANA = this.create("pomohana", PomohanaFlowerBlock(BlockBehaviour.Properties.of().mapColor(MapColor.PLANT).noCollission().instabreak().sound(SoundType.GRASS).ignitedByLava().pushReaction(PushReaction.DESTROY)))
+    @JvmField
+    val PAUVILLEA = this.create("pauvillea",PauvilleaFlowerBlock(BlockBehaviour.Properties.of().mapColor(MapColor.PLANT).noCollission().sound(SoundType.GRASS).instabreak().ignitedByLava().pushReaction(PushReaction.DESTROY)))
+    @JvmField
+    val WISTENSU = this.create("wistensu", WistensuFlowerHeadBlock(BlockBehaviour.Properties.of().mapColor(MapColor.PLANT).noCollission().sound(SoundType.GRASS).instabreak().ignitedByLava().pushReaction(PushReaction.DESTROY).lightLevel{11}))
+    @JvmField
+    val WISTENSU_VINE = this.create("wistensu_vine", WistensuFlowerVineBlock(BlockBehaviour.Properties.of().mapColor(MapColor.PLANT).noCollission().sound(SoundType.GRASS).instabreak().ignitedByLava().pushReaction(PushReaction.DESTROY)))
+
+    @JvmField
+    val ELECTRIC_SEED = this.terrainSeed("electric_seed", TerrainSeedBlock.TerrainSeedType.ELECTRIC)
+    @JvmField
+    val PSYCHIC_SEED = this.terrainSeed("psychic_seed", TerrainSeedBlock.TerrainSeedType.PSYCHIC)
+    @JvmField
+    val MISTY_SEED = this.terrainSeed("misty_seed", TerrainSeedBlock.TerrainSeedType.MISTY)
+    @JvmField
+    val GRASSY_SEED = this.terrainSeed("grassy_seed", TerrainSeedBlock.TerrainSeedType.GRASSY)
+    @JvmField
+    val VOLTACONIA = this.terrainPlant("voltaconia") { state -> if (state.getValue(TerrainPlantBlock.GLOWING)) 8 else 0 }
+    @JvmField
+    val VERDROOT = this.terrainPlant("verdroot") { state -> if (state.getValue(TerrainPlantBlock.GLOWING)) 5 else 0 }
+    @JvmField
+    val LUCIBELL = this.terrainPlant("lucibell") { state -> if (state.getValue(TerrainPlantBlock.GLOWING)) 8 else 0 }
+    @JvmField
+    val MISTLEAF = this.create(
+        "mistleaf",
+        MistleafFlowerBlock {
+            if ((it.getValue(MistleafFlowerBlock.GLOWING) >= 1)) it.getValue(MistleafFlowerBlock.GLOWING) + 2 else 0
+        }
+    )
+
     @JvmField
     val HEARTY_GRAIN_BALE = this.create("hearty_grain_bale", BaleBlock(BlockBehaviour.Properties.of().mapColor(MapColor.PLANT).instrument(NoteBlockInstrument.BANJO).strength(0.5F).sound(CobblemonSounds.HEARTY_GRAIN_BALE_SOUNDS)))
     @JvmField
@@ -1033,6 +1103,147 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     val YACHE_BERRY = this.berryBlock("yache")
     //val BINDING_SOIL = this.create("binding_soil", BindingSoilBlock(BlockBehaviour.Properties.of()))
 
+    @JvmField
+    val POTTED_AGUAV_BERRY = this.create("potted_aguav_berry", BlocksInvoker.createFlowerPotBlock(AGUAV_BERRY))
+    @JvmField
+    val POTTED_APICOT_BERRY = this.create("potted_apicot_berry", BlocksInvoker.createFlowerPotBlock(APICOT_BERRY))
+    @JvmField
+    val POTTED_ASPEAR_BERRY = this.create("potted_aspear_berry", BlocksInvoker.createFlowerPotBlock(ASPEAR_BERRY))
+    @JvmField
+    val POTTED_BABIRI_BERRY = this.create("potted_babiri_berry", BlocksInvoker.createFlowerPotBlock(BABIRI_BERRY))
+    @JvmField
+    val POTTED_BELUE_BERRY = this.create("potted_belue_berry", BlocksInvoker.createFlowerPotBlock(BELUE_BERRY))
+    @JvmField
+    val POTTED_BLUK_BERRY = this.create("potted_bluk_berry", BlocksInvoker.createFlowerPotBlock(BLUK_BERRY))
+    @JvmField
+    val POTTED_CHARTI_BERRY = this.create("potted_charti_berry", BlocksInvoker.createFlowerPotBlock(CHARTI_BERRY))
+    @JvmField
+    val POTTED_CHERI_BERRY = this.create("potted_cheri_berry", BlocksInvoker.createFlowerPotBlock(CHERI_BERRY))
+    @JvmField
+    val POTTED_CHESTO_BERRY = this.create("potted_chesto_berry", BlocksInvoker.createFlowerPotBlock(CHESTO_BERRY))
+    @JvmField
+    val POTTED_CHILAN_BERRY = this.create("potted_chilan_berry", BlocksInvoker.createFlowerPotBlock(CHILAN_BERRY))
+    @JvmField
+    val POTTED_CHOPLE_BERRY = this.create("potted_chople_berry", BlocksInvoker.createFlowerPotBlock(CHOPLE_BERRY))
+    @JvmField
+    val POTTED_COBA_BERRY = this.create("potted_coba_berry", BlocksInvoker.createFlowerPotBlock(COBA_BERRY))
+    @JvmField
+    val POTTED_COLBUR_BERRY = this.create("potted_colbur_berry", BlocksInvoker.createFlowerPotBlock(COLBUR_BERRY))
+    @JvmField
+    val POTTED_CORNN_BERRY = this.create("potted_cornn_berry", BlocksInvoker.createFlowerPotBlock(CORNN_BERRY))
+    @JvmField
+    val POTTED_CUSTAP_BERRY = this.create("potted_custap_berry", BlocksInvoker.createFlowerPotBlock(CUSTAP_BERRY))
+    @JvmField
+    val POTTED_DURIN_BERRY = this.create("potted_durin_berry", BlocksInvoker.createFlowerPotBlock(DURIN_BERRY))
+    @JvmField
+    val POTTED_EGGANT_BERRY = this.create("potted_eggant_berry", BlocksInvoker.createFlowerPotBlock(EGGANT_BERRY))
+    @JvmField
+    val POTTED_ENIGMA_BERRY = this.create("potted_enigma_berry", BlocksInvoker.createFlowerPotBlock(ENIGMA_BERRY))
+    @JvmField
+    val POTTED_FIGY_BERRY = this.create("potted_figy_berry", BlocksInvoker.createFlowerPotBlock(FIGY_BERRY))
+    @JvmField
+    val POTTED_GANLON_BERRY = this.create("potted_ganlon_berry", BlocksInvoker.createFlowerPotBlock(GANLON_BERRY))
+    @JvmField
+    val POTTED_GREPA_BERRY = this.create("potted_grepa_berry", BlocksInvoker.createFlowerPotBlock(GREPA_BERRY))
+    @JvmField
+    val POTTED_HABAN_BERRY = this.create("potted_haban_berry", BlocksInvoker.createFlowerPotBlock(HABAN_BERRY))
+    @JvmField
+    val POTTED_HONDEW_BERRY = this.create("potted_hondew_berry", BlocksInvoker.createFlowerPotBlock(HONDEW_BERRY))
+    @JvmField
+    val POTTED_HOPO_BERRY = this.create("potted_hopo_berry", BlocksInvoker.createFlowerPotBlock(HOPO_BERRY))
+    @JvmField
+    val POTTED_IAPAPA_BERRY = this.create("potted_iapapa_berry", BlocksInvoker.createFlowerPotBlock(IAPAPA_BERRY))
+    @JvmField
+    val POTTED_JABOCA_BERRY = this.create("potted_jaboca_berry", BlocksInvoker.createFlowerPotBlock(JABOCA_BERRY))
+    @JvmField
+    val POTTED_KASIB_BERRY = this.create("potted_kasib_berry", BlocksInvoker.createFlowerPotBlock(KASIB_BERRY))
+    @JvmField
+    val POTTED_KEBIA_BERRY = this.create("potted_kebia_berry", BlocksInvoker.createFlowerPotBlock(KEBIA_BERRY))
+    @JvmField
+    val POTTED_KEE_BERRY = this.create("potted_kee_berry", BlocksInvoker.createFlowerPotBlock(KEE_BERRY))
+    @JvmField
+    val POTTED_KELPSY_BERRY = this.create("potted_kelpsy_berry", BlocksInvoker.createFlowerPotBlock(KELPSY_BERRY))
+    @JvmField
+    val POTTED_LANSAT_BERRY = this.create("potted_lansat_berry", BlocksInvoker.createFlowerPotBlock(LANSAT_BERRY))
+    @JvmField
+    val POTTED_LEPPA_BERRY = this.create("potted_leppa_berry", BlocksInvoker.createFlowerPotBlock(LEPPA_BERRY))
+    @JvmField
+    val POTTED_LIECHI_BERRY = this.create("potted_liechi_berry", BlocksInvoker.createFlowerPotBlock(LIECHI_BERRY))
+    @JvmField
+    val POTTED_LUM_BERRY = this.create("potted_lum_berry", BlocksInvoker.createFlowerPotBlock(LUM_BERRY))
+    @JvmField
+    val POTTED_MAGO_BERRY = this.create("potted_mago_berry", BlocksInvoker.createFlowerPotBlock(MAGO_BERRY))
+    @JvmField
+    val POTTED_MAGOST_BERRY = this.create("potted_magost_berry", BlocksInvoker.createFlowerPotBlock(MAGOST_BERRY))
+    @JvmField
+    val POTTED_MARANGA_BERRY = this.create("potted_maranga_berry", BlocksInvoker.createFlowerPotBlock(MARANGA_BERRY))
+    @JvmField
+    val POTTED_MICLE_BERRY = this.create("potted_micle_berry", BlocksInvoker.createFlowerPotBlock(MICLE_BERRY))
+    @JvmField
+    val POTTED_NANAB_BERRY = this.create("potted_nanab_berry", BlocksInvoker.createFlowerPotBlock(NANAB_BERRY))
+    @JvmField
+    val POTTED_NOMEL_BERRY = this.create("potted_nomel_berry", BlocksInvoker.createFlowerPotBlock(NOMEL_BERRY))
+    @JvmField
+    val POTTED_OCCA_BERRY = this.create("potted_occa_berry", BlocksInvoker.createFlowerPotBlock(OCCA_BERRY))
+    @JvmField
+    val POTTED_ORAN_BERRY = this.create("potted_oran_berry", BlocksInvoker.createFlowerPotBlock(ORAN_BERRY))
+    @JvmField
+    val POTTED_PAMTRE_BERRY = this.create("potted_pamtre_berry", BlocksInvoker.createFlowerPotBlock(PAMTRE_BERRY))
+    @JvmField
+    val POTTED_PASSHO_BERRY = this.create("potted_passho_berry", BlocksInvoker.createFlowerPotBlock(PASSHO_BERRY))
+    @JvmField
+    val POTTED_PAYAPA_BERRY = this.create("potted_payapa_berry", BlocksInvoker.createFlowerPotBlock(PAYAPA_BERRY))
+    @JvmField
+    val POTTED_PECHA_BERRY = this.create("potted_pecha_berry", BlocksInvoker.createFlowerPotBlock(PECHA_BERRY))
+    @JvmField
+    val POTTED_PERSIM_BERRY = this.create("potted_persim_berry", BlocksInvoker.createFlowerPotBlock(PERSIM_BERRY))
+    @JvmField
+    val POTTED_PETAYA_BERRY = this.create("potted_petaya_berry", BlocksInvoker.createFlowerPotBlock(PETAYA_BERRY))
+    @JvmField
+    val POTTED_PINAP_BERRY = this.create("potted_pinap_berry", BlocksInvoker.createFlowerPotBlock(PINAP_BERRY))
+    @JvmField
+    val POTTED_POMEG_BERRY = this.create("potted_pomeg_berry", BlocksInvoker.createFlowerPotBlock(POMEG_BERRY))
+    @JvmField
+    val POTTED_QUALOT_BERRY = this.create("potted_qualot_berry", BlocksInvoker.createFlowerPotBlock(QUALOT_BERRY))
+    @JvmField
+    val POTTED_RABUTA_BERRY = this.create("potted_rabuta_berry", BlocksInvoker.createFlowerPotBlock(RABUTA_BERRY))
+    @JvmField
+    val POTTED_RAWST_BERRY = this.create("potted_rawst_berry", BlocksInvoker.createFlowerPotBlock(RAWST_BERRY))
+    @JvmField
+    val POTTED_RAZZ_BERRY = this.create("potted_razz_berry", BlocksInvoker.createFlowerPotBlock(RAZZ_BERRY))
+    @JvmField
+    val POTTED_RINDO_BERRY = this.create("potted_rindo_berry", BlocksInvoker.createFlowerPotBlock(RINDO_BERRY))
+    @JvmField
+    val POTTED_ROSELI_BERRY = this.create("potted_roseli_berry", BlocksInvoker.createFlowerPotBlock(ROSELI_BERRY))
+    @JvmField
+    val POTTED_ROWAP_BERRY = this.create("potted_rowap_berry", BlocksInvoker.createFlowerPotBlock(ROWAP_BERRY))
+    @JvmField
+    val POTTED_SALAC_BERRY = this.create("potted_salac_berry", BlocksInvoker.createFlowerPotBlock(SALAC_BERRY))
+    @JvmField
+    val POTTED_SHUCA_BERRY = this.create("potted_shuca_berry", BlocksInvoker.createFlowerPotBlock(SHUCA_BERRY))
+    @JvmField
+    val POTTED_SITRUS_BERRY = this.create("potted_sitrus_berry", BlocksInvoker.createFlowerPotBlock(SITRUS_BERRY))
+    @JvmField
+    val POTTED_SPELON_BERRY = this.create("potted_spelon_berry", BlocksInvoker.createFlowerPotBlock(SPELON_BERRY))
+    @JvmField
+    val POTTED_STARF_BERRY = this.create("potted_starf_berry", BlocksInvoker.createFlowerPotBlock(STARF_BERRY))
+    @JvmField
+    val POTTED_TAMATO_BERRY = this.create("potted_tamato_berry", BlocksInvoker.createFlowerPotBlock(TAMATO_BERRY))
+    @JvmField
+    val POTTED_TANGA_BERRY = this.create("potted_tanga_berry", BlocksInvoker.createFlowerPotBlock(TANGA_BERRY))
+    @JvmField
+    val POTTED_TOUGA_BERRY = this.create("potted_touga_berry", BlocksInvoker.createFlowerPotBlock(TOUGA_BERRY))
+    @JvmField
+    val POTTED_WACAN_BERRY = this.create("potted_wacan_berry", BlocksInvoker.createFlowerPotBlock(WACAN_BERRY))
+    @JvmField
+    val POTTED_WATMEL_BERRY = this.create("potted_watmel_berry", BlocksInvoker.createFlowerPotBlock(WATMEL_BERRY))
+    @JvmField
+    val POTTED_WEPEAR_BERRY = this.create("potted_wepear_berry", BlocksInvoker.createFlowerPotBlock(WEPEAR_BERRY))
+    @JvmField
+    val POTTED_WIKI_BERRY = this.create("potted_wiki_berry", BlocksInvoker.createFlowerPotBlock(WIKI_BERRY))
+    @JvmField
+    val POTTED_YACHE_BERRY = this.create("potted_yache_berry", BlocksInvoker.createFlowerPotBlock(YACHE_BERRY))
+
     init {
         /**
          * Makes all blocks in array flammable by adding them to FireBlock's flammableRegistry.
@@ -1134,4 +1345,48 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     }
 
     fun typeGemClusters() = typeGemClusters.toMap()
+
+    private fun pottedPlant(name: String, flower: Block) = this.create(name, BlocksInvoker.createFlowerPotBlock(flower))
+
+    private fun mintLitter(name: String, color: MapColor) = this.create(
+        name,
+        MintLitterBlock(
+            BlockBehaviour.Properties.of()
+                .sound(CobblemonSounds.MINT_SOUNDS)
+                .mapColor(color)
+                .noOcclusion()
+                .noCollission()
+                .pushReaction(PushReaction.DESTROY)
+        )
+    )
+
+    private fun terrainSeed(name: String, type: TerrainSeedBlock.TerrainSeedType) = this.create(
+        name,
+        TerrainSeedBlock(
+            type,
+            BlockBehaviour.Properties.of()
+                .pushReaction(PushReaction.DESTROY)
+                .ignitedByLava()
+                .mapColor(MapColor.PLANT)
+                .offsetType(BlockBehaviour.OffsetType.XZ)
+                .noCollission()
+                .randomTicks()
+                .instabreak()
+        )
+    )
+
+    private fun terrainPlant(name: String, lightLevel: (BlockState) -> Int) = this.create(
+        name,
+        TerrainPlantBlock(
+            BlockBehaviour.Properties.of()
+                .mapColor(MapColor.PLANT)
+                .noCollission()
+                .instabreak()
+                .sound(SoundType.GRASS)
+                .offsetType(BlockBehaviour.OffsetType.XZ)
+                .ignitedByLava()
+                .pushReaction(PushReaction.DESTROY)
+                .lightLevel(lightLevel)
+        )
+    )
 }

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

@@ -477,8 +477,8 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField val DUBIOUS_DISC = itemNameBlockItem("dubious_disc", CobblemonBlocks.DUBIOUS_DISC)
     @JvmField val DEEP_SEA_SCALE = noSettingsItem("deep_sea_scale")
     @JvmField val DEEP_SEA_TOOTH = noSettingsItem("deep_sea_tooth")
-    @JvmField val ELECTIRIZER = noSettingsItem("electirizer")
-    @JvmField val MAGMARIZER = noSettingsItem("magmarizer")
+    @JvmField val ELECTIRIZER = itemNameBlockItem("electirizer", CobblemonBlocks.ELECTIRIZER)
+    @JvmField val MAGMARIZER = itemNameBlockItem("magmarizer", CobblemonBlocks.MAGMARIZER)
     @JvmField val OVAL_STONE = noSettingsItem("oval_stone")
     @JvmField val PROTECTOR = noSettingsItem("protector")
     @JvmField val REAPER_CLOTH = noSettingsItem("reaper_cloth")
@@ -711,7 +711,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val PEP_UP_FLOWER = compostableBlockItem("pep_up_flower", CobblemonBlocks.PEP_UP_FLOWER)
     @JvmField
-    val MEDICINAL_BREW = noSettingsItem("medicinal_brew")
+    val MEDICINAL_BREW = itemNameBlockItem("medicinal_brew", CobblemonBlocks.MEDICINAL_BREW)
     @JvmField
     val REMEDY = compostableItem("remedy", RemedyItem(RemedyItem.NORMAL), 0.65f)
     @JvmField
@@ -719,7 +719,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val SUPERB_REMEDY = compostableItem("superb_remedy", RemedyItem(RemedyItem.SUPERB), 1f)
     @JvmField
-    val MOOMOO_MILK = create("moomoo_milk", MoomooMilk(Item.Properties().craftRemainder(Items.GLASS_BOTTLE).stacksTo((16))))
+    val MOOMOO_MILK = create("moomoo_milk", MoomooMilk(Item.Properties().craftRemainder(Items.GLASS_BOTTLE).stacksTo((16)), CobblemonBlocks.MOOMOO_MILK))
 
     @JvmField
     val POTION = create("potion", PotionItem(PotionType.POTION, CobblemonBlocks.POTION))
@@ -748,27 +748,27 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val RED_MINT_SEEDS = mintSeed("red", MintType.RED.getCropBlock())
     @JvmField
-    val RED_MINT_LEAF = mintLeaf("red", MintLeafItem(MintType.RED))
+    val RED_MINT_LEAF = compostableItemNameBlockItem("red_mint_leaf", CobblemonBlocks.RED_MINT_LEAF_LITTER, 0.50f)
     @JvmField
     val BLUE_MINT_SEEDS = mintSeed("blue", MintType.BLUE.getCropBlock())
     @JvmField
-    val BLUE_MINT_LEAF = mintLeaf("blue", MintLeafItem(MintType.BLUE))
+    val BLUE_MINT_LEAF = compostableItemNameBlockItem("blue_mint_leaf", CobblemonBlocks.BLUE_MINT_LEAF_LITTER, 0.50f)
     @JvmField
     val CYAN_MINT_SEEDS = mintSeed("cyan", MintType.CYAN.getCropBlock())
     @JvmField
-    val CYAN_MINT_LEAF = mintLeaf("cyan", MintLeafItem(MintType.CYAN))
+    val CYAN_MINT_LEAF = compostableItemNameBlockItem("cyan_mint_leaf", CobblemonBlocks.CYAN_MINT_LEAF_LITTER, 0.50f)
     @JvmField
     val PINK_MINT_SEEDS = mintSeed("pink", MintType.PINK.getCropBlock())
     @JvmField
-    val PINK_MINT_LEAF = mintLeaf("pink", MintLeafItem(MintType.PINK))
+    val PINK_MINT_LEAF = compostableItemNameBlockItem("pink_mint_leaf", CobblemonBlocks.PINK_MINT_LEAF_LITTER, 0.50f)
     @JvmField
     val GREEN_MINT_SEEDS = mintSeed("green", MintType.GREEN.getCropBlock())
     @JvmField
-    val GREEN_MINT_LEAF = mintLeaf("green", MintLeafItem(MintType.GREEN))
+    val GREEN_MINT_LEAF = compostableItemNameBlockItem("green_mint_leaf", CobblemonBlocks.GREEN_MINT_LEAF_LITTER, 0.50f)
     @JvmField
     val WHITE_MINT_SEEDS = mintSeed("white", MintType.WHITE.getCropBlock())
     @JvmField
-    val WHITE_MINT_LEAF = mintLeaf("white", MintLeafItem(MintType.WHITE))
+    val WHITE_MINT_LEAF = compostableItemNameBlockItem("white_mint_leaf", CobblemonBlocks.WHITE_MINT_LEAF_LITTER, 0.50f)
 
     val mints = mutableMapOf<String, MintItem>()
 
@@ -969,7 +969,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val EJECT_PACK = heldItem("eject_pack")
     @JvmField
-    val ELECTRIC_SEED = heldItem("electric_seed")
+    val ELECTRIC_SEED = itemNameBlockItem("electric_seed", CobblemonBlocks.ELECTRIC_SEED)
     @JvmField
     val EVERSTONE = heldItem("everstone")
     @JvmField
@@ -985,7 +985,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val FOCUS_SASH = heldItem("focus_sash")
     @JvmField
-    val GRASSY_SEED = heldItem("grassy_seed")
+    val GRASSY_SEED = itemNameBlockItem("grassy_seed", CobblemonBlocks.GRASSY_SEED)
     @JvmField
     val GRIP_CLAW = heldItem("grip_claw")
     @JvmField
@@ -1033,7 +1033,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val POWER_WEIGHT = heldItem("power_weight")
     @JvmField
-    val PSYCHIC_SEED = heldItem("psychic_seed")
+    val PSYCHIC_SEED = itemNameBlockItem("psychic_seed", CobblemonBlocks.PSYCHIC_SEED)
     @JvmField
     val PROTECTIVE_PADS = heldItem("protective_pads")
     @JvmField
@@ -1057,7 +1057,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val SILVER_POWDER = heldItem("silver_powder")
     @JvmField
-    val SOFT_SAND = heldItem("soft_sand")
+    val SOFT_SAND = itemNameBlockItem("soft_sand", CobblemonBlocks.SOFT_SAND)
     @JvmField
     val SMOKE_BALL = itemNameBlockItem("smoke_ball", CobblemonBlocks.SMOKE_BALL)
     @JvmField
@@ -1065,7 +1065,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val STICKY_BARB = heldItem("sticky_barb")
     @JvmField
-    val TERRAIN_EXTENDER = heldItem("terrain_extender")
+    val TERRAIN_EXTENDER = itemNameBlockItem("terrain_extender", CobblemonBlocks.TERRAIN_EXTENDER)
     @JvmField
     val THROAT_SPRAY = itemNameBlockItem("throat_spray", CobblemonBlocks.THROAT_SPRAY)
     @JvmField
@@ -1085,13 +1085,13 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val MIRROR_HERB = compostableHeldItem("mirror_herb", null, 0.85F)
     @JvmField
-    val MISTY_SEED = heldItem("misty_seed")
+    val MISTY_SEED = itemNameBlockItem("misty_seed", CobblemonBlocks.MISTY_SEED)
     @JvmField
     val POWER_HERB = compostableHeldItem("power_herb", null, 0.85F)
     @JvmField
     val WHITE_HERB = compostableHeldItem("white_herb", null, 0.85F)
     @JvmField
-    val BRIGHT_POWDER = itemNameBlockItem("bright_powder", CobblemonBlocks.BRIGHT_POWDER)
+    val BRIGHT_POWDER = glowItem("bright_powder", CobblemonBlocks.BRIGHT_POWDER)
     @JvmField
     val METAL_POWDER = itemNameBlockItem("metal_powder", CobblemonBlocks.METAL_POWDER)
     @JvmField
@@ -1103,7 +1103,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val SMOOTH_ROCK = itemNameBlockItem("smooth_rock", CobblemonBlocks.SMOOTH_ROCK)
     @JvmField
-    val ICY_ROCK = itemNameBlockItem("icy_rock", CobblemonBlocks.ICY_ROCK)
+    val ICY_ROCK = heldItem("icy_rock")
 
     // Mulch
     @JvmField
@@ -1558,6 +1558,25 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     //@JvmField
     //val BINDING_SOIL = blockItem("binding_soil", CobblemonBlocks.BINDING_SOIL)
 
+    // Plants, Flora, and Flowers
+    @JvmField
+    val LOBAILA = compostableBlockItem("lobaila", CobblemonBlocks.LOBAILA, 0.65f)
+    @JvmField
+    val POMOHANA = compostableBlockItem("pomohana", CobblemonBlocks.POMOHANA, 0.3f)
+    @JvmField
+    val PAUVILLEA = compostableBlockItem("pauvillea", CobblemonBlocks.PAUVILLEA, 0.65f)
+    @JvmField
+    val WISTENSU = compostableBlockItem("wistensu", CobblemonBlocks.WISTENSU, 0.5f)
+
+    @JvmField
+    val VOLTACONIA = compostableBlockItem("voltaconia", CobblemonBlocks.VOLTACONIA, 0.85f)
+    @JvmField
+    val VERDROOT = compostableBlockItem("verdroot", CobblemonBlocks.VERDROOT, 0.85f)
+    @JvmField
+    val MISTLEAF = compostableBlockItem("mistleaf", CobblemonBlocks.MISTLEAF, 0.85f)
+    @JvmField
+    val LUCIBELL = compostableBlockItem("lucibell", CobblemonBlocks.LUCIBELL, 0.85f)
+
     private fun blockItem(name: String, block: Block, rarity: Rarity = Rarity.COMMON): BlockItem = this.create(name, BlockItem(block, Item.Properties().rarity(rarity)))
 
     private fun itemNameBlockItem(name: String, block: Block, rarity: Rarity = Rarity.COMMON): ItemNameBlockItem = this.create(name, ItemNameBlockItem(block, Item.Properties().rarity(rarity)))
@@ -1760,4 +1779,6 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     private fun foodItem(nutrition: Int, saturationModifier: Float): Item {
         return CobblemonItem(Item.Properties().food(FoodProperties.Builder().nutrition(nutrition).saturationModifier(saturationModifier).build()))
     }
+
+    private fun glowItem(name: String, block: Block): GlowItem  = this.create(name, GlowItem(block, Item.Properties()))
 }

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

@@ -148,6 +148,9 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
     @JvmField
     val MONITOR_GLITCHING = this.create("block.monitor.glitching")
 
+    @JvmField
+    val BRIGHT_POWDER_USE = this.create("block.bright_powder.use")
+
     @JvmField
     val FOSSIL_MACHINE_ACTIVATE = this.create("block.fossil_machine.activate")
     @JvmField
@@ -657,5 +660,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/events/pokemon/TradeEvent.kt

@@ -9,12 +9,14 @@
 package com.cobblemon.mod.common.api.events.pokemon
 
 import com.bedrockk.molang.runtime.value.DoubleValue
+import com.bedrockk.molang.runtime.value.MoValue
 import com.cobblemon.mod.common.api.events.Cancelable
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.trade.TradeParticipant
+import com.cobblemon.mod.common.util.asArrayValue
 import com.cobblemon.mod.common.util.getPlayer
 
 /**
@@ -31,9 +33,9 @@ interface TradeEvent {
     val tradeParticipant1: TradeParticipant
 
     /**
-     * The [Pokemon] being traded by the first participant.
+     * All the [Pokemon] the first participant receives in the trade.
      */
-    val tradeParticipant1Pokemon: Pokemon
+    val tradeParticipant1Pokemon: List<Pokemon>
 
     /**
      * The second [TradeParticipant].
@@ -41,9 +43,19 @@ interface TradeEvent {
     val tradeParticipant2: TradeParticipant
 
     /**
-     * The [Pokemon] being traded by the second participant.
+     * All the [Pokemon] the second participant receives in the trade.
      */
-    val tradeParticipant2Pokemon: Pokemon
+    val tradeParticipant2Pokemon: List<Pokemon>
+
+    fun createContext(): MutableMap<String, MoValue> = mutableMapOf(
+        "trade_participant_1" to (tradeParticipant1.uuid.getPlayer()?.asMoLangValue() ?: DoubleValue.ZERO),
+        "trade_participant_2" to (tradeParticipant2.uuid.getPlayer()?.asMoLangValue() ?: DoubleValue.ZERO),
+        // Kept for backwards compatibility, this is the first Pokémon of each side.
+        "trade_participant_1_pokemon" to tradeParticipant1Pokemon.first().struct,
+        "trade_participant_2_pokemon" to tradeParticipant2Pokemon.first().struct,
+        "trade_participant_1_pokemon_list" to tradeParticipant1Pokemon.asArrayValue { it.struct },
+        "trade_participant_2_pokemon_list" to tradeParticipant2Pokemon.asArrayValue { it.struct }
+    )
 
     /**
      * Event fired when a trade is about to happen. Cancelling this event prevents the trade from occurring.
@@ -53,16 +65,11 @@ interface TradeEvent {
      */
     data class Pre(
         override val tradeParticipant1: TradeParticipant,
-        override val tradeParticipant1Pokemon: Pokemon,
+        override val tradeParticipant1Pokemon: List<Pokemon>,
         override val tradeParticipant2: TradeParticipant,
-        override val tradeParticipant2Pokemon: Pokemon
+        override val tradeParticipant2Pokemon: List<Pokemon>
     ) : TradeEvent, Cancelable() {
-        val context = mutableMapOf(
-            "trade_participant_1" to (tradeParticipant1.uuid.getPlayer()?.asMoLangValue() ?: DoubleValue.ZERO),
-            "trade_participant_2" to (tradeParticipant2.uuid.getPlayer()?.asMoLangValue() ?: DoubleValue.ZERO),
-            "trade_participant_1_pokemon" to tradeParticipant1Pokemon.struct,
-            "trade_participant_2_pokemon" to tradeParticipant2Pokemon.struct
-        )
+        val context = createContext()
 
         val functions = moLangFunctionMap(
             cancelFunc
@@ -77,15 +84,10 @@ interface TradeEvent {
      */
     data class Post(
         override val tradeParticipant1: TradeParticipant,
-        override val tradeParticipant1Pokemon: Pokemon,
+        override val tradeParticipant1Pokemon: List<Pokemon>,
         override val tradeParticipant2: TradeParticipant,
-        override val tradeParticipant2Pokemon: Pokemon
+        override val tradeParticipant2Pokemon: List<Pokemon>
     ) : TradeEvent {
-        val context = mutableMapOf(
-            "trade_participant_1" to (tradeParticipant1.uuid.getPlayer()?.asMoLangValue() ?: DoubleValue.ZERO),
-            "trade_participant_2" to (tradeParticipant2.uuid.getPlayer()?.asMoLangValue() ?: DoubleValue.ZERO),
-            "trade_participant_1_pokemon" to tradeParticipant1Pokemon.struct,
-            "trade_participant_2_pokemon" to tradeParticipant2Pokemon.struct
-        )
+        val context = createContext()
     }
 }

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/api/types/ElementalType.kt

@@ -34,6 +34,7 @@ class ElementalType(
     val resourceLocation: ResourceLocation = ResourceLocation.fromNamespaceAndPath(Cobblemon.MODID, "ui/types.png"),
     val showdownId: String = ShowdownIdentifiable.REGEX.replace(name.lowercase(), ""),
     val typeGem: ResourceLocation = ResourceLocation.fromNamespaceAndPath(Cobblemon.MODID, showdownId + "_gem"),
+    val order: Int = 1000
     ) : ShowdownIdentifiable {
 
     override fun showdownId(): String {

common/src/main/kotlin/com/cobblemon/mod/common/api/types/ElementalTypes.kt

@@ -25,7 +25,8 @@ object ElementalTypes {
         hue = 0xE8E8DA,
         textureXMultiplier = 0,
         primaryColor = 0x8FA689,
-        secondaryColor = 0xFFFBE2
+        secondaryColor = 0xFFFBE2,
+        order = 0
     )
 
     @JvmField
@@ -35,7 +36,8 @@ object ElementalTypes {
         hue = 0xFF6E21,
         textureXMultiplier = 1,
         primaryColor = 0xF92D2D,
-        secondaryColor = 0xF99B1D
+        secondaryColor = 0xF99B1D,
+        order = 1
     )
 
     @JvmField
@@ -45,7 +47,8 @@ object ElementalTypes {
         hue = 0x3FA5FF,
         textureXMultiplier = 2,
         primaryColor = 0x377AF6,
-        secondaryColor = 0x50DDF9
+        secondaryColor = 0x50DDF9,
+        order = 2
     )
 
     @JvmField
@@ -55,7 +58,8 @@ object ElementalTypes {
         hue = 0x62D14F,
         textureXMultiplier = 3,
         primaryColor = 0x0EAE95,
-        secondaryColor = 0xC6F554
+        secondaryColor = 0xC6F554,
+        order = 3
     )
 
     @JvmField
@@ -65,7 +69,8 @@ object ElementalTypes {
         hue = 0xFFD314,
         textureXMultiplier = 4,
         primaryColor = 0xF7AB19,
-        secondaryColor = 0xFFF257
+        secondaryColor = 0xFFF257,
+        order = 4
     )
 
     @JvmField
@@ -75,7 +80,8 @@ object ElementalTypes {
         hue = 0x54F2F2,
         textureXMultiplier = 5,
         primaryColor = 0x41BAED,
-        secondaryColor = 0x91F4F9
+        secondaryColor = 0x91F4F9,
+        order = 5
     )
 
     @JvmField
@@ -85,7 +91,8 @@ object ElementalTypes {
         hue = 0xEF565D,
         textureXMultiplier = 6,
         primaryColor = 0xC8356B,
-        secondaryColor = 0xF36A3F
+        secondaryColor = 0xF36A3F,
+        order = 6
     )
 
     @JvmField
@@ -95,7 +102,8 @@ object ElementalTypes {
         hue = 0xD651FF,
         textureXMultiplier = 7,
         primaryColor = 0x7B41DD,
-        secondaryColor = 0xE568F4
+        secondaryColor = 0xE568F4,
+        order = 7
     )
 
     @JvmField
@@ -105,7 +113,8 @@ object ElementalTypes {
         hue = 0xF4A453,
         textureXMultiplier = 8,
         primaryColor = 0xE08835,
-        secondaryColor = 0xFFD057
+        secondaryColor = 0xFFD057,
+        order = 8
     )
 
     @JvmField
@@ -115,7 +124,8 @@ object ElementalTypes {
         hue = 0xB8B2FF,
         textureXMultiplier = 9,
         primaryColor = 0x6083F6,
-        secondaryColor = 0xD5CCFA
+        secondaryColor = 0xD5CCFA,
+        order = 9
     )
 
     @JvmField
@@ -125,7 +135,8 @@ object ElementalTypes {
         hue = 0xFF5E9E,
         textureXMultiplier = 10,
         primaryColor = 0xE553CE,
-        secondaryColor = 0xF69DD5
+        secondaryColor = 0xF69DD5,
+        order = 10
     )
 
     @JvmField
@@ -135,7 +146,8 @@ object ElementalTypes {
         hue = 0xD3D319,
         textureXMultiplier = 11,
         primaryColor = 0x9FBE1B,
-        secondaryColor = 0xE9FB5B
+        secondaryColor = 0xE9FB5B,
+        order = 11
     )
 
     @JvmField
@@ -145,7 +157,8 @@ object ElementalTypes {
         hue = 0xB7A16E,
         textureXMultiplier = 12,
         primaryColor = 0x9F814A,
-        secondaryColor = 0xEECB7A
+        secondaryColor = 0xEECB7A,
+        order = 12
     )
 
     @JvmField
@@ -155,7 +168,8 @@ object ElementalTypes {
         hue = 0x9C80F7,
         textureXMultiplier = 13,
         primaryColor = 0x4F57DD,
-        secondaryColor = 0xC182F1
+        secondaryColor = 0xC182F1,
+        order = 13
     )
 
     @JvmField
@@ -165,7 +179,8 @@ object ElementalTypes {
         hue = 0x7580FF,
         textureXMultiplier = 14,
         primaryColor = 0x4E68E2,
-        secondaryColor = 0x47C7F7
+        secondaryColor = 0x47C7F7,
+        order = 14
     )
 
     @JvmField
@@ -175,7 +190,8 @@ object ElementalTypes {
         hue = 0x587DA0,
         textureXMultiplier = 15,
         primaryColor = 0x465B99,
-        secondaryColor = 0x689EBF
+        secondaryColor = 0x689EBF,
+        order = 15
     )
 
     @JvmField
@@ -185,7 +201,8 @@ object ElementalTypes {
         hue = 0xABD1F4,
         textureXMultiplier = 16,
         primaryColor = 0x628CB9,
-        secondaryColor = 0xD6F7F3
+        secondaryColor = 0xD6F7F3,
+        order = 16
     )
 
     @JvmField
@@ -195,18 +212,21 @@ object ElementalTypes {
         hue = 0xFF7FE5,
         textureXMultiplier = 17,
         primaryColor = 0xE2678C,
-        secondaryColor = 0xF5A7B7
+        secondaryColor = 0xF5A7B7,
+        order = 17
     )
 
     @JvmStatic
-    fun register(name: String, displayName: MutableComponent, hue: Int, textureXMultiplier: Int, primaryColor: Int, secondaryColor: Int): ElementalType {
+    @JvmOverloads
+    fun register(name: String, displayName: MutableComponent, hue: Int, textureXMultiplier: Int, primaryColor: Int, secondaryColor: Int, order: Int = 1000): ElementalType {
         return ElementalType(
             name = name,
             displayName = displayName,
             hue = hue,
             textureXMultiplier = textureXMultiplier,
             primaryColor =  primaryColor,
-            secondaryColor = secondaryColor
+            secondaryColor = secondaryColor,
+            order = order
         ).also {
             allTypes.add(it)
         }

common/src/main/kotlin/com/cobblemon/mod/common/block/DecorativeItemBlock.kt

@@ -48,7 +48,8 @@ class DecorativeItemBlock(settings: Properties, val type: DecorativeItemBlockTyp
         NEVERMELT,
         SCOPE,
         WIDE,
-        ZOOM;
+        ZOOM,
+        IZER;
 
         override fun getSerializedName(): String = this.name.lowercase()
 
@@ -76,6 +77,7 @@ class DecorativeItemBlock(settings: Properties, val type: DecorativeItemBlockTyp
         val SCOPE_HITBOX = Shapes.box(0.625, 0.0, 0.4375, 0.9375, 0.125, 0.75)
         val WIDE_HITBOX = Shapes.box(0.625, 0.0, 0.125, 0.9375, 0.0625, 0.625)
         val ZOOM_HITBOX = Shapes.box(0.125, 0.0, 0.1875, 0.375, 0.1875, 0.5)
+        val IZER_HITBOX = Shapes.box(0.25, 0.0, 0.25, 0.75, 0.375, 0.75)
 
         fun getShape(type: DecorativeItemBlockType): VoxelShape {
             return when (type) {
@@ -87,6 +89,7 @@ class DecorativeItemBlock(settings: Properties, val type: DecorativeItemBlockTyp
                 DecorativeItemBlockType.SCOPE -> SCOPE_HITBOX
                 DecorativeItemBlockType.WIDE -> WIDE_HITBOX
                 DecorativeItemBlockType.ZOOM -> ZOOM_HITBOX
+                DecorativeItemBlockType.IZER -> IZER_HITBOX
                 DecorativeItemBlockType.FLATTENED_10x4 -> SMOOSHED4_HITBOX
                 DecorativeItemBlockType.FLATTENED_8x4 -> FLAT4_HITBOX
                 DecorativeItemBlockType.FLATTENED_8x6 -> FLAT6_HITBOX

common/src/main/kotlin/com/cobblemon/mod/common/block/MintBlock.kt

@@ -103,15 +103,15 @@ class MintBlock(private val mintType: MintType, settings: Properties) : CropBloc
             GREEN -> CobblemonItems.GREEN_MINT_SEEDS
             WHITE -> CobblemonItems.WHITE_MINT_SEEDS
         }
-
-        fun getLeaf(): MintLeafItem = when (this) {
-            RED -> CobblemonItems.RED_MINT_LEAF
-            BLUE -> CobblemonItems.BLUE_MINT_LEAF
-            CYAN -> CobblemonItems.CYAN_MINT_LEAF
-            PINK -> CobblemonItems.PINK_MINT_LEAF
-            GREEN -> CobblemonItems.GREEN_MINT_LEAF
-            WHITE -> CobblemonItems.WHITE_MINT_LEAF
-        }
+// These don't seem to get called to anywhere besides the direct item, and since I'm trying to do funny stuff there, just commenting this out
+//        fun getLeaf(): MintLeafItem = when (this) {
+//            RED -> CobblemonItems.RED_MINT_LEAF
+//            BLUE -> CobblemonItems.BLUE_MINT_LEAF
+//            CYAN -> CobblemonItems.CYAN_MINT_LEAF
+//            PINK -> CobblemonItems.PINK_MINT_LEAF
+//            GREEN -> CobblemonItems.GREEN_MINT_LEAF
+//            WHITE -> CobblemonItems.WHITE_MINT_LEAF
+//        }
 
         fun getCropBlock(): MintBlock = when (this) {
             RED -> CobblemonBlocks.RED_MINT

common/src/main/kotlin/com/cobblemon/mod/common/block/StackableItemBlock.kt

@@ -45,7 +45,9 @@ class StackableItemBlock(settings: Properties, val type: StackableItemBlockType)
         IRON_BALL,
         THROAT_SPRAY,
         UPGRADE,
-        DICE;
+        DICE,
+        GLASS_BOTTLE,
+        EXTENDER;
 
         override fun getSerializedName(): String = this.name.lowercase()
 
@@ -133,6 +135,18 @@ class StackableItemBlock(settings: Properties, val type: StackableItemBlockType)
                     Shapes.box(0.125, 0.0, 0.625, 0.5625, 0.1875, 0.875),
                     Shapes.box(0.125, 0.0, 0.4375, 0.5625, 0.1875, 0.875),
                     Shapes.box(0.125, 0.0, 0.4375, 0.5625, 0.375, 0.875)
+                ),
+                StackableItemBlockType.GLASS_BOTTLE to listOf(
+                    Shapes.box(0.375, 0.0, 0.375, 0.625, 0.375, 0.625),
+                    Shapes.box(0.1875, 0.0, 0.1875, 0.8125, 0.375, 0.6875),
+                    Shapes.box(0.125, 0.0, 0.125, 0.8125, 0.375, 0.875),
+                    Shapes.box(0.125, 0.0, 0.125, 0.875, 0.375, 0.875)
+                ),
+                StackableItemBlockType.EXTENDER to listOf(
+                    Shapes.box(0.25, 0.0, 0.375, 0.625, 0.5625, 0.625),
+                    Shapes.box(0.125, 0.0, 0.25, 0.875, 0.5625, 0.75),
+                    Shapes.box(0.0625, 0.0, 0.0625, 0.875, 0.5625, 0.875),
+                    Shapes.box(0.0625, 0.0, 0.0625, 0.9375, 0.5625, 0.9375)
                 )
             )
 

common/src/main/kotlin/com/cobblemon/mod/common/block/decor/LobailaFlowerBlock.kt

@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.block.decor
+
+import net.minecraft.core.BlockPos
+import net.minecraft.world.item.context.BlockPlaceContext
+import net.minecraft.world.level.BlockGetter
+import net.minecraft.world.level.block.Block
+import net.minecraft.world.level.block.SimpleWaterloggedBlock
+import net.minecraft.world.level.block.TallFlowerBlock
+import net.minecraft.world.level.block.state.BlockState
+import net.minecraft.world.level.block.state.StateDefinition
+import net.minecraft.world.level.block.state.properties.BlockStateProperties.WATERLOGGED
+import net.minecraft.world.level.block.state.properties.DoubleBlockHalf
+import net.minecraft.world.level.material.FluidState
+import net.minecraft.world.level.material.Fluids
+import net.minecraft.world.phys.shapes.CollisionContext
+import net.minecraft.world.phys.shapes.Shapes
+import net.minecraft.world.phys.shapes.VoxelShape
+
+
+class LobailaFlowerBlock(properties: Properties?) : TallFlowerBlock(properties), SimpleWaterloggedBlock {
+
+    init {
+        registerDefaultState(stateDefinition.any()
+            .setValue(HALF, DoubleBlockHalf.LOWER)
+            .setValue(WATERLOGGED, false))
+    }
+
+    override fun getFluidState(blockState: BlockState): FluidState? {
+        return if (blockState.getValue(WATERLOGGED)) Fluids.WATER.getSource(false) else super.getFluidState(blockState);
+    }
+
+    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
+        builder.add(HALF, WATERLOGGED)
+    }
+
+    override fun getStateForPlacement(context: BlockPlaceContext): BlockState? {
+        val fluidState = context.level.getFluidState(context.clickedPos)
+        return this.defaultBlockState()
+            .setValue(
+                WATERLOGGED,
+                fluidState.type === Fluids.WATER
+            )
+    }
+
+    override fun getShape(state: BlockState, world: BlockGetter, pos: BlockPos, context: CollisionContext): VoxelShape = AABB
+
+    companion object {
+        private val AABB = Shapes.box(0.125, 0.0, 0.125, 0.875, 1.0, 0.875)
+    }
+
+}

common/src/main/kotlin/com/cobblemon/mod/common/block/decor/MistleafFlowerBlock.kt

@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.block.decor
+
+import com.cobblemon.mod.common.CobblemonBlockEntities
+import com.cobblemon.mod.common.block.entity.MistleafFlowerBlockEntity
+import net.minecraft.core.BlockPos
+import net.minecraft.world.level.BlockGetter
+import net.minecraft.world.level.Level
+import net.minecraft.world.level.LevelReader
+import net.minecraft.world.level.block.BaseEntityBlock
+import net.minecraft.world.level.block.Block
+import net.minecraft.world.level.block.EntityBlock
+import net.minecraft.world.level.block.SoundType
+import net.minecraft.world.level.block.TallFlowerBlock
+import net.minecraft.world.level.block.entity.BlockEntity
+import net.minecraft.world.level.block.entity.BlockEntityTicker
+import net.minecraft.world.level.block.entity.BlockEntityType
+import net.minecraft.world.level.block.state.BlockBehaviour
+import net.minecraft.world.level.block.state.BlockState
+import net.minecraft.world.level.block.state.StateDefinition
+import net.minecraft.world.level.block.state.properties.DoubleBlockHalf
+import net.minecraft.world.level.block.state.properties.IntegerProperty
+import net.minecraft.world.level.material.MapColor
+import net.minecraft.world.level.material.PushReaction
+import net.minecraft.world.phys.shapes.CollisionContext
+import net.minecraft.world.phys.shapes.Shapes
+import net.minecraft.world.phys.shapes.VoxelShape
+
+class MistleafFlowerBlock(lightLevel: (BlockState) -> Int) :
+    EntityBlock,
+    TallFlowerBlock(
+        Properties.of()
+            .mapColor(MapColor.PLANT)
+            .noCollission()
+            .instabreak()
+            .sound(SoundType.GRASS)
+            .offsetType(OffsetType.XZ)
+            .ignitedByLava()
+            .pushReaction(PushReaction.DESTROY)
+            .lightLevel(lightLevel)
+    ) {
+
+    init {
+        registerDefaultState(stateDefinition.any()
+            .setValue(HALF, DoubleBlockHalf.LOWER)
+            .setValue(GLOWING, 0))
+    }
+
+    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
+        builder.add(HALF, GLOWING)
+    }
+    override fun isValidBonemealTarget(level: LevelReader, pos: BlockPos, state: BlockState): Boolean {
+        return false
+    }
+
+    override fun getShape(state: BlockState, world: BlockGetter, pos: BlockPos, context: CollisionContext): VoxelShape = AABB
+
+    override fun newBlockEntity(pos: BlockPos, state: BlockState): BlockEntity? {
+        return MistleafFlowerBlockEntity(pos, state)
+    }
+
+    override fun <T : BlockEntity?> getTicker(
+        level: Level,
+        state: BlockState,
+        blockEntityType: BlockEntityType<T?>
+    ): BlockEntityTicker<T?>? {
+        return if (level.isClientSide) null else BaseEntityBlock.createTickerHelper(blockEntityType as BlockEntityType<*>,
+            CobblemonBlockEntities.MISTLEAF_FLOWER, MistleafFlowerBlockEntity::serverTick) as BlockEntityTicker<T?>?
+    }
+
+    companion object {
+        private val AABB = Shapes.box(0.125, 0.0, 0.125, 0.875, 1.0, 0.875)
+        val GLOWING = IntegerProperty.create("glowing", 0, 8)
+    }
+
+    override fun hasAnalogOutputSignal(state: BlockState): Boolean { return true }
+    override fun getAnalogOutputSignal(state: BlockState, level: Level, pos: BlockPos): Int {
+        return state.getValue(GLOWING) as Int
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/block/decor/PauvilleaFlowerBlock.kt

@@ -0,0 +1,104 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.block.decor
+
+import com.mojang.serialization.MapCodec
+import com.mojang.serialization.codecs.RecordCodecBuilder
+import net.minecraft.core.BlockPos
+import net.minecraft.core.Direction
+import net.minecraft.server.level.ServerLevel
+import net.minecraft.util.RandomSource
+import net.minecraft.world.item.ItemStack
+import net.minecraft.world.item.context.BlockPlaceContext
+import net.minecraft.world.level.BlockGetter
+import net.minecraft.world.level.Level
+import net.minecraft.world.level.LevelAccessor
+import net.minecraft.world.level.LevelReader
+import net.minecraft.world.level.block.Block
+import net.minecraft.world.level.block.Blocks
+import net.minecraft.world.level.block.BonemealableBlock
+import net.minecraft.world.level.block.DirectionalBlock
+import net.minecraft.world.level.block.state.BlockState
+import net.minecraft.world.level.block.state.StateDefinition
+import net.minecraft.world.phys.shapes.CollisionContext
+import net.minecraft.world.phys.shapes.Shapes
+import net.minecraft.world.phys.shapes.VoxelShape
+
+class PauvilleaFlowerBlock(properties: Properties?) : DirectionalBlock(properties), BonemealableBlock {
+    init {
+        registerDefaultState(stateDefinition.any()
+            .setValue(FACING, Direction.DOWN))
+    }
+
+    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
+        builder.add(FACING)
+    }
+
+    override fun getStateForPlacement(ctx: BlockPlaceContext): BlockState? {
+        var blockState = defaultBlockState()
+        val worldView = ctx.level
+        val blockPos = ctx.clickedPos
+        blockState = blockState.setValue(FACING, ctx.clickedFace) as BlockState
+        if (blockState.canSurvive(worldView, blockPos)) {
+            return blockState
+        }
+        return null
+    }
+
+    override fun updateShape(state: BlockState, direction: Direction, neighborState: BlockState, level: LevelAccessor, pos: BlockPos, neighborPos: BlockPos): BlockState {
+        val facing = state.getValue(FACING)
+        if (direction == facing.opposite && !canSurvive(state, level, pos)) {
+            return Blocks.AIR.defaultBlockState()
+        }
+        return super.updateShape(state, direction, neighborState, level, pos, neighborPos)
+    }
+
+    override fun canSurvive(state: BlockState, level: LevelReader, pos: BlockPos): Boolean {
+        val direction = state.getValue(FACING) as Direction
+        val blockState = level.getBlockState(pos.relative(direction.opposite))
+        return blockState.isCollisionShapeFullBlock(level, pos) or blockState.canOcclude()
+    }
+
+    override fun codec(): MapCodec<PauvilleaFlowerBlock> = CODEC
+
+    override fun getShape(state: BlockState, blockGetter: BlockGetter, pos: BlockPos, collisionContext: CollisionContext): VoxelShape {
+        return when (state.getValue(FACING)) {
+            Direction.DOWN -> CEILING
+            Direction.NORTH -> WALL_NORTH
+            Direction.EAST -> WALL_EAST
+            Direction.SOUTH -> WALL_SOUTH
+            Direction.WEST -> WALL_WEST
+            Direction.UP -> FLOOR
+        }
+    }
+
+    companion object {
+        val CODEC: MapCodec<PauvilleaFlowerBlock> = RecordCodecBuilder.mapCodec {
+            it.group(propertiesCodec()).apply(it, ::PauvilleaFlowerBlock)
+        }
+        val FLOOR = Shapes.box(0.075, 0.0, 0.075, 0.925, 0.4375, 0.925)
+        val WALL_NORTH = Shapes.box(0.0, 0.0, 0.8125, 1.0, 1.0, 1.0)
+        val WALL_EAST = Shapes.box(0.0, 0.0, 0.0, 0.1875, 1.0, 1.0)
+        val WALL_SOUTH = Shapes.box(0.0, 0.0, 0.0, 1.0, 1.0, 0.1875)
+        val WALL_WEST = Shapes.box(0.8125, 0.0, 0.0, 1.0, 1.0, 1.0)
+        val CEILING = Shapes.box(0.075, 0.0, 0.075, 0.925, 1.0, 0.925)
+    }
+
+    override fun isValidBonemealTarget(level: LevelReader?, pos: BlockPos?, state: BlockState?): Boolean {
+        return true
+    }
+
+    override fun isBonemealSuccess(level: Level?, random: RandomSource?, pos: BlockPos?, state: BlockState?): Boolean {
+        return true
+    }
+
+    override fun performBonemeal(level: ServerLevel, random: RandomSource?, pos: BlockPos, state: BlockState?) {
+        popResource(level, pos, ItemStack(this))
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/block/decor/PomohanaFlowerBlock.kt

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.block.decor
+
+
+import net.minecraft.core.BlockPos
+import net.minecraft.world.level.BlockGetter
+import net.minecraft.world.level.block.PinkPetalsBlock
+import net.minecraft.world.level.block.state.BlockState
+import net.minecraft.world.phys.shapes.CollisionContext
+import net.minecraft.world.phys.shapes.Shapes
+import net.minecraft.world.phys.shapes.VoxelShape
+
+
+class PomohanaFlowerBlock(properties: Properties?) : PinkPetalsBlock(properties) {
+
+    override fun getShape(state: BlockState, world: BlockGetter, pos: BlockPos, context: CollisionContext): VoxelShape = AABB
+
+    companion object {
+        private val AABB = Shapes.box(0.125, 0.0, 0.125, 0.875, 1.0, 0.875)
+    }
+
+}

common/src/main/kotlin/com/cobblemon/mod/common/block/decor/TerrainPlantBlock.kt

@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.block.decor
+
+import com.cobblemon.mod.common.CobblemonBlockEntities
+import com.cobblemon.mod.common.CobblemonBlocks
+import com.cobblemon.mod.common.block.entity.TerrainPlantBlockEntity
+import net.minecraft.core.BlockPos
+import net.minecraft.server.level.ServerLevel
+import net.minecraft.util.RandomSource
+import net.minecraft.world.entity.Entity
+import net.minecraft.world.level.BlockGetter
+import net.minecraft.world.level.Level
+import net.minecraft.world.level.LevelReader
+import net.minecraft.world.level.block.BaseEntityBlock
+import net.minecraft.world.level.block.Block
+import net.minecraft.world.level.block.EntityBlock
+import net.minecraft.world.level.block.TallFlowerBlock
+import net.minecraft.world.level.block.entity.BlockEntity
+import net.minecraft.world.level.block.entity.BlockEntityTicker
+import net.minecraft.world.level.block.entity.BlockEntityType
+import net.minecraft.world.level.block.state.BlockState
+import net.minecraft.world.level.block.state.StateDefinition
+import net.minecraft.world.level.block.state.properties.BooleanProperty
+import net.minecraft.world.level.block.state.properties.DoubleBlockHalf
+import net.minecraft.world.phys.shapes.CollisionContext
+import net.minecraft.world.phys.shapes.Shapes
+import net.minecraft.world.phys.shapes.VoxelShape
+
+class TerrainPlantBlock(properties: Properties) : TallFlowerBlock(properties), EntityBlock {
+
+    init {
+        registerDefaultState(stateDefinition.any()
+            .setValue(HALF, DoubleBlockHalf.LOWER)
+            .setValue(GLOWING, false))
+    }
+
+    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
+        builder.add(HALF, GLOWING)
+    }
+    override fun isValidBonemealTarget(level: LevelReader, pos: BlockPos, state: BlockState): Boolean {
+        return false
+    }
+
+    override fun tick(state: BlockState, level: ServerLevel, pos: BlockPos, random: RandomSource) {
+        if (state.`is`(CobblemonBlocks.LUCIBELL)) { this.checkInside(level, pos, state) }
+    }
+
+    private fun checkInside(level: Level, pos: BlockPos, state: BlockState) {
+        // Only lower will handle this
+        val upperState = level.getBlockState(pos.above()).takeIf { it.`is`(CobblemonBlocks.LUCIBELL) && it.getValue(HALF) == DoubleBlockHalf.UPPER }
+
+        val entityInside = level.getEntities(null, state.getShape(level, pos).bounds().move(pos)).isNotEmpty()
+                || upperState?.let { level.getEntities(null, it.getShape(level, pos.above()).bounds().move(pos.above())).isNotEmpty() } ?: false
+
+        val glowingState = state.getValue(GLOWING)
+        if (glowingState != entityInside) {
+            level.setBlock(pos, state.setValue(GLOWING, entityInside), UPDATE_CLIENTS)
+            upperState?.let { level.setBlock(pos.above(), it.setValue(GLOWING, entityInside), UPDATE_CLIENTS) }
+        }
+        if (entityInside) level.scheduleTick(pos, this, 30) // tick occasionally to check if player inside
+    }
+
+    override fun entityInside(state: BlockState, level: Level, pos: BlockPos, entity: Entity) {
+        // Lucibell lower block will be our 'driver'
+        if (!level.isClientSide && !state.getValue(GLOWING) && state.`is`(CobblemonBlocks.LUCIBELL)) {
+            val halfState = state.getValue(HALF)
+            if (halfState == DoubleBlockHalf.UPPER) {
+                val lowerState = level.getBlockState(pos.below())
+                    .takeIf { it.`is`(CobblemonBlocks.LUCIBELL) && it.getValue(HALF) == DoubleBlockHalf.LOWER }
+                    ?: return
+                (lowerState.block as TerrainPlantBlock).checkInside(level, pos.below(), lowerState)
+            } else {
+                checkInside(level, pos, state)
+            }
+        }
+    }
+
+    override fun getShape(state: BlockState, world: BlockGetter, pos: BlockPos, context: CollisionContext): VoxelShape = AABB
+
+    override fun newBlockEntity(pos: BlockPos, state: BlockState): BlockEntity {
+        return TerrainPlantBlockEntity(pos, state)
+    }
+
+    override fun <T : BlockEntity> getTicker(
+        level: Level,
+        state: BlockState,
+        blockEntityType: BlockEntityType<T?>
+    ): BlockEntityTicker<T?>? {
+        return if (level.isClientSide) null else BaseEntityBlock.createTickerHelper(blockEntityType as BlockEntityType<*>,
+            CobblemonBlockEntities.TERRAIN_PLANT, TerrainPlantBlockEntity::serverTick) as BlockEntityTicker<T?>?
+    }
+
+    companion object {
+        private val AABB = Shapes.box(0.125, 0.0, 0.125, 0.875, 1.0, 0.875)
+        val GLOWING = BooleanProperty.create("glowing")
+
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/block/decor/TerrainSeedBlock.kt

@@ -0,0 +1,273 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.block.decor
+
+import com.cobblemon.mod.common.CobblemonBlocks
+import com.cobblemon.mod.common.CobblemonItems
+import com.cobblemon.mod.common.CobblemonSounds
+import com.mojang.serialization.MapCodec
+import com.mojang.serialization.codecs.RecordCodecBuilder
+import net.minecraft.core.BlockPos
+import net.minecraft.core.Direction
+import net.minecraft.server.level.ServerLevel
+import net.minecraft.util.RandomSource
+import net.minecraft.util.StringRepresentable
+import net.minecraft.world.entity.player.Player
+import net.minecraft.world.item.Item
+import net.minecraft.world.item.ItemStack
+import net.minecraft.world.level.*
+import net.minecraft.world.level.block.*
+import net.minecraft.world.level.block.entity.BlockEntity
+import net.minecraft.world.level.block.state.BlockState
+import net.minecraft.world.level.block.state.StateDefinition
+import net.minecraft.world.level.block.state.properties.BlockStateProperties
+import net.minecraft.world.level.block.state.properties.DoubleBlockHalf
+import net.minecraft.world.level.block.state.properties.EnumProperty
+import net.minecraft.world.level.block.state.properties.IntegerProperty
+import net.minecraft.world.level.material.Fluids
+import net.minecraft.world.phys.shapes.CollisionContext
+import net.minecraft.world.phys.shapes.VoxelShape
+
+@Suppress("OVERRIDE_DEPRECATION")
+class TerrainSeedBlock(private val terrainSeedType: TerrainSeedType, settings: Properties) : CropBlock(settings) {
+    companion object {
+        val CODEC: MapCodec<TerrainSeedBlock> = RecordCodecBuilder.mapCodec { it.group(
+            TerrainSeedType.CODEC.fieldOf("terrainSeedType").forGetter(TerrainSeedBlock::terrainSeedType),
+            propertiesCodec()
+        ).apply(it, ::TerrainSeedBlock) }
+        const val MATURE_AGE = 4
+        val AGE: IntegerProperty = IntegerProperty.create("age", 0, MATURE_AGE)
+        val HALF: EnumProperty<DoubleBlockHalf> = BlockStateProperties.DOUBLE_BLOCK_HALF
+
+        val AGE_TO_SHAPE = arrayOf(
+            box(2.0, 0.0, 2.0, 14.0, 6.0, 14.0), // Stage 0
+            box(2.0, 0.0, 2.0, 14.0, 16.0, 14.0), // Stage 1
+            box(2.0, 0.0, 2.0, 14.0, 16.0, 14.0), // Stage 2
+            box(2.0, 0.0, 2.0, 14.0, 16.0, 14.0), // Stage 3
+            box(2.0, 0.0, 2.0, 14.0, 16.0, 14.0),  // Stage 4
+        )
+
+        val AGE_TO_SHAPE_TOP = arrayOf(
+            box(2.0, 0.0, 2.0, 14.0, 1.0, 14.0), // Stage 0
+            box(2.0, 0.0, 2.0, 14.0, 1.0, 14.0), // Stage 1
+            box(2.0, 0.0, 2.0, 14.0, 8.0, 14.0), // Stage 2
+            box(2.0, 0.0, 2.0, 14.0, 16.0, 14.0), // Stage 3
+            box(2.0, 0.0, 2.0, 14.0, 16.0, 14.0),  // Stage 4
+        )
+    }
+
+    override fun codec(): MapCodec<out CropBlock> {
+        return CODEC
+    }
+
+    init {
+        this.registerDefaultState(
+            this.stateDefinition.any()
+                .setValue(AGE, 0)
+                .setValue(HALF, DoubleBlockHalf.LOWER)
+        )
+    }
+
+    override fun getAgeProperty(): IntegerProperty = AGE
+
+    override fun getMaxAge(): Int = MATURE_AGE
+
+    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
+        builder.add(AGE, HALF)
+    }
+
+    override fun getBaseSeedId(): ItemLike = this.terrainSeedType.getSeed()
+
+    override fun getShape(state: BlockState, world: BlockGetter, pos: BlockPos, context: CollisionContext): VoxelShape =
+        if (state.getValue(HALF) == DoubleBlockHalf.UPPER) AGE_TO_SHAPE_TOP[getAge(state)] else AGE_TO_SHAPE[this.getAge(state)]
+
+    override fun randomTick(state: BlockState, world: ServerLevel, pos: BlockPos, random: RandomSource) {
+        if (state.getValue(HALF) == DoubleBlockHalf.UPPER || !canGrow(world, pos, state)) return
+
+        if (hasSufficientLight(world, pos) && random.nextInt(32) == 0) {
+            grow(world, pos, state, 1)
+        }
+    }
+
+    private fun canGrow(world: LevelReader, pos: BlockPos, state: BlockState): Boolean {
+        return !this.isMaxAge(state) && canSurvive(state, world, pos) && !(!canGrowInto(world, pos.above()) && state.getValue(AGE) >= 4)
+    }
+
+    private fun canGrowInto(world: LevelReader, pos: BlockPos): Boolean {
+        val blockState = world.getBlockState(pos)
+        return blockState.isAir || blockState.`is`(this.terrainSeedType.getCropBlock())
+    }
+
+    override fun updateShape(state: BlockState, direction: Direction, neighborState: BlockState, world: LevelAccessor, pos: BlockPos, neighborPos: BlockPos): BlockState {
+        return if (state.getValue(AGE) >= 2) {
+            super.updateShape(state, direction, neighborState, world, pos, neighborPos)
+        } else {
+            if (state.canSurvive(world, pos)) state else Blocks.AIR.defaultBlockState()
+        }
+    }
+
+    override fun isValidBonemealTarget(level: LevelReader, pos: BlockPos, state: BlockState): Boolean {
+        val posAndState = getLowerHalf(level, pos, state)
+        return if (posAndState == null) false else this.canGrow(
+            level,
+            posAndState.first,
+            posAndState.second
+        )
+    }
+
+    override fun performBonemeal(level: ServerLevel, random: RandomSource, pos: BlockPos, state: BlockState) {
+        val posAndState = getLowerHalf(level, pos, state)
+        if (posAndState != null) {
+            grow(level, posAndState.first, posAndState.second, getBonemealAgeIncrease(level))
+        }
+    }
+
+    fun grow(world: Level, pos: BlockPos, state: BlockState, increment: Int) {
+        if (!canGrow(world, pos, state)) return
+
+        val newAge = (this.getAge(state) + increment).coerceAtMost(this.maxAge)
+        world.setBlock(pos, state.setValue(this.ageProperty, newAge), UPDATE_CLIENTS)
+
+        val abovePos = pos.above()
+        val stateAbove = world.getBlockState(abovePos)
+        // Set top half depending on age
+        if (newAge >= (2)) {
+            if (stateAbove.isAir) {
+                world.setBlock(
+                    abovePos,
+                    this.defaultBlockState().setValue(AGE, newAge).setValue(HALF, DoubleBlockHalf.UPPER),
+                    UPDATE_CLIENTS
+                )
+            }
+            else if (stateAbove.hasProperty(HALF) && stateAbove.getValue(HALF) == DoubleBlockHalf.UPPER) {
+                world.setBlock(
+                    abovePos,
+                    stateAbove.setValue(AGE, newAge),
+                    UPDATE_CLIENTS
+                )
+            }
+        }
+        // Swaps blocks to the actual Flower when fully grown
+        if (newAge == this.maxAge) {
+            val nextStateLower = this.terrainSeedType.getFlowerBlock().defaultBlockState().setValue(HALF, DoubleBlockHalf.LOWER)
+            val nextStateUpper = this.terrainSeedType.getFlowerBlock().defaultBlockState().setValue(HALF, DoubleBlockHalf.UPPER)
+            world.setBlock(abovePos, nextStateUpper, UPDATE_CLIENTS)
+            world.setBlock(pos, nextStateLower, UPDATE_CLIENTS)
+        }
+    }
+
+    override fun getBonemealAgeIncrease(level: Level): Int {
+        return 1
+    }
+
+    override fun canSurvive(state: BlockState, world: LevelReader, pos: BlockPos): Boolean {
+        return when (state.getValue(HALF)) {
+            DoubleBlockHalf.LOWER -> {
+                val floorBlock = pos.below()
+                val floor = world.getBlockState(floorBlock)
+
+                floor.`is`(Blocks.FARMLAND)
+            }
+            DoubleBlockHalf.UPPER -> {
+                getLowerHalf(world, pos, state) != null
+                // Upper part survives only if the lower part is valid
+            }
+        }
+    }
+
+    private fun getLowerHalf(level: LevelReader, pos: BlockPos, state: BlockState): Pair<BlockPos, BlockState>? {
+        if (isLower(state)) {
+            return Pair(pos, state)
+        } else {
+            val blockPos = pos.below()
+            val blockState = level.getBlockState(blockPos)
+            return if (isLower(blockState)) Pair(
+                blockPos,
+                blockState
+            ) else null
+        }
+    }
+
+    private fun isLower(state: BlockState): Boolean =
+        state.`is`(this.terrainSeedType.getCropBlock()) && state.getValue(HALF) == DoubleBlockHalf.LOWER
+
+    override fun getSoundType(state: BlockState): SoundType {
+        return CobblemonSounds.HEARTY_GRAINS_SOUNDS
+    }
+
+    @Suppress("unused")
+    enum class TerrainSeedType : StringRepresentable {
+        ELECTRIC,
+        PSYCHIC,
+        MISTY,
+        GRASSY;
+        fun getSeed(): Item = when (this) {
+            ELECTRIC -> CobblemonItems.ELECTRIC_SEED
+            PSYCHIC -> CobblemonItems.PSYCHIC_SEED
+            MISTY -> CobblemonItems.MISTY_SEED
+            GRASSY -> CobblemonItems.GRASSY_SEED
+        }
+        fun getCropBlock(): TerrainSeedBlock = when (this) {
+            ELECTRIC -> CobblemonBlocks.ELECTRIC_SEED
+            PSYCHIC -> CobblemonBlocks.PSYCHIC_SEED
+            MISTY -> CobblemonBlocks.MISTY_SEED
+            GRASSY -> CobblemonBlocks.GRASSY_SEED
+        }
+        fun getFlowerBlock(): Block = when (this) {
+            ELECTRIC -> CobblemonBlocks.VOLTACONIA
+            PSYCHIC -> CobblemonBlocks.LUCIBELL
+            MISTY -> CobblemonBlocks.MISTLEAF
+            GRASSY -> CobblemonBlocks.VERDROOT
+        }
+
+        override fun getSerializedName(): String = this.name.lowercase()
+
+        companion object {
+            val CODEC = StringRepresentable.fromEnum(::values)
+        }
+    }
+
+    override fun playerWillDestroy(level: Level, pos: BlockPos, state: BlockState, player: Player): BlockState {
+        if (!level.isClientSide) {
+            if (player.isCreative()) {
+                preventDropFromBottomPart(level, pos, state, player)
+            } else {
+                dropResources(state, level, pos, null as BlockEntity?, player, player.getMainHandItem())
+            }
+        }
+
+        return super.playerWillDestroy(level, pos, state, player)
+    }
+
+    override fun playerDestroy(
+        level: Level,
+        player: Player,
+        pos: BlockPos,
+        state: BlockState,
+        blockEntity: BlockEntity?,
+        tool: ItemStack
+    ) {
+        super.playerDestroy(level, player, pos, Blocks.AIR.defaultBlockState(), blockEntity, tool)
+    }
+
+    fun preventDropFromBottomPart(level: Level, pos: BlockPos, state: BlockState, player: Player?) {
+        val doubleblockhalf = state.getValue<DoubleBlockHalf?>(DoublePlantBlock.HALF) as DoubleBlockHalf
+        if (doubleblockhalf == DoubleBlockHalf.UPPER) {
+            val blockpos = pos.below()
+            val blockstate = level.getBlockState(blockpos)
+            if (blockstate.`is`(state.getBlock()) && blockstate.getValue<DoubleBlockHalf?>(DoublePlantBlock.HALF) == DoubleBlockHalf.LOWER) {
+                val blockstate1 = if (blockstate.getFluidState()
+                        .`is`(Fluids.WATER)
+                ) Blocks.WATER.defaultBlockState() else Blocks.AIR.defaultBlockState()
+                level.setBlock(blockpos, blockstate1, 35)
+                level.levelEvent(player, 2001, blockpos, getId(blockstate))
+            }
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/block/decor/WistensuFlowerBlock.kt

@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.block.decor
+
+import com.cobblemon.mod.common.CobblemonBlocks
+import net.minecraft.core.BlockPos
+import net.minecraft.core.Direction
+import net.minecraft.world.item.context.BlockPlaceContext
+import net.minecraft.world.level.LevelAccessor
+import net.minecraft.world.level.LevelReader
+import net.minecraft.world.level.block.Block
+import net.minecraft.world.level.block.state.BlockState
+import net.minecraft.world.level.block.state.StateDefinition
+import net.minecraft.world.level.block.state.properties.BlockStateProperties
+import net.minecraft.world.level.block.state.properties.BooleanProperty
+
+interface WistensuFlowerBlock {
+    fun additionalBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
+        builder.add(BlockStateProperties.FACING)
+        builder.add(ROOT)
+    }
+
+    fun adjustStateForPlacement(context: BlockPlaceContext, defaultState: BlockState): BlockState {
+        val upperBlock = context.level.getBlockState(context.clickedPos.relative(Direction.UP))
+        if (upperBlock.`is`(CobblemonBlocks.WISTENSU) || upperBlock.`is`(CobblemonBlocks.WISTENSU_VINE)) {
+            return defaultState
+                .setValue(BlockStateProperties.FACING, Direction.DOWN)
+                .setValue(ROOT, false)
+        } else {
+            var placeDirection = context.clickedFace
+            if (placeDirection == Direction.UP) placeDirection = Direction.DOWN
+            return defaultState
+                .setValue(BlockStateProperties.FACING, placeDirection)
+                .setValue(ROOT, true)
+        }
+    }
+
+    fun copyStateValues(target: BlockState, source: BlockState): BlockState {
+        return target
+            .setValue(ROOT, source.getValue(ROOT))
+            .setValue(BlockStateProperties.FACING, source.getValue(BlockStateProperties.FACING))
+    }
+
+    fun wisternCanSurvive(state: BlockState, level: LevelReader, pos: BlockPos): Boolean {
+        if (state.getValue(ROOT)) {
+            val facing = state.getValue(BlockStateProperties.FACING)
+            val targetPos = pos.relative(facing.opposite)
+            val directionState = level.getBlockState(targetPos)
+            return directionState.isFaceSturdy(level, targetPos, facing)
+        } else {
+            val topState = level.getBlockState(pos.relative(Direction.UP))
+            return topState.`is`(CobblemonBlocks.WISTENSU) || topState.`is`(CobblemonBlocks.WISTENSU_VINE)
+        }
+    }
+
+    fun wisternUpdateShape(state: BlockState, direction: Direction, neighborState: BlockState, level: LevelAccessor, pos: BlockPos, neighborPos: BlockPos, block: Block): BlockState? {
+        if (!wisternCanSurvive(state, level, pos)) {
+            level.scheduleTick(pos, block, 1)
+        }
+
+        if (direction == Direction.UP &&
+            (neighborState.`is`(CobblemonBlocks.WISTENSU) || neighborState.`is`(CobblemonBlocks.WISTENSU_VINE))) {
+            return state
+                .setValue(ROOT, false)
+                .setValue(BlockStateProperties.FACING, Direction.DOWN)
+        }
+
+        return null
+    }
+
+    companion object {
+        val ROOT = BooleanProperty.create("root")
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/block/decor/WistensuFlowerHeadBlock.kt

@@ -0,0 +1,114 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.block.decor
+
+
+import com.cobblemon.mod.common.CobblemonBlocks
+import com.mojang.serialization.MapCodec
+import com.mojang.serialization.codecs.RecordCodecBuilder
+import net.minecraft.core.BlockPos
+import net.minecraft.core.Direction
+import net.minecraft.server.level.ServerLevel
+import net.minecraft.util.RandomSource
+import net.minecraft.world.item.context.BlockPlaceContext
+import net.minecraft.world.level.LevelAccessor
+import net.minecraft.world.level.LevelReader
+import net.minecraft.world.level.block.Block
+import net.minecraft.world.level.block.GrowingPlantHeadBlock
+import net.minecraft.world.level.block.state.BlockState
+import net.minecraft.world.level.block.state.StateDefinition
+import net.minecraft.world.level.block.state.properties.BlockStateProperties
+import net.minecraft.world.phys.shapes.VoxelShape
+import kotlin.math.min
+
+//TODO: Root/connection shit
+class WistensuFlowerHeadBlock(properties: Properties?) : GrowingPlantHeadBlock(properties, Direction.DOWN, SHAPE, false, 0.1), WistensuFlowerBlock {
+    companion object {
+        val CODEC: MapCodec<WistensuFlowerHeadBlock> = RecordCodecBuilder.mapCodec {
+            it.group(propertiesCodec()).apply(it, ::WistensuFlowerHeadBlock)
+        }
+        val SHAPE: VoxelShape = box(1.0, 2.0, 1.0, 15.0, 16.0, 15.0)
+    }
+    override fun codec(): MapCodec<WistensuFlowerHeadBlock> = CODEC
+
+    override fun getBlocksToGrowWhenBonemealed(random: RandomSource): Int {
+        var d = 1.0
+        var i = 0
+        while (random.nextDouble() < d) {
+            d *= 0.826
+            ++i
+        }
+        return i
+    }
+
+    override fun canGrowInto(state: BlockState): Boolean {
+        return state.isAir
+    }
+
+    override fun getBodyBlock(): Block {
+        return CobblemonBlocks.WISTENSU_VINE
+    }
+
+    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
+        super.createBlockStateDefinition(builder)
+        additionalBlockStateDefinition(builder)
+    }
+
+    override fun updateShape(
+        state: BlockState,
+        direction: Direction,
+        neighborState: BlockState,
+        level: LevelAccessor,
+        pos: BlockPos,
+        neighborPos: BlockPos
+    ): BlockState {
+        val updateState = wisternUpdateShape(state, direction, neighborState, level, pos, neighborPos, this)
+        if (updateState != null) return updateState
+
+        if (direction == Direction.DOWN &&
+            (neighborState.`is`(CobblemonBlocks.WISTENSU) || neighborState.`is`(CobblemonBlocks.WISTENSU_VINE))) {
+            return updateBodyAfterConvertedFromHead(state, bodyBlock.defaultBlockState())
+        }
+        return state
+    }
+
+    override fun getStateForPlacement(context: BlockPlaceContext): BlockState {
+        val defaultState = super.getStateForPlacement(context)!!
+        return adjustStateForPlacement(context, defaultState)
+    }
+
+    override fun getGrowIntoState(state: BlockState, random: RandomSource): BlockState {
+        return super.getGrowIntoState(state, random)
+            .setValue(WistensuFlowerBlock.ROOT, false)
+            .setValue(BlockStateProperties.FACING, Direction.DOWN)
+    }
+
+    override fun updateBodyAfterConvertedFromHead(head: BlockState, body: BlockState): BlockState {
+        return copyStateValues(body, head)
+    }
+
+    override fun performBonemeal(level: ServerLevel, random: RandomSource, pos: BlockPos, state: BlockState) {
+        var blockPos = pos.relative(growthDirection)
+        var i = min(state.getValue(AGE), MAX_AGE)
+        val j = getBlocksToGrowWhenBonemealed(random)
+        var currentState = state
+
+        for (k in 0..<j) {
+            if (!canGrowInto(level.getBlockState(blockPos))) break
+            level.setBlockAndUpdate(blockPos, getGrowIntoState(currentState, random))
+            currentState = level.getBlockState(blockPos)
+            blockPos = blockPos.relative(growthDirection)
+            i = min(i + 1, MAX_AGE)
+        }
+    }
+
+    override fun canSurvive(state: BlockState, level: LevelReader, pos: BlockPos): Boolean {
+        return wisternCanSurvive(state, level, pos)
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/block/decor/WistensuFlowerVineBlock.kt

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.block.decor
+
+import com.cobblemon.mod.common.CobblemonBlocks
+import com.mojang.serialization.MapCodec
+import com.mojang.serialization.codecs.RecordCodecBuilder
+import net.minecraft.core.BlockPos
+import net.minecraft.core.Direction
+import net.minecraft.world.item.context.BlockPlaceContext
+import net.minecraft.world.level.LevelAccessor
+import net.minecraft.world.level.LevelReader
+import net.minecraft.world.level.block.Block
+import net.minecraft.world.level.block.GrowingPlantBodyBlock
+import net.minecraft.world.level.block.GrowingPlantHeadBlock
+import net.minecraft.world.level.block.state.BlockState
+import net.minecraft.world.level.block.state.StateDefinition
+import net.minecraft.world.level.block.state.properties.BlockStateProperties
+import net.minecraft.world.phys.shapes.VoxelShape
+
+//TODO: Root/connection shit
+class WistensuFlowerVineBlock(properties: Properties?) : GrowingPlantBodyBlock(properties, Direction.DOWN, SHAPE, false), WistensuFlowerBlock
+{
+    companion object {
+        val CODEC: MapCodec<WistensuFlowerVineBlock> = RecordCodecBuilder.mapCodec {
+            it.group(propertiesCodec()).apply(it, ::WistensuFlowerVineBlock)
+        }
+        val SHAPE: VoxelShape = box(1.0, 0.0, 1.0, 15.0, 16.0, 15.0)
+    }
+    override fun codec(): MapCodec<WistensuFlowerVineBlock> = CODEC
+
+    override fun getHeadBlock(): GrowingPlantHeadBlock {
+        return CobblemonBlocks.WISTENSU
+    }
+
+    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
+        super.createBlockStateDefinition(builder)
+        additionalBlockStateDefinition(builder)
+    }
+
+    override fun updateShape(
+        state: BlockState,
+        direction: Direction,
+        neighborState: BlockState,
+        level: LevelAccessor,
+        pos: BlockPos,
+        neighborPos: BlockPos
+    ): BlockState {
+        val updateState = wisternUpdateShape(state, direction, neighborState, level, pos, neighborPos, this)
+        if (updateState != null) return updateState
+
+        if (direction == Direction.DOWN &&
+                !neighborState.`is`(CobblemonBlocks.WISTENSU) && !neighborState.`is`(CobblemonBlocks.WISTENSU_VINE)) {
+            return updateHeadAfterConvertedFromBody(state, headBlock.getStateForPlacement(level))
+        }
+        return state
+    }
+
+    override fun getStateForPlacement(context: BlockPlaceContext): BlockState {
+        val defaultState = super.getStateForPlacement(context)!!
+        return adjustStateForPlacement(context, defaultState)
+    }
+
+    override fun updateHeadAfterConvertedFromBody(head: BlockState, body: BlockState): BlockState {
+        return copyStateValues(body, head)
+    }
+
+    override fun canSurvive(state: BlockState, level: LevelReader, pos: BlockPos): Boolean {
+        return wisternCanSurvive(state, level, pos)
+    }
+}

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/entity/MistleafFlowerBlockEntity.kt

@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.block.entity
+
+import com.cobblemon.mod.common.CobblemonBlockEntities
+import com.cobblemon.mod.common.CobblemonBlocks
+import com.cobblemon.mod.common.block.decor.MistleafFlowerBlock
+import net.minecraft.core.BlockPos
+import net.minecraft.world.level.Level
+import net.minecraft.world.level.block.Block
+import net.minecraft.world.level.block.entity.BlockEntity
+import net.minecraft.world.level.block.state.BlockState
+
+class MistleafFlowerBlockEntity(pos: BlockPos, state: BlockState): BlockEntity(CobblemonBlockEntities.MISTLEAF_FLOWER, pos, state) {
+    companion object {
+        fun serverTick(level: Level, pos: BlockPos, state: BlockState, mistleafFlowerBlockEntity: MistleafFlowerBlockEntity) {
+            if (level.isClientSide) return
+            if (state.block !is MistleafFlowerBlock) return
+
+            val glowing = state.getValue(MistleafFlowerBlock.GLOWING)
+
+            val wantedState = when (state.`is`(CobblemonBlocks.MISTLEAF)) {
+                //The light level and comparator output increases on odds from New to Full, and decreases on the evens from Full to New
+                ((level.dayTime().toInt().mod(24000) in 12542..23459) && level.moonPhase == 4) -> 1 //New Moon
+                ((level.dayTime().toInt().mod(24000) in 12542..23459) && level.moonPhase == 5) -> 3 //Waxing Crescent
+                ((level.dayTime().toInt().mod(24000) in 12542..23459) && level.moonPhase == 6) -> 5 //First Quarter
+                ((level.dayTime().toInt().mod(24000) in 12542..23459) && level.moonPhase == 7) -> 7 //Waxing Gibbous
+                ((level.dayTime().toInt().mod(24000) in 12542..23459) && level.moonPhase == 0) -> 8 //Full Moon
+                ((level.dayTime().toInt().mod(24000) in 12542..23459) && level.moonPhase == 1) -> 6 //Waning Gibbous
+                ((level.dayTime().toInt().mod(24000) in 12542..23459) && level.moonPhase == 2) -> 4 // Third Quarter
+                ((level.dayTime().toInt().mod(24000) in 12542..23459) && level.moonPhase == 3) -> 2 //Waning Crescent
+                else -> 0 //Daytime, and likely dimensions with no concept of day/night cycle or moon phase
+            }
+
+            if (glowing != wantedState) {
+                level.setBlock(pos, state.setValue(MistleafFlowerBlock.GLOWING, wantedState), Block.UPDATE_ALL)
+            }
+        }
+    }
+}

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

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.block.entity
+
+import com.cobblemon.mod.common.CobblemonBlockEntities
+import com.cobblemon.mod.common.CobblemonBlocks
+import com.cobblemon.mod.common.block.decor.TerrainPlantBlock
+import net.minecraft.core.BlockPos
+import net.minecraft.world.level.Level
+import net.minecraft.world.level.block.Block
+import net.minecraft.world.level.block.entity.BlockEntity
+import net.minecraft.world.level.block.state.BlockState
+
+class TerrainPlantBlockEntity(pos: BlockPos, state: BlockState): BlockEntity(CobblemonBlockEntities.TERRAIN_PLANT, pos, state) {
+    companion object {
+        fun serverTick(level: Level, pos: BlockPos, state: BlockState, terrainPlantBlockEntity: TerrainPlantBlockEntity) {
+            if (level.isClientSide) return
+            if (state.block !is TerrainPlantBlock) return
+
+            val glowing = state.getValue(TerrainPlantBlock.GLOWING)
+
+            val wantedState = if (state.`is`(CobblemonBlocks.VOLTACONIA)) level.isThundering
+                else if (state.`is`(CobblemonBlocks.VERDROOT)) level.isRaining && !level.isThundering
+                else null // We dont control glowing here
+
+            if (wantedState != null && glowing != wantedState) {
+                level.setBlock(pos, state.setValue(TerrainPlantBlock.GLOWING, wantedState), Block.UPDATE_CLIENTS)
+            }
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/block/general/MintLitterBlock.kt

@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.block.general
+
+import com.cobblemon.mod.common.util.rotateShape
+import com.mojang.serialization.MapCodec
+import com.mojang.serialization.codecs.RecordCodecBuilder
+import net.minecraft.core.BlockPos
+import net.minecraft.core.Direction
+import net.minecraft.world.item.context.BlockPlaceContext
+import net.minecraft.world.level.BlockGetter
+import net.minecraft.world.level.LevelAccessor
+import net.minecraft.world.level.LevelReader
+import net.minecraft.world.level.block.*
+import net.minecraft.world.level.block.state.BlockState
+import net.minecraft.world.level.block.state.StateDefinition
+import net.minecraft.world.level.block.HorizontalDirectionalBlock.FACING
+import net.minecraft.world.level.block.state.properties.BlockStateProperties.HORIZONTAL_FACING
+import net.minecraft.world.level.block.state.properties.IntegerProperty
+import net.minecraft.world.phys.shapes.CollisionContext
+import net.minecraft.world.phys.shapes.Shapes
+import net.minecraft.world.phys.shapes.VoxelShape
+import kotlin.math.min
+
+class MintLitterBlock(properties: Properties?) : Block(properties) {
+    init {
+        registerDefaultState(stateDefinition.any()
+            .setValue(FACING, Direction.NORTH)
+            .setValue(AMOUNT, 1))
+    }
+
+    override fun getStateForPlacement(context: BlockPlaceContext): BlockState? {
+        val blockState = context.getLevel().getBlockState(context.getClickedPos())
+        return if (blockState.`is`(this)) blockState.setValue<Int?, Int?>(
+            AMOUNT,
+            min(4, blockState.getValue<Int?>(AMOUNT) as Int + 1)
+        ) as BlockState else this.defaultBlockState().setValue<Direction?, Direction?>(
+            FACING,
+            context.getHorizontalDirection().getOpposite()
+        ) as BlockState
+    }
+
+    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
+        builder.add(FACING)
+        builder.add(AMOUNT)
+    }
+
+    override fun updateShape(
+        state: BlockState,
+        direction: Direction?,
+        neighborState: BlockState?,
+        level: LevelAccessor?,
+        pos: BlockPos?,
+        neighborPos: BlockPos?
+    ): BlockState {
+        return if (!state.canSurvive(level, pos)) Blocks.AIR.defaultBlockState() else super.updateShape(
+            state,
+            direction,
+            neighborState,
+            level,
+            pos,
+            neighborPos
+        )
+    }
+
+    override fun canSurvive(state: BlockState?, level: LevelReader, pos: BlockPos): Boolean {
+        val posBelow = pos.below()
+        return level.getBlockState(posBelow).isFaceSturdy(level, posBelow, Direction.UP)
+    }
+
+    override fun propagatesSkylightDown(state: BlockState, level: BlockGetter?, pos: BlockPos?): Boolean {
+        return state.getFluidState().isEmpty()
+    }
+
+    public override fun canBeReplaced(state: BlockState, useContext: BlockPlaceContext): Boolean {
+        return if (!useContext.isSecondaryUseActive && useContext.itemInHand.`is`(this.asItem()) && state.getValue(
+                AMOUNT
+            ) <= MAX_AMOUNT
+        ) true else super.canBeReplaced(state, useContext)
+    }
+
+    @Deprecated("Deprecated in Java")
+    override fun rotate(state: BlockState, rotation: Rotation): BlockState {
+        return state.setValue(HORIZONTAL_FACING, rotation.rotate(state.getValue(HORIZONTAL_FACING)))
+    }
+
+    override fun getShape(state: BlockState, level: BlockGetter, pos: BlockPos, context: CollisionContext): VoxelShape? {
+        val litterBoxes = when (state.getValue(FACING)) {
+            Direction.SOUTH -> SOUTH_SHAPES
+            Direction.WEST -> WEST_SHAPES
+            Direction.EAST -> EAST_SHAPES
+            else -> NORTH_SHAPES
+        }
+
+        var litterBox = litterBoxes[state.getValue(AMOUNT)]
+        return litterBox
+    }
+
+    companion object {
+        val CODEC: MapCodec<MintLitterBlock> = RecordCodecBuilder.mapCodec {
+            it.group(
+                propertiesCodec()
+            ).apply(it, ::MintLitterBlock) }
+
+        val AMOUNT = IntegerProperty.create("amount", 1, 4)
+        const val MAX_AMOUNT: Int = 4
+
+        private val NORTH_SHAPES = listOf(
+            Shapes.box(0.0, 0.0, 0.0, 1.0, 0.125, 1.0),
+            Shapes.box(0.0, 0.0, 0.0, 0.5, 0.0625, 0.5),
+            Shapes.box(0.0, 0.0, 0.0, 0.5, 0.0625, 1.0),
+            Shapes.or(
+                Shapes.box(0.0, 0.0, 0.0, 0.5, 0.0625, 1.0),
+                Shapes.box(0.5, 0.0, 0.5, 1.0, 0.0625, 1.0)
+            ),
+            Shapes.box(0.0, 0.0, 0.0, 1.0, 0.0625, 1.0)
+        )
+
+        private val SOUTH_SHAPES = createShapes(Direction.SOUTH)
+        private val WEST_SHAPES = createShapes(Direction.WEST)
+        private val EAST_SHAPES = createShapes(Direction.EAST)
+
+        private fun createShapes(to: Direction): List<VoxelShape> {
+            return NORTH_SHAPES.map { rotateShape(Direction.NORTH, to, it) }
+        }
+    }
+}

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
@@ -390,7 +391,7 @@ object CobblemonClient {
             CobblemonBlocks.X_SP_ATK,
             CobblemonBlocks.X_SP_DEF,
             CobblemonBlocks.X_SPEED,
-            CobblemonBlocks.TM_MACHINE,
+            CobblemonBlocks.TM_MACHINE,   
 
             CobblemonBlocks.GALARICA_CUFF,
             CobblemonBlocks.GALARICA_WREATH,
@@ -414,7 +415,108 @@ object CobblemonClient {
             CobblemonBlocks.NEVER_MELT_ICE,
             CobblemonBlocks.WIDE_LENS,
             CobblemonBlocks.ZOOM_LENS,
-            CobblemonBlocks.SCOPE_LENS
+            CobblemonBlocks.SCOPE_LENS,
+            CobblemonBlocks.MOOMOO_MILK,
+            CobblemonBlocks.MEDICINAL_BREW,
+            CobblemonBlocks.TERRAIN_EXTENDER,
+            
+            CobblemonBlocks.RED_MINT_LEAF_LITTER,
+            CobblemonBlocks.POTTED_RED_MINT,
+            CobblemonBlocks.BLUE_MINT_LEAF_LITTER,
+            CobblemonBlocks.POTTED_BLUE_MINT,
+            CobblemonBlocks.CYAN_MINT_LEAF_LITTER,
+            CobblemonBlocks.POTTED_CYAN_MINT,
+            CobblemonBlocks.PINK_MINT_LEAF_LITTER,
+            CobblemonBlocks.POTTED_PINK_MINT,
+            CobblemonBlocks.GREEN_MINT_LEAF_LITTER,
+            CobblemonBlocks.POTTED_GREEN_MINT,
+            CobblemonBlocks.WHITE_MINT_LEAF_LITTER,
+            CobblemonBlocks.POTTED_WHITE_MINT,
+
+            CobblemonBlocks.LOBAILA,
+            CobblemonBlocks.POMOHANA,
+            CobblemonBlocks.PAUVILLEA,
+            CobblemonBlocks.WISTENSU,
+            CobblemonBlocks.WISTENSU_VINE,
+            CobblemonBlocks.ELECTRIC_SEED,
+            CobblemonBlocks.VOLTACONIA,
+            CobblemonBlocks.GRASSY_SEED,
+            CobblemonBlocks.VERDROOT,
+            CobblemonBlocks.MISTY_SEED,
+            CobblemonBlocks.MISTLEAF,
+            CobblemonBlocks.PSYCHIC_SEED,
+            CobblemonBlocks.LUCIBELL,
+
+            CobblemonBlocks.POTTED_AGUAV_BERRY,
+            CobblemonBlocks.POTTED_APICOT_BERRY,
+            CobblemonBlocks.POTTED_ASPEAR_BERRY,
+            CobblemonBlocks.POTTED_BABIRI_BERRY,
+            CobblemonBlocks.POTTED_BELUE_BERRY,
+            CobblemonBlocks.POTTED_BLUK_BERRY,
+            CobblemonBlocks.POTTED_CHARTI_BERRY,
+            CobblemonBlocks.POTTED_CHERI_BERRY,
+            CobblemonBlocks.POTTED_CHESTO_BERRY,
+            CobblemonBlocks.POTTED_CHILAN_BERRY,
+            CobblemonBlocks.POTTED_CHOPLE_BERRY,
+            CobblemonBlocks.POTTED_COBA_BERRY,
+            CobblemonBlocks.POTTED_COLBUR_BERRY,
+            CobblemonBlocks.POTTED_CORNN_BERRY,
+            CobblemonBlocks.POTTED_CUSTAP_BERRY,
+            CobblemonBlocks.POTTED_DURIN_BERRY,
+            CobblemonBlocks.POTTED_EGGANT_BERRY,
+            CobblemonBlocks.POTTED_ENIGMA_BERRY,
+            CobblemonBlocks.POTTED_FIGY_BERRY,
+            CobblemonBlocks.POTTED_GANLON_BERRY,
+            CobblemonBlocks.POTTED_GREPA_BERRY,
+            CobblemonBlocks.POTTED_HABAN_BERRY,
+            CobblemonBlocks.POTTED_HONDEW_BERRY,
+            CobblemonBlocks.POTTED_HOPO_BERRY,
+            CobblemonBlocks.POTTED_IAPAPA_BERRY,
+            CobblemonBlocks.POTTED_JABOCA_BERRY,
+            CobblemonBlocks.POTTED_KASIB_BERRY,
+            CobblemonBlocks.POTTED_KEBIA_BERRY,
+            CobblemonBlocks.POTTED_KEE_BERRY,
+            CobblemonBlocks.POTTED_KELPSY_BERRY,
+            CobblemonBlocks.POTTED_LANSAT_BERRY,
+            CobblemonBlocks.POTTED_LEPPA_BERRY,
+            CobblemonBlocks.POTTED_LIECHI_BERRY,
+            CobblemonBlocks.POTTED_LUM_BERRY,
+            CobblemonBlocks.POTTED_MAGOST_BERRY,
+            CobblemonBlocks.POTTED_MAGO_BERRY,
+            CobblemonBlocks.POTTED_MARANGA_BERRY,
+            CobblemonBlocks.POTTED_MICLE_BERRY,
+            CobblemonBlocks.POTTED_NANAB_BERRY,
+            CobblemonBlocks.POTTED_NOMEL_BERRY,
+            CobblemonBlocks.POTTED_OCCA_BERRY,
+            CobblemonBlocks.POTTED_ORAN_BERRY,
+            CobblemonBlocks.POTTED_PAMTRE_BERRY,
+            CobblemonBlocks.POTTED_PASSHO_BERRY,
+            CobblemonBlocks.POTTED_PAYAPA_BERRY,
+            CobblemonBlocks.POTTED_PECHA_BERRY,
+            CobblemonBlocks.POTTED_PERSIM_BERRY,
+            CobblemonBlocks.POTTED_PETAYA_BERRY,
+            CobblemonBlocks.POTTED_PINAP_BERRY,
+            CobblemonBlocks.POTTED_POMEG_BERRY,
+            CobblemonBlocks.POTTED_QUALOT_BERRY,
+            CobblemonBlocks.POTTED_RABUTA_BERRY,
+            CobblemonBlocks.POTTED_RAWST_BERRY,
+            CobblemonBlocks.POTTED_RAZZ_BERRY,
+            CobblemonBlocks.POTTED_RINDO_BERRY,
+            CobblemonBlocks.POTTED_ROSELI_BERRY,
+            CobblemonBlocks.POTTED_ROWAP_BERRY,
+            CobblemonBlocks.POTTED_SALAC_BERRY,
+            CobblemonBlocks.POTTED_SHUCA_BERRY,
+            CobblemonBlocks.POTTED_SITRUS_BERRY,
+            CobblemonBlocks.POTTED_SPELON_BERRY,
+            CobblemonBlocks.POTTED_STARF_BERRY,
+            CobblemonBlocks.POTTED_TAMATO_BERRY,
+            CobblemonBlocks.POTTED_TANGA_BERRY,
+            CobblemonBlocks.POTTED_TOUGA_BERRY,
+            CobblemonBlocks.POTTED_WACAN_BERRY,
+            CobblemonBlocks.POTTED_WATMEL_BERRY,
+            CobblemonBlocks.POTTED_WEPEAR_BERRY,
+            CobblemonBlocks.POTTED_WIKI_BERRY,
+            CobblemonBlocks.POTTED_YACHE_BERRY
         )
 
         this.createBoatModelLayers()
@@ -436,8 +538,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/gui/trade/PartySlot.kt

@@ -28,9 +28,9 @@ import org.joml.Vector3f
 
 open class PartySlot(
     x: Int, y: Int,
-    private val pokemon: TradeStartedPacket.TradeablePokemon?,
+    val pokemon: TradeStartedPacket.TradeablePokemon?,
     private val parent: TradeGUI,
-    private val isOpposing: Boolean = false,
+    val isOpposing: Boolean = false,
     onPress: OnPress
 ) : Button(x, y, SIZE, SIZE, Component.literal("PartySlot"), onPress, DEFAULT_NARRATION), CobblemonRenderable {
     val state = FloatingState()
@@ -42,6 +42,8 @@ open class PartySlot(
         private val genderIconFemale = cobblemonResource("textures/gui/pc/gender_icon_female.png")
         private val selectPointerResource = cobblemonResource("textures/gui/pc/pc_pointer.png")
         private val untradeableResource = cobblemonResource("textures/gui/trade/trade_slot_icon_locked.png")
+        private val tradePartySlotSelectedResource = cobblemonResource("textures/gui/trade/trade_party_slot_selected.png")
+        private val tradePartySlotSelectedOpposingResource = cobblemonResource("textures/gui/trade/trade_party_slot_selected_opposing.png")
     }
 
     override fun playDownSound(soundManager: SoundManager) {
@@ -60,6 +62,17 @@ open class PartySlot(
             )
         }
 
+        if (hasSelected()) {
+            blitk(
+                matrixStack = matrices,
+                texture = if (isOpposing) tradePartySlotSelectedOpposingResource else tradePartySlotSelectedResource,
+                x = x - 2,
+                y = y - 2,
+                width = 29,
+                height = 29
+            )
+        }
+
         if (pokemon != null) {
             // context.enableScissor(x - 2, y + 2, x + SIZE + 4, y + SIZE + 4)
             // Render Pokémon
@@ -118,7 +131,16 @@ open class PartySlot(
             }
 
             matrices.popPose()
-            if (hasSelected()) {
+            
+            val isViewed = if (isOpposing) {
+                parent.opposingOfferedPokemon?.uuid == pokemon.pokemonId
+            } else {
+                parent.offeredPokemon?.uuid == pokemon.pokemonId
+            }
+
+            if (isViewed && pokemon.tradeable) {
+                matrices.pushPose()
+                matrices.translate(0.0, 0.0, 200.0)
                 blitk(
                     matrixStack = matrices,
                     texture = selectPointerResource,
@@ -128,6 +150,7 @@ open class PartySlot(
                     height = 8,
                     scale = TradeGUI.SCALE
                 )
+                matrices.popPose()
             }
 
             // Held Item
@@ -145,8 +168,9 @@ open class PartySlot(
     }
 
     open fun hasSelected(): Boolean {
-        val offeredPokemon = if (isOpposing) parent.trade.oppositeOffer.get() else parent.trade.myOffer.get()
-        return pokemon?.pokemonId == offeredPokemon?.uuid && pokemon != null
+        if (pokemon == null) return false
+        val offeredPokemons = if (isOpposing) parent.trade.oppositeOffer.get() else parent.trade.myOffer.get()
+        return offeredPokemons.any { it.uuid == pokemon.pokemonId }
     }
 
     fun isHovered(mouseX: Int, mouseY: Int) = pokemon?.tradeable != false && mouseX.toFloat() in (x.toFloat()..(x.toFloat() + SIZE)) && mouseY.toFloat() in (y.toFloat()..(y.toFloat() + SIZE))

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/trade/TradeGUI.kt

@@ -25,6 +25,7 @@ import com.cobblemon.mod.common.client.gui.summary.widgets.common.reformatNature
 import com.cobblemon.mod.common.client.render.drawScaledText
 import com.cobblemon.mod.common.client.render.drawScaledTextJustifiedRight
 import com.cobblemon.mod.common.client.trade.ClientTrade
+import com.cobblemon.mod.common.net.messages.client.trade.TradeStartedPacket
 import com.cobblemon.mod.common.net.messages.client.trade.TradeStartedPacket.TradeablePokemon
 import com.cobblemon.mod.common.net.messages.server.trade.*
 import com.cobblemon.mod.common.pokemon.Gender
@@ -98,15 +99,23 @@ class TradeGUI(
         private val tradeAnimationArrowsResource = cobblemonResource("textures/gui/trade/trade_animation_arrows.png")
     }
 
-    private var offeredPokemonModel: ModelWidget? = null
-    private var opposingOfferedPokemonModel: ModelWidget? = null
+    private var offeredPokemonModels: MutableList<ModelWidget> = mutableListOf()
+    private var opposingOfferedPokemonModels: MutableList<ModelWidget> = mutableListOf()
 
     private lateinit var offeredPokemonMarkings: MarkingsWidget
     private lateinit var opposingOfferedPokemonMarkings: MarkingsWidget
 
+    var selectedPartyIndices = mutableListOf<Int>()
+    var offeredPokemons: MutableList<Pokemon> = mutableListOf()
+    var opposingPokemons: MutableList<Pokemon> = mutableListOf()
+
+    // For backwards compatibility where single is referenced in rendering text info
     var offeredPokemon: Pokemon? = null
     var opposingOfferedPokemon: Pokemon? = null
 
+    var myGridMode = true
+    var opposingGridMode = true
+
     var ticksElapsed = 0
     var protectiveTicks = 0
     var selectPointerOffsetY = 0
@@ -125,30 +134,67 @@ class TradeGUI(
         }
 
         trade.completedEmitter.subscribe {
-            val (pokemonId1, pokemonId2) = it
-            val myTradedPokemon = party.find { it?.pokemonId == pokemonId1 }
-            val theirTradedPokemon = traderParty.find { it?.pokemonId == pokemonId2 }
-            if (myTradedPokemon == null || theirTradedPokemon == null) {
+            val (pokemonIds1, pokemonIds2) = it
+            val myTradedPokemons = pokemonIds1.mapNotNull { id -> party.find { it?.pokemonId == id } }
+            val theirTradedPokemons = pokemonIds2.mapNotNull { id -> traderParty.find { it?.pokemonId == id } }
+            if (myTradedPokemons.isEmpty() || theirTradedPokemons.isEmpty()) {
                 CobblemonNetwork.sendToServer(CancelTradePacket())
                 return@subscribe onClose()
             }
-            val tradedSlot = party.indexOf(myTradedPokemon)
-            val opposingTradedSlot = traderParty.indexOf(theirTradedPokemon)
-            party[tradedSlot] = theirTradedPokemon
-            traderParty[opposingTradedSlot] = myTradedPokemon
+
+            myTradedPokemons.forEach { pk ->
+                val idx = party.indexOf(pk)
+                if (idx != -1) party[idx] = null
+            }
+            theirTradedPokemons.forEach { pk ->
+                val idx = traderParty.indexOf(pk)
+                if (idx != -1) traderParty[idx] = null
+            }
+
+            val newSelectedIndices = mutableListOf<Int>()
+            theirTradedPokemons.forEach { pk ->
+                val emptyIdx = party.indexOf(null)
+                if (emptyIdx != -1) {
+                    party[emptyIdx] = pk
+                }
+            }
+            myTradedPokemons.forEach { pk ->
+                val emptyIdx = traderParty.indexOf(null)
+                if (emptyIdx != -1) traderParty[emptyIdx] = pk
+            }
+
+            val compactUI = { list: MutableList<TradeStartedPacket.TradeablePokemon?> ->
+                val nonNulls = list.filterNotNull()
+                list.clear()
+                list.addAll(nonNulls)
+                while (list.size < 6) list.add(null)
+            }
+            compactUI(party)
+            compactUI(traderParty)
+
+            theirTradedPokemons.forEach { pk ->
+                val idx = party.indexOf(pk)
+                if (idx != -1) newSelectedIndices.add(idx)
+            }
 
             trade.oppositeAcceptedMyOffer.set(false)
-            CobblemonNetwork.sendToServer(UpdateTradeOfferPacket(Pair(theirTradedPokemon.pokemonId, PartyPosition(tradedSlot))))
+            selectedPartyIndices.clear()
+            selectedPartyIndices.addAll(newSelectedIndices)
+
+            val newOffers = selectedPartyIndices.mapNotNull { idx ->
+                party[idx]?.let { it.pokemonId to PartyPosition(idx) }
+            }
+            CobblemonNetwork.sendToServer(UpdateTradeOfferPacket(newOffers))
 
             rebuildWidgets()
         }
 
-        trade.oppositeOffer.subscribe { newOffer: Pokemon? ->
-            setOfferedPokemon(pokemon = newOffer, isOpposing = true)
+        trade.oppositeOffer.subscribe { newOffer: List<Pokemon> ->
+            setOfferedPokemon(pokemonList = newOffer, isOpposing = true)
         }
 
-        trade.myOffer.subscribe { myOffer: Pokemon? ->
-            setOfferedPokemon(pokemon = myOffer)
+        trade.myOffer.subscribe { myOffer: List<Pokemon> ->
+            setOfferedPokemon(pokemonList = myOffer)
         }
 
         trade.oppositeAcceptedMyOffer.subscribe {
@@ -216,9 +262,16 @@ class TradeGUI(
                 pokemon = pokemon,
                 parent = this,
                 onPress = {
-                    if (!trade.acceptedOppositeOffer && !tradeProcessing) {
-                        val pk = if (offeredPokemon?.uuid == pokemon?.pokemonId) null else pokemon
-                        CobblemonNetwork.sendToServer(UpdateTradeOfferPacket(pk?.let { it.pokemonId to PartyPosition(partyIndex) }))
+                    if (!trade.acceptedOppositeOffer && !tradeProcessing && pokemon != null) {
+                        if (selectedPartyIndices.contains(partyIndex)) {
+                            selectedPartyIndices.remove(partyIndex)
+                        } else if (selectedPartyIndices.size < 6) {
+                            selectedPartyIndices.add(partyIndex)
+                        }
+                        val newOffers = selectedPartyIndices.mapNotNull { idx ->
+                            party[idx]?.let { it.pokemonId to PartyPosition(idx) }
+                        }
+                        CobblemonNetwork.sendToServer(UpdateTradeOfferPacket(newOffers))
                         playSound(CobblemonSounds.GUI_CLICK)
                     }
                 }
@@ -250,8 +303,8 @@ class TradeGUI(
             ).also { widget -> addRenderableWidget(widget) }
         }
 
-        setOfferedPokemon(pokemon = offeredPokemon, isOpposing = false)
-        setOfferedPokemon(pokemon = opposingOfferedPokemon, isOpposing = true)
+        setOfferedPokemon(pokemonList = offeredPokemons.toList(), isOpposing = false)
+        setOfferedPokemon(pokemonList = opposingPokemons.toList(), isOpposing = true)
 
         offeredPokemonMarkings = MarkingsWidget(x + 74.5, y + 21, offeredPokemon, false)
         opposingOfferedPokemonMarkings = MarkingsWidget(x + 177.5, y + 21, opposingOfferedPokemon, false)
@@ -284,7 +337,7 @@ class TradeGUI(
                 if (tradeAnimationProgress > REVERSE_ANIMATION_TICK)
                     (REVERSE_ANIMATION_TICK + TRADE_ANIMATION_FRAMES - tradeAnimationProgress)
                 else (tradeAnimationProgress - MODEL_SCALE_BUFFER_FRAMES)
-            ) * TRADE_ANIMATION_HEIGHT
+                ) * TRADE_ANIMATION_HEIGHT
             blitk(
                 matrixStack = matrices,
                 texture = tradeAnimationResource,
@@ -313,20 +366,56 @@ class TradeGUI(
         // Render Model Portraits
         var scale = PORTRAIT_SCALE
         var scaleOffsetY = PORTRAIT_MODEL_OFFSET_Y
+        var isShrinking = false
         if (tradeProcessing) {
             val scaleInterval = if (tradeAnimationProgress > REVERSE_ANIMATION_TICK) (MAX_TRADE_PROGRESS - tradeAnimationProgress) else tradeAnimationProgress
             scale = (PORTRAIT_SCALE - (scaleInterval * PORTRAIT_SCALE_MULTIPLIER)).coerceIn(0F, PORTRAIT_SCALE)
             scaleOffsetY = (45.0 - (45.0 / PORTRAIT_SCALE) * scale) + PORTRAIT_MODEL_OFFSET_Y
+            isShrinking = true
         }
+        val shrinkPercentage = if (isShrinking) 1.0F - (scale / PORTRAIT_SCALE) else 0.0F
+        val myCenterXDest = x + 70 + (PORTRAIT_SIZE / 2.0)
+        val myCenterYDest = y + 30 + (PORTRAIT_SIZE / 2.0)
+        val opCenterXDest = x + 145 + (PORTRAIT_SIZE / 2.0)
+        val opCenterYDest = y + 30 + (PORTRAIT_SIZE / 2.0)
+
         if (scale > 0F) {
             context.enableScissor(backgroundX, backgroundY, backgroundX + BASE_BACKGROUND_WIDTH, backgroundY +  BASE_BACKGROUND_HEIGHT)
-            offeredPokemonModel?.baseScale = scale
-            offeredPokemonModel?.offsetY = scaleOffsetY
-            offeredPokemonModel?.render(context, mouseX, mouseY, delta)
 
-            opposingOfferedPokemonModel?.baseScale = scale
-            opposingOfferedPokemonModel?.offsetY = scaleOffsetY
-            opposingOfferedPokemonModel?.render(context, mouseX, mouseY, delta)
+            offeredPokemonModels.forEachIndexed { i, model ->
+                val posAndScale = getModelPositionAndScale(i, offeredPokemons.size, x + 70, y + 30)
+                val originalScale = posAndScale.second
+                model.baseScale = if (isShrinking) (originalScale / PORTRAIT_SCALE) * scale else originalScale
+                model.offsetY = if (isShrinking) scaleOffsetY else PORTRAIT_MODEL_OFFSET_Y
+
+                val startCenterX = posAndScale.first.first + (PORTRAIT_SIZE / 2.0)
+                val startCenterY = posAndScale.first.second + (PORTRAIT_SIZE / 2.0)
+
+                context.pose().pushPose()
+                context.pose().translate((myCenterXDest - startCenterX) * shrinkPercentage, (myCenterYDest - startCenterY) * shrinkPercentage, 0.0)
+
+                model.render(context, mouseX, mouseY, delta)
+
+                context.pose().popPose()
+            }
+
+            opposingOfferedPokemonModels.forEachIndexed { i, model ->
+                val posAndScale = getModelPositionAndScale(i, opposingPokemons.size, x + 145, y + 30)
+                val originalScale = posAndScale.second
+                model.baseScale = if (isShrinking) (originalScale / PORTRAIT_SCALE) * scale else originalScale
+                model.offsetY = if (isShrinking) scaleOffsetY else PORTRAIT_MODEL_OFFSET_Y
+
+                val startCenterX = posAndScale.first.first + (PORTRAIT_SIZE / 2.0)
+                val startCenterY = posAndScale.first.second + (PORTRAIT_SIZE / 2.0)
+
+                context.pose().pushPose()
+                context.pose().translate((opCenterXDest - startCenterX) * shrinkPercentage, (opCenterYDest - startCenterY) * shrinkPercentage, 0.0)
+
+                model.render(context, mouseX, mouseY, delta)
+
+                context.pose().popPose()
+            }
+
             context.disableScissor()
         }
 
@@ -341,8 +430,46 @@ class TradeGUI(
 
         renderInfoLabels(context, x, y)
 
-        renderPokemonInfo(offeredPokemon, false, context, x, y, mouseX, mouseY)
-        renderPokemonInfo(opposingOfferedPokemon, true, context, x, y, mouseX, mouseY)
+        children().filterIsInstance<PartySlot>().forEach { slot ->
+            if (slot.isHovered(mouseX, mouseY)) {
+                val hoveredId = slot.pokemon?.pokemonId
+                if (slot.isOpposing && slot.hasSelected()) {
+                    opposingPokemons.find { it.uuid == hoveredId }?.let { opposingOfferedPokemon = it }
+                } else if (!slot.isOpposing) {
+                    val matchingModel = offeredPokemons.find { it.uuid == hoveredId }
+                    if (matchingModel != null) {
+                        offeredPokemon = matchingModel
+                    } else {
+                        val realPokemon = com.cobblemon.mod.common.client.CobblemonClient.storage.party.find { it?.uuid == hoveredId }
+                        if (realPokemon != null) {
+                            offeredPokemon = realPokemon
+                        }
+                    }
+                }
+            }
+        }
+
+        val currentOffered = offeredPokemon
+        if (currentOffered != null) {
+            renderPokemonInfo(currentOffered, false, context, x, y, mouseX, mouseY)
+            if (::offeredPokemonMarkings.isInitialized) {
+                offeredPokemonMarkings.visible = true
+                if (offeredPokemonMarkings.pokemon != currentOffered) offeredPokemonMarkings.setActivePokemon(currentOffered)
+            }
+        } else {
+            if (::offeredPokemonMarkings.isInitialized) offeredPokemonMarkings.visible = false
+        }
+
+        val currentOpposing = opposingOfferedPokemon
+        if (currentOpposing != null) {
+            renderPokemonInfo(currentOpposing, true, context, x, y, mouseX, mouseY)
+            if (::opposingOfferedPokemonMarkings.isInitialized) {
+                opposingOfferedPokemonMarkings.visible = true
+                if (opposingOfferedPokemonMarkings.pokemon != currentOpposing) opposingOfferedPokemonMarkings.setActivePokemon(currentOpposing)
+            }
+        } else {
+            if (::opposingOfferedPokemonMarkings.isInitialized) opposingOfferedPokemonMarkings.visible = false
+        }
 
         if (trade.acceptedOppositeOffer) {
             blitk(
@@ -431,19 +558,25 @@ class TradeGUI(
 
         super.render(context, mouseX, mouseY, delta)
 
-        // Item Tooltip
-        if (offeredPokemon != null && !offeredPokemon!!.heldItemNoCopy().isEmpty) {
-            val itemX = x + 50
-            val itemY = y + 125
-            val itemHovered = mouseX.toFloat() in (itemX.toFloat()..(itemX.toFloat() + 16)) && mouseY.toFloat() in (itemY.toFloat()..(itemY.toFloat() + 16))
-            if (itemHovered) context.renderTooltip(Minecraft.getInstance().font, offeredPokemon!!.heldItemNoCopy(), mouseX, mouseY)
+        val ttOffered = offeredPokemon
+        if (ttOffered != null) {
+            // Item Tooltip
+            if (!ttOffered.heldItemNoCopy().isEmpty) {
+                val itemX = x + 50
+                val itemY = y + 125
+                val itemHovered = mouseX.toFloat() in (itemX.toFloat()..(itemX.toFloat() + 16)) && mouseY.toFloat() in (itemY.toFloat()..(itemY.toFloat() + 16))
+                if (itemHovered) context.renderTooltip(Minecraft.getInstance().font, ttOffered.heldItemNoCopy(), mouseX, mouseY)
+            }
         }
 
-        if (opposingOfferedPokemon != null && !opposingOfferedPokemon!!.heldItemNoCopy().isEmpty) {
-            val itemX = x + 227
-            val itemY = y + 125
-            val itemHovered = mouseX.toFloat() in (itemX.toFloat()..(itemX.toFloat() + 16)) && mouseY.toFloat() in (itemY.toFloat()..(itemY.toFloat() + 16))
-            if (itemHovered) context.renderTooltip(Minecraft.getInstance().font, opposingOfferedPokemon!!.heldItemNoCopy(), mouseX, mouseY)
+        val ttOpposing = opposingOfferedPokemon
+        if (ttOpposing != null) {
+            if (!ttOpposing.heldItemNoCopy().isEmpty) {
+                val itemX = x + 227
+                val itemY = y + 125
+                val itemHovered = mouseX.toFloat() in (itemX.toFloat()..(itemX.toFloat() + 16)) && mouseY.toFloat() in (itemY.toFloat()..(itemY.toFloat() + 16))
+                if (itemHovered) context.renderTooltip(Minecraft.getInstance().font, ttOpposing.heldItemNoCopy(), mouseX, mouseY)
+            }
         }
     }
 
@@ -480,11 +613,13 @@ class TradeGUI(
             }
 
             if (tradeAnimationProgress == (MAX_TRADE_PROGRESS + CRY_BUFFER)) {
-                if (offeredPokemonModel !== null && opposingOfferedPokemonModel !== null) {
-                    offeredPokemonModel!!.state.activeAnimations.clear()
-                    offeredPokemonModel!!.state.addFirstAnimation(setOf("cry"))
-                    opposingOfferedPokemonModel!!.state.activeAnimations.clear()
-                    opposingOfferedPokemonModel!!.state.addFirstAnimation(setOf("cry"))
+                offeredPokemonModels.forEach {
+                    it.state.activeAnimations.clear()
+                    it.state.addFirstAnimation(setOf("cry"))
+                }
+                opposingOfferedPokemonModels.forEach {
+                    it.state.activeAnimations.clear()
+                    it.state.addFirstAnimation(setOf("cry"))
                 }
             }
 
@@ -515,41 +650,140 @@ class TradeGUI(
 
     override fun renderMenuBackground(context: GuiGraphics) {}
 
-    private fun setOfferedPokemon(pokemon: Pokemon?, isOpposing: Boolean = false) {
+    private fun setOfferedPokemon(pokemonList: List<Pokemon>, isOpposing: Boolean = false) {
         protectiveTicks = 20
+        if (isOpposing) {
+            val wasEmpty = opposingPokemons.isEmpty()
+            val currentViewedUuid = if (opposingGridMode) null else opposingOfferedPokemon?.uuid
+            opposingPokemons.clear()
+            opposingPokemons.addAll(pokemonList)
+
+            val matchingPokemon = opposingPokemons.find { it.uuid == currentViewedUuid }
+
+            if (matchingPokemon != null) {
+                opposingOfferedPokemon = matchingPokemon
+                if (::opposingOfferedPokemonMarkings.isInitialized) opposingOfferedPokemonMarkings.setActivePokemon(opposingOfferedPokemon)
+            } else {
+                opposingOfferedPokemon = opposingPokemons.lastOrNull()
+                if (::opposingOfferedPokemonMarkings.isInitialized) opposingOfferedPokemonMarkings.setActivePokemon(opposingOfferedPokemon)
+                if (wasEmpty && opposingOfferedPokemon != null) {
+                    opposingGridMode = false
+                } else if (!opposingGridMode) {
+                    opposingGridMode = true
+                }
+            }
+            trade.acceptedOppositeOffer = false
+        } else {
+            val wasEmpty = offeredPokemons.isEmpty()
+            val currentViewedUuid = if (myGridMode) null else offeredPokemon?.uuid
+            offeredPokemons.clear()
+            offeredPokemons.addAll(pokemonList)
+
+            val matchingPokemon = offeredPokemons.find { it.uuid == currentViewedUuid }
+
+            if (matchingPokemon != null) {
+                offeredPokemon = matchingPokemon
+                if (::offeredPokemonMarkings.isInitialized) offeredPokemonMarkings.setActivePokemon(offeredPokemon)
+            } else {
+                offeredPokemon = offeredPokemons.lastOrNull()
+                if (::offeredPokemonMarkings.isInitialized) offeredPokemonMarkings.setActivePokemon(offeredPokemon)
+                if (wasEmpty && offeredPokemon != null) {
+                    myGridMode = false
+                } else if (!myGridMode) {
+                    myGridMode = true
+                }
+            }
+        }
+        rebuildSelectedModels(isOpposing)
+    }
+
+    private fun rebuildSelectedModels(isOpposing: Boolean) {
         val x = (width - BASE_WIDTH) / 2
         val y = (height - BASE_HEIGHT) / 2
 
         if (isOpposing) {
-            opposingOfferedPokemon = pokemon
-            opposingOfferedPokemonModel = if (pokemon != null) ModelWidget(
-                pX = x + 145,
-                pY = y + 30,
-                pWidth = PORTRAIT_SIZE,
-                pHeight = PORTRAIT_SIZE,
-                pokemon = pokemon.asRenderablePokemon(),
-                baseScale = PORTRAIT_SCALE,
-                rotationY = 35F,
-                offsetY = PORTRAIT_MODEL_OFFSET_Y
-            ) else null
-            if (::opposingOfferedPokemonMarkings.isInitialized) opposingOfferedPokemonMarkings.setActivePokemon(opposingOfferedPokemon)
-            trade.acceptedOppositeOffer = false
+            opposingOfferedPokemonModels.clear()
+            val total = opposingPokemons.size
+            opposingPokemons.forEachIndexed { i, pk ->
+                val (pos, currentScale) = getModelPositionAndScale(i, total, x + 145, y + 30)
+                opposingOfferedPokemonModels.add(ModelWidget(
+                    pX = pos.first, pY = pos.second,
+                    pWidth = PORTRAIT_SIZE, pHeight = PORTRAIT_SIZE,
+                    pokemon = pk.asRenderablePokemon(),
+                    baseScale = currentScale,
+                    rotationY = 35F,
+                    offsetY = PORTRAIT_MODEL_OFFSET_Y
+                ))
+            }
         } else {
-            offeredPokemon = pokemon
-            offeredPokemonModel = if (pokemon != null) ModelWidget(
-                pX = x + 70,
-                pY = y + 30,
-                pWidth = PORTRAIT_SIZE,
-                pHeight = PORTRAIT_SIZE,
-                pokemon = pokemon.asRenderablePokemon(),
-                baseScale = PORTRAIT_SCALE,
-                rotationY = 325F,
-                offsetY = PORTRAIT_MODEL_OFFSET_Y
-            ) else null
-            if (::offeredPokemonMarkings.isInitialized) offeredPokemonMarkings.setActivePokemon(offeredPokemon)
+            offeredPokemonModels.clear()
+            val total = offeredPokemons.size
+            offeredPokemons.forEachIndexed { i, pk ->
+                val (pos, currentScale) = getModelPositionAndScale(i, total, x + 70, y + 30)
+                offeredPokemonModels.add(ModelWidget(
+                    pX = pos.first, pY = pos.second,
+                    pWidth = PORTRAIT_SIZE, pHeight = PORTRAIT_SIZE,
+                    pokemon = pk.asRenderablePokemon(),
+                    baseScale = currentScale,
+                    rotationY = 325F,
+                    offsetY = PORTRAIT_MODEL_OFFSET_Y
+                ))
+            }
         }
     }
 
+    private fun getModelPositionAndScale(index: Int, total: Int, baseX: Int, baseY: Int): Pair<Pair<Int, Int>, Float> {
+        val scale = when (total) {
+            1 -> PORTRAIT_SCALE
+            2 -> PORTRAIT_SCALE * 0.75f
+            3 -> PORTRAIT_SCALE * 0.65f
+            4 -> PORTRAIT_SCALE * 0.55f
+            else -> PORTRAIT_SCALE * 0.5f
+        }
+
+        if (total <= 1) {
+            return Pair(Pair(baseX, baseY), scale)
+        }
+
+        val rowLength1 = when (total) {
+            2, 3, 4 -> 2
+            else -> 3
+        }
+        val rowLength2 = total - rowLength1
+
+        val isBottomRow = index >= rowLength1
+        val row = if (isBottomRow) 1 else 0
+        val col = if (isBottomRow) index - rowLength1 else index
+        val currentRowLength = if (isBottomRow) rowLength2 else rowLength1
+
+        val colSpacing = when (total) {
+            2 -> 35
+            3 -> 30
+            4 -> 25
+            else -> 23
+        }
+        val rowSpacing = when (total) {
+            2, 3 -> 30
+            4 -> 28
+            else -> 25
+        }
+
+        val totalWidth = (currentRowLength - 1) * colSpacing
+        val startX = baseX - (totalWidth / 2)
+
+        val totalHeight = if (rowLength2 > 0) rowSpacing else 0
+        var startY = baseY + 12 - (totalHeight / 2)
+
+        if (total >= 4) {
+            startY += 8
+        }
+
+        val posX = startX + (col * colSpacing)
+        val posY = startY + (row * rowSpacing)
+
+        return Pair(Pair(posX, posY), scale)
+    }
+
     private fun playSound(soundEvent: SoundEvent): SoundInstance {
         val soundInstance = SimpleSoundInstance.forUI(soundEvent, 1.0F)
         Minecraft.getInstance().soundManager.play(soundInstance)
@@ -557,10 +791,10 @@ class TradeGUI(
     }
 
     private fun cancelTradeSound() {
-        if (tradeSoundInstance !== null) Minecraft.getInstance().soundManager.stop(tradeSoundInstance)
+        if (tradeSoundInstance != null) Minecraft.getInstance().soundManager.stop(tradeSoundInstance!!)
     }
 
-    private fun renderPokemonInfo(pokemon: Pokemon?, isOpposing: Boolean, context: GuiGraphics, x: Int, y: Int, mouseX: Int, mouseY: Int) {
+    public fun renderPokemonInfo(pokemon: Pokemon?, isOpposing: Boolean, context: GuiGraphics, x: Int, y: Int, mouseX: Int, mouseY: Int) {
         if (pokemon != null) {
             val matrices = context.pose()
             // Level
@@ -1047,4 +1281,4 @@ class TradeGUI(
             scale = SCALE
         )
     }
-}
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/net/trade/TradeAcceptanceChangedHandler.kt

@@ -15,9 +15,9 @@ import net.minecraft.client.Minecraft
 
 object TradeAcceptanceChangedHandler : ClientNetworkPacketHandler<TradeAcceptanceChangedPacket> {
     override fun handle(packet: TradeAcceptanceChangedPacket, client: Minecraft) {
-        if (CobblemonClient.trade?.myOffer?.get()?.uuid == packet.pokemonId) {
+        if (CobblemonClient.trade?.myOffer?.get()?.any { it.uuid == packet.pokemonId } == true) {
             CobblemonClient.trade!!.oppositeAcceptedMyOffer.set(packet.accepted)
-        } else if (CobblemonClient.trade?.oppositeOffer?.get()?.uuid == packet.pokemonId) {
+        } else if (CobblemonClient.trade?.oppositeOffer?.get()?.any { it.uuid == packet.pokemonId } == true) {
             CobblemonClient.trade!!.acceptedOppositeOffer = packet.accepted
         }
     }

common/src/main/kotlin/com/cobblemon/mod/common/client/net/trade/TradeCompletedHandler.kt

@@ -16,6 +16,6 @@ import net.minecraft.client.Minecraft
 object TradeCompletedHandler : ClientNetworkPacketHandler<TradeCompletedPacket> {
     override fun handle(packet: TradeCompletedPacket, client: Minecraft) {
         val trade = CobblemonClient.trade ?: return
-        trade.completedEmitter.emit(packet.pokemonId1 to packet.pokemonId2)
+        trade.completedEmitter.emit(packet.pokemonIds1 to packet.pokemonIds2)
     }
 }

common/src/main/kotlin/com/cobblemon/mod/common/client/net/trade/TradeStartedHandler.kt

@@ -20,7 +20,7 @@ import net.minecraft.client.Minecraft
 
 object TradeStartedHandler : ClientNetworkPacketHandler<TradeStartedPacket> {
     override fun handle(packet: TradeStartedPacket, client: Minecraft) {
-        Cobblemon.LOGGER.error("handle trade start from: " + packet.traderId)
+        Cobblemon.LOGGER.info("Trade started with {}", packet.traderId)
         val trade = ClientTrade()
         CobblemonClient.trade = trade
         Minecraft.getInstance().setScreen(

common/src/main/kotlin/com/cobblemon/mod/common/client/net/trade/TradeUpdatedHandler.kt

@@ -18,9 +18,9 @@ object TradeUpdatedHandler : ClientNetworkPacketHandler<TradeUpdatedPacket> {
         val trade = CobblemonClient.trade ?: return
 
         if (packet.playerId == Minecraft.getInstance().player?.uuid) {
-            trade.myOffer.set(packet.pokemon)
+            trade.myOffer.set(packet.pokemons)
         } else {
-            trade.oppositeOffer.set(packet.pokemon)
+            trade.oppositeOffer.set(packet.pokemons)
         }
         trade.oppositeAcceptedMyOffer.set(false)
         trade.acceptedOppositeOffer = false

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/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/models/blockbench/pokemon/gen1/EkansModel.kt

@@ -1,104 +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.models.blockbench.pokemon.gen1
-
-import com.cobblemon.mod.common.client.render.models.blockbench.PosableState
-import com.cobblemon.mod.common.client.render.models.blockbench.animation.WaveAnimation
-import com.cobblemon.mod.common.client.render.models.blockbench.animation.WaveSegment
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.HeadedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.CryProvider
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonPosableModel
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.ModelPartTransformation.Companion.X_AXIS
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.ModelPartTransformation.Companion.Y_AXIS
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
-import com.cobblemon.mod.common.client.render.models.blockbench.wavefunction.sineFunction
-import com.cobblemon.mod.common.entity.PoseType
-import com.cobblemon.mod.common.entity.PoseType.Companion.MOVING_POSES
-import com.cobblemon.mod.common.entity.PoseType.Companion.STATIONARY_POSES
-import com.cobblemon.mod.common.entity.PoseType.Companion.UI_POSES
-import net.minecraft.client.model.geom.ModelPart
-import net.minecraft.world.phys.Vec3
-
-class EkansModel(root: ModelPart) : PokemonPosableModel(root), HeadedFrame {
-
-    override val rootPart = root.registerChildWithAllChildren("ekans")
-    private val body = getPart("body")
-    override val head = getPart("head")
-    private val tail = getPart("tail")
-    private val tail2 = getPart("tail2")
-    private val tail3 = getPart("tail3")
-    private val tail4 = getPart("tail4")
-    private val tail5 = getPart("tail5")
-    private val tail6 = getPart("tail6")
-
-    val tailSegment = WaveSegment(modelPart = tail, length = 9F)
-    val tail2Segment = WaveSegment(modelPart = tail2, length = 9F)
-    val tail3Segment = WaveSegment(modelPart = tail3, length = 9F)
-    val tail4Segment = WaveSegment(modelPart = tail4, length = 9F)
-    val tail5Segment = WaveSegment(modelPart = tail5, length = 10F)
-    val tail6Segment = WaveSegment(modelPart = tail6, length = 10F)
-
-    override var portraitScale = 1.7F
-    override var portraitTranslation = Vec3(-0.3, -0.45, 0.0)
-
-    override var profileScale = 0.7F
-    override var profileTranslation = Vec3(-0.05, 0.6, 0.0)
-
-    lateinit var sleep: Pose
-
-    override val cryAnimation = CryProvider { bedrockStateful("ekans", "cry") }
-
-    override fun registerPoses() {
-        sleep = registerPose(
-            poseType = PoseType.SLEEP,
-            animations = arrayOf(bedrock("ekans", "sleep"))
-        )
-        val blink = quirk { bedrockStateful("ekans", "blink") }
-        registerPose(
-            poseName = "normal",
-            poseTypes = STATIONARY_POSES + MOVING_POSES,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("ekans", "ground_idle"),
-                WaveAnimation(
-                    waveFunction = sineFunction(
-                        period = 8F,
-                        amplitude = 0.8F
-                    ),
-                    basedOnLimbSwing = true,
-                    oscillationsScalar = 5F,
-                    head = head,
-                    rotationAxis = Y_AXIS,
-                    motionAxis = X_AXIS,
-                    moveHead = false,
-                    headLength = 16F,
-                    segments = arrayOf(
-                        tailSegment,
-                        tail2Segment,
-                        tail3Segment,
-                        tail4Segment,
-                        tail5Segment,
-                        tail6Segment
-                    )
-                )
-            )
-        )
-
-        registerPose(
-            poseName = "portrait",
-            poseTypes = UI_POSES,
-            quirks = arrayOf(blink),
-            animations = arrayOf(bedrock("ekans", "summary_idle"))
-        )
-    }
-
-
-    override fun getFaintAnimation(state: PosableState) = bedrockStateful("ekans", "faint")
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen1/GloomModel.kt

@@ -1,63 +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.models.blockbench.pokemon.gen1
-
-import com.cobblemon.mod.common.client.render.models.blockbench.PosableState
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.CryProvider
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonPosableModel
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
-import com.cobblemon.mod.common.entity.PoseType
-import com.cobblemon.mod.common.entity.PoseType.Companion.MOVING_POSES
-import com.cobblemon.mod.common.entity.PoseType.Companion.STATIONARY_POSES
-import com.cobblemon.mod.common.entity.PoseType.Companion.UI_POSES
-import net.minecraft.client.model.geom.ModelPart
-import net.minecraft.world.phys.Vec3
-
-class GloomModel(root: ModelPart) : PokemonPosableModel(root) {
-    override val rootPart = root.registerChildWithAllChildren("gloom")
-
-    override var portraitScale = 1.8F
-    override var portraitTranslation = Vec3(-0.0, -1.0, 0.0)
-
-    override var profileScale = 1.05F
-    override var profileTranslation = Vec3(0.0, 0.19, 0.0)
-
-    lateinit var sleep: Pose
-    lateinit var standing: Pose
-    lateinit var walk: Pose
-
-    override val cryAnimation = CryProvider { bedrockStateful("gloom", "cry") }
-
-    override fun registerPoses() {
-        standing = registerPose(
-            poseName = "standing",
-            poseTypes = STATIONARY_POSES + UI_POSES,
-            transformTicks = 10,
-            animations = arrayOf(
-                bedrock("gloom", "ground_idle")
-            )
-        )
-
-        sleep = registerPose(
-            poseType = PoseType.SLEEP,
-            animations = arrayOf(bedrock("gloom", "sleep"))
-        )
-
-        walk = registerPose(
-            poseName = "walk",
-            poseTypes = MOVING_POSES,
-            transformTicks = 10,
-            animations = arrayOf(
-                bedrock("gloom", "ground_walk")
-            )
-        )
-    }
-
-    override fun getFaintAnimation(state: PosableState) = bedrockStateful("gloom", "faint")
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen1/OddishModel.kt

@@ -1,66 +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.models.blockbench.pokemon.gen1
-
-import com.cobblemon.mod.common.client.render.models.blockbench.PosableState
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.CryProvider
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonPosableModel
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
-import com.cobblemon.mod.common.entity.PoseType
-import com.cobblemon.mod.common.entity.PoseType.Companion.MOVING_POSES
-import com.cobblemon.mod.common.entity.PoseType.Companion.STATIONARY_POSES
-import com.cobblemon.mod.common.entity.PoseType.Companion.UI_POSES
-import net.minecraft.client.model.geom.ModelPart
-import net.minecraft.world.phys.Vec3
-
-class OddishModel(root: ModelPart) : PokemonPosableModel(root) {
-    override val rootPart = root.registerChildWithAllChildren("oddish")
-
-    override var portraitScale = 2.0F
-    override var portraitTranslation = Vec3(-0.0, -1.0, 0.0)
-
-    override var profileScale = 0.85F
-    override var profileTranslation = Vec3(0.0, 0.5, 0.0)
-
-    lateinit var sleep: Pose
-    lateinit var standing: Pose
-    lateinit var walk: Pose
-
-    override val cryAnimation = CryProvider { bedrockStateful("oddish", "cry") }
-
-    override fun registerPoses() {
-        val blink = quirk { bedrockStateful("oddish", "blink")}
-        standing = registerPose(
-            poseName = "standing",
-            poseTypes = STATIONARY_POSES + UI_POSES,
-            transformTicks = 10,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                bedrock("oddish", "ground_idle")
-            )
-        )
-
-        sleep = registerPose(
-                poseType = PoseType.SLEEP,
-                animations = arrayOf(bedrock("oddish", "sleep"))
-        )
-
-        walk = registerPose(
-            poseName = "walk",
-            poseTypes = MOVING_POSES,
-            transformTicks = 10,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                bedrock("oddish", "ground_walk")
-            )
-        )
-    }
-
-    override fun getFaintAnimation(state: PosableState) = bedrockStateful("oddish", "faint")
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen1/PoliwagModel.kt

@@ -1,75 +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.models.blockbench.pokemon.gen1
-
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.CryProvider
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonPosableModel
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
-import com.cobblemon.mod.common.entity.PoseType
-import com.cobblemon.mod.common.entity.PoseType.Companion.STANDING_POSES
-import com.cobblemon.mod.common.entity.PoseType.Companion.UI_POSES
-import net.minecraft.client.model.geom.ModelPart
-import net.minecraft.world.phys.Vec3
-
-class PoliwagModel(root: ModelPart) : PokemonPosableModel(root) {
-    override val rootPart = root.registerChildWithAllChildren("poliwag")
-
-    override var portraitScale = 1.8F
-    override var portraitTranslation = Vec3(0.0, -0.7, 0.0)
-
-    override var profileScale = 0.9F
-    override var profileTranslation = Vec3(0.0, 0.38, 0.0)
-
-    lateinit var sleep: Pose
-    lateinit var standing: Pose
-    lateinit var float: Pose
-    lateinit var swim: Pose
-
-    override val cryAnimation = CryProvider { bedrockStateful("poliwag", "cry") }
-
-    override fun registerPoses() {
-        val blink = quirk { bedrockStateful("poliwag", "blink")}
-        standing = registerPose(
-            poseName = "standing",
-            poseTypes = STANDING_POSES + UI_POSES,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                bedrock("poliwag", "ground_idle")
-            )
-        )
-
-        sleep = registerPose(
-                poseType = PoseType.SLEEP,
-                animations = arrayOf(bedrock("poliwag", "sleep"))
-        )
-
-        float = registerPose(
-            poseName = "float",
-            poseType = PoseType.FLOAT,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                bedrock("poliwag", "water_idle")
-            )
-        )
-
-        swim = registerPose(
-            poseName = "swim",
-            poseType = PoseType.SWIM,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                bedrock("poliwag", "water_swim")
-            )
-        )
-    }
-
-//    override fun getFaintAnimation(
-//    ) = if (state.isPosedIn(standing, walk)) bedrockStateful("poliwag", "faint") else null
-//        pokemonEntity: PokemonEntity,
-//        state: PosableState<PokemonEntity>
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen1/VileplumeModel.kt

@@ -1,66 +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.models.blockbench.pokemon.gen1
-
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonPosableModel
-import com.cobblemon.mod.common.client.render.models.blockbench.PosableState
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.CryProvider
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
-import com.cobblemon.mod.common.entity.PoseType
-import com.cobblemon.mod.common.entity.PoseType.Companion.MOVING_POSES
-import com.cobblemon.mod.common.entity.PoseType.Companion.STATIONARY_POSES
-import com.cobblemon.mod.common.entity.PoseType.Companion.UI_POSES
-import net.minecraft.client.model.geom.ModelPart
-import net.minecraft.world.phys.Vec3
-
-class VileplumeModel(root: ModelPart) : PokemonPosableModel(root) {
-    override val rootPart = root.registerChildWithAllChildren("vileplume")
-
-    override var portraitScale = 1.8F
-    override var portraitTranslation = Vec3(-0.35, -0.8, 0.0)
-
-    override var profileScale = 0.8F
-    override var profileTranslation = Vec3(0.0, 0.53, 0.0)
-
-    lateinit var sleep: Pose
-    lateinit var standing: Pose
-    lateinit var walk: Pose
-
-    override val cryAnimation = CryProvider { bedrockStateful("vileplume", "cry") }
-
-    override fun registerPoses() {
-        val blink = quirk { bedrockStateful("vileplume", "blink")}
-        standing = registerPose(
-            poseName = "standing",
-            poseTypes = STATIONARY_POSES + UI_POSES,
-            transformTicks = 10,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                bedrock("vileplume", "idle")
-            )
-        )
-
-        sleep = registerPose(
-                poseType = PoseType.SLEEP,
-                animations = arrayOf(bedrock("vileplume", "sleep"))
-        )
-
-        walk = registerPose(
-            poseName = "walk",
-            poseTypes = MOVING_POSES,
-            transformTicks = 10,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                bedrock("vileplume", "ground_walk")
-            )
-        )
-    }
-
-    override fun getFaintAnimation(state: PosableState) = bedrockStateful("vileplume", "faint")
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen2/BellossomModel.kt

@@ -1,95 +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.models.blockbench.pokemon.gen2
-
-import com.cobblemon.mod.common.client.render.models.blockbench.createTransformation
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.HeadedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonPosableModel
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.ModelPartTransformation
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
-import com.cobblemon.mod.common.entity.PoseType
-import com.cobblemon.mod.common.entity.PoseType.Companion.MOVING_POSES
-import com.cobblemon.mod.common.entity.PoseType.Companion.SHOULDER_POSES
-import com.cobblemon.mod.common.entity.PoseType.Companion.STATIONARY_POSES
-import com.cobblemon.mod.common.entity.PoseType.Companion.UI_POSES
-import net.minecraft.client.model.geom.ModelPart
-import net.minecraft.world.phys.Vec3
-
-class BellossomModel(root: ModelPart) : PokemonPosableModel(root), HeadedFrame {
-    override val rootPart = root.registerChildWithAllChildren("bellossom")
-    override val head = getPart("head")
-
-    override var portraitScale = 1.8F
-    override var portraitTranslation = Vec3(0.0, -0.2, 0.0)
-
-    override var profileScale = 1.0F
-    override var profileTranslation = Vec3(0.0, 0.21, 0.0)
-
-    lateinit var standing: Pose
-    lateinit var walk: Pose
-    lateinit var shoulderLeft: Pose
-    lateinit var shoulderRight: Pose
-
-    val shoulderOffset = 5
-
-    override fun registerPoses() {
-        val blink = quirk { bedrockStateful("bellossom", "blink") }
-        standing = registerPose(
-            poseName = "standing",
-            poseTypes = STATIONARY_POSES + UI_POSES,
-            transformTicks = 10,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                bedrock("bellossom", "ground_idle"),
-                singleBoneLook()
-            )
-        )
-
-        walk = registerPose(
-            poseName = "walk",
-            poseTypes = MOVING_POSES,
-            transformTicks = 10,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                bedrock("bellossom", "ground_idle"),
-                bedrock("bellossom", "ground_walk"),
-                singleBoneLook()
-            )
-        )
-
-        shoulderLeft = registerPose(
-                poseType = PoseType.SHOULDER_LEFT,
-                quirks = arrayOf(blink),
-                animations = arrayOf(
-                        singleBoneLook(),
-                        bedrock("bellossom", "ground_idle")
-                ),
-                transformedParts = arrayOf(
-                        rootPart.createTransformation().addPosition(ModelPartTransformation.X_AXIS, shoulderOffset)
-                )
-        )
-
-        shoulderRight = registerPose(
-                poseType = PoseType.SHOULDER_RIGHT,
-                quirks = arrayOf(blink),
-                animations = arrayOf(
-                        singleBoneLook(),
-                        bedrock("bellossom", "ground_idle")
-                ),
-                transformedParts = arrayOf(
-                        rootPart.createTransformation().addPosition(ModelPartTransformation.X_AXIS, -shoulderOffset)
-                )
-        )
-    }
-
-//    override fun getFaintAnimation(
-//        pokemonEntity: PokemonEntity,
-//        state: PosableState<PokemonEntity>
-//    ) = if (state.isPosedIn(standing, walk)) bedrockStateful("bellossom", "faint") else null
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen2/PolitoedModel.kt

@@ -1,80 +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.models.blockbench.pokemon.gen2
-
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.BipedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.HeadedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonPosableModel
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
-import com.cobblemon.mod.common.entity.PoseType
-import com.cobblemon.mod.common.entity.PoseType.Companion.UI_POSES
-import net.minecraft.client.model.geom.ModelPart
-import net.minecraft.world.phys.Vec3
-
-class PolitoedModel(root: ModelPart) : PokemonPosableModel(root), HeadedFrame, BipedFrame {
-    override val rootPart = root.registerChildWithAllChildren("politoed")
-    override val head = getPart("head")
-
-    override val leftLeg = getPart("leftleg")
-    override val rightLeg = getPart("rightleg")
-
-    override var portraitScale = 2.4F
-    override var portraitTranslation = Vec3(-0.04, -0.55, 0.0)
-
-    override var profileScale = 1.1F
-    override var profileTranslation = Vec3(0.0, 0.1, 0.0)
-
-    lateinit var standing: Pose
-    lateinit var walking: Pose
-    lateinit var float: Pose
-    lateinit var swim: Pose
-
-    override fun registerPoses() {
-        standing = registerPose(
-            poseName = "standing",
-            poseTypes = UI_POSES + PoseType.STAND,
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("politoed", "ground_idle")
-            )
-        )
-
-        walking = registerPose(
-            poseName = "walking",
-            poseType = PoseType.WALK,
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("politoed", "ground_idle")
-            )
-        )
-
-        float = registerPose(
-            poseName = "float",
-            poseTypes = setOf(PoseType.FLOAT, PoseType.HOVER),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("politoed", "water_idle")
-            )
-        )
-
-        swim = registerPose(
-            poseName = "swim",
-            poseTypes = setOf(PoseType.SWIM, PoseType.FLY),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("politoed", "water_swim")
-            )
-        )
-    }
-
-    //    override fun getFaintAnimation(
-//        pokemonEntity: PokemonEntity,
-//        state: PosableState<PokemonEntity>
-//    ) = if (state.isPosedIn(standing, walk)) bedrockStateful("politoed", "faint") else null
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen2/SudowoodoModel.kt

@@ -1,72 +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.models.blockbench.pokemon.gen2
-
-import com.cobblemon.mod.common.client.render.models.blockbench.animation.BimanualSwingAnimation
-import com.cobblemon.mod.common.client.render.models.blockbench.animation.BipedWalkAnimation
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.BimanualFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.BipedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.HeadedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonPosableModel
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
-import com.cobblemon.mod.common.entity.PoseType.Companion.MOVING_POSES
-import com.cobblemon.mod.common.entity.PoseType.Companion.STATIONARY_POSES
-import com.cobblemon.mod.common.entity.PoseType.Companion.UI_POSES
-import net.minecraft.client.model.geom.ModelPart
-import net.minecraft.world.phys.Vec3
-
-class SudowoodoModel(root: ModelPart) : PokemonPosableModel(root), HeadedFrame, BipedFrame, BimanualFrame {
-    override val rootPart = root.registerChildWithAllChildren("sudowoodo")
-    override val head = getPart("head")
-
-    override val leftArm = getPart("arm_left")
-    override val rightArm = getPart("arm_right")
-    override val leftLeg = getPart("leg_left")
-    override val rightLeg = getPart("leg_right")
-
-    override var portraitScale = 1.9F
-    override var portraitTranslation = Vec3(-0.7, 1.6, 0.0)
-
-    override var profileScale = 0.5F
-    override var profileTranslation = Vec3(-0.1, 0.95, 0.0)
-
-    lateinit var standing: Pose
-    lateinit var walk: Pose
-
-    override fun registerPoses() {
-        val blink = quirk { bedrockStateful("sudowoodo", "blink") }
-        standing = registerPose(
-            poseName = "standing",
-            poseTypes = STATIONARY_POSES + UI_POSES,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(yawMultiplier = 0F),
-                bedrock("sudowoodo", "ground_idle")
-            )
-        )
-
-        walk = registerPose(
-            poseName = "walk",
-            poseTypes = MOVING_POSES,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(yawMultiplier = 0F),
-                bedrock("sudowoodo", "ground_idle"),
-                BipedWalkAnimation(this, periodMultiplier = 0.6F, amplitudeMultiplier = 0.9F),
-                BimanualSwingAnimation(this, swingPeriodMultiplier = 0.6F, amplitudeMultiplier = 0.9F)
-                //bedrock("sudowoodo", "ground_walk")
-            )
-        )
-    }
-
-//    override fun getFaintAnimation(
-//        pokemonEntity: PokemonEntity,
-//        state: PosableState<PokemonEntity>
-//    ) = if (state.isPosedIn(standing, walk)) bedrockStateful("sudowoodo", "faint") else null
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen3/ShroomishModel.kt

@@ -1,91 +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.models.blockbench.pokemon.gen3
-
-import com.cobblemon.mod.common.client.render.models.blockbench.PosableState
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.BipedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.HeadedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.CryProvider
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonPosableModel
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
-import com.cobblemon.mod.common.entity.PoseType
-import com.cobblemon.mod.common.entity.PoseType.Companion.MOVING_POSES
-import com.cobblemon.mod.common.entity.PoseType.Companion.STATIONARY_POSES
-import com.cobblemon.mod.common.entity.PoseType.Companion.UI_POSES
-import com.cobblemon.mod.common.util.isBattling
-import net.minecraft.client.model.geom.ModelPart
-import net.minecraft.world.phys.Vec3
-
-class ShroomishModel(root: ModelPart) : PokemonPosableModel(root), HeadedFrame, BipedFrame {
-    override val rootPart = root.registerChildWithAllChildren("shroomish")
-    override val head = getPart("torso")
-
-    override val leftLeg = getPart("foot_left")
-    override val rightLeg = getPart("foot_right")
-
-    override var portraitScale = 2.0F
-    override var portraitTranslation = Vec3(-0.1, -1.2, 0.0)
-
-    override var profileScale = 1.0F
-    override var profileTranslation = Vec3(0.0, 0.3, 0.0)
-
-    lateinit var standing: Pose
-    lateinit var battling: Pose
-    lateinit var sleeping: Pose
-    lateinit var walk: Pose
-
-    override val cryAnimation = CryProvider { bedrockStateful("shroomish", "cry") }
-
-    override fun registerPoses() {
-        val blink = quirk { bedrockStateful("shroomish", "blink") }
-        standing = registerPose(
-            poseName = "standing",
-            poseTypes = STATIONARY_POSES + UI_POSES,
-            quirks = arrayOf(blink),
-            condition = { !it.isBattling },
-            animations = arrayOf(
-                singleBoneLook(pitchMultiplier = 0.5F),
-                bedrock("shroomish", "ground_idle")
-            )
-        )
-
-        walk = registerPose(
-            poseName = "walk",
-            poseTypes = MOVING_POSES,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(pitchMultiplier = 0.5F),
-                bedrock("shroomish", "ground_walk")
-            )
-        )
-
-        battling = registerPose(
-            poseName = "battlestanding",
-            poseTypes = STATIONARY_POSES,
-            transformTicks = 10,
-            quirks = arrayOf(blink),
-            condition = { it.isBattling },
-            animations = arrayOf(
-                singleBoneLook(pitchMultiplier = 0.5F),
-                bedrock("shroomish", "battle_idle")
-            )
-        )
-
-        sleeping = registerPose(
-            poseName = "sleeping",
-            poseType = PoseType.SLEEP,
-            transformTicks = 10,
-            animations = arrayOf(
-                bedrock("shroomish", "sleep")
-            )
-        )
-    }
-
-    override fun getFaintAnimation(state: PosableState) = if (state.isPosedIn(standing, walk, battling, sleeping)) bedrockStateful("shroomish", "faint") else null
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen4/BonslyModel.kt

@@ -1,102 +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.models.blockbench.pokemon.gen4
-
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.BipedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.HeadedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonPosableModel
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
-import com.cobblemon.mod.common.entity.PoseType
-import com.cobblemon.mod.common.entity.PoseType.Companion.MOVING_POSES
-import com.cobblemon.mod.common.entity.PoseType.Companion.STATIONARY_POSES
-import com.cobblemon.mod.common.entity.PoseType.Companion.UI_POSES
-import com.cobblemon.mod.common.util.isBattling
-import net.minecraft.client.model.geom.ModelPart
-import net.minecraft.world.phys.Vec3
-
-class BonslyModel(root: ModelPart) : PokemonPosableModel(root), HeadedFrame, BipedFrame {
-    override val rootPart = root.registerChildWithAllChildren("bonsly")
-    override val head = getPart("torso")
-
-    override val leftLeg = getPart("leg_left")
-    override val rightLeg = getPart("leg_right")
-
-    override var portraitScale = 2.2F
-    override var portraitTranslation = Vec3(-0.2, -0.8, 0.0)
-
-    override var profileScale = 0.72F
-    override var profileTranslation = Vec3(0.0, 0.65, 0.0)
-
-    lateinit var standing: Pose
-    lateinit var walk: Pose
-    lateinit var battleidle: Pose
-    lateinit var sleep: Pose
-    lateinit var battlesleep: Pose
-
-    override fun registerPoses() {
-        val blink = quirk { bedrockStateful("bonsly", "blink") }
-        standing = registerPose(
-            poseName = "standing",
-            poseTypes = STATIONARY_POSES + UI_POSES,
-            quirks = arrayOf(blink),
-            condition = { !it.isBattling },
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("bonsly", "ground_idle")
-            )
-        )
-
-        walk = registerPose(
-            poseName = "walk",
-            poseTypes = MOVING_POSES,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("bonsly", "ground_walk")
-            )
-        )
-
-        sleep = registerPose(
-            poseName = "sleep",
-            poseType = PoseType.SLEEP,
-            condition = { !it.isBattling },
-            animations = arrayOf(
-                bedrock("bonsly", "sleep_pot")
-            )
-        )
-
-        battlesleep = registerPose(
-            poseName = "battlesleep",
-            poseType = PoseType.SLEEP,
-            condition = { it.isBattling },
-            animations = arrayOf(
-                bedrock("bonsly", "sleep")
-            )
-        )
-
-        battleidle = registerPose(
-            poseName = "battle_idle",
-            poseTypes = PoseType.STATIONARY_POSES,
-            transformTicks = 10,
-            quirks = arrayOf(blink),
-            condition = { it.isBattling },
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("bonsly", "battle_idle")
-            )
-        )
-    }
-
-//    override fun getFaintAnimation(
-//        pokemonEntity: PokemonEntity,
-//        state: PosableState<PokemonEntity>
-//    ) = if (state.isPosedIn(standing, walk))
-//        bedrockStateful("bonsly", "faint")
-//    else null
-}

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

@@ -231,13 +231,8 @@ object VaryingModelRepository {
         inbuilt("paras", ::ParasModel)
         inbuilt("mankey", ::MankeyModel)
         inbuilt("primeape", ::PrimeapeModel)
-        inbuilt("oddish", ::OddishModel)
-        inbuilt("gloom", ::GloomModel)
-        inbuilt("vileplume", ::VileplumeModel)
-        inbuilt("bellossom", ::BellossomModel)
         inbuilt("voltorb", ::VoltorbModel)
         inbuilt("electrode", ::ElectrodeModel)
-        inbuilt("ekans", ::EkansModel)
         inbuilt("machop", ::MachopModel)
         inbuilt("machoke", ::MachokeModel)
         inbuilt("machamp", ::MachampModel)
@@ -266,8 +261,6 @@ object VaryingModelRepository {
         inbuilt("nidorino", ::NidorinoModel)
         inbuilt("persian", ::PersianModel)
         inbuilt("pinsir", ::PinsirModel)
-        inbuilt("poliwag", ::PoliwagModel)
-        inbuilt("politoed", ::PolitoedModel)
         inbuilt("ponyta", ::PonytaModel)
         inbuilt("psyduck", ::PsyduckModel)
         inbuilt("rapidash", ::RapidashModel)
@@ -375,7 +368,6 @@ object VaryingModelRepository {
         inbuilt("gliscor", ::GliscorModel)
         inbuilt("poochyena", ::PoochyenaModel)
         inbuilt("mightyena", ::MightyenaModel)
-        inbuilt("shroomish", ::ShroomishModel)
         inbuilt("breloom", ::BreloomModel)
         inbuilt("charcadet", ::CharcadetModel)
         inbuilt("flittle", ::FlittleModel)
@@ -397,8 +389,6 @@ object VaryingModelRepository {
         inbuilt("sirfetchd", ::SirfetchdModel)
         inbuilt("duskull", ::DuskullModel)
         inbuilt("dusclops", ::DusclopsModel)
-        inbuilt("bonsly", ::BonslyModel)
-        inbuilt("sudowoodo", ::SudowoodoModel)
         inbuilt("cetoddle", ::CetoddleModel)
         inbuilt("cetitan", ::CetitanModel)
         inbuilt("aipom", ::AipomModel)

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/client/trade/ClientTrade.kt

@@ -14,12 +14,12 @@ import com.cobblemon.mod.common.pokemon.Pokemon
 import java.util.UUID
 
 class ClientTrade {
-    var myOffer = SettableObservable<Pokemon?>(null)
-    var oppositeOffer = SettableObservable<Pokemon?>(null)
+    var myOffer = SettableObservable<List<Pokemon>>(emptyList())
+    var oppositeOffer = SettableObservable<List<Pokemon>>(emptyList())
     var tradeProcessing = SettableObservable(Pair(false, false))
     var oppositeAcceptedMyOffer = SettableObservable(false)
     var acceptedOppositeOffer = false
 
-    var completedEmitter = SimpleObservable<Pair<UUID, UUID>>()
+    var completedEmitter = SimpleObservable<Pair<List<UUID>, List<UUID>>>()
     var cancelEmitter = SimpleObservable<Unit>()
 }

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/events/AdvancementHandler.kt

@@ -31,6 +31,7 @@ import net.minecraft.world.item.BlockItem
 import com.cobblemon.mod.common.platform.events.ServerPlayerEvent
 import com.cobblemon.mod.common.api.storage.player.PlayerInstancedDataStoreTypes
 import com.cobblemon.mod.common.item.GemItem
+import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.platform.events.PlatformEvents
 import com.cobblemon.mod.common.util.effectiveName
 import com.cobblemon.mod.common.util.getPlayer
@@ -164,26 +165,21 @@ object AdvancementHandler : EventHandler {
     }
 
     fun onTradeCompleted(event : TradeEvent.Post) {
-        val player1 = event.tradeParticipant1Pokemon.getOwnerPlayer()
-        val player2 = event.tradeParticipant2Pokemon.getOwnerPlayer()
-        if (player1 != null) {
-            CobblemonCriteria.TRADE_POKEMON.trigger(player1, TradePokemonContext(event.tradeParticipant1Pokemon, event.tradeParticipant2Pokemon))
-            val playerData = Cobblemon.playerDataManager.getGenericData(player1)
-            val advancementData = playerData.advancementData
-            advancementData.updateTotalTradedCount()
-            advancementData.updateAspectsCollected(player1, event.tradeParticipant2Pokemon)
-            CobblemonCriteria.COLLECT_ASPECT.trigger(player1, advancementData.aspectsCollected)
-            Cobblemon.playerDataManager.saveSingle(playerData, PlayerInstancedDataStoreTypes.GENERAL)
-        }
-        if (player2 != null) {
-            CobblemonCriteria.TRADE_POKEMON.trigger(player2, TradePokemonContext(event.tradeParticipant2Pokemon, event.tradeParticipant1Pokemon))
-            val playerData = Cobblemon.playerDataManager.getGenericData(player2)
-            val advancementData = playerData.advancementData
-            advancementData.updateTotalTradedCount()
-            advancementData.updateAspectsCollected(player2, event.tradeParticipant1Pokemon)
-            CobblemonCriteria.COLLECT_ASPECT.trigger(player2, advancementData.aspectsCollected)
-            Cobblemon.playerDataManager.saveSingle(playerData, PlayerInstancedDataStoreTypes.GENERAL)
+        onTradeCompleted(event.tradeParticipant1Pokemon, event.tradeParticipant2Pokemon)
+        onTradeCompleted(event.tradeParticipant2Pokemon, event.tradeParticipant1Pokemon)
+    }
+
+    private fun onTradeCompleted(received: List<Pokemon>, traded: List<Pokemon>) {
+        val player = received.firstOrNull()?.getOwnerPlayer() ?: return
+        received.forEach { receivedPokemon ->
+            traded.forEach { tradedPokemon -> CobblemonCriteria.TRADE_POKEMON.trigger(player, TradePokemonContext(tradedPokemon, receivedPokemon)) }
         }
+        val playerData = Cobblemon.playerDataManager.getGenericData(player)
+        val advancementData = playerData.advancementData
+        advancementData.updateTotalTradedCount()
+        received.forEach { advancementData.updateAspectsCollected(player, it) }
+        CobblemonCriteria.COLLECT_ASPECT.trigger(player, advancementData.aspectsCollected)
+        Cobblemon.playerDataManager.saveSingle(playerData, PlayerInstancedDataStoreTypes.GENERAL)
     }
 
     /**

common/src/main/kotlin/com/cobblemon/mod/common/events/StatHandler.kt

@@ -110,8 +110,8 @@ object StatHandler : EventHandler {
     }
 
     fun onTradeCompleted(event : TradeEvent.Post) {
-        event.tradeParticipant1Pokemon.getOwnerPlayer()?.awardStat(getStat(Cobblemon.statistics.TRADED))
-        event.tradeParticipant2Pokemon.getOwnerPlayer()?.awardStat(getStat(Cobblemon.statistics.TRADED))
+        event.tradeParticipant1Pokemon.firstOrNull()?.getOwnerPlayer()?.awardStat(getStat(Cobblemon.statistics.TRADED))
+        event.tradeParticipant2Pokemon.firstOrNull()?.getOwnerPlayer()?.awardStat(getStat(Cobblemon.statistics.TRADED))
     }
 
     fun onFossilRevived(event : FossilRevivedEvent) {

common/src/main/kotlin/com/cobblemon/mod/common/item/GlowItem.kt

@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.item
+
+import com.cobblemon.mod.common.CobblemonSounds
+import net.minecraft.sounds.SoundSource
+import net.minecraft.world.entity.player.Player
+import net.minecraft.world.item.ItemNameBlockItem
+import net.minecraft.world.item.SignApplicator
+import net.minecraft.world.level.Level
+import net.minecraft.world.level.block.Block
+import net.minecraft.world.level.block.entity.SignBlockEntity
+import net.minecraft.world.level.block.entity.SignText
+
+class GlowItem(block: Block, settings: Properties) : ItemNameBlockItem(block, settings), SignApplicator {
+
+    override fun tryApplyToSign(level: Level, sign: SignBlockEntity, isFront: Boolean, player: Player?): Boolean {
+        if (sign.updateText({ signText: SignText? -> signText!!.setHasGlowingText(true) }, isFront)) {
+            level.playSound(
+                null as Player?,
+                sign.blockPos,
+                CobblemonSounds.BRIGHT_POWDER_USE,
+                SoundSource.BLOCKS,
+                1.0f,
+                1.0f
+            )
+            return true
+        } else {
+            return false
+        }
+    }
+
+}

common/src/main/kotlin/com/cobblemon/mod/common/item/MoomooMilk.kt

@@ -13,10 +13,12 @@ import com.cobblemon.mod.common.api.battles.model.actor.BattleActor
 import com.cobblemon.mod.common.battles.pokemon.BattlePokemon
 import com.cobblemon.mod.common.item.battle.BagItem
 import com.cobblemon.mod.common.item.battle.SimpleBagItemLike
+import net.minecraft.world.item.ItemNameBlockItem
 import net.minecraft.world.item.ItemStack
 import net.minecraft.world.item.Items
+import net.minecraft.world.level.block.Block
 
-class MoomooMilk(properties: Properties) : CobblemonItem(properties), SimpleBagItemLike {
+class MoomooMilk(properties: Properties, block: Block) : ItemNameBlockItem(block, properties), SimpleBagItemLike {
     override val bagItem = object : BagItem {
         override val itemName = "item.cobblemon.moomoo_milk"
         override val returnItem = Items.GLASS_BOTTLE

common/src/main/kotlin/com/cobblemon/mod/common/item/group/CobblemonItemGroups.kt

@@ -12,9 +12,11 @@ import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.CobblemonItemComponents
 import com.cobblemon.mod.common.CobblemonItems
 import com.cobblemon.mod.common.api.riding.stats.RidingStat
+import com.cobblemon.mod.common.api.tms.TechnicalMachines
 import com.cobblemon.mod.common.block.TypeGemClusterBlock
 import com.cobblemon.mod.common.item.AprijuiceItem
 import com.cobblemon.mod.common.item.components.RideBoostsComponent
+import com.cobblemon.mod.common.item.components.TMMoveComponent
 import com.cobblemon.mod.common.util.cobblemonResource
 import net.minecraft.core.component.DataComponents
 import net.minecraft.core.registries.BuiltInRegistries
@@ -40,44 +42,111 @@ object CobblemonItemGroups {
     private val ALL = arrayListOf<ItemGroupHolder>()
     private val INJECTORS = hashMapOf<ResourceKey<CreativeModeTab>, (injector: Injector) -> Unit>()
 
-    @JvmStatic val BLOCKS_KEY = this.create("blocks", this::blockEntries) {
+    @JvmStatic
+    val BLOCKS_KEY = this.create("blocks", this::blockEntries) {
         ItemStack(CobblemonItems.PC)
     }
-    @JvmStatic val UTILITY_ITEMS_KEY = this.create("utility_item", this::utilityItemEntries) {
+    @JvmStatic
+    val UTILITY_ITEMS_KEY = this.create("utility_item", this::utilityItemEntries) {
         ItemStack(CobblemonItems.POKE_BALL)
     }
-    @JvmStatic val AGRICULTURE_KEY = this.create("agriculture", this::agricultureEntries) {
+    @JvmStatic
+    val AGRICULTURE_KEY = this.create("agriculture", this::agricultureEntries) {
         ItemStack(CobblemonItems.MEDICINAL_LEEK)
     }
-    @JvmStatic val ARCHAEOLOGY_KEY = this.create("archaeology", this::archaeologyEntries) {
+    @JvmStatic
+    val ARCHAEOLOGY_KEY = this.create("archaeology", this::archaeologyEntries) {
         ItemStack(CobblemonItems.HELIX_FOSSIL)
     }
-    @JvmStatic val CONSUMABLES_KEY = this.create("consumables", this::consumableEntries) {
+    @JvmStatic
+    val CONSUMABLES_KEY = this.create("consumables", this::consumableEntries) {
         ItemStack(CobblemonItems.ROASTED_LEEK)
     }
-    @JvmStatic val HELD_ITEMS_KEY = this.create("held_item", this::heldItemEntries) {
+    @JvmStatic
+    val HELD_ITEMS_KEY = this.create("held_item", this::heldItemEntries) {
         ItemStack(CobblemonItems.EXP_SHARE)
     }
-    @JvmStatic val EVOLUTION_ITEMS_KEY = this.create("evolution_item", this::evolutionItemEntries) {
+    @JvmStatic
+    val EVOLUTION_ITEMS_KEY = this.create("evolution_item", this::evolutionItemEntries) {
         ItemStack(CobblemonItems.BLACK_AUGURITE)
     }
 
-    @JvmStatic val BLOCKS get() = BuiltInRegistries.CREATIVE_MODE_TAB.get(BLOCKS_KEY)
-    @JvmStatic val UTILITY_ITEMS get() = BuiltInRegistries.CREATIVE_MODE_TAB.get(UTILITY_ITEMS_KEY)
-    @JvmStatic val AGRICULTURE get() = BuiltInRegistries.CREATIVE_MODE_TAB.get(AGRICULTURE_KEY)
-    @JvmStatic val ARCHAEOLOGY get() = BuiltInRegistries.CREATIVE_MODE_TAB.get(ARCHAEOLOGY_KEY)
-    @JvmStatic val CONSUMABLES get() = BuiltInRegistries.CREATIVE_MODE_TAB.get(CONSUMABLES_KEY)
-    @JvmStatic val HELD_ITEMS get() = BuiltInRegistries.CREATIVE_MODE_TAB.get(HELD_ITEMS_KEY)
-    @JvmStatic val EVOLUTION_ITEMS get() = BuiltInRegistries.CREATIVE_MODE_TAB.get(EVOLUTION_ITEMS_KEY)
+    @JvmStatic
+    val TM_ITEMS_KEY = this.create("tm_item", this::tmItemEntries) {
+        ItemStack(CobblemonItems.BLANK_TM)
+    }
 
-    @JvmStatic val BUILDING_BLOCKS_INJECTIONS = this.inject(ResourceKey.create(BuiltInRegistries.CREATIVE_MODE_TAB.key(), ResourceLocation.parse("building_blocks")), this::blocksInjections)
-    @JvmStatic val COLORED_BLOCKS_INJECTIONS = this.inject(ResourceKey.create(BuiltInRegistries.CREATIVE_MODE_TAB.key(), ResourceLocation.parse("colored_blocks")), this::coloredBlocksInjections)
-    @JvmStatic val FUNCTIONAL_BLOCKS = this.inject(ResourceKey.create(BuiltInRegistries.CREATIVE_MODE_TAB.key(), ResourceLocation.parse("functional_blocks")), this::functionalBlocksInjections)
-    @JvmStatic val REDSTONE_BLOCKS = this.inject(ResourceKey.create(BuiltInRegistries.CREATIVE_MODE_TAB.key(), ResourceLocation.parse("redstone_blocks")), this::redstoneBlocksInjections)
-    @JvmStatic val FOOD_INJECTIONS = this.inject(ResourceKey.create(BuiltInRegistries.CREATIVE_MODE_TAB.key(), ResourceLocation.parse("food_and_drinks")), this::foodInjections)
-    @JvmStatic val TOOLS_AND_UTILITIES_INJECTIONS = this.inject(ResourceKey.create(BuiltInRegistries.CREATIVE_MODE_TAB.key(), ResourceLocation.parse("tools_and_utilities")), this::toolsAndUtilitiesInjections)
-    @JvmStatic val INGREDIENTS_INJECTIONS = this.inject(ResourceKey.create(BuiltInRegistries.CREATIVE_MODE_TAB.key(), ResourceLocation.parse("ingredients")), this::ingredientsInjections)
-    @JvmStatic val OP_BLOCKS_INJECTIONS = this.inject(ResourceKey.create(BuiltInRegistries.CREATIVE_MODE_TAB.key(), ResourceLocation.parse("op_blocks")), this::opBlocksInjections)
+    @JvmStatic
+    val BLOCKS get() = BuiltInRegistries.CREATIVE_MODE_TAB.get(BLOCKS_KEY)
+    @JvmStatic
+    val UTILITY_ITEMS get() = BuiltInRegistries.CREATIVE_MODE_TAB.get(UTILITY_ITEMS_KEY)
+    @JvmStatic
+    val AGRICULTURE get() = BuiltInRegistries.CREATIVE_MODE_TAB.get(AGRICULTURE_KEY)
+    @JvmStatic
+    val ARCHAEOLOGY get() = BuiltInRegistries.CREATIVE_MODE_TAB.get(ARCHAEOLOGY_KEY)
+    @JvmStatic
+    val CONSUMABLES get() = BuiltInRegistries.CREATIVE_MODE_TAB.get(CONSUMABLES_KEY)
+    @JvmStatic
+    val HELD_ITEMS get() = BuiltInRegistries.CREATIVE_MODE_TAB.get(HELD_ITEMS_KEY)
+    @JvmStatic
+    val EVOLUTION_ITEMS get() = BuiltInRegistries.CREATIVE_MODE_TAB.get(EVOLUTION_ITEMS_KEY)
+    @JvmStatic
+    val TM_ITEMS get() = BuiltInRegistries.CREATIVE_MODE_TAB.get(TM_ITEMS_KEY)
+
+    @JvmStatic
+    val BUILDING_BLOCKS_INJECTIONS = this.inject(
+        ResourceKey.create(
+            BuiltInRegistries.CREATIVE_MODE_TAB.key(),
+            ResourceLocation.parse("building_blocks")
+        ), this::blocksInjections
+    )
+    @JvmStatic
+    val COLORED_BLOCKS_INJECTIONS = this.inject(
+        ResourceKey.create(
+            BuiltInRegistries.CREATIVE_MODE_TAB.key(),
+            ResourceLocation.parse("colored_blocks")
+        ), this::coloredBlocksInjections
+    )
+    @JvmStatic
+    val FUNCTIONAL_BLOCKS = this.inject(
+        ResourceKey.create(
+            BuiltInRegistries.CREATIVE_MODE_TAB.key(),
+            ResourceLocation.parse("functional_blocks")
+        ), this::functionalBlocksInjections
+    )
+    @JvmStatic
+    val REDSTONE_BLOCKS = this.inject(
+        ResourceKey.create(
+            BuiltInRegistries.CREATIVE_MODE_TAB.key(),
+            ResourceLocation.parse("redstone_blocks")
+        ), this::redstoneBlocksInjections
+    )
+    @JvmStatic
+    val FOOD_INJECTIONS = this.inject(
+        ResourceKey.create(
+            BuiltInRegistries.CREATIVE_MODE_TAB.key(),
+            ResourceLocation.parse("food_and_drinks")
+        ), this::foodInjections
+    )
+    @JvmStatic
+    val TOOLS_AND_UTILITIES_INJECTIONS = this.inject(
+        ResourceKey.create(
+            BuiltInRegistries.CREATIVE_MODE_TAB.key(),
+            ResourceLocation.parse("tools_and_utilities")
+        ), this::toolsAndUtilitiesInjections
+    )
+    @JvmStatic
+    val INGREDIENTS_INJECTIONS = this.inject(
+        ResourceKey.create(
+            BuiltInRegistries.CREATIVE_MODE_TAB.key(),
+            ResourceLocation.parse("ingredients")
+        ), this::ingredientsInjections
+    )
+    @JvmStatic
+    val OP_BLOCKS_INJECTIONS = this.inject(
+        ResourceKey.create(BuiltInRegistries.CREATIVE_MODE_TAB.key(), ResourceLocation.parse("op_blocks")),
+        this::opBlocksInjections
+    )
 
     fun register(consumer: (holder: ItemGroupHolder) -> CreativeModeTab) {
         ALL.forEach(consumer::invoke)
@@ -96,13 +165,20 @@ object CobblemonItemGroups {
         val displayName: Component = Component.translatable("itemGroup.${key.location().namespace}.${key.location().path}")
     )
 
-    private fun create(name: String, entryCollector: DisplayItemsGenerator, displayIconProvider: () -> ItemStack): ResourceKey<CreativeModeTab> {
+    private fun create(
+        name: String,
+        entryCollector: DisplayItemsGenerator,
+        displayIconProvider: () -> ItemStack
+    ): ResourceKey<CreativeModeTab> {
         val key = ResourceKey.create(BuiltInRegistries.CREATIVE_MODE_TAB.key(), cobblemonResource(name))
         this.ALL += ItemGroupHolder(key, displayIconProvider, entryCollector)
         return key
     }
 
-    private fun inject(key: ResourceKey<CreativeModeTab>, consumer: (injector: Injector) -> Unit): (injector: Injector) -> Unit {
+    private fun inject(
+        key: ResourceKey<CreativeModeTab>,
+        consumer: (injector: Injector) -> Unit
+    ): (injector: Injector) -> Unit {
         this.INJECTORS[key] = consumer
         return consumer
     }
@@ -122,6 +198,14 @@ object CobblemonItemGroups {
         entries.accept(CobblemonItems.GALARICA_NUTS)
         entries.accept(CobblemonItems.HEARTY_GRAINS)
         entries.accept(CobblemonItems.TASTY_TAIL)
+        entries.accept(CobblemonItems.POMOHANA)
+        entries.accept(CobblemonItems.PAUVILLEA)
+        entries.accept(CobblemonItems.LOBAILA)
+        entries.accept(CobblemonItems.WISTENSU)
+        entries.accept(CobblemonItems.VOLTACONIA)
+        entries.accept(CobblemonItems.VERDROOT)
+        entries.accept(CobblemonItems.MISTLEAF)
+        entries.accept(CobblemonItems.LUCIBELL)
 //        entries.accept(CobblemonItems.BUGWORT) // TODO after 1.7
 
         entries.accept(CobblemonItems.RED_APRICORN)
@@ -631,8 +715,6 @@ object CobblemonItemGroups {
         entries.accept(CobblemonItems.ABILITY_CAPSULE)
         entries.accept(CobblemonItems.ABILITY_PATCH)
 
-        entries.accept(CobblemonItems.BLANK_TM)
-
         entries.accept(CobblemonItems.POKE_BAIT)
         entries.accept(CobblemonItems.POKE_SNACK)
         entries.accept(CobblemonItems.POKE_CAKE)
@@ -649,15 +731,17 @@ object CobblemonItemGroups {
 
     private fun defaultAprijuice(item: AprijuiceItem): ItemStack {
         return ItemStack(item).apply {
-            this.set(CobblemonItemComponents.RIDE_BOOST, RideBoostsComponent(
-                mapOf(
-                    RidingStat.ACCELERATION to 1,
-                    RidingStat.JUMP to 1,
-                    RidingStat.SPEED to 1,
-                    RidingStat.STAMINA to 1,
-                    RidingStat.SKILL to 1
+            this.set(
+                CobblemonItemComponents.RIDE_BOOST, RideBoostsComponent(
+                    mapOf(
+                        RidingStat.ACCELERATION to 1,
+                        RidingStat.JUMP to 1,
+                        RidingStat.SPEED to 1,
+                        RidingStat.STAMINA to 1,
+                        RidingStat.SKILL to 1
+                    )
                 )
-            ))
+            )
         }
     }
 
@@ -848,6 +932,16 @@ object CobblemonItemGroups {
         entries.accept(CobblemonItems.PSYCHIC_SEED)
     }
 
+    private fun tmItemEntries(displayContext: ItemDisplayParameters, entries: Output) {
+        entries.accept(CobblemonItems.BLANK_TM)
+        TechnicalMachines
+            .tmMap
+            .entries
+            .sortedBy { it.value.moveName.name }
+            .sortedBy { it.value.moveName.elementalType.order }
+            .forEach { entries.accept(TMMoveComponent.createStack(it.value.moveName)) }
+    }
+
     private fun utilityItemEntries(displayContext: ItemDisplayParameters, entries: Output) {
         CobblemonItems.pokeBalls.forEach(entries::accept)
         CobblemonItems.pokeRods.forEach(entries::accept)
@@ -855,7 +949,7 @@ object CobblemonItemGroups {
     }
 
     private fun blocksInjections(injector: Injector) {
-        if(Cobblemon.implementation.isModInstalled("adorn")) { //adorn modifies vanilla block tab and if we don't follow suit we crash the game
+        if (Cobblemon.implementation.isModInstalled("adorn")) { //adorn modifies vanilla block tab and if we don't follow suit we crash the game
             injector.putLast(CobblemonItems.APRICORN_LOG)
             injector.putLast(CobblemonItems.APRICORN_WOOD)
             injector.putLast(CobblemonItems.STRIPPED_APRICORN_LOG)
@@ -974,7 +1068,10 @@ object CobblemonItemGroups {
         injector.putAfter(CobblemonItems.NOSTALGIC_SHERD, CobblemonItems.HELIX_SHERD)
         injector.putAfter(CobblemonItems.SUSPICIOUS_SHERD, CobblemonItems.NOSTALGIC_SHERD)
 
-        injector.putAfter(CobblemonItems.AUTOMATON_ARMOR_TRIM_SMITHING_TEMPLATE, Items.SPIRE_ARMOR_TRIM_SMITHING_TEMPLATE)
+        injector.putAfter(
+            CobblemonItems.AUTOMATON_ARMOR_TRIM_SMITHING_TEMPLATE,
+            Items.SPIRE_ARMOR_TRIM_SMITHING_TEMPLATE
+        )
         injector.putAfter(CobblemonItems.POKEROD_SMITHING_TEMPLATE, Items.NETHERITE_UPGRADE_SMITHING_TEMPLATE)
     }