Merge branch 'evolution-tree' into 'main'

Evolution tree

See merge request cable-mc/cobblemon!2385

CHANGELOG.md

@@ -2,6 +2,9 @@
 ## [1.8.2 (MONTH xth, 2026)](#1-8-2)
 
 ### Additions
+- 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.
+
+### New rideable Pokémon
 - 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.
@@ -111,6 +114,14 @@
 - Fixed certain Pokémon sounds sometimes being doubled when played at specific times in their animations
 
 ### Developer
+- Evolution requirements can now set `pokedexIcon` and `pokedexTooltip` directly in their JSON to control how they're shown on the Pokédex's evolution tree, for example:
+  ```json
+  {
+    "variant": "attack_defence_ratio",
+    "pokedexIcon": "minecraft:diamond_sword",
+    "pokedexTooltip": "cobblemon.ui.pokedex.requirement.attack_defence_ratio.tooltip"
+  }
+  ```
 - Fixed wrong order of operations in the code flow prior to the `FOSSIL_REVIVED` event causing pokemon to appear without entity link
 - Fixed TestPartySlot command not correctly comparing the provided spec with the target Pokémon
 

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/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/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/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
@@ -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/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/net/messages/client/data/SpeciesEvolutionSyncPacket.kt

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

common/src/main/resources/data/cobblemon/species/generation4/grotle.json

@@ -278,7 +278,7 @@
         },
         {
           "variant": "biome",
-          "biomeConditions": "#cobblemon:is_swamp"
+          "biomeCondition": "#cobblemon:is_swamp"
         },
         {
           "variant": "held_item",