first person render roll changes

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

CHANGELOG.md

@@ -1,194 +1,31 @@
 # Changelog
-## [1.8.2 (MONTH xth, 2026)](#1-8-2)
+## [1.8.x (MONTH xth, 2026)](#1-8-x)
 
 ### Additions
-- The following items can now be placed on the ground as blocks:
-  - King's Rock, Galarica Cuff, Unremarkable Teacup, Masterpiece Teacup, Chipped Pot, Cracked Pot, Sachet, Metal Powder, Quick Powder, Bright Powder, Soft Sand, Electirizer, Magmarizer, Icy Rock, Heat Rock, Smooth Rock, Damp Rock, Destiny Knot, Luminous Moss, Never-Melt Ice, Wide Lens, Scope Lens, and Zoom Lens.
-  - Iron Ball, Metal Coat, Throat Spray, Terrain Extender, Medicinal Brew, Moomoo Milk, HP Up, Protein, Iron, Carbos, Calcium, Zinc, PP Up, PP Max, Upgrade, Dubious Disc, and Loaded Dice.
-- The following items can now be placed on various surfaces:
-  - Galarica Wreath, Magnet, Flame Orb, Life Orb, Toxic Orb, Light Ball, and Smoke Ball.
-- The following items can now be placed as blocks and have additional functionality:
-  - Ring Target, Metronome, and Eject Button.
-- The following items can now be worn by Players and Pokémon:
-  - Galarica Wreath, Cleanse Tag, Spell Tag, Sharp Beak, Covert Cloak, Shell Helmet, and Never-Melt Ice.
-- Wearable items can now be equipped by a player by holding it and right-clicking (or rebound use/interact)
-  - Wearable items that can be placed down are exempt from this behaviour.
-- Mint Leaves can now be placed on the ground as Leaf Litter, or in Flower Pots
-- Added Oricorio Flowers
-- Added Terrain Plants
-- Berries can now be placed in Flower Pots
-- The evolution tree can now be viewed on the Pokédex, showing a Pokémon's full family line and what's needed to evolve into each stage.
-- Added custom sounds to a bunch of items that can be placed as blocks: liquid bottles, pill bottles, powders and dice.
-- New Cosmetic Item for Pikachu: Paper
-- Burmy changes its cloak after a battle it took part in, based on the biome: Trash Cloak in the Deep Dark, Nether and End, Plant Cloak in lush biomes such as forests, jungles, plains and swamps, and Sandy Cloak in sandy biomes, beaches and caves.
-- The evolution tree can now be viewed on the Pokédex, showing a Pokémon's full family line and what's needed to evolve into each stage.
-- Added custom sounds to a bunch of items that can be placed as blocks: liquid bottles, pill bottles, powders and dice.
 
-### Fixes
-- Fixed #updateMovesOnFormChange not properly initializing a form-swapped Pokemon's non-form_change moves.
-### TEST
+### New rideable Pokémon
+
 ### Pokémon Added
-#### Generation 4
-- Snover
-- Abomasnow
-- Burmy
-- Wormadam
-- Mothim
-
-#### Generation 5
-- Tympole
-- Palpitoad
-- Seismitoad
-
-#### Generation 6
-- Helioptile
-- Heliolisk
-
-#### Generation 7
-- Grubbin
-- Charjabug
-- Vikavolt
-- Minior
-
-#### Generation 8
-- Eternatus
-
-#### Generation 9
-- Greavard
-- Houndstone
 
 ### Model updates for the following Pokémon
-- Sudowoodo
-- Spheal
-- Cacnea
-- Cacturne
-- Binacle
-- Barbaracle
-- Glimmet
-- Glimmora
-- Deerling
-- Sawsbuck (All forms)
-- Absol
-- Poliwag
-- Politoed
-- Ekans
-- Oddish
-- Gloom
-- Vileplume
-- Bellossom
-- Shroomish
-- Chespin
-- Quilladin
-- Chesnaught
-- Fennekin
-- Braixen
-- Delphox
-- Froakie
-- Frogadier
-- Greninja
-- Shinx
-- Luxio
-- Luxray
-- Slakoth
-- Riolu
-- Lucario
 
 ### Animation updates for the following Pokémon
-- Treecko (New Shoulder Mount!)
-- Bonsly (New Shoulder Mount!)
-- Sudowoodo
-- Cacnea
-- Cacturne
-- Ekans
-- Arbok
-- Oddish
-- Gloom
-- Vileplume
-- Bellossom
-- Pichu
-- Pikachu
-- Raichu (+ Alolan)
-- Greninja
-- Slakoth
 
 ### Changes
-- Terrain Seeds can now be planted
-- Terrain Seeds are now consumed during PvP and NPC battles
-- Glow Item Frames can be crafted using Bright Powder as an alternative to Glow Ink Sacs
-- Bright Powder can be used on Signs and Hanging Signs to make text glow, as an alternative to Glow Ink Sacs
-- Updated various recipes to display in Recipe Groups within the Recipe Book
-- Updated most recipes to display more logically/consistently within the Recipe Book's categories
-- Updated the following recipes
-  - Never-Melt Ice, Focus Sash, Blunder Policy, Weakness Policy, Blank TM
-- Make ride rotations less jittery in multiplayer.
-- Changes Disc Shelf TMs to use textures instead of tinting and overlays to line up with item display
-- Blank TM can now be inserted into the Disc Shelf
-- Added TM creative tab
-- Recall animation now renders ball in hand with the player arm raised.
-- Made regional and Vivillon split-evo locations now mutually exclusive
-- Vivillon's patterns are now viewable as forms with form names and unique Pokedex entries displayed.
-- Item evolutions now unlock **all** locked evolutions whose requirements are met instead of stopping after the first.
-  - Exceptions being "forced" evolutions which will continue to stop after the first one
-- Removed Mega Drain as a TM
-- Vivillon's patterns are now viewable as forms with form names and unique Pokedex entries displayed.
-- Slowed the speed of Type Gem growth, and revamped their generation to grow in a more crystal-like shape
-- PokeSnacks (and other area spawns) will now start the vertical offset checking from the center rather than base coordinate
-  - This will help PokeSnacks to work inside caves or tighter spaces better
+- Reworked spawn presets and added structure tags for spawns
 
 ### Fixes
-- Correctly grants "They're Minerals!" advancement when planting a type gem
-- Shoulder mounted Pokémon now follow player body animations, improving their positioning with custom player animations and default actions.
-- Shoulder mounted Pokémon now sit slightly higher with chest armor equipped for better alignment, with a configurable blacklist.
-- Type Gem Blocks now have advancements to give you the recipe in the recipe book (the data for the advancements were inside the recipes somehow??)
-- Some other recipes without advancements have also been corrected
-- Corrected the TM Recipes for Charge Beam and Payday
-- Type Gem blocks now properly generate clusters off of the block.
-- Starter Screen Categories will no longer stop rendering if they are bigger than the viewport, and you are not viewing top or bottom edges
-- Random Starter option now properly handled in height calculation, so now it won't run off into other categories or be un-accessible due to scroll limits if it causes a new row
-- Mochi and Feathers no longer drop glass bottles on use
-- Fixed a rare set of concurrency bugs related to reloading packs on NeoForge; fixes a ModernFix issue
-- Removed unnecessary conditions for Mimikyu's standing pose. Hopefully fixes the rare instance of it using its shoulder animations during battle in multiplayer scenarios.
-- Fixed Rockruff line not blinking
-- Fixed Flygon sometimes using its running animation instead of walking
-- Fixed Bramblin always sleeping outside of battle
-- Fixed Dragonair using its battle idle as a normal idle
-- Fixed Lycanroc's head movement
-- Added head movement to Archaludon
-- Fixed Duraludon line not having any sleep animations
-- Fixed Diglett line not having their faint animations
-- Fixed Kingambit moving its legs while walking
-- Fixed Alolan Diglett's cry not playing
-- Fixed shiny alpha Snorlax using the non-shiny texture
-- Various Structure fixes
-- Fixed shiny Pokémon under certain circumstances forgetting taught TMs
-- Fixed certain Pokémon sounds sometimes being doubled when played at specific times in their animations
-- Fixed ball capture beam origin coming from behind the ball.
-- Fixed Safari Ball catch rate outside of battle
-- Fixed alpha eye (and other) particles not respecting client particle density setting in video options
+- Fixed blank Cooking Pot recipe book entries and missing tabs on Fabric.
+- Fixed Minior's "Shields Down" ability not working as intended
 
 ### Developer
-- Evolution requirements can now set `pokedexIcon` and `pokedexTooltip` directly in their JSON to control how they're shown on the Pokédex's evolution tree, for example:
-  ```json
-  {
-    "variant": "attack_defence_ratio",
-    "pokedexIcon": "minecraft:diamond_sword",
-    "pokedexTooltip": "cobblemon.ui.pokedex.requirement.attack_defence_ratio.tooltip"
-  }
-  ```
-- Fixed wrong order of operations in the code flow prior to the `FOSSIL_REVIVED` event causing pokemon to appear without entity link
-- Fixed TestPartySlot command not correctly comparing the provided spec with the target Pokémon
 
 ### Molang & Datapacks
-- A new `negate` variant for evolution requirements has been added, which will negate (invert) the provided inner condition.
-- Added Molang functions for individual Pokédex ids, wherein a subdex is passed in as a string to `dex_caught_count` etc.
-- Added a `battle_ended` callback, backed by the new `BATTLE_ENDED` event, which fires whenever a battle ends for any reason, alongside a multitude of flags not previously covered by `BATTLE_VICTORY`.
-- Added `battle_pokemon` to battle actor structs and `has_faced_opponents` to battle Pokémon structs.
-- Added the `cobblemon:form_change/bagworm_cloak/plant_cloak`, `sandy_cloak` and `trash_cloak` biome tags, which control Burmy's cloak after battle.
-- Added a `battlingEyeHeight` field to set the eye height of a Pokémon while battling
+- Added `q.target_fainted` function to move action effects that checks if any opponents fainted from the move.
 
 ### Particles
 
 #### New Move Animations
 
 ### Localization
-- Updated translations for:
+- Updated translations for:

changelogs/CHANGELOG-1.8.0.md

@@ -36,6 +36,7 @@
 - Added `cobblemon:catch_alpha_pokemon` advancement trigger and `totalAlphaCaptureCount` stat for captured Alpha Pokémon.
 
 ### New rideable Pokémon
+- Pidgeot
 - Crobat
 - Skarmory
 - Milotic
@@ -106,7 +107,9 @@
 - Avalugg (Hisuian Form)
 
 ### Model updates for the following Pokémon
-
+- Pidgey
+- Pidgeotto
+- Pidgeot
 - Sandshrew
 - Sandslash
 - Nidoking

changelogs/CHANGELOG-1.8.2.md

@@ -0,0 +1,211 @@
+# Changelog
+## [1.8.2 (October 11th, 2026)](#1-8-2)
+
+### Additions
+- The following items can now be placed on the ground as blocks:
+  - King's Rock, Galarica Cuff, Unremarkable Teacup, Masterpiece Teacup, Chipped Pot, Cracked Pot, Sachet, Metal Powder, Quick Powder, Bright Powder, Soft Sand, Electirizer, Magmarizer, Icy Rock, Heat Rock, Smooth Rock, Damp Rock, Destiny Knot, Luminous Moss, Never-Melt Ice, Wide Lens, Scope Lens, and Zoom Lens.
+  - I wasn't finished. Iron Ball, Metal Coat, Throat Spray, Terrain Extender, Medicinal Brew, Moomoo Milk, HP Up, Protein, Iron, Carbos, Calcium, Zinc, PP Up, PP Max, Upgrade, Dubious Disc, and Loaded Dice.
+- The following items can now be placed on various surfaces:
+  - Galarica Wreath, Magnet, Flame Orb, Life Orb, Toxic Orb, Light Ball, and Smoke Ball.
+- The following items can now be placed as blocks and have additional functionality:
+  - Ring Target, Metronome, and Eject Button.
+- The following items can now be worn by Players and Pokémon:
+  - Galarica Wreath, Cleanse Tag, Spell Tag, Sharp Beak, Covert Cloak, Shell Helmet, and Never-Melt Ice.
+- Wearable items can now be equipped by a player by holding it and right-clicking (or whatever you've rebound use/interact to).
+  - Wearable items that can be placed down are exempt from this behaviour.
+- Mint Leaves can now be placed on the ground as Leaf Litter, or in Flower Pots.
+- The recall animation now renders the ball in hand with the player's arm raised.
+- Added Oricorio Flowers.
+- Added Terrain Plants, four plants grown from Electric, Grassy, Misty, and Psychic Seeds, which glow under specific environmental conditions and can be farmed for more of their seeds.
+- Berries can now be placed in Flower Pots.
+- The evolution tree for a Pokémon can now be viewed in the Pokédex, showing the Pokémon's full family line and what's needed to evolve into each stage.
+- Added custom sounds to a bunch of items that can be placed as blocks: liquid bottles, pill bottles, powders, and dice.
+- Added paper as a new cosmetic item for Pikachu.
+- Burmy changes its cloak after a battle it took part in, based on the biome.
+  - Trash Cloak in the Deep Dark, Nether and End.
+  - Plant Cloak in lush biomes such as forests, jungles, plains and swamps.
+  - Sandy Cloak in sandy biomes, beaches and caves.
+
+### Pokémon Added
+#### Generation 4
+- Snover
+- Abomasnow
+- Burmy
+- Wormadam
+- Mothim
+
+#### Generation 5
+- Tympole
+- Palpitoad
+- Seismitoad
+
+#### Generation 6
+- Helioptile
+- Heliolisk
+
+#### Generation 7
+- Grubbin
+- Charjabug
+- Vikavolt
+- Minior
+
+#### Generation 8
+- Eternatus
+
+#### Generation 9
+- Greavard
+- Houndstone
+
+### Model updates for the following Pokémon
+- Sudowoodo
+- Spheal
+- Cacnea
+- Cacturne
+- Binacle
+- Barbaracle
+- Glimmet
+- Glimmora
+- Deerling
+- Sawsbuck (All forms)
+- Absol
+- Poliwag
+- Politoed
+- Ekans
+- Oddish
+- Gloom
+- Vileplume
+- Bellossom
+- Shroomish
+- Chespin
+- Quilladin
+- Chesnaught
+- Fennekin
+- Braixen
+- Delphox
+- Froakie
+- Frogadier
+- Greninja
+- Shinx
+- Luxio
+- Luxray
+- Slakoth
+- Riolu
+- Lucario
+- Corsola
+- Mime Jr.
+
+### Animation updates for the following Pokémon
+- Treecko (New Shoulder Mount!)
+- Bonsly (New Shoulder Mount!)
+- Sudowoodo
+- Cacnea
+- Cacturne
+- Ekans
+- Arbok
+- Oddish
+- Gloom
+- Vileplume
+- Bellossom
+- Pichu
+- Pikachu
+- Raichu (+ Alolan)
+- Greninja
+- Slakoth
+
+### Changes
+- Slowed the speed of Type Gem growth, and revamped their generation to grow in a more crystal-like shape.
+- Terrain Seeds can now be planted.
+- Terrain Seeds are now consumed during PvP and NPC battles.
+- Glow Item Frames can be crafted using Bright Powder as an alternative to Glow Ink Sacs.
+- Bright Powder can be used on Signs and Hanging Signs to make text glow, as an alternative to Glow Ink Sacs.
+- Updated various recipes to display in Recipe Groups within the Recipe Book.
+- Updated most recipes to display more logically and consistently within the Recipe Book's categories.
+- Updated the following recipes
+  - Never-Melt Ice, Focus Sash, Blunder Policy, Weakness Policy, Blank TM.
+- Made ride rotations less jittery in multiplayer.
+- Changes Disc Shelf TMs to use textures instead of tinting and overlays to line up with item display.
+- Blank TM can now be inserted into the Disc Shelf.
+- Added a TM creative tab.
+- Made regional and Vivillon split-evo locations mutually exclusive.
+- Vivillon's patterns are now viewable as forms with form names and unique Pokédex entries displayed.
+- Item evolutions now unlock **all** locked evolutions whose requirements are met instead of stopping after the first.
+  - Exceptions being "forced" evolutions which stop after the first one.
+- Removed Mega Drain as a TM.
+- PokeSnacks (and other area spawns) will now start the vertical offset checking from the center rather than base coordinate
+  - This will help PokeSnacks to work inside caves or tighter spaces better.
+
+### Fixes
+- Type Gem blocks now properly generate clusters off of the block.
+- Correctly grant "They're Minerals!" advancement when planting a Type Gem.
+- Shoulder mounted Pokémon now follow player body animations, improving their positioning with custom player animations and default actions.
+- Shoulder mounted Pokémon now sit slightly higher with chest armor equipped for better alignment, with a configurable blacklist.
+- Type Gem Blocks now have advancements to give you the recipe in the recipe book (the data for the advancements were inside the recipes somehow??).
+  - Some other recipes without advancements have also been corrected.
+- Corrected the TM Recipes for Charge Beam and Payday.
+- Starter Screen Categories will no longer stop rendering if they are bigger than the viewport and you are not viewing the top or bottom edges.
+- The Random Starter option no longer runs off into other categories or becomes unaccessible due to scroll limits if it causes a new row.
+- Mochi and Feathers no longer drop glass bottles on use.
+- Fixed a rare set of concurrency bugs related to reloading packs on NeoForge; fixes a ModernFix compatibility issue.
+- Removed unnecessary conditions for Mimikyu's standing pose. Hopefully fixes the rare instance of it using its shoulder animations during battle in multiplayer scenarios.
+- Fixed Rockruff line not blinking.
+- Fixed Flygon sometimes using its running animation instead of walking.
+- Fixed Bramblin always sleeping outside of battle.
+- Fixed Dragonair using its battle idle as a normal idle.
+- Fixed Lycanroc's head movement.
+- Added head movement to Archaludon.
+- Fixed Duraludon line not having any sleep animations.
+- Fixed Diglett line not having their faint animations.
+- Fixed Kingambit moving its legs while walking.
+- Fixed Alolan Diglett's cry not playing.
+- Fixed shiny alpha Snorlax using the non-shiny texture.
+- Fixed Crabominable's head breaking when looking around.
+- Fixed Shiny Dipplin and Hydrapple's textures.
+- Various structure fixes.
+- Fixed shiny Pokémon under certain circumstances forgetting taught TMs.
+- Fixed certain Pokémon sounds sometimes being doubled when played at specific times in their animations.
+- Fixed ball capture beam origin coming from behind the ball.
+- Fixed Safari Ball catch rate outside of battle.
+- Fixed alpha eye (and other) particles not respecting the client particle density setting in video options.
+- Fixed the TM Machine UI not closing when player is moving away from it.
+- Moved the config category for alpha/shiny chance config fields for fossil machine and honey log slathering to Spawning.
+- Fixed crashes for addon species with non-Cobblemon namespaces in evolution, fishing bait, and Pokédex lookups.
+- Bees will now grow Apricorns and the Galarica Nut Bush, which were in the bee growables tag but never handled, and correctly spend their nectar when they do.
+- Saccharine Leaves can now be bone mealed.
+- Fixed equipping a stack of wearable items instead of one item of a stack.
+- Fixed TM stack consumption in TM Machine screen when a player teaches a move to a Pokémon.
+- Fixed every Miltank giving mushroom stew, not only mushroom variants.
+- Medicinal Leeks can now be eaten when they aren't being planted, matching their food properties.
+- Sweeping attacks no longer set owned Pokémon on fire (e.g. with Fire Aspect) or knock them back. Friendly Fire is now off.
+- Fixed Pokémon not losing their previous form's signature moves when changing forms (e.g. Rotom keeping Overheat after leaving its Heat form).
+- Form-specific moves gained from a form change are now only granted if the Pokémon is high enough level to learn them, and no longer create duplicates in benched moves.
+- Spinda now learns Teeter Dance at level 32 instead of via TM.
+- Fixed Oricorio Pa'u form description in the Pokédex.
+- Fixed PC playing sound on close when opened via command.
+
+### 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 the wrong order of operations in the code flow prior to the `FOSSIL_REVIVED` event causing Pokémon to appear without the entity link.
+- Fixed TestPartySlot command not correctly comparing the provided spec with the target Pokémon.
+
+### Molang & Datapacks
+- A new `negate` variant for evolution requirements has been added, which will negate (invert) the provided inner condition.
+- Added Molang functions for individual Pokédex ids, wherein a subdex is passed in as a string to `dex_caught_count` etc.
+- Added a `battle_ended` callback, backed by the new `BATTLE_ENDED` event, which fires whenever a battle ends for any reason, alongside a multitude of flags not previously covered by `BATTLE_VICTORY`.
+- Added `battle_pokemon` to battle actor structs and `has_faced_opponents` to battle Pokémon structs.
+- Added the `cobblemon:form_change/bagworm_cloak/plant_cloak`, `sandy_cloak` and `trash_cloak` biome tags, which control Burmy's cloak after battle.
+
+### Localization
+- Updated translations for:
+  - Brazilian Portuguese
+  - Canadian French
+  - Japanese
+  - Korean
+  - Russian
+  - Ukrainian

changelogs/CHANGELOG-1.8.3.md

@@ -0,0 +1,107 @@
+# Changelog
+## [1.8.3 (October 25th, 2026)](#1-8-3)
+
+### Additions
+- Added compatability with AppleSkin.
+
+### New Rideable Pokémon
+- Vikavolt
+- Fearow
+
+### Particles
+## New Move Animations
+- Water Shuriken
+
+### Cries added/updated for the following Pokémon
+- Hoppip
+- Skiploom
+- Jumpluff
+- Houndour
+- Houndoom
+- Wurmple
+- Silcoon
+- Beautifly
+- Cascoon
+- Dustox
+- Surskit
+- Masquerain
+- Torkoal
+- Starly
+- Staravia
+- Staraptor
+- Combee
+- Vespiquen
+- Dusknoir
+- Helioptile
+- Heliolisk
+- Grubbin
+- Charjabug
+- Vikavolt
+- Applin (updated)
+- Flapple (updated)
+- Appletun
+- Runerigus
+- Dipplin
+
+### Animation updates for the following Pokémon
+- Vikavolt
+- Magby
+- Magmar
+- Ninetales (+ Alolan)
+- Spearow
+- Fearow
+- Squawkabilly
+- Mudkip
+- Marshtomp
+- Swampert
+
+### Changes
+- Changed the Misc icon in the Campfire Pot Recipe Book to Health Candy.
+- Moved EXP Candies from the Medicine recipe book category to the Misc category.
+- Removed Dynamic Lights data from the Magmarizer item for consistency with the block.
+- Added `doPokemonPredation` game rule, which controls aggressiveness of Pokémon with the `hate_entity` brain task defined.
+- Added `predation_chance` server config value, which controls the possibility of attacking the hated entity found in `hate_entity` brain tasks.
+- Prehistoric Eroded Pillar generates slightly more frequently.
+- Togekiss was changed from a jet-style mount to bird-style.
+
+### Fixes
+- Fixed datapacks with item interaction evolutions that don't specify an item crashing the world on load.
+- Fixed the Pokédex evolution tree crashing when a datapack's dex entry is missing an evolution's form.
+- Fixed the Pokédex evolution tree crashing with a stack overflow on evolutions that loop back on themselves.
+- Fixed the Pokédex evolution tree crashing when looking at a dex that is not part of the "National Dex" aggregate.
+- Fixed some display names in the Pokédex evolution tree having unintended font colours.
+- Fixed evolution trees not building properly when a Pokémon has several Pokédex entries for different regions.
+- Fixed form-changing evolutions sometimes resolving to the source form in the Pokédex evolution tree.
+- Broken datapack evolutions are now logged and skipped in the Pokédex evolution tree instead of crashing.
+- Fixed the `alpha` property having no tab completion in commands such as `/pokespawn`, `/pokegive` and `/pokeedit`, and added the missing `dmax_level`, `gmax_factor` and `tradable` aliases to tab completion.
+- Fixed friendship booster items not being recognised as such.
+- Fixed conflicts with other mods that would make use of recipe books in certain ways (Farmer's Delight Cooking Pot).
+- Fixed Pokémon battles stalling when a sidemod cancels the `THROWN_POKEBALL_HIT` hit event.
+- Fixed choice feature tab completion in `spawnpokemon/pokegive/pokeedit` commands.
+- Fixed MoLang that's targeting players intermittedly failing when they have died, requiring them to relog.
+- Fixed a NeoForge bug where none of the Cobblemon plants/berries could be placed into pots.
+- Fixed party overlay not hiding when the player opens the Pokédex scanner.
+- Fixed `hate_entity` task focusing on its own entity, therefore enabling deadly warfare between Zangoose and Seviper.
+- Prehistoric Frozen Pond, Prehistoric Frozen Spike, and Prehistoric Lush Den now actually generate (oops).
+- Fixed Frogadier floating in its `battle_idle` animation.
+- Fixed absence or incorrect mergers in spawning conditions, causing the max height/depth of conditions to use the min value instead.
+- Added stricter riding checks on server side to prevent possible packet forgery when a player tries to ride Pokémon.
+- Fixed Pokémon cries and animation sounds played from GUIs, such as the starter selection screen and the Pokédex, being tied to the Master volume slider instead of Friendly Creatures.
+- Fixed Archeops T-posing during its `air_cry` animation.
+
+### Developer
+- Bumped NeoForge to `21.1.195` to get access to MixinExtras `0.5` and the expressions annotation.
+- New Platform Event `PLAYER_RESPAWN` which is fired when a player respawns (either through death or returning from the end).
+- Platform Events `SERVER_PLAYER_TICK_PRE` and `SERVER_PLAYER_TICK_POST` no longer fire when the player is dead.
+  - It is now tied much closer to the actual entity rather than the player or their connection.
+
+### Molang & Datapacks
+- Fixed `q.pokemon.nature` returning class instance instead of proper string value (`cobblemon:adamant`).
+- Fixed `q.entity.is_looking_at` result being always `1` for whatever entity passed as the target parameter.
+- Added hate chance optional parameter to `hate_entity` task. `1.0` will make an entity always attack the target.
+
+### Localization
+- Updated translations for:
+  - Russian
+  - Japanese
+  - Brazilian Portuguese

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

@@ -8,54 +8,42 @@
 
 package com.cobblemon.mod.common.mixin;
 
-import com.cobblemon.mod.common.block.SaccharineLeafBlock;
+import com.llamalad7.mixinextras.sugar.Local;
 import net.minecraft.core.BlockPos;
-import net.minecraft.world.level.block.Block;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.entity.animal.Bee;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.BonemealableBlock;
 import net.minecraft.world.level.block.state.BlockState;
-import net.minecraft.world.level.block.state.properties.BlockStateProperties;
+import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.ModifyVariable;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
 
 
 @Mixin(targets = "net.minecraft.world.entity.animal.Bee$BeeGrowCropGoal")
 public abstract class BeeEntityMixin {
 
-    @Unique
-    private BlockState cobblemon$result = null;
-
-    @Inject(method = "tick()V", at = @At(
-            value = "INVOKE",
-            target = "Lnet/minecraft/world/level/block/BonemealableBlock;performBonemeal(Lnet/minecraft/server/level/ServerLevel;Lnet/minecraft/util/RandomSource;Lnet/minecraft/core/BlockPos;Lnet/minecraft/world/level/block/state/BlockState;)V",
-            shift = At.Shift.BY,
-            by = 2
-        ),
-        locals = LocalCapture.CAPTURE_FAILHARD
-    )
-    private void injectCustomGrowth(CallbackInfo ci, int i, BlockPos blockPos, BlockState blockState, Block block) {
-        if (block instanceof SaccharineLeafBlock) {
-
-            int age = blockState.getValue(SaccharineLeafBlock.Companion.getAGE());
-            boolean waterlogged = blockState.getValue(BlockStateProperties.WATERLOGGED);
-
-            if (age < 2 && !waterlogged) {
-                this.cobblemon$result = blockState.setValue(SaccharineLeafBlock.Companion.getAGE(), age + 1);
-            }
-        }
-    }
+    @Shadow(aliases = {"this$0", "field_20373"}) @Final private Bee bee;
 
+    // Grows bonemealable blocks vanilla's hardcoded checks miss, returning the state so it handles the rest.
     @ModifyVariable(method = "tick", at = @At(value = "LOAD", ordinal = 0), index = 5)
-    private BlockState applyCustomBlockState(BlockState before) {
-        if(this.cobblemon$result != null && before == null) {
-            BlockState result = this.cobblemon$result;
-            this.cobblemon$result = null;
-            return result;
+    private BlockState cobblemon$growBonemealableBlocks(BlockState grownState, @Local(ordinal = 0) BlockState blockState, @Local BlockPos pos) {
+        if (grownState != null || blockState.is(Blocks.CAVE_VINES) || blockState.is(Blocks.CAVE_VINES_PLANT)) {
+            return grownState;
         }
 
-        return before;
+        if (!(blockState.getBlock() instanceof BonemealableBlock bonemealable)) {
+            return null;
+        }
+
+        ServerLevel level = (ServerLevel) this.bee.level();
+        if (!bonemealable.isValidBonemealTarget(level, pos, blockState)) {
+            return null;
+        }
+
+        bonemealable.performBonemeal(level, this.bee.getRandom(), pos, blockState);
+        return level.getBlockState(pos);
     }
 }

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

@@ -75,9 +75,10 @@ public abstract class LivingEntityMixin extends Entity implements OrientationCon
     public @NotNull HitResult pick(double hitDistance, float partialTicks, boolean hitFluids) {
         Entity vehicle = this.getVehicle();
         if (vehicle instanceof PokemonEntity pokemonEntity && pokemonEntity.getDelegate() instanceof PokemonClientDelegate delegate) {
-            int seatIndex = pokemonEntity.getPassengers().indexOf(this);
-            Seat seat = pokemonEntity.getSeats().get(seatIndex);
-            MatrixWrapper locator = delegate.getLocatorStates().get(seat.getLocator());
+            // Passenger order isn't seat order, so look the seat up directly
+            Seat seat = pokemonEntity.getSeatForPassenger(this);
+            MatrixWrapper locator = seat != null ? delegate.getLocatorStates().get(seat.getLocator()) : null;
+            if (locator == null) return super.pick(hitDistance, partialTicks, hitFluids);
 
             Vec3 locatorOffset = new Vec3(locator.getMatrix().getTranslation(new Vector3f()));
 
@@ -99,7 +100,8 @@ public abstract class LivingEntityMixin extends Entity implements OrientationCon
 
     @Unique
     private Vec3 cobblemon$getEyePosition(float partialTicks, PokemonEntity pokemonEntity, Vec3 locatorOffset) {
-        OrientationController controller = this.getOrientationController();
+        // The ride owns the orientation, the passenger's own controller is never active
+        OrientationController controller = ((OrientationControllable) pokemonEntity).getOrientationController();
 
         float currEyeHeight = this.getEyeHeight();
         Vec3 offset = locatorOffset.add(pokemonEntity.position());
@@ -107,7 +109,7 @@ public abstract class LivingEntityMixin extends Entity implements OrientationCon
             Quaternionf orientation = controller.getRenderOrientation(partialTicks);
             Vec3 rotatedEyeHeight = new Vec3(orientation.transform(new Vector3f(0f, currEyeHeight - (this.getBbHeight() / 2), 0f)));
 
-            offset.add(rotatedEyeHeight);
+            offset = offset.add(rotatedEyeHeight);
         }
 
         return offset;

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

@@ -35,13 +35,16 @@ import com.cobblemon.mod.common.util.DataKeys;
 import com.cobblemon.mod.common.world.gamerules.CobblemonGameRules;
 import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import com.llamalad7.mixinextras.sugar.Local;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.nbt.Tag;
 import net.minecraft.network.chat.Component;
 import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.level.ServerLevel;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.util.Mth;
 import net.minecraft.world.damagesource.DamageSource;
+import net.minecraft.world.entity.Entity;
 import net.minecraft.world.entity.EntityDimensions;
 import net.minecraft.world.entity.EntityType;
 import net.minecraft.world.entity.LivingEntity;
@@ -50,6 +53,7 @@ import net.minecraft.world.entity.item.ItemEntity;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.food.FoodProperties;
 import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.enchantment.EnchantmentHelper;
 import net.minecraft.world.level.Level;
 import net.minecraft.world.phys.Vec3;
 import org.jetbrains.annotations.Nullable;
@@ -371,4 +375,33 @@ public abstract class PlayerMixin extends LivingEntity implements ScannableEntit
         this.cobblemon$rideEyePos = rideEyePos;
     }
 
+    /**
+     * Sweeping attacks apply post-attack enchantment effects (e.g. Fire Aspect) to every entity caught
+     * in the sweep, even if the damage itself was blocked. Skip them for Pokémon immune to the attack.
+     */
+    @WrapOperation(
+            method = "attack",
+            at = @At(value = "INVOKE", target = "Lnet/minecraft/world/item/enchantment/EnchantmentHelper;doPostAttackEffects(Lnet/minecraft/server/level/ServerLevel;Lnet/minecraft/world/entity/Entity;Lnet/minecraft/world/damagesource/DamageSource;)V")
+    )
+    private void cobblemon$skipPostAttackEffectsOnImmunePokemon(ServerLevel level, Entity target, DamageSource source, Operation<Void> original) {
+        if (target instanceof PokemonEntity pokemonEntity && pokemonEntity.isInvulnerableTo(source)) {
+            return;
+        }
+        original.call(level, target, source);
+    }
+
+    /**
+     * Sweeping attacks also knock back every entity caught in the sweep regardless of whether it took damage.
+     */
+    @WrapOperation(
+            method = "attack",
+            at = @At(value = "INVOKE", target = "Lnet/minecraft/world/entity/LivingEntity;knockback(DDD)V")
+    )
+    private void cobblemon$skipKnockbackOnImmunePokemon(LivingEntity target, double strength, double x, double z, Operation<Void> original, @Local DamageSource source) {
+        if (target instanceof PokemonEntity pokemonEntity && pokemonEntity.isInvulnerableTo(source)) {
+            return;
+        }
+        original.call(target, strength, x, z);
+    }
+
 }

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

@@ -83,7 +83,7 @@ public abstract class CameraMixin implements CameraDuck {
         }
 
         // reset the rotation values if it is now not being ridden.
-        MountedCameraRenderer.INSTANCE.setSmoothRotation(null);
+        MountedCameraRenderer.INSTANCE.reset();
         original.call(instance, x, y, z);
     }
 }

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

@@ -16,6 +16,7 @@ import com.cobblemon.mod.common.item.crafting.CookingPotShapelessRecipe;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Maps;
+import com.llamalad7.mixinextras.sugar.Local;
 import net.minecraft.client.ClientRecipeBook;
 import net.minecraft.client.RecipeBookCategories;
 import net.minecraft.client.gui.screens.recipebook.RecipeCollection;
@@ -63,23 +64,12 @@ public abstract class ClientRecipeBookMixin {
         }
     }
 
-    @Inject(method = "setupCollections", at = @At("RETURN"))
-    private void addCustomAggregateCategories(Iterable<RecipeHolder<?>> recipes, RegistryAccess registryAccess, CallbackInfo ci) {
-        Map<RecipeBookCategories, List<List<RecipeHolder<?>>>> map = categorizeAndGroupRecipes(recipes);
-        Map<RecipeBookCategories, List<RecipeCollection>> map2 = Maps.newHashMap();
-        ImmutableList.Builder<RecipeCollection> builder = ImmutableList.builder();
-
-        map.forEach((recipeBookCategories, list) -> {
-            List<RecipeCollection> collections = list.stream()
-                    .map(listx -> new RecipeCollection(registryAccess, listx))
-                    .peek(builder::add)
-                    .collect(ImmutableList.toImmutableList());
-            map2.put(recipeBookCategories, collections);
-        });
-        RecipeBookCategories.AGGREGATE_CATEGORIES.forEach((recipeBookCategories, list) -> map2.put(recipeBookCategories, (List) list.stream().flatMap((recipeBookCategoriesx) -> ((List) map2.getOrDefault(recipeBookCategoriesx, ImmutableList.of())).stream()).collect(ImmutableList.toImmutableList())));
+    @Inject(method = "setupCollections",
+            at = @At(
+                    value = "INVOKE",
+                    target = "Lcom/google/common/collect/ImmutableMap;copyOf(Ljava/util/Map;)Lcom/google/common/collect/ImmutableMap;"
+            ))
+    private void addCustomAggregateCategories(Iterable<RecipeHolder<?>> recipes, RegistryAccess registryAccess, CallbackInfo ci, @Local(ordinal = 1) Map<RecipeBookCategories, List<RecipeCollection>> map2) {
         CobblemonRecipeCategories.Companion.getCustomAggregateCategories().forEach((recipeBookCategories, list) -> map2.put(recipeBookCategories, (List) list.stream().flatMap((recipeBookCategoriesx) -> ((List) map2.getOrDefault(recipeBookCategoriesx, ImmutableList.of())).stream()).collect(ImmutableList.toImmutableList())));
-
-        this.collectionsByTab = ImmutableMap.copyOf(map2);
-        this.allCollections = builder.build();
     }
 }

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

@@ -9,11 +9,14 @@
 package com.cobblemon.mod.common.mixin.client;
 
 import com.cobblemon.mod.common.OrientationControllable;
+import com.cobblemon.mod.common.client.render.camera.MountedCameraRenderer;
 import com.cobblemon.mod.common.client.render.player.FirstPersonRecallBallRenderer;
 import com.cobblemon.mod.common.item.PokedexItem;
 import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.math.Axis;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.player.AbstractClientPlayer;
+import net.minecraft.client.player.LocalPlayer;
 import net.minecraft.client.renderer.ItemInHandRenderer;
 import net.minecraft.client.renderer.MultiBufferSource;
 import net.minecraft.world.InteractionHand;
@@ -40,6 +43,14 @@ public class ItemInHandRendererMixin {
         }
     }
 
+    @Inject(method = "renderHandsWithItems", at = @At("HEAD"))
+    private void cobblemon$rollHandsWithRide(float partialTicks, PoseStack poseStack, MultiBufferSource.BufferSource buffer, LocalPlayer player, int light, CallbackInfo ci) {
+        float roll = MountedCameraRenderer.INSTANCE.getHandRoll();
+        if (roll != 0f) {
+            poseStack.mulPose(Axis.ZN.rotationDegrees(roll));
+        }
+    }
+
     @Redirect(method = "renderHandsWithItems", at = @At(value = "INVOKE", target = "Lcom/mojang/blaze3d/vertex/PoseStack;mulPose(Lorg/joml/Quaternionf;)V"))
     private void cobblemon$renderHandswithItems(PoseStack instance, Quaternionf quaternion) {
         if (!(Minecraft.getInstance().player != null && Minecraft.getInstance().player.getVehicle() instanceof OrientationControllable controllable && controllable.getOrientationController().isActive())) {

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

@@ -32,7 +32,6 @@ import net.minecraft.client.multiplayer.ClientLevel;
 import net.minecraft.client.player.AbstractClientPlayer;
 import net.minecraft.client.player.Input;
 import net.minecraft.client.player.LocalPlayer;
-import net.minecraft.util.Mth;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.level.ClipContext;
@@ -50,11 +49,13 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
 import java.util.Map;
+import java.util.Objects;
 
 @Mixin(LocalPlayer.class)
 public abstract class LocalPlayerMixin extends AbstractClientPlayer implements OrientationControllable, DoubleJump {
 
     @Unique Matrix3f cobblemon$lastOrientation;
+    @Unique int cobblemon$lastOrientationVehicleId = -1;
 
     @Unique float cobblemon$lastRideXRot;
     @Unique float cobblemon$lastRideYRot;
@@ -81,30 +82,28 @@ public abstract class LocalPlayerMixin extends AbstractClientPlayer implements O
     private void cobblemon$updateRotationMatrixPassenger(CallbackInfo ci) {
         if (!(this.getVehicle() instanceof OrientationControllable controllableVehicle)) return;
         var vehicleController = controllableVehicle.getOrientationController();
-        if (!vehicleController.isActive() || vehicleController.getOrientation() == cobblemon$lastOrientation) return;
-        cobblemon$lastOrientation = vehicleController.getOrientation() != null ? new Matrix3f(vehicleController.getOrientation()) : null;
-        CobblemonNetwork.INSTANCE.sendToServer(new ServerboundUpdateOrientationPacket(this.getVehicle().getId(), vehicleController.getOrientation()));
+        if (!vehicleController.isActive()) {
+            // Forget the last sent value so the next ride always gets its first orientation sent
+            cobblemon$lastOrientation = null;
+            return;
+        }
+        var orientation = vehicleController.getOrientation();
+        var vehicleId = this.getVehicle().getId();
+        // Compare by value, the stored one is a copy so a reference check never matches
+        if (vehicleId == cobblemon$lastOrientationVehicleId && Objects.equals(orientation, cobblemon$lastOrientation)) return;
+        cobblemon$lastOrientation = orientation != null ? new Matrix3f(orientation) : null;
+        cobblemon$lastOrientationVehicleId = vehicleId;
+        CobblemonNetwork.INSTANCE.sendToServer(new ServerboundUpdateOrientationPacket(vehicleId, orientation));
     }
 
     @Inject(method = "rideTick", at = @At("HEAD"))
     private void cobblemon$updateOrientationControllerRideTick(CallbackInfo ci) {
         if (Minecraft.getInstance().player != (Object)this) return;
-        var driver = (LocalPlayer)(Object)this;
-        var vehicle = driver.getVehicle();
         if (!(this.getVehicle() instanceof OrientationControllable controllableVehicle)) return;
         var shouldUseCustomOrientation = cobblemon$shouldUseCustomOrientation((LocalPlayer)(Object)this);
         var vehicleController = controllableVehicle.getOrientationController();
 
-        // If the player has just switched to riding a custom orientation ride then set their
-        // x and y rots local to the vehicle rots(if the controller wasn't active and will now be active)
-        // This ensures that on transition your camera stays in the same spot
-        if (!vehicleController.isActive() && shouldUseCustomOrientation) {
-            // Set local to the vehicle x and yrot so
-            var playerRotater = (RidePassenger)driver;
-            playerRotater.cobblemon$setRideXRot(Mth.wrapDegrees(driver.getXRot() - vehicle.getXRot()));
-            playerRotater.cobblemon$setRideYRot(Mth.wrapDegrees(driver.getYRot() - vehicle.getYRot()));
-        }
-
+        // Look angles get seeded by the camera on its first rolling frame
         vehicleController.setActive(shouldUseCustomOrientation);
     }
 

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

@@ -11,6 +11,10 @@ package com.cobblemon.mod.common.mixin.client;
 import com.cobblemon.mod.common.Cobblemon;
 import com.cobblemon.mod.common.OrientationControllable;
 import com.cobblemon.mod.common.api.orientation.OrientationController;
+import com.cobblemon.mod.common.api.riding.behaviour.RideSteerInput;
+import com.cobblemon.mod.common.api.riding.camera.RideLookInput;
+import com.cobblemon.mod.common.api.riding.camera.RideLookSettings;
+import com.cobblemon.mod.common.api.riding.camera.RideLookTake;
 import com.cobblemon.mod.common.client.CobblemonClient;
 import com.cobblemon.mod.common.client.keybind.keybinds.PartySendBinding;
 import com.cobblemon.mod.common.client.keybind.keybinds.RidingFreelookBinding;
@@ -20,13 +24,12 @@ import com.cobblemon.mod.common.pokedex.scanner.PokedexUsageContext;
 import com.llamalad7.mixinextras.injector.v2.WrapWithCondition;
 import com.llamalad7.mixinextras.sugar.Local;
 import com.mojang.blaze3d.Blaze3D;
-import kotlin.Pair;
+import kotlin.Unit;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.MouseHandler;
 import net.minecraft.client.player.LocalPlayer;
 import net.minecraft.util.Mth;
 import net.minecraft.util.SmoothDouble;
-import net.minecraft.world.phys.Vec3;
 import org.objectweb.asm.Opcodes;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
@@ -42,6 +45,11 @@ import static net.minecraft.util.Mth.lerp;
 
 @Mixin(MouseHandler.class)
 public abstract class MouseHandlerMixin {
+    // Entity.turn scales mouse movement to degrees by this
+    @Unique private static final float COBBLEMON$VANILLA_DEGREES_PER_MOUSE_UNIT = 0.15F;
+    // Share of the look offset closed per second as it drifts back to centre. Raise to recentre faster
+    @Unique private static final float COBBLEMON$LOOK_RECENTER_RATE = 5.0F;
+
     @Shadow private double accumulatedScrollY;
     @Shadow @Final private Minecraft minecraft;
 
@@ -160,74 +168,48 @@ public abstract class MouseHandlerMixin {
         }
 
         var vehicleController = controllableVehicle.getOrientationController();
-        var freeLooking = RidingFreelookBinding.INSTANCE.isDown();
-        Pair<Boolean, Boolean> mouseShouldModifyDriver = ((PokemonEntity) vehicle).ifRidingAvailableSupply(new Pair(false, false), (behaviour, settings, state) -> {
-            return behaviour.mouseModifiesDriverRotation(
-                    settings,
-                    state,
-                    (PokemonEntity) vehicle
-            );
+        var pokemonVehicle = (PokemonEntity) vehicle;
+        var playerRotater = (RidePassenger)player;
+        float yawDelta = (float)cursorDeltaX * COBBLEMON$VANILLA_DEGREES_PER_MOUSE_UNIT;
+        float pitchDelta = (float)cursorDeltaY * COBBLEMON$VANILLA_DEGREES_PER_MOUSE_UNIT;
+
+        // Passengers only ever look around
+        if (player.getControlledVehicle() == null) {
+            cobblemon$addLook(player, yawDelta, pitchDelta);
+            return false;
+        }
+
+        // The ride takes what it wants of the mouse to steer with and the rest moves the look. Freelook keeps it all for the look
+        var lookInput = new RideLookInput(yawDelta, pitchDelta, playerRotater.cobblemon$getRideYRot(), playerRotater.cobblemon$getRideXRot());
+        RideLookTake take = RidingFreelookBinding.INSTANCE.isDown() ? RideLookTake.NONE : pokemonVehicle.ifRidingAvailableSupply(RideLookTake.all(lookInput), (behaviour, settings, state) -> {
+            return behaviour.consumeLook(settings, state, pokemonVehicle, lookInput);
+        });
+        float lookYaw = yawDelta - take.getYaw();
+        float lookPitch = pitchDelta - take.getPitch();
+        if (lookYaw != 0.0f || lookPitch != 0.0f) {
+            cobblemon$addLook(player, lookYaw, lookPitch);
+        }
+
+        // Drift the look back to centre on the axes the ride steers with
+        float recenter = min(COBBLEMON$LOOK_RECENTER_RATE * (float)movementTime, 1.0f);
+        if (take.getRecenterYaw()) {
+            playerRotater.cobblemon$setRideYRot(lerp(recenter, Mth.wrapDegrees(playerRotater.cobblemon$getRideYRot()), 0.0f));
+        }
+        if (take.getRecenterPitch()) {
+            playerRotater.cobblemon$setRideXRot(lerp(recenter, Mth.wrapDegrees(playerRotater.cobblemon$getRideXRot()), 0.0f));
+        }
+
+        // Hand the ride its share back in mouse units since that's what every ride's steering is tuned for
+        double rideDeltaX = yawDelta == 0.0f ? 0.0 : cursorDeltaX * (take.getYaw() / yawDelta);
+        double rideDeltaY = pitchDelta == 0.0f ? 0.0 : cursorDeltaY * (take.getPitch() / pitchDelta);
+        var steerInput = cobblemon$getSteerInput(vehicleController, rideDeltaX, rideDeltaY, movementTime);
+        pokemonVehicle.ifRidingAvailable((behaviour, settings, state) -> {
+            behaviour.steer(settings, state, pokemonVehicle, player, steerInput);
+            return Unit.INSTANCE;
         });
 
-        //-------------------------------------------------------------------------
-        // If looking around then modify the players orientation instead and zero the mouse deltas so the mouse doesn't
-        // affect the vehicle orientation when looking around.
-        // If the client is a passenger it will modify these rotations and return
-        //-------------------------------------------------------------------------
-        if (freeLooking || player.getControlledVehicle() == null) {
-            // Modify driver rotations
-            cobblemon$setDriverRotations(player, cursorDeltaX, cursorDeltaY);
-
-            // If the player/passenger is not the driver then return and ignore all vehicle rotation logic
-            if (player.getControlledVehicle() == null) return false;
-
-            // Set to zero so that vehicle rotations don't also get affected by movement.
-            cursorDeltaX = 0.0;
-            cursorDeltaY = 0.0;
-        } else if (mouseShouldModifyDriver.getFirst()) { // If not freelooking then check modification per mouse input dimension
-            cobblemon$setDriverRotations(player, cursorDeltaX, 0.0);
-            cursorDeltaX = 0.0;
-        } else if (mouseShouldModifyDriver.getSecond()) {
-            cobblemon$setDriverRotations(player, 0.0, cursorDeltaY);
-            cursorDeltaY = 0.0;
-        }
-
-        //-------------------------------------------------------------------------
-        // Smoothly return driver rotations to zero when needed
-        //-------------------------------------------------------------------------
-        var playerRotater = (RidePassenger)player;
-        if( !freeLooking && !mouseShouldModifyDriver.getFirst()){
-            playerRotater.cobblemon$setRideYRot(lerp(min(5.0f * (float)movementTime, 1.0f), Mth.wrapDegrees(playerRotater.cobblemon$getRideYRot()), 0.0f));
-        }
-        if( !freeLooking && !mouseShouldModifyDriver.getSecond()) {
-            playerRotater.cobblemon$setRideXRot(lerp(min(5.0f * (float)movementTime, 1.0f), Mth.wrapDegrees(playerRotater.cobblemon$getRideXRot()), 0.0f));
-        }
-
-        // Send mouse input to be interpreted into rotation deltas by the ride controller
-        Vec3 angVecMouse = cobblemon$getRideMouseRotation(cursorDeltaX, cursorDeltaY, movementTime);
-
-        // Perform Rotation using mouse influenced rotation deltas.
-        vehicleController.rotate(
-            (float) angVecMouse.x,
-            (float) angVecMouse.y,
-            (float) angVecMouse.z
-        );
-
-        // Gather and apply the current rotation deltas
-        var angRot = cobblemon$getAngularVelocity(movementTime);
-
-        // Apply smoothing if requested by the controller.
-        if(cobblemon$shouldUseAngVelSmoothing()) {
-            var yaw = yawSmoother.getNewDeltaValue(angRot.x * 0.5f, d);
-            var pitch = pitchSmoother.getNewDeltaValue(angRot.y * 0.5f, d);
-            var roll = rollSmoother.getNewDeltaValue(angRot.z * 0.5f, d);
-            vehicleController.rotate((float) yaw, (float) pitch, (float) roll);
-        }
-        else {
-            vehicleController.rotate((float) (angRot.x * 10 * d), (float) (angRot.y * 10 * d), (float) (angRot.z * 10 * d));
-        }
-
-        return returnValue;
+        // The camera sets the player's rotation from the look every frame so vanilla turn would only get overwritten
+        return false;
     }
 
     @Inject(method = "handleAccumulatedMovement", at = @At("HEAD"))
@@ -248,28 +230,9 @@ public abstract class MouseHandlerMixin {
         this.turnPlayer(cobblemon$timeDelta);
     }
 
+    /** The ride's share of the mouse put through the riding sensitivity, invert and swap options. */
     @Unique
-    private Vec3 cobblemon$getAngularVelocity(double deltaTime) {
-        var player = minecraft.player;
-        if (player == null) return Vec3.ZERO;
-        if (!(player instanceof OrientationControllable)) return Vec3.ZERO;
-
-        var playerVehicle = player.getVehicle();
-        if (playerVehicle == null) return Vec3.ZERO;
-        if (!(playerVehicle instanceof PokemonEntity pokemonEntity)) return Vec3.ZERO;
-        return pokemonEntity.ifRidingAvailableSupply(Vec3.ZERO, (behaviour, settings, state) -> {
-            return behaviour.angRollVel(settings, state, pokemonEntity, player, deltaTime);
-        });
-    }
-
-    @Unique
-    private Vec3 cobblemon$getRideMouseRotation(double mouseX, double mouseY, double deltaTime) {
-        var player = minecraft.player;
-        if (player == null) return Vec3.ZERO;
-        var vehicle = player.getVehicle();
-        if (vehicle == null) return Vec3.ZERO;
-        if (!(vehicle instanceof PokemonEntity pokemonEntity)) return Vec3.ZERO;
-
+    private RideSteerInput cobblemon$getSteerInput(OrientationController controller, double mouseX, double mouseY, double deltaTime) {
         var invertYaw = Cobblemon.config.getInvertYaw();
         var invertPitch = Cobblemon.config.getInvertPitch();
 
@@ -282,21 +245,18 @@ public abstract class MouseHandlerMixin {
 
         var pitch = (swapXAndY ? xValue : yValue) * (invertPitch? -1.0f : 1.0f);
 
-        var sensitivity = cobblemon$getRidingSensitivity();
-        return pokemonEntity.ifRidingAvailableSupply(Vec3.ZERO, (behaviour, settings, state) -> {
-            return behaviour.rotationOnMouseXY(
-                    settings,
-                    state,
-                    pokemonEntity,
-                    player,
-                    pitch,
-                    yaw,
-                    yMouseSmoother,
-                    xMouseSmoother,
-                    sensitivity,
-                    deltaTime
-            );
-        });
+        return new RideSteerInput(
+                controller,
+                yaw,
+                pitch,
+                xMouseSmoother,
+                yMouseSmoother,
+                cobblemon$getRidingSensitivity(),
+                deltaTime,
+                yawSmoother,
+                pitchSmoother,
+                rollSmoother
+        );
     }
 
     @Unique
@@ -305,31 +265,33 @@ public abstract class MouseHandlerMixin {
         return Math.pow(sensitivity, 3);
     }
 
+    /** Moves the ride look by degrees within the ride's look limits. Same job as vanilla turn but on the look instead of the player. */
     @Unique
-    private void cobblemon$setDriverRotations(LocalPlayer player, double cursorDeltaX, double cursorDeltaY) {
-        // the vanilla turn() method redone so that it uses rideRotations.
-        float f = (float)cursorDeltaY * 0.15F; // Note: turn() uses xRot for pitch (up/down)
-        float g = (float)cursorDeltaX * 0.15F; // Note: turn() uses yRot for yaw (left/right)
+    private void cobblemon$addLook(LocalPlayer player, float yawDelta, float pitchDelta) {
         var playerRotater = (RidePassenger)player;
-        playerRotater.cobblemon$setRideXRot(playerRotater.cobblemon$getRideXRot() + f);
-        playerRotater.cobblemon$setRideYRot(playerRotater.cobblemon$getRideYRot() + g);
-        playerRotater.cobblemon$setRideXRot(Mth.clamp(playerRotater.cobblemon$getRideXRot(), -89.0F, 89.0F));
-        playerRotater.cobblemon$setRideYRot(Mth.clamp(playerRotater.cobblemon$getRideYRot(), -105.0F, 105.0F));
+        var lookSettings = cobblemon$getLookSettings(player);
+        playerRotater.cobblemon$setRideXRot(cobblemon$softClamp(playerRotater.cobblemon$getRideXRot(), pitchDelta, lookSettings.getMaxPitch()));
+        playerRotater.cobblemon$setRideYRot(cobblemon$softClamp(playerRotater.cobblemon$getRideYRot(), yawDelta, lookSettings.getMaxYaw()));
         if (player.getVehicle() != null) {
             player.getVehicle().onPassengerTurned(player);
         }
     }
 
+    /**
+     * Moves an angle by delta while keeping it inside the limit. An angle already past the limit
+     * (the base turning under a low carry look can put it there) isn't snapped back, it just can't go further out.
+     */
     @Unique
-    private boolean cobblemon$shouldUseAngVelSmoothing() {
-        var player = minecraft.player;
-        if (player == null) return true;
+    private static float cobblemon$softClamp(float angle, float delta, float limit) {
+        float bound = Math.max(limit, Math.abs(angle));
+        return Mth.clamp(angle + delta, -bound, bound);
+    }
 
-        var playerVehicle = player.getVehicle();
-        if (playerVehicle == null) return true;
-        if (!(playerVehicle instanceof PokemonEntity pokemonEntity)) return true;
-        return pokemonEntity.ifRidingAvailableSupply(true, (behaviour, settings, state) -> {
-            return behaviour.useAngVelSmoothing(settings, state, pokemonEntity);
+    @Unique
+    private RideLookSettings cobblemon$getLookSettings(LocalPlayer player) {
+        if (!(player.getVehicle() instanceof PokemonEntity pokemonEntity)) return RideLookSettings.DEFAULT;
+        return pokemonEntity.ifRidingAvailableSupply(RideLookSettings.DEFAULT, (behaviour, settings, state) -> {
+            return behaviour.lookSettings(settings, state, pokemonEntity);
         });
     }
 

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

@@ -9,55 +9,25 @@
 package com.cobblemon.mod.common.mixin.client;
 
 import com.cobblemon.mod.common.CobblemonRecipeCategories;
-import net.minecraft.client.ClientRecipeBook;
-import net.minecraft.client.Minecraft;
+import com.llamalad7.mixinextras.expression.Definition;
+import com.llamalad7.mixinextras.expression.Expression;
+import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
+import com.llamalad7.mixinextras.sugar.Local;
 import net.minecraft.client.RecipeBookCategories;
 import net.minecraft.client.gui.screens.recipebook.RecipeBookComponent;
-import net.minecraft.client.gui.screens.recipebook.RecipeBookPage;
-import net.minecraft.client.gui.screens.recipebook.RecipeBookTabButton;
-import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 @Mixin(RecipeBookComponent.class)
 public class RecipeBookComponentMixin {
-
-    @Shadow private ClientRecipeBook book;
-
-    @Shadow protected Minecraft minecraft;
-
-    @Shadow private int width;
-
-    @Shadow private int xOffset;
-
-    @Shadow private int height;
-
-    @Shadow @Final private RecipeBookPage recipeBookPage;
-
-    @Inject(method = "updateTabs", at = @At("HEAD"), cancellable = true)
-    private void customUpdateTabs(CallbackInfo ci) {
-        RecipeBookComponent instance = (RecipeBookComponent) (Object) this;
-        int i = (width - 147) / 2 - xOffset - 30;
-        int j = (height - 166) / 2 + 3;
-        int k = 27;
-        int l = 0;
-
-        for (RecipeBookTabButton recipeBookTabButton : instance.tabButtons) {
-            RecipeBookCategories recipeBookCategories = recipeBookTabButton.getCategory();
-            if (recipeBookCategories != RecipeBookCategories.CRAFTING_SEARCH && recipeBookCategories != RecipeBookCategories.FURNACE_SEARCH && recipeBookCategories != CobblemonRecipeCategories.COOKING_POT_SEARCH.toVanillaCategory()) {
-                if (recipeBookTabButton.updateVisibility(book)) {
-                    recipeBookTabButton.setPosition(i, j + 27 * l++);
-                    recipeBookTabButton.startAnimation(minecraft);
-                }
-            } else {
-                recipeBookTabButton.visible = true;
-                recipeBookTabButton.setPosition(i, j + k * l++);
-            }
-        }
-
-        ci.cancel();
+    @Definition(id = "recipeBookCategories", local = @Local(type = RecipeBookCategories.class))
+    @Definition(id = "FURNACE_SEARCH", field = "Lnet/minecraft/client/RecipeBookCategories;FURNACE_SEARCH:Lnet/minecraft/client/RecipeBookCategories;")
+    @Expression("recipeBookCategories != FURNACE_SEARCH")
+    @ModifyExpressionValue(
+            method = "updateTabs",
+            at = @At(value = "MIXINEXTRAS:EXPRESSION")
+    )
+    private boolean notCookingPotSearch(boolean original, @Local RecipeBookCategories recipeBookCategories) {
+        return original && recipeBookCategories != CobblemonRecipeCategories.COOKING_POT_SEARCH.toVanillaCategory();
     }
 }

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

@@ -38,6 +38,9 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 @Mixin(Entity.class)
 public abstract class EntityMixin {
 
+    // How far the clientsent ride eye can sit from the players
+    @Unique private static final double COBBLEMON$MAX_RIDE_EYE_OFFSET = 3.0;
+
     @Shadow @Nullable public abstract Entity getVehicle();
 
     @Inject(method = "updateInWaterStateAndDoWaterCurrentPushing", at = @At(value = "FIELD", target = "Lnet/minecraft/world/entity/Entity;wasTouchingWater:Z", ordinal = 1), cancellable = true)
@@ -91,6 +94,9 @@ public abstract class EntityMixin {
         if (vehicleController == null) return;
 
         Vec3 customEyePos = ridePassenger.cobblemon$getRideEyePos();
+        Vec3 vanillaEyePos = new Vec3(player.getX(), player.getEyeY(), player.getZ());
+        double maxSqr = COBBLEMON$MAX_RIDE_EYE_OFFSET * COBBLEMON$MAX_RIDE_EYE_OFFSET;
+        if (customEyePos == null || !(customEyePos.distanceToSqr(vanillaEyePos) <= maxSqr)) return;
         cir.setReturnValue(customEyePos);
     }
 

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

@@ -260,6 +260,9 @@ object Cobblemon {
             RequestManager.onLogoff(it.player)
             serverPlayerStructs.remove(it.player.uuid)
         }
+        PlatformEvents.PLAYER_RESPAWN.subscribe {
+            serverPlayerStructs.remove(it.player.uuid)
+        }
         PlatformEvents.PLAYER_DEATH.subscribe {
             PCLinkManager.removeLink(it.player.uuid)
             battleRegistry.getBattleByParticipatingPlayer(it.player)?.stop()

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

@@ -845,54 +845,35 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     @JvmField
     val PEP_UP_FLOWER = this.create("pep_up_flower", FlowerBlock(MobEffects.LEVITATION, 10F, BlockBehaviour.Properties.of().mapColor(MapColor.PLANT).noCollission().instabreak().sound(SoundType.GRASS).offsetType(BlockBehaviour.OffsetType.XZ).pushReaction(PushReaction.DESTROY)))
     @JvmField
-    val POTTED_PEP_UP_FLOWER = this.create("potted_pep_up_flower", BlocksInvoker.createFlowerPotBlock(PEP_UP_FLOWER))
-    @JvmField
     val HEARTY_GRAINS = this.create("hearty_grains", HeartyGrainsBlock(BlockBehaviour.Properties.of().pushReaction(PushReaction.DESTROY).ignitedByLava().mapColor(MapColor.PLANT).noCollission().randomTicks().instabreak()))
-
     @JvmField
     val GALARICA_NUT_BUSH = this.create("galarica_nut_bush", NutBushBlock(BlockBehaviour.Properties.of().mapColor(MapColor.PLANT).randomTicks().noCollission().sound(SoundType.SWEET_BERRY_BUSH).pushReaction(PushReaction.DESTROY)))
 
-    @JvmField
-    val POTTED_RED_APRICORN_SAPLING = this.create("potted_red_apricorn_sapling", BlocksInvoker.createFlowerPotBlock(RED_APRICORN_SAPLING))
-    @JvmField
-    val POTTED_YELLOW_APRICORN_SAPLING = this.create("potted_yellow_apricorn_sapling", BlocksInvoker.createFlowerPotBlock(YELLOW_APRICORN_SAPLING))
-    @JvmField
-    val POTTED_GREEN_APRICORN_SAPLING = this.create("potted_green_apricorn_sapling", BlocksInvoker.createFlowerPotBlock(GREEN_APRICORN_SAPLING))
-    @JvmField
-    val POTTED_BLUE_APRICORN_SAPLING = this.create("potted_blue_apricorn_sapling", BlocksInvoker.createFlowerPotBlock(BLUE_APRICORN_SAPLING))
-    @JvmField
-    val POTTED_PINK_APRICORN_SAPLING = this.create("potted_pink_apricorn_sapling", BlocksInvoker.createFlowerPotBlock(PINK_APRICORN_SAPLING))
-    @JvmField
-    val POTTED_BLACK_APRICORN_SAPLING = this.create("potted_black_apricorn_sapling", BlocksInvoker.createFlowerPotBlock(BLACK_APRICORN_SAPLING))
-    @JvmField
-    val POTTED_WHITE_APRICORN_SAPLING = this.create("potted_white_apricorn_sapling", BlocksInvoker.createFlowerPotBlock(WHITE_APRICORN_SAPLING))
-    @JvmField
-    val POTTED_SACCHARINE_SAPLING = this.create("potted_saccharine_sapling", BlocksInvoker.createFlowerPotBlock(SACCHARINE_SAPLING))
 
     @JvmField
     val RED_MINT_LEAF_LITTER = this.mintLitter("red_mint_leaf_litter", MapColor.COLOR_RED)
     @JvmField
-    val POTTED_RED_MINT = this.pottedPlant("potted_red_mint", RED_MINT_LEAF_LITTER)
+    val POTTED_RED_MINT = this.flowerPot("potted_red_mint", RED_MINT_LEAF_LITTER)
     @JvmField
     val BLUE_MINT_LEAF_LITTER = this.mintLitter("blue_mint_leaf_litter", MapColor.COLOR_BLUE)
     @JvmField
-    val POTTED_BLUE_MINT = this.pottedPlant("potted_blue_mint", BLUE_MINT_LEAF_LITTER)
+    val POTTED_BLUE_MINT = this.flowerPot("potted_blue_mint", BLUE_MINT_LEAF_LITTER)
     @JvmField
     val CYAN_MINT_LEAF_LITTER = this.mintLitter("cyan_mint_leaf_litter", MapColor.COLOR_CYAN)
     @JvmField
-    val POTTED_CYAN_MINT = this.pottedPlant("potted_cyan_mint", CYAN_MINT_LEAF_LITTER)
+    val POTTED_CYAN_MINT = this.flowerPot("potted_cyan_mint", CYAN_MINT_LEAF_LITTER)
     @JvmField
     val PINK_MINT_LEAF_LITTER = this.mintLitter("pink_mint_leaf_litter", MapColor.COLOR_PINK)
     @JvmField
-    val POTTED_PINK_MINT = this.pottedPlant("potted_pink_mint", PINK_MINT_LEAF_LITTER)
+    val POTTED_PINK_MINT = this.flowerPot("potted_pink_mint", PINK_MINT_LEAF_LITTER)
     @JvmField
     val GREEN_MINT_LEAF_LITTER = this.mintLitter("green_mint_leaf_litter", MapColor.COLOR_GREEN)
     @JvmField
-    val POTTED_GREEN_MINT = this.pottedPlant("potted_green_mint", GREEN_MINT_LEAF_LITTER)
+    val POTTED_GREEN_MINT = this.flowerPot("potted_green_mint", GREEN_MINT_LEAF_LITTER)
     @JvmField
     val WHITE_MINT_LEAF_LITTER = this.mintLitter("white_mint_leaf_litter", MapColor.SNOW)
     @JvmField
-    val POTTED_WHITE_MINT = this.pottedPlant("potted_white_mint", WHITE_MINT_LEAF_LITTER)
+    val POTTED_WHITE_MINT = this.flowerPot("potted_white_mint", WHITE_MINT_LEAF_LITTER)
 
     @JvmField
     val LOBAILA = this.create("lobaila", LobailaFlowerBlock(BlockBehaviour.Properties.of().mapColor(MapColor.PLANT).noCollission().instabreak().sound(SoundType.GRASS).offsetType(BlockBehaviour.OffsetType.XZ).ignitedByLava().pushReaction(PushReaction.DESTROY)))
@@ -1104,145 +1085,163 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     //val BINDING_SOIL = this.create("binding_soil", BindingSoilBlock(BlockBehaviour.Properties.of()))
 
     @JvmField
-    val POTTED_AGUAV_BERRY = this.create("potted_aguav_berry", BlocksInvoker.createFlowerPotBlock(AGUAV_BERRY))
+    val POTTED_AGUAV_BERRY = this.flowerPot("potted_aguav_berry", AGUAV_BERRY)
     @JvmField
-    val POTTED_APICOT_BERRY = this.create("potted_apicot_berry", BlocksInvoker.createFlowerPotBlock(APICOT_BERRY))
+    val POTTED_APICOT_BERRY = this.flowerPot("potted_apicot_berry", APICOT_BERRY)
     @JvmField
-    val POTTED_ASPEAR_BERRY = this.create("potted_aspear_berry", BlocksInvoker.createFlowerPotBlock(ASPEAR_BERRY))
+    val POTTED_ASPEAR_BERRY = this.flowerPot("potted_aspear_berry", ASPEAR_BERRY)
     @JvmField
-    val POTTED_BABIRI_BERRY = this.create("potted_babiri_berry", BlocksInvoker.createFlowerPotBlock(BABIRI_BERRY))
+    val POTTED_BABIRI_BERRY = this.flowerPot("potted_babiri_berry", BABIRI_BERRY)
     @JvmField
-    val POTTED_BELUE_BERRY = this.create("potted_belue_berry", BlocksInvoker.createFlowerPotBlock(BELUE_BERRY))
+    val POTTED_BELUE_BERRY = this.flowerPot("potted_belue_berry", BELUE_BERRY)
     @JvmField
-    val POTTED_BLUK_BERRY = this.create("potted_bluk_berry", BlocksInvoker.createFlowerPotBlock(BLUK_BERRY))
+    val POTTED_BLUK_BERRY = this.flowerPot("potted_bluk_berry", BLUK_BERRY)
     @JvmField
-    val POTTED_CHARTI_BERRY = this.create("potted_charti_berry", BlocksInvoker.createFlowerPotBlock(CHARTI_BERRY))
+    val POTTED_CHARTI_BERRY = this.flowerPot("potted_charti_berry", CHARTI_BERRY)
     @JvmField
-    val POTTED_CHERI_BERRY = this.create("potted_cheri_berry", BlocksInvoker.createFlowerPotBlock(CHERI_BERRY))
+    val POTTED_CHERI_BERRY = this.flowerPot("potted_cheri_berry", CHERI_BERRY)
     @JvmField
-    val POTTED_CHESTO_BERRY = this.create("potted_chesto_berry", BlocksInvoker.createFlowerPotBlock(CHESTO_BERRY))
+    val POTTED_CHESTO_BERRY = this.flowerPot("potted_chesto_berry", CHESTO_BERRY)
     @JvmField
-    val POTTED_CHILAN_BERRY = this.create("potted_chilan_berry", BlocksInvoker.createFlowerPotBlock(CHILAN_BERRY))
+    val POTTED_CHILAN_BERRY = this.flowerPot("potted_chilan_berry", CHILAN_BERRY)
     @JvmField
-    val POTTED_CHOPLE_BERRY = this.create("potted_chople_berry", BlocksInvoker.createFlowerPotBlock(CHOPLE_BERRY))
+    val POTTED_CHOPLE_BERRY = this.flowerPot("potted_chople_berry", CHOPLE_BERRY)
     @JvmField
-    val POTTED_COBA_BERRY = this.create("potted_coba_berry", BlocksInvoker.createFlowerPotBlock(COBA_BERRY))
+    val POTTED_COBA_BERRY = this.flowerPot("potted_coba_berry", COBA_BERRY)
     @JvmField
-    val POTTED_COLBUR_BERRY = this.create("potted_colbur_berry", BlocksInvoker.createFlowerPotBlock(COLBUR_BERRY))
+    val POTTED_COLBUR_BERRY = this.flowerPot("potted_colbur_berry", COLBUR_BERRY)
     @JvmField
-    val POTTED_CORNN_BERRY = this.create("potted_cornn_berry", BlocksInvoker.createFlowerPotBlock(CORNN_BERRY))
+    val POTTED_CORNN_BERRY = this.flowerPot("potted_cornn_berry", CORNN_BERRY)
     @JvmField
-    val POTTED_CUSTAP_BERRY = this.create("potted_custap_berry", BlocksInvoker.createFlowerPotBlock(CUSTAP_BERRY))
+    val POTTED_CUSTAP_BERRY = this.flowerPot("potted_custap_berry", CUSTAP_BERRY)
     @JvmField
-    val POTTED_DURIN_BERRY = this.create("potted_durin_berry", BlocksInvoker.createFlowerPotBlock(DURIN_BERRY))
+    val POTTED_DURIN_BERRY = this.flowerPot("potted_durin_berry", DURIN_BERRY)
     @JvmField
-    val POTTED_EGGANT_BERRY = this.create("potted_eggant_berry", BlocksInvoker.createFlowerPotBlock(EGGANT_BERRY))
+    val POTTED_EGGANT_BERRY = this.flowerPot("potted_eggant_berry", EGGANT_BERRY)
     @JvmField
-    val POTTED_ENIGMA_BERRY = this.create("potted_enigma_berry", BlocksInvoker.createFlowerPotBlock(ENIGMA_BERRY))
+    val POTTED_ENIGMA_BERRY = this.flowerPot("potted_enigma_berry", ENIGMA_BERRY)
     @JvmField
-    val POTTED_FIGY_BERRY = this.create("potted_figy_berry", BlocksInvoker.createFlowerPotBlock(FIGY_BERRY))
+    val POTTED_FIGY_BERRY = this.flowerPot("potted_figy_berry", FIGY_BERRY)
     @JvmField
-    val POTTED_GANLON_BERRY = this.create("potted_ganlon_berry", BlocksInvoker.createFlowerPotBlock(GANLON_BERRY))
+    val POTTED_GANLON_BERRY = this.flowerPot("potted_ganlon_berry", GANLON_BERRY)
     @JvmField
-    val POTTED_GREPA_BERRY = this.create("potted_grepa_berry", BlocksInvoker.createFlowerPotBlock(GREPA_BERRY))
+    val POTTED_GREPA_BERRY = this.flowerPot("potted_grepa_berry", GREPA_BERRY)
     @JvmField
-    val POTTED_HABAN_BERRY = this.create("potted_haban_berry", BlocksInvoker.createFlowerPotBlock(HABAN_BERRY))
+    val POTTED_HABAN_BERRY = this.flowerPot("potted_haban_berry", HABAN_BERRY)
     @JvmField
-    val POTTED_HONDEW_BERRY = this.create("potted_hondew_berry", BlocksInvoker.createFlowerPotBlock(HONDEW_BERRY))
+    val POTTED_HONDEW_BERRY = this.flowerPot("potted_hondew_berry", HONDEW_BERRY)
     @JvmField
-    val POTTED_HOPO_BERRY = this.create("potted_hopo_berry", BlocksInvoker.createFlowerPotBlock(HOPO_BERRY))
+    val POTTED_HOPO_BERRY = this.flowerPot("potted_hopo_berry", HOPO_BERRY)
     @JvmField
-    val POTTED_IAPAPA_BERRY = this.create("potted_iapapa_berry", BlocksInvoker.createFlowerPotBlock(IAPAPA_BERRY))
+    val POTTED_IAPAPA_BERRY = this.flowerPot("potted_iapapa_berry", IAPAPA_BERRY)
     @JvmField
-    val POTTED_JABOCA_BERRY = this.create("potted_jaboca_berry", BlocksInvoker.createFlowerPotBlock(JABOCA_BERRY))
+    val POTTED_JABOCA_BERRY = this.flowerPot("potted_jaboca_berry", JABOCA_BERRY)
     @JvmField
-    val POTTED_KASIB_BERRY = this.create("potted_kasib_berry", BlocksInvoker.createFlowerPotBlock(KASIB_BERRY))
+    val POTTED_KASIB_BERRY = this.flowerPot("potted_kasib_berry", KASIB_BERRY)
     @JvmField
-    val POTTED_KEBIA_BERRY = this.create("potted_kebia_berry", BlocksInvoker.createFlowerPotBlock(KEBIA_BERRY))
+    val POTTED_KEBIA_BERRY = this.flowerPot("potted_kebia_berry", KEBIA_BERRY)
     @JvmField
-    val POTTED_KEE_BERRY = this.create("potted_kee_berry", BlocksInvoker.createFlowerPotBlock(KEE_BERRY))
+    val POTTED_KEE_BERRY = this.flowerPot("potted_kee_berry", KEE_BERRY)
     @JvmField
-    val POTTED_KELPSY_BERRY = this.create("potted_kelpsy_berry", BlocksInvoker.createFlowerPotBlock(KELPSY_BERRY))
+    val POTTED_KELPSY_BERRY = this.flowerPot("potted_kelpsy_berry", KELPSY_BERRY)
     @JvmField
-    val POTTED_LANSAT_BERRY = this.create("potted_lansat_berry", BlocksInvoker.createFlowerPotBlock(LANSAT_BERRY))
+    val POTTED_LANSAT_BERRY = this.flowerPot("potted_lansat_berry", LANSAT_BERRY)
     @JvmField
-    val POTTED_LEPPA_BERRY = this.create("potted_leppa_berry", BlocksInvoker.createFlowerPotBlock(LEPPA_BERRY))
+    val POTTED_LEPPA_BERRY = this.flowerPot("potted_leppa_berry", LEPPA_BERRY)
     @JvmField
-    val POTTED_LIECHI_BERRY = this.create("potted_liechi_berry", BlocksInvoker.createFlowerPotBlock(LIECHI_BERRY))
+    val POTTED_LIECHI_BERRY = this.flowerPot("potted_liechi_berry", LIECHI_BERRY)
     @JvmField
-    val POTTED_LUM_BERRY = this.create("potted_lum_berry", BlocksInvoker.createFlowerPotBlock(LUM_BERRY))
+    val POTTED_LUM_BERRY = this.flowerPot("potted_lum_berry", LUM_BERRY)
     @JvmField
-    val POTTED_MAGO_BERRY = this.create("potted_mago_berry", BlocksInvoker.createFlowerPotBlock(MAGO_BERRY))
+    val POTTED_MAGO_BERRY = this.flowerPot("potted_mago_berry", MAGO_BERRY)
     @JvmField
-    val POTTED_MAGOST_BERRY = this.create("potted_magost_berry", BlocksInvoker.createFlowerPotBlock(MAGOST_BERRY))
+    val POTTED_MAGOST_BERRY = this.flowerPot("potted_magost_berry", MAGOST_BERRY)
     @JvmField
-    val POTTED_MARANGA_BERRY = this.create("potted_maranga_berry", BlocksInvoker.createFlowerPotBlock(MARANGA_BERRY))
+    val POTTED_MARANGA_BERRY = this.flowerPot("potted_maranga_berry", MARANGA_BERRY)
     @JvmField
-    val POTTED_MICLE_BERRY = this.create("potted_micle_berry", BlocksInvoker.createFlowerPotBlock(MICLE_BERRY))
+    val POTTED_MICLE_BERRY = this.flowerPot("potted_micle_berry", MICLE_BERRY)
     @JvmField
-    val POTTED_NANAB_BERRY = this.create("potted_nanab_berry", BlocksInvoker.createFlowerPotBlock(NANAB_BERRY))
+    val POTTED_NANAB_BERRY = this.flowerPot("potted_nanab_berry", NANAB_BERRY)
     @JvmField
-    val POTTED_NOMEL_BERRY = this.create("potted_nomel_berry", BlocksInvoker.createFlowerPotBlock(NOMEL_BERRY))
+    val POTTED_NOMEL_BERRY = this.flowerPot("potted_nomel_berry", NOMEL_BERRY)
     @JvmField
-    val POTTED_OCCA_BERRY = this.create("potted_occa_berry", BlocksInvoker.createFlowerPotBlock(OCCA_BERRY))
+    val POTTED_OCCA_BERRY = this.flowerPot("potted_occa_berry", OCCA_BERRY)
     @JvmField
-    val POTTED_ORAN_BERRY = this.create("potted_oran_berry", BlocksInvoker.createFlowerPotBlock(ORAN_BERRY))
+    val POTTED_ORAN_BERRY = this.flowerPot("potted_oran_berry", ORAN_BERRY)
     @JvmField
-    val POTTED_PAMTRE_BERRY = this.create("potted_pamtre_berry", BlocksInvoker.createFlowerPotBlock(PAMTRE_BERRY))
+    val POTTED_PAMTRE_BERRY = this.flowerPot("potted_pamtre_berry", PAMTRE_BERRY)
     @JvmField
-    val POTTED_PASSHO_BERRY = this.create("potted_passho_berry", BlocksInvoker.createFlowerPotBlock(PASSHO_BERRY))
+    val POTTED_PASSHO_BERRY = this.flowerPot("potted_passho_berry", PASSHO_BERRY)
     @JvmField
-    val POTTED_PAYAPA_BERRY = this.create("potted_payapa_berry", BlocksInvoker.createFlowerPotBlock(PAYAPA_BERRY))
+    val POTTED_PAYAPA_BERRY = this.flowerPot("potted_payapa_berry", PAYAPA_BERRY)
     @JvmField
-    val POTTED_PECHA_BERRY = this.create("potted_pecha_berry", BlocksInvoker.createFlowerPotBlock(PECHA_BERRY))
+    val POTTED_PECHA_BERRY = this.flowerPot("potted_pecha_berry", PECHA_BERRY)
     @JvmField
-    val POTTED_PERSIM_BERRY = this.create("potted_persim_berry", BlocksInvoker.createFlowerPotBlock(PERSIM_BERRY))
+    val POTTED_PERSIM_BERRY = this.flowerPot("potted_persim_berry", PERSIM_BERRY)
     @JvmField
-    val POTTED_PETAYA_BERRY = this.create("potted_petaya_berry", BlocksInvoker.createFlowerPotBlock(PETAYA_BERRY))
+    val POTTED_PETAYA_BERRY = this.flowerPot("potted_petaya_berry", PETAYA_BERRY)
     @JvmField
-    val POTTED_PINAP_BERRY = this.create("potted_pinap_berry", BlocksInvoker.createFlowerPotBlock(PINAP_BERRY))
+    val POTTED_PINAP_BERRY = this.flowerPot("potted_pinap_berry", PINAP_BERRY)
     @JvmField
-    val POTTED_POMEG_BERRY = this.create("potted_pomeg_berry", BlocksInvoker.createFlowerPotBlock(POMEG_BERRY))
+    val POTTED_POMEG_BERRY = this.flowerPot("potted_pomeg_berry", POMEG_BERRY)
     @JvmField
-    val POTTED_QUALOT_BERRY = this.create("potted_qualot_berry", BlocksInvoker.createFlowerPotBlock(QUALOT_BERRY))
+    val POTTED_QUALOT_BERRY = this.flowerPot("potted_qualot_berry", QUALOT_BERRY)
     @JvmField
-    val POTTED_RABUTA_BERRY = this.create("potted_rabuta_berry", BlocksInvoker.createFlowerPotBlock(RABUTA_BERRY))
+    val POTTED_RABUTA_BERRY = this.flowerPot("potted_rabuta_berry", RABUTA_BERRY)
     @JvmField
-    val POTTED_RAWST_BERRY = this.create("potted_rawst_berry", BlocksInvoker.createFlowerPotBlock(RAWST_BERRY))
+    val POTTED_RAWST_BERRY = this.flowerPot("potted_rawst_berry", RAWST_BERRY)
     @JvmField
-    val POTTED_RAZZ_BERRY = this.create("potted_razz_berry", BlocksInvoker.createFlowerPotBlock(RAZZ_BERRY))
+    val POTTED_RAZZ_BERRY = this.flowerPot("potted_razz_berry", RAZZ_BERRY)
     @JvmField
-    val POTTED_RINDO_BERRY = this.create("potted_rindo_berry", BlocksInvoker.createFlowerPotBlock(RINDO_BERRY))
+    val POTTED_RINDO_BERRY = this.flowerPot("potted_rindo_berry", RINDO_BERRY)
     @JvmField
-    val POTTED_ROSELI_BERRY = this.create("potted_roseli_berry", BlocksInvoker.createFlowerPotBlock(ROSELI_BERRY))
+    val POTTED_ROSELI_BERRY = this.flowerPot("potted_roseli_berry", ROSELI_BERRY)
     @JvmField
-    val POTTED_ROWAP_BERRY = this.create("potted_rowap_berry", BlocksInvoker.createFlowerPotBlock(ROWAP_BERRY))
+    val POTTED_ROWAP_BERRY = this.flowerPot("potted_rowap_berry", ROWAP_BERRY)
     @JvmField
-    val POTTED_SALAC_BERRY = this.create("potted_salac_berry", BlocksInvoker.createFlowerPotBlock(SALAC_BERRY))
+    val POTTED_SALAC_BERRY = this.flowerPot("potted_salac_berry", SALAC_BERRY)
     @JvmField
-    val POTTED_SHUCA_BERRY = this.create("potted_shuca_berry", BlocksInvoker.createFlowerPotBlock(SHUCA_BERRY))
+    val POTTED_SHUCA_BERRY = this.flowerPot("potted_shuca_berry", SHUCA_BERRY)
     @JvmField
-    val POTTED_SITRUS_BERRY = this.create("potted_sitrus_berry", BlocksInvoker.createFlowerPotBlock(SITRUS_BERRY))
+    val POTTED_SITRUS_BERRY = this.flowerPot("potted_sitrus_berry", SITRUS_BERRY)
     @JvmField
-    val POTTED_SPELON_BERRY = this.create("potted_spelon_berry", BlocksInvoker.createFlowerPotBlock(SPELON_BERRY))
+    val POTTED_SPELON_BERRY = this.flowerPot("potted_spelon_berry", SPELON_BERRY)
     @JvmField
-    val POTTED_STARF_BERRY = this.create("potted_starf_berry", BlocksInvoker.createFlowerPotBlock(STARF_BERRY))
+    val POTTED_STARF_BERRY = this.flowerPot("potted_starf_berry", STARF_BERRY)
     @JvmField
-    val POTTED_TAMATO_BERRY = this.create("potted_tamato_berry", BlocksInvoker.createFlowerPotBlock(TAMATO_BERRY))
+    val POTTED_TAMATO_BERRY = this.flowerPot("potted_tamato_berry", TAMATO_BERRY)
     @JvmField
-    val POTTED_TANGA_BERRY = this.create("potted_tanga_berry", BlocksInvoker.createFlowerPotBlock(TANGA_BERRY))
+    val POTTED_TANGA_BERRY = this.flowerPot("potted_tanga_berry", TANGA_BERRY)
     @JvmField
-    val POTTED_TOUGA_BERRY = this.create("potted_touga_berry", BlocksInvoker.createFlowerPotBlock(TOUGA_BERRY))
+    val POTTED_TOUGA_BERRY = this.flowerPot("potted_touga_berry", TOUGA_BERRY)
     @JvmField
-    val POTTED_WACAN_BERRY = this.create("potted_wacan_berry", BlocksInvoker.createFlowerPotBlock(WACAN_BERRY))
+    val POTTED_WACAN_BERRY = this.flowerPot("potted_wacan_berry", WACAN_BERRY)
     @JvmField
-    val POTTED_WATMEL_BERRY = this.create("potted_watmel_berry", BlocksInvoker.createFlowerPotBlock(WATMEL_BERRY))
+    val POTTED_WATMEL_BERRY = this.flowerPot("potted_watmel_berry", WATMEL_BERRY)
     @JvmField
-    val POTTED_WEPEAR_BERRY = this.create("potted_wepear_berry", BlocksInvoker.createFlowerPotBlock(WEPEAR_BERRY))
+    val POTTED_WEPEAR_BERRY = this.flowerPot("potted_wepear_berry", WEPEAR_BERRY)
     @JvmField
-    val POTTED_WIKI_BERRY = this.create("potted_wiki_berry", BlocksInvoker.createFlowerPotBlock(WIKI_BERRY))
+    val POTTED_WIKI_BERRY = this.flowerPot("potted_wiki_berry", WIKI_BERRY)
     @JvmField
-    val POTTED_YACHE_BERRY = this.create("potted_yache_berry", BlocksInvoker.createFlowerPotBlock(YACHE_BERRY))
+    val POTTED_YACHE_BERRY = this.flowerPot("potted_yache_berry", YACHE_BERRY)
+    @JvmField
+    val POTTED_PEP_UP_FLOWER = this.flowerPot("potted_pep_up_flower", PEP_UP_FLOWER)
+    @JvmField
+    val POTTED_RED_APRICORN_SAPLING = this.flowerPot("potted_red_apricorn_sapling", RED_APRICORN_SAPLING)
+    @JvmField
+    val POTTED_YELLOW_APRICORN_SAPLING = this.flowerPot("potted_yellow_apricorn_sapling", YELLOW_APRICORN_SAPLING)
+    @JvmField
+    val POTTED_GREEN_APRICORN_SAPLING = this.flowerPot("potted_green_apricorn_sapling", GREEN_APRICORN_SAPLING)
+    @JvmField
+    val POTTED_BLUE_APRICORN_SAPLING = this.flowerPot("potted_blue_apricorn_sapling", BLUE_APRICORN_SAPLING)
+    @JvmField
+    val POTTED_PINK_APRICORN_SAPLING = this.flowerPot("potted_pink_apricorn_sapling", PINK_APRICORN_SAPLING)
+    @JvmField
+    val POTTED_BLACK_APRICORN_SAPLING = this.flowerPot("potted_black_apricorn_sapling", BLACK_APRICORN_SAPLING)
+    @JvmField
+    val POTTED_WHITE_APRICORN_SAPLING = this.flowerPot("potted_white_apricorn_sapling", WHITE_APRICORN_SAPLING)
+    @JvmField
+    val POTTED_SACCHARINE_SAPLING = this.flowerPot("potted_saccharine_sapling", SACCHARINE_SAPLING)
 
     init {
         /**
@@ -1346,7 +1345,16 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
 
     fun typeGemClusters() = typeGemClusters.toMap()
 
-    private fun pottedPlant(name: String, flower: Block) = this.create(name, BlocksInvoker.createFlowerPotBlock(flower))
+    private fun flowerPot(name: String, flower: Block) = this.create(
+        name,
+        FlowerPotBlock(
+            flower,
+            BlockBehaviour.Properties.of()
+                .instabreak()
+                .noOcclusion()
+                .pushReaction(PushReaction.DESTROY)
+        )
+    )
 
     private fun mintLitter(name: String, color: MapColor) = this.create(
         name,

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

@@ -425,7 +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(DexEvolutionDisplaySyncPacket.ID, DexEvolutionDisplaySyncPacket::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/CobblemonRideSettings.kt

@@ -20,6 +20,7 @@ import com.cobblemon.mod.common.api.riding.behaviour.types.air.HelicopterSetting
 import com.cobblemon.mod.common.api.riding.behaviour.types.air.HoverSettings
 import com.cobblemon.mod.common.api.riding.behaviour.types.air.JetSettings
 import com.cobblemon.mod.common.api.riding.behaviour.types.air.RocketSettings
+import com.cobblemon.mod.common.api.riding.behaviour.types.air.BoardSettings
 import com.cobblemon.mod.common.api.riding.behaviour.types.land.HorseSettings
 import com.cobblemon.mod.common.api.riding.behaviour.types.land.MinekartSettings
 import com.cobblemon.mod.common.api.riding.behaviour.types.land.VehicleSettings
@@ -56,6 +57,7 @@ object CobblemonRideSettings : DataRegistry {
     var hover = HoverSettings()
     var jet = JetSettings()
     var rocket = RocketSettings()
+    var board = BoardSettings()
 
     var horse = HorseSettings()
     var minekart = MinekartSettings()
@@ -75,6 +77,7 @@ object CobblemonRideSettings : DataRegistry {
                 hover = hover,
                 jet = jet,
                 rocket = rocket,
+                board = board,
                 horse = horse,
                 minekart = minekart,
                 vehicle = vehicle,
@@ -93,6 +96,7 @@ object CobblemonRideSettings : DataRegistry {
         hover = loadStyle(manager, "hover", HoverSettings::class.java)
         jet = loadStyle(manager, "jet", JetSettings::class.java)
         rocket = loadStyle(manager, "rocket", RocketSettings::class.java)
+        board = loadStyle(manager, "board", BoardSettings::class.java)
         horse = loadStyle(manager, "horse", HorseSettings::class.java)
         minekart = loadStyle(manager, "minekart", MinekartSettings::class.java)
         vehicle = loadStyle(manager, "vehicle", VehicleSettings::class.java)

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/config/task/HateEntityTaskConfig.kt

@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.api.ai.config.task
 
 import com.bedrockk.molang.Expression
+import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
 import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
@@ -17,6 +18,7 @@ import com.cobblemon.mod.common.util.asExpression
 import com.cobblemon.mod.common.util.mainThreadRuntime
 import com.cobblemon.mod.common.util.resolveBoolean
 import com.cobblemon.mod.common.util.withQueryValue
+import com.cobblemon.mod.common.world.gamerules.CobblemonGameRules
 import com.mojang.datafixers.util.Either
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.ai.behavior.BehaviorControl
@@ -34,6 +36,8 @@ import net.minecraft.world.entity.ai.sensing.SensorType
 class HateEntityTaskConfig : SingleTaskConfig {
     val entityCondition: Expression = "true".asExpression()
     val range: ExpressionOrEntityVariable = Either.left("24".asExpression())
+    val chance: Float = Cobblemon.config.predationChance
+    private val coercedChance = chance.coerceIn(0f, 1f)
 
     override fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext) = emptyList<MoLangConfigVariable>()
     override fun createTask(
@@ -43,24 +47,44 @@ class HateEntityTaskConfig : SingleTaskConfig {
         val range = range.resolveFloat(behaviourConfigurationContext.runtime)
         behaviourConfigurationContext.addMemories(
             MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES,
-            MemoryModuleType.ANGRY_AT
+            MemoryModuleType.ANGRY_AT,
+            MemoryModuleType.ATTACK_TARGET
         )
         behaviourConfigurationContext.addSensors(SensorType.NEAREST_LIVING_ENTITIES)
         return BehaviorBuilder.create { instance ->
             instance.group(
                 instance.present(MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES),
-                instance.registered(MemoryModuleType.ANGRY_AT)
-            ).apply(instance) { entities, angryAt ->
+                instance.registered(MemoryModuleType.ANGRY_AT),
+                instance.registered(MemoryModuleType.ATTACK_TARGET),
+            ).apply(instance) { entities, angryAt, attackTarget ->
                 Trigger { world, entity, _ ->
-                    val target = instance.get(entities).findClosest {
-                        mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
+                    // bail if gamerule is disabled
+                    if (!world.gameRules.getBoolean(CobblemonGameRules.DO_POKEMON_PREDATION)) return@Trigger false
+                    val target = instance.get(entities).findClosest { hated ->
+                        mainThreadRuntime.withQueryValue("entity", hated.asMostSpecificMoLangValue())
                         return@findClosest mainThreadRuntime.resolveBoolean(entityCondition)
                     }.orElse(null)
 
+                    var shouldTrigger = false
                     if (target != null && target.distanceTo(entity) <= range) {
-                        angryAt.set(target.uuid)
+                        shouldTrigger = when {
+                            // set always attacking if activity chance is equal to 1.0
+                            coercedChance == 1f -> {
+                                angryAt.set(target.uuid)
+                                attackTarget.set(target)
+                                true
+                            }
+                            // roll the dice in other way
+                            coercedChance != 1f && world.random.nextFloat() < coercedChance -> {
+                                angryAt.set(target.uuid)
+                                attackTarget.set(target)
+                                true
+                            }
+                            // fallback to peaceful behavior in unattended cases
+                            else -> false
+                        }
                     }
-                    return@Trigger true
+                    return@Trigger shouldTrigger
                 }
             }
         }

common/src/main/kotlin/com/cobblemon/mod/common/api/battles/model/PokemonBattle.kt

@@ -239,6 +239,10 @@ open class PokemonBattle(
     }
 
     fun writeShowdownAction(vararg messages: String) {
+        if (messages.any { it.contains("\n") || it.contains("\r") }) {
+            LOGGER.warn("Refusing to forward Showdown action with an embedded line break for battle {}: {}", battleId, messages.joinToString(" | "))
+            return
+        }
         log(messages.joinToString("\n"))
         ShowdownService.service.send(battleId, messages.toList().toTypedArray())
     }

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

@@ -11,9 +11,6 @@ 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
 
 /**
@@ -24,19 +21,11 @@ import java.lang.reflect.Type
  * @author Hiroku
  * @since July 17th, 2022
  */
-interface RegistryLikeAdapter<B> : JsonDeserializer<RegistryLikeCondition<B>>, JsonSerializer<RegistryLikeCondition<B>> {
+interface RegistryLikeAdapter<B> : JsonDeserializer<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/molang/function/LivingEntityMoLangFunctions.kt

@@ -98,14 +98,14 @@ object LivingEntityMoLangFunctions : AbstractMoLangFunctionHolder<LivingEntity>(
             val targetEntity = params.get<MoValue>(0)
             val maxDistance = params.getDoubleOrNull(1)?.toFloat() ?: 2.0F
 
-            val entity =
+            val target =
                 if (targetEntity is ObjectValue<*> && targetEntity.obj is Entity) {
                     targetEntity.obj as Entity
                 } else {
                     return@isLookingAt DoubleValue.ZERO
                 }
 
-            DoubleValue(entity.isLookingAt(entity, maxDistance))
+            DoubleValue(entity.isLookingAt(target, maxDistance))
         }
         functions["is_living_entity"] = { DoubleValue.ONE }
         functions["is_flying"] = { DoubleValue(entity.isFallFlying) }

common/src/main/kotlin/com/cobblemon/mod/common/api/molang/function/PokemonMoLangFunctions.kt

@@ -212,7 +212,7 @@ object PokemonMoLangFunctions : AbstractMoLangFunctionHolder<Pokemon>() {
         // Lol. Lmao, even.
         // TO-DO: Subscribe to [PokemonSpecies.observable].
         functions["pre_evolution"] = { pokemon.species.preEvolution ?: DoubleValue.ZERO }
-        functions["nature"] = { StringValue(pokemon.nature.toString()) }
+        functions["nature"] = { StringValue(pokemon.nature.name.toString()) }
         functions["is_wild"] = { DoubleValue(pokemon.entity?.let { it.ownerUUID == null } == true) }
         functions["is_shiny"] = { DoubleValue(pokemon.shiny) }
         functions["is_in_party"] = { DoubleValue(pokemon.storeCoordinates.get()?.store is PartyStore) }

common/src/main/kotlin/com/cobblemon/mod/common/api/orientation/OrientationController.kt

@@ -29,7 +29,8 @@ open class OrientationController(val entity: LivingEntity) {
         val UP: Vector3f = Vector3f(0.0f, 1.0f, 0.0f)
         val LEFT: Vector3f = Vector3f(-1.0f, 0.0f, 0.0f)
         private const val TICK_DT = 1f / 20f // Minecraft server tick rate
-        private const val RENDER_SMOOTH_HALFLIFE = 0.1f // seconds to close ~half the gap
+        // Seconds for the render orientation to close half the gap to the real one. Raise for smoother but laggier visuals
+        private const val RENDER_SMOOTH_HALFLIFE = 0.15f
     }
 
     open var active: Boolean = false
@@ -101,7 +102,7 @@ open class OrientationController(val entity: LivingEntity) {
         // Use a "quat spring" to smoothly move the render orientation towards the goal orientation.
         // It takes into account the orientations angular velocities and should be much more resilient
         // to sharp changes in goal orientation or late/missed packets.
-        simpleSpringDamperQuat(renderSpring, targetQuat, 0.15f, TICK_DT)
+        simpleSpringDamperQuat(renderSpring, targetQuat, RENDER_SMOOTH_HALFLIFE, TICK_DT)
 
         val newRenderOrientation = Matrix3f()
         renderSpring.quat.get(newRenderOrientation)

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

@@ -10,9 +10,6 @@ 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
@@ -64,38 +61,6 @@ object Dexes : JsonDataRegistry<PokedexDef> {
         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/entry/DexEntries.kt

@@ -8,13 +8,20 @@
 
 package com.cobblemon.mod.common.api.pokedex.entry
 
+import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.CobblemonItems
 import com.cobblemon.mod.common.api.data.JsonDataRegistry
 import com.cobblemon.mod.common.api.molang.ExpressionLike
+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.DexEntrySyncPacket
+import com.cobblemon.mod.common.net.messages.client.data.DexEvolutionDisplaySyncPacket
+import com.cobblemon.mod.common.pokemon.FormData
 import com.cobblemon.mod.common.util.adapters.ExpressionLikeAdapter
 import com.cobblemon.mod.common.util.adapters.IdentifierAdapter
+import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
 import com.cobblemon.mod.common.util.cobblemonResource
+import com.cobblemon.mod.common.util.lang
 import com.google.gson.Gson
 import com.google.gson.GsonBuilder
 import com.google.gson.reflect.TypeToken
@@ -38,6 +45,8 @@ object DexEntries : JsonDataRegistry<PokedexEntry> {
 
     val entries = mutableMapOf<ResourceLocation, PokedexEntry>()
 
+    val evolutionDisplays = mutableListOf<DexEvolutionDisplay>()
+
     override fun reload(data: Map<ResourceLocation, PokedexEntry>) {
         data.forEach { _, entry ->
             entries[entry.id] = entry
@@ -50,6 +59,7 @@ object DexEntries : JsonDataRegistry<PokedexEntry> {
                 }
             }
         }
+        computeEvolutionDisplays()
         observable.emit(this)
     }
 
@@ -57,5 +67,58 @@ object DexEntries : JsonDataRegistry<PokedexEntry> {
 
     override fun sync(player: ServerPlayer) {
         DexEntrySyncPacket(entries.values).sendToPlayer(player)
+        DexEvolutionDisplaySyncPacket(evolutionDisplays).sendToPlayer(player)
     }
-}
+
+    fun computeEvolutionDisplays() {
+        evolutionDisplays.clear()
+        PokemonSpecies.species.forEach {
+            try {
+                evolutionDisplays.addAll(buildDisplays(it.standardForm) + it.forms.flatMap { form -> buildDisplays(form) })
+            } catch (e: Exception) {
+                Cobblemon.LOGGER.error("Failed to build dex evolution displays for ${it.resourceIdentifier}", e)
+            }
+        }
+    }
+
+    fun buildDisplays(form: FormData): List<DexEvolutionDisplay> {
+        val result = mutableListOf<DexEvolutionDisplay>()
+        (form.ownEvolutions ?: form.evolutions).forEach { evolution ->
+            val requirements = mutableListOf<DexEvolutionRequirementDisplay>()
+            getToolTipHeaderIcon(evolution)?.let { header ->
+                requirements.add(header)
+            }
+            evolution.requirements.mapNotNull { resolveRequirementData(it) }.forEach { requirement ->
+                requirements.add(requirement)
+            }
+
+            listOfNotNull(evolution.result, evolution.shedder).forEach resultLoop@{ resultProperties ->
+                val resultSpecies = resultProperties.species
+                    ?.let { PokemonSpecies.getByIdentifier(it.asIdentifierDefaultingNamespace()) }
+                    ?: return@resultLoop
+
+                // The result's own aspects win, otherwise carry the source form's aspects over
+                // like a real evolution does (Alola-Bias Pichu -> Alola-Bias Pikachu)
+                val resultForm = resultSpecies.getForm(resultProperties.aspects).takeIf { it != resultSpecies.standardForm }
+                    ?: resultSpecies.getForm(form.aspects.toSet() + resultProperties.aspects)
+                val toAspects = resultProperties.aspects + resultForm.aspects
+                val resultRequirements = if (resultProperties === evolution.shedder) {
+                    requirements + CobblemonDexEvolutionRequirementDisplay(CobblemonItems.POKE_BALL, lang("ui.pokedex.evolution.shedder.tooltip"))
+                } else {
+                    requirements
+                }
+
+                result.add(DexEvolutionDisplay(
+                    fromSpecies = form.species.resourceIdentifier,
+                    fromForm = form.name,
+                    fromAspects = form.aspects.toSet(),
+                    toSpecies = resultSpecies.resourceIdentifier,
+                    toForm = resultForm.name,
+                    toAspects = toAspects,
+                    requirements = resultRequirements,
+                ))
+            }
+        }
+        return result
+    }
+}

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

@@ -0,0 +1,466 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.pokedex.entry
+
+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.PokemonSpecies
+import com.cobblemon.mod.common.api.pokemon.evolution.Evolution
+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.types.ElementalTypes
+import com.cobblemon.mod.common.pokemon.evolution.variants.ItemInteractionEvolution
+import com.cobblemon.mod.common.pokemon.evolution.variants.TradeEvolution
+import com.cobblemon.mod.common.pokemon.requirements.*
+import com.cobblemon.mod.common.util.adapters.RegistryAccessResolver
+import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
+import com.cobblemon.mod.common.util.asTranslated
+import com.cobblemon.mod.common.util.lang
+import net.minecraft.core.registries.BuiltInRegistries
+import net.minecraft.core.registries.Registries
+import net.minecraft.network.chat.Component
+import net.minecraft.network.chat.MutableComponent
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.util.ExtraCodecs
+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
+import kotlin.jvm.optionals.getOrNull
+
+data class DexEvolutionDisplay(
+    val fromSpecies: ResourceLocation,
+    val fromForm: String,
+    val fromAspects: Set<String>,
+    val toSpecies: ResourceLocation,
+    val toForm: String,
+    val toAspects: Set<String>,
+    val requirements: List<DexEvolutionRequirementDisplay>,
+)
+
+interface DexEvolutionRequirementDisplay {
+    val icon: Item
+    val tooltip: MutableComponent
+}
+
+data class CobblemonDexEvolutionRequirementDisplay(
+    override val icon: Item,
+    override val tooltip: MutableComponent,
+) : DexEvolutionRequirementDisplay
+
+data class CobblemonBiomeDexEvolutionRequirementDisplay(
+    override val icon: Item,
+    override val tooltip: MutableComponent,
+    val condition: ExtraCodecs.TagOrElementLocation? = null,
+    val antiCondition: ExtraCodecs.TagOrElementLocation? = null,
+) : DexEvolutionRequirementDisplay
+
+fun getToolTipHeaderIcon(evolution: Evolution): DexEvolutionRequirementDisplay? {
+    when (evolution) {
+        is ItemInteractionEvolution -> return getToolTipHeaderIcon(evolution)
+        is TradeEvolution -> return getToolTipHeaderIcon(evolution)
+    }
+
+    return null
+}
+
+
+fun getToolTipHeaderIcon(itemInteractionEvolution: ItemInteractionEvolution): CobblemonDexEvolutionRequirementDisplay? {
+    val item = itemInteractionEvolution.requiredContext.items.orElse(null)?.firstOrNull()?.value() ?: return null
+    return CobblemonDexEvolutionRequirementDisplay(item, lang("ui.pokedex.evolution.item_interact.tooltip", item.description.plainCopy().green()))
+}
+
+fun getToolTipHeaderIcon(tradeEvolution: TradeEvolution): CobblemonDexEvolutionRequirementDisplay {
+    val species = tradeEvolution.requiredContext.species
+    val tooltip = if (species == null) {
+        lang("ui.pokedex.evolution.trade.tooltip.with_any_species")
+    } else {
+        PokemonSpecies.getByIdentifier(species.asIdentifierDefaultingNamespace())
+            ?.let { lang("ui.pokedex.evolution.trade.tooltip.with_species", it.translatedName.plainCopy().green()) }
+            ?: lang("ui.pokedex.evolution.trade.tooltip.with_any_species")
+    }
+    return CobblemonDexEvolutionRequirementDisplay(CobblemonItems.LINK_CABLE, tooltip)
+}
+
+fun resolveRequirementData(requirement: Requirement): DexEvolutionRequirementDisplay? {
+    val icon = requirement.pokedexIcon?.let {
+        RegistryAccessResolver.getAccess().registryOrThrow(Registries.ITEM).get(it)
+    }
+
+    val tooltip = requirement.pokedexTooltip?.let {
+        Component.translatable(it)
+    }
+
+    if (icon != null && tooltip != null) {
+        return CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
+    }
+
+    return buildRequirementData(requirement)
+}
+
+fun buildRequirementData(requirement: Requirement): DexEvolutionRequirementDisplay? {
+    when (requirement) {
+        is AdvancementRequirement -> return buildAdvancementRequirement(requirement)
+        is BattleCriticalHitsRequirement -> return buildBattleCriticalHitsRequirement(requirement)
+        is BiomeRequirement -> return buildBiomeRequirement(requirement)
+        is BlocksTraveledRequirement -> return buildBlocksTraveledRequirement(requirement)
+        is DamageTakenRequirement -> return buildDamageTakenRequirement(requirement)
+        is DefeatRequirement -> return buildDefeatRequirement(requirement)
+        is FriendshipRequirement -> return buildFriendshipRequirement(requirement)
+        is HeldItemRequirement -> return buildHeldItemRequirement(requirement)
+        is LevelRequirement -> return buildLevelRequirement(requirement)
+        is MoonPhaseRequirement -> return buildMoonPhaseRequirement(requirement)
+        is MoveSetRequirement -> return buildMoveSetRequirement(requirement)
+        is MoveTypeRequirement -> return buildMoveTypeRequirement(requirement)
+        is NegateRequirement -> return buildNegateRequirement(requirement)
+        is OwnerHoldsItemRequirement -> return buildOwnerHoldsItemRequirement(requirement)
+        is PartyMemberRequirement -> return buildPartyMemberRequirement(requirement)
+        is PokemonPropertiesRequirement -> return buildPokemonPropertiesRequirement(requirement)
+        is PropertyRangeRequirement -> return buildPropertyRangeRequirement(requirement)
+        is RecoilRequirement -> return buildRecoilRequirement(requirement)
+        is StatCompareRequirement -> return buildStatCompareRequirement(requirement)
+        is StatEqualRequirement -> return buildStatEqualRequirement(requirement)
+        is StructureRequirement -> return buildStructureRequirement(requirement)
+        is TimeRangeRequirement -> return buildTimeRangeRequirement(requirement)
+        is UseMoveRequirement -> return buildUseMoveRequirement(requirement)
+        is WeatherRequirement -> return buildWeatherRequirement(requirement)
+    }
+
+    return null
+}
+
+fun buildAdvancementRequirement(advancementRequirement: AdvancementRequirement): DexEvolutionRequirementDisplay {
+    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 CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
+}
+
+fun buildBattleCriticalHitsRequirement(battleCriticalHitsRequirement: BattleCriticalHitsRequirement): DexEvolutionRequirementDisplay {
+    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 CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
+}
+
+private fun tagDisplayName(registry: String, id: ResourceLocation): MutableComponent {
+    return Component.translatableWithFallback("tag.$registry.${id.namespace}.${id.path.replace('/', '.')}", prettifyPath(id.path))
+}
+
+private fun prettifyPath(path: String): String {
+    return path.substringAfterLast('/').removePrefix("is_").split('_').joinToString(" ") { part -> part.replaceFirstChar(Char::titlecase) }
+}
+
+fun buildNegateRequirement(negateRequirement: NegateRequirement): DexEvolutionRequirementDisplay? {
+    val inner = negateRequirement.inner
+    when (inner) {
+        is BiomeRequirement -> buildBiomeRequirement(inner, negated = true)?.let { return it }
+        is StructureRequirement -> buildStructureRequirement(inner, negated = true)?.let { return it }
+    }
+    val innerDisplay = resolveRequirementData(inner) ?: return null
+    return CobblemonDexEvolutionRequirementDisplay(innerDisplay.icon, lang("ui.pokedex.requirement.negate.tooltip", innerDisplay.tooltip))
+}
+
+fun buildBiomeRequirement(biomeRequirement: BiomeRequirement, negated: Boolean = false): DexEvolutionRequirementDisplay? {
+    // Negating "in X" is "not in X"; negating both a condition and an anticondition isn't expressible as one line
+    if (negated && biomeRequirement.biomeCondition != null && biomeRequirement.biomeAnticondition != null) return null
+    val condition = if (negated) biomeRequirement.biomeAnticondition else biomeRequirement.biomeCondition
+    val antiCondition = if (negated) biomeRequirement.biomeCondition else biomeRequirement.biomeAnticondition
+    if (condition == null && antiCondition == null) {
+        return null
+    }
+
+    val icon = Items.COMPASS
+    val displayName: (RegistryLikeCondition<Biome>) -> MutableComponent = {
+        when (it) {
+            is RegistryLikeTagCondition -> tagDisplayName("worldgen.biome", it.tag.location())
+            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())
+    }
+
+    var conditionConverted: ExtraCodecs.TagOrElementLocation? = null
+    if (condition != null) {
+        val conditionIdentifier = if (condition is RegistryLikeIdentifierCondition) condition.identifier else (condition as RegistryLikeTagCondition).tag.location
+        conditionConverted = ExtraCodecs.TagOrElementLocation(conditionIdentifier, condition is RegistryLikeTagCondition)
+    }
+
+    var antiConditionConverted: ExtraCodecs.TagOrElementLocation? = null
+    if (antiCondition != null) {
+        val conditionIdentifier = if (antiCondition is RegistryLikeIdentifierCondition) antiCondition.identifier else (antiCondition as RegistryLikeTagCondition).tag.location
+        antiConditionConverted = ExtraCodecs.TagOrElementLocation(conditionIdentifier, antiCondition is RegistryLikeTagCondition)
+    }
+
+    return CobblemonBiomeDexEvolutionRequirementDisplay(icon, tooltip, conditionConverted, antiConditionConverted)
+}
+
+fun buildBlocksTraveledRequirement(blocksTraveledRequirement: BlocksTraveledRequirement): DexEvolutionRequirementDisplay {
+    val icon = Items.LEATHER_BOOTS
+    val blocksComponent = Component.literal(blocksTraveledRequirement.amount.toString()).green()
+    val tooltip = lang("ui.pokedex.requirement.blocks_traveled.tooltip", blocksComponent)
+
+    return CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
+}
+
+fun buildDamageTakenRequirement(damageTakenRequirement: DamageTakenRequirement): DexEvolutionRequirementDisplay {
+    val icon = CobblemonItems.PUNCHING_GLOVE
+    val blocksComponent = Component.literal(damageTakenRequirement.amount.toString()).green()
+    val tooltip = lang("ui.pokedex.requirement.damage_taken.tooltip", blocksComponent)
+
+    return CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
+}
+
+fun buildDefeatRequirement(defeatRequirement: DefeatRequirement): DexEvolutionRequirementDisplay? {
+    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 CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
+}
+
+fun buildFriendshipRequirement(friendshipRequirement: FriendshipRequirement): DexEvolutionRequirementDisplay {
+    val icon = CobblemonItems.SOOTHE_BELL
+    val friendshipAmountComponent = Component.literal(friendshipRequirement.amount.toString()).green()
+    val tooltip = lang("ui.pokedex.requirement.friendship.tooltip", friendshipAmountComponent)
+
+    return CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
+}
+
+fun buildHeldItemRequirement(heldItemRequirement: HeldItemRequirement): DexEvolutionRequirementDisplay? {
+    val items = heldItemRequirement.itemCondition.items.getOrNull() ?: return null
+    val item = items.firstOrNull()?.value() ?: return null
+    val itemComponent = items.unwrapKey().map { tag ->
+        val id = tag.location()
+        val fallback = id.path.substringAfterLast('/').split('_').joinToString(" ") { part -> part.replaceFirstChar(Char::titlecase) }
+        Component.translatableWithFallback("tag.item.${id.namespace}.${id.path.replace('/', '.')}", fallback)
+    }.orElseGet { item.description.plainCopy() }
+    val tooltip = lang("ui.pokedex.requirement.held_item.tooltip", itemComponent.green())
+
+    return CobblemonDexEvolutionRequirementDisplay(item, tooltip)
+}
+
+fun buildLevelRequirement(levelRequirement: LevelRequirement): DexEvolutionRequirementDisplay {
+    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 CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
+}
+
+fun buildMoonPhaseRequirement(moonPhaseRequirement: MoonPhaseRequirement): DexEvolutionRequirementDisplay {
+    val icon = Items.CLOCK
+    val moonPhaseComponent = moonPhaseRequirement.moonPhase.displayName().plainCopy().green()
+    val tooltip = lang("ui.pokedex.requirement.moon_phase.tooltip", moonPhaseComponent)
+
+    return CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
+}
+
+fun buildMoveSetRequirement(moveSetRequirement: MoveSetRequirement): DexEvolutionRequirementDisplay {
+    val icon = CobblemonItems.TECHNICAL_MACHINE
+    val tooltip = lang("ui.pokedex.requirement.has_move.tooltip", moveSetRequirement.move.displayName.plainCopy().green())
+
+    return CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
+}
+
+fun buildMoveTypeRequirement(moveTypeRequirement: MoveTypeRequirement): DexEvolutionRequirementDisplay {
+    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.plainCopy().green())
+
+    return CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
+}
+
+fun buildOwnerHoldsItemRequirement(ownerHoldsItemRequirement: OwnerHoldsItemRequirement): DexEvolutionRequirementDisplay? {
+    val item = ownerHoldsItemRequirement.itemCondition.items.orElse(null)?.firstOrNull()?.value() ?: return null
+    val tooltip = lang("ui.pokedex.requirement.owner_held_item.tooltip", item.description.plainCopy().green())
+
+    return CobblemonDexEvolutionRequirementDisplay(item, tooltip)
+}
+
+fun buildPartyMemberRequirement(partyMemberRequirement: PartyMemberRequirement): DexEvolutionRequirementDisplay? {
+    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 CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
+}
+
+fun buildPokemonPropertiesRequirement(pokemonPropertiesRequirement: PokemonPropertiesRequirement): DexEvolutionRequirementDisplay? {
+    val description = describePokemonProperties(pokemonPropertiesRequirement.target) ?: return null
+    val icon = Items.NAME_TAG
+    val tooltip = lang("ui.pokedex.requirement.pokemon_properties.tooltip", description)
+
+    return CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
+}
+
+fun buildPropertyRangeRequirement(propertyRangeRequirement: PropertyRangeRequirement): DexEvolutionRequirementDisplay? {
+    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 CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
+}
+
+fun buildRecoilRequirement(recoilRequirement: RecoilRequirement): DexEvolutionRequirementDisplay {
+    val icon = CobblemonItems.LIFE_ORB
+    val recoilComponent = Component.literal(recoilRequirement.amount.toString()).green()
+    val tooltip = lang("ui.pokedex.requirement.recoil.tooltip", recoilComponent)
+
+    return CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
+}
+
+fun buildStatCompareRequirement(statCompareRequirement: StatCompareRequirement): DexEvolutionRequirementDisplay {
+    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 CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
+}
+
+fun buildStatEqualRequirement(statEqualRequirement: StatEqualRequirement): DexEvolutionRequirementDisplay {
+    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 CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
+}
+
+fun buildStructureRequirement(structureRequirement: StructureRequirement, negated: Boolean = false): DexEvolutionRequirementDisplay? {
+    if (negated && structureRequirement.structureCondition != null && structureRequirement.structureAnticondition != null) return null
+    val condition = if (negated) structureRequirement.structureAnticondition else structureRequirement.structureCondition
+    val anticondition = if (negated) structureRequirement.structureCondition else structureRequirement.structureAnticondition
+    if (condition == null && anticondition == null) {
+        return null
+    }
+
+    val icon = Items.FILLED_MAP
+    val displayName: (RegistryLikeCondition<Structure>) -> MutableComponent = {
+        when (it) {
+            is RegistryLikeTagCondition -> tagDisplayName("worldgen.structure", it.tag.location())
+            is RegistryLikeIdentifierCondition -> Component.literal(prettifyPath(it.identifier.path))
+            else -> Component.literal(it.toString())
+        }
+    }
+    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 CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
+}
+
+fun buildTimeRangeRequirement(timeRangeRequirement: TimeRangeRequirement): DexEvolutionRequirementDisplay? {
+    val icon = Items.CLOCK
+    val timeRangeComponent = timeRangeRequirement.range.displayName()?.plainCopy() ?: return null
+    val tooltip = lang("ui.pokedex.requirement.time_range.tooltip", timeRangeComponent.green())
+
+    return CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
+}
+
+fun buildUseMoveRequirement(useMoveRequirement: UseMoveRequirement): DexEvolutionRequirementDisplay {
+    val icon = CobblemonItems.CHOICE_BAND
+    val tooltip = lang("ui.pokedex.requirement.use_move.tooltip", useMoveRequirement.move.displayName.plainCopy().green())
+
+    return CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
+}
+
+fun buildWeatherRequirement(weatherRequirement: WeatherRequirement): DexEvolutionRequirementDisplay {
+    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 CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
+}

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

@@ -6,7 +6,7 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-package com.cobblemon.mod.common.client.gui.pokedex.widgets.evolutiontree
+package com.cobblemon.mod.common.api.pokedex.entry
 
 import com.cobblemon.mod.common.api.pokemon.Natures
 import com.cobblemon.mod.common.api.pokemon.PokemonProperties
@@ -21,7 +21,6 @@ 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
@@ -29,14 +28,14 @@ import net.minecraft.network.chat.Component
 import net.minecraft.network.chat.MutableComponent
 import net.minecraft.world.item.Items
 
-internal fun describePokemonProperties(properties: PokemonProperties): MutableComponent? {
+fun describePokemonProperties(properties: PokemonProperties): MutableComponent? {
     if (hasUndescribedProperty(properties)) {
         return null
     }
 
     val descriptors = mutableListOf<MutableComponent>()
 
-    properties.species?.let { PokemonSpecies.getByIdentifier(cobblemonResource(it)) }?.let {
+    properties.species?.let { PokemonSpecies.getByIdentifier(it.asIdentifierDefaultingNamespace()) }?.let {
         descriptors.add(it.translatedName.plainCopy().green())
     }
     properties.gender?.let {
@@ -136,7 +135,7 @@ private fun describeStringSpeciesFeature(property: StringSpeciesFeature): Mutabl
         return null
     }
 
-    val value = PokemonSpecies.getByIdentifier(cobblemonResource(property.value))?.translatedName?.plainCopy()
+    val value = PokemonSpecies.getByIdentifier(property.value.asIdentifierDefaultingNamespace())?.translatedName?.plainCopy()
         ?: Component.literal(property.value)
 
     return lang(key, value.green())

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

@@ -26,7 +26,6 @@ import com.cobblemon.mod.common.api.moves.MoveTemplate
 import com.cobblemon.mod.common.api.moves.MovesetBuilder
 import com.cobblemon.mod.common.api.moves.adapters.MoveTemplateAdapter
 import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
-import com.cobblemon.mod.common.api.pokemon.PokemonSpecies.getByIdentifier
 import com.cobblemon.mod.common.api.pokemon.effect.ShoulderEffect
 import com.cobblemon.mod.common.api.pokemon.effect.adapter.ShoulderEffectAdapter
 import com.cobblemon.mod.common.api.pokemon.egg.EggGroup
@@ -44,9 +43,6 @@ 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
@@ -246,18 +242,6 @@ 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,8 +25,6 @@ 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/riding/behaviour/RideSteerInput.kt

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.riding.behaviour
+
+import com.cobblemon.mod.common.api.orientation.OrientationController
+import net.minecraft.util.SmoothDouble
+import net.minecraft.world.phys.Vec3
+
+/**
+ * One frame of steering for a rolling ride on the client that's driving it.
+ * The mouse values are the share the ride took in consumeLook, already through the riding
+ * sensitivity, invert and swap options and still in mouse units.
+ */
+class RideSteerInput(
+    /** The ride's own orientation controller */
+    val controller: OrientationController,
+    val mouseYaw: Double,
+    val mousePitch: Double,
+    val mouseXSmoother: SmoothDouble,
+    val mouseYSmoother: SmoothDouble,
+    /** Vanilla's mouse sensitivity curve, cubed */
+    val sensitivity: Double,
+    /** Seconds since the last frame */
+    val deltaTime: Double,
+    private val yawSmoother: SmoothDouble,
+    private val pitchSmoother: SmoothDouble,
+    private val rollSmoother: SmoothDouble
+) {
+    companion object {
+        // Share of each push the smoothers get. Lower makes smoothed turning softer
+        const val SMOOTHED_SHARE = 0.5
+    }
+
+    /** Turns the ride by local yaw, pitch and roll degrees right away. */
+    fun rotate(rotation: Vec3) {
+        controller.rotate(rotation.x.toFloat(), rotation.y.toFloat(), rotation.z.toFloat())
+    }
+
+    /** Turns the ride by local yaw, pitch and roll degrees eased through vanilla's mouse smoother so it spreads over a few frames. */
+    fun rotateSmoothed(rotation: Vec3) {
+        controller.rotate(
+            yawSmoother.getNewDeltaValue(rotation.x * SMOOTHED_SHARE, deltaTime).toFloat(),
+            pitchSmoother.getNewDeltaValue(rotation.y * SMOOTHED_SHARE, deltaTime).toFloat(),
+            rollSmoother.getNewDeltaValue(rotation.z * SMOOTHED_SHARE, deltaTime).toFloat()
+        )
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/RidingBehaviour.kt

@@ -12,15 +12,20 @@ import com.bedrockk.molang.runtime.value.DoubleValue
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.api.molang.ObjectValue
 import com.cobblemon.mod.common.api.riding.RidingStyle
+import com.cobblemon.mod.common.api.riding.camera.RideCameraContext
+import com.cobblemon.mod.common.api.riding.camera.RideLookInput
+import com.cobblemon.mod.common.api.riding.camera.RideLookTake
+import com.cobblemon.mod.common.api.riding.camera.RideLookSettings
 import com.cobblemon.mod.common.api.riding.sound.RideSoundSettingsList
+import com.cobblemon.mod.common.api.riding.util.RideFrame
 import com.cobblemon.mod.common.entity.PoseType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import net.minecraft.resources.ResourceLocation
-import net.minecraft.util.SmoothDouble
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.player.Player
 import net.minecraft.world.phys.Vec2
 import net.minecraft.world.phys.Vec3
+import org.joml.Quaternionf
 
 /**
  * Represents the behaviour of a Pokemon when being ridden.
@@ -41,30 +46,39 @@ interface RidingBehaviour<Settings : RidingBehaviourSettings, State : RidingBeha
 
     fun pose(settings: Settings, state: State, vehicle: PokemonEntity): PoseType
 
+    /** Ride speed for vanilla's setSpeed. Only reads state, anything that changes state goes in [driverTick]. */
     fun speed(settings: Settings, state: State, vehicle: PokemonEntity, driver: Player): Float
 
+    /**
+     * Runs once a tick only on the client that's steering, after [tick] and the ride's rotation.
+     * Whatever it works out reaches the server and other players through the riding state sync.
+     */
+    fun driverTick(settings: Settings, state: State, vehicle: PokemonEntity, driver: Player) {}
+
     fun clampPassengerRotation(settings: Settings, state: State, vehicle: PokemonEntity, driver: LivingEntity) {}
 
     fun updatePassengerRotation(settings: Settings, state: State, vehicle: PokemonEntity, driver: LivingEntity) {}
 
     fun rotation(settings: Settings, state: State, vehicle: PokemonEntity, driver: LivingEntity): Vec2
 
+    /**
+     * Ride velocity for this tick in world space blocks per tick.
+     * [RideFrame.yawToWorld] turns a velocity worked out along the ride's yaw into world space.
+     */
     fun velocity(settings: Settings, state: State, vehicle: PokemonEntity, driver: Player, input: Vec3): Vec3
 
-    fun angRollVel(settings: Settings, state: State, vehicle: PokemonEntity, driver: Player, deltaTime: Double): Vec3
+    /**
+     * True to have the driver's client call [velocity] a second time each tick inside travel.
+     * Vanilla already asks for it once in getRiddenInput and travel always asked again, so every ride's
+     * numbers are tuned around running twice a tick. Return false once a ride is retuned for a single run.
+     */
+    fun velocityRunsTwicePerTick(settings: Settings, state: State, vehicle: PokemonEntity): Boolean = true
 
-    fun rotationOnMouseXY(
-        settings: Settings,
-        state: State,
-        vehicle: PokemonEntity,
-        driver: Player,
-        mouseY: Double,
-        mouseX: Double,
-        mouseYSmoother: SmoothDouble,
-        mouseXSmoother: SmoothDouble,
-        sensitivity: Double,
-        deltaTime: Double
-    ): Vec3
+    /**
+     * Turns the ride for one frame while it rolls. Runs every frame on the client that's driving with the mouse
+     * share the ride took in [consumeLook]. Rotate through [RideSteerInput.controller] or its helpers.
+     */
+    fun steer(settings: Settings, state: State, vehicle: PokemonEntity, driver: Player, input: RideSteerInput) {}
 
     fun canJump(settings: Settings, state: State, vehicle: PokemonEntity, driver: Player): Boolean
 
@@ -76,8 +90,6 @@ interface RidingBehaviour<Settings : RidingBehaviourSettings, State : RidingBeha
 
     fun rideFovMultiplier(settings: Settings, state: State, vehicle: PokemonEntity, driver: Player): Float
 
-    fun useAngVelSmoothing(settings: Settings, state: State, vehicle: PokemonEntity): Boolean
-
     fun inertia(settings: Settings, state: State, vehicle: PokemonEntity): Double
 
     fun shouldRoll(settings: Settings, state: State, vehicle: PokemonEntity): Boolean
@@ -111,10 +123,22 @@ interface RidingBehaviour<Settings : RidingBehaviourSettings, State : RidingBeha
     fun applyRenderRotation(settings: Settings, state: State, vehicle: PokemonEntity, partialTicks: Float) {}
 
     /**
-     * Determines if the pair of mouse inputs Pair(mouseX, mouseY) get used to modify the driverRotations or the vehicle rotations themselves.
-     * Driver rotations are the rotations used by passengers or a driver that is freelooking. This does not override the freelook button.
+     * How much of this frame's mouse look the ride takes to steer with. What it takes goes through
+     * [steer] and the rest moves the rider's look. Only asked for the driver and never while freelooking.
      */
-    fun mouseModifiesDriverRotation(settings: Settings, state: State, vehicle: PokemonEntity): Pair<Boolean, Boolean> = Pair(false, false)
+    fun consumeLook(settings: Settings, state: State, vehicle: PokemonEntity, input: RideLookInput): RideLookTake = RideLookTake.all(input)
+
+    /**
+     * Rotation the rider's camera hangs off while the ride rolls. Called every frame on the client
+     * and the rider's look sits on top of it. The player's disableRoll setting still applies after this.
+     */
+    fun cameraBase(settings: Settings, state: State, vehicle: PokemonEntity, context: RideCameraContext): Quaternionf = context.defaultBase()
+
+    /** Degrees to roll the first person hands and held items */
+    fun firstPersonHandRoll(settings: Settings, state: State, vehicle: PokemonEntity, context: RideCameraContext): Float = 0f
+
+    /** Look limits and carry for riders while the ride rolls. */
+    fun lookSettings(settings: Settings, state: State, vehicle: PokemonEntity): RideLookSettings = RideLookSettings.DEFAULT
 
     /**
      * Used in MoLang functions for querying states for animations or other magical MoLang effects.

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/RidingBehaviours.kt

@@ -10,6 +10,7 @@ package com.cobblemon.mod.common.api.riding.behaviour
 
 import com.cobblemon.mod.common.api.riding.behaviour.types.air.*
 import com.cobblemon.mod.common.api.riding.behaviour.types.composite.CompositeBehaviour
+import com.cobblemon.mod.common.api.riding.behaviour.types.land.ClimbBehaviour
 import com.cobblemon.mod.common.api.riding.behaviour.types.land.HorseBehaviour
 import com.cobblemon.mod.common.api.riding.behaviour.types.land.VehicleBehaviour
 import com.cobblemon.mod.common.api.riding.behaviour.types.land.MinekartBehaviour
@@ -35,7 +36,9 @@ object RidingBehaviours {
         register(MinekartBehaviour.KEY, MinekartBehaviour())
         register(HoverBehaviour.KEY, HoverBehaviour())
         register(RocketBehaviour.KEY, RocketBehaviour())
+        register(BoardBehaviour.KEY, BoardBehaviour())
         register(SubmarineBehaviour.KEY, SubmarineBehaviour())
+        register(ClimbBehaviour.KEY, ClimbBehaviour())
         register(CompositeBehaviour.KEY, CompositeBehaviour())
     }
 

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/types/air/BirdBehaviour.kt

@@ -15,8 +15,13 @@ import com.cobblemon.mod.common.CobblemonRideSettings
 import com.cobblemon.mod.common.OrientationControllable
 import com.cobblemon.mod.common.api.molang.ObjectValue
 import com.cobblemon.mod.common.api.orientation.OrientationController
+import com.cobblemon.mod.common.api.orientation.OrientationController.Companion.FORWARDS
+import com.cobblemon.mod.common.api.orientation.OrientationController.Companion.UP
 import com.cobblemon.mod.common.api.riding.RidingStyle
 import com.cobblemon.mod.common.api.riding.behaviour.*
+import com.cobblemon.mod.common.api.riding.camera.RideCameraContext
+import com.cobblemon.mod.common.api.riding.camera.RideLookInput
+import com.cobblemon.mod.common.api.riding.camera.RideLookTake
 import com.cobblemon.mod.common.api.riding.posing.PoseOption
 import com.cobblemon.mod.common.api.riding.posing.PoseProvider
 import com.cobblemon.mod.common.api.riding.sound.RideSoundSettingsList
@@ -24,7 +29,9 @@ import com.cobblemon.mod.common.api.riding.stats.RidingStat
 import com.cobblemon.mod.common.entity.PoseType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.*
+import com.cobblemon.mod.common.util.math.FloatSpring
 import com.cobblemon.mod.common.util.math.geometry.toRadians
+import com.cobblemon.mod.common.util.math.simpleSpringDamper
 import net.minecraft.network.FriendlyByteBuf
 import net.minecraft.network.RegistryFriendlyByteBuf
 import net.minecraft.resources.ResourceLocation
@@ -34,6 +41,8 @@ import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.player.Player
 import net.minecraft.world.phys.Vec2
 import net.minecraft.world.phys.Vec3
+import org.joml.Matrix3f
+import org.joml.Quaternionf
 import org.joml.Vector3f
 import kotlin.math.*
 
@@ -42,6 +51,28 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
         val KEY = cobblemonResource("air/bird")
 
         private const val FLY_POSE_SPEED = 0.1
+        // At or below this the bird hovers instead of flying
+        private const val HOVER_SPEED = 0.1
+        // Within this many degrees of straight up or down wings level means nothing so the camera holds its roll
+        private const val VERTICAL_DEADZONE_DEGREES = 15f
+        private val MIN_LEVEL_UP_LENGTH_SQ = sin(VERTICAL_DEADZONE_DEGREES.toRadians()).pow(2)
+        // Below this speed the bird is too slow to bank so its wings always level out
+        private const val NO_BANK_SPEED = 0.2
+        // Degrees before the max roll where rolling further starts easing off. Raise for a softer stop
+        private const val ROLL_CAP_BAND_DEGREES = 20f
+        // Degrees past the turn roll limit over which mouse pitch hands over from world up and down to the bird's own pitch
+        private const val PITCH_BLEND_BAND_DEGREES = 15f
+        // Pitch where mouse pitch starts handing back to the bird's own pitch. By straight up or down it's all the bird's
+        // own so a loop carries on over the top instead of world up pulling it back
+        private const val WORLD_PITCH_FADE_START = 60f
+        // Fastest the wings level out by themselves in degrees per second
+        private const val MAX_ROLL_SETTLE_RATE = 45f
+        // Within this many degrees of level the settle rate eases off so it lands on level instead of overshooting
+        private const val ROLL_SETTLE_ARRIVAL_DEGREES = 35f
+        // How fast the settle rate can change in degrees per second squared. Same as the old per frame cap at 60 fps
+        private const val ROLL_SETTLE_ACCEL = 67.5f
+        // Keeps the turn roll limit from dividing by zero
+        private const val MIN_TURN_ROLL_LIMIT = 1f
         private const val GLIDE_ENTRY_SPEED = 0.19
         private const val GLIDE_EXIT_SPEED = 0.13
     }
@@ -84,25 +115,17 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
     ) {
         if(vehicle.level().isClientSide) {
             tickStamina(settings, state, vehicle, driver)
-            checkUpsideDown(state, vehicle, driver)
+            checkStaminaDive(state)
         }
     }
 
-    private fun checkUpsideDown(
-        state: BirdState,
-        vehicle: PokemonEntity,
-        driver: Player,
-    ) {
-        // Also checks stamina
-        val controller = (vehicle as OrientationControllable).orientationController
-        if (cos(controller.roll.toRadians()) < 0.0) {
-            val upsideDownRate = 1.0 / (2.0 * 20.0) // 2 seconds to max out upsideDown force
-            state.currUpsideDownForce.set( min(1.0, state.currUpsideDownForce.get() + upsideDownRate * abs(cos(controller.roll.toRadians()))))
-        } else if (state.stamina.get() == 0.0f) { // checks stamina depletion and forces dive if depleted
-            val upsideDownRate = 1.0 / (2.0 * 20.0) // 1 seconds to max out
-            state.currUpsideDownForce.set( min(1.0, state.currUpsideDownForce.get() + upsideDownRate))
-        } else { // Its right side up or has stamina so reset it
-            state.currUpsideDownForce.set(0.0)
+    // Out of stamina the bird can't hold itself up so it builds up a dive
+    private fun checkStaminaDive(state: BirdState) {
+        if (state.stamina.get() == 0.0f) {
+            val diveRate = 1.0 / (2.0 * 20.0) // 2 seconds to max out
+            state.staminaDiveForce.set(min(1.0, state.staminaDiveForce.get() + diveRate))
+        } else {
+            state.staminaDiveForce.set(0.0)
         }
     }
 
@@ -161,8 +184,8 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
         //Perform ride velocity update
         calculateRideSpaceVel(settings, state, vehicle, driver)
 
-        // The downward force used to encourage players to stop flying upside down.
-        val extraDownwardForce = state.currUpsideDownForce.get().pow(2) * -0.3 // 6 blocks a second downward
+        // Pulls the bird down once it's out of stamina
+        val extraDownwardForce = state.staminaDiveForce.get().pow(2) * -0.3 // 6 blocks a second downward
 
         // Convert the local velocity vector into a world vector
         val localVelVec = Vector3f(
@@ -170,8 +193,7 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
             (state.rideVelocity.get().y).toFloat(),
             state.rideVelocity.get().z.toFloat() * -1.0f // Flip the z axis to make this left handed
         )
-        // Unrotate preemptively as this vector gets rotatee later down the line in MC logic.
-        var worldVelVec = localVelVec.mul(controller.orientation).toVec3d().yRot(vehicle.yRot.toRadians())
+        var worldVelVec = localVelVec.mul(controller.orientation).toVec3d()
         worldVelVec =  worldVelVec.add(0.0, extraDownwardForce, 0.0) // Add the stamina depletion force to bring the ride down.
 
         return worldVelVec
@@ -282,19 +304,23 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
         state.rideVelocity.set(newVelocity)
     }
 
-    override fun angRollVel(
+    private fun rotateOverTime(
         settings: BirdSettings,
         state: BirdState,
         vehicle: PokemonEntity,
         driver: Player,
         deltaTime: Double
-    ): Vec3 {
-        if (vehicle !is OrientationControllable) return Vec3.ZERO
+    ) {
+        if (vehicle !is OrientationControllable) return
         val controller = (vehicle as OrientationControllable).orientationController
 
         val handling = vehicle.runtime.resolveDouble(settings.handlingExpr ?: globalBird.handlingExpr!!)
 
-        val yawDeltaDeg =  deltaTime * handling * sin(Math.toRadians(controller.roll.toDouble()))
+        // Turn rate tops out at the turn roll limit. Banking further is for show and doesn't turn any harder
+        val turnRollLimit = frameTuning(settings, state, vehicle).turnRollLimit.coerceIn(MIN_TURN_ROLL_LIMIT, 90f)
+        val bankFromLevel = if (abs(controller.roll) > 90f) 180f - abs(controller.roll) else abs(controller.roll)
+        val turnShare = sin(min(bankFromLevel, turnRollLimit).toRadians()) / sin(turnRollLimit.toRadians()) * controller.roll.sign
+        val yawDeltaDeg =  deltaTime * handling * turnShare
         val trueYawDelt = yawDeltaDeg * abs(cos(Math.toRadians(controller.pitch.toDouble()))).coerceIn(-1.0, 1.0)
 
         // Dampen yaw when upside down
@@ -309,8 +335,6 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
         controller.applyGlobalPitch(pCorr)
         controller.rotateRoll(rCorr)
 
-        //yaw, pitch, roll
-        return Vec3(0.0, 0.0, 0.0)
     }
 
     private fun correctOrientation(
@@ -320,45 +344,28 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
         controller: OrientationController,
         deltaTime: Double
     ) {
-        // Calculate correcting roll force.
-        val rollCorrectionTimer = vehicle.runtime.resolveDouble(settings.timeToRollCorrect ?: globalBird.timeToRollCorrect!!)
-        // If the ride is moving then have the correction rate be an equal proportion of:
-        // - how rolled are you
-        // - how long has it been since last mouse input (higher is stronger correction)
-        // Also the correction is proportional as a whole to how NOT pitched are you so you don't spin endlessly when looking up or down
-        val howRolledAmI =  sqrt(abs((cos(controller.roll.toRadians()) - 1.0f) * 0.5f)) // sqrt so it trends towards one pretty quickly
-        val maxRollCorrectionRate =
-            if (state.rideVelocity.get().length() < 0.2) 45.0f
-            else 45.0f * cos(controller.pitch.toRadians()).pow(2) * (
-                         howRolledAmI*1.0f +
-                         (state.noInputTimeRoll.get() - rollCorrectionTimer).coerceIn(0.0, 1.0).pow(2).toFloat()*0.5f
-                    )
-        val maxRollForce = maxRollCorrectionRate / 40.0f
-        val rollArrivalDeg = 35.0f
-        val desiredRoll = 0.0f
-
-        // Calculate the signed error (how far and in what direction)
-        val rollError = Mth.wrapDegrees(desiredRoll.angleDifference(controller.roll))
-        // Use the absolute error to     calculate the magnitude of the influence
-        val influenceMagnitude = (min(rollArrivalDeg, abs(rollError)) / rollArrivalDeg)
-        val desiredRollForce = maxRollCorrectionRate * influenceMagnitude * -rollError.sign
-        var steeredRollForce = desiredRollForce - state.currRollCorrectionForce.get()
-        // Ensure the 'steering' correction force doesn't exceed our maxForce
-        if (abs(steeredRollForce) > maxRollForce) {
-            steeredRollForce = steeredRollForce.sign * maxRollForce
+        // Wings only level out by themselves when the rider has let go and they're nearly level already,
+        // or when the bird's too slow to bank at all. A bank the rider holds stays where they put it
+        val tuning = frameTuning(settings, state, vehicle)
+        val idle = state.noInputTimeRoll.get() >= tuning.rollSettleDelay
+        val settling = state.rideVelocity.get().length() < NO_BANK_SPEED || (idle && abs(controller.roll) < tuning.rollSettleAngle)
+        val rollError = Mth.wrapDegrees(0.0f.angleDifference(controller.roll))
+        val desiredRollRate = if (settling) {
+            MAX_ROLL_SETTLE_RATE * (min(ROLL_SETTLE_ARRIVAL_DEGREES, abs(rollError)) / ROLL_SETTLE_ARRIVAL_DEGREES) * -rollError.sign
+        } else {
+            0f
         }
-        // Apply the 'steered' force (its really not a steering force I need a better name)
-        state.currRollCorrectionForce.set(
-            state.currRollCorrectionForce.get() + steeredRollForce
-        )
+        val maxRateChange = ROLL_SETTLE_ACCEL * deltaTime
+        val currentRollRate = state.currRollCorrectionForce.get()
+        state.currRollCorrectionForce.set(currentRollRate + (desiredRollRate - currentRollRate).coerceIn(-maxRateChange, maxRateChange))
 
         //Calculate correcting pitch force.
-        val maxPitchCorrectionRate = if (state.currUpsideDownForce.get() != 0.0) 15.0f * state.currUpsideDownForce.get().toFloat() else 30.0f
+        val maxPitchCorrectionRate = if (state.staminaDiveForce.get() != 0.0) 15.0f * state.staminaDiveForce.get().toFloat() else 30.0f
         val maxPitchForce = maxPitchCorrectionRate / 40.0f
         val pitchArrivalDeg = 35.0f
-        val desiredPitch = if (state.currUpsideDownForce.get() != 0.0) 90.0f else 0.0f
+        val desiredPitch = if (state.staminaDiveForce.get() != 0.0) 90.0f else 0.0f
 
-        if((state.rideVelocity.get().length() < 0.1) || state.currUpsideDownForce.get() != 0.0) {
+        if((state.rideVelocity.get().length() < 0.1) || state.staminaDiveForce.get() != 0.0) {
             val pitchErrror = Mth.wrapDegrees(desiredPitch.angleDifference(controller.pitch))
             val arrivalInfluence = (min(pitchArrivalDeg,abs(pitchErrror)) / pitchArrivalDeg)
             val desiredPitchForce = maxPitchCorrectionRate * arrivalInfluence * -pitchErrror.sign
@@ -381,7 +388,18 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
         }
     }
 
-    override fun rotationOnMouseXY(
+    override fun steer(
+        settings: BirdSettings,
+        state: BirdState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        input: RideSteerInput
+    ) {
+        input.rotate(mouseRotation(settings, state, vehicle, driver, input.mousePitch, input.mouseYaw, input.mouseYSmoother, input.mouseXSmoother, input.sensitivity, input.deltaTime))
+        rotateOverTime(settings, state, vehicle, driver, input.deltaTime)
+    }
+
+    private fun mouseRotation(
         settings: BirdSettings,
         state: BirdState,
         vehicle: PokemonEntity,
@@ -394,15 +412,10 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
         deltaTime: Double
     ): Vec3 {
         if (driver !is OrientationControllable) return Vec3.ZERO
-        val controller = (driver as OrientationControllable).orientationController
-        // Begin the roll correction time counter if not enough mouse input
-        // is detected
-        if (mouseX < 1 && abs(mouseY) < 1) {
+        // Time since the rider last moved the mouse, wings only settle once it passes the settle delay
+        if (abs(mouseX) < 1 && abs(mouseY) < 1) {
             state.noInputTimeRoll.set(state.noInputTimeRoll.get() + deltaTime)
-        } else if (cos(controller.roll.toRadians()) < 0.1) {
-            state.noInputTimeRoll.set(state.noInputTimeRoll.get() + deltaTime * 0.5)
-        }
-        else {
+        } else {
             state.noInputTimeRoll.set(0.0)
         }
 
@@ -443,46 +456,42 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
 
         val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr ?: globalBird.speedExpr!!) / 20.0
         val mouseInputMult = vehicle.runtime.resolveDouble(settings.mouseInputMult ?: globalBird.mouseInputMult!!)
-        // Applied to mouseX to prevent turning upside down when trying to roll hard.
-        val rollDegreeDebuff = if(mouseX.sign.toFloat() == controller.roll.sign) 1 - 0.9f*sqrt(abs(sin(controller.roll.toRadians())))*sqrt(abs(cos(controller.pitch))) else 1.0f
+        val tuning = frameTuning(settings, state, vehicle)
 
         //Smooth out mouse input.
         val smoothingSpeed = 2.0
-        val mouseXc = (mouseX).coerceIn(-45.0, 45.0) * mouseInputMult * rollDegreeDebuff
-        // When upside down apply a pitching force to nudge the player towards a dive. This reduces the 'weirdness'
-        // of being upside down
-        val rolledOverPitchCorrection = -8*sqrt(abs(min(cos(controller.roll.toRadians()),0.0f))) * (cos(controller.pitch.toRadians())).pow(2)
-        val mouseYc = ((mouseY).coerceIn(-45.0, 45.0) * mouseInputMult) + rolledOverPitchCorrection
+        val mouseXc = (mouseX).coerceIn(-45.0, 45.0) * mouseInputMult
+        val mouseYc = (mouseY).coerceIn(-45.0, 45.0) * mouseInputMult
         val xInput = mouseXSmoother.getNewDeltaValue(mouseXc * 0.1, deltaTime * smoothingSpeed)
         val yInput = mouseYSmoother.getNewDeltaValue(mouseYc * 0.1, deltaTime * smoothingSpeed)
         val currSpeed = state.rideVelocity.get().length()
         val currHorzSpeed = state.rideVelocity.get().horizontalDistance()
-        val hoverSpeed = 0.1
+        val hoverSpeed = HOVER_SPEED
         val pitchDamping = abs(cos(controller.pitch.toRadians())).pow(2) // Helper value used when wanting to discard the influence of another value at steep pitches
 
         // Yaw locally when at or below hoverSpeed but not when pitched up or rolled over
         val globalYaw = xInput * (1 - sqrt(RidingBehaviour.scaleToRange(currHorzSpeed, hoverSpeed, topSpeed))).coerceIn(0.0, 1.0)
         controller.applyGlobalYaw(globalYaw.toFloat())
 
-        // Pitch locally up or down depending upon a number of factors:
-        // - Reduce pitch substantially when rolled and in a steep yaw. This prevents the player from ignoring a slow handling stat
-        // - Do not pitch at all when at or below hover speed
-        // - pitch faster at higher speeds
-        val p = 1.0 - vehicle.runtime.resolveDouble(settings.horizontalPitchExpr ?: globalBird.horizontalPitchExpr!!)
-        var localPitch = yInput * (1 - abs(sin(controller.roll.toRadians())).pow(2) * p * hypot(controller.forwardVector.x.toDouble(), controller.forwardVector.z.toDouble()).toFloat())
-        localPitch *= if (currSpeed > hoverSpeed || yInput > 0.0) RidingBehaviour.scaleToRange(currSpeed, 0.0, topSpeed).coerceIn(0.2, 1.0)
+        // No pitching at hover speed and faster pitching the faster the bird goes
+        val pitchInput = yInput * if (currSpeed > hoverSpeed || yInput > 0.0) RidingBehaviour.scaleToRange(currSpeed, 0.0, topSpeed).coerceIn(0.2, 1.0)
             else 0.0
 
-        // Roll less when slow and not at all when at hoverSpeed or lower.
-        // Apply a roll righting force when trying to pitch hard while rolled sideways. This nudges the player towards
-        // pitching globally
-        val pitchInfluencedRollCorrection = 0.0
-        val howRolledAmI =  (( cos(controller.roll.toRadians()) - 1).coerceIn(-1.0f, 0.0f) * -2) //Coerce into how much roll you want to let in in the deadzone
+        // Inside a normal bank mouse pitch is world up and down so pulling up climbs instead of tightening the turn.
+        // Past the turn roll limit, or pointing near straight up or down, it hands over to the bird's own pitch
+        val pastTurnRoll = smoothstep01((abs(controller.roll) - tuning.turnRollLimit) / PITCH_BLEND_BAND_DEGREES)
+        val nearVertical = smoothstep01((abs(controller.pitch) - WORLD_PITCH_FADE_START) / (90f - WORLD_PITCH_FADE_START))
+        val localShare = 1f - (1f - pastTurnRoll) * (1f - nearVertical)
+        controller.applyGlobalPitch((pitchInput * (1f - localShare)).toFloat())
+
+        // Pulling with the bird's own pitch while rolled turns hard so it's held back by handling there
+        val p = 1.0 - vehicle.runtime.resolveDouble(settings.horizontalPitchExpr ?: globalBird.horizontalPitchExpr!!)
+        val localPitch = pitchInput * localShare * (1 - abs(sin(controller.roll.toRadians())).pow(2) * p * hypot(controller.forwardVector.x.toDouble(), controller.forwardVector.z.toDouble()).toFloat())
+
+        // Roll less when slow and not at all when at hoverSpeed or lower
         val isInputtingTowardsRoll = if ( xInput.sign == controller.roll.sign.toDouble()) 1.0 else 0.0
-        val inputInRolledDir = if (isInputtingTowardsRoll == 1.0) 1.0 else -cos(controller.roll.toRadians()).coerceIn(-1.0f, 0.0f).toDouble()
-        val rollDampen = (1 - howRolledAmI.coerceIn(0.0f, 0.7f) * pitchDamping * inputInRolledDir)
-        val rollForce = if (currHorzSpeed > hoverSpeed) xInput * sqrt(abs(RidingBehaviour.scaleToRange(currHorzSpeed, hoverSpeed, topSpeed)).coerceIn(0.0,1.0)) * rollDampen + pitchInfluencedRollCorrection
-            else 0.0
+        val rollInput = xInput * sqrt(abs(RidingBehaviour.scaleToRange(currHorzSpeed, hoverSpeed, topSpeed)).coerceIn(0.0,1.0))
+        val rollForce = if (currHorzSpeed > hoverSpeed) capRoll(rollInput, controller.roll, tuning.maxRoll) else 0.0
 
         // When already rolled significantly part of the roll force should turn to local yaw force
         val localYawForce = rollForce * abs(sin(controller.roll.toRadians())).pow(2) * pitchDamping * isInputtingTowardsRoll
@@ -546,14 +555,6 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
         return 1.0f + normalizedGlideSpeed.pow(2).toFloat() * 0.2f
     }
 
-    override fun useAngVelSmoothing(
-        settings: BirdSettings,
-        state: BirdState,
-        vehicle: PokemonEntity
-    ): Boolean {
-        return false
-    }
-
     override fun inertia(settings: BirdSettings, state: BirdState, vehicle: PokemonEntity): Double {
         return 0.5
     }
@@ -607,6 +608,139 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
 
     override fun createDefaultState(settings: BirdSettings) = BirdState()
 
+    /**
+     * Keeps the camera level until the bird rolls past the engage angle, then eases it into the bird's roll.
+     * It levels out again once the bird comes back under the release angle. Yaw and pitch always follow the bird.
+     */
+    override fun cameraBase(
+        settings: BirdSettings,
+        state: BirdState,
+        vehicle: PokemonEntity,
+        context: RideCameraContext
+    ): Quaternionf {
+        val ride = context.defaultBase()
+        val tuning = frameTuning(settings, state, vehicle)
+        val roll = context.data as? BirdCameraRoll ?: BirdCameraRoll().also { context.data = it }
+
+        val forward = FORWARDS.rotate(ride, Vector3f())
+        val up = UP.rotate(ride, Vector3f())
+
+        // Up with wings level. Pointing near straight up or down it flips sides so it's only used away from vertical
+        val levelUp = Vector3f(0f, 1f, 0f).sub(Vector3f(forward).mul(forward.y))
+        val hasLevel = levelUp.lengthSquared() > MIN_LEVEL_UP_LENGTH_SQ
+        if (hasLevel) {
+            levelUp.normalize()
+            val rideRoll = signedAngle(levelUp, up, forward)
+            if (roll.engaged && abs(rideRoll) < tuning.rollRelease) {
+                roll.engaged = false
+            } else if (!roll.engaged && abs(rideRoll) > tuning.rollEngage) {
+                roll.engaged = true
+            }
+        }
+
+        // Camera up lives in world space so the level up flipping over the top of a loop can't drag the camera round
+        val cameraUp = roll.cameraUp?.let { flatten(it, forward) } ?: Vector3f(up)
+        val target = when {
+            roll.engaged -> up
+            hasLevel -> levelUp
+            else -> Vector3f(cameraUp)
+        }
+
+        if (roll.cameraUp == null) {
+            cameraUp.set(target)
+        } else if (context.frameSeconds > 0f) {
+            // Spring the leftover angle so it builds up speed and settles instead of lunging at the start
+            roll.spring.value = signedAngle(target, cameraUp, forward)
+            simpleSpringDamper(roll.spring, 0f, tuning.rollHalflife, context.frameSeconds)
+            cameraUp.set(target).rotateAxis(roll.spring.value * Mth.DEG_TO_RAD, forward.x, forward.y, forward.z)
+        }
+        roll.cameraUp = cameraUp
+
+        return levelFrame(forward, cameraUp)
+    }
+
+    override fun firstPersonHandRoll(
+        settings: BirdSettings,
+        state: BirdState,
+        vehicle: PokemonEntity,
+        context: RideCameraContext
+    ): Float {
+        return context.rideRollAroundView() * frameTuning(settings, state, vehicle).handRollShare
+    }
+
+    // Hovering the rider can look up and down freely and around up to the hover limit. Only pushing past it turns the bird
+    override fun consumeLook(
+        settings: BirdSettings,
+        state: BirdState,
+        vehicle: PokemonEntity,
+        input: RideLookInput
+    ): RideLookTake {
+        // Only forward speed counts so rising or sinking on the spot is still hovering
+        if (state.rideVelocity.get().horizontalDistance() > HOVER_SPEED) return RideLookTake.all(input)
+        val limit = frameTuning(settings, state, vehicle).hoverLookYawLimit
+        // Never snap a look that's already past the limit, it just can't be pushed further out
+        val bound = max(limit, abs(input.yaw))
+        val target = input.yaw + input.yawDelta
+        val pushed = target - target.coerceIn(-bound, bound)
+        return RideLookTake(pushed, 0f, recenterYaw = false, recenterPitch = false)
+    }
+
+    /** Knobs the bird reads every frame, resolved at most once a tick so MoLang doesn't run per frame. */
+    private fun frameTuning(settings: BirdSettings, state: BirdState, vehicle: PokemonEntity): BirdTuning {
+        val cached = state.frameTuning.get()
+        if (cached != null && cached.tick == vehicle.tickCount) return cached
+        val runtime = vehicle.runtime
+        return BirdTuning(
+            tick = vehicle.tickCount,
+            rollEngage = runtime.resolveFloat(settings.cameraRollEngage ?: globalBird.cameraRollEngage!!),
+            rollRelease = runtime.resolveFloat(settings.cameraRollRelease ?: globalBird.cameraRollRelease!!),
+            rollHalflife = runtime.resolveFloat(settings.cameraRollHalflife ?: globalBird.cameraRollHalflife!!),
+            hoverLookYawLimit = runtime.resolveFloat(settings.hoverLookYawLimit ?: globalBird.hoverLookYawLimit!!),
+            turnRollLimit = runtime.resolveFloat(settings.turnRollLimit ?: globalBird.turnRollLimit!!),
+            maxRoll = runtime.resolveFloat(settings.maxRoll ?: globalBird.maxRoll!!),
+            rollSettleAngle = runtime.resolveFloat(settings.rollSettleAngle ?: globalBird.rollSettleAngle!!),
+            rollSettleDelay = runtime.resolveFloat(settings.timeToRollCorrect ?: globalBird.timeToRollCorrect!!),
+            handRollShare = runtime.resolveFloat(settings.handRollShare ?: globalBird.handRollShare!!)
+        ).also { state.frameTuning.set(it) }
+    }
+
+    /** Smoothstep of [t] clamped to 0 to 1. */
+    private fun smoothstep01(t: Float): Float {
+        val x = t.coerceIn(0f, 1f)
+        return x * x * (3f - 2f * x)
+    }
+
+    /**
+     * Eases roll that would take the bird further from level to a stop at [maxRoll] degrees.
+     * Rolling back toward level is never held back.
+     */
+    private fun capRoll(rollDelta: Double, roll: Float, maxRoll: Float): Double {
+        if (rollDelta.sign != roll.sign.toDouble()) return rollDelta
+        val room = (maxRoll - abs(roll)).coerceAtLeast(0f)
+        val ease = (room / ROLL_CAP_BAND_DEGREES).coerceIn(0f, 1f)
+        val eased = rollDelta * ease * ease * (3f - 2f * ease)
+        // Never step past the cap in one frame
+        return eased.coerceIn(-room.toDouble(), room.toDouble())
+    }
+
+    /** Signed degrees from [from] to [to] turning around [axis]. Both have to be perpendicular to it. */
+    private fun signedAngle(from: Vector3f, to: Vector3f, axis: Vector3f): Float {
+        return atan2(Vector3f(from).cross(to).dot(axis), from.dot(to)) * Mth.RAD_TO_DEG
+    }
+
+    /** [vector] with the part along [axis] removed, or null if nothing is left. */
+    private fun flatten(vector: Vector3f, axis: Vector3f): Vector3f? {
+        val flat = Vector3f(vector).sub(Vector3f(axis).mul(vector.dot(axis)))
+        return if (flat.lengthSquared() > 0f) flat.normalize() else null
+    }
+
+    /** Rotation whose forward is [forward] and up is [up]. They have to be unit length and perpendicular. */
+    private fun levelFrame(forward: Vector3f, up: Vector3f): Quaternionf {
+        val right = Vector3f(forward).cross(up)
+        val back = Vector3f(forward).negate()
+        return Quaternionf().setFromNormalized(Matrix3f(right, up, back))
+    }
+
     override fun asMoLangValue(
         settings: BirdSettings,
         state: BirdState,
@@ -659,6 +793,39 @@ class BirdSettings : RidingBehaviourSettings {
     // This is coerced between 1 and 0 or things would get weird.
     var stamDrainPerRateDive: Expression? = null
         private set
+    // Degrees of roll before the camera starts rolling with the bird
+    var cameraRollEngage: Expression? = null
+        private set
+
+    // Degrees the bird has to roll back under before the camera levels out. Keep it below engage so it doesn't flicker
+    var cameraRollRelease: Expression? = null
+        private set
+
+    // Seconds the camera roll spring takes to settle. Raise for a lazier camera
+    var cameraRollHalflife: Expression? = null
+        private set
+
+    // Degrees either side the rider can look while hovering before pushing further turns the bird
+    var hoverLookYawLimit: Expression? = null
+        private set
+
+    // Roll in degrees where turning tops out and mouse pitch stops being world up and down
+    var turnRollLimit: Expression? = null
+        private set
+
+    // Furthest the bird can roll from level in degrees. Keep cameraRollEngage just above it so the camera
+    // stays level through normal flying and only rolls in loops and flips. 180 lets it roll all the way over
+    var maxRoll: Expression? = null
+        private set
+
+    // Within this many degrees of level the wings settle back to level once the rider lets go of the mouse
+    var rollSettleAngle: Expression? = null
+        private set
+
+    // Share of the bird's roll the first person hands lean with, 0 to 1
+    var handRollShare: Expression? = null
+        private set
+
     var rideSounds: RideSoundSettingsList = RideSoundSettingsList()
 
     override fun encode(buffer: RegistryFriendlyByteBuf) {
@@ -677,6 +844,14 @@ class BirdSettings : RidingBehaviourSettings {
         buffer.writeNullableExpression(stamDrainPercRateGlide)
         buffer.writeNullableExpression(stamDrainPerRateDive)
         buffer.writeNullableExpression(timeToRollCorrect)
+        buffer.writeNullableExpression(cameraRollEngage)
+        buffer.writeNullableExpression(cameraRollRelease)
+        buffer.writeNullableExpression(cameraRollHalflife)
+        buffer.writeNullableExpression(hoverLookYawLimit)
+        buffer.writeNullableExpression(turnRollLimit)
+        buffer.writeNullableExpression(maxRoll)
+        buffer.writeNullableExpression(rollSettleAngle)
+        buffer.writeNullableExpression(handRollShare)
     }
 
     override fun decode(buffer: RegistryFriendlyByteBuf) {
@@ -695,6 +870,14 @@ class BirdSettings : RidingBehaviourSettings {
         stamDrainPercRateGlide = buffer.readNullableExpression()
         stamDrainPerRateDive = buffer.readNullableExpression()
         timeToRollCorrect = buffer.readNullableExpression()
+        cameraRollEngage = buffer.readNullableExpression()
+        cameraRollRelease = buffer.readNullableExpression()
+        cameraRollHalflife = buffer.readNullableExpression()
+        hoverLookYawLimit = buffer.readNullableExpression()
+        turnRollLimit = buffer.readNullableExpression()
+        maxRoll = buffer.readNullableExpression()
+        rollSettleAngle = buffer.readNullableExpression()
+        handRollShare = buffer.readNullableExpression()
     }
 }
 
@@ -705,7 +888,9 @@ class BirdState : RidingBehaviourState() {
     var currPitchCorrectionForce = ridingState(0.0, Side.CLIENT)
     var noInputTimeRoll = ridingState(0.0, Side.CLIENT)
     var noInputTimePitch = ridingState(0.0, Side.CLIENT)
-    var currUpsideDownForce = ridingState(0.0, Side.CLIENT)
+    var staminaDiveForce = ridingState(0.0, Side.CLIENT)
+    // Client only cache of the knobs read every frame, never synced
+    var frameTuning = ridingState<BirdTuning?>(null, Side.CLIENT)
 
     override fun encode(buffer: FriendlyByteBuf) {
         super.encode(buffer)
@@ -725,6 +910,7 @@ class BirdState : RidingBehaviourState() {
         currPitchCorrectionForce.set(0.0, forced = true)
         noInputTimeRoll.set(0.0, forced = true)
         noInputTimePitch.set(0.0, forced = true)
+        frameTuning.set(null, forced = true)
     }
 
     override fun toString(): String {
@@ -761,3 +947,26 @@ fun Float.angleDifference(other: Float): Float {
     while (diff > 180F) diff -= 360F
     return diff
 }
+
+/** Bird knobs resolved for one tick. */
+data class BirdTuning(
+    val tick: Int,
+    val rollEngage: Float,
+    val rollRelease: Float,
+    val rollHalflife: Float,
+    val hoverLookYawLimit: Float,
+    val turnRollLimit: Float,
+    val maxRoll: Float,
+    val rollSettleAngle: Float,
+    val rollSettleDelay: Float,
+    val handRollShare: Float
+)
+
+/** Bird's camera roll smoothing, kept in the camera context between frames. */
+class BirdCameraRoll {
+    var engaged = false
+    // World space up the camera had last frame, null until the first frame
+    var cameraUp: Vector3f? = null
+    // Degrees left between the camera and where it's heading, plus how fast that's closing
+    val spring = FloatSpring()
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/types/air/BoardBehaviour.kt

@@ -0,0 +1,938 @@
+/*
+ * 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.riding.behaviour.types.air
+
+import com.bedrockk.molang.Expression
+import com.bedrockk.molang.runtime.value.DoubleValue
+import com.cobblemon.mod.common.CobblemonRideSettings
+import com.cobblemon.mod.common.OrientationControllable
+import com.cobblemon.mod.common.api.molang.ObjectValue
+import com.cobblemon.mod.common.api.orientation.OrientationController
+import com.cobblemon.mod.common.api.riding.RidingStyle
+import com.cobblemon.mod.common.api.riding.behaviour.RideSteerInput
+import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviour
+import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviourSettings
+import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviourState
+import com.cobblemon.mod.common.api.riding.behaviour.Side
+import com.cobblemon.mod.common.api.riding.behaviour.ridingState
+import com.cobblemon.mod.common.api.riding.posing.PoseOption
+import com.cobblemon.mod.common.api.riding.posing.PoseProvider
+import com.cobblemon.mod.common.api.riding.sound.RideSoundSettingsList
+import com.cobblemon.mod.common.api.riding.stats.RidingStat
+import com.cobblemon.mod.common.api.riding.util.DistanceFieldLayer
+import com.cobblemon.mod.common.api.riding.util.DistanceFieldTuning
+import com.cobblemon.mod.common.api.riding.util.PrimitiveShape
+import com.cobblemon.mod.common.api.riding.util.RideFrame
+import com.cobblemon.mod.common.api.riding.util.collectPrimitivesFromBlocks
+import com.cobblemon.mod.common.api.riding.util.estimateGradient
+import com.cobblemon.mod.common.api.riding.util.sampleField
+import com.cobblemon.mod.common.api.riding.util.visualizeDistanceField
+import com.cobblemon.mod.common.entity.PoseType
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.util.blockPositionsAsListRounded
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.cobblemon.mod.common.util.readNullableExpression
+import com.cobblemon.mod.common.util.readRidingStats
+import com.cobblemon.mod.common.util.resolveBoolean
+import com.cobblemon.mod.common.util.resolveDouble
+import com.cobblemon.mod.common.util.resolveFloat
+import com.cobblemon.mod.common.util.writeNullableExpression
+import com.cobblemon.mod.common.util.writeRidingStats
+import net.minecraft.client.Minecraft
+import kotlin.math.abs
+import kotlin.math.max
+import kotlin.math.min
+import kotlin.math.pow
+import kotlin.math.sign
+import kotlin.math.sqrt
+import net.minecraft.core.Direction
+import net.minecraft.core.particles.ParticleTypes
+import net.minecraft.network.FriendlyByteBuf
+import net.minecraft.network.RegistryFriendlyByteBuf
+import net.minecraft.util.Mth
+import net.minecraft.util.SmoothDouble
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.ai.attributes.Attributes
+import net.minecraft.world.entity.player.Player
+import net.minecraft.world.phys.AABB
+import net.minecraft.world.phys.Vec2
+import net.minecraft.world.phys.Vec3
+import net.minecraft.world.phys.shapes.Shapes
+import org.joml.Matrix3f
+import org.joml.Quaternionf
+import org.joml.Vector3f
+
+class BoardBehaviour : RidingBehaviour<BoardSettings, BoardState> {
+    companion object {
+        val KEY = cobblemonResource("air/board")
+    }
+
+    override val key = KEY
+    val globalBoard: BoardSettings
+        get() = CobblemonRideSettings.board
+
+    override fun getRidingStyle(settings: BoardSettings, state: BoardState): RidingStyle {
+        return RidingStyle.LAND
+    }
+
+    val poseProvider = PoseProvider<BoardSettings, BoardState>(PoseType.HOVER)
+        .with(PoseOption(PoseType.FLY) { _, state, vehicle ->
+            return@PoseOption state.walking.get()
+        })
+
+    override fun isActive(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity
+    ): Boolean {
+        return Shapes.create(vehicle.boundingBox).blockPositionsAsListRounded().any {
+            // Need to check other fluids
+            if (vehicle.isInWater || vehicle.isUnderWater) {
+                return@any false
+            }
+            // This might not actually work, depending on what the yPos actually is. yPos of the middle of the entity? the feet?
+            if (it.y.toDouble() == (vehicle.position().y)) {
+                val blockState = vehicle.level().getBlockState(it.below())
+                return@any !blockState.isAir && blockState.fluidState.isEmpty
+            }
+            true
+        }
+    }
+
+    override fun pose(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity
+    ): PoseType {
+        return this.poseProvider.select(settings, state, vehicle)
+    }
+
+    override fun speed(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity,
+        driver: Player
+    ): Float {
+        return state.rideVelocity.get().length().toFloat()
+    }
+
+    override fun tick(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        input: Vec3
+    ) {
+        if (vehicle.level().isClientSide) {
+            handleSprinting(state, driver)
+            inAirCheck(state, vehicle)
+            tickStamina(settings, state, vehicle)
+            state.walking.set(state.rideVelocity.get().horizontalDistance() > 0.1 || driver.zza != 0.0f)
+            //surfDistCheck(state, vehicle)
+        }
+
+        //TODO: should be a config somewhere
+        val debugVisualizeField = true;
+
+        if (false && debugVisualizeField && !vehicle.level().isClientSide && vehicle.tickCount % 5 == 0) {
+            visualizeDistanceField(
+                referenceEntity = vehicle,
+                center = vehicle.position().add(0.0, (vehicle.bbHeight * 0.5f).toDouble(), 0.0),
+                layers = listOf(
+                    DistanceFieldLayer(isoValue = 2.5f, color = Vector3f(1f, 0.2f, 0.2f))
+                ),
+                shape = PrimitiveShape.ELLIPSOID,
+                horizontalRadius = 4.0,
+                verticalRange = 4.0,
+                sampleSpacing = 0.3,
+                marchStep = 0.15,
+                tuning = DistanceFieldTuning(smoothingRange = 0.25f)
+            )
+        }
+    }
+
+    /**
+     * Check how far the vehicle is from the "surface"
+     */
+    fun surfDistCheck(
+        state: BoardState,
+        vehicle: PokemonEntity,
+    ) {
+        val center = vehicle.position()
+        val horizontalRadius = 4.0;
+        val verticalRange = 4.0;
+        val level = vehicle.level()
+
+        //if (level !is ServerLevel) return
+
+        // Take a cubic area around the vehicle and gather SDF primitives from it.
+        val searchBox = AABB(
+            center.x - horizontalRadius, center.y - verticalRange, center.z - horizontalRadius,
+            center.x + horizontalRadius, center.y + verticalRange, center.z + horizontalRadius
+        )
+        val primitives = collectPrimitivesFromBlocks(level,
+            searchBox,
+            PrimitiveShape.ELLIPSOID,
+            includeFluids = true
+        )
+        val sp = center.toVector3f() // Sample Point
+        val tuning = DistanceFieldTuning(smoothingRange = 0.25f)
+        val sd = sampleField(primitives, sp.x, sp.y, sp.z, tuning)
+        state.surfDist.set(sd)
+    }
+
+    fun inAirCheck(
+        state: BoardState,
+        vehicle: PokemonEntity,
+    ) {
+        // Check both vertical movement and if there are blocks below.
+        val posBelow = vehicle.blockPosition().below()
+        val blockStateBelow = vehicle.level().getBlockState(posBelow)
+        val isAirOrLiquid = blockStateBelow.isAir || !blockStateBelow.fluidState.isEmpty
+
+        val canSupportEntity = blockStateBelow.isFaceSturdy(vehicle.level(), posBelow, Direction.UP)
+        val standingOnSolid = canSupportEntity && !isAirOrLiquid
+
+        // inAir if not on the ground
+        val inAir = !(vehicle.deltaMovement.y == 0.0 || standingOnSolid)
+        state.inAir.set(true)
+    }
+
+    fun handleSprinting(
+        state: BoardState,
+        driver: Player
+    ) {
+        val sprintTimerTickLength = 7 // Emulate vanillas tick timer length
+        var hasDoubleTapped = false
+
+        // If you are not sprinting and you just pressed down and theres no
+        if (!state.forwardHeldLastTick.get() && Minecraft.getInstance().options.keyUp.isDown() && !state.sprinting.get() && state.sprintTickTimer.get() == 0) {
+            state.sprintTickTimer.set(sprintTimerTickLength)
+        } else if (!state.forwardHeldLastTick.get() && Minecraft.getInstance().options.keyUp.isDown() && state.sprintTickTimer.get() != 0) { // If has double tapped
+            hasDoubleTapped = true
+        }else if(!state.sprinting.get() && state.sprintTickTimer.get() > 0) {
+            state.sprintTickTimer.set(state.sprintTickTimer.get() - 1)
+        } else {
+            state.sprintTickTimer.set(0)
+        }
+
+        val tryingToSprint = (Minecraft.getInstance().options.keySprint.isDown() && Minecraft.getInstance().options.keyUp.isDown()) || hasDoubleTapped
+
+        if (state.stamina.get() <= 0.0f || !Minecraft.getInstance().options.keyUp.isDown()) {
+            // If stamina runs out or the player is not holding forward then stop sprinting
+            state.sprinting.set(false)
+            if (state.stamina.get() <= 0.0f) {
+                state.sprintToggleable.set(false)
+            }
+        } else if (!state.sprinting.get() && !state.sprintToggleable.get() && state.stamina.get() > 0.33f) {
+            // If you are not sprinting and sprint is not toggleable and you're not trying to sprint and stamina is above 0.3 then enable the toggle
+            state.sprintToggleable.set(true)
+        } else if (tryingToSprint && state.sprintToggleable.get()) {
+            // If you are trying to sprint and the toggle allows it then start sprinting and disable toggle
+            state.sprinting.set(true)
+        }
+
+        // Take not of whether forward was held last tick
+        state.forwardHeldLastTick.set(Minecraft.getInstance().options.keyUp.isDown())
+    }
+
+    fun tickStamina(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity,
+    ) {
+        val stam = state.stamina.get()
+
+        if (vehicle.runtime.resolveBoolean(settings.infiniteStamina ?: globalBoard.infiniteStamina!!)) {
+            return
+        }
+
+
+        val stamDrainRate = (1.0f / vehicle.runtime.resolveDouble(settings.staminaExpr ?: globalBoard.staminaExpr!!)).toFloat() / 20.0f
+
+        val newStam = if (state.sprinting.get()) {
+            max(0.0f,stam - stamDrainRate)
+        } else {
+            min(1.0f,stam + stamDrainRate * 4)
+        }
+
+        state.stamina.set(newStam.coerceIn(0F, 1F))
+    }
+
+    override fun updatePassengerRotation(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity,
+        driver: LivingEntity
+    ) { return }
+
+    override fun clampPassengerRotation(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity,
+        driver: LivingEntity
+    ) { }
+
+
+    override fun rotation(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity,
+        driver: LivingEntity
+    ): Vec2 {
+        val turnAmount =  calcRotAmount(settings, state, vehicle, driver)
+        return Vec2(vehicle.xRot, vehicle.yRot + turnAmount )
+
+    }
+
+    /*
+   *  Calculates the rotation amount given the difference between
+   *  the current player y rot and entity y rot. This gives the
+   *  affect of influencing a rides rotation through the mouse
+   *  without it being instant.
+   */
+    fun calcRotAmount(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity,
+        driver: LivingEntity
+    ): Float {
+        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr ?: globalBoard.speedExpr!!)
+        val handling = vehicle.runtime.resolveDouble(settings.handlingExpr ?: globalBoard.handlingExpr!!)
+        val walkHandlingBoost = 5
+        val maxYawDiff = vehicle.runtime.resolveFloat(settings.lookYawLimit ?: globalBoard.lookYawLimit!!)
+
+        // Normalize the current rotation diff
+        val rotDiff = Mth.wrapDegrees(driver.yRot - vehicle.yRot).coerceIn(-maxYawDiff,maxYawDiff)
+        val rotDiffNorm = rotDiff / maxYawDiff//(rotDiff / maxYawDiff).coerceIn(-0.2f, 0.2f)
+
+        // Take the square root so that the ride levels out quicker when at lower differences between entity
+        // y and driver y
+        // This influences the speed of the turn based on how far in one direction you're looking
+        val minRotMod = 0.4f // Min speed that the rotation modulation converges towards
+        val rotDiffMod = ((sqrt(abs(rotDiffNorm)) * (1.0f - minRotMod)) + minRotMod) * rotDiffNorm.sign
+
+        // Turn rate should be quick when walking and slower when sprinting.
+        // Smoothly move between these based on speed
+        val walkSpeed = getWalkSpeed(vehicle)
+        val w = max(walkSpeed, vehicle.deltaMovement.horizontalDistance())
+        val invRelSpeed = (RidingBehaviour.scaleToRange(w, walkSpeed, topSpeed ) - 1.0f) * -1.0f
+        val turnRate = ((handling.toFloat() / 20.0f) * max(walkHandlingBoost * sqrt(abs(invRelSpeed)), 1.0)).toFloat()
+
+        // Ensure you only ever rotate as much difference as there is between the angles.
+        val turnSpeed = turnRate * rotDiffMod
+        val rotAmount = turnSpeed.coerceIn(-abs(rotDiff), abs(rotDiff))
+
+        return rotAmount
+    }
+
+    private fun spawnGradientDebugParticles(vehicle: PokemonEntity, normal: Vec3) {
+        val level = vehicle.level()
+        val headPos = vehicle.position().add(0.0, vehicle.bbHeight.toDouble(), 0.0)
+
+        val steps = 20
+        val length = 2.0
+        for (i in 0..steps) {
+            val t = i.toDouble() / steps
+            val point = headPos.add(normal.scale(length * t))
+            level.addParticle(ParticleTypes.END_ROD, point.x, point.y, point.z, 0.0, 0.0, 0.0)
+        }
+    }
+
+
+    // This ride works along its yaw so its velocity gets turned into world space here
+    override fun velocity(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        input: Vec3
+    ): Vec3 {
+        return RideFrame.yawToWorld(localVelocity(settings, state, vehicle, driver, input), vehicle.yRot)
+    }
+
+    private fun localVelocity(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        input: Vec3
+    ): Vec3 {
+            state.rideVelocity.set(calculateRideSpaceVel(settings, state, vehicle, driver))
+            return state.rideVelocity.get()
+    }
+
+    private fun calculateRideSpaceVel(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity,
+        driver: Player
+    ): Vec3 {
+        val canSprint = vehicle.runtime.resolveBoolean(settings.canSprint ?: globalBoard.canSprint!!)
+        val canJump = vehicle.runtime.resolveBoolean(settings.canJump ?: globalBoard.canJump!!)
+        val jumpForce = vehicle.runtime.resolveDouble(settings.jumpExpr ?: globalBoard.jumpExpr!!) * 0.75
+        val rideTopSpeed = vehicle.runtime.resolveDouble(settings.speedExpr ?: globalBoard.speedExpr!!)
+        val walkSpeed = getWalkSpeed(vehicle)
+        val topSpeed = if(canSprint && state.sprinting.get()) rideTopSpeed else walkSpeed
+        val accelTime = if(state.sprinting.get()) (vehicle.runtime.resolveDouble(settings.accelerationExpr ?: globalBoard.accelerationExpr!!) * 20.0) else 0.5 * 20.0
+        val accel = topSpeed / accelTime
+        var activeInput = false
+
+        /******************************************************
+         * Gather the previous velocity and check for horizontal
+         * collisions
+         *****************************************************/
+        var newVelocity = state.rideVelocity.get() //.normalize().scale(vehicle.deltaMovement.horizontalDistance())
+
+        /******************************************************
+         * Gather the previous velocity and check for horizontal
+         * collisions
+         *****************************************************/
+        if (vehicle.horizontalCollision) {
+            var horizontalVec = Vec3(newVelocity.x, 0.0, newVelocity.z)
+            horizontalVec = horizontalVec.normalize().scale(min(horizontalVec.length(), 0.3))
+            newVelocity = Vec3(horizontalVec.x, newVelocity.y, horizontalVec.z)
+        }
+
+        /******************************************************
+         * Speed up and slow down based on input
+         *****************************************************/
+        if (driver.zza != 0.0f) {
+
+            // If on a tight turn then do not speed up past half of top speed in order to turn quicker
+            // Also determine how fast to be slowing down based on how far turned you are
+            val lookYawLimit = vehicle.runtime.resolveFloat(settings.lookYawLimit ?: globalBoard.lookYawLimit!!)
+            val percOfMaxTurnSpeed = abs(Mth.wrapDegrees(driver.yRot - vehicle.yRot) / lookYawLimit) * 100.0f
+            val turnPercThresh = 0.0f
+            val s = min(((percOfMaxTurnSpeed - turnPercThresh) / (100.0f - turnPercThresh)).pow(1),1.0f)
+            val effectiveTopSpeed = if (percOfMaxTurnSpeed > turnPercThresh) topSpeed / max(2.0f*s,1.0f) else topSpeed
+            val turningSlowDown = s * 0.1
+
+            //make sure it can't exceed top speed
+            val forwardInput = when {
+                driver.zza > 0 && newVelocity.z > effectiveTopSpeed -> 0.0
+                driver.zza < 0 && newVelocity.z < (-effectiveTopSpeed / 3.0) -> 0.0
+                else -> driver.zza.sign
+            }
+
+            // Add extra friction if trying to slow down to turn faster
+            if (newVelocity.z > effectiveTopSpeed) {
+                newVelocity = newVelocity.subtract(0.0, 0.0, min(turningSlowDown * newVelocity.z.sign, newVelocity.z))
+            }
+
+            newVelocity = Vec3(
+                newVelocity.x,
+                newVelocity.y,
+                (newVelocity.z + (accel * forwardInput.toDouble())))
+
+            activeInput = true
+        }
+
+        /******************************************************
+         * Gravity logic
+         *****************************************************/
+//         if(state.surfDist.get() > 1.6f) {
+//            val gravity = (9.8 / ( 20.0)) * 0.2 * 0.6
+//            val terminalVel = 2.0
+//            newVelocity = Vec3(newVelocity.x, max(newVelocity.y - gravity, -terminalVel), newVelocity.z)
+//        } else if(state.surfDist.get() > 1.4f && state.surfDist.get() <= 1.6f) {
+//             newVelocity = Vec3(newVelocity.x, 0.0, newVelocity.z)
+//        } else if(state.surfDist.get() <= 1.4f) {
+//             val gravity = -(9.8 / ( 20.0)) * 0.2 * 0.6
+//             val terminalVel = -2.0
+//             newVelocity = Vec3(newVelocity.x, min(newVelocity.y - gravity, -terminalVel), newVelocity.z)
+//        }
+
+        /******************************************************
+         * Hover logic - non-predictive: correct against current position
+         *****************************************************/
+        val correctionGain = 0.5
+        val maxCorrectionSpeed = 0.3
+        val center = vehicle.position()
+        val horizontalRadius = 4.0;
+        val verticalRange = 4.0;
+        val level = vehicle.level()
+
+        // Take a cubic area around the vehicle and gather SDF primitives from it.
+        val searchBox = AABB(
+            center.x - horizontalRadius, center.y - verticalRange, center.z - horizontalRadius,
+            center.x + horizontalRadius, center.y + vehicle.bbHeight, center.z + horizontalRadius
+        )
+        val primitives = collectPrimitivesFromBlocks(level,
+            searchBox,
+            PrimitiveShape.ELLIPSOID,
+            includeFluids = true
+        )
+        val tuning = DistanceFieldTuning(smoothingRange = 0.25f)
+
+        val currentPos = vehicle.position()
+        val currentDist = sampleField(primitives, currentPos.x.toFloat(), currentPos.y.toFloat(), currentPos.z.toFloat(), tuning)
+        val normal = estimateGradient(primitives, currentPos, tuning)
+        state.surfaceNormal.set(normal)
+        //spawnGradientDebugParticles(vehicle, normal) // LETS SEE IT!
+
+        // Only correct when under the hover surface.
+        // Otherwise allow gravity to do its thing
+//        if (currentDist < targetHoverDist) {
+//            val error = currentDist - targetHoverDist
+//            val normalSpeed = newVelocity.dot(normal)
+//            val tangentialVelocity = newVelocity.subtract(normal.scale(normalSpeed))
+//
+//            val correctionSpeed = (-error * correctionGain).coerceIn(-maxCorrectionSpeed, maxCorrectionSpeed)
+//            newVelocity = tangentialVelocity.add(normal.scale(correctionSpeed))
+//        } else {
+//            val hoverCoolnessLowGravFactor = 0.5
+//            val gravity = (9.8 / ( 20.0)) * 0.2 * 0.6 * hoverCoolnessLowGravFactor
+//            val terminalVel = 2.0 * hoverCoolnessLowGravFactor
+//            newVelocity = Vec3(newVelocity.x, max(newVelocity.y - gravity, -terminalVel), newVelocity.z)
+//        }
+
+        /******************************************************
+         * Hover logic
+         *****************************************************/
+        val hoverActivationDist = 3.0f
+        val targetHoverDist = 1.0f
+        val hoverCoolnessLowGravFactor = 0.70
+        val gravity = (9.8 / 20.0) * 0.2 * 0.6 * hoverCoolnessLowGravFactor
+        val terminalVel = 2.0 * hoverCoolnessLowGravFactor
+//        val repelStrength = 0.05 // tested and was alright
+//        val hoverDamping = 0.15
+        val repelStrength = 0.1
+        val hoverDamping = 0.2
+
+        val surfDist = currentDist
+
+        if (surfDist > hoverActivationDist) {
+            // Free fall - no surface influence yet, same as before.
+            newVelocity = Vec3(newVelocity.x, max(newVelocity.y - gravity, -terminalVel), newVelocity.z)
+        } else {
+            // Getting close - push back toward targetHoverDist, harder the nearer we are.
+            val closeness = ((hoverActivationDist - surfDist) / (hoverActivationDist - targetHoverDist)).coerceIn(0f, 1.5f)
+            val repelForce = closeness * repelStrength
+            val dampingForce = -newVelocity.y * hoverDamping // resists overshoot/bounce
+
+            newVelocity = Vec3(newVelocity.x, newVelocity.y + repelForce + dampingForce - gravity * 0.3, newVelocity.z)
+        }
+
+
+
+        /******************************************************
+         * Ground Friction
+//         *****************************************************/
+//        if( (newVelocity.horizontalDistance() > 0 && vehicle.onGround() && !activeInput) || newVelocity.horizontalDistance() > topSpeed) {
+//            newVelocity = newVelocity.subtract(0.0, 0.0, min(0.03 * newVelocity.z.sign, newVelocity.z))
+//        }
+
+        /******************************************************
+         * Jump Logic
+         *****************************************************/
+        if (state.jumpTicks.get() > 0 || (state.jumpTicks.get() >= 0 && driver.jumping && vehicle.onGround() && canJump && driver.deltaMovement.y <= 0.1)) {
+            // Spread out jumpforce so that variable height jumps are possible
+            val jumpInputTicks = 6
+            if (driver.jumping && (state.jumpTicks.get() >= 0 && state.jumpTicks.get() < jumpInputTicks)) {
+                val appliedJumpForce = ((jumpForce*1.5) / jumpInputTicks) //* (1 - state.jumpTicks.get() / jumpInputTicks)
+                newVelocity = Vec3(newVelocity.x, newVelocity.y + appliedJumpForce, newVelocity.z)
+                state.jumpTicks.set(state.jumpTicks.get() + 1)
+            } else {
+                // Set delay before next jump is possible after hitting ground
+                val tickJumpDelay = 3
+                state.jumpTicks.set(-tickJumpDelay)
+            }
+        } else if (vehicle.onGround() && state.jumpTicks.get() < 0) {
+            // Tick off the delay once reaching the ground
+            state.jumpTicks.set(state.jumpTicks.get() + 1)
+        }
+
+        // Zero out lateral velocity possibly picked up from a controller transition
+        newVelocity = Vec3(0.0, newVelocity.y, newVelocity.z)
+
+
+        return newVelocity
+    }
+
+    private fun getWalkSpeed( vehicle: PokemonEntity ): Double {
+        val walkspeed = vehicle.runtime.resolveDouble(vehicle.behaviour.moving.walk.walkSpeed)
+        val movementSpeed = vehicle.attributes.getValue(Attributes.MOVEMENT_SPEED)
+        val speedModifier = 1.2 * 0.35
+        return walkspeed * movementSpeed * speedModifier
+
+    }
+
+    private fun rotateOverTime(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        deltaTime: Double
+    ) {
+        if (vehicle !is OrientationControllable) return
+        val controller = (vehicle as OrientationControllable).orientationController
+
+        // turning
+        val turnMaxRate = 5.5
+        val turnAccel = 1.0
+        val turnFriction = 0.75
+
+        val targetYawRate = -driver.xxa.toDouble() * turnMaxRate
+        val currentYawRate = state.yawAngularVelocity.get()
+        val newYawRate = if (abs(targetYawRate) > 0.001) {
+            moveToward(currentYawRate, targetYawRate, turnAccel * deltaTime * 20.0)
+        } else {
+            moveToward(currentYawRate, 0.0, turnFriction * deltaTime * 20.0)
+        }
+        state.yawAngularVelocity.set(newYawRate)
+        controller.applyGlobalYaw((newYawRate * deltaTime * 20.0).toFloat())
+
+        // up-vector alignment framerate-independent
+        val upAlignmentRatePerTick = 0.1 // fraction of the remaining gap closed per tick
+        val frameBlend = 1.0 - (1.0 - upAlignmentRatePerTick).pow(deltaTime * 20.0)
+        alignUpToSurfaceNormal(controller, state.surfaceNormal.get(), frameBlend.toFloat())
+
+        // lean into turns (cosmetic local roll)
+        val maxLeanDeg = 35.0
+        val leanPerYawRate = 4.0 * 3.0
+        val leanRatePerTick = 0.25 * 1.5
+
+        val desiredLean = (newYawRate * leanPerYawRate).coerceIn(-maxLeanDeg, maxLeanDeg)
+        val leanFrameBlend = 1.0 - (1.0 - leanRatePerTick).pow(deltaTime * 20.0)
+        val leanError = controller.roll.angleDifference(desiredLean.toFloat())
+        controller.rotateRoll((leanError * leanFrameBlend).toFloat())
+
+    }
+
+    private fun moveToward(current: Double, target: Double, maxDelta: Double): Double {
+        val diff = target - current
+        return if (abs(diff) <= maxDelta) target else current + maxDelta * diff.sign
+    }
+
+    private fun alignUpToSurfaceNormal(controller: OrientationController, targetUp: Vec3, alignmentBlend: Float) {
+        if (targetUp.lengthSqr() < 1e-6) return
+        val targetUpVec = Vector3f(targetUp.x.toFloat(), targetUp.y.toFloat(), targetUp.z.toFloat()).normalize()
+
+        controller.updateOrientation { current ->
+            val currentUp = current.transform(Vector3f(OrientationController.UP), Vector3f())
+            if (currentUp.lengthSquared() < 1e-6f) return@updateOrientation current
+
+            // Full rotation that would exactly align currentUp to targetUp...
+            val fullCorrection = Quaternionf().rotationTo(currentUp, targetUpVec)
+            // ...but only take a partial step toward it, so alignment is smooth, not instant.
+            val steppedCorrection = Quaternionf().slerp(fullCorrection, alignmentBlend)
+
+            // Pre-multiply (world-space correction), same pattern applyGlobalYaw uses.
+            Matrix3f().set(steppedCorrection).mul(current, Matrix3f())
+        }
+    }
+
+    override fun steer(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        input: RideSteerInput
+    ) {
+        input.rotate(mouseRotation(settings, state, vehicle, driver, input.mousePitch, input.mouseYaw, input.mouseYSmoother, input.mouseXSmoother, input.sensitivity, input.deltaTime))
+        rotateOverTime(settings, state, vehicle, driver, input.deltaTime)
+    }
+
+    private fun mouseRotation(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        mouseY: Double,
+        mouseX: Double,
+        mouseYSmoother: SmoothDouble,
+        mouseXSmoother: SmoothDouble,
+        sensitivity: Double,
+        deltaTime: Double
+    ): Vec3 {
+        //Smooth out mouse input.
+        val smoothingSpeed = 4
+        val xInput = mouseXSmoother.getNewDeltaValue(mouseX * 0.1, deltaTime * smoothingSpeed);
+        val yInput = mouseYSmoother.getNewDeltaValue(mouseY * 0.1, deltaTime * smoothingSpeed);
+
+        //yaw, pitch, roll
+        return Vec3(0.0, yInput, xInput)
+    }
+
+    override fun canJump(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity,
+        driver: Player
+    ): Boolean {
+        return false
+    }
+
+    override fun setRideBar(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity,
+        driver: Player
+    ): Float {
+        return (state.stamina.get() / 1.0f)
+    }
+
+    override fun jumpForce(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        jumpStrength: Int
+    ): Vec3 {
+        return Vec3.ZERO
+    }
+
+    override fun gravity(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity,
+        regularGravity: Double
+    ): Double {
+        return 0.0
+    }
+
+    override fun rideFovMultiplier(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity,
+        driver: Player
+    ): Float {
+        return if (state.sprinting.get()) 1.15f else 1.0f
+    }
+
+    override fun inertia(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity
+    ): Double {
+            return 1.0
+    }
+
+    override fun shouldRoll(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity
+    ): Boolean {
+        return true
+    }
+
+    override fun turnOffOnGround(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity
+    ): Boolean {
+        return false
+    }
+
+    override fun dismountOnShift(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity
+    ): Boolean {
+        return false
+    }
+
+    override fun shouldRotatePokemonHead(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity
+    ): Boolean {
+        return false
+    }
+
+    override fun shouldRotateRiderHead(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity
+    ): Boolean {
+        return true
+    }
+
+    override fun maxUpStep(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity
+    ): Float? {
+        return if (state.inAir.get()) 0.0f else 1.2f
+    }
+
+    override fun getRideSounds(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity
+    ): RideSoundSettingsList {
+        return settings.rideSounds
+    }
+
+    override fun createDefaultState(settings: BoardSettings) = BoardState()
+
+    override fun asMoLangValue(
+        settings: BoardSettings,
+        state: BoardState,
+        vehicle: PokemonEntity
+    ): ObjectValue<RidingBehaviour<BoardSettings, BoardState>> {
+        val canJump = vehicle.runtime.resolveBoolean(settings.canJump ?: globalBoard.canJump!!)
+        val value = super.asMoLangValue(settings, state, vehicle)
+        value.functions.put("sprinting") { DoubleValue(state.sprinting.get()) }
+        value.functions.put("walking") { DoubleValue(state.walking.get()) }
+        value.functions.put("in_air") { DoubleValue(state.inAir.get() || (state.rideVelocity.get().y >= 0.0 && (vehicle.controllingPassenger as? Player)?.jumping == true && canJump) || (state.rideVelocity.get().y > 0.0)) }
+        return value
+    }
+}
+
+class BoardSettings : RidingBehaviourSettings {
+    override val key = BoardBehaviour.KEY
+    override val stats = mutableMapOf<RidingStat, IntRange>()
+
+    var infiniteStamina: Expression? = null
+        private set
+    var canJump: Expression? = null
+        private set
+
+    var canSprint: Expression? = null
+        private set
+
+    var lookYawLimit: Expression? = null
+        private set
+
+    var speedExpr: Expression? = null
+        private set
+
+    // Max accel is a whole 1.0 in 1 second. The conversion in the function below is to convert seconds to ticks
+    var accelerationExpr: Expression? = null
+        private set
+
+    // Between 30 seconds and 10 seconds at the lowest when at full speed.
+    var staminaExpr: Expression? = null
+        private set
+
+    //Between a one block jump and a six block jump
+    var jumpExpr: Expression? = null
+        private set
+
+    var handlingExpr: Expression? = null
+        private set
+
+    var rideSounds: RideSoundSettingsList = RideSoundSettingsList()
+
+    override fun encode(buffer: RegistryFriendlyByteBuf) {
+        buffer.writeRidingStats(stats)
+        rideSounds.encode(buffer)
+        buffer.writeNullableExpression(infiniteStamina)
+        buffer.writeNullableExpression(canJump)
+        buffer.writeNullableExpression(canSprint)
+        buffer.writeNullableExpression(lookYawLimit)
+        buffer.writeNullableExpression(speedExpr)
+        buffer.writeNullableExpression(accelerationExpr)
+        buffer.writeNullableExpression(staminaExpr)
+        buffer.writeNullableExpression(jumpExpr)
+        buffer.writeNullableExpression(handlingExpr)
+        buffer.writeNullableExpression(canJump)
+        buffer.writeNullableExpression(canSprint)
+    }
+
+    override fun decode(buffer: RegistryFriendlyByteBuf) {
+        stats.putAll(buffer.readRidingStats())
+
+
+        rideSounds = RideSoundSettingsList.decode(buffer)
+        infiniteStamina = buffer.readNullableExpression()
+        canJump = buffer.readNullableExpression()
+        canSprint = buffer.readNullableExpression()
+        lookYawLimit = buffer.readNullableExpression()
+        speedExpr = buffer.readNullableExpression()
+        accelerationExpr = buffer.readNullableExpression()
+        staminaExpr = buffer.readNullableExpression()
+        jumpExpr = buffer.readNullableExpression()
+        handlingExpr = buffer.readNullableExpression()
+        canJump = buffer.readNullableExpression()
+        canSprint = buffer.readNullableExpression()
+    }
+}
+
+class BoardState : RidingBehaviourState() {
+    var sprinting = ridingState(false, Side.CLIENT)
+    var walking = ridingState(false, Side.BOTH)
+    var sprintToggleable = ridingState(false, Side.CLIENT)
+    var inAir = ridingState(false, Side.CLIENT)
+    var jumpTicks = ridingState(0, Side.CLIENT)
+    var sprintTickTimer = ridingState(0, Side.CLIENT)
+    var forwardHeldLastTick = ridingState(false, Side.CLIENT)
+    var surfDist = ridingState(Float.POSITIVE_INFINITY, Side.BOTH)
+    var surfaceNormal = ridingState(Vec3(0.0, 1.0, 0.0), Side.CLIENT)
+    var yawAngularVelocity = ridingState(0.0, Side.CLIENT)
+
+    override fun encode(buffer: FriendlyByteBuf) {
+        super.encode(buffer)
+        buffer.writeBoolean(sprinting.get())
+        buffer.writeBoolean(walking.get())
+        buffer.writeBoolean(sprintToggleable.get())
+        buffer.writeBoolean(inAir.get())
+        buffer.writeInt(jumpTicks.get())
+        buffer.writeInt(sprintTickTimer.get())
+        buffer.writeBoolean(forwardHeldLastTick.get())
+        buffer.writeFloat(surfDist.get())
+        buffer.writeVec3(surfaceNormal.get())
+        buffer.writeDouble(yawAngularVelocity.get())
+    }
+
+    override fun decode(buffer: FriendlyByteBuf) {
+        super.decode(buffer)
+        sprinting.set(buffer.readBoolean(), forced = true)
+        walking.set(buffer.readBoolean(), forced = true)
+        sprintToggleable.set(buffer.readBoolean(), forced = true)
+        inAir.set(buffer.readBoolean(), forced = true)
+        jumpTicks.set(buffer.readInt(), forced = true)
+        sprintTickTimer.set(buffer.readInt(), forced = true)
+        forwardHeldLastTick.set(buffer.readBoolean(), forced = true)
+        surfDist.set(buffer.readFloat(), forced = true)
+        surfaceNormal.set(buffer.readVec3(), forced = true)
+        yawAngularVelocity.set(buffer.readDouble(), forced = true)
+    }
+
+    override fun reset() {
+        super.reset()
+        sprinting.set(false, forced = true)
+        walking.set(false, forced = true)
+        sprintToggleable.set(false, forced = true)
+        inAir.set(false, forced = true)
+        jumpTicks.set(0, forced = true)
+        sprintTickTimer.set(0, forced = true)
+        forwardHeldLastTick.set(false, forced = true)
+        surfDist.set(Float.POSITIVE_INFINITY, forced = true)
+        surfaceNormal.set(Vec3(0.0, 1.0, 0.0), forced = true)
+        yawAngularVelocity.set(0.0, forced = true)
+    }
+
+    override fun copy() = BoardState().also {
+        it.rideVelocity.set(this.rideVelocity.get(), forced = true)
+        it.stamina.set(this.stamina.get(), forced = true)
+        it.sprinting.set(this.sprinting.get(), forced = true)
+        it.walking.set(this.sprinting.get(), forced = true)
+        it.sprintToggleable.set(this.sprintToggleable.get(), forced = true)
+        it.inAir.set(this.inAir.get(), forced = true)
+        it.jumpTicks.set(this.jumpTicks.get(), forced = true)
+        it.sprintTickTimer.set(this.sprintTickTimer.get(), forced = true)
+        it.forwardHeldLastTick.set(this.forwardHeldLastTick.get(), forced = true)
+        it.surfDist.set(this.surfDist.get(), forced = true)
+        it.surfaceNormal.set(this.surfaceNormal.get(), forced = true)
+        it.yawAngularVelocity.set(this.yawAngularVelocity.get(), forced = true)
+    }
+
+    override fun shouldSync(previous: RidingBehaviourState): Boolean {
+        if (previous !is BoardState) return false
+        if (previous.sprinting.get() != sprinting.get()) return true
+        if (previous.walking.get() != walking.get()) return true
+        if (previous.sprintToggleable.get() != sprintToggleable.get()) return true
+        if (previous.inAir.get() != inAir.get()) return true
+        if (previous.surfDist.get() != surfDist.get()) return true
+        return super.shouldSync(previous)
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/types/air/GliderBehaviour.kt

@@ -10,7 +10,6 @@ package com.cobblemon.mod.common.api.riding.behaviour.types.air
 
 import com.bedrockk.molang.Expression
 import com.cobblemon.mod.common.CobblemonRideSettings
-import com.cobblemon.mod.common.OrientationControllable
 import com.cobblemon.mod.common.api.riding.RidingStyle
 import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviourState
 import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviour
@@ -19,11 +18,11 @@ import com.cobblemon.mod.common.api.riding.posing.PoseOption
 import com.cobblemon.mod.common.api.riding.posing.PoseProvider
 import com.cobblemon.mod.common.api.riding.sound.RideSoundSettingsList
 import com.cobblemon.mod.common.api.riding.stats.RidingStat
+import com.cobblemon.mod.common.api.riding.util.RideFrame
 import com.cobblemon.mod.common.entity.PoseType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.*
 import net.minecraft.network.RegistryFriendlyByteBuf
-import net.minecraft.util.SmoothDouble
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.player.Player
 import net.minecraft.world.phys.Vec2
@@ -67,7 +66,18 @@ class GliderBehaviour : RidingBehaviour<GliderSettings, RidingBehaviourState> {
         return Vec2(driver.xRot, driver.yRot)
     }
 
+    // This ride works along its yaw so its velocity gets turned into world space here
     override fun velocity(
+        settings: GliderSettings,
+        state: RidingBehaviourState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        input: Vec3
+    ): Vec3 {
+        return RideFrame.yawToWorld(localVelocity(settings, state, vehicle, driver, input), vehicle.yRot)
+    }
+
+    private fun localVelocity(
             settings: GliderSettings,
             state: RidingBehaviourState,
             vehicle: PokemonEntity,
@@ -80,34 +90,6 @@ class GliderBehaviour : RidingBehaviour<GliderSettings, RidingBehaviourState> {
         return Vec3(xVector, yVector, zVector)
     }
 
-    override fun angRollVel(
-            settings: GliderSettings,
-            state: RidingBehaviourState,
-            vehicle: PokemonEntity,
-            driver: Player,
-            deltaTime: Double
-    ): Vec3 {
-        return Vec3.ZERO
-    }
-
-    override fun rotationOnMouseXY(
-            settings: GliderSettings,
-            state: RidingBehaviourState,
-            vehicle: PokemonEntity,
-            driver: Player,
-            mouseY: Double,
-            mouseX: Double,
-            mouseYSmoother: SmoothDouble,
-            mouseXSmoother: SmoothDouble,
-            sensitivity: Double,
-            deltaTime: Double
-    ): Vec3 {
-        if (driver !is OrientationControllable) return Vec3.ZERO
-
-        //Might need to add the smoothing here for default.
-        return Vec3(0.0, mouseY, mouseX)
-    }
-
     override fun canJump(settings: GliderSettings, state: RidingBehaviourState, vehicle: PokemonEntity, driver: Player): Boolean {
         return false
     }
@@ -149,10 +131,6 @@ class GliderBehaviour : RidingBehaviour<GliderSettings, RidingBehaviourState> {
         return 1.0f
     }
 
-    override fun useAngVelSmoothing(settings: GliderSettings, state: RidingBehaviourState, vehicle: PokemonEntity): Boolean {
-        return false
-    }
-
     override fun inertia(settings: GliderSettings, state: RidingBehaviourState, vehicle: PokemonEntity): Double {
         return 0.5
     }

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/types/air/HelicopterBehaviour.kt

@@ -13,6 +13,7 @@ import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.CobblemonRideSettings
 import com.cobblemon.mod.common.OrientationControllable
 import com.cobblemon.mod.common.api.riding.RidingStyle
+import com.cobblemon.mod.common.api.riding.behaviour.RideSteerInput
 import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviour
 import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviourSettings
 import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviourState
@@ -20,6 +21,7 @@ import com.cobblemon.mod.common.api.riding.posing.PoseOption
 import com.cobblemon.mod.common.api.riding.posing.PoseProvider
 import com.cobblemon.mod.common.api.riding.sound.RideSoundSettingsList
 import com.cobblemon.mod.common.api.riding.stats.RidingStat
+import com.cobblemon.mod.common.api.riding.util.RideFrame
 import com.cobblemon.mod.common.entity.PoseType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.blockPositionsAsListRounded
@@ -91,12 +93,23 @@ class HelicopterBehaviour : RidingBehaviour<HelicopterSettings, RidingBehaviourS
         return Vec2(driver.xRot * 0.5f, driver.yRot)
     }
 
+    // This ride works along its yaw so its velocity gets turned into world space here
     override fun velocity(
         settings: HelicopterSettings,
         state: RidingBehaviourState,
         vehicle: PokemonEntity,
         driver: Player,
         input: Vec3
+    ): Vec3 {
+        return RideFrame.yawToWorld(localVelocity(settings, state, vehicle, driver, input), vehicle.yRot)
+    }
+
+    private fun localVelocity(
+        settings: HelicopterSettings,
+        state: RidingBehaviourState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        input: Vec3
     ): Vec3 {
         val runtime = vehicle.runtime
 
@@ -120,7 +133,7 @@ class HelicopterBehaviour : RidingBehaviour<HelicopterSettings, RidingBehaviourS
         return Vec3(xVel, yVel, zVel)
     }
 
-    override fun angRollVel(
+    private fun rotationOverTime(
         settings: HelicopterSettings,
         state: RidingBehaviourState,
         vehicle: PokemonEntity,
@@ -175,7 +188,18 @@ class HelicopterBehaviour : RidingBehaviour<HelicopterSettings, RidingBehaviourS
         return Vec3(0.0, 0.0, 0.0)
     }
 
-    override fun rotationOnMouseXY(
+    override fun steer(
+        settings: HelicopterSettings,
+        state: RidingBehaviourState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        input: RideSteerInput
+    ) {
+        input.rotate(mouseRotation(settings, state, vehicle, driver, input.mousePitch, input.mouseYaw, input.mouseYSmoother, input.mouseXSmoother, input.sensitivity, input.deltaTime))
+        input.rotateSmoothed(rotationOverTime(settings, state, vehicle, driver, input.deltaTime))
+    }
+
+    private fun mouseRotation(
         settings: HelicopterSettings,
         state: RidingBehaviourState,
         vehicle: PokemonEntity,
@@ -241,10 +265,6 @@ class HelicopterBehaviour : RidingBehaviour<HelicopterSettings, RidingBehaviourS
         return 1.0f
     }
 
-    override fun useAngVelSmoothing(settings: HelicopterSettings, state: RidingBehaviourState, vehicle: PokemonEntity): Boolean {
-        return true
-    }
-
     override fun inertia(settings: HelicopterSettings, state: RidingBehaviourState, vehicle: PokemonEntity): Double {
         return 0.1
     }

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/types/air/HoverBehaviour.kt

@@ -18,6 +18,7 @@ import com.cobblemon.mod.common.api.riding.posing.PoseOption
 import com.cobblemon.mod.common.api.riding.posing.PoseProvider
 import com.cobblemon.mod.common.api.riding.sound.RideSoundSettingsList
 import com.cobblemon.mod.common.api.riding.stats.RidingStat
+import com.cobblemon.mod.common.api.riding.util.RideFrame
 import com.cobblemon.mod.common.entity.PoseType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.*
@@ -26,7 +27,6 @@ import net.minecraft.client.Minecraft
 import net.minecraft.network.FriendlyByteBuf
 import net.minecraft.network.RegistryFriendlyByteBuf
 import net.minecraft.util.Mth
-import net.minecraft.util.SmoothDouble
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.player.Player
 import net.minecraft.world.level.ClipContext
@@ -190,12 +190,23 @@ class HoverBehaviour : RidingBehaviour<HoverSettings, HoverState> {
         return rotAmount
     }
 
+    // This ride works along its yaw so its velocity gets turned into world space here
     override fun velocity(
         settings: HoverSettings,
         state: HoverState,
         vehicle: PokemonEntity,
         driver: Player,
         input: Vec3
+    ): Vec3 {
+        return RideFrame.yawToWorld(localVelocity(settings, state, vehicle, driver, input), vehicle.yRot)
+    }
+
+    private fun localVelocity(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        input: Vec3
     ): Vec3 {
         val retVel = calculateRideSpaceVel(settings, state, vehicle, driver)
         state.rideVelocity.set(retVel)
@@ -283,31 +294,6 @@ class HoverBehaviour : RidingBehaviour<HoverSettings, HoverState> {
         return newVelocity
     }
 
-    override fun angRollVel(
-        settings: HoverSettings,
-        state: HoverState,
-        vehicle: PokemonEntity,
-        driver: Player,
-        deltaTime: Double
-    ): Vec3 {
-        return Vec3.ZERO
-    }
-
-    override fun rotationOnMouseXY(
-        settings: HoverSettings,
-        state: HoverState,
-        vehicle: PokemonEntity,
-        driver: Player,
-        mouseY: Double,
-        mouseX: Double,
-        mouseYSmoother: SmoothDouble,
-        mouseXSmoother: SmoothDouble,
-        sensitivity: Double,
-        deltaTime: Double
-    ): Vec3 {
-        return Vec3.ZERO
-    }
-
     override fun canJump(
         settings: HoverSettings,
         state: HoverState,
@@ -355,14 +341,6 @@ class HoverBehaviour : RidingBehaviour<HoverSettings, HoverState> {
         return if (state.isBoosting.get()) 1.1f else 1.0f
     }
 
-    override fun useAngVelSmoothing(
-        settings: HoverSettings,
-        state: HoverState,
-        vehicle: PokemonEntity
-    ): Boolean {
-        return false
-    }
-
     override fun inertia(
         settings: HoverSettings,
         state: HoverState,

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/types/air/JetBehaviour.kt

@@ -15,6 +15,7 @@ import com.cobblemon.mod.common.CobblemonRideSettings
 import com.cobblemon.mod.common.OrientationControllable
 import com.cobblemon.mod.common.api.molang.ObjectValue
 import com.cobblemon.mod.common.api.riding.RidingStyle
+import com.cobblemon.mod.common.api.riding.behaviour.RideSteerInput
 import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviour
 import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviourSettings
 import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviourState
@@ -28,7 +29,6 @@ import com.cobblemon.mod.common.entity.PoseType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.blockPositionsAsListRounded
 import com.cobblemon.mod.common.util.cobblemonResource
-import com.cobblemon.mod.common.util.math.geometry.toRadians
 import com.cobblemon.mod.common.util.readNullableExpression
 import com.cobblemon.mod.common.util.readRidingStats
 import com.cobblemon.mod.common.util.resolveDouble
@@ -176,7 +176,7 @@ class JetBehaviour : RidingBehaviour<JetSettings, JetState> {
             (state.rideVelocity.get().y).toFloat(),
             state.rideVelocity.get().z.toFloat() * -1.0f // Flip the z axis to make this left handed? orr.. right handed? idk, flip it though
         )
-        var worldVelVec = localVelVec.mul(controller.orientation).toVec3d().yRot(vehicle.yRot.toRadians()) // Unrotate preemptively as this vector gets rotate later down the line in MC logic.
+        var worldVelVec = localVelVec.mul(controller.orientation).toVec3d()
         worldVelVec =  Vec3(
             worldVelVec.x,
             worldVelVec.y * (1 - (state.noStamTickCnt.get() / penaltyDeccel).coerceIn(0.0f, 1.0f)), // Dampen the upwards movement depending on stamina depletion time
@@ -266,7 +266,7 @@ class JetBehaviour : RidingBehaviour<JetSettings, JetState> {
 
     }
 
-    override fun angRollVel(
+    private fun rotationOverTime(
         settings: JetSettings,
         state: JetState,
         vehicle: PokemonEntity,
@@ -292,7 +292,18 @@ class JetBehaviour : RidingBehaviour<JetSettings, JetState> {
         return Vec3(yawForce, 0.0, 0.0)
     }
 
-    override fun rotationOnMouseXY(
+    override fun steer(
+        settings: JetSettings,
+        state: JetState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        input: RideSteerInput
+    ) {
+        input.rotate(mouseRotation(settings, state, vehicle, driver, input.mousePitch, input.mouseYaw, input.mouseYSmoother, input.mouseXSmoother, input.sensitivity, input.deltaTime))
+        input.rotateSmoothed(rotationOverTime(settings, state, vehicle, driver, input.deltaTime))
+    }
+
+    private fun mouseRotation(
         settings: JetSettings,
         state: JetState,
         vehicle: PokemonEntity,
@@ -390,10 +401,6 @@ class JetBehaviour : RidingBehaviour<JetSettings, JetState> {
         }
     }
 
-    override fun useAngVelSmoothing(settings: JetSettings, state: JetState, vehicle: PokemonEntity): Boolean {
-        return true
-    }
-
     override fun inertia(settings: JetSettings, state: JetState, vehicle: PokemonEntity): Double {
         return 1.0
     }

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/types/air/RocketBehaviour.kt

@@ -19,6 +19,7 @@ import com.cobblemon.mod.common.api.riding.posing.PoseOption
 import com.cobblemon.mod.common.api.riding.posing.PoseProvider
 import com.cobblemon.mod.common.api.riding.sound.RideSoundSettingsList
 import com.cobblemon.mod.common.api.riding.stats.RidingStat
+import com.cobblemon.mod.common.api.riding.util.RideFrame
 import com.cobblemon.mod.common.entity.PoseType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.*
@@ -27,7 +28,6 @@ import net.minecraft.client.Minecraft
 import net.minecraft.network.FriendlyByteBuf
 import net.minecraft.network.RegistryFriendlyByteBuf
 import net.minecraft.util.Mth
-import net.minecraft.util.SmoothDouble
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.player.Player
 import net.minecraft.world.phys.Vec2
@@ -75,15 +75,19 @@ class RocketBehaviour : RidingBehaviour<RocketSettings, RocketState> {
         vehicle: PokemonEntity,
         driver: Player
     ): Float {
-        // Use this as a "tick" function and check to see if the driver is "boosting"
-        if (vehicle.level().isClientSide) {
-            handleBoosting(settings, state, vehicle, driver)
-            tickStamina(settings, state, vehicle, driver)
-        }
-
         return state.rideVelocity.get().length().toFloat()
     }
 
+    override fun driverTick(
+        settings: RocketSettings,
+        state: RocketState,
+        vehicle: PokemonEntity,
+        driver: Player
+    ) {
+        handleBoosting(settings, state, vehicle, driver)
+        tickStamina(settings, state, vehicle, driver)
+    }
+
     fun handleBoosting(
         settings: RocketSettings,
         state: RocketState,
@@ -208,12 +212,23 @@ class RocketBehaviour : RidingBehaviour<RocketSettings, RocketState> {
     }
 
 
+    // This ride works along its yaw so its velocity gets turned into world space here
     override fun velocity(
         settings: RocketSettings,
         state: RocketState,
         vehicle: PokemonEntity,
         driver: Player,
         input: Vec3
+    ): Vec3 {
+        return RideFrame.yawToWorld(localVelocity(settings, state, vehicle, driver, input), vehicle.yRot)
+    }
+
+    private fun localVelocity(
+        settings: RocketSettings,
+        state: RocketState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        input: Vec3
     ): Vec3 {
         val retVel = calculateRideSpaceVel(settings, state, vehicle, driver)
         state.rideVelocity.set(retVel)
@@ -318,37 +333,6 @@ class RocketBehaviour : RidingBehaviour<RocketSettings, RocketState> {
         return newVelocity
     }
 
-    override fun angRollVel(
-        settings: RocketSettings,
-        state: RocketState,
-        vehicle: PokemonEntity,
-        driver: Player,
-        deltaTime: Double
-    ): Vec3 {
-        return Vec3.ZERO
-    }
-
-    override fun rotationOnMouseXY(
-        settings: RocketSettings,
-        state: RocketState,
-        vehicle: PokemonEntity,
-        driver: Player,
-        mouseY: Double,
-        mouseX: Double,
-        mouseYSmoother: SmoothDouble,
-        mouseXSmoother: SmoothDouble,
-        sensitivity: Double,
-        deltaTime: Double
-    ): Vec3 {
-        //Smooth out mouse input.
-        val smoothingSpeed = 4
-        val xInput = mouseXSmoother.getNewDeltaValue(mouseX * 0.1, deltaTime * smoothingSpeed);
-        val yInput = mouseYSmoother.getNewDeltaValue(mouseY * 0.1, deltaTime * smoothingSpeed);
-
-        //yaw, pitch, roll
-        return Vec3(0.0, yInput, xInput)
-    }
-
     override fun canJump(
         settings: RocketSettings,
         state: RocketState,
@@ -403,14 +387,6 @@ class RocketBehaviour : RidingBehaviour<RocketSettings, RocketState> {
         }
     }
 
-    override fun useAngVelSmoothing(
-        settings: RocketSettings,
-        state: RocketState,
-        vehicle: PokemonEntity
-    ): Boolean {
-        return false
-    }
-
     override fun inertia(
         settings: RocketSettings,
         state: RocketState,

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/types/composite/CompositeBehaviour.kt

@@ -11,6 +11,10 @@ package com.cobblemon.mod.common.api.riding.behaviour.types.composite
 import com.cobblemon.mod.common.api.riding.RidingStyle
 import com.cobblemon.mod.common.api.riding.behaviour.*
 import com.cobblemon.mod.common.api.riding.behaviour.types.composite.strategies.CompositeRidingStrategies
+import com.cobblemon.mod.common.api.riding.camera.RideCameraContext
+import com.cobblemon.mod.common.api.riding.camera.RideLookInput
+import com.cobblemon.mod.common.api.riding.camera.RideLookTake
+import com.cobblemon.mod.common.api.riding.camera.RideLookSettings
 import com.cobblemon.mod.common.api.riding.sound.RideSoundSettingsList
 import com.cobblemon.mod.common.api.riding.stats.RidingStat
 import com.cobblemon.mod.common.entity.PoseType
@@ -22,11 +26,11 @@ import com.cobblemon.mod.common.util.writeRidingStats
 import net.minecraft.network.FriendlyByteBuf
 import net.minecraft.network.RegistryFriendlyByteBuf
 import net.minecraft.resources.ResourceLocation
-import net.minecraft.util.SmoothDouble
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.player.Player
 import net.minecraft.world.phys.Vec2
 import net.minecraft.world.phys.Vec3
+import org.joml.Quaternionf
 
 class CompositeBehaviour : RidingBehaviour<CompositeSettings, CompositeState> {
     companion object {
@@ -170,16 +174,6 @@ class CompositeBehaviour : RidingBehaviour<CompositeSettings, CompositeState> {
         }
     }
 
-    override fun useAngVelSmoothing(
-        settings: CompositeSettings,
-        state: CompositeState,
-        vehicle: PokemonEntity
-    ): Boolean {
-        return chooseBehaviour(settings, state) { behaviour, behaviourSettings, behaviourState ->
-            behaviour.useAngVelSmoothing(behaviourSettings, behaviourState, vehicle)
-        }
-    }
-
     override fun rideFovMultiplier(
         settings: CompositeSettings,
         state: CompositeState,
@@ -236,46 +230,6 @@ class CompositeBehaviour : RidingBehaviour<CompositeSettings, CompositeState> {
         }
     }
 
-    override fun rotationOnMouseXY(
-        settings: CompositeSettings,
-        state: CompositeState,
-        vehicle: PokemonEntity,
-        driver: Player,
-        mouseY: Double,
-        mouseX: Double,
-        mouseYSmoother: SmoothDouble,
-        mouseXSmoother: SmoothDouble,
-        sensitivity: Double,
-        deltaTime: Double
-    ): Vec3 {
-        return chooseBehaviour(settings, state) { behaviour, behaviourSettings, behaviourState ->
-            behaviour.rotationOnMouseXY(
-                behaviourSettings,
-                behaviourState,
-                vehicle,
-                driver,
-                mouseY,
-                mouseX,
-                mouseYSmoother,
-                mouseXSmoother,
-                sensitivity,
-                deltaTime
-            )
-        }
-    }
-
-    override fun angRollVel(
-        settings: CompositeSettings,
-        state: CompositeState,
-        vehicle: PokemonEntity,
-        driver: Player,
-        deltaTime: Double
-    ): Vec3 {
-        return chooseBehaviour(settings, state) { behaviour, behaviourSettings, behaviourState ->
-            behaviour.angRollVel(behaviourSettings, behaviourState, vehicle, driver, deltaTime)
-        }
-    }
-
     override fun velocity(
         settings: CompositeSettings,
         state: CompositeState,
@@ -288,6 +242,28 @@ class CompositeBehaviour : RidingBehaviour<CompositeSettings, CompositeState> {
         }
     }
 
+    override fun steer(
+        settings: CompositeSettings,
+        state: CompositeState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        input: RideSteerInput
+    ) {
+        chooseBehaviour(settings, state) { behaviour, behaviourSettings, behaviourState ->
+            behaviour.steer(behaviourSettings, behaviourState, vehicle, driver, input)
+        }
+    }
+
+    override fun velocityRunsTwicePerTick(
+        settings: CompositeSettings,
+        state: CompositeState,
+        vehicle: PokemonEntity
+    ): Boolean {
+        return chooseBehaviour(settings, state) { behaviour, behaviourSettings, behaviourState ->
+            behaviour.velocityRunsTwicePerTick(behaviourSettings, behaviourState, vehicle)
+        }
+    }
+
     override fun rotation(
         settings: CompositeSettings,
         state: CompositeState,
@@ -310,6 +286,17 @@ class CompositeBehaviour : RidingBehaviour<CompositeSettings, CompositeState> {
         }
     }
 
+    override fun driverTick(
+        settings: CompositeSettings,
+        state: CompositeState,
+        vehicle: PokemonEntity,
+        driver: Player
+    ) {
+        chooseBehaviour(settings, state) { behaviour, behaviourSettings, behaviourState ->
+            behaviour.driverTick(behaviourSettings, behaviourState, vehicle, driver)
+        }
+    }
+
     override fun pose(
         settings: CompositeSettings,
         state: CompositeState,
@@ -361,6 +348,49 @@ class CompositeBehaviour : RidingBehaviour<CompositeSettings, CompositeState> {
             behaviour.damageOnCollision(behaviourSettings, behaviourState, vehicle, impactVec)
         }
     }
+
+    override fun cameraBase(
+        settings: CompositeSettings,
+        state: CompositeState,
+        vehicle: PokemonEntity,
+        context: RideCameraContext
+    ): Quaternionf {
+        return chooseBehaviour(settings, state) { behaviour, behaviourSettings, behaviourState ->
+            behaviour.cameraBase(behaviourSettings, behaviourState, vehicle, context)
+        }
+    }
+
+    override fun firstPersonHandRoll(
+        settings: CompositeSettings,
+        state: CompositeState,
+        vehicle: PokemonEntity,
+        context: RideCameraContext
+    ): Float {
+        return chooseBehaviour(settings, state) { behaviour, behaviourSettings, behaviourState ->
+            behaviour.firstPersonHandRoll(behaviourSettings, behaviourState, vehicle, context)
+        }
+    }
+
+    override fun lookSettings(
+        settings: CompositeSettings,
+        state: CompositeState,
+        vehicle: PokemonEntity
+    ): RideLookSettings {
+        return chooseBehaviour(settings, state) { behaviour, behaviourSettings, behaviourState ->
+            behaviour.lookSettings(behaviourSettings, behaviourState, vehicle)
+        }
+    }
+
+    override fun consumeLook(
+        settings: CompositeSettings,
+        state: CompositeState,
+        vehicle: PokemonEntity,
+        input: RideLookInput
+    ): RideLookTake {
+        return chooseBehaviour(settings, state) { behaviour, behaviourSettings, behaviourState ->
+            behaviour.consumeLook(behaviourSettings, behaviourState, vehicle, input)
+        }
+    }
 }
 
 open class CompositeSettings : RidingBehaviourSettings {

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/types/composite/strategies/RunStrategy.kt

@@ -13,6 +13,7 @@ import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviourState
 import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviours
 import com.cobblemon.mod.common.api.riding.behaviour.types.composite.CompositeSettings
 import com.cobblemon.mod.common.api.riding.behaviour.types.composite.CompositeState
+import com.cobblemon.mod.common.api.riding.util.RideFrame
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.cobblemonResource
 import net.minecraft.world.entity.player.Player
@@ -63,7 +64,8 @@ object RunStrategy : CompositeRidingStrategy<CompositeSettings> {
         if (state.activeBehaviour.get() == alternativeSettings.key) return false
         if (state.lastTransition.get() + 20 >= entity.level().gameTime) return false
         val alternativeBehaviour = RidingBehaviours.get(alternativeSettings.key)
-        return driver.isSprinting && input.z > 0.5 && alternativeBehaviour.isActive(alternativeSettings, state.alternateBehaviourState, entity)
+        // Ride velocity is world space so check how much of it is forward
+        return driver.isSprinting && RideFrame.worldToYaw(input, entity.yRot).z > 0.5 && alternativeBehaviour.isActive(alternativeSettings, state.alternateBehaviourState, entity)
     }
 
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/types/land/ClimbBehaviour.kt

@@ -0,0 +1,797 @@
+/*
+ * 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.riding.behaviour.types.land
+
+import com.bedrockk.molang.Expression
+import com.cobblemon.mod.common.CobblemonRideSettings
+import com.cobblemon.mod.common.OrientationControllable
+import com.cobblemon.mod.common.api.orientation.OrientationController
+import com.cobblemon.mod.common.api.orientation.OrientationController.Companion.UP
+import com.cobblemon.mod.common.api.riding.RidingStyle
+import com.cobblemon.mod.common.api.riding.behaviour.*
+import com.cobblemon.mod.common.api.riding.posing.PoseOption
+import com.cobblemon.mod.common.api.riding.posing.PoseProvider
+import com.cobblemon.mod.common.api.riding.util.DistanceFieldLayer
+import com.cobblemon.mod.common.api.riding.util.FieldPrimitive
+import com.cobblemon.mod.common.api.riding.util.PrimitiveShape
+import com.cobblemon.mod.common.api.riding.util.collectPrimitivesFromBlocks
+import com.cobblemon.mod.common.api.riding.util.estimateGradient
+import com.cobblemon.mod.common.api.riding.util.sampleField
+import com.cobblemon.mod.common.api.riding.util.visualizeDistanceField
+import com.cobblemon.mod.common.api.riding.sound.RideSoundSettingsList
+import com.cobblemon.mod.common.api.riding.stats.RidingStat
+import com.cobblemon.mod.common.api.riding.util.DistanceFieldTuning
+import com.cobblemon.mod.common.api.riding.util.RideFrame
+import com.cobblemon.mod.common.entity.PoseType
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.util.*
+import com.cobblemon.mod.common.util.math.geometry.toRadians
+import net.minecraft.core.Direction
+import net.minecraft.core.particles.ParticleTypes
+import net.minecraft.network.FriendlyByteBuf
+import net.minecraft.network.RegistryFriendlyByteBuf
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.util.Mth
+import net.minecraft.util.SmoothDouble
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.ai.attributes.Attributes
+import net.minecraft.world.entity.player.Player
+import net.minecraft.world.phys.AABB
+import net.minecraft.world.phys.Vec2
+import net.minecraft.world.phys.Vec3
+import net.minecraft.world.phys.shapes.Shapes
+import org.joml.Matrix3f
+import org.joml.Quaternionf
+import org.joml.Vector3f
+import kotlin.math.*
+
+class ClimbBehaviour : RidingBehaviour<ClimbSettings, ClimbState> {
+    companion object {
+        val KEY = cobblemonResource("land/climb")
+    }
+
+    override val key = KEY
+
+    override fun getRidingStyle(settings: ClimbSettings, state: ClimbState): RidingStyle {
+        return RidingStyle.LAND
+    }
+
+    val poseProvider = PoseProvider<ClimbSettings, ClimbState>(PoseType.STAND)
+        .with(PoseOption(PoseType.WALK) { _, state, vehicle ->
+            return@PoseOption abs(state.rideVelocity.get().horizontalDistance()) > 0.0
+        })
+
+    override fun isActive(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity
+    ): Boolean {
+        return Shapes.create(vehicle.boundingBox).blockPositionsAsListRounded().any {
+            // Need to check other fluids
+            if (vehicle.isInWater || vehicle.isUnderWater) {
+                return@any false
+            }
+            // This might not actually work, depending on what the yPos actually is. yPos of the middle of the entity? the feet?
+            if (it.y.toDouble() == (vehicle.position().y)) {
+                val blockState = vehicle.level().getBlockState(it.below())
+                return@any !blockState.isAir && blockState.fluidState.isEmpty
+            }
+            true
+        }
+    }
+
+    override fun pose(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity
+    ): PoseType {
+        return this.poseProvider.select(settings, state, vehicle)
+    }
+
+    override fun speed(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity,
+        driver: Player
+    ): Float {
+        return state.rideVelocity.get().length().toFloat()
+    }
+
+    override fun tick(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        input: Vec3
+    ) {
+        handleSprinting(state, driver)
+        inAirCheck(state, vehicle)
+        tickStamina(settings, state, vehicle)
+
+        // attachmentNormal: discrete, physics-facing - which face are we touching, used
+        //   for the sticking force (newDownForce) in velocity().
+        // renderSurfaceNormal: smoothed field-gradient - purely cosmetic, used to slowly
+        //   rotate the model's up vector in rotateOverTime(). The two are intentionally
+        //   separate and should not be conflated.
+        updateAttachment(state, vehicle)
+        updateRenderSurfaceNormal(state, vehicle)
+
+        //TODO: should be a config somewhere
+        val debugVisualizeField = true;
+
+        if (debugVisualizeField && !vehicle.level().isClientSide && vehicle.tickCount % 5 == 0) {
+            visualizeDistanceField(
+                referenceEntity = vehicle,
+                center = vehicle.position().add(0.0, (vehicle.bbHeight * 0.5f).toDouble(), 0.0),
+                layers = listOf(
+                    DistanceFieldLayer(isoValue = 0.0f, color = Vector3f(1f, 0.2f, 0.2f)),
+                    DistanceFieldLayer(isoValue = 1.0f, color = Vector3f(0.2f, 0.6f, 1f))
+                ),
+                horizontalRadius = 2.0,
+                verticalRange = 2.0,
+                sampleSpacing = 0.35,
+                marchStep = 0.15,
+                tuning = DistanceFieldTuning(smoothingRange = 0.5f)
+            )
+        }
+    }
+
+    /**
+     * Computes the smoothed field-gradient normal used for rendering only (up-vector
+     * alignment in rotateOverTime). Cached here at tick rate since collecting primitives
+     * and sampling the field is real work - actually applying the rotation happens
+     * separately at frame rate, same pattern as HorseBehaviour's surfDist/BoardBehaviour's
+     * surfaceNormal.
+     */
+    fun updateRenderSurfaceNormal(state: ClimbState, vehicle: PokemonEntity) {
+        val level = vehicle.level()
+        val center = vehicle.position().add(0.0, (vehicle.bbHeight * 0.5f).toDouble(), 0.0)
+        val horizontalRadius = 1.5
+        val verticalRange = 1.5
+
+        val searchBox = AABB(
+            center.x - horizontalRadius, center.y - verticalRange, center.z - horizontalRadius,
+            center.x + horizontalRadius, center.y + verticalRange, center.z + horizontalRadius
+        )
+
+        val primitives: List<FieldPrimitive> = collectPrimitivesFromBlocks(level, searchBox, PrimitiveShape.ELLIPSOID)
+        if (primitives.isEmpty()) return
+
+        val tuning = DistanceFieldTuning(smoothingRange = 0.5f)
+        val gradient = estimateGradient(primitives, center, tuning)
+        state.renderSurfaceNormal.set(gradient)
+    }
+
+    /** Debug viz: draws a short line of particles from the vehicle out along the current attachment normal. */
+    fun spawnAttachmentNormalParticles(vehicle: PokemonEntity, normal: Vec3) {
+        val level = vehicle.level()
+        if (!level.isClientSide) return
+        if (normal.lengthSqr() < 1e-6) return
+
+        val origin = vehicle.position().add(0.0, (vehicle.bbHeight * 0.5f).toDouble(), 0.0)
+        val length = 1.5
+        val steps = 15
+        for (i in 0..steps) {
+            val t = i.toDouble() / steps
+            val point = origin.add(normal.scale(length * t))
+            level.addParticle(ParticleTypes.END_ROD, point.x, point.y, point.z, 0.0, 0.0, 0.0)
+        }
+    }
+
+    fun inAirCheck(
+        state: ClimbState,
+        vehicle: PokemonEntity,
+    ) {
+        // Check both vertical movement and if there are blocks below.
+        val posBelow = vehicle.blockPosition().below()
+        val blockStateBelow = vehicle.level().getBlockState(posBelow)
+        val isAirOrLiquid = blockStateBelow.isAir || !blockStateBelow.fluidState.isEmpty
+
+        val canSupportEntity = blockStateBelow.isFaceSturdy(vehicle.level(), posBelow, Direction.UP)
+        val standingOnSolid = canSupportEntity && !isAirOrLiquid
+
+        // inAir if not on the ground
+        val inAir = !(vehicle.deltaMovement.y == 0.0 || standingOnSolid)
+        state.inAir.set(inAir)
+    }
+
+    fun handleSprinting(
+        state: ClimbState,
+        driver: Player
+    ) {
+        if (state.sprinting.get()) {
+            state.sprinting.set(driver.isSprinting && state.stamina.get() > 0.0f)
+        } else {
+            // Only allow sprinting to start if over x percentage of stamina left
+            val stamSprintPerc = 25.0f
+            state.sprinting.set(driver.isSprinting && state.stamina.get() > stamSprintPerc / 100.0f)
+        }
+    }
+
+    fun tickStamina(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity,
+    ) {
+        val stam = state.stamina.get()
+        var newStam = stam
+        val stamDrainRate = (1.0f / vehicle.runtime.resolveDouble(settings.staminaExpr)).toFloat() / 20.0f
+
+        if (state.sprinting.get()) {
+            newStam = max(0.0f,stam - stamDrainRate)
+
+        } else {
+            newStam = min(1.0f,stam + stamDrainRate * 4)
+        }
+
+        state.stamina.set(newStam)
+    }
+
+    override fun updatePassengerRotation(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity,
+        driver: LivingEntity
+    ) { return }
+
+    override fun clampPassengerRotation(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity,
+        driver: LivingEntity
+    ) { }
+
+
+    override fun rotation(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity,
+        driver: LivingEntity
+    ): Vec2 {
+        return Vec2(vehicle.xRot, vehicle.yRot )
+
+    }
+
+    /*
+   *  Calculates the rotation amount given the difference between
+   *  the current player y rot and entity y rot. This gives the
+   *  affect of influencing a rides rotation through the mouse
+   *  without it being instant.
+   *
+   * THIS IS ADAPTED FOR 3D ORIENTATION
+   */
+    fun calcRotAmount(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity,
+        driver: LivingEntity
+    ): Float {
+        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr)
+        val handling = vehicle.runtime.resolveDouble(settings.handlingExpr)
+        val walkHandlingBoost = 5
+        val maxYawDiff = vehicle.runtime.resolveFloat(settings.lookYawLimit)
+
+        // Normalize the current rotation diff
+        val controller = (vehicle as? OrientationControllable)?.orientationController
+        if (controller == null || controller.orientation == null) return 0.0f
+
+        val rotDiff = Mth.wrapDegrees(Mth.wrapDegrees(driver.yRot) - controller.yaw).coerceIn(-maxYawDiff,maxYawDiff)
+        val rotDiffNorm = rotDiff / maxYawDiff
+
+        // Take the square root so that the ride levels out quicker when at lower differences between entity
+        // y and driver y
+        // This influences the speed of the turn based on how far in one direction you're looking
+        val minRotMod = 0.4f // Min speed that the rotation modulation converges towards
+        val rotDiffMod = ((sqrt(abs(rotDiffNorm)) * (1.0f - minRotMod)) + minRotMod) * rotDiffNorm.sign
+
+        // Turn rate should be quick when walking and slower when sprinting.
+        // Smoothly move between these based on speed
+        val walkSpeed = getWalkSpeed(vehicle)
+        val w = max(walkSpeed, vehicle.deltaMovement.horizontalDistance())
+        val invRelSpeed = (RidingBehaviour.scaleToRange(w, walkSpeed, topSpeed ) - 1.0f) * -1.0f
+        val turnRate = ((handling.toFloat() / 20.0f) * max(walkHandlingBoost * invRelSpeed, 1.0)).toFloat()
+
+        // Ensure you only ever rotate as much difference as there is between the angles.
+        val turnSpeed = turnRate * rotDiffMod
+        val rotAmount = turnSpeed.coerceIn(-abs(rotDiff), abs(rotDiff))
+
+        return rotAmount
+    }
+
+
+    // This ride works along its yaw so its velocity gets turned into world space here
+    override fun velocity(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        input: Vec3
+    ): Vec3 {
+        return RideFrame.yawToWorld(localVelocity(settings, state, vehicle, driver, input), vehicle.yRot)
+    }
+
+    private fun localVelocity(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        input: Vec3
+    ): Vec3 {
+        state.rideVelocity.set(calculateRideSpaceVel(settings, state, vehicle, driver))
+        return state.rideVelocity.get()
+    }
+
+    private fun calculateRideSpaceVel(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity,
+        driver: Player
+    ): Vec3 {
+        val globalHorse: HorseSettings = CobblemonRideSettings.horse
+        val canSprint = vehicle.runtime.resolveBoolean(settings.canSprint ?: globalHorse.canSprint!!)
+        val canJump = vehicle.runtime.resolveBoolean(settings.canJump ?: globalHorse.canJump!!)
+        val jumpForce = vehicle.runtime.resolveDouble(settings.jumpExpr ?: globalHorse.jumpExpr!!) * 0.75
+        val rideTopSpeed = vehicle.runtime.resolveDouble(settings.speedExpr ?: globalHorse.speedExpr!!)
+        val walkSpeed = getWalkSpeed(vehicle)
+        val topSpeed = if(canSprint && state.sprinting.get()) rideTopSpeed else walkSpeed
+        val accelTime = if(state.sprinting.get()) (vehicle.runtime.resolveDouble(settings.accelerationExpr ?: globalHorse.accelerationExpr!!) * 20.0) else 0.5 * 20.0
+        val accel = topSpeed / accelTime
+        var activeInput = false
+
+        /******************************************************
+         * Gather the previous velocity and check for horizontal
+         * collisions
+         *****************************************************/
+        var newVelocity = state.rideVelocity.get() //.normalize().scale(vehicle.deltaMovement.horizontalDistance())
+
+        /******************************************************
+         * Gather the previous velocity and check for horizontal
+         * collisions
+         *****************************************************/
+        if (vehicle.horizontalCollision) {
+            var horizontalVec = Vec3(newVelocity.x, 0.0, newVelocity.z)
+            horizontalVec = horizontalVec.normalize().scale(min(horizontalVec.length(), 0.3))
+            newVelocity = Vec3(horizontalVec.x, newVelocity.y, horizontalVec.z)
+        }
+
+        /******************************************************
+         * Speed up and slow down based on input
+         *****************************************************/
+        if (driver.zza != 0.0f) {
+
+            // If on a tight turn then do not speed up past half of top speed in order to turn quicker
+            // Also determine how fast to be slowing down based on how far turned you are
+            val lookYawLimit = vehicle.runtime.resolveFloat(settings.lookYawLimit ?: globalHorse.lookYawLimit!!)
+            val percOfMaxTurnSpeed = abs(Mth.wrapDegrees(driver.yRot - vehicle.yRot) / lookYawLimit) * 100.0f
+            val turnPercThresh = 0.0f
+            val s = min(((percOfMaxTurnSpeed - turnPercThresh) / (100.0f - turnPercThresh)).pow(1),1.0f)
+            val effectiveTopSpeed = if (percOfMaxTurnSpeed > turnPercThresh) topSpeed / max(2.0f*s,1.0f) else topSpeed
+            val turningSlowDown = s * 0.1
+
+            //make sure it can't exceed top speed
+            val forwardInput = when {
+                driver.zza > 0 && newVelocity.z > effectiveTopSpeed -> 0.0
+                driver.zza < 0 && newVelocity.z < (-effectiveTopSpeed / 3.0) -> 0.0
+                else -> driver.zza.sign
+            }
+
+            // Add extra friction if trying to slow down to turn faster
+            if (newVelocity.z > effectiveTopSpeed) {
+                newVelocity = newVelocity.subtract(0.0, 0.0, min(turningSlowDown * newVelocity.z.sign, newVelocity.z))
+            }
+
+            newVelocity = Vec3(
+                newVelocity.x,
+                newVelocity.y,
+                (newVelocity.z + (accel * forwardInput.toDouble())))
+
+            activeInput = true
+        }
+
+        /******************************************************
+         * Gravity logic
+         *****************************************************/
+        val isOnTopSurface = state.attachmentNormal.get() == Vec3(0.0, 1.0, 0.0)
+        if (isOnTopSurface) {
+            if (!vehicle.onGround() && state.jumpTicks.get() <= 0) {
+                val gravity = (9.8 / ( 20.0)) * 0.2 * 0.6
+                val terminalVel = 2.0
+                newVelocity = Vec3(newVelocity.x, max(newVelocity.y - gravity, -terminalVel), newVelocity.z)
+            } else if(vehicle.onGround()) {
+                newVelocity = Vec3(newVelocity.x, 0.0, newVelocity.z)
+            }
+        } else {
+            // Wall/ceiling - small constant pull to stay stuck, not real gravity.
+            val stickForce = 0.08
+            newVelocity = Vec3(newVelocity.x, newVelocity.y - stickForce, newVelocity.z)
+        }
+
+
+        /******************************************************
+         * Ground Friction
+         *****************************************************/
+        if( (newVelocity.horizontalDistance() > 0 && vehicle.onGround() && !activeInput) || newVelocity.horizontalDistance() > topSpeed) {
+            newVelocity = newVelocity.subtract(0.0, 0.0, min(0.03 * newVelocity.z.sign, newVelocity.z))
+        }
+
+        /******************************************************
+         * Jump Logic
+         *****************************************************/
+        if (state.jumpTicks.get() > 0 || (state.jumpTicks.get() >= 0 && driver.jumping && vehicle.onGround() && canJump && driver.deltaMovement.y <= 0.1)) {
+            // Spread out jumpforce so that variable height jumps are possible
+            val jumpInputTicks = 6
+            if (driver.jumping && (state.jumpTicks.get() >= 0 && state.jumpTicks.get() < jumpInputTicks)) {
+                val appliedJumpForce = ((jumpForce*1.5) / jumpInputTicks) //* (1 - state.jumpTicks.get() / jumpInputTicks)
+                newVelocity = Vec3(newVelocity.x, newVelocity.y + appliedJumpForce, newVelocity.z)
+                state.jumpTicks.set(state.jumpTicks.get() + 1)
+            } else {
+                // Set delay before next jump is possible after hitting ground
+                val tickJumpDelay = 3
+                state.jumpTicks.set(-tickJumpDelay)
+            }
+        } else if (vehicle.onGround() && state.jumpTicks.get() < 0) {
+            // Tick off the delay once reaching the ground
+            state.jumpTicks.set(state.jumpTicks.get() + 1)
+        }
+
+        // Zero out lateral velocity possibly picked up from a controller transition
+        newVelocity = Vec3(0.0, newVelocity.y, newVelocity.z)
+
+
+        return newVelocity
+    }
+
+    private fun getWalkSpeed( vehicle: PokemonEntity ): Double {
+        val walkspeed = vehicle.runtime.resolveDouble(vehicle.behaviour.moving.walk.walkSpeed)
+        val movementSpeed = vehicle.attributes.getValue(Attributes.MOVEMENT_SPEED)
+        val speedModifier = 1.2 * 0.35
+        return walkspeed * movementSpeed * speedModifier
+
+    }
+
+    private fun rotateOverTime(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        deltaTime: Double
+    ) {
+        if (vehicle !is OrientationControllable) return
+        val controller = vehicle.orientationController
+
+        // Smoothly rotate the model's up vector toward the (separately computed,
+        // smoothed) field-gradient normal. Purely cosmetic - does not affect attachment
+        // or movement, which are driven by state.attachmentNormal instead.
+        val upAlignmentRatePerTick = 0.2
+        val frameBlend = 1.0 - (1.0 - upAlignmentRatePerTick).pow(deltaTime * 20.0)
+        alignUpToSurfaceNormal(controller, state.renderSurfaceNormal.get(), frameBlend.toFloat())
+
+    }
+
+    /**
+     * Rotates [controller]'s orientation so its up vector moves a fraction of the way
+     * toward [targetUp] - partial per call, not instant, so alignment settles smoothly
+     * rather than snapping every time the target changes.
+     */
+    private fun alignUpToSurfaceNormal(controller: OrientationController, targetUp: Vec3, alignmentBlend: Float) {
+        if (targetUp.lengthSqr() < 1e-6) return
+        val targetUpVec = Vector3f(targetUp.x.toFloat(), targetUp.y.toFloat(), targetUp.z.toFloat()).normalize()
+
+        controller.updateOrientation { current ->
+            val currentUp = current.transform(Vector3f(UP), Vector3f())
+            if (currentUp.lengthSquared() < 1e-6f) return@updateOrientation current
+
+            // Full rotation that would exactly align currentUp to targetUp...
+            val fullCorrection = Quaternionf().rotationTo(currentUp, targetUpVec)
+            // ...but only take a partial step toward it, so alignment is smooth, not instant.
+            val steppedCorrection = Quaternionf().slerp(fullCorrection, alignmentBlend)
+
+            Matrix3f().set(steppedCorrection).mul(current, Matrix3f())
+        }
+    }
+
+    override fun steer(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        input: RideSteerInput
+    ) {
+        input.rotate(mouseRotation(settings, state, vehicle, driver, input.mousePitch, input.mouseYaw, input.mouseYSmoother, input.mouseXSmoother, input.sensitivity, input.deltaTime))
+        rotateOverTime(settings, state, vehicle, driver, input.deltaTime)
+    }
+
+    private fun mouseRotation(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        mouseY: Double,
+        mouseX: Double,
+        mouseYSmoother: SmoothDouble,
+        mouseXSmoother: SmoothDouble,
+        sensitivity: Double,
+        deltaTime: Double
+    ): Vec3 {
+        if (vehicle !is OrientationControllable) return Vec3.ZERO
+        val vehicleController = vehicle.orientationController
+
+        val smoothingSpeed = 4
+        val xInput = mouseXSmoother.getNewDeltaValue(mouseX * 0.1, deltaTime * smoothingSpeed)
+        val yInput = mouseYSmoother.getNewDeltaValue(mouseY * 0.1, deltaTime * smoothingSpeed)
+
+        //yaw, pitch, roll
+        return Vec3(xInput, 0.0, 0.0)
+    }
+
+
+    override fun canJump(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity,
+        driver: Player
+    ): Boolean {
+        return false
+    }
+
+    override fun setRideBar(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity,
+        driver: Player
+    ): Float {
+        return (state.stamina.get() / 1.0f)
+    }
+
+    override fun jumpForce(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        jumpStrength: Int
+    ): Vec3 {
+        return Vec3.ZERO
+    }
+
+    override fun gravity(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity,
+        regularGravity: Double
+    ): Double {
+        return 0.0
+    }
+
+    override fun rideFovMultiplier(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity,
+        driver: Player
+    ): Float {
+        return 1.0f
+    }
+
+    override fun inertia(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity
+    ): Double {
+        return 1.0
+    }
+
+    override fun shouldRoll(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity
+    ): Boolean {
+        return true
+    }
+
+    override fun turnOffOnGround(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity
+    ): Boolean {
+        return false
+    }
+
+    override fun dismountOnShift(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity
+    ): Boolean {
+        return false
+    }
+
+    override fun shouldRotatePokemonHead(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity
+    ): Boolean {
+        return false
+    }
+
+    override fun shouldRotateRiderHead(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity
+    ): Boolean {
+        return true
+    }
+
+    override fun getRideSounds(
+        settings: ClimbSettings,
+        state: ClimbState,
+        vehicle: PokemonEntity
+    ): RideSoundSettingsList {
+        return settings.rideSounds
+    }
+
+    override fun createDefaultState(settings: ClimbSettings) = ClimbState()
+}
+
+class ClimbSettings : RidingBehaviourSettings {
+    override val key = ClimbBehaviour.KEY
+    override val stats = mutableMapOf<RidingStat, IntRange>()
+
+    var canJump = "true".asExpression()
+        private set
+
+    var canSprint = "true".asExpression()
+        private set
+
+    var lookYawLimit = "90.0f".asExpression()
+        private set
+
+    var speedExpr: Expression = "q.get_ride_stats('SPEED', 'LAND', 1.0, 0.4)".asExpression()
+        private set
+
+    // Max accel is a whole 1.0 in 1 second. The conversion in the function below is to convert seconds to ticks
+    var accelerationExpr: Expression =
+        "q.get_ride_stats('ACCELERATION', 'LAND', 0.5, 2.0)".asExpression()
+        private set
+
+    // Between 30 seconds and 10 seconds at the lowest when at full speed.
+    var staminaExpr: Expression = "q.get_ride_stats('STAMINA', 'LAND', 30.0, 10.0)".asExpression()
+        private set
+
+    //Between a one block jump and a six block jump
+    var jumpExpr: Expression = "q.get_ride_stats('JUMP', 'LAND', 1.0, 0.38)".asExpression()
+        private set
+
+    var handlingExpr: Expression = "q.get_ride_stats('SKILL', 'LAND', 180.0, 40.0)".asExpression()
+        private set
+
+    var rideSounds: RideSoundSettingsList = RideSoundSettingsList()
+
+    override fun encode(buffer: RegistryFriendlyByteBuf) {
+        buffer.writeResourceLocation(key)
+        buffer.writeRidingStats(stats)
+        rideSounds.encode(buffer)
+        buffer.writeExpression(speedExpr)
+        buffer.writeExpression(accelerationExpr)
+        buffer.writeExpression(staminaExpr)
+        buffer.writeExpression(jumpExpr)
+        buffer.writeExpression(handlingExpr)
+        buffer.writeExpression(canJump)
+        buffer.writeExpression(canSprint)
+    }
+
+    override fun decode(buffer: RegistryFriendlyByteBuf) {
+        stats.putAll(buffer.readRidingStats())
+        rideSounds = RideSoundSettingsList.decode(buffer)
+        speedExpr = buffer.readExpression()
+        accelerationExpr = buffer.readExpression()
+        staminaExpr = buffer.readExpression()
+        jumpExpr = buffer.readExpression()
+        handlingExpr = buffer.readExpression()
+        canJump = buffer.readExpression()
+        canSprint = buffer.readExpression()
+    }
+}
+
+class ClimbState : RidingBehaviourState() {
+    var sprinting = ridingState(false, Side.CLIENT)
+    var inAir = ridingState(false, Side.CLIENT)
+    var jumpTicks = ridingState(0, Side.CLIENT)
+
+    // Discrete, physics-facing: which of the 6 faces we're attached to right now.
+    // Drives newDownForce in velocity(). Set by updateAttachment().
+    var attachmentNormal = ridingState(Vec3(0.0, 1.0, 0.0), Side.CLIENT)
+    var attachmentPoint = ridingState(Vec3(0.0, 1.0, 0.0), Side.CLIENT)
+
+    // Smoothed, rendering-facing: the field-gradient normal used only to slowly rotate
+    // the model's visual up vector in rotateOverTime(). Deliberately separate from
+    // attachmentNormal - see comments in tick(). Set by updateRenderSurfaceNormal().
+    var renderSurfaceNormal = ridingState(Vec3(0.0, 1.0, 0.0), Side.CLIENT)
+
+    override fun encode(buffer: FriendlyByteBuf) {
+        super.encode(buffer)
+        buffer.writeBoolean(sprinting.get())
+        buffer.writeBoolean(inAir.get())
+        buffer.writeInt(jumpTicks.get())
+    }
+
+    override fun decode(buffer: FriendlyByteBuf) {
+        super.decode(buffer)
+        sprinting.set(buffer.readBoolean(), forced = true)
+        inAir.set(buffer.readBoolean(), forced = true)
+        jumpTicks.set(buffer.readInt(), forced = true)
+    }
+
+    override fun reset() {
+        super.reset()
+        sprinting.set(false, forced = true)
+        inAir.set(false, forced = true)
+        jumpTicks.set(0, forced = true)
+        attachmentNormal.set(Vec3(0.0, 1.0, 0.0), forced = true)
+        attachmentPoint.set(Vec3(0.0, 1.0, 0.0), forced = true)
+        renderSurfaceNormal.set(Vec3(0.0, 1.0, 0.0), forced = true)
+    }
+
+    override fun copy() = ClimbState().also {
+        it.rideVelocity.set(this.rideVelocity.get(), forced = true)
+        it.stamina.set(this.stamina.get(), forced = true)
+        it.sprinting.set(this.sprinting.get(), forced = true)
+        it.inAir.set(this.inAir.get(), forced = true)
+        it.jumpTicks.set(this.jumpTicks.get(), forced = true)
+        it.attachmentNormal.set(this.attachmentNormal.get(), forced = true)
+        it.attachmentPoint.set(this.attachmentNormal.get(), forced = true)
+        it.renderSurfaceNormal.set(this.renderSurfaceNormal.get(), forced = true)
+    }
+
+    override fun shouldSync(previous: RidingBehaviourState): Boolean {
+        if (previous !is ClimbState) return false
+        if (previous.sprinting.get() != sprinting.get()) return true
+        if (previous.inAir.get() != inAir.get()) return true
+        return super.shouldSync(previous)
+    }
+}
+
+fun updateAttachment(state: ClimbState, vehicle: PokemonEntity) {
+    val probeMargin = 0.15
+    val currentFace = AttachmentFace.entries.firstOrNull { it.normal == state.attachmentNormal.get() }
+    val face = determineAttachmentFace(vehicle, currentFace, probeMargin)
+    if (face != null) {
+        state.attachmentNormal.set(face.normal)
+    }
+    // face == null means nothing's currently in reach - leave attachmentNormal as
+    // whatever it last was until the jump/detach state takes over.
+}
+
+enum class AttachmentFace(val normal: Vec3) {
+    UP(Vec3(0.0, 1.0, 0.0)),
+    DOWN(Vec3(0.0, -1.0, 0.0)),
+    NORTH(Vec3(0.0, 0.0, -1.0)),
+    SOUTH(Vec3(0.0, 0.0, 1.0)),
+    EAST(Vec3(1.0, 0.0, 0.0)),
+    WEST(Vec3(-1.0, 0.0, 0.0))
+}
+
+/** Thin slab test on one face of the vehicle's actual bounding box - true if anything solid is touching that side. */
+fun probeFaceContact(vehicle: PokemonEntity, face: AttachmentFace, probeMargin: Double): Boolean {
+    val box = vehicle.boundingBox
+    val testBox = when (face) {
+        AttachmentFace.UP    -> AABB(box.minX, box.maxY, box.minZ, box.maxX, box.maxY + probeMargin, box.maxZ)
+        AttachmentFace.DOWN  -> AABB(box.minX, box.minY - probeMargin, box.minZ, box.maxX, box.minY, box.maxZ)
+        AttachmentFace.NORTH -> AABB(box.minX, box.minY, box.minZ - probeMargin, box.maxX, box.maxY, box.minZ)
+        AttachmentFace.SOUTH -> AABB(box.minX, box.minY, box.maxZ, box.maxX, box.maxY, box.maxZ + probeMargin)
+        AttachmentFace.EAST  -> AABB(box.maxX, box.minY, box.minZ, box.maxX + probeMargin, box.maxY, box.maxZ)
+        AttachmentFace.WEST  -> AABB(box.minX - probeMargin, box.minY, box.minZ, box.minX, box.maxY, box.maxZ)
+    }
+    return !vehicle.level().noCollision(vehicle, testBox)
+}
+
+/** Stays on the current face if it's still touching, otherwise scans for a new one. */
+fun determineAttachmentFace(vehicle: PokemonEntity, currentFace: AttachmentFace?, probeMargin: Double): AttachmentFace? {
+    if (currentFace != null && probeFaceContact(vehicle, currentFace, probeMargin)) {
+        return currentFace
+    }
+    return AttachmentFace.entries.firstOrNull { probeFaceContact(vehicle, it, probeMargin) }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/types/land/HorseBehaviour.kt

@@ -22,6 +22,7 @@ import com.cobblemon.mod.common.api.riding.posing.PoseOption
 import com.cobblemon.mod.common.api.riding.posing.PoseProvider
 import com.cobblemon.mod.common.api.riding.sound.RideSoundSettingsList
 import com.cobblemon.mod.common.api.riding.stats.RidingStat
+import com.cobblemon.mod.common.api.riding.util.RideFrame
 import com.cobblemon.mod.common.entity.PoseType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.blockPositionsAsListRounded
@@ -44,7 +45,6 @@ import net.minecraft.core.Direction
 import net.minecraft.network.FriendlyByteBuf
 import net.minecraft.network.RegistryFriendlyByteBuf
 import net.minecraft.util.Mth
-import net.minecraft.util.SmoothDouble
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.ai.attributes.Attributes
 import net.minecraft.world.entity.player.Player
@@ -267,12 +267,23 @@ class HorseBehaviour : RidingBehaviour<HorseSettings, HorseState> {
     }
 
 
+    // This ride works along its yaw so its velocity gets turned into world space here
     override fun velocity(
         settings: HorseSettings,
         state: HorseState,
         vehicle: PokemonEntity,
         driver: Player,
         input: Vec3
+    ): Vec3 {
+        return RideFrame.yawToWorld(localVelocity(settings, state, vehicle, driver, input), vehicle.yRot)
+    }
+
+    private fun localVelocity(
+        settings: HorseSettings,
+        state: HorseState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        input: Vec3
     ): Vec3 {
             state.rideVelocity.set(calculateRideSpaceVel(settings, state, vehicle, driver))
             return state.rideVelocity.get()
@@ -398,37 +409,6 @@ class HorseBehaviour : RidingBehaviour<HorseSettings, HorseState> {
 
     }
 
-    override fun angRollVel(
-        settings: HorseSettings,
-        state: HorseState,
-        vehicle: PokemonEntity,
-        driver: Player,
-        deltaTime: Double
-    ): Vec3 {
-        return Vec3.ZERO
-    }
-
-    override fun rotationOnMouseXY(
-        settings: HorseSettings,
-        state: HorseState,
-        vehicle: PokemonEntity,
-        driver: Player,
-        mouseY: Double,
-        mouseX: Double,
-        mouseYSmoother: SmoothDouble,
-        mouseXSmoother: SmoothDouble,
-        sensitivity: Double,
-        deltaTime: Double
-    ): Vec3 {
-        //Smooth out mouse input.
-        val smoothingSpeed = 4
-        val xInput = mouseXSmoother.getNewDeltaValue(mouseX * 0.1, deltaTime * smoothingSpeed);
-        val yInput = mouseYSmoother.getNewDeltaValue(mouseY * 0.1, deltaTime * smoothingSpeed);
-
-        //yaw, pitch, roll
-        return Vec3(0.0, yInput, xInput)
-    }
-
     override fun canJump(
         settings: HorseSettings,
         state: HorseState,
@@ -475,14 +455,6 @@ class HorseBehaviour : RidingBehaviour<HorseSettings, HorseState> {
         return if (state.sprinting.get()) 1.15f else 1.0f
     }
 
-    override fun useAngVelSmoothing(
-        settings: HorseSettings,
-        state: HorseState,
-        vehicle: PokemonEntity
-    ): Boolean {
-        return false
-    }
-
     override fun inertia(
         settings: HorseSettings,
         state: HorseState,

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/types/land/MinekartBehaviour.kt

@@ -12,7 +12,6 @@ import com.bedrockk.molang.Expression
 import com.bedrockk.molang.runtime.MoLangMath.lerp
 import com.bedrockk.molang.runtime.value.DoubleValue
 import com.cobblemon.mod.common.CobblemonRideSettings
-import com.cobblemon.mod.common.OrientationControllable
 import com.cobblemon.mod.common.api.molang.ObjectValue
 import com.cobblemon.mod.common.api.riding.RidingStyle
 import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviour
@@ -25,6 +24,7 @@ import com.cobblemon.mod.common.api.riding.posing.PoseOption
 import com.cobblemon.mod.common.api.riding.posing.PoseProvider
 import com.cobblemon.mod.common.api.riding.sound.RideSoundSettingsList
 import com.cobblemon.mod.common.api.riding.stats.RidingStat
+import com.cobblemon.mod.common.api.riding.util.RideFrame
 import com.cobblemon.mod.common.entity.PoseType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.blockPositionsAsListRounded
@@ -45,7 +45,6 @@ import kotlin.math.sign
 import net.minecraft.core.Direction
 import net.minecraft.network.FriendlyByteBuf
 import net.minecraft.network.RegistryFriendlyByteBuf
-import net.minecraft.util.SmoothDouble
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.player.Player
 import net.minecraft.world.phys.Vec2
@@ -98,7 +97,15 @@ class MinekartBehaviour : RidingBehaviour<MinekartSettings, MinekartState> {
         vehicle: PokemonEntity,
         driver: Player
     ): Float {
+        return driver.deltaMovement.length().toFloat()
+    }
 
+    override fun driverTick(
+        settings: MinekartSettings,
+        state: MinekartState,
+        vehicle: PokemonEntity,
+        driver: Player
+    ) {
         val boostMax = vehicle.runtime.resolveFloat(settings.boostLimit ?: globalMinekart.boostLimit!!)
         //TODO: should this be by how much turn has accumulated or simply time turning... or both?
         val boostPerSecond = 20.0f
@@ -127,7 +134,6 @@ class MinekartBehaviour : RidingBehaviour<MinekartSettings, MinekartState> {
         }
 
         inAirCheck(state, vehicle)
-        return driver.deltaMovement.length().toFloat()
     }
 
     fun inAirCheck(
@@ -197,12 +203,23 @@ class MinekartBehaviour : RidingBehaviour<MinekartSettings, MinekartState> {
 
     }
 
+    // This ride works along its yaw so its velocity gets turned into world space here
     override fun velocity(
         settings: MinekartSettings,
         state: MinekartState,
         vehicle: PokemonEntity,
         driver: Player,
         input: Vec3
+    ): Vec3 {
+        return RideFrame.yawToWorld(localVelocity(settings, state, vehicle, driver, input), vehicle.yRot)
+    }
+
+    private fun localVelocity(
+        settings: MinekartSettings,
+        state: MinekartState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        input: Vec3
     ): Vec3 {
         state.rideVelocity.set(calculateRideSpaceVel(settings, state, vehicle, driver))
         return state.rideVelocity.get()
@@ -308,34 +325,6 @@ class MinekartBehaviour : RidingBehaviour<MinekartSettings, MinekartState> {
         return newVelocity
     }
 
-    override fun angRollVel(
-        settings: MinekartSettings,
-        state: MinekartState,
-        vehicle: PokemonEntity,
-        driver: Player,
-        deltaTime: Double
-    ): Vec3 {
-        return Vec3.ZERO
-    }
-
-    override fun rotationOnMouseXY(
-        settings: MinekartSettings,
-        state: MinekartState,
-        vehicle: PokemonEntity,
-        driver: Player,
-        mouseY: Double,
-        mouseX: Double,
-        mouseYSmoother: SmoothDouble,
-        mouseXSmoother: SmoothDouble,
-        sensitivity: Double,
-        deltaTime: Double
-    ): Vec3 {
-        if (driver !is OrientationControllable) return Vec3.ZERO
-
-        //Might need to add the smoothing here for default.
-        return Vec3(0.0, mouseY, mouseX)
-    }
-
     override fun canJump(
         settings: MinekartSettings,
         state: MinekartState,
@@ -387,14 +376,6 @@ class MinekartBehaviour : RidingBehaviour<MinekartSettings, MinekartState> {
         return fov
     }
 
-    override fun useAngVelSmoothing(
-        settings: MinekartSettings,
-        state: MinekartState,
-        vehicle: PokemonEntity
-    ): Boolean {
-        return false
-    }
-
     override fun inertia(settings: MinekartSettings, state: MinekartState, vehicle: PokemonEntity): Double {
         return 1.0
     }

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/types/land/VehicleBehaviour.kt

@@ -12,7 +12,6 @@ import com.bedrockk.molang.Expression
 import com.bedrockk.molang.runtime.MoLangMath.lerp
 import com.bedrockk.molang.runtime.value.DoubleValue
 import com.cobblemon.mod.common.CobblemonRideSettings
-import com.cobblemon.mod.common.OrientationControllable
 import com.cobblemon.mod.common.api.molang.ObjectValue
 import com.cobblemon.mod.common.api.riding.RidingStyle
 import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviour
@@ -25,6 +24,7 @@ import com.cobblemon.mod.common.api.riding.posing.PoseOption
 import com.cobblemon.mod.common.api.riding.posing.PoseProvider
 import com.cobblemon.mod.common.api.riding.sound.RideSoundSettingsList
 import com.cobblemon.mod.common.api.riding.stats.RidingStat
+import com.cobblemon.mod.common.api.riding.util.RideFrame
 import com.cobblemon.mod.common.entity.PoseType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.blockPositionsAsListRounded
@@ -44,7 +44,6 @@ import kotlin.math.sign
 import net.minecraft.core.Direction
 import net.minecraft.network.FriendlyByteBuf
 import net.minecraft.network.RegistryFriendlyByteBuf
-import net.minecraft.util.SmoothDouble
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.player.Player
 import net.minecraft.world.phys.Vec2
@@ -98,7 +97,15 @@ class VehicleBehaviour : RidingBehaviour<VehicleSettings, VehicleState> {
         vehicle: PokemonEntity,
         driver: Player
     ): Float {
+        return driver.deltaMovement.length().toFloat()
+    }
 
+    override fun driverTick(
+        settings: VehicleSettings,
+        state: VehicleState,
+        vehicle: PokemonEntity,
+        driver: Player
+    ) {
         if (driver.isShiftKeyDown) {
             state.drifting.set(true)
             if(driver.zza != 0.0f) {
@@ -112,7 +119,6 @@ class VehicleBehaviour : RidingBehaviour<VehicleSettings, VehicleState> {
         }
 
         inAirCheck(state, vehicle)
-        return driver.deltaMovement.length().toFloat()
     }
 
     fun inAirCheck(
@@ -172,12 +178,23 @@ class VehicleBehaviour : RidingBehaviour<VehicleSettings, VehicleState> {
         return Vec2(driver.xRot, vehicle.yRot + newMomentum.toFloat())
     }
 
+    // This ride works along its yaw so its velocity gets turned into world space here
     override fun velocity(
         settings: VehicleSettings,
         state: VehicleState,
         vehicle: PokemonEntity,
         driver: Player,
         input: Vec3
+    ): Vec3 {
+        return RideFrame.yawToWorld(localVelocity(settings, state, vehicle, driver, input), vehicle.yRot)
+    }
+
+    private fun localVelocity(
+        settings: VehicleSettings,
+        state: VehicleState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        input: Vec3
     ): Vec3 {
         state.rideVelocity.set(calculateRideSpaceVel(settings, state, vehicle, driver))
         return state.rideVelocity.get()
@@ -278,34 +295,6 @@ class VehicleBehaviour : RidingBehaviour<VehicleSettings, VehicleState> {
         return newVelocity
     }
 
-    override fun angRollVel(
-        settings: VehicleSettings,
-        state: VehicleState,
-        vehicle: PokemonEntity,
-        driver: Player,
-        deltaTime: Double
-    ): Vec3 {
-        return Vec3.ZERO
-    }
-
-    override fun rotationOnMouseXY(
-        settings: VehicleSettings,
-        state: VehicleState,
-        vehicle: PokemonEntity,
-        driver: Player,
-        mouseY: Double,
-        mouseX: Double,
-        mouseYSmoother: SmoothDouble,
-        mouseXSmoother: SmoothDouble,
-        sensitivity: Double,
-        deltaTime: Double
-    ): Vec3 {
-        if (driver !is OrientationControllable) return Vec3.ZERO
-
-        //Might need to add the smoothing here for default.
-        return Vec3(0.0, mouseY, mouseX)
-    }
-
     override fun canJump(
         settings: VehicleSettings,
         state: VehicleState,
@@ -352,14 +341,6 @@ class VehicleBehaviour : RidingBehaviour<VehicleSettings, VehicleState> {
         return 1.0f
     }
 
-    override fun useAngVelSmoothing(
-        settings: VehicleSettings,
-        state: VehicleState,
-        vehicle: PokemonEntity
-    ): Boolean {
-        return false
-    }
-
     override fun inertia(settings: VehicleSettings, state: VehicleState, vehicle: PokemonEntity): Double {
         return 1.0
     }

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/types/liquid/BoatBehaviour.kt

@@ -11,7 +11,6 @@ package com.cobblemon.mod.common.api.riding.behaviour.types.liquid
 import com.bedrockk.molang.Expression
 import com.bedrockk.molang.runtime.value.DoubleValue
 import com.cobblemon.mod.common.CobblemonRideSettings
-import com.cobblemon.mod.common.OrientationControllable
 import com.cobblemon.mod.common.api.molang.ObjectValue
 import com.cobblemon.mod.common.api.riding.RidingStyle
 import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviour
@@ -23,6 +22,7 @@ import com.cobblemon.mod.common.api.riding.posing.PoseOption
 import com.cobblemon.mod.common.api.riding.posing.PoseProvider
 import com.cobblemon.mod.common.api.riding.sound.RideSoundSettingsList
 import com.cobblemon.mod.common.api.riding.stats.RidingStat
+import com.cobblemon.mod.common.api.riding.util.RideFrame
 import com.cobblemon.mod.common.entity.PoseType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.blockPositionsAsListRounded
@@ -40,7 +40,6 @@ import kotlin.math.min
 import net.minecraft.core.BlockPos
 import net.minecraft.network.RegistryFriendlyByteBuf
 import net.minecraft.util.Mth
-import net.minecraft.util.SmoothDouble
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.player.Player
 import net.minecraft.world.phys.Vec2
@@ -133,12 +132,23 @@ class BoatBehaviour : RidingBehaviour<BoatSettings, BoatState> {
         return Vec2(vehicle.xRot, vehicle.yRot + state.deltaRotation.get().toFloat())
     }
 
+    // This ride works along its yaw so its velocity gets turned into world space here
     override fun velocity(
         settings: BoatSettings,
         state: BoatState,
         vehicle: PokemonEntity,
         driver: Player,
         input: Vec3
+    ): Vec3 {
+        return RideFrame.yawToWorld(localVelocity(settings, state, vehicle, driver, input), vehicle.yRot)
+    }
+
+    private fun localVelocity(
+        settings: BoatSettings,
+        state: BoatState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        input: Vec3
     ): Vec3 {
         applyStrafeRotation(vehicle, driver, settings, state)
 
@@ -259,34 +269,6 @@ class BoatBehaviour : RidingBehaviour<BoatSettings, BoatState> {
         vehicle.setYHeadRot(driver.yRot)
     }
 
-    override fun angRollVel(
-        settings: BoatSettings,
-        state: BoatState,
-        vehicle: PokemonEntity,
-        driver: Player,
-        deltaTime: Double
-    ): Vec3 {
-        return Vec3.ZERO
-    }
-
-    override fun rotationOnMouseXY(
-        settings: BoatSettings,
-        state: BoatState,
-        vehicle: PokemonEntity,
-        driver: Player,
-        mouseY: Double,
-        mouseX: Double,
-        mouseYSmoother: SmoothDouble,
-        mouseXSmoother: SmoothDouble,
-        sensitivity: Double,
-        deltaTime: Double
-    ): Vec3 {
-        if (driver !is OrientationControllable) return Vec3.ZERO
-
-        //Might need to add the smoothing here for default.
-        return Vec3(0.0, mouseY, mouseX)
-    }
-
     override fun canJump(
         settings: BoatSettings,
         state: BoatState,
@@ -334,10 +316,6 @@ class BoatBehaviour : RidingBehaviour<BoatSettings, BoatState> {
         return if (state.isVehicleSprinting.get()) sprintFov else 1.0f
     }
 
-    override fun useAngVelSmoothing(settings: BoatSettings, state: BoatState, vehicle: PokemonEntity): Boolean {
-        return false
-    }
-
     override fun inertia(settings: BoatSettings, state: BoatState, vehicle: PokemonEntity): Double {
         return 0.5
     }

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/types/liquid/BurstBehaviour.kt

@@ -10,7 +10,6 @@ package com.cobblemon.mod.common.api.riding.behaviour.types.liquid
 
 import com.bedrockk.molang.runtime.value.DoubleValue
 import com.cobblemon.mod.common.CobblemonRideSettings
-import com.cobblemon.mod.common.OrientationControllable
 import com.cobblemon.mod.common.api.molang.ObjectValue
 import com.cobblemon.mod.common.api.riding.RidingStyle
 import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviour
@@ -22,6 +21,7 @@ import com.cobblemon.mod.common.api.riding.posing.PoseOption
 import com.cobblemon.mod.common.api.riding.posing.PoseProvider
 import com.cobblemon.mod.common.api.riding.sound.RideSoundSettingsList
 import com.cobblemon.mod.common.api.riding.stats.RidingStat
+import com.cobblemon.mod.common.api.riding.util.RideFrame
 import com.cobblemon.mod.common.entity.PoseType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.blockPositionsAsListRounded
@@ -29,7 +29,6 @@ import com.cobblemon.mod.common.util.cobblemonResource
 import com.cobblemon.mod.common.util.readRidingStats
 import com.cobblemon.mod.common.util.writeRidingStats
 import net.minecraft.network.RegistryFriendlyByteBuf
-import net.minecraft.util.SmoothDouble
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.player.Player
 import net.minecraft.world.phys.Vec2
@@ -96,12 +95,23 @@ class BurstBehaviour : RidingBehaviour<BurstSettings, BurstState> {
         return Vec2(driver.xRot * 0.5f, driver.yRot)
     }
 
+    // This ride works along its yaw so its velocity gets turned into world space here
     override fun velocity(
         settings: BurstSettings,
         state: BurstState,
         vehicle: PokemonEntity,
         driver: Player,
         input: Vec3
+    ): Vec3 {
+        return RideFrame.yawToWorld(localVelocity(settings, state, vehicle, driver, input), vehicle.yRot)
+    }
+
+    private fun localVelocity(
+        settings: BurstSettings,
+        state: BurstState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        input: Vec3
     ): Vec3 {
         val f = driver.xxa * 0.05f
         var g = driver.zza * 0.6f
@@ -112,34 +122,6 @@ class BurstBehaviour : RidingBehaviour<BurstSettings, BurstState> {
         return Vec3(f.toDouble(), 0.0, g.toDouble())
     }
 
-    override fun angRollVel(
-        settings: BurstSettings,
-        state: BurstState,
-        vehicle: PokemonEntity,
-        driver: Player,
-        deltaTime: Double
-    ): Vec3 {
-        return Vec3.ZERO
-    }
-
-    override fun rotationOnMouseXY(
-        settings: BurstSettings,
-        state: BurstState,
-        vehicle: PokemonEntity,
-        driver: Player,
-        mouseY: Double,
-        mouseX: Double,
-        mouseYSmoother: SmoothDouble,
-        mouseXSmoother: SmoothDouble,
-        sensitivity: Double,
-        deltaTime: Double
-    ): Vec3 {
-        if (driver !is OrientationControllable) return Vec3.ZERO
-
-        //Might need to add the smoothing here for default.
-        return Vec3(0.0, mouseX, mouseY)
-    }
-
     override fun canJump(
         settings: BurstSettings,
         state: BurstState,
@@ -186,10 +168,6 @@ class BurstBehaviour : RidingBehaviour<BurstSettings, BurstState> {
         return 1.0f
     }
 
-    override fun useAngVelSmoothing(settings: BurstSettings, state: BurstState, vehicle: PokemonEntity): Boolean {
-        return false
-    }
-
     override fun inertia(settings: BurstSettings, state: BurstState, vehicle: PokemonEntity): Double {
         return 0.5
     }

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/types/liquid/DolphinBehaviour.kt

@@ -16,6 +16,7 @@ import com.cobblemon.mod.common.OrientationControllable
 import com.cobblemon.mod.common.api.molang.ObjectValue
 import com.cobblemon.mod.common.api.orientation.OrientationController
 import com.cobblemon.mod.common.api.riding.RidingStyle
+import com.cobblemon.mod.common.api.riding.behaviour.RideSteerInput
 import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviour
 import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviourSettings
 import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviourState
@@ -54,6 +55,8 @@ import org.joml.Vector3f
 
 class DolphinBehaviour : RidingBehaviour<DolphinSettings, DolphinState> {
     companion object {
+        // The correction forces were tuned as degrees per tenth of a second
+        private const val CORRECTION_FORCE_TO_DEGREES_PER_SECOND = 10.0
         val KEY = cobblemonResource("liquid/dolphin")
     }
 
@@ -201,7 +204,7 @@ class DolphinBehaviour : RidingBehaviour<DolphinSettings, DolphinState> {
             }
 
             state.lastVelocity.set(prevVel)
-            return state.lastVelocity.get().yRot(vehicle.yRot.toRadians())
+            return state.lastVelocity.get()
         } else {
             if(state.hasBreached.get()) {
                 state.clearMouseSmoothers.set(true)
@@ -238,18 +241,17 @@ class DolphinBehaviour : RidingBehaviour<DolphinSettings, DolphinState> {
         val worldVelVec = localVelVec.mul(orientation).toVec3d()
         state.lastVelocity.set(worldVelVec) // Set last velocity to be used during breaching
 
-        // Unrotate preemptively as this vector gets rotated later down the line in MC logic.
-        return worldVelVec.yRot(vehicle.yRot.toRadians())
+        return worldVelVec
     }
 
-    override fun angRollVel(
+    private fun rotateOverTime(
         settings: DolphinSettings,
         state: DolphinState,
         vehicle: PokemonEntity,
         driver: Player,
         deltaTime: Double
-    ): Vec3 {
-        if (vehicle !is OrientationControllable) return Vec3.ZERO
+    ) {
+        if (vehicle !is OrientationControllable) return
         val controller = (vehicle as OrientationControllable).orientationController
 
         val currSpeed = vehicle.deltaMovement.length()
@@ -267,8 +269,8 @@ class DolphinBehaviour : RidingBehaviour<DolphinSettings, DolphinState> {
         // Correct orientation when at low speeds
         correctOrientation(settings, state, vehicle, controller, driver, deltaTime)
 
-        //yaw, pitch, roll
-        return Vec3(0.0, state.currPitchCorrectionForce.get(), state.currRollCorrectionForce.get())
+        val correction = deltaTime * CORRECTION_FORCE_TO_DEGREES_PER_SECOND
+        controller.rotate(0f, (state.currPitchCorrectionForce.get() * correction).toFloat(), (state.currRollCorrectionForce.get() * correction).toFloat())
     }
 
     private fun correctOrientation(
@@ -354,7 +356,18 @@ class DolphinBehaviour : RidingBehaviour<DolphinSettings, DolphinState> {
         }
     }
 
-    override fun rotationOnMouseXY(
+    override fun steer(
+        settings: DolphinSettings,
+        state: DolphinState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        input: RideSteerInput
+    ) {
+        input.rotate(mouseRotation(settings, state, vehicle, driver, input.mousePitch, input.mouseYaw, input.mouseYSmoother, input.mouseXSmoother, input.sensitivity, input.deltaTime))
+        rotateOverTime(settings, state, vehicle, driver, input.deltaTime)
+    }
+
+    private fun mouseRotation(
         settings: DolphinSettings,
         state: DolphinState,
         vehicle: PokemonEntity,
@@ -487,10 +500,6 @@ class DolphinBehaviour : RidingBehaviour<DolphinSettings, DolphinState> {
         return if (state.boosting.get()) 1.2f else 1.0f
     }
 
-    override fun useAngVelSmoothing(settings: DolphinSettings, state: DolphinState, vehicle: PokemonEntity): Boolean {
-        return false
-    }
-
     override fun inertia(settings: DolphinSettings, state: DolphinState, vehicle: PokemonEntity): Double {
         return if (!vehicle.isInWater && !vehicle.isUnderWater) 1.0 else 0.1
     }

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/types/liquid/SubmarineBehaviour.kt

@@ -17,14 +17,16 @@ import com.cobblemon.mod.common.api.molang.ObjectValue
 import com.cobblemon.mod.common.api.orientation.OrientationController
 import com.cobblemon.mod.common.api.riding.RidingStyle
 import com.cobblemon.mod.common.api.riding.behaviour.*
+import com.cobblemon.mod.common.api.riding.camera.RideLookInput
+import com.cobblemon.mod.common.api.riding.camera.RideLookTake
 import com.cobblemon.mod.common.api.riding.posing.PoseOption
 import com.cobblemon.mod.common.api.riding.posing.PoseProvider
 import com.cobblemon.mod.common.api.riding.sound.RideSoundSettingsList
 import com.cobblemon.mod.common.api.riding.stats.RidingStat
+import com.cobblemon.mod.common.api.riding.util.RideFrame
 import com.cobblemon.mod.common.entity.PoseType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.cobblemonResource
-import com.cobblemon.mod.common.util.math.geometry.toRadians
 import com.cobblemon.mod.common.util.readNullableExpression
 import com.cobblemon.mod.common.util.readRidingStats
 import com.cobblemon.mod.common.util.resolveBoolean
@@ -254,29 +256,17 @@ class SubmarineBehaviour : RidingBehaviour<SubmarineSettings, SubmarineState> {
          *********************************************/
         // If the driver and vehicles eyes are out of the water but the vehicle is still in it then move only horizontally or downwards as you have surfaced
         if (state.onSurface.get()) {
-            val worldVelVec = Vec3(currVel.x, min(0.0, currVel.y), currVel.z)
-            return worldVelVec
+            return RideFrame.yawToWorld(Vec3(currVel.x, min(0.0, currVel.y), currVel.z), vehicle.yRot)
         } else {
             val vertVec = Vec3(0.0, currVel.y, 0.0)
-            val horzVec = Vec3(currVel.x, 0.0, 0.0)
+            val horzVec = RideFrame.yawToWorld(Vec3(currVel.x, 0.0, 0.0), vehicle.yRot)
             val localZVelVec = Vector3f(0.0f, 0.0f, currVel.z.toFloat() * -1.0f) // Flip the z axis to make this left handed
-            // Unrotate preemptively as this vector gets rotated later down the line in MC logic.
-            val worldVelVec = localZVelVec.mul(orientation).toVec3d().yRot(vehicle.yRot.toRadians())
+            val worldVelVec = localZVelVec.mul(orientation).toVec3d()
             // Add back the horizontal and vertical components.
             return worldVelVec.add(vertVec).add(horzVec)
         }
     }
 
-    override fun angRollVel(
-        settings: SubmarineSettings,
-        state: SubmarineState,
-        vehicle: PokemonEntity,
-        driver: Player,
-        deltaTime: Double
-    ): Vec3 {
-        return Vec3.ZERO
-    }
-
     override fun applyRenderRotation(
         settings: SubmarineSettings,
         state: SubmarineState,
@@ -323,7 +313,17 @@ class SubmarineBehaviour : RidingBehaviour<SubmarineSettings, SubmarineState> {
 
     }
 
-    override fun rotationOnMouseXY(
+    override fun steer(
+        settings: SubmarineSettings,
+        state: SubmarineState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        input: RideSteerInput
+    ) {
+        input.rotate(mouseRotation(settings, state, vehicle, driver, input.mousePitch, input.mouseYaw, input.mouseYSmoother, input.mouseXSmoother, input.sensitivity, input.deltaTime))
+    }
+
+    private fun mouseRotation(
         settings: SubmarineSettings,
         state: SubmarineState,
         vehicle: PokemonEntity,
@@ -432,10 +432,6 @@ class SubmarineBehaviour : RidingBehaviour<SubmarineSettings, SubmarineState> {
         return 1.0f
     }
 
-    override fun useAngVelSmoothing(settings: SubmarineSettings, state: SubmarineState, vehicle: PokemonEntity): Boolean {
-        return false
-    }
-
     override fun inertia(settings: SubmarineSettings, state: SubmarineState, vehicle: PokemonEntity): Double {
         return if (!vehicle.isUnderWater) 1.0 else 0.1
     }
@@ -452,8 +448,10 @@ class SubmarineBehaviour : RidingBehaviour<SubmarineSettings, SubmarineState> {
         return false
     }
 
-    override fun mouseModifiesDriverRotation(settings: SubmarineSettings, state: SubmarineState, vehicle: PokemonEntity): Pair<Boolean, Boolean> {
-        return Pair(false, state.onSurface.get())
+    // Surfaced the mouse pitch only moves the look so you can look around without nosing the sub under
+    override fun consumeLook(settings: SubmarineSettings, state: SubmarineState, vehicle: PokemonEntity, input: RideLookInput): RideLookTake {
+        if (!state.onSurface.get()) return RideLookTake.all(input)
+        return RideLookTake(input.yawDelta, 0f, recenterYaw = true, recenterPitch = false)
     }
 
     override fun shouldRotatePokemonHead(

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/camera/RideCameraContext.kt

@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.riding.camera
+
+import com.cobblemon.mod.common.api.orientation.OrientationController.Companion.FORWARDS
+import com.cobblemon.mod.common.api.orientation.OrientationController.Companion.UP
+import net.minecraft.util.Mth
+import org.joml.Quaternionf
+import org.joml.Vector3f
+import kotlin.math.atan2
+
+/**
+ * What a ride gets to build its camera base from each frame.
+ * One lives per ride on the client so [data] can keep a ride's own camera state between frames.
+ */
+class RideCameraContext {
+    companion object {
+        // Ride up this close to the view direction has no readable roll
+        private const val MIN_FLAT_LENGTH_SQ = 1.0E-6f
+    }
+
+    /** Ride orientation exactly as the driver sets it */
+    val rawOrientation = Quaternionf()
+    /** Spring smoothed ride orientation the model and seats are drawn with */
+    val renderOrientation = Quaternionf()
+    /** True when the local player is the one steering */
+    var isDriving = false
+        private set
+    /** Base the camera used last frame, null on the first frame of a ride */
+    var previousBase: Quaternionf? = null
+        private set
+    /** Seconds since the last frame, 0 while paused */
+    var frameSeconds = 0f
+        private set
+    var partialTicks = 0f
+        private set
+    /** Free slot for a ride to keep its own camera state in. Cleared when the ride changes */
+    var data: Any? = null
+    /** Final camera view this frame, base with the look on top */
+    val view = Quaternionf()
+
+    /** Drivers hang straight off the ride. Passengers get the smoothed one since raw packets make it jerky */
+    fun defaultBase(): Quaternionf = Quaternionf(if (isDriving) rawOrientation else renderOrientation)
+
+    internal fun update(raw: Quaternionf, render: Quaternionf, isDriving: Boolean, frameSeconds: Float, partialTicks: Float) {
+        rawOrientation.set(raw)
+        renderOrientation.set(render)
+        this.isDriving = isDriving
+        this.frameSeconds = frameSeconds
+        this.partialTicks = partialTicks
+    }
+
+    /** Degrees the ride's model is rolled from the camera around the view direction */
+    fun rideRollAroundView(): Float {
+        val forward = FORWARDS.rotate(view, Vector3f())
+        val cameraUp = UP.rotate(view, Vector3f())
+        val rideUp = UP.rotate(renderOrientation, Vector3f())
+        rideUp.sub(Vector3f(forward).mul(rideUp.dot(forward)))
+        if (rideUp.lengthSquared() < MIN_FLAT_LENGTH_SQ) return 0f
+        return atan2(Vector3f(cameraUp).cross(rideUp).dot(forward), cameraUp.dot(rideUp)) * Mth.RAD_TO_DEG
+    }
+
+    internal fun updateView(view: Quaternionf) {
+        this.view.set(view)
+    }
+
+    internal fun finishFrame(base: Quaternionf) {
+        previousBase = (previousBase ?: Quaternionf()).set(base)
+    }
+
+    internal fun reset() {
+        view.identity()
+        rawOrientation.identity()
+        renderOrientation.identity()
+        isDriving = false
+        previousBase = null
+        frameSeconds = 0f
+        partialTicks = 0f
+        data = null
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/camera/RideLookInput.kt

@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.riding.camera
+
+/**
+ * One frame of mouse look in degrees, before the ride takes its share.
+ * Angles are relative to the camera base.
+ */
+data class RideLookInput(
+    /** Degrees the mouse moved the look sideways this frame */
+    val yawDelta: Float,
+    /** Degrees the mouse moved the look up or down this frame */
+    val pitchDelta: Float,
+    /** Look yaw before this frame's movement */
+    val yaw: Float,
+    /** Look pitch before this frame's movement */
+    val pitch: Float
+)

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/camera/RideLookSettings.kt

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.riding.camera
+
+/**
+ * How far a rider can look around the camera base and how much of the base's turning the look follows.
+ */
+data class RideLookSettings(
+    /** Degrees the look can pitch either side of the camera base */
+    val maxPitch: Float = DEFAULT_MAX_PITCH,
+    /** Degrees the look can yaw either side of the camera base */
+    val maxYaw: Float = DEFAULT_MAX_YAW,
+    /** 0 to 1 share of the base's turning the look follows. 1 turns with the base and 0 holds its direction in the world */
+    val carry: Float = FULL_CARRY
+) {
+    companion object {
+        // Just short of straight up or down so yaw never goes degenerate
+        const val DEFAULT_MAX_PITCH = 89f
+        // A bit past side on so you can look over your shoulder. Raise to let riders look further back
+        const val DEFAULT_MAX_YAW = 105f
+        const val FULL_CARRY = 1f
+
+        @JvmField
+        val DEFAULT = RideLookSettings()
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/camera/RideLookTake.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.riding.camera
+
+/**
+ * The part of a frame's mouse look a ride takes to steer with, in degrees.
+ * Whatever isn't taken moves the rider's look instead.
+ */
+data class RideLookTake(
+    val yaw: Float,
+    val pitch: Float,
+    /** Ease the look back to centre on this axis */
+    val recenterYaw: Boolean,
+    val recenterPitch: Boolean
+) {
+    companion object {
+        /** Ride takes nothing and the look stays where it's put */
+        @JvmField
+        val NONE = RideLookTake(0f, 0f, recenterYaw = false, recenterPitch = false)
+
+        /** Ride steers with all of it and the look drifts back to centre. How rolling rides have always worked */
+        @JvmStatic
+        fun all(input: RideLookInput) = RideLookTake(input.yawDelta, input.pitchDelta, recenterYaw = true, recenterPitch = true)
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/util/RideFrame.kt

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.riding.util
+
+import com.cobblemon.mod.common.util.math.geometry.toRadians
+import net.minecraft.util.Mth
+import net.minecraft.world.phys.Vec3
+
+/**
+ * Turns ride velocities between world space and a ride's yaw local space,
+ * where x is strafe, y is up and z is forward along the ride's yaw.
+ */
+object RideFrame {
+    /** Yaw local to world. Same maths PokemonEntity.travel always used so rides come out identical. */
+    @JvmStatic
+    fun yawToWorld(local: Vec3, yawDegrees: Float): Vec3 {
+        val sin = Mth.sin(yawDegrees.toRadians()).toDouble()
+        val cos = Mth.cos(yawDegrees.toRadians()).toDouble()
+        return Vec3(local.x * cos - local.z * sin, local.y, local.z * cos + local.x * sin)
+    }
+
+    /** World to yaw local. Exact inverse of [yawToWorld]. */
+    @JvmStatic
+    fun worldToYaw(world: Vec3, yawDegrees: Float): Vec3 {
+        val sin = Mth.sin(yawDegrees.toRadians()).toDouble()
+        val cos = Mth.cos(yawDegrees.toRadians()).toDouble()
+        return Vec3(world.x * cos + world.z * sin, world.y, world.z * cos - world.x * sin)
+    }
+}

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

@@ -42,8 +42,8 @@ abstract class AreaTypeSpawningCondition<T : AreaSpawnablePosition> : SpawningCo
     override fun copyFrom(other: SpawningCondition<*>, merger: Merger) {
         super.copyFrom(other, merger)
         if (other is AreaTypeSpawningCondition) {
-            merger.mergeSingle(minHeight, other.minHeight)
-            merger.mergeSingle(maxHeight, other.maxHeight)
+            minHeight = merger.mergeSingle(minHeight, other.minHeight)
+            maxHeight = merger.mergeSingle(maxHeight, other.maxHeight)
             neededNearbyBlocks = merger.merge(neededNearbyBlocks, other.neededNearbyBlocks)?.toMutableList()
         }
     }

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

@@ -46,7 +46,7 @@ abstract class SubmergedTypeSpawningCondition<T : SubmergedSpawnablePosition> :
         super.copyFrom(other, merger)
         if (other is SubmergedTypeSpawningCondition) {
             minDepth = merger.mergeSingle(minDepth, other.minDepth)
-            maxDepth = merger.mergeSingle(minDepth, other.minDepth)
+            maxDepth = merger.mergeSingle(maxDepth, other.maxDepth)
             fluidIsSource = merger.mergeSingle(fluidIsSource, other.fluidIsSource)
             fluid = merger.mergeSingle(fluid, other.fluid)
         }

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

@@ -39,7 +39,7 @@ abstract class SurfaceTypeSpawningCondition<T : SurfaceSpawnablePosition> : Area
         super.copyFrom(other, merger)
         if (other is SurfaceTypeSpawningCondition) {
             minDepth = merger.mergeSingle(minDepth, other.minDepth)
-            maxDepth = merger.mergeSingle(minDepth, other.minDepth)
+            maxDepth = merger.mergeSingle(maxDepth, other.maxDepth)
             fluid = merger.mergeSingle(fluid, other.fluid)
         }
     }

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

@@ -22,6 +22,7 @@ import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
 import com.cobblemon.mod.common.api.types.ElementalTypes
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.entity.pokemon.ai.sensors.AlphaLevelMatchingSensor
+import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.world.entity.Entity
 
@@ -76,7 +77,7 @@ open class SpawnBaitInfluence(val effects: List<SpawnBait.Effect>, val onUsed: (
             ?: return super.affectWeight(detail, spawnablePosition, weight)
 
         val detailSpecies = pokemonDetail.pokemon.species
-            ?.let { PokemonSpecies.getByName(it) }
+            ?.let { PokemonSpecies.getByIdentifier(it.asIdentifierDefaultingNamespace()) }
             ?: return super.affectWeight(detail, spawnablePosition, weight)
 
         val formData = detailSpecies.getForm(pokemonDetail.pokemon.aspects)

common/src/main/kotlin/com/cobblemon/mod/common/api/tags/CobblemonItemTags.kt

@@ -120,7 +120,7 @@ object CobblemonItemTags {
     @JvmField val DESTINY_KNOT = create("held/destiny_knot")
     @JvmField val EVERSTONE = create("held/everstone")
     @JvmField val EXPERIENCE_SHARE = create("held/experience_share")
-    @JvmField val IS_FRIENDSHIP_BOOSTER = create("is_friendship_booster")
+    @JvmField val IS_FRIENDSHIP_BOOSTER = create("held/is_friendship_booster")
     @JvmField val ANY_HELD_ITEM = create("held/is_held_item")
     @JvmField val BLACKLISTED_ITEMS_TO_HOLD = create("held/blacklisted_items_to_hold")
     @JvmField val WHITELISTED_ITEMS_TO_HOLD = create("held/whitelisted_items_to_hold")

common/src/main/kotlin/com/cobblemon/mod/common/battles/ShowdownActionRequest.kt

@@ -117,6 +117,9 @@ abstract class ShowdownActionResponse(val type: ShowdownActionResponseType) {
 
 data class MoveActionResponse(var moveName: String, var targetPnx: String? = null, var gimmickID: String? = null): ShowdownActionResponse(ShowdownActionResponseType.MOVE) {
     override fun isValid(activeBattlePokemon: ActiveBattlePokemon, showdownMoveSet: ShowdownMoveset?, forceSwitch: Boolean): Boolean {
+        // Ensure that the gimmick ID the player is sending is valid
+        gimmickID?.let { if (it !in VALID_GIMMICK_IDS) return false }
+
         if (forceSwitch || showdownMoveSet == null) {
             return false
         }
@@ -168,6 +171,10 @@ data class MoveActionResponse(var moveName: String, var targetPnx: String? = nul
         gimmickID = buffer.readNullable { buffer.readString() }
         return this
     }
+
+    companion object {
+        private val VALID_GIMMICK_IDS = ShowdownMoveset.Gimmick.entries.map { it.id }.toSet()
+    }
 }
 
 data class HealItemActionResponse(var item: String) : ShowdownActionResponse(ShowdownActionResponseType.FORCE_PASS) {
@@ -183,7 +190,8 @@ data class HealItemActionResponse(var item: String) : ShowdownActionResponse(Sho
     }
 
     override fun isValid(activeBattlePokemon: ActiveBattlePokemon, showdownMoveSet: ShowdownMoveset?, forceSwitch: Boolean): Boolean {
-        return !forceSwitch
+        // Previously checked for !forceSwitch, excepts in the case of a forceSwitch, this couldn't legally be sent anyway.
+        return false
     }
 
     override fun toShowdownString(activeBattlePokemon: ActiveBattlePokemon, showdownMoveSet: ShowdownMoveset?): String {

common/src/main/kotlin/com/cobblemon/mod/common/battles/interpreter/instructions/MoveInstruction.kt

@@ -37,7 +37,6 @@ import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
 import com.cobblemon.mod.common.util.battleLang
 import com.cobblemon.mod.common.util.cobblemonResource
 import java.util.concurrent.CompletableFuture
-import net.minecraft.world.entity.LivingEntity
 
 /**
  * Format: |move|POKEMON|MOVE|TARGET
@@ -77,7 +76,7 @@ class MoveInstruction(
             val pokemonName = userPokemon.getName()
             ShowdownInterpreter.lastCauser[battle.battleId] = message
             // For Spread targets the message data only gives the pnx strings. So we can't know what pokemon are actually targeted until the previous messages have been interpreted
-            val spreadTargetPokemon = spreadTargets.map { battle.activePokemon.firstOrNull() { poke -> poke.getPNX() == it }?.battlePokemon }
+            val spreadTargetPokemon = spreadTargets.map { battle.activePokemon.firstOrNull { poke -> poke.getPNX() == it }?.battlePokemon }
 
             val targetPokemonEntity = targetPokemon?.entity
             if (targetPokemonEntity != null) {
@@ -137,10 +136,20 @@ class MoveInstruction(
 
             val subsequentInstructions = instructionSet.findInstructionsCausedBy(this)
             val missedTargets = subsequentInstructions.filterIsInstance<MissInstruction>().mapNotNull { it.target }
+            val faintedTargets = subsequentInstructions.filterIsInstance<FaintInstruction>().map { it.faintingPokemon }
             val failed = subsequentInstructions.any { it is FailInstruction }
             val failedTargets = subsequentInstructions.filterIsInstance<FailInstruction>().mapNotNull { it.target }
             val hitCountInstruction = subsequentInstructions.filterIsInstance<HitCountInstruction>().firstOrNull()
 
+            runtime.environment.query.addFunction("target_fainted") { params ->
+                if (params.params.size == 0) {
+                    return@addFunction DoubleValue(faintedTargets.isNotEmpty())
+                } else {
+                    val entityUUID = params.getString(0)
+                    return@addFunction DoubleValue(faintedTargets.any { it.entity?.stringUUID == entityUUID })
+                }
+            }
+
             runtime.environment.query.addFunction("missed") { params ->
                 if (params.params.size == 0) {
                     return@addFunction DoubleValue(missedTargets.isNotEmpty())

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

@@ -34,7 +34,9 @@ import net.minecraft.world.item.alchemy.Potions
 import net.minecraft.world.level.BlockGetter
 import net.minecraft.world.level.Level
 import net.minecraft.world.level.LevelAccessor
+import net.minecraft.world.level.LevelReader
 import net.minecraft.world.level.block.Block
+import net.minecraft.world.level.block.BonemealableBlock
 import net.minecraft.world.level.block.DispenserBlock
 import net.minecraft.world.level.block.LeavesBlock
 import net.minecraft.world.level.block.state.BlockState
@@ -52,7 +54,7 @@ import net.minecraft.world.phys.shapes.EntityCollisionContext
 import net.minecraft.world.phys.shapes.Shapes
 import net.minecraft.world.phys.shapes.VoxelShape
 
-class SaccharineLeafBlock(settings: Properties) : LeavesBlock(settings) {
+class SaccharineLeafBlock(settings: Properties) : LeavesBlock(settings), BonemealableBlock {
     companion object {
         val AGE: IntegerProperty = BlockStateProperties.AGE_2
         val DISTANCE: IntegerProperty = BlockStateProperties.DISTANCE
@@ -181,6 +183,15 @@ class SaccharineLeafBlock(settings: Properties) : LeavesBlock(settings) {
         super.randomTick(state, world, pos, random)
     }
 
+    override fun isValidBonemealTarget(level: LevelReader, pos: BlockPos, state: BlockState): Boolean =
+        state.getValue(AGE) < MAX_AGE && !state.getValue(BlockStateProperties.WATERLOGGED)
+
+    override fun isBonemealSuccess(level: Level, random: RandomSource, pos: BlockPos, state: BlockState) = true
+
+    override fun performBonemeal(level: ServerLevel, random: RandomSource, pos: BlockPos, state: BlockState) {
+        level.setBlock(pos, changeAge(state, 1), UPDATE_CLIENTS)
+    }
+
     override fun placeLiquid(level: LevelAccessor, pos: BlockPos, state: BlockState, fluidState: FluidState): Boolean {
         if (!state.getValue(BlockStateProperties.WATERLOGGED) && fluidState.type === Fluids.WATER) {
             val hasHoney = state.getValue(AGE) > 0

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

@@ -165,24 +165,24 @@ class TypeGemCoreBlock(properties: Properties) : Block(properties) {
         expand(level, pos, random)
     }
 
-    fun expand(level: LevelAccessor, pos: BlockPos, random: RandomSource) {
+    fun expand(level: LevelAccessor, pos: BlockPos, random: RandomSource, forceGrow: Boolean = false) {
         getConnectedGemBlocks(level, pos).forEach {
             val state = it.first
             val pos = it.second
             addClustersToBlock(state, pos, level, random)
-            growClusters(pos, level, random)
+            growClusters(pos, level, random, forceGrow)
         }
     }
 
-    private fun growClusters(pos: BlockPos, level: LevelAccessor, random: RandomSource) {
+    private fun growClusters(pos: BlockPos, level: LevelAccessor, random: RandomSource, forceGrow: Boolean) {
         Direction.entries.forEach { direction ->
             val relativePos = pos.relative(direction)
             val relativeState = level.getBlockState(relativePos)
             val clusterBlock = relativeState.block as? TypeGemClusterBlock ?: return@forEach
 
-            if (relativeState.getValue(DirectionalBlock.FACING) == direction &&
-                random.nextFloat() < Cobblemon.config.typeGemGrowthChance
-            ) {
+            if ((relativeState.getValue(DirectionalBlock.FACING) == direction &&
+                random.nextFloat() < Cobblemon.config.typeGemGrowthChance) || forceGrow
+                ) {
                 clusterBlock.advanceGrowth(relativeState, level, relativePos, random)
             }
         }

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

@@ -334,8 +334,6 @@ class TMMachineBlockEntity(pos: BlockPos, state: BlockState) :
         level?.updateNeighborsAt(blockPos, currentState.block)
     }
 
-    override fun stillValid(player: Player): Boolean = tmMachineInventory.stillValid(player)
-
     override fun canPlaceItem(slot: Int, stack: ItemStack): Boolean = tmMachineInventory.canPlaceItem(slot, stack)
 
     override fun canTakeItem(target: Container, slot: Int, stack: ItemStack): Boolean =

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

@@ -1,50 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.client
-
-import org.joml.Quaternionf
-import org.spongepowered.asm.mixin.Unique
-
-interface RidingCameraInterface {
-    // Used to help in camera rotation rendering when transitioning
-    // from rolled to unrolled.
-    @Unique
-    fun `getCobblemon$returnTimer`(): Float
-
-    @Unique
-    fun `setCobblemon$returnTimer`(time: Float)
-
-    @Unique
-    fun `getCobblemon$lastHandledRotationTime`(): Double
-
-    @Unique
-    fun `setCobblemon$lastHandledRotationTime`(time: Double)
-
-    @Unique
-    fun `getCobblemon$frameTime`(): Double
-
-    @Unique
-    fun `setCobblemon$frameTime`(time: Double)
-
-    @Unique
-    fun `getCobblemon$partialTickTime`(): Float
-
-    @Unique
-    fun `setCobblemon$partialTickTime`(time: Float)
-
-    @Unique
-    fun `getCobblemon$rollAngleStart`(): Float
-
-    @Unique
-    fun `setCobblemon$rollAngleStart`(angle: Float)
-
-    fun `getCobblemon$smoothRotation`(): Quaternionf?
-
-    fun `setCobblemon$smoothRotation`(smoothRotation: Quaternionf)
-}

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

@@ -85,6 +85,7 @@ class PartyOverlay : Gui(Minecraft.getInstance()) {
             if (HidePartyBinding.shouldHide) {
                 return false
             }
+
             return true
         }
     }
@@ -558,4 +559,4 @@ class PartyOverlay : Gui(Minecraft.getInstance()) {
             }
         }
     }
-}
+}

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

@@ -182,6 +182,7 @@ class RideControlsOverlay : Gui(Minecraft.getInstance()) {
                     showHorizontalMouse = false
                 }
                 VehicleBehaviour.KEY -> {}
+                BoardBehaviour.KEY -> {}
             }
 
             val centerX = minecraft.window.guiScaledWidth / 2

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/habitat/HabitatSpawnEditorGUI.kt

@@ -17,6 +17,7 @@ import com.cobblemon.mod.common.api.text.text
 import com.cobblemon.mod.common.client.gui.CobblemonRenderable
 import com.cobblemon.mod.common.pokemon.Species
 import com.cobblemon.mod.common.util.adapters.IntRangesAdapter
+import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
 import com.cobblemon.mod.common.util.lang
 import java.awt.Color
 import net.minecraft.client.Minecraft
@@ -328,7 +329,7 @@ class HabitatSpawnEditorGUI(
     private fun parseSpecies(value: String): Species? {
         val lowered = value.lowercase()
         pokemonSpeciesByTranslatedName[lowered]?.let { return it }
-        return runCatching { PokemonSpecies.getByName(lowered) }.getOrNull()
+        return runCatching { PokemonSpecies.getByIdentifier(lowered.asIdentifierDefaultingNamespace()) }.getOrNull()
     }
 
     private fun parsePhases(raw: String): IntRanges? {

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/pc/PCGUI.kt

@@ -56,7 +56,8 @@ class PCGUI(
     val party: ClientParty,
     val configuration: PCGUIConfiguration,
     val openOnBox: Int = CobblemonClient.lastPcBoxViewed,
-    val unseenWallpapers: MutableSet<ResourceLocation> = mutableSetOf()
+    val unseenWallpapers: MutableSet<ResourceLocation> = mutableSetOf(),
+    val silent: Boolean = false
 ) : Screen(Component.translatable("cobblemon.ui.pc.title")), CobblemonRenderable {
 
     companion object {
@@ -703,7 +704,7 @@ class PCGUI(
     }
 
     fun closeNormally(unlink: Boolean = true) {
-        playSound(CobblemonSounds.PC_OFF)
+        if (!silent) playSound(CobblemonSounds.PC_OFF)
         Minecraft.getInstance().setScreen(null)
         if (unlink) {
             UnlinkPlayerFromPCPacket().sendToServer()
@@ -748,7 +749,7 @@ class PCGUI(
 
         if (isInventoryKeyPressed(minecraft, keyCode, scanCode) && !boxNameFocused && !filterFocused) {
             saveMarkings(isPreviewInParty ?: false)
-            playSound(CobblemonSounds.PC_OFF)
+            if (!silent) playSound(CobblemonSounds.PC_OFF)
             UnlinkPlayerFromPCPacket().sendToServer()
             Minecraft.getInstance().setScreen(null)
             return true
@@ -759,7 +760,7 @@ class PCGUI(
         if (!filterFocused && !boxNameFocused) {
             when (keyCode) {
                 InputConstants.KEY_ESCAPE -> {
-                    playSound(CobblemonSounds.PC_OFF)
+                    if (!silent) playSound(CobblemonSounds.PC_OFF)
                     UnlinkPlayerFromPCPacket().sendToServer()
                     onClose()
                     return true
@@ -831,4 +832,4 @@ class PCGUI(
             markingsWidget.setActivePokemon(null)
         }
     }
-}
+}

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

@@ -38,7 +38,6 @@ import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.BASE_HEIG
 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
@@ -52,8 +51,7 @@ 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.*
-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.gui.pokedex.widgets.EvolutionTreeWidget
 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
@@ -194,6 +192,7 @@ class PokedexGUI private constructor(
     public override fun init() {
         super.init()
         clearWidgets()
+        evolutionTreeExpanded = false
 
         availableRegions = Dexes.dexEntryMap.keys.toList()
         selectedRegionIndex = 0
@@ -828,10 +827,6 @@ 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/PokedexTooltip.kt

@@ -16,13 +16,17 @@ 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.Component
 import net.minecraft.network.chat.MutableComponent
+import net.minecraft.network.chat.Style
 import net.minecraft.resources.ResourceLocation
+import java.util.Optional
 
 private val tooltipEdge = cobblemonResource("textures/gui/pokedex/tooltip_edge.png")
 private val tooltipBackground = cobblemonResource("textures/gui/pokedex/tooltip_background.png")
 
 private const val TOOLTIP_SLICE_SIZE = 11
+private const val TOOLTIP_MAX_TEXT_WIDTH = 160
 
 fun renderTooltip(
     context: GuiGraphics,
@@ -49,7 +53,12 @@ fun renderTooltip(
     posY: Int,
     delta: Float,
     offsetY: Int = 0,
+    maxTextWidth: Int = TOOLTIP_MAX_TEXT_WIDTH,
 ) {
+    val text = text.flatMap { wrapTooltipLine(it, maxTextWidth) }
+    // Only a tooltip that fits on a single line is centered; wrapped text is left-aligned
+    val centered = text.size == 1
+
     val poseStack = context.pose()
     val textWidth = text.maxOf { Minecraft.getInstance().font.width(it.font(CobblemonResources.DEFAULT_LARGE)) }
     val tooltipPadding = 6
@@ -78,8 +87,6 @@ fun renderTooltip(
     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,
@@ -95,6 +102,20 @@ fun renderTooltip(
     poseStack.popPose()
 }
 
+private fun wrapTooltipLine(line: MutableComponent, maxWidth: Int): List<MutableComponent> {
+    val styled = line.copy().font(CobblemonResources.DEFAULT_LARGE)
+    if (Minecraft.getInstance().font.width(styled) <= maxWidth) return listOf(line)
+
+    return Minecraft.getInstance().font.splitter.splitLines(styled, maxWidth, Style.EMPTY).map { wrapped ->
+        val component = Component.empty()
+        wrapped.visit({ style, string ->
+            component.append(Component.literal(string).withStyle(style))
+            Optional.empty<Unit>()
+        }, Style.EMPTY)
+        component
+    }
+}
+
 // 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(

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

@@ -6,20 +6,18 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-package com.cobblemon.mod.common.client.gui.pokedex.widgets.evolutiontree
+package com.cobblemon.mod.common.client.gui.pokedex.widgets
 
 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.pokedex.entry.*
 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.api.text.green
+import com.cobblemon.mod.common.api.text.red
 import com.cobblemon.mod.common.client.CobblemonClient
 import com.cobblemon.mod.common.client.CobblemonResources
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUI
@@ -29,18 +27,22 @@ import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.POKEMON_D
 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.FormData
 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.Minecraft
 import net.minecraft.client.gui.GuiGraphics
+import net.minecraft.core.registries.Registries
+import net.minecraft.locale.Language
 import net.minecraft.network.chat.Component
 import net.minecraft.network.chat.MutableComponent
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.tags.TagKey
 
 class EvolutionTreeWidget(
     val parent: PokedexGUI,
@@ -92,6 +94,8 @@ class EvolutionTreeWidget(
 
     private var hoveredTooltips: List<MutableComponent>? = null
 
+    private var viewedForm: FormData? = null
+
     private val expandButton: ScaledButton = ScaledButton(
         0f,
         0f,
@@ -100,11 +104,14 @@ class EvolutionTreeWidget(
         resource = expandResource,
         clickAction = {
             parent.evolutionTreeExpanded = !parent.evolutionTreeExpanded
-            expandButton.resource = if (parent.evolutionTreeExpanded) minimizeResource else expandResource
             updatePositioning()
         }
     ).apply { addWidget(this) }
 
+    init {
+        updatePositioning()
+    }
+
     override fun renderWidget(
         guiGraphics: GuiGraphics,
         mouseX: Int,
@@ -146,9 +153,31 @@ class EvolutionTreeWidget(
         if (pokedexEntry == null || pokedexForm == null) return
 
         updatePositioning()
+        var rootSpecies = pokedexEntry
+        var rootForm = pokedexForm
+        var preEvolution = findPreEvolution(rootSpecies, rootForm)
+        // Stop at whatever the dex can't resolve, and at cycles (datapacks)
+        val visited = mutableSetOf(rootSpecies.speciesId to rootForm.displayForm)
+        while (preEvolution != null) {
+            val preEvolutionSpecies = DexEntries.entries.values.firstOrNull { it.speciesId == preEvolution.fromSpecies &&
+                    it.forms.any {form -> form.displayForm.equals(preEvolution.fromForm, ignoreCase = true)}} ?: break
+            val preEvolutionForm = preEvolutionSpecies.forms.firstOrNull { it.displayForm.equals(preEvolution.fromForm, ignoreCase = true) } ?: break
+            if (!visited.add(preEvolutionSpecies.speciesId to preEvolutionForm.displayForm)) break
+            rootSpecies = preEvolutionSpecies
+            rootForm = preEvolutionForm
+            preEvolution = findPreEvolution(rootSpecies, rootForm)
+        }
 
-        val (rootPokedexEntry, rootPokedexForm) = Dexes.findRootDexEntryBySpeciesId(pokedexEntry.speciesId, pokedexForm.displayForm)
-        val rootEvolutionNode = buildEvolutionTree(rootPokedexEntry, rootPokedexForm, null)
+        val viewedFormEquivalents = Dexes.getFormEquivalents(pokedexForm.displayForm)
+        viewedForm = PokemonSpecies.getByIdentifier(pokedexEntry.speciesId)
+            ?.forms?.firstOrNull { viewedFormEquivalents.contains(it.name.lowercase()) }
+
+        val formEquivalents = Dexes.getFormEquivalents(rootForm.displayForm)
+        val form =
+            rootSpecies.forms.firstOrNull { formEquivalents.contains(it.displayForm.lowercase()) } ?:
+            rootSpecies.forms.first { it.displayForm.equals("Normal", ignoreCase = true) }
+
+        val rootEvolutionNode = buildEvolutionTree(rootSpecies, form)
 
 //        val isSameEntry = previousRootPokedexEntry != null && pokedexEntry?.id == previousRootPokedexEntry?.id
 //        val isSameForm =
@@ -172,6 +201,13 @@ class EvolutionTreeWidget(
         panningY = 0.0
     }
 
+    /** The evolution leading to [form]; the standard form falls back to any form of the species (no evolution leads to regular Vivillon). */
+    private fun findPreEvolution(entry: PokedexEntry, form: PokedexForm): DexEvolutionDisplay? {
+        return DexEntries.evolutionDisplays.firstOrNull { it.toSpecies == entry.speciesId && form.displayForm.equals(it.toForm, ignoreCase = true) }
+            ?: DexEntries.evolutionDisplays.takeIf { form.displayForm.equals("Normal", ignoreCase = true) }
+                ?.firstOrNull { it.toSpecies == entry.speciesId }
+    }
+
     fun updatePositioning() {
         x = pX + X_MARGIN
         y = pY + if (parent.evolutionTreeExpanded) Y_MARGIN_EXPANDED else Y_MARGIN_MINIMIZED
@@ -180,6 +216,7 @@ class EvolutionTreeWidget(
         panningX = 0.0
         panningY = 0.0
 
+        expandButton.resource = if (parent.evolutionTreeExpanded) minimizeResource else expandResource
         expandButton.buttonX = x + EXPAND_BUTTON_X_MARGIN
         expandButton.buttonY = y + EXPAND_BUTTON_Y_MARGIN
     }
@@ -187,61 +224,62 @@ class EvolutionTreeWidget(
     private fun buildEvolutionTree(
         pokedexEntry: PokedexEntry,
         pokedexForm: PokedexForm,
-        evolution: Evolution? = null,
-        resultProperties: PokemonProperties? = evolution?.result,
-        renderData: RenderEvolutionData? = evolution?.let { renderEvolutionData(it) }
+        aspects: Set<String> = emptySet(),
+        ancestors: Set<Pair<ResourceLocation, String>> = emptySet(),
     ): EvolutionNode {
-        val species = PokemonSpecies.getByIdentifier(pokedexEntry.speciesId)!!
+        // Datapack evolutions can loop back (A -> B -> A), so stop at anything already on this branch
+        val path = ancestors + (pokedexEntry.speciesId to pokedexForm.displayForm.lowercase())
+        val discoveryLevel = CobblemonClient.clientPokedexData.getHighestKnowledgeFor(pokedexEntry, pokedexForm, aspects.toMutableSet())
 
         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 evolutions = DexEntries.evolutionDisplays.filter { it.fromSpecies == pokedexEntry.speciesId && formEquivalents.contains(it.fromForm.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)
+        val children = evolutions.mapNotNull {
+            val childPokedexEntry = DexEntries.entries.values.firstOrNull { entry -> entry.speciesId == it.toSpecies &&
+                    entry.forms.any {form -> form.displayForm.equals(it.toForm, ignoreCase = true)}}
+            if (childPokedexEntry == null) {
+                Cobblemon.LOGGER.warn("Dex entry not found for species: ${it.toSpecies}")
+                return@mapNotNull null
             }
+            val formEquivalents = Dexes.getFormEquivalents(it.toForm.lowercase())
+            val childPokedexForm = childPokedexEntry.forms.firstOrNull { formEquivalents.contains(it.displayForm.lowercase()) }
+            if (childPokedexForm == null) {
+                Cobblemon.LOGGER.warn("Dex form ${it.toForm} not found for species: ${it.toSpecies}")
+                return@mapNotNull null
+            }
+            if ((childPokedexEntry.speciesId to childPokedexForm.displayForm.lowercase()) in path) {
+                Cobblemon.LOGGER.warn("Evolution loop found at species: ${it.toSpecies} form: ${it.toForm}")
+                return@mapNotNull null
+            }
+            buildEvolutionTree(childPokedexEntry, childPokedexForm, it.toAspects, path)
         }
 
-        return EvolutionNode(pokedexEntry, parentPokedexForm, aspects, discoveryLevel, children, renderData)
+        return EvolutionNode(
+            pokedexEntry = pokedexEntry,
+            pokedexForm = pokedexForm,
+            aspects = aspects,
+            pokedexEntryProgress = discoveryLevel,
+            children = mergeEquivalentChildren(children),
+            renderDataAlternatives = evolutions,
+        )
+    }
+
+    private fun mergeEquivalentChildren(children: List<EvolutionNode>): List<EvolutionNode> {
+        return children
+            .groupBy { Triple(it.pokedexEntry.speciesId, it.pokedexForm.displayForm.lowercase(), it.aspects) }
+            .values
+            .map { group ->
+                if (group.size == 1) return@map group.first()
+                val first = group.first()
+                EvolutionNode(
+                    first.pokedexEntry,
+                    first.pokedexForm,
+                    first.aspects,
+                    first.pokedexEntryProgress,
+                    first.children,
+                    group.flatMap { it.renderDataAlternatives }
+                )
+            }
     }
 
     private fun renderTreeDrawingNode(
@@ -258,15 +296,19 @@ class EvolutionTreeWidget(
             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 ->
+            val formEquivalents = Dexes.getFormEquivalents(child.value.pokedexForm.displayForm)
+            val alternatives = treeDrawingNode.value.renderDataAlternatives.filter {
+                it.toSpecies == child.value.pokedexEntry.speciesId && formEquivalents.contains(it.toForm.lowercase()) && it.toAspects == child.value.aspects
+            }
+
+            alternatives.takeIf { it.isNotEmpty() }?.let {
                 drawEvolutionInfo(
                     guiGraphics,
-                    renderData,
+                    it,
                     lineStartX,
-                    lineEndX,
+                    childX,
                     lineY,
                     mouseX,
                     mouseY,
@@ -298,16 +340,19 @@ class EvolutionTreeWidget(
             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 ->
+                val formEquivalents = Dexes.getFormEquivalents(child.value.pokedexForm.displayForm)
+                val alternatives = treeDrawingNode.value.renderDataAlternatives.filter {
+                    it.toSpecies == child.value.pokedexEntry.speciesId && formEquivalents.contains(it.toForm.lowercase()) && it.toAspects == child.value.aspects
+                }
+
+                alternatives.takeIf { it.isNotEmpty() }?.let {
                     drawEvolutionInfo(
                         guiGraphics,
-                        renderData,
-                        lineStartX,
-                        lineEndX,
+                        it,
+                        treeForkEnd,
+                        childX,
                         lineY,
                         mouseX,
                         mouseY,
@@ -346,7 +391,7 @@ class EvolutionTreeWidget(
                         if (formName == "normal") null
                         else lang("ui.pokedex.info.form.${species}-${formName.replace("-", "")}")
 
-                    formComponent?.add(" ")?.add(speciesComponent) ?: speciesComponent
+                    formComponent?.let { speciesComponent.copy().add(" (").add(it).add(")") } ?: speciesComponent
                 }
 
             guiGraphics.disableScissor()
@@ -408,7 +453,7 @@ class EvolutionTreeWidget(
 
     private fun drawEvolutionInfo(
         guiGraphics: GuiGraphics,
-        renderData: RenderEvolutionData,
+        renderDataAlternatives: List<DexEvolutionDisplay>,
         lineStartX: Int,
         lineEndX: Int,
         lineY: Int,
@@ -416,6 +461,26 @@ class EvolutionTreeWidget(
         mouseY: Int,
         delta: Float,
     ) {
+        val icons = renderDataAlternatives.flatMap { it.requirements.filter(::isDisplayable).map { req -> req.icon } }.distinct()
+        val playerBiome = Minecraft.getInstance().player?.let { it.level().getBiome(it.blockPosition()) }
+        val alternativeTooltips = renderDataAlternatives.map { alternative ->
+            alternative.requirements.filter(::isDisplayable).map { req ->
+                if (req is CobblemonBiomeDexEvolutionRequirementDisplay) {
+                    val tooltip = req.tooltip.copy()
+                    if (playerBiome != null) {
+                        val conditionFits = req.condition?.let { if (it.tag) playerBiome.`is`(TagKey.create(Registries.BIOME, it.id)) else playerBiome.`is`(it.id) } ?: true
+                        val antiConditionFits = req.antiCondition?.let { if (it.tag) playerBiome.`is`(TagKey.create(Registries.BIOME, it.id)) else playerBiome.`is`(it.id) } ?: false
+                        val isMet = conditionFits && !antiConditionFits
+                        tooltip.add(if (isMet) Component.literal(" ✔").green() else Component.literal(" ✘").red())
+                    }
+                    tooltip
+                } else {
+                    req.tooltip
+                }
+            }
+        }
+        val tooltips = combineAlternativeTooltips(alternativeTooltips)
+
         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()
@@ -431,7 +496,7 @@ class EvolutionTreeWidget(
             return
         }
 
-        if (renderData.icons.isEmpty()) {
+        if (icons.isEmpty()) {
             guiGraphics.hLine(
                 lineStartX,
                 lineEndX,
@@ -462,8 +527,8 @@ class EvolutionTreeWidget(
                 height = iconSize,
             )
 
-            val index = (System.currentTimeMillis() / MILLIS_BETWEEN_ICONS_CYCLE) % renderData.icons.size
-            val item = renderData.icons[index.toInt()]
+            val index = (System.currentTimeMillis() / MILLIS_BETWEEN_ICONS_CYCLE) % icons.size
+            val item = icons[index.toInt()]
 
             renderScaledGuiItemIcon(
                 itemStack = item.defaultInstance,
@@ -478,17 +543,49 @@ class EvolutionTreeWidget(
         val isIconHovered = isElementHovered(
             mouseX,
             mouseY,
-            iconX.toInt(),
-            iconX.toInt() + iconSize,
-            iconY.toInt(),
-            iconY.toInt() + iconSize,
+            iconX,
+            iconX + iconSize,
+            iconY,
+            iconY + iconSize,
         )
 
-        if (renderData.tooltips.isNotEmpty() &&
+        if (tooltips.isNotEmpty() &&
             (isLineHovered || isIconHovered) &&
             this.isHovered(mouseX.toDouble(), mouseY.toDouble())
         ) {
-            hoveredTooltips = renderData.tooltips
+            hoveredTooltips = tooltips.map { it.copy() }
+        }
+    }
+
+    /** Hides biome requirements naming untranslated biomes, e.g. from mods that aren't installed (aether:skyroot_forest) */
+    private fun isDisplayable(requirement: DexEvolutionRequirementDisplay): Boolean {
+        if (requirement !is CobblemonBiomeDexEvolutionRequirementDisplay) return true
+        return listOfNotNull(requirement.condition, requirement.antiCondition).all {
+            it.tag || Language.getInstance().has("biome.${it.id.namespace}.${it.id.path}")
+        }
+    }
+
+    private fun combineAlternativeTooltips(alternatives: List<List<Component>>): List<Component> {
+        val groups = alternatives.filter { it.isNotEmpty() }
+        if (groups.size <= 1) return groups.firstOrNull() ?: emptyList()
+
+        val sharedStrings = groups.map { group -> group.map { it.string }.toSet() }.reduce { acc, strings -> acc intersect strings }
+        val shared = groups.first().filter { it.string in sharedStrings }.distinctBy { it.string }
+        val remainders = groups
+            .map { group -> group.filter { it.string !in sharedStrings } }
+            .distinctBy { group -> group.map { it.string } }
+
+        // An alternative needing nothing beyond the shared lines makes the others irrelevant
+        if (remainders.any { it.isEmpty() }) return shared
+        if (remainders.size == 1) return shared + remainders.first()
+
+        return if (remainders.size >= 3 && remainders.all { it.size == 1 }) {
+            shared + lang("ui.pokedex.evolution.one_of").bold() + remainders.map { it.first() }
+        } else {
+            // Show each alternative in full, otherwise it's unclear where the first one starts
+            groups.distinctBy { group -> group.map { it.string } }.flatMapIndexed { index, group ->
+                if (index == 0) group else listOf(lang("ui.pokedex.evolution.or").bold()) + group
+            }
         }
     }
 
@@ -566,6 +663,6 @@ class EvolutionTreeWidget(
         val aspects: Set<String>,
         val pokedexEntryProgress: PokedexEntryProgress,
         override val children: List<EvolutionNode>,
-        val renderData: RenderEvolutionData?,
+        val renderDataAlternatives: List<DexEvolutionDisplay>,
     ) : TreeNode<EvolutionNode>
 }

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

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

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

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

@@ -1041,7 +1041,10 @@ class TMMachineScreen(containerMenu: TMMachineMenu, val inventory: Inventory, ti
                     // Scroll to move if moves list contains held TM move
                     if (tmList.get().contains(heldStackTm)) {
                         val moveListIndex = tmList.get().indexOf(heldStackTm)
-                        movesScrollingList.scrollAmount = (if (moveListIndex == tmList.get().lastIndex) 1.0 else (moveListIndex / tmList.get().size.toDouble()))* movesScrollingList.maxScroll
+                        movesScrollingList.scrollAmount = movesScrollingList.maxScroll * when (moveListIndex) {
+                            tmList.get().lastIndex -> 1.0
+                            else -> (moveListIndex / tmList.get().size.toDouble())
+                        }
                     }
                 }
             }

common/src/main/kotlin/com/cobblemon/mod/common/client/net/orientation/ClientboundUpdateOrientationHandler.kt

@@ -10,10 +10,8 @@ package com.cobblemon.mod.common.client.net.orientation
 
 import com.cobblemon.mod.common.OrientationControllable
 import com.cobblemon.mod.common.api.net.ClientNetworkPacketHandler
-import com.cobblemon.mod.common.duck.RidePassenger
 import com.cobblemon.mod.common.net.messages.client.orientation.ClientboundUpdateOrientationPacket
 import net.minecraft.client.Minecraft
-import net.minecraft.util.Mth
 
 object ClientboundUpdateOrientationHandler : ClientNetworkPacketHandler<ClientboundUpdateOrientationPacket> {
     override fun handle(packet: ClientboundUpdateOrientationPacket, client: Minecraft) {
@@ -26,21 +24,7 @@ object ClientboundUpdateOrientationHandler : ClientNetworkPacketHandler<Clientbo
         // of truth on vehicle orientation updates.
         if (vehicle.controllingPassenger != player) {
             packet.active?.let { shouldUseCustomOrientation ->
-
-                val playerIsPassenger = vehicle.passengers.contains(player)
-
-                // If the player has just switched to riding a custom orientation ride then set their
-                // ride x and y rots local to the vehicle rots(if the controller wasn't active and will now be active)
-                // This ensures that on transition your camera stays in the same spot
-                if (!vehicleController.isActive() && shouldUseCustomOrientation && playerIsPassenger) {
-                    // Set local to the vehicle x and yrot
-                    val playerRotater = player as RidePassenger?
-                    if (playerRotater != null) {
-                        playerRotater.`cobblemon$setRideXRot`(Mth.wrapDegrees(player.getXRot() - vehicle.getXRot()))
-                        playerRotater.`cobblemon$setRideYRot`(Mth.wrapDegrees(player.getYRot() - vehicle.getYRot()))
-                    }
-                }
-
+                // Passenger look angles get seeded by the camera on its first rolling frame
                 vehicle.orientationController.active = shouldUseCustomOrientation
             }
             vehicle.orientationController.updateOrientation { _ -> packet.orientation }

common/src/main/kotlin/com/cobblemon/mod/common/client/net/storage/pc/OpenPCHandler.kt

@@ -24,8 +24,9 @@ object OpenPCHandler : ClientNetworkPacketHandler<OpenPCPacket> {
                 party = CobblemonClient.storage.party,
                 configuration = PCGUIConfiguration(),
                 openOnBox = packet.box ?: CobblemonClient.lastPcBoxViewed,
-                unseenWallpapers = packet.unseenWallpapers.toMutableSet()
+                unseenWallpapers = packet.unseenWallpapers.toMutableSet(),
+                silent = packet.silent
             )
         )
     }
-}
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/camera/MountedCameraRenderer.kt

@@ -14,6 +14,7 @@ import com.cobblemon.mod.common.api.orientation.OrientationController
 import com.cobblemon.mod.common.api.orientation.OrientationController.Companion.FORWARDS
 import com.cobblemon.mod.common.api.orientation.OrientationController.Companion.LEFT
 import com.cobblemon.mod.common.api.orientation.OrientationController.Companion.UP
+import com.cobblemon.mod.common.api.riding.camera.RideLookSettings
 import com.cobblemon.mod.common.client.MountedPokemonAnimationRenderController
 import com.cobblemon.mod.common.client.entity.PokemonClientDelegate
 import com.cobblemon.mod.common.client.render.models.blockbench.FloatingState
@@ -36,17 +37,29 @@ import org.joml.Matrix3f
 import org.joml.Quaternionf
 import org.joml.Vector3d
 import org.joml.Vector3f
+import kotlin.math.asin
+import kotlin.math.atan2
 import kotlin.math.min
 import kotlin.math.sign
 import kotlin.math.sqrt
 
 object MountedCameraRenderer {
-    private var returnTimer: Float = 0f
+    private const val MIN_OFFSET_LENGTH = 1.0E-6
+    // Below this the forward vector is pointing almost straight up or down so it has no usable yaw
+    private const val MIN_HORIZONTAL_LENGTH_SQ = 1.0E-6f
+    // Entity.turn clamps pitch to this
+    private const val VANILLA_MAX_PITCH = 90f
+
     private var lastHandledRotationTime: Double = Double.MIN_VALUE
     private var frameTime: Double = 0.0
-    private var rollAngleStart: Float = 0f
 
-    var smoothRotation: Quaternionf? = null
+    private val state = RideCameraState()
+
+    /** Drops all per ride camera state. Called whenever the camera isn't on a ride. */
+    fun reset() = state.reset()
+
+    /** Degrees to roll the first person hands this frame */
+    fun getHandRoll(): Float = state.handRoll
 
     fun getCameraPosition(
         instance: Camera,
@@ -79,7 +92,7 @@ object MountedCameraRenderer {
         val locator = delegate.locatorStates[locatorName] ?: return null
 
         // Get additional offset from poser and add to the eyeHeight offset
-        val currEyeHeight: Double = Mth.lerp(instance.partialTickTime.toDouble(), eyeHeight, eyeHeightOld)
+        val currEyeHeight: Double = Mth.lerp(instance.partialTickTime.toDouble(), eyeHeightOld, eyeHeight)
         var offset = Vec3(0.0, currEyeHeight - (driver.bbHeight / 2), 0.0)
         var eyeOffset = Vec3(0.0, currEyeHeight - (driver.bbHeight / 2), 0.0)
 
@@ -126,10 +139,10 @@ object MountedCameraRenderer {
         } */
 
         val offsetDistance = offset.length()
-        val offsetDirection = offset.scale(1 / offsetDistance)
+        val offsetDirection = safeDirection(offset, offsetDistance)
 
         val eyeOffsetDistance = eyeOffset.length()
-        val eyeOffsetDirection = eyeOffset.scale(1 / eyeOffsetDistance)
+        val eyeOffsetDirection = safeDirection(eyeOffset, eyeOffsetDistance)
 
         // Use getMaxZoom to calculate clipping
         val maxZoom: Double = getMaxZoom(offsetDistance, offsetDirection, pos, instance)
@@ -143,6 +156,7 @@ object MountedCameraRenderer {
     // Return value is false if the vanilla camera rotations should be applied.
     fun setRotation(instance: Camera): Boolean {
         val cameraDuck = instance as CameraDuck
+        state.handRoll = 0f
 
         // Calculate the current frametime
         val d = Blaze3D.getTime()
@@ -152,6 +166,7 @@ object MountedCameraRenderer {
         // Don't assume the camera to be attached to an entity. Ponder Scenes from create et.al. for example aren't.
         val vehicle: Entity? = cameraDuck.`cobblemon$getEntity`()?.vehicle ?: return false
         if (vehicle !is OrientationControllable) return false
+        state.bindTo(vehicle.id)
 
         // If the current vehicle has no orientation then return and perform
         // vanilla camera rotations
@@ -161,11 +176,12 @@ object MountedCameraRenderer {
         // If the controller has been deactivated but the orientation isn't null yet
         // then perform transition from rolled ride/camera to vanilla
         if (!vehicleController.isActive() && vehicleController.orientation != null) {
+            state.lookSeeded = false
             return applyTransitionRotation(vehicleController, instance)
         } else { // Otherwise perform cobblemon specific camera rotation and set transition helper variables
             applyCameraRotation(instance)
-            returnTimer = 0f
-            rollAngleStart = instance.rotation().getEulerAnglesYXZ(Vector3f()).z()
+            state.returnTimer = 0f
+            state.rollAngleStart = instance.rotation().getEulerAnglesYXZ(Vector3f()).z()
             return true
         }
     }
@@ -182,25 +198,31 @@ object MountedCameraRenderer {
         val vehicleController: OrientationController = controllableVehicle.getOrientationController()
 
         val isDriving = driver.controlledVehicle != null
+        val ride = vehicle as? PokemonEntity
 
-
-        // Grab the ride orientation
-        // If the player is driving then use the current orientation since the driver sets it.
-        // If not then use the smoothed render orientation for passengers otherwise the vehicle rotation will be jerky
-        var newRotation = if (isDriving) {
-             vehicleController.orientation!!.normal(Matrix3f()).getNormalizedRotation(Quaternionf())
-        } else {
-            vehicleController.getRenderOrientation(instance.partialTickTime)
-        }
+        val context = state.context
+        context.update(
+            vehicleController.orientation!!.normal(Matrix3f()).getNormalizedRotation(Quaternionf()),
+            vehicleController.getRenderOrientation(instance.partialTickTime),
+            isDriving,
+            if (Minecraft.getInstance().isPaused) 0f else frameTime.toFloat(),
+            instance.partialTickTime
+        )
+        // The ride picks what the camera hangs off. disableRoll still gets the last word below since it's the player's setting
+        var newRotation = ride?.let { pokemon ->
+            pokemon.ifRidingAvailableSupply<Quaternionf?>(null) { behaviour, settings, rideState ->
+                behaviour.cameraBase(settings, rideState, pokemon, context)
+            }
+        } ?: context.defaultBase()
 
         // Unroll the current rotation if no roll is requested and not currently freelooking
         if (Cobblemon.config.disableRoll) {
             // Init the smooth rotation if it has not been set yet.
-            if (smoothRotation == null) {
-                smoothRotation = Quaternionf().set(instance.rotation())
+            if (state.smoothRotation == null) {
+                state.smoothRotation = Quaternionf().set(instance.rotation())
             }
             val rideAngs = newRotation.getEulerAnglesYXZ(Vector3f())
-            val cameraAngs = smoothRotation!!.getEulerAnglesYXZ(Vector3f())
+            val cameraAngs = state.smoothRotation!!.getEulerAnglesYXZ(Vector3f())
 
             val degDiff = Mth.degreesDifference(
                 Math.toDegrees(cameraAngs.y().toDouble()).toFloat(),
@@ -237,37 +259,103 @@ object MountedCameraRenderer {
 
             // Set rotations
             val smoothedRot = Quaternionf().rotateYXZ(newYaw.toFloat(), newPitch.toFloat(), newRoll)
-            smoothRotation?.set(smoothedRot)
+            state.smoothRotation?.set(smoothedRot)
             newRotation.set(smoothedRot)
 
         }
 
-        var rotationOffset = 0
-        if (Minecraft.getInstance().options.cameraType.isMirrored) {
-            newRotation.rotateY(Math.toRadians(180.0).toFloat())
-            rotationOffset = 180
+        // newRotation is the camera base from here on
+        val playerRotater = driver as RidePassenger
+        // First frame on a roll ride so carry over wherever the player was already looking
+        if (!state.lookSeeded) {
+            seedLook(driver, playerRotater, newRotation)
+            state.lookSeeded = true
+        } else {
+            val carry = ride?.let { pokemon ->
+                pokemon.ifRidingAvailableSupply(RideLookSettings.DEFAULT) { behaviour, settings, rideState ->
+                    behaviour.lookSettings(settings, rideState, pokemon)
+                }.carry
+            } ?: RideLookSettings.FULL_CARRY
+            val previousBase = context.previousBase
+            // Full carry is exactly what the look angles already do so skip the work
+            if (carry < RideLookSettings.FULL_CARRY && previousBase != null) {
+                carryLook(playerRotater, previousBase, newRotation, carry)
+            }
         }
+        context.finishFrame(newRotation)
 
+        // Look sits on top of the base. Built straight as a quaternion so nothing round trips through euler angles
+        val view = Quaternionf(newRotation).mul(lookRotation(playerRotater)).normalize()
 
-        // Get the drivers local look angle in relation to the ride and apply it.
-        if (vehicleController.active) {
-            val vehicleMatrix = Matrix3f().set(newRotation)
-            val driverMatrix = Matrix3f() // Base the driver
-            val playerRotater = driver as RidePassenger
-            newRotation = vehicleMatrix.mul(
-                driverMatrix.rotateYXZ(
-                    -Mth.DEG_TO_RAD * (playerRotater.`cobblemon$getRideYRot`()),
-                    -Mth.DEG_TO_RAD * playerRotater.`cobblemon$getRideXRot`(),
-                    0.0f
-                )
-            ).normal(Matrix3f()).getNormalizedRotation(Quaternionf())
+        // Mirroring only flips the camera so the player still aims where they look
+        val cameraRotation = if (Minecraft.getInstance().options.cameraType.isMirrored) Quaternionf(view).rotateY(Mth.PI) else view
+        setCameraRotations(cameraRotation, instance, cameraDuck)
+        lookAlong(driver, view)
+
+        // Third person shows the player model which already leans with the ride
+        context.updateView(view)
+        if (Minecraft.getInstance().options.cameraType.isFirstPerson) {
+            state.handRoll = ride?.let { pokemon ->
+                pokemon.ifRidingAvailableSupply(0f) { behaviour, settings, rideState ->
+                    behaviour.firstPersonHandRoll(settings, rideState, pokemon, context)
+                }
+            } ?: 0f
         }
-        val eulerAngs = newRotation.getEulerAnglesYXZ(Vector3f())
-        setCameraRotations(newRotation, instance, cameraDuck)
+    }
 
-        // Set the drivers rotations to match
-        driver.xRot = -eulerAngs.x() * Mth.RAD_TO_DEG + rotationOffset
-        driver.yRot = 180.0f - (eulerAngs.y() * Mth.RAD_TO_DEG)
+    /** Sets ride look angles so the view keeps pointing where [player] already looks once [base] takes over. */
+    private fun seedLook(player: Entity, rotater: RidePassenger, base: Quaternionf) {
+        val local = Quaternionf(base).invert().transform(player.calculateViewVector(player.xRot, player.yRot).toVector3f())
+        setLookFromLocal(rotater, local)
+    }
+
+    /**
+     * Turns the look by only [carry] of how far the base turned since last frame.
+     * Whatever the look doesn't follow ends up as a change in the look angles instead.
+     */
+    private fun carryLook(rotater: RidePassenger, previousBase: Quaternionf, base: Quaternionf, carry: Float) {
+        val worldLook = Quaternionf(previousBase).mul(lookRotation(rotater))
+        val baseDelta = Quaternionf(base).mul(Quaternionf(previousBase).invert())
+        Quaternionf().slerp(baseDelta, carry).mul(worldLook, worldLook)
+        val local = Quaternionf(base).invert().transform(FORWARDS.rotate(worldLook, Vector3f()))
+        setLookFromLocal(rotater, local)
+    }
+
+    /** Look as a rotation relative to the base. */
+    private fun lookRotation(rotater: RidePassenger): Quaternionf = Quaternionf().rotationYXZ(
+        -Mth.DEG_TO_RAD * rotater.`cobblemon$getRideYRot`(),
+        -Mth.DEG_TO_RAD * rotater.`cobblemon$getRideXRot`(),
+        0.0f
+    )
+
+    /** Look angles that point along [local], a direction in the base's frame. Inverse of [lookRotation]. */
+    private fun setLookFromLocal(rotater: RidePassenger, local: Vector3f) {
+        rotater.`cobblemon$setRideXRot`(-asin(local.y.coerceIn(-1f, 1f)) * Mth.RAD_TO_DEG)
+        rotater.`cobblemon$setRideYRot`(atan2(local.x, -local.z) * Mth.RAD_TO_DEG)
+    }
+
+    /**
+     * Points [player] along [view] so picking, bows and other clients follow the camera.
+     * Yaw stays continuous so partial tick lerps never sweep through a 360 wrap.
+     */
+    private fun lookAlong(player: Entity, view: Quaternionf) {
+        val forward = FORWARDS.rotate(view, Vector3f())
+        val pitch = pitchOf(forward)
+        val yaw = player.yRot + Mth.wrapDegrees(yawOf(forward, player.yRot) - player.yRot)
+        // Shift the old values by the same amount like vanilla turn does so the lerped view vector doesn't trail a tick behind
+        player.xRotO = Mth.clamp(player.xRotO + pitch - player.xRot, -VANILLA_MAX_PITCH, VANILLA_MAX_PITCH)
+        player.yRotO += yaw - player.yRot
+        player.xRot = pitch
+        player.yRot = yaw
+    }
+
+    /** Vanilla style pitch in degrees for a forward vector. */
+    private fun pitchOf(forward: Vector3f): Float = -asin(forward.y.coerceIn(-1f, 1f)) * Mth.RAD_TO_DEG
+
+    /** Vanilla style yaw in degrees for a forward vector, or [fallback] when looking straight up or down. */
+    private fun yawOf(forward: Vector3f, fallback: Float): Float {
+        if (forward.x * forward.x + forward.z * forward.z < MIN_HORIZONTAL_LENGTH_SQ) return fallback
+        return atan2(-forward.x, forward.z) * Mth.RAD_TO_DEG
     }
 
     private fun applyTransitionRotation(
@@ -277,14 +365,14 @@ object MountedCameraRenderer {
         val cameraDuck = instance as CameraDuck
         val entity = cameraDuck.`cobblemon$getEntity`()!!
         // If the transition has just started then
-        if (returnTimer == 0f) {
+        if (state.returnTimer == 0f) {
             resetDriverRotations(instance, entity)
         }
 
-        if (returnTimer < 1f) {
+        if (state.returnTimer < 1f) {
             // Rotation is taken from entity since we no longer handle mouse ourselves
             // Stops a period of time when you can't input anything.
-            val interpolatedRoll = Mth.lerp(returnTimer, rollAngleStart, 0.0f)
+            val interpolatedRoll = Mth.lerp(state.returnTimer, state.rollAngleStart, 0.0f)
             val pitch = Math.toRadians(-entity.xRot.toDouble()).toFloat()
             val yaw = Math.toRadians((180 - entity.yRot).toDouble()).toFloat()
 
@@ -293,16 +381,16 @@ object MountedCameraRenderer {
 
             setCameraRotations(interRot, instance, cameraDuck)
 
-            if (rollAngleStart == 0f) {
-                rollAngleStart = 1f
+            if (state.rollAngleStart == 0f) {
+                state.rollAngleStart = 1f
                 vehicleController.reset()
                 resetDriverRotations(instance, entity)
                 return false
             }
-            returnTimer += instance.partialTickTime * (1.0f / 20.0f)
+            state.returnTimer += instance.partialTickTime * (1.0f / 20.0f)
             return true
         } else {
-            returnTimer = 1f
+            state.returnTimer = 1f
             vehicleController.reset()
             resetDriverRotations(instance, entity)
             return false
@@ -329,7 +417,7 @@ object MountedCameraRenderer {
         val offset = if (thirdPersonReverse && cameraOffsets.containsKey(locatorName + "_reverse")) {
             cameraOffsets[locatorName + "_reverse"]!!
         } else if (thirdPersonReverse && cameraOffsets.containsKey("seat_default_reverse")) {
-            cameraOffsets[locatorName + "seat_default_reverse"]!!
+            cameraOffsets["seat_default_reverse"]!!
         } else if (cameraOffsets.containsKey(locatorName)) {
             cameraOffsets[locatorName]!!
         } else if (cameraOffsets.containsKey("seat_default")) {
@@ -354,6 +442,10 @@ object MountedCameraRenderer {
     }
 
 
+    /** Unit direction of [offset], or zero when it's too short to have one (avoids NaN from 0 / 0). */
+    private fun safeDirection(offset: Vec3, length: Double): Vec3 =
+        if (length > MIN_OFFSET_LENGTH) offset.scale(1 / length) else Vec3.ZERO
+
     private fun getMaxZoom(maxZoom: Double, directionVector: Vec3, positionVector: Vec3, instance: Camera): Double {
         var maxZoom = maxZoom
         for (i in 0 .. 7) {
@@ -384,14 +476,14 @@ object MountedCameraRenderer {
     }
 
     private fun setCameraRotations(rotation: Quaternionf, instance: Camera, duck: CameraDuck) {
-        val eulerAngs = rotation.getEulerAnglesYXZ(Vector3f())
-        val cameraRotation = instance.rotation()
-        cameraRotation.rotationYXZ(eulerAngs.y, eulerAngs.x, eulerAngs.z)
-        duck.`cobblemon$setXRot`(eulerAngs.x() * Mth.RAD_TO_DEG)
-        duck.`cobblemon$setYRot`(eulerAngs.y() * Mth.RAD_TO_DEG)
-
-        FORWARDS.rotate(rotation, duck.`cobblemon$getForwards`())
-        UP.rotate(rotation, duck.`cobblemon$getUp`())
+        val cameraRotation = instance.rotation().set(rotation).normalize()
+        FORWARDS.rotate(cameraRotation, duck.`cobblemon$getForwards`())
+        UP.rotate(cameraRotation, duck.`cobblemon$getUp`())
         LEFT.rotate(cameraRotation, duck.`cobblemon$getLeft`())
+
+        // Same yaw and pitch convention vanilla setRotation stores since vanilla reads these back
+        val forward = duck.`cobblemon$getForwards`()
+        duck.`cobblemon$setXRot`(pitchOf(forward))
+        duck.`cobblemon$setYRot`(yawOf(forward, duck.`cobblemon$getYRot`()))
     }
 }

common/src/main/kotlin/com/cobblemon/mod/common/client/render/camera/RideCameraState.kt

@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.client.render.camera
+
+import com.cobblemon.mod.common.api.riding.camera.RideCameraContext
+import org.joml.Quaternionf
+
+/**
+ * Camera state for the ride the local player is on.
+ * Tied to one vehicle so nothing leaks from one ride into the next.
+ */
+class RideCameraState {
+    companion object {
+        private const val NO_VEHICLE = -1
+    }
+
+    var vehicleId: Int = NO_VEHICLE
+        private set
+
+    // 0 to 1 progress of the roll going back to level once a roll ride turns off
+    var returnTimer: Float = 0f
+    // Camera roll at the start of that transition
+    var rollAngleStart: Float = 0f
+    // Smoothed rotation the disableRoll camera eases with
+    var smoothRotation: Quaternionf? = null
+    // False until the look has been rebuilt from the player's real look for this stretch of rolling
+    var lookSeeded: Boolean = false
+    // Degrees the first person hands are rolled this frame
+    var handRoll: Float = 0f
+    // Handed to the ride's camera hooks every frame
+    val context = RideCameraContext()
+
+    /** Starts fresh if [vehicleId] isn't the vehicle this state was built for. */
+    fun bindTo(vehicleId: Int) {
+        if (this.vehicleId == vehicleId) return
+        reset()
+        this.vehicleId = vehicleId
+    }
+
+    fun reset() {
+        vehicleId = NO_VEHICLE
+        returnTimer = 0f
+        rollAngleStart = 0f
+        smoothRotation = null
+        lookSeeded = false
+        handRoll = 0f
+        context.reset()
+    }
+}

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

@@ -34,6 +34,7 @@ import com.cobblemon.mod.common.client.render.models.blockbench.bedrock.animatio
 import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
 import com.cobblemon.mod.common.client.render.models.blockbench.quirk.ModelQuirk
 import com.cobblemon.mod.common.client.render.models.blockbench.quirk.QuirkData
+import com.cobblemon.mod.common.client.sound.instances.UIEntitySoundInstance
 import com.cobblemon.mod.common.entity.PosableEntity
 import com.cobblemon.mod.common.entity.PoseType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
@@ -44,7 +45,6 @@ import com.mojang.brigadier.exceptions.CommandSyntaxException
 import java.util.concurrent.ConcurrentLinkedQueue
 import net.minecraft.client.Minecraft
 import net.minecraft.client.multiplayer.ClientLevel
-import net.minecraft.client.resources.sounds.SimpleSoundInstance
 import net.minecraft.commands.arguments.item.ItemParser
 import net.minecraft.sounds.SoundEvent
 import net.minecraft.world.entity.Entity
@@ -289,7 +289,7 @@ abstract class PosableState : Schedulable {
                         entity.level().playLocalSound(entity, soundEvent, entity.soundSource, volume, pitch)
                     }
                 } else {
-                    Minecraft.getInstance().soundManager.play(SimpleSoundInstance.forUI(soundEvent, volume, pitch))
+                    Minecraft.getInstance().soundManager.play(UIEntitySoundInstance(soundEvent, volume, pitch))
                 }
             }
         }

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

@@ -19,6 +19,7 @@ import com.cobblemon.mod.common.client.render.models.blockbench.PosableState
 import com.cobblemon.mod.common.client.render.models.blockbench.pose.Bone
 import com.cobblemon.mod.common.client.render.models.blockbench.repository.RenderContext
 import com.cobblemon.mod.common.client.sound.instances.AlphaCrySoundInstance
+import com.cobblemon.mod.common.client.sound.instances.UIEntitySoundInstance
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.effectiveName
 import com.cobblemon.mod.common.util.genericRuntime
@@ -31,7 +32,6 @@ import net.minecraft.client.Minecraft
 import net.minecraft.client.model.geom.ModelPart
 import net.minecraft.client.multiplayer.ClientLevel
 import net.minecraft.client.resources.sounds.EntityBoundSoundInstance
-import net.minecraft.client.resources.sounds.SimpleSoundInstance
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.sounds.SoundEvent
 import net.minecraft.world.entity.Entity
@@ -121,7 +121,7 @@ class BedrockSoundKeyframe(
                     }
                 }
             } else {
-                Minecraft.getInstance().soundManager.play(SimpleSoundInstance.forUI(soundEvent, 1F, 1F))
+                Minecraft.getInstance().soundManager.play(UIEntitySoundInstance(soundEvent))
             }
         }
     }

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

@@ -1,98 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.client.render.models.blockbench.pokemon.gen1
-
-import com.cobblemon.mod.common.client.render.models.blockbench.PosableState
-import com.cobblemon.mod.common.client.render.models.blockbench.createTransformation
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.HeadedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.CryProvider
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonPosableModel
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.CobblemonPose
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.ModelPartTransformation
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
-import com.cobblemon.mod.common.entity.PoseType
-import com.cobblemon.mod.common.entity.PoseType.Companion.MOVING_POSES
-import com.cobblemon.mod.common.entity.PoseType.Companion.STATIONARY_POSES
-import com.cobblemon.mod.common.entity.PoseType.Companion.UI_POSES
-import net.minecraft.client.model.geom.ModelPart
-import net.minecraft.world.phys.Vec3
-
-class CaterpieModel(root: ModelPart) : PokemonPosableModel(root), HeadedFrame {
-    override val rootPart = root.registerChildWithAllChildren("caterpie")
-    override val head = getPart("head")
-
-    override var portraitScale = 2.1F
-    override var portraitTranslation = Vec3(-0.55, -1.55, 0.0)
-    override var profileScale = 0.8F
-    override var profileTranslation = Vec3(0.0, 0.55, 0.0)
-
-    lateinit var sleep: Pose
-    lateinit var standing: Pose
-    lateinit var walk: Pose
-    lateinit var shoulderLeft: CobblemonPose
-    lateinit var shoulderRight: CobblemonPose
-
-    val shoulderOffset = 3
-
-
-    override val cryAnimation = CryProvider { bedrockStateful("caterpie", "cry") }
-
-    override fun registerPoses() {
-        val blink = quirk { bedrockStateful("caterpie", "blink")}
-        sleep = registerPose(
-            poseType = PoseType.SLEEP,
-            transformTicks = 10,
-            animations = arrayOf(bedrock("caterpie", "sleep"))
-        )
-
-        standing = registerPose(
-            poseName = "standing",
-            poseTypes = STATIONARY_POSES + UI_POSES,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("caterpie", "ground_idle")
-            )
-        )
-
-        walk = registerPose(
-            poseName = "walking",
-            poseTypes = MOVING_POSES,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("caterpie", "ground_walk")
-            )
-        )
-
-        shoulderLeft = registerPose(
-                poseType = PoseType.SHOULDER_LEFT,
-                quirks = arrayOf(blink),
-                animations = arrayOf(
-                        bedrock("caterpie", "ground_idle")
-                ),
-                transformedParts = arrayOf(
-                        rootPart.createTransformation().addPosition(ModelPartTransformation.X_AXIS, shoulderOffset)
-                )
-        )
-
-        shoulderRight = registerPose(
-                poseType = PoseType.SHOULDER_RIGHT,
-                quirks = arrayOf(blink),
-                animations = arrayOf(
-                        bedrock("caterpie", "ground_idle")
-                ),
-                transformedParts = arrayOf(
-                        rootPart.createTransformation().addPosition(ModelPartTransformation.X_AXIS, -shoulderOffset)
-                )
-        )
-    }
-
-    override fun getFaintAnimation(state: PosableState) = bedrockStateful("caterpie", "faint")
-}

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

@@ -29,8 +29,8 @@ class FarfetchdGalarianModel(root: ModelPart) : PokemonPosableModel(root), Heade
     override var portraitScale = 2.6F
     override var portraitTranslation = Vec3(-0.2, -1.0, 0.0)
 
-    override var profileScale = 1.1F
-    override var profileTranslation = Vec3(-0.1, 0.1, 0.0)
+    override var profileScale = 0.93F
+    override var profileTranslation = Vec3(-0.1, 0.36, 0.0)
 
     lateinit var standing: Pose
     lateinit var walk: Pose

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

@@ -28,8 +28,8 @@ class FarfetchdModel(root: ModelPart) : PokemonPosableModel(root), HeadedFrame,
     override var portraitScale = 2.6F
     override var portraitTranslation = Vec3(-0.2, -1.0, 0.0)
 
-    override var profileScale = 1.1F
-    override var profileTranslation = Vec3(-0.1, 0.1, 0.0)
+    override var profileScale = 0.93F
+    override var profileTranslation = Vec3(-0.1, 0.36, 0.0)
 
     lateinit var standing: Pose
     lateinit var walk: Pose

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

@@ -23,8 +23,8 @@ class KabutoModel(root: ModelPart) : PokemonPosableModel(root) {
     override var portraitScale = 3.3F
     override var portraitTranslation = Vec3(0.0, -3.3, 0.0)
 
-    override var profileScale = 1.6F
-    override var profileTranslation = Vec3(0.0, -0.6, 0.0)
+    override var profileScale = 1.25F
+    override var profileTranslation = Vec3(0.0, -0.17, 0.0)
 
     lateinit var standing: CobblemonPose
     lateinit var walk: CobblemonPose

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

@@ -1,98 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.client.render.models.blockbench.pokemon.gen1
-
-import com.cobblemon.mod.common.client.render.models.blockbench.PosableState
-import com.cobblemon.mod.common.client.render.models.blockbench.createTransformation
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.HeadedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.CryProvider
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonPosableModel
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.ModelPartTransformation
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
-import com.cobblemon.mod.common.entity.PoseType
-import com.cobblemon.mod.common.entity.PoseType.Companion.MOVING_POSES
-import com.cobblemon.mod.common.entity.PoseType.Companion.STATIONARY_POSES
-import com.cobblemon.mod.common.entity.PoseType.Companion.UI_POSES
-import net.minecraft.client.model.geom.ModelPart
-import net.minecraft.world.phys.Vec3
-
-class WeedleModel(root: ModelPart) : PokemonPosableModel(root), HeadedFrame {
-    override val rootPart = root.registerChildWithAllChildren("weedle")
-    override val head = getPart("head")
-
-    override var portraitScale = 2.2F
-    override var portraitTranslation = Vec3(-0.31, -1.83, 0.0)
-    override var profileScale = 0.8F
-    override var profileTranslation = Vec3(0.1, 0.6, 0.0)
-
-    lateinit var sleep: Pose
-    lateinit var standing: Pose
-    lateinit var walk: Pose
-    lateinit var shoulderLeft: Pose
-    lateinit var shoulderRight: Pose
-
-    val shoulderOffset = 3.8
-    val shoulderZOffset = -3
-
-    override val cryAnimation = CryProvider { bedrockStateful("weedle", "cry") }
-
-    override fun registerPoses() {
-        val blink = quirk { bedrockStateful("weedle", "blink")}
-        sleep = registerPose(
-            poseType = PoseType.SLEEP,
-            animations = arrayOf(bedrock("weedle", "sleep"))
-        )
-
-        standing = registerPose(
-            poseName = "standing",
-            poseTypes = STATIONARY_POSES + UI_POSES,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("weedle", "ground_idle2")
-            )
-        )
-
-        walk = registerPose(
-            poseName = "walk",
-            poseTypes = MOVING_POSES,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("weedle", "ground_walk")
-            )
-        )
-
-        shoulderLeft = registerPose(
-                poseType = PoseType.SHOULDER_LEFT,
-                quirks = arrayOf(blink),
-                animations = arrayOf(
-                        bedrock("weedle", "ground_idle")
-                ),
-                transformedParts = arrayOf(
-                        rootPart.createTransformation().addPosition(ModelPartTransformation.X_AXIS, shoulderOffset),
-                        rootPart.createTransformation().addPosition(ModelPartTransformation.Z_AXIS, shoulderZOffset)
-                )
-        )
-
-        shoulderRight = registerPose(
-                poseType = PoseType.SHOULDER_RIGHT,
-                quirks = arrayOf(blink),
-                animations = arrayOf(
-                        bedrock("weedle", "ground_idle")
-                ),
-                transformedParts = arrayOf(
-                        rootPart.createTransformation().addPosition(ModelPartTransformation.X_AXIS, -shoulderOffset),
-                        rootPart.createTransformation().addPosition(ModelPartTransformation.Z_AXIS, shoulderZOffset)
-                )
-        )
-    }
-
-    override fun getFaintAnimation(state: PosableState) = bedrockStateful("weedle", "faint")
-}

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

@@ -21,8 +21,8 @@ class HoothootModel (root: ModelPart) : PokemonPosableModel(root) {
 
     override var portraitScale = 2.2F
     override var portraitTranslation = Vec3(-0.25, -0.9, 0.0)
-    override var profileScale = 1.0F
-    override var profileTranslation = Vec3(0.0, 0.3, 0.0)
+    override var profileScale = 0.82F
+    override var profileTranslation = Vec3(0.0, 0.53, 0.0)
 
     lateinit var standing: Pose
     lateinit var walk: Pose

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

@@ -29,8 +29,8 @@ class WooperModel(root: ModelPart) : PokemonPosableModel(root), HeadedFrame {
     override var portraitScale = 2.0F
     override var portraitTranslation = Vec3(-0.15, -0.65, 0.0)
 
-    override var profileScale = 0.9F
-    override var profileTranslation = Vec3(0.0, 0.4, 0.0)
+    override var profileScale = 0.75F
+    override var profileTranslation = Vec3(0.0, 0.6, 0.0)
 
     lateinit var shoulderLeft: Pose
     lateinit var shoulderRight: Pose

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

@@ -29,8 +29,8 @@ class WooperPaldeanModel(root: ModelPart) : PokemonPosableModel(root), HeadedFra
     override var portraitScale = 2.0F
     override var portraitTranslation = Vec3(-0.15, -0.65, 0.0)
 
-    override var profileScale = 0.9F
-    override var profileTranslation = Vec3(0.0, 0.4, 0.0)
+    override var profileScale = 0.75F
+    override var profileTranslation = Vec3(0.0, 0.6, 0.0)
 
     lateinit var shoulderLeft: Pose
     lateinit var shoulderRight: Pose

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

@@ -12,6 +12,7 @@ import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonP
 import com.cobblemon.mod.common.client.render.models.blockbench.frame.HeadedFrame
 import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
 import com.cobblemon.mod.common.entity.PoseType
+import com.cobblemon.mod.common.util.asExpressionLike
 import net.minecraft.client.model.geom.ModelPart
 import net.minecraft.world.phys.Vec3
 
@@ -28,6 +29,8 @@ class MasquerainModel(root: ModelPart) : PokemonPosableModel(root), HeadedFrame
     lateinit var walk: Pose
     lateinit var standing: Pose
     override fun registerPoses() {
+        animations["cry"] = "q.bedrock_stateful('masquerain', 'cry')".asExpressionLike()
+
         val blink = quirk { bedrockStateful("masquerain", "blink") }
         standing = registerPose(
             poseName = "standing",

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

@@ -14,6 +14,7 @@ import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonP
 import com.cobblemon.mod.common.client.render.models.blockbench.pose.ModelPartTransformation
 import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
 import com.cobblemon.mod.common.entity.PoseType
+import com.cobblemon.mod.common.util.asExpressionLike
 import com.cobblemon.mod.common.util.isInWater
 import net.minecraft.client.model.geom.ModelPart
 import net.minecraft.world.phys.Vec3
@@ -36,6 +37,8 @@ class SurskitModel(root: ModelPart) : PokemonPosableModel(root), HeadedFrame {
     val wateroffset = -8
 
     override fun registerPoses() {
+        animations["cry"] = "q.bedrock_stateful('surskit', 'cry')".asExpressionLike()
+
         val blink = quirk { bedrockStateful("surskit", "blink") }
         standing = registerPose(
             poseName = "standing",

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

@@ -14,6 +14,7 @@ import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonP
 import com.cobblemon.mod.common.client.render.models.blockbench.pose.ModelPartTransformation
 import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
 import com.cobblemon.mod.common.entity.PoseType
+import com.cobblemon.mod.common.util.asExpressionLike
 import net.minecraft.client.model.geom.ModelPart
 import net.minecraft.world.phys.Vec3
 
@@ -36,6 +37,8 @@ class CombeeModel (root: ModelPart) : PokemonPosableModel(root) {
     val shoulderZOffset = 8
 
     override fun registerPoses() {
+        animations["cry"] = "q.bedrock_stateful('combee', 'cry')".asExpressionLike()
+
         val blink1 = quirk { bedrockStateful("combee", "blink_right") }
         val blink2 = quirk { bedrockStateful("combee", "blink_gender") }
         val blink3 = quirk { bedrockStateful("combee", "blink_left") }

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

@@ -12,6 +12,7 @@ import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonP
 import com.cobblemon.mod.common.client.render.models.blockbench.PosableState
 import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
 import com.cobblemon.mod.common.entity.PoseType
+import com.cobblemon.mod.common.util.asExpressionLike
 import net.minecraft.client.model.geom.ModelPart
 import net.minecraft.world.phys.Vec3
 
@@ -30,6 +31,8 @@ class VespiquenModel (root: ModelPart) : PokemonPosableModel(root) {
     lateinit var standing: Pose
 
     override fun registerPoses() {
+        animations["cry"] = "q.bedrock_stateful('vespiquen', 'cry')".asExpressionLike()
+
         val blink1 = quirk { bedrockStateful("vespiquen", "blink") }
         val wingsleep = quirk { bedrockStateful("vespiquen", "sleep_flap") }
 

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen5/JellicentModel.kt

@@ -1,59 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.client.render.models.blockbench.pokemon.gen5
-
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.HeadedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonPosableModel
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.CobblemonPose
-import com.cobblemon.mod.common.entity.PoseType
-import net.minecraft.client.model.geom.ModelPart
-import net.minecraft.world.phys.Vec3
-
-class JellicentModel (root: ModelPart) : PokemonPosableModel(root), HeadedFrame {
-    override val rootPart = root.registerChildWithAllChildren("jellicent")
-    override val head = getPart("head")
-
-    override var portraitScale = 1.13F
-    override var portraitTranslation = Vec3(-0.56, 1.64, 0.0)
-
-    override var profileScale = 0.51F
-    override var profileTranslation = Vec3(0.0, 1.05, 0.0)
-
-    lateinit var standing: CobblemonPose
-    lateinit var walk: CobblemonPose
-
-    override fun registerPoses() {
-        val blink = quirk { bedrockStateful("jellicent", "blink") }
-
-        standing = registerPose(
-            poseName = "standing",
-            poseTypes = PoseType.STATIONARY_POSES + PoseType.UI_POSES,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("jellicent", "render")
-            )
-        )
-
-        walk = registerPose(
-            poseName = "walk",
-            poseTypes = PoseType.MOVING_POSES,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("jellicent", "render")
-            )
-        )
-    }
-
-//    override fun getFaintAnimation(
-//        pokemonEntity: PokemonEntity,
-//        state: PosableState<PokemonEntity>
-//    ) = if (state.isPosedIn(standing, walk)) bedrockStateful("jellicent", "faint") else null
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen5/SerperiorModel.kt

@@ -1,62 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.client.render.models.blockbench.pokemon.gen5
-
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.HeadedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.CryProvider
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonPosableModel
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
-import com.cobblemon.mod.common.entity.PoseType
-import net.minecraft.client.model.geom.ModelPart
-import net.minecraft.world.phys.Vec3
-
-class SerperiorModel (root: ModelPart) : PokemonPosableModel(root), HeadedFrame {
-    override val rootPart = root.registerChildWithAllChildren("serperior")
-    override val head = getPart("head_ai")
-
-    override var portraitScale = 2.5F
-    override var portraitTranslation = Vec3(-0.3, 1.25, 0.0)
-
-    override var profileScale = 0.6F
-    override var profileTranslation = Vec3(0.0, 0.8, 0.0)
-
-    lateinit var standing: Pose
-    lateinit var walk: Pose
-    lateinit var sleep: Pose
-
-    override val cryAnimation = CryProvider { bedrockStateful("serperior", "cry") }
-
-    override fun registerPoses() {
-        val blink = quirk { bedrockStateful("serperior", "blink") }
-        sleep = registerPose(
-            poseType = PoseType.SLEEP,
-            animations = arrayOf(bedrock("serperior", "sleep"))
-        )
-
-        standing = registerPose(
-            poseName = "standing",
-            poseTypes = PoseType.STATIONARY_POSES + PoseType.UI_POSES,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("serperior", "ground_idle")
-            )
-        )
-
-        walk = registerPose(
-            poseName = "walk",
-            poseTypes = PoseType.MOVING_POSES,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("serperior", "ground_walk")
-            )
-        )
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen5/ServineModel.kt

@@ -1,70 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.client.render.models.blockbench.pokemon.gen5
-
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.BimanualFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.BipedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.HeadedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.CryProvider
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonPosableModel
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
-import com.cobblemon.mod.common.entity.PoseType
-import net.minecraft.client.model.geom.ModelPart
-import net.minecraft.world.phys.Vec3
-
-class ServineModel (root: ModelPart) : PokemonPosableModel(root), HeadedFrame, BipedFrame, BimanualFrame {
-    override val rootPart = root.registerChildWithAllChildren("servine")
-    override val head = getPart("head_ai")
-    override val rightArm = getPart("arm_right")
-    override val leftArm = getPart("arm_left")
-    override val rightLeg = getPart("leg_right")
-    override val leftLeg = getPart("leg_left")
-
-    override var portraitScale = 2.6F
-    override var portraitTranslation = Vec3(-0.15, 0.75, 0.0)
-    override var profileScale = 0.8F
-    override var profileTranslation = Vec3(0.0, 0.55, 0.0)
-
-    lateinit var sleep: Pose
-    lateinit var standing: Pose
-    lateinit var walk: Pose
-
-    override val cryAnimation = CryProvider { bedrockStateful("servine", "cry") }
-
-    override fun registerPoses() {
-        val blink = quirk { bedrockStateful("servine", "blink") }
-        sleep = registerPose(
-            poseType = PoseType.SLEEP,
-            transformTicks = 10,
-            animations = arrayOf(bedrock("servine", "sleep"))
-        )
-
-        standing = registerPose(
-            poseName = "standing",
-            poseTypes = PoseType.STATIONARY_POSES + PoseType.UI_POSES,
-            transformTicks = 10,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("servine", "ground_idle")
-            )
-        )
-
-        walk = registerPose(
-            poseName = "walking",
-            poseTypes =  PoseType.MOVING_POSES,
-            transformTicks = 10,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("servine", "ground_walk")
-            )
-        )
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen5/SnivyModel.kt

@@ -1,70 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.client.render.models.blockbench.pokemon.gen5
-
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.BimanualFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.BipedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.HeadedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.CryProvider
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonPosableModel
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
-import com.cobblemon.mod.common.entity.PoseType
-import net.minecraft.client.model.geom.ModelPart
-import net.minecraft.world.phys.Vec3
-
-class SnivyModel (root: ModelPart) : PokemonPosableModel(root), HeadedFrame, BipedFrame, BimanualFrame {
-    override val rootPart = root.registerChildWithAllChildren("snivy")
-    override val head = getPart("head_ai")
-    override val rightArm = getPart("arm_right")
-    override val leftArm = getPart("arm_left")
-    override val rightLeg = getPart("leg_right")
-    override val leftLeg = getPart("leg_left")
-
-    override var portraitScale = 2.0F
-    override var portraitTranslation = Vec3(-0.15, 0.32, 0.0)
-    override var profileScale = 0.8F
-    override var profileTranslation = Vec3(0.0, 0.55, 0.0)
-
-    lateinit var sleep: Pose
-    lateinit var standing: Pose
-    lateinit var walk: Pose
-
-    override val cryAnimation = CryProvider { bedrockStateful("snivy", "cry") }
-
-    override fun registerPoses() {
-        val blink = quirk { bedrockStateful("snivy", "blink") }
-        sleep = registerPose(
-            poseType = PoseType.SLEEP,
-            transformTicks = 10,
-            animations = arrayOf(bedrock("snivy", "sleep"))
-        )
-
-        standing = registerPose(
-            poseName = "standing",
-            poseTypes = PoseType.STATIONARY_POSES + PoseType.UI_POSES,
-            transformTicks = 10,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("snivy", "ground_idle")
-            )
-        )
-
-        walk = registerPose(
-            poseName = "walking",
-            poseTypes =  PoseType.MOVING_POSES,
-            transformTicks = 10,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("snivy", "ground_walk")
-            )
-        )
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen6/CarbinkModel.kt

@@ -23,7 +23,7 @@ class CarbinkModel (root: ModelPart) : PokemonPosableModel(root) {
     override var portraitScale = 1.8F
     override var portraitTranslation = Vec3(0.0, 0.2, 0.0)
 
-    override var profileScale = 0.85F
+    override var profileScale = 0.68F
     override var profileTranslation = Vec3(0.0, 0.7, 0.0)
 
     lateinit var standing: CobblemonPose