Finalization Of The System

Makes Poké Snacks act as spawners

See merge request cable-mc/cobblemon!1915

.gitignore

@@ -12,7 +12,8 @@ out
 *.ipr
 *.iws
 *.iml
-.idea
+.idea/*
+!.idea/icon.png
 
 # gradle
 build

CHANGELOG-AI.md

@@ -15,6 +15,9 @@
 - baseScale in NPCs has been removed from classes and presets, and in the entity it is replaced with hitboxScale and renderScale.
 - Added `EntityCallbacks` to `NPCEntity` and `PokemonEntity`. You can trigger custom callback types by using `[Entity].callbacks.process(...)`
 
+### Fixes
+- Fixed Pokémon with a moving walk target frequently spinning in place as they re-calculate their path.
+
 ### MoLang & Datapacks
 - Added a `behaviours` datapack folder which motivates the Behaviour Editor screen on NPCs and Pokémon.
 - Added "callback" support on PokemonEntity and NPCEntity that allows MoLang scripts to be executed in response to certain scenarios.

CHANGELOG-PC.md

@@ -22,6 +22,7 @@
 ### Changes
 - Slots in pastures will now have darker backgrounds and italicised Pokémon names if the Pokémon is not owned by the player.
 - The pasture slot will show the name of the Pokémon owner when hovered if the Pokémon is not owned.
+- Increased the default PC box count from 30 to 40 to accommodate the fact that we have way more Pokémon now. If you've changed this config option then you'll need to edit it again after starting up with 1.7!
 
 ### Developer
 - Added `RenamePCBoxEvent.Pre` and `RenamePCBoxEvent.Post` events to prevent players from renaming a box or changing their input.

CHANGELOG-SPAWNING.md

@@ -4,6 +4,7 @@
 
 ### Fixes
 - Fixed the "enabled" property in spawn files not actually being respected. Where do they find these devs?
+- Fixed Terralith's shrubland not counting as plains for spawning purposes the way it was intended to.
 
 ### Developer
 - Spawning Influences now have the context of what the other buckets are when adjusting bucket weights. This will break existing influences that do bucket weight adjustment.
@@ -11,6 +12,14 @@
   - SpawningContext is now SpawnablePosition
   - WorldSlice is SpawningZone
   - SpawningProspector is now SpawningZoneGenerator
+-  Majorly refactored the hierarchy of Spawner
+  - The base Spawner interface provides more functions to allow single-point and area spawning given appropriate inputs.
+  - TickingSpawner is removed in favour of outside code handling ticking logic.
+  - AreaSpawner is removed.
+  - BasicSpawner is the first implementation of Spawner which can be used for any purpose.
+  - PlayerSpawners are now mixin'd into ServerPlayer and ticked from ServerPlayer#tick.
+  - A hierarchy diagram can be found at `./docs/spawner-hierarchy.png` in the mod repository.
+- The SpawnerManager class has been removed as its functionality is all now handled elsewhere.
 - Renamed things in Spawn Rules to go with the other renames:
-  - contextSelector is now spawnablePositionSelector
+    - contextSelector is now spawnablePositionSelector
   - context is now spawnable_position

CHANGELOG.md

@@ -2,6 +2,7 @@
 ## [1.7.0 (Month xth, 2025)](#1-7-0)
 
 ### Additions
+- Added `/npcdelete` uuid parameter support and usuable to console
 - Added `/spectateBattle <player>` command to spectate battles without having to manually walk up to the target.
 - Added an in-game configuration screen, allowing all settings from `main.json` to be edited directly in-game.
 - Added `/cobblemonconfig reload` command to reload `main.json` configuration. **Note:** Some settings require a server restart to take effect; use this command cautiously.
@@ -33,6 +34,7 @@
 - Added Hyper Training items (IV Modification) as well as some additional candy items to do so (Health Candy, Sickly Candy)
 - Added Galarica Nut Bushes
 - Many Pokémon (mostly cats) are now feared by phantoms
+- Combees are now capable of gathering nectar from flowers and delivering it to either Saccharine leaves or hives. (Hive interactions are restricted to wild Combees) 
 - Lightning is now affected by a Pokemon's ability/typing
   - Pokémon with the ability Lightning Rod draw in lightning similar to a lightning rod block albeit with a lower priority and range, gain immunity to lightning damage, and receive a temporary damage buff.
   - Pokémon with the ability Motor Drive are immune to lightning damage and receive a temporary speed buff when struck by lightning
@@ -143,6 +145,8 @@
 - Dedenne
 - Noibat
 - Noivern
+- Furfrou
+  - You can change Furfrou's form by using shears on it while it holds a certain dye in its cosmetic slot.
 
 #### Gen 7
 - Yungoos
@@ -277,6 +281,20 @@
 - Parasect
 - Bastiodon
 - Amaura
+- Varoom
+- Revavroom
+- Bouffalant
+- Lickilicky
+- Blaziken
+- Rhyhorn
+- Rhydon
+- Rhyperior
+- Tauros
+- Tauros - Paldea Aqua
+- Tauros - Paldea Blaze
+- Tauros - Paldea Combat
+- Dewgong
+- Exeggutor - Kanto
 
 ### Model updates for the following Pokémon
 - Cleffa
@@ -383,6 +401,13 @@
 - Starly
 - Staravia
 - Staraptor
+- Varoom
+- Revavroom
+- Nickit
+- Thievul
+- Litwick
+- Lampent
+- Chandelure
 
 ### Changes
 - Changed pokemon caught and seen count to update based on the current pokedex being looked
@@ -396,6 +421,8 @@
 - Updated some item tags to better integrate behaviours between Cobblemon, Vanilla Minecraft, and other mods
   - Removed Cooked Meat, Raw Meat, Protein Ingredients, and Zinc Ingredients, the first two are now using `c` namespace tags, the latter have better integrated use of tags within their recipes which removes need for custom tags.
   - Added our seeds tag into `#c:seeds`, which is now made use of for the Miracle Seed recipe.
+  - Updated the `#cobblemon:berries` tag to use subtags located in `data/cobblemon/tags/item/berries`, such as `#cobblemon:berries/hp_recovery` for sorting purposes
+  - Moved the tag `#cobblemon:mutated_berries` to `#cobblemon:berries/mutation_result`
 - Added herbs and snowballs to the consumable in PvE and Wild battle tags
 - Tweaked the Natural Materials Vanilla file to fit with the changes to tags
 - Substantially optimised spawning checks mainly by front-loading biome filtering.
@@ -446,6 +473,9 @@
 - Updated `EvolutionCompleteEvent` parameters to include the Source Pokemon that evolved.
 - Updated `HatchEggEvent.Post` to include the Pokemon that hatched.
 - Roseli Berry Trees now naturally generate in their preferred biomes.
+- Refactored dynamic lights compat to be more future proof. The dynamic light support is only tested with LambDynamicLights, on NeoForged use that mod in combination with Sinytra Connector
+- Shulker Boxes and Traveler's Backpacks can no longer be held by Pokémon. Thanks Monocle ;) You could re-enable this with a datapack but you'd be crazy.
+- Moomoo Milk now clears Pokémon stat changes when used in battle.
 
 ### Fixes
 - Fixed game crashing when removing national pokedex using datapacks
@@ -528,6 +558,10 @@
 - Fixed Pokémon with alternate forms being created with an incorrect 'forced' tag on their ability.
 - Fixed busted abilities and moves in Pokémon data due to removed datapacks etc. causing storage corruption. It now just rerolls their ability / uses Tackle.
 - Fixed singular Pokémon corruption causing entire storage corruption. Storages will now skip corrupted Pokémon and print an error to console.
+- Fixed species additions not being able to properly mark a species as implemented.
+- Fixed Pokémon item models not showing a glint when enchanted.
+- Fixed some specific bag items not being dropped when used in battle.
+- Fixed the "use all berry bait" achievement not being progressed
 
 ### Developer
 - A finished battle now has winners and losers set inside of `PokemonBattle` instead of them always being empty.
@@ -658,6 +692,132 @@
 - Added `q.pokemon.is_busy` Returns whether the Pokémon is busy.
 - Added `q.pokemon.is_rideable` Returns whether the Pokémon is rideable.
 - Fixed `background` field and added `textColor` field for dialogues.
+- Added support to reload some data registries:
+    - MoLang scripts
+    - Callbacks
+    - Spawn Detail Presets
+    - Spawn Pools
+    - Spawn Rules
+    - Cosmetic Items
+    - Dialogues
+    - Fossils
+    - Natural Materials
+    - Action Effects
+    - Mechanics
+    - Unlockable Wallpapers
+    - Starter Data
+- Fixed `cobblemon:reel_in_pokemon` criteria not working when used together with a `baitId`
+  - Also changed the default from `cobblemon:empty_bait` to `any`
+  - The previous default is still available by using the above as baitId
+
+### Particles
+Added new/updated particles for the following moves:
+- Absorb
+- Acid
+- Acid Spray
+- Aerial Ace
+- Amnesia
+- Aurora Beam
+- Bite
+- Body Slam
+- Bubble
+- Bubble Beam
+- Bulldoze
+- Bullet Punch
+- Close Combat
+- Confusion
+- Crunch
+- Cotton Guard
+- Double Team
+- Dragon Claw
+- Egg Bomb
+- Ember
+- Eruption
+- Explosion
+- Fire Blast
+- Fire Punch
+- Fire Spin
+- Flame Burst
+- Flame Charge
+- Flamethrower
+- Flame Wheel
+- Frost Breath
+- Frustration
+- Giga Drain
+- Growl
+- Haze
+- Hidden Power
+- Horn Attack
+- Hyper Fang
+- Hypnosis
+- Ice Beam
+- Ice Punch
+- Ice Shard
+- Icy Wind
+- Infestation
+- Kinesis
+- Lava Plume
+- Leech Life
+- Leech Seed
+- Leer
+- Lick
+- Magical Leaf
+- Mega Drain
+- Minimize
+- Mist
+- Mud Bomb
+- MudSport
+- Mystical Fire
+- Nasty Plot
+- Poison Fang
+- Poison Gas
+- Poison Powder
+- Population Bomb
+- Pound
+- Powder
+- Powder Snow
+- Present
+- Protect
+- Psybeam
+- Psychic
+- Pursuit
+- Quick Attack
+- Rage Powder
+- Razor Leaf
+- Return
+- Rock Throw
+- Sand Attack
+- Scary Face
+- Scratch
+- Seed Bomb
+- Seismic Toss
+- Self Destruct
+- Shadow Ball
+- Shadow Claw
+- Sing
+- Sleep Powder
+- Sludge Bomb
+- Smokescreen
+- Spike
+- Spore
+- Stomp
+- String Shot
+- Stun Spore
+- Super Fang
+- Swords Dance
+- Tackle
+- Tail Whip
+- Thunder
+- Thunder Punch
+- Thunderbolt
+- Thunder Shock
+- Thunder Wave
+- Toxic
+- Water Gun
+- Water Pulse
+- Water Sport
+- Will-O-Wisp
+- Withdraw
 
 ## [1.6.1 (January 26th, 2025)](#1-6-1)
 
@@ -844,6 +1004,7 @@
 - Parametric particle motion now works.
 - Event-spawned particles now work.
 - Particles can now have independent coordinate spaces.
+- Fixed suffocation of Pokémon when a pokeball breaks near a wall 
 
 ### Developer
 - Updated the Pokédex data updated events to always include a `Pokemon` instance, and optionally a `DisguiseData` instance.

common/build.gradle.kts

@@ -31,6 +31,7 @@ repositories {
     maven(url = "${rootProject.projectDir}/deps")
     maven(url = "https://api.modrinth.com/maven")
     maven(url = "https://maven.neoforged.net/releases")
+    maven(url = "https://maven.gegy.dev")
     mavenLocal()
 }
 
@@ -44,6 +45,12 @@ dependencies {
     modCompileOnly(libs.bundles.common.integrations.compileOnly) {
         isTransitive = false
     }
+    // LambDynamicLights is handled differently because we need the Mojang-mappings version of it.
+    modCompileOnly(libs.lambDynamicLights) {
+        capabilities {
+            requireCapability("dev.lambdaurora.lambdynamiclights:api-mojmap")
+        }
+    }
     // Flywheel has no common dep so just pick one and don't use any platform specific code in common
     // modCompileOnly(libs.flywheelFabric)
 
@@ -94,4 +101,4 @@ sourceSets {
             }
         }
     }
-}
+}

common/src/main/java/com/cobblemon/mod/common/PlayerSpawnerGetter.java

@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common;
+
+import com.cobblemon.mod.common.api.spawning.spawner.PlayerSpawner;
+
+/**
+ * Used for mixin shenanigans. ServerPlayers now store their Cobblemon spawner
+ * inside, so this interface helps execute that.
+ *
+ * @author Hiroku
+ * @since October 27th, 2025
+ */
+public interface PlayerSpawnerGetter {
+    PlayerSpawner getPlayerSpawner();
+}

common/src/main/java/com/cobblemon/mod/common/compat/LambDynamicLightsCompat.java

@@ -1,102 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.compat;
-
-import com.cobblemon.mod.common.CobblemonEntities;
-import com.cobblemon.mod.common.client.render.layer.PokemonOnShoulderRenderer;
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
-import com.cobblemon.mod.common.item.PokedexItem;
-import com.cobblemon.mod.common.pokemon.FormData;
-import com.cobblemon.mod.common.pokemon.lighthing.LightingData;
-import dev.lambdaurora.lambdynlights.LambDynLights;
-import dev.lambdaurora.lambdynlights.api.DynamicLightHandler;
-import dev.lambdaurora.lambdynlights.api.DynamicLightHandlers;
-import net.minecraft.core.BlockPos;
-import net.minecraft.world.entity.EntityType;
-import net.minecraft.world.item.ItemStack;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.Optional;
-
-import net.minecraft.world.entity.player.Player;
-
-// Java class due to relying on entrypoint on Fabric side
-public class LambDynamicLightsCompat {
-
-    // This is all called on client side
-    // These things are checked every tick so try to keep it as free as possible
-    // That being said it's unlikely school Toshiba person is running dynamic lighting and shaders to enjoy this
-    // Make sure not to call anything Fabric specific :)
-    public static void hookCompat() {
-        // Pokémon entities
-        DynamicLightHandlers.registerDynamicLightHandler(
-            CobblemonEntities.POKEMON,
-            DynamicLightHandler.makeHandler(
-                LambDynamicLightsCompat::resolvedPokemonLightLevel,
-                pokemon -> false
-            )
-        );
-
-        // Shouldered Pokémon
-        DynamicLightHandlers.registerDynamicLightHandler(
-            EntityType.PLAYER,
-            DynamicLightHandler.makeHandler(
-                LambDynamicLightsCompat::resolvedPlayerLightLevel,
-                player -> false
-            )
-        );
-    }
-
-    private static int resolvedPokemonLightLevel(PokemonEntity pokemon) {
-        var underwater = !pokemon.level().getFluidState(BlockPos.containing(pokemon.getX(), pokemon.getEyeY(), pokemon.getZ())).isEmpty();
-
-        ItemStack item = pokemon.getShownItem();
-        int itemLightLevel = item.isEmpty()?0:LambDynLights.getLuminanceFromItemStack(item, underwater);
-        int formLightLevel = extractFormLightLevel(pokemon.getForm(), underwater).orElse(0);
-
-        return Math.max(itemLightLevel, formLightLevel);
-    }
-
-    private static int resolvedPlayerLightLevel(Player player) {
-        var underwater = !player.level().getFluidState(BlockPos.containing(player.getX(), player.getEyeY(), player.getZ())).isEmpty();
-        final int leftShoulderLightLevel = extractShoulderLightLevel(PokemonOnShoulderRenderer.shoulderDataFrom(player.getShoulderEntityLeft()), underwater);
-        final int rightShoulderLightLevel = extractShoulderLightLevel(PokemonOnShoulderRenderer.shoulderDataFrom(player.getShoulderEntityRight()), underwater);
-        final int itemLightLevel = customHeldItemLightLevel(player.getMainHandItem(), player.getOffhandItem());
-
-        return Math.max(itemLightLevel, Math.max(leftShoulderLightLevel, rightShoulderLightLevel));
-    }
-
-    private static Optional<Integer> extractFormLightLevel(@NotNull FormData form, boolean underwater) {
-        if (form.getLightingData() == null || !liquidGlowModeSupport(form.getLightingData().getLiquidGlowMode(), underwater)) {
-            return Optional.empty();
-        }
-        return Optional.of(form.getLightingData().getLightLevel());
-    }
-
-    private static int extractShoulderLightLevel(@Nullable PokemonOnShoulderRenderer.ShoulderData shoulderData, boolean underwater) {
-        if (shoulderData == null) {
-            return 0;
-        }
-
-        ItemStack item = shoulderData.getShownItem();
-        int itemLightLevel = item.isEmpty() ? 0 :LambDynLights.getLuminanceFromItemStack(item, underwater);
-        int formLightLevel = extractFormLightLevel(shoulderData.getForm(), underwater).orElse(0);
-
-        return Math.max(itemLightLevel, formLightLevel);
-    }
-
-    private static int customHeldItemLightLevel(ItemStack mainhand, ItemStack offhand) {
-        return (mainhand.getItem() instanceof PokedexItem || offhand.getItem() instanceof PokedexItem) ? 13 : 0;
-    }
-
-    private static boolean liquidGlowModeSupport(@NotNull LightingData.LiquidGlowMode liquidGlowMode, boolean underwater) {
-        return underwater ? liquidGlowMode.getGlowsUnderwater() : liquidGlowMode.getGlowsInLand();
-    }
-}

common/src/main/java/com/cobblemon/mod/common/compat/lambdynamiclights/CustomLuminance.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.compat.lambdynamiclights;
+
+import com.cobblemon.mod.common.pokemon.FormData;
+import com.cobblemon.mod.common.pokemon.lighthing.LightingData;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Optional;
+
+public abstract class CustomLuminance {
+    protected static Optional<Integer> extractFormLightLevel(@NotNull FormData form, boolean underwater) {
+        if (form.getLightingData() == null || !liquidGlowModeSupport(form.getLightingData().getLiquidGlowMode(), underwater)) {
+            return Optional.empty();
+        }
+        return Optional.of(form.getLightingData().getLightLevel());
+    }
+
+    protected static boolean liquidGlowModeSupport(@NotNull LightingData.LiquidGlowMode liquidGlowMode, boolean underwater) {
+        return underwater ? liquidGlowMode.getGlowsUnderwater() : liquidGlowMode.getGlowsInLand();
+    }
+}

common/src/main/java/com/cobblemon/mod/common/compat/lambdynamiclights/LambDynamicLightsInitializer.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.compat.lambdynamiclights;
+
+import com.cobblemon.mod.common.Cobblemon;
+import dev.lambdaurora.lambdynlights.api.DynamicLightsContext;
+import dev.lambdaurora.lambdynlights.api.DynamicLightsInitializer;
+import dev.lambdaurora.lambdynlights.api.entity.luminance.EntityLuminance;
+import dev.lambdaurora.lambdynlights.api.item.ItemLightSourceManager;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.EntityType;
+
+public class LambDynamicLightsInitializer implements DynamicLightsInitializer {
+    public static final EntityLuminance.Type POKEMON_LUMINANCE = EntityLuminance.Type.registerSimple(
+            ResourceLocation.fromNamespaceAndPath(Cobblemon.MODID, "pokemon"),
+            PokemonLuminance.INSTANCE
+    );
+    public static final EntityLuminance.Type PLAYER_LUMINANCE = EntityLuminance.Type.registerSimple(
+            ResourceLocation.fromNamespaceAndPath(Cobblemon.MODID, "shoulder"),
+            PlayerLuminance.INSTANCE
+    );
+
+    @Override
+    public void onInitializeDynamicLights(DynamicLightsContext context) {
+        Cobblemon.LOGGER.info("Lamb Dynamic Lights compatibility enabled");
+
+        context.entityLightSourceManager().onRegisterEvent().register(ctx -> {
+            ctx.register(EntityType.PLAYER, PlayerLuminance.INSTANCE);
+        });
+    }
+
+    @SuppressWarnings({"removal", "UnstableApiUsage"})
+    @Override
+    public void onInitializeDynamicLights(ItemLightSourceManager itemLightSourceManager) {}
+}
+

common/src/main/java/com/cobblemon/mod/common/compat/lambdynamiclights/PlayerLuminance.java

@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.compat.lambdynamiclights;
+
+import com.cobblemon.mod.common.Cobblemon;
+import com.cobblemon.mod.common.client.render.layer.PokemonOnShoulderRenderer;
+import dev.lambdaurora.lambdynlights.api.entity.luminance.EntityLuminance;
+import dev.lambdaurora.lambdynlights.api.item.ItemLightSourceManager;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.tags.TagKey;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.Range;
+
+public final class PlayerLuminance extends CustomLuminance implements EntityLuminance {
+    public static final PlayerLuminance INSTANCE = new PlayerLuminance();
+    private static final TagKey<Item> POKEDEX = TagKey.create(Registries.ITEM, ResourceLocation.fromNamespaceAndPath(Cobblemon.MODID, "pokedex"));
+
+    @Override
+    public @NotNull Type type() {
+        return LambDynamicLightsInitializer.PLAYER_LUMINANCE;
+    }
+
+    @Override
+    public @Range(from = 0L, to = 15L) int getLuminance(@NotNull ItemLightSourceManager itemLightSourceManager, @NotNull Entity entity) {
+        if (entity instanceof Player player) {
+            final int shoulderLightLevel = shoulderLuminance(itemLightSourceManager, player);
+
+            final int itemLightLevel = player.isHolding(stack -> stack.is(POKEDEX)) ? 13 : 0;
+
+            return Math.max(shoulderLightLevel, itemLightLevel);
+        } else {
+            return 0;
+        }
+    }
+
+    private @Range(from = 0L, to = 15L) static int shoulderLuminance(@NotNull ItemLightSourceManager itemLightSourceManager, @NotNull Player player) {
+        final var leftShoulder = PokemonOnShoulderRenderer.shoulderDataFrom(player.getShoulderEntityLeft());
+        final var rightShoulder = PokemonOnShoulderRenderer.shoulderDataFrom(player.getShoulderEntityRight());
+
+        if (leftShoulder == null && rightShoulder == null) {
+            return 0;
+        }
+
+        final int leftShoulderLightLevel = extractShoulderLightLevel(leftShoulder, itemLightSourceManager, player.isUnderWater());
+        final int rightShoulderLightLevel = extractShoulderLightLevel(rightShoulder, itemLightSourceManager, player.isUnderWater());
+        return Math.max(leftShoulderLightLevel, rightShoulderLightLevel);
+    }
+
+    private static int extractShoulderLightLevel(@Nullable PokemonOnShoulderRenderer.ShoulderData shoulderData, @NotNull ItemLightSourceManager itemLightSourceManager, boolean underwater) {
+        if (shoulderData == null) {
+            return 0;
+        }
+
+        ItemStack item = shoulderData.getShownItem();
+        int itemLightLevel = item.isEmpty() ? 0 : itemLightSourceManager.getLuminance(item, underwater);
+        int formLightLevel = extractFormLightLevel(shoulderData.getForm(), underwater).orElse(0);
+
+        return Math.max(itemLightLevel, formLightLevel);
+    }
+}

common/src/main/java/com/cobblemon/mod/common/compat/lambdynamiclights/PokemonLuminance.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.compat.lambdynamiclights;
+
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import dev.lambdaurora.lambdynlights.api.entity.luminance.EntityLuminance;
+import dev.lambdaurora.lambdynlights.api.item.ItemLightSourceManager;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.item.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Range;
+
+public final class PokemonLuminance extends CustomLuminance implements EntityLuminance {
+    public static final PokemonLuminance INSTANCE = new PokemonLuminance();
+
+    private PokemonLuminance() {}
+
+    @Override
+    public @NotNull Type type() {
+        return LambDynamicLightsInitializer.POKEMON_LUMINANCE;
+    }
+
+    @Override
+    public @Range(from = 0L, to = 15L) int getLuminance(
+            @NotNull ItemLightSourceManager itemLightSourceManager,
+            @NotNull Entity entity
+    ) {
+        if (entity instanceof PokemonEntity pokemon) {
+            boolean underwater = pokemon.isUnderWater();
+            ItemStack item = pokemon.getShownItem();
+            int itemLightLevel = item.isEmpty() ? 0 : itemLightSourceManager.getLuminance(item, underwater);
+            int formLightLevel = extractFormLightLevel(pokemon.getForm(), underwater).orElse(0);
+
+            return Math.max(itemLightLevel, formLightLevel);
+        } else {
+            return 0;
+        }
+    }
+}

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

@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+
+import com.cobblemon.mod.common.CobblemonMemories;
+import com.cobblemon.mod.common.api.ai.config.task.PathToBeeHiveTaskConfig;
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import net.minecraft.core.BlockPos;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.tags.BlockTags;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.item.component.CustomData;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.BeehiveBlock;
+import net.minecraft.world.level.block.HorizontalDirectionalBlock;
+import net.minecraft.world.level.block.entity.BeehiveBlockEntity;
+import net.minecraft.world.phys.Vec3;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(BeehiveBlockEntity.Occupant.class)
+public abstract class BeeOccupantMixin {
+
+    @Inject(method = "createEntity", at = @At("RETURN"), cancellable = true)
+    private void cobblemon$createEntity(Level level, BlockPos pos, CallbackInfoReturnable<Entity> cir) {
+        // Needing to replicate all the post op stuff on the hive isn't great
+        if (cir.getReturnValue() == null) {
+            final BeehiveBlockEntity.Occupant occupant = (BeehiveBlockEntity.Occupant) (Object) this;
+            CompoundTag compoundTag = occupant.entityData().copyTag();
+            Entity entity = EntityType.loadEntityRecursive(compoundTag, level, (entityx) -> entityx);
+            if (entity instanceof PokemonEntity pokemonEntity) {
+                var state = level.getBlockState(pos);
+                var newPos = Vec3.ZERO;
+                var newYaw = 0f;
+                var brain = pokemonEntity.getBrain();
+                if (state.is(BlockTags.BEEHIVES)) {
+                    // position in front of the entrance, face away from the block
+                    var facing = state.getValue(HorizontalDirectionalBlock.FACING);
+                    newPos = pos.relative(facing).getCenter();
+                    newYaw = facing.toYRot();
+                    brain.setMemory(CobblemonMemories.INSTANCE.getHIVE_LOCATION(), pos); // This needs to be set in the case that the hive was picked up and moved.
+                } else {
+                    // Block has likely been destroyed
+                    var center = pos.getCenter();
+                    newPos = new Vec3(
+                            center.x + level.random.nextFloat() * 0.6 - 0.3,
+                            center.y + level.random.nextFloat() * 0.6 - 0.3,
+                            center.z + level.random.nextFloat() * 0.6 - 0.3
+                    );
+                    newYaw = level.random.nextFloat() * 360F;
+                    brain.eraseMemory(CobblemonMemories.INSTANCE.getHIVE_LOCATION());
+                }
+                entity.yRotO = newYaw;
+                entity.setPos(newPos);
+                // Do honey logic
+                var hasNectar = brain.getMemory(CobblemonMemories.INSTANCE.getHAS_NECTAR()).orElse(false);
+                if (hasNectar) {
+                    // Remove nectar and reset got to hive cooldown
+                    brain.eraseMemory(CobblemonMemories.INSTANCE.getHAS_NECTAR());
+                    brain.setMemoryWithExpiry(CobblemonMemories.INSTANCE.getHIVE_COOLDOWN(), true, PathToBeeHiveTaskConfig.STAY_OUT_OF_HIVE_COOLDOWN);
+                    // Increment honey level of the hive
+                    if (state.is(BlockTags.BEEHIVES, (blockStateBase) -> blockStateBase.hasProperty(BeehiveBlock.HONEY_LEVEL))) {
+                        int i = state.getValue(BeehiveBlock.HONEY_LEVEL);
+                        if (i < 5) {
+                            int j = level.random.nextInt(100) == 0 ? 2 : 1;
+                            if (i + j > 5) {
+                                --j;
+                            }
+                            level.setBlockAndUpdate(pos, state.setValue(BeehiveBlock.HONEY_LEVEL, i + j));
+                        }
+                    }
+                }
+                cir.setReturnValue(entity);
+            }
+        }
+    }
+
+    @Inject(method = "of", at = @At("HEAD"), cancellable = true)
+    private static void cobblemon$of(Entity entity, CallbackInfoReturnable<BeehiveBlockEntity.Occupant> cir) {
+        if (entity instanceof PokemonEntity pokemonEntity) {
+            CompoundTag compoundTag = new CompoundTag();
+            entity.save(compoundTag);
+            Boolean hasNectar = pokemonEntity.getBrain().getMemory(CobblemonMemories.INSTANCE.getHAS_NECTAR()).orElse(false);
+            cir.setReturnValue(new BeehiveBlockEntity.Occupant(CustomData.of(compoundTag), 0, hasNectar ? 2400 : 600));
+            cir.cancel();
+        }
+
+    }
+}
+

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

@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import com.cobblemon.mod.common.mixin.accessor.BeeDataAccessor;
+import com.cobblemon.mod.common.mixin.accessor.BeehiveBlockEntityAccessor;
+import com.cobblemon.mod.common.mixin.accessor.BlockEntityAccessor;
+import com.google.common.collect.Lists;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.ai.memory.MemoryModuleType;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.entity.BeehiveBlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import org.jetbrains.annotations.Nullable;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import java.util.List;
+
+@Mixin(BeehiveBlockEntity.class)
+public abstract class BeehiveBlockEntityMixin {
+
+
+    // Accessor for the private 'stored' field in BeehiveBlockEntity
+    @Accessor("stored")
+    public abstract List<BeeDataAccessor> getStored();
+
+    @Inject(method = "emptyAllLivingFromHive", at = @At("HEAD"))
+    private void cobblemon$emptyAllLivingFromHive(@Nullable Player player, BlockState state, BeehiveBlockEntity.BeeReleaseStatus releaseStatus, CallbackInfo ci) {
+        if (player != null) {
+            final BeehiveBlockEntity blockEntity = (BeehiveBlockEntity) (Object) this;
+            // if the block is sedated or the player is too far away, no aggro should be applied
+            if (blockEntity.isSedated() || player.position().distanceToSqr(blockEntity.getBlockPos().getCenter()) > 16.0)
+                return;
+            // from this point need to access private members of the block entity
+            final BeehiveBlockEntityAccessor blockEntityAccessor = (BeehiveBlockEntityAccessor) this;
+            List<Object> storedList = blockEntityAccessor.getStored();
+
+            List<Entity> list = Lists.newArrayList();
+            storedList.removeIf((beeData) -> {
+                        BeehiveBlockEntity.Occupant occupant = ((BeeDataAccessor) beeData).invokeToOccupant();
+                        // Checking the for the tag allows us to make sure it's one of our pokemon before trying to rehydrate it into an entity
+                        boolean isPokemon = false;
+                        if (occupant.entityData().contains("id")) {
+                            isPokemon = "cobblemon:pokemon".equals(occupant.entityData().getUnsafe().getString("id"));
+                        }
+                        if (isPokemon) {
+                            return BeehiveBlockEntityAccessor.releaseOccupant(
+                                    ((BlockEntityAccessor) blockEntityAccessor).getLevel(),
+                                    ((BlockEntityAccessor) blockEntityAccessor).getWorldPosition(),
+                                    state,
+                                    occupant,
+                                    list,
+                                    releaseStatus,
+                                    blockEntityAccessor.savedFlowerPos());
+                        } else {
+                            return false;
+                        }
+                    }
+            );
+            for (Entity entity : list) {
+                if (entity instanceof PokemonEntity) {
+                    ((PokemonEntity) entity).getBrain().setMemory(MemoryModuleType.ATTACK_TARGET, player);
+                }
+            }
+        }
+    }
+
+    @Redirect(
+            method = "releaseOccupant",
+            at = @At(
+                    value = "INVOKE",
+                    target = "Lnet/minecraft/world/level/Level;addFreshEntity(Lnet/minecraft/world/entity/Entity;)Z"
+            )
+    )
+    private static boolean cobblemon$captureReleasedEntity(
+            Level level, Entity entity,
+            Level lvl, BlockPos pos, BlockState state,
+            BeehiveBlockEntity.Occupant occupant, @Nullable List<Entity> bees,
+            BeehiveBlockEntity.BeeReleaseStatus releaseStatus, @Nullable BlockPos flowerPos) {
+
+        if (bees != null && !bees.contains(entity)) {
+            // Avoid duplicates if vanilla also adds bees to the list on your version
+            bees.add(entity);
+        }
+        return level.addFreshEntity(entity);
+    }
+}
+

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

@@ -7,6 +7,7 @@
  */
 
 package com.cobblemon.mod.common.mixin;
+
 import com.cobblemon.mod.common.duck.ChannelDuck;
 import com.mojang.blaze3d.audio.Channel;
 import org.lwjgl.openal.AL10;

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

@@ -55,48 +55,6 @@ public abstract class LivingEntityMixin extends Entity implements OrientationCon
         }
     }
 
-    @Override
-    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());
-
-            Vec3 locatorOffset = new Vec3(locator.getMatrix().getTranslation(new Vector3f()));
-
-            Vec3 eyePosition = cobblemon$getEyePosition(partialTicks, pokemonEntity, locatorOffset);
-
-            Vec3 viewVector = this.getViewVector(partialTicks);
-            Vec3 viewDistanceVector = eyePosition.add(viewVector.x * hitDistance, viewVector.y * hitDistance, viewVector.z * hitDistance);
-
-            return this.level()
-                    .clip(
-                            new ClipContext(
-                                    eyePosition, viewDistanceVector, ClipContext.Block.OUTLINE, hitFluids ? net.minecraft.world.level.ClipContext.Fluid.ANY : net.minecraft.world.level.ClipContext.Fluid.NONE, this
-                            )
-                    );
-        }
-
-        return super.pick(hitDistance, partialTicks, hitFluids);
-    }
-
-    @Unique
-    private Vec3 cobblemon$getEyePosition(float partialTicks, PokemonEntity pokemonEntity, Vec3 locatorOffset) {
-        OrientationController controller = this.getOrientationController();
-
-        float currEyeHeight = this.getEyeHeight();
-        Vec3 offset = locatorOffset.add(pokemonEntity.position());
-        if (controller.isActive() && controller.getOrientation() != null) {
-            Quaternionf orientation = controller.getRenderOrientation(partialTicks);
-            Vec3 rotatedEyeHeight = new Vec3(orientation.transform(new Vector3f(0f, currEyeHeight - (this.getBbHeight() / 2), 0f)));
-
-            offset.add(rotatedEyeHeight);
-        }
-
-        return offset;
-    }
-
     @Inject(method = "tick", at = @At("HEAD"))
     private void cobblemon$updateRenderOrientation(CallbackInfo ci) {
         this.cobblemon$orientationController.tick();

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

@@ -8,20 +8,51 @@
 
 package com.cobblemon.mod.common.mixin;
 
+import com.cobblemon.mod.common.Cobblemon;
 import com.cobblemon.mod.common.OrientationControllable;
+import com.cobblemon.mod.common.PlayerSpawnerGetter;
+import com.cobblemon.mod.common.api.spawning.spawner.PlayerSpawner;
+import com.cobblemon.mod.common.api.spawning.spawner.PlayerSpawnerFactory;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import com.cobblemon.mod.common.world.gamerules.CobblemonGameRules;
 import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
 import com.llamalad7.mixinextras.sugar.Local;
+import net.minecraft.server.level.ServerLevel;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.entity.Entity;
 import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 @Mixin(ServerPlayer.class)
-public abstract class ServerPlayerMixin {
+public abstract class ServerPlayerMixin implements PlayerSpawnerGetter {
+    @Shadow
+    public abstract ServerLevel serverLevel();
+
+    @Unique
+    public PlayerSpawner cobblemon$spawner;
+
+    @Override
+    public PlayerSpawner getPlayerSpawner() {
+        ServerPlayer player = (ServerPlayer)(Object)this;
+        if (cobblemon$spawner == null) {
+            cobblemon$spawner = PlayerSpawnerFactory.INSTANCE.create(player);
+        }
+        return cobblemon$spawner;
+    }
+
+    @Inject(method = "tick", at = @At("TAIL"))
+    private void cobblemon$tickSpawner(CallbackInfo ci) {
+        if (!Cobblemon.config.getEnableSpawning()) {
+            return;
+        } else if (!serverLevel().getGameRules().getBoolean(CobblemonGameRules.DO_POKEMON_SPAWNING)) {
+            return;
+        }
+        getPlayerSpawner().tick();
+    }
 
     @Inject(method = "rideTick", at = @At("HEAD"))
     private void cobblemon$updateOrientationControllerRideTick(CallbackInfo ci) {
@@ -51,5 +82,4 @@ public abstract class ServerPlayerMixin {
     private boolean cobblemon$cancelSavingPokemonMounts(boolean original, @Local(ordinal=0) Entity entity) {
         return original && !(entity instanceof PokemonEntity);
     }
-
 }

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

@@ -25,9 +25,9 @@ public class TargetingConditionsMixin {
     @Inject(method = "test", at = @At("HEAD"), cancellable = true)
     public void test(@Nullable LivingEntity baseEntity, LivingEntity targetEntity, CallbackInfoReturnable<Boolean> ci) {
         if (targetEntity instanceof ServerPlayer player) {
-            boolean canTargetInBattle = player.level().getGameRules().getBoolean(CobblemonGameRules.MOB_TARGET_IN_BATTLE);
+            if (player.level().getGameRules().getBoolean(CobblemonGameRules.MOB_TARGET_IN_BATTLE)) return;
             boolean targetInBattle = Cobblemon.INSTANCE.getBattleRegistry().getBattleByParticipatingPlayer(player) != null;
-            if (!canTargetInBattle && targetInBattle) ci.setReturnValue(false);
+            if (targetInBattle) ci.setReturnValue(false);
         }
     }
 }

common/src/main/java/com/cobblemon/mod/common/mixin/accessor/BeeDataAccessor.java

@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin.accessor;
+
+
+import net.minecraft.world.level.block.entity.BeehiveBlockEntity;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Invoker;
+
+@Mixin(targets = "net.minecraft.world.level.block.entity.BeehiveBlockEntity$BeeData")
+public interface BeeDataAccessor {
+    @Invoker("toOccupant")
+    BeehiveBlockEntity.Occupant invokeToOccupant();
+}
+

common/src/main/java/com/cobblemon/mod/common/mixin/accessor/BeehiveBlockEntityAccessor.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin.accessor;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.entity.BeehiveBlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import org.jetbrains.annotations.Nullable;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import org.spongepowered.asm.mixin.gen.Invoker;
+
+import java.util.List;
+
+@Mixin(BeehiveBlockEntity.class)
+public interface BeehiveBlockEntityAccessor {
+    @Accessor("stored")
+    List<Object> getStored();
+    @Accessor("savedFlowerPos")
+    BlockPos savedFlowerPos();
+
+
+    /**
+     * Access the private static method:
+     * private static void releaseOccupant(Level level, BlockPos pos, BeeData beeData, ...)
+     */
+    @Invoker("releaseOccupant")
+    static boolean releaseOccupant(Level level, BlockPos pos, BlockState state, BeehiveBlockEntity.Occupant occupant, @Nullable List<Entity> storedInHives, BeehiveBlockEntity.BeeReleaseStatus releaseStatus, @Nullable BlockPos storedFlowerPos) {
+        throw new AssertionError(); // Mixin will overwrite
+    }
+}
+

common/src/main/java/com/cobblemon/mod/common/mixin/accessor/BlockEntityAccessor.java

@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin.accessor;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(BlockEntity.class)
+public interface BlockEntityAccessor {
+    @Accessor("level") Level getLevel();
+    @Accessor("worldPosition") BlockPos getWorldPosition();
+}

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

@@ -31,14 +31,15 @@ public class AbstractClientPlayerMixin {
         PokedexUsageContext usageContext = CobblemonClient.INSTANCE.getPokedexUsageContext();
         if (usageContext.getScanningGuiOpen()) {
             cir.setReturnValue(usageContext.getFovMultiplier());
-        }
+        } else {
+            // Only modify fov through riding if the pokedex is not open
+            LocalPlayer player = (LocalPlayer) (Object) this;
+            if (player != null && player.isPassenger() && player.getVehicle() instanceof PokemonEntity) {
+                PokemonEntity ride = (PokemonEntity) player.getVehicle();
 
-        LocalPlayer player = (LocalPlayer) (Object) this;
-        if (player != null && player.isPassenger() && player.getVehicle() instanceof PokemonEntity) {
-            PokemonEntity ride = (PokemonEntity) player.getVehicle();
-
-            //Return custom fov mult
-            cir.setReturnValue(ride.rideFovMult());
+                // Return custom fov mult for riding
+                cir.setReturnValue(ride.rideFovMult());
+            }
         }
     }
 }

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

@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin.client;
+
+import com.cobblemon.mod.common.client.render.player.MountedPlayerRenderer;
+import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.blaze3d.vertex.VertexConsumer;
+import net.minecraft.client.model.AgeableListModel;
+import net.minecraft.client.model.HumanoidModel;
+import net.minecraft.client.model.Model;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+/**
+ * This mixin adds to the head of the renderToBuffer function and allows us to detect if it is a HumanoidModel and
+ * is being rendered as part of a player in the world who is riding a PokemonEntity. If so we need to obey any
+ * root animations that have been applied earlier.
+ *
+ * @author Hiroku
+ * @since May 16, 2025
+ */
+@Mixin(AgeableListModel.class)
+public class AgeableListModelMixin {
+    @Inject(method = "renderToBuffer", at = @At("HEAD"))
+    private void cobblemon$renderToBuffer(
+        PoseStack poseStack,
+        VertexConsumer vertexConsumer,
+        int packedLight,
+        int packedOverlay,
+        int colour,
+        CallbackInfo ci
+    ) {
+        Model model = (Model) (Object) this;
+        if (model instanceof HumanoidModel<?> && MountedPlayerRenderer.shouldApplyRootAnimation) {
+            MountedPlayerRenderer.INSTANCE.animateRoot(poseStack);
+        }
+    }
+}

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

@@ -9,15 +9,21 @@
 package com.cobblemon.mod.common.mixin.client;
 
 import com.cobblemon.mod.common.api.scheduling.ClientTaskTracker;
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import com.llamalad7.mixinextras.sugar.Local;
 import net.minecraft.client.DeltaTracker;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.GameRenderer;
+import net.minecraft.world.entity.Entity;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.ModifyArg;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
+import java.util.function.Predicate;
+
 @Mixin(GameRenderer.class)
 public class GameRendererMixin {
     @Unique
@@ -42,4 +48,16 @@ public class GameRendererMixin {
         lastTime = newTime;
     }
 
+    @ModifyArg(
+        method = "pick(Lnet/minecraft/world/entity/Entity;DDF)Lnet/minecraft/world/phys/HitResult;",
+        at = @At(
+            value = "INVOKE",
+            target = "Lnet/minecraft/world/entity/projectile/ProjectileUtil;getEntityHitResult(Lnet/minecraft/world/entity/Entity;Lnet/minecraft/world/phys/Vec3;Lnet/minecraft/world/phys/Vec3;Lnet/minecraft/world/phys/AABB;Ljava/util/function/Predicate;D)Lnet/minecraft/world/phys/EntityHitResult;"
+        ),
+        index = 4
+    )
+    private Predicate<Entity> filterPokemonVehicle(Predicate<Entity> original, @Local(ordinal = 0, argsOnly = true) Entity entity) {
+        return (entityX) -> !(entity.getVehicle() == entityX && entityX instanceof PokemonEntity) && original.test(entityX);
+    }
+
 }

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

@@ -19,20 +19,17 @@ import net.minecraft.world.entity.LivingEntity;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
-import java.util.HashMap;
-
 @Mixin(HumanoidModel.class)
 public class HumanoidModelMixin {
-    @Unique HashMap<String, ModelPart> relevantPartsByName = new HashMap<>();
-
     @Shadow @Final
     public ModelPart head;
     @Shadow @Final
+    public ModelPart hat;
+    @Shadow @Final
     public ModelPart rightArm;
     @Shadow @Final
     public ModelPart leftArm;
@@ -40,6 +37,8 @@ public class HumanoidModelMixin {
     public ModelPart rightLeg;
     @Shadow @Final
     public ModelPart leftLeg;
+    @Shadow @Final
+    public ModelPart body;
 
     @Inject(method = "setupAnim*", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/model/geom/ModelPart;copyFrom(Lnet/minecraft/client/model/geom/ModelPart;)V", shift = At.Shift.BEFORE))
     public void cobblemon$animateRiders(
@@ -51,19 +50,23 @@ public class HumanoidModelMixin {
         float headPitch,
         CallbackInfo ci
     ) {
-        if (relevantPartsByName.isEmpty()) {
-            relevantPartsByName.put("arm_left", leftArm);
-            relevantPartsByName.put("arm_right", rightArm);
-            relevantPartsByName.put("leg_left", leftLeg);
-            relevantPartsByName.put("leg_right", rightLeg);
-            relevantPartsByName.put("head", head);
+        MountedPlayerRenderer.shouldApplyRootAnimation = false;
+
+        if (MountedPlayerRenderer.relevantPartsByName.size() <= 1) {
+            MountedPlayerRenderer.relevantPartsByName.put("arm_left", leftArm);
+            MountedPlayerRenderer.relevantPartsByName.put("arm_right", rightArm);
+            MountedPlayerRenderer.relevantPartsByName.put("leg_left", leftLeg);
+            MountedPlayerRenderer.relevantPartsByName.put("leg_right", rightLeg);
+            MountedPlayerRenderer.relevantPartsByName.put("head", head);
+            MountedPlayerRenderer.relevantPartsByName.put("hat", hat);
+            MountedPlayerRenderer.relevantPartsByName.put("torso", body);
         }
 
         Entity vehicle = entity.getVehicle();
         if (vehicle instanceof PokemonEntity pokemonEntity && entity instanceof OrientationControllable) {
-            var shouldRotatePlayerHead = pokemonEntity.ifRidingAvailableSupply(false, (behaviour, settings, state) -> {
-                return behaviour.shouldRotateRiderHead(settings, state, pokemonEntity);
-            });
+            var shouldRotatePlayerHead = pokemonEntity.ifRidingAvailableSupply(false, (behaviour, settings, state) ->
+                    behaviour.shouldRotateRiderHead(settings, state, pokemonEntity)
+            );
 
             if (!shouldRotatePlayerHead) {
                 netHeadYaw = 0f;
@@ -76,7 +79,8 @@ public class HumanoidModelMixin {
 
             if (!(entity instanceof AbstractClientPlayer player)) return;
 
-            MountedPlayerRenderer.INSTANCE.animate(pokemonEntity, player, relevantPartsByName, netHeadYaw, headPitch, ageInTicks, limbSwing, limbSwingAmount);
+            MountedPlayerRenderer.shouldApplyRootAnimation = true;
+            MountedPlayerRenderer.INSTANCE.animate((HumanoidModel<AbstractClientPlayer>)(Object)this, pokemonEntity, player, netHeadYaw, headPitch, ageInTicks, limbSwing, limbSwingAmount);
         }
     }
 }

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

@@ -174,6 +174,16 @@ public abstract class LocalPlayerMixin extends AbstractClientPlayer implements O
         return this.cobblemon$isDoubleJumping;
     }
 
+    @Inject(method = "isHandsBusy", at = @At("HEAD"), cancellable = true)
+    private void cobblemon$isHandsBusy(CallbackInfoReturnable<Boolean> cir) {
+        Entity vehicle = this.getVehicle();
+        if (vehicle instanceof PokemonEntity pokemonEntity) {
+            int seatIndex = pokemonEntity.getPassengers().indexOf(this);
+            Seat seat = pokemonEntity.getSeats().get(seatIndex);
+            cir.setReturnValue(seat.getHandsBusy());
+        }
+    }
+
     @Override
     public HitResult pick(double hitDistance, float partialTicks, boolean hitFluids) {
         Entity vehicle = this.getVehicle();

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

@@ -117,6 +117,8 @@ public abstract class MouseHandlerMixin {
         @Local(argsOnly = true) double d,
         @Local(argsOnly = true) double movementTime
         ) {
+        boolean returnValue = true;
+
         PokedexUsageContext usageContext = CobblemonClient.INSTANCE.getPokedexUsageContext();
         if (usageContext.getScanningGuiOpen()) {
             this.smoothTurnY.reset();
@@ -127,7 +129,7 @@ public abstract class MouseHandlerMixin {
             var sensitivity = Mth.lerp(usageContext.getFovMultiplier(), spyglassSensitivity, lookSensitivity);
             var yRotationFlip = this.minecraft.options.invertYMouse().get() ? -1 : 1;
             player.turn(this.accumulatedDX * sensitivity, (this.accumulatedDY * sensitivity * yRotationFlip));
-            return false;
+            returnValue = false;
         }
 
         // Clamp player rotation if riding and the vehicle demands it
@@ -143,35 +145,33 @@ public abstract class MouseHandlerMixin {
             pitchSmoother.reset();
             rollSmoother.reset();
             yawSmoother.reset();
-            return true;
+            return returnValue;
         }
 
-        //Send mouse input to be interpreted into rotation
-        //deltas by the ride controller
+        // 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.
+        // Perform Rotation using mouse influenced rotation deltas.
         controllable.getOrientationController().rotate(
             (float) angVecMouse.x,
             (float) angVecMouse.y,
             (float) angVecMouse.z
         );
 
-        //Gather and apply the current rotation deltas
+        // Gather and apply the current rotation deltas
         var angRot = cobblemon$getAngularVelocity(movementTime);
 
-        //Apply smoothing if requested by the controller.
-        //This Might be best if done by the controller itself?
-        if(cobblemon$shouldUseAngVelSmoothing())
-        {
+        // Apply smoothing if requested by the controller.
+        // This Might be best if done by the controller itself?
+        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);
             controllable.getOrientationController().rotate((float) yaw, (float) pitch, (float) roll);
         }
-        //Otherwise simply apply the smoothing
-        else
-        {
+        // Otherwise simply apply the smoothing
+        else {
             controllable.getOrientationController().rotate((float) (angRot.x * 10 * d), (float) (angRot.y * 10 * d), (float) (angRot.z * 10 * d));
         }
         return false;

common/src/main/java/com/cobblemon/mod/common/mixin/client/snapshots/SnapshotWarningMixin.java

@@ -10,8 +10,7 @@ package com.cobblemon.mod.common.mixin.client.snapshots;
 
 import com.cobblemon.mod.common.CobblemonBuildDetails;
 import com.cobblemon.mod.common.client.gui.snapshots.SnapshotWarningScreen;
-import com.cobblemon.mod.common.client.snapshots.SnapshotAcknowledgementData;
-import com.cobblemon.mod.common.client.snapshots.SnapshotAcknowledgementReader;
+import com.cobblemon.mod.common.client.persisted.ClientPersistedData;
 import kotlin.Unit;
 import net.minecraft.SharedConstants;
 import net.minecraft.client.Minecraft;
@@ -42,7 +41,7 @@ public final class SnapshotWarningMixin {
                     return Unit.INSTANCE;
                 }
 
-                SnapshotAcknowledgementReader.INSTANCE.write(new SnapshotAcknowledgementData(CobblemonBuildDetails.VERSION, dsa));
+                ClientPersistedData.INSTANCE.writeSnapshotsData(new ClientPersistedData.SnapshotAcknowledgementData(CobblemonBuildDetails.VERSION, dsa));
 
                 runnable.run();
                 return Unit.INSTANCE;
@@ -54,7 +53,7 @@ public final class SnapshotWarningMixin {
     @Unique
     @SuppressWarnings("ResultOfMethodCallIgnored")
     private boolean cobblemon$isAcknowledged() {
-        SnapshotAcknowledgementData data = SnapshotAcknowledgementReader.INSTANCE.read();
+        ClientPersistedData.SnapshotAcknowledgementData data = ClientPersistedData.INSTANCE.readSnapshotsData();
         if (data == null) {
             return false;
         }

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

@@ -11,7 +11,10 @@ package com.cobblemon.mod.common.mixin.entity;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
 import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
 import net.minecraft.world.entity.Entity;
+import net.minecraft.world.level.Level;
 import org.jetbrains.annotations.Nullable;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
@@ -39,10 +42,17 @@ public abstract class EntityMixin {
                     target = "Lnet/minecraft/world/entity/Entity;onGround()Z"
             )
     )
-    public boolean cobblemon$forceOnGroundForStepUp(Entity entity, Operation<Boolean> original)
-    {
+    public boolean cobblemon$forceOnGroundForStepUp(Entity entity, Operation<Boolean> original) {
         if (entity instanceof PokemonEntity && entity.hasControllingPassenger()) {
-            return true;
+            BlockPos below = entity.blockPosition().below();
+            Level level = entity.level();
+            var blockStateBelow = level.getBlockState(below);
+            boolean isAirOrLiquid = blockStateBelow.isAir() || !blockStateBelow.getFluidState().isEmpty();
+            boolean canSupportEntity = blockStateBelow.isFaceSturdy(level, below, Direction.UP);
+            boolean standingOnSolid = canSupportEntity && !isAirOrLiquid;
+            if (standingOnSolid) {
+                return true;
+            }
         }
         return original.call(entity);
     }

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

@@ -128,7 +128,7 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     @JvmField
     val APRICORN_FENCE = this.create("apricorn_fence", FenceBlock(BlockBehaviour.Properties.of().mapColor(APRICORN_PLANKS.defaultMapColor()).instrument(NoteBlockInstrument.BASS).strength(2.0f, 3.0f).sound(SoundType.WOOD)))
     @JvmField
-    val APRICORN_FENCE_GATE = this.create("apricorn_fence_gate", FenceGateBlock(APRICORN_WOOD_TYPE, BlockBehaviour.Properties.of().mapColor(APRICORN_PLANKS.defaultMapColor()).strength(2.0f, 3.0f).sound(SoundType.WOOD)))
+    val APRICORN_FENCE_GATE = this.create("apricorn_fence_gate", FenceGateBlock(APRICORN_WOOD_TYPE, BlockBehaviour.Properties.of().mapColor(APRICORN_PLANKS.defaultMapColor()).strength(2.0f, 3.0f).sound(SoundType.WOOD).ignitedByLava().forceSolidOn()))
     @JvmField
     val APRICORN_BUTTON = this.create("apricorn_button", BlocksInvoker.createWoodenButtonBlock(APRICORN_BLOCK_SET_TYPE))
     @JvmField
@@ -205,7 +205,7 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     @JvmField
     val SACCHARINE_FENCE = this.create("saccharine_fence", FenceBlock(BlockBehaviour.Properties.of().mapColor(SACCHARINE_PLANKS.defaultMapColor()).instrument(NoteBlockInstrument.BASS).strength(2.0f, 3.0f).sound(SoundType.WOOD)))
     @JvmField
-    val SACCHARINE_FENCE_GATE = this.create("saccharine_fence_gate", FenceGateBlock(SACCHARINE_WOOD_TYPE, BlockBehaviour.Properties.of().mapColor(SACCHARINE_PLANKS.defaultMapColor()).instrument(NoteBlockInstrument.BASS).strength(2.0f, 3.0f).sound(SoundType.WOOD)))
+    val SACCHARINE_FENCE_GATE = this.create("saccharine_fence_gate", FenceGateBlock(SACCHARINE_WOOD_TYPE, BlockBehaviour.Properties.of().mapColor(SACCHARINE_PLANKS.defaultMapColor()).instrument(NoteBlockInstrument.BASS).strength(2.0f, 3.0f).sound(SoundType.WOOD).ignitedByLava().forceSolidOn()))
     @JvmField
     val SACCHARINE_BUTTON = this.create("saccharine_button", BlocksInvoker.createWoodenButtonBlock(BlockSetType.OAK))
     @JvmField
@@ -213,7 +213,7 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     @JvmField
     val SACCHARINE_SIGN = this.create("saccharine_sign", CobblemonSignBlock(BlockBehaviour.Properties.ofFullCopy(Blocks.OAK_SIGN), SACCHARINE_WOOD_TYPE))
     @JvmField
-    val SACCHARINE_WALL_SIGN = this.create("saccharine_wall_sign", CobblemonWallSignBlock(BlockBehaviour.Properties.ofFullCopy(Blocks.OAK_WALL_SIGN), SACCHARINE_WOOD_TYPE))
+    val SACCHARINE_WALL_SIGN = this.create("saccharine_wall_sign", CobblemonWallSignBlock(BlockBehaviour.Properties.ofFullCopy(Blocks.OAK_SIGN), SACCHARINE_WOOD_TYPE))
     @JvmField
     val SACCHARINE_HANGING_SIGN = this.create("saccharine_hanging_sign", CobblemonHangingSignBlock(BlockBehaviour.Properties.ofFullCopy(Blocks.OAK_WALL_HANGING_SIGN), SACCHARINE_WOOD_TYPE))
     @JvmField

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

@@ -26,10 +26,10 @@ object CobblemonItemComponents : PlatformRegistry<Registry<DataComponentType<*>>
         .networkSynchronized(PokemonItemComponent.PACKET_CODEC)
         .build())
 
-    val HELD_ITEM_REP: DataComponentType<HeldItemCapableComponent> = DataComponentType.builder<HeldItemCapableComponent>()
-        .persistent(HeldItemCapableComponent.CODEC)
-        .networkSynchronized(HeldItemCapableComponent.PACKET_CODEC)
-        .build()
+    val HELD_ITEM_EFFECT: DataComponentType<HeldItemEffectComponent> = create("held_item_effect", DataComponentType.builder<HeldItemEffectComponent>()
+        .persistent(HeldItemEffectComponent.CODEC)
+        .networkSynchronized(HeldItemEffectComponent.PACKET_CODEC)
+        .build())
 
     val BAIT: DataComponentType<RodBaitComponent> = create("bait", DataComponentType.builder<RodBaitComponent>()
         .persistent(RodBaitComponent.CODEC)
@@ -86,6 +86,7 @@ object CobblemonItemComponents : PlatformRegistry<Registry<DataComponentType<*>>
         Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.parse("cobblemon:ingredient"), INGREDIENT)
         Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.parse("cobblemon:food"), FOOD)
         Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.parse("cobblemon:mob_effects"), MOB_EFFECTS)
+        Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.parse("cobblemon:held_item_effect"), HELD_ITEM_EFFECT)
     }
 
     override val registry = BuiltInRegistries.DATA_COMPONENT_TYPE

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

@@ -22,6 +22,7 @@ import com.cobblemon.mod.common.block.BerryBlock
 import com.cobblemon.mod.common.block.MintBlock
 import com.cobblemon.mod.common.block.MintBlock.MintType
 import com.cobblemon.mod.common.client.pokedex.PokedexType
+import com.cobblemon.mod.common.block.campfirepot.CampfirePotColor
 import com.cobblemon.mod.common.entity.boat.CobblemonBoatType
 import com.cobblemon.mod.common.item.*
 import com.cobblemon.mod.common.item.armor.CobblemonArmorTrims
@@ -192,19 +193,19 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
 
     val campfire_pots = mutableListOf<CampfirePotItem>()
     @JvmField
-    val CAMPFIRE_POT_RED = campfirePotItem(CobblemonBlocks.RED_CAMPFIRE_POT, "red")
+    val CAMPFIRE_POT_RED = campfirePotItem(CobblemonBlocks.RED_CAMPFIRE_POT, CampfirePotColor.RED)
     @JvmField
-    val CAMPFIRE_POT_YELLOW = campfirePotItem(CobblemonBlocks.YELLOW_CAMPFIRE_POT, "yellow")
+    val CAMPFIRE_POT_YELLOW = campfirePotItem(CobblemonBlocks.YELLOW_CAMPFIRE_POT, CampfirePotColor.YELLOW)
     @JvmField
-    val CAMPFIRE_POT_GREEN = campfirePotItem(CobblemonBlocks.GREEN_CAMPFIRE_POT, "green")
+    val CAMPFIRE_POT_GREEN = campfirePotItem(CobblemonBlocks.GREEN_CAMPFIRE_POT, CampfirePotColor.GREEN)
     @JvmField
-    val CAMPFIRE_POT_BLUE = campfirePotItem(CobblemonBlocks.BLUE_CAMPFIRE_POT, "blue")
+    val CAMPFIRE_POT_BLUE = campfirePotItem(CobblemonBlocks.BLUE_CAMPFIRE_POT, CampfirePotColor.BLUE)
     @JvmField
-    val CAMPFIRE_POT_PINK = campfirePotItem(CobblemonBlocks.PINK_CAMPFIRE_POT, "pink")
+    val CAMPFIRE_POT_PINK = campfirePotItem(CobblemonBlocks.PINK_CAMPFIRE_POT, CampfirePotColor.PINK)
     @JvmField
-    val CAMPFIRE_POT_BLACK = campfirePotItem(CobblemonBlocks.BLACK_CAMPFIRE_POT, "black")
+    val CAMPFIRE_POT_BLACK = campfirePotItem(CobblemonBlocks.BLACK_CAMPFIRE_POT, CampfirePotColor.BLACK)
     @JvmField
-    val CAMPFIRE_POT_WHITE = campfirePotItem(CobblemonBlocks.WHITE_CAMPFIRE_POT, "white")
+    val CAMPFIRE_POT_WHITE = campfirePotItem(CobblemonBlocks.WHITE_CAMPFIRE_POT, CampfirePotColor.WHITE)
 
     @JvmField
     val HEARTY_GRAINS = compostableItem("hearty_grains", ItemNameBlockItem(CobblemonBlocks.HEARTY_GRAINS, Properties().rarity(Rarity.COMMON)))
@@ -695,7 +696,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val SUPERB_REMEDY = compostableItem("superb_remedy", RemedyItem(RemedyItem.SUPERB), 0.85f)
     @JvmField
-    val MOOMOO_MILK = create("moomoo_milk", CobblemonItem(Item.Properties().craftRemainder(Items.GLASS_BOTTLE).stacksTo((16))))
+    val MOOMOO_MILK = create("moomoo_milk", MoomooMilk(Item.Properties().craftRemainder(Items.GLASS_BOTTLE).stacksTo((16))))
 
     @JvmField
     val POTION = create("potion", PotionItem(PotionType.POTION))
@@ -1500,8 +1501,8 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
         }
     )
 
-    private fun campfirePotItem(block: Block, type: String): CampfirePotItem {
-        val item = create("campfire_pot_${type}", CampfirePotItem(block))
+    private fun campfirePotItem(block: Block, color: CampfirePotColor): CampfirePotItem {
+        val item = create("campfire_pot_${color.suffix}", CampfirePotItem(block, color))
         campfire_pots.add(item)
         return item
     }
@@ -1648,4 +1649,4 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     private fun foodItem(nutrition: Int, saturationModifier: Float): Item {
         return CobblemonItem(Item.Properties().food(FoodProperties.Builder().nutrition(nutrition).saturationModifier(saturationModifier).build()))
     }
-}
+}

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

@@ -39,6 +39,7 @@ object CobblemonMechanics : DataRegistry {
     var potions = PotionsMechanic()
 
     override fun sync(player: ServerPlayer) {}
+
     override fun reload(manager: ResourceManager) {
         remedies = loadMechanic(manager, "remedies", RemediesMechanic::class.java)
         berries = loadMechanic(manager, "berries", BerriesMechanic::class.java)

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

@@ -15,12 +15,12 @@ import com.cobblemon.mod.common.api.moves.animations.ActionEffectContext
 import com.mojang.serialization.Codec
 import com.mojang.serialization.codecs.ListCodec
 import com.mojang.serialization.codecs.PrimitiveCodec
-import net.minecraft.core.UUIDUtil
-import net.minecraft.world.entity.ai.memory.MemoryModuleType
-import java.util.Optional
-import java.util.UUID
 import net.minecraft.core.BlockPos
+import net.minecraft.core.GlobalPos
+import net.minecraft.core.UUIDUtil
 import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.ai.memory.MemoryModuleType
+import java.util.*
 
 object CobblemonMemories {
     val memories = mutableMapOf<String, MemoryModuleType<*>>()
@@ -48,10 +48,13 @@ object CobblemonMemories {
     val TIME_TRYING_TO_REACH_BERRY_BUSH = register<Int>("time_trying_to_reach_berry_bush")
     val IS_CONSUMING_ITEM = register<Boolean>("is_consuming_item")
     val RECENTLY_ATE_GRASS = register<Boolean>("recently_ate_grass")
-    val HIVE_LOCATION = register<BlockPos>("hive_location")
+    val HIVE_LOCATION = register<BlockPos>("hive_location", BlockPos.CODEC)
+    val HIVE_BLACKLIST = register<List<BlockPos>>("hive_blacklist")
     val HIVE_COOLDOWN = register<Boolean>("hive_cooldown")
-    val NEARBY_FLOWERS = register<List<BlockPos>>("nearby_flower")
-    val POLLINATED = register<Boolean>("pollinated", PrimitiveCodec.BOOL)
+    val NEARBY_FLOWER = register<BlockPos>("nearby_flower", BlockPos.CODEC)
+    val PATH_TO_NEARBY_FLOWER_COOLDOWN = register<Boolean>("path_to_nearby_flower_cooldown")
+    val HAS_NECTAR = register<Boolean>("has_nectar", PrimitiveCodec.BOOL)
+    val NEARBY_SACC_LEAVES = register<BlockPos>("nearby_sacc_leaves", BlockPos.CODEC)
     /** who am i following rn? */
     val HERD_LEADER = register<String>("herd_leader", PrimitiveCodec.STRING)
     /** how many are following me rn? */

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

@@ -9,8 +9,8 @@
 package com.cobblemon.mod.common
 
 import com.cobblemon.mod.common.api.net.NetworkPacket
-import com.cobblemon.mod.common.client.net.OpenBehaviourEditorHandler
 import com.cobblemon.mod.common.client.net.CalculateSeatPositionsHandler
+import com.cobblemon.mod.common.client.net.OpenBehaviourEditorHandler
 import com.cobblemon.mod.common.client.net.PlayerInteractOptionsHandler
 import com.cobblemon.mod.common.client.net.SetClientPlayerDataHandler
 import com.cobblemon.mod.common.client.net.animation.PlayPosableAnimationHandler
@@ -20,7 +20,7 @@ import com.cobblemon.mod.common.client.net.callback.party.OpenPartyCallbackHandl
 import com.cobblemon.mod.common.client.net.callback.partymove.OpenPartyMoveCallbackHandler
 import com.cobblemon.mod.common.client.net.cooking.ToggleCookingPotLidHandler
 import com.cobblemon.mod.common.client.net.data.DataRegistrySyncPacketHandler
-import com.cobblemon.mod.common.client.net.data.UnlockReloadPacketHandler
+import com.cobblemon.mod.common.client.net.data.RideSettingsSyncHandler
 import com.cobblemon.mod.common.client.net.dialogue.DialogueClosedHandler
 import com.cobblemon.mod.common.client.net.dialogue.DialogueOpenedHandler
 import com.cobblemon.mod.common.client.net.effect.PokeSnackBlockParticlesHandler
@@ -65,8 +65,8 @@ import com.cobblemon.mod.common.client.net.trade.TradeProcessStartedHandler
 import com.cobblemon.mod.common.client.net.trade.TradeStartedHandler
 import com.cobblemon.mod.common.client.net.trade.TradeUpdatedHandler
 import com.cobblemon.mod.common.net.PacketRegisterInfo
-import com.cobblemon.mod.common.net.messages.client.OpenBehaviourEditorPacket
 import com.cobblemon.mod.common.net.messages.client.CalculateSeatPositionsPacket
+import com.cobblemon.mod.common.net.messages.client.OpenBehaviourEditorPacket
 import com.cobblemon.mod.common.net.messages.client.PlayerInteractOptionsPacket
 import com.cobblemon.mod.common.net.messages.client.SetClientPlayerDataPacket
 import com.cobblemon.mod.common.net.messages.client.animation.PlayPosableAnimationPacket
@@ -157,6 +157,7 @@ import com.cobblemon.mod.common.net.messages.server.callback.party.PartyPokemonS
 import com.cobblemon.mod.common.net.messages.server.callback.party.PartySelectCancelledPacket
 import com.cobblemon.mod.common.net.messages.server.callback.partymove.PartyMoveSelectCancelledPacket
 import com.cobblemon.mod.common.net.messages.server.callback.partymove.PartyPokemonMoveSelectedPacket
+import com.cobblemon.mod.common.net.messages.server.debug.ServerboundUpdateRidingSettingsPacket
 import com.cobblemon.mod.common.net.messages.server.debug.ServerboundUpdateRidingStatRangePacket
 import com.cobblemon.mod.common.net.messages.server.debug.ServerboundUpdateRidingStatsPacket
 import com.cobblemon.mod.common.net.messages.server.dialogue.EscapeDialoguePacket
@@ -170,11 +171,11 @@ import com.cobblemon.mod.common.net.messages.server.pasture.UnpasturePokemonPack
 import com.cobblemon.mod.common.net.messages.server.pokedex.scanner.FinishScanningPacket
 import com.cobblemon.mod.common.net.messages.server.pokedex.scanner.StartScanningPacket
 import com.cobblemon.mod.common.net.messages.server.pokemon.interact.InteractPokemonPacket
-import com.cobblemon.mod.common.net.messages.server.pokemon.update.SetItemHiddenPacket
-import com.cobblemon.mod.common.net.messages.server.pokemon.update.SetNicknamePacket
-import com.cobblemon.mod.common.net.messages.server.pokemon.update.SetActiveMarkPacket
-import com.cobblemon.mod.common.net.messages.server.pokemon.update.SetMarkingsPacket
 import com.cobblemon.mod.common.net.messages.server.pokemon.update.ServerboundUpdateRidingStatePacket
+import com.cobblemon.mod.common.net.messages.server.pokemon.update.SetActiveMarkPacket
+import com.cobblemon.mod.common.net.messages.server.pokemon.update.SetItemHiddenPacket
+import com.cobblemon.mod.common.net.messages.server.pokemon.update.SetMarkingsPacket
+import com.cobblemon.mod.common.net.messages.server.pokemon.update.SetNicknamePacket
 import com.cobblemon.mod.common.net.messages.server.pokemon.update.evolution.AcceptEvolutionPacket
 import com.cobblemon.mod.common.net.messages.server.riding.DismountPokemonPacket
 import com.cobblemon.mod.common.net.messages.server.riding.ServerboundUpdateDriverInputPacket
@@ -208,6 +209,7 @@ import com.cobblemon.mod.common.net.serverhandling.callback.party.PartyPokemonSe
 import com.cobblemon.mod.common.net.serverhandling.callback.party.PartySelectCancelledHandler
 import com.cobblemon.mod.common.net.serverhandling.callback.partymove.PartyMoveSelectCancelledHandler
 import com.cobblemon.mod.common.net.serverhandling.callback.partymove.PartyPokemonMoveSelectedHandler
+import com.cobblemon.mod.common.net.serverhandling.debug.ServerboundUpdateRidingSettingsHandler
 import com.cobblemon.mod.common.net.serverhandling.debug.ServerboundUpdateRidingStatRangeHandler
 import com.cobblemon.mod.common.net.serverhandling.debug.ServerboundUpdateRidingStatsHandler
 import com.cobblemon.mod.common.net.serverhandling.dialogue.EscapeDialogueHandler
@@ -222,11 +224,11 @@ import com.cobblemon.mod.common.net.serverhandling.pasture.UnpasturePokemonHandl
 import com.cobblemon.mod.common.net.serverhandling.pokedex.scanner.FinishScanningHandler
 import com.cobblemon.mod.common.net.serverhandling.pokedex.scanner.StartScanningHandler
 import com.cobblemon.mod.common.net.serverhandling.pokemon.interact.InteractPokemonHandler
-import com.cobblemon.mod.common.net.serverhandling.pokemon.update.SetItemHiddenHandler
-import com.cobblemon.mod.common.net.serverhandling.pokemon.update.SetNicknameHandler
-import com.cobblemon.mod.common.net.serverhandling.pokemon.update.SetActiveMarkHandler
-import com.cobblemon.mod.common.net.serverhandling.pokemon.update.SetMarkingsHandler
 import com.cobblemon.mod.common.net.serverhandling.pokemon.update.ServerboundUpdateRidingStateHandler
+import com.cobblemon.mod.common.net.serverhandling.pokemon.update.SetActiveMarkHandler
+import com.cobblemon.mod.common.net.serverhandling.pokemon.update.SetItemHiddenHandler
+import com.cobblemon.mod.common.net.serverhandling.pokemon.update.SetMarkingsHandler
+import com.cobblemon.mod.common.net.serverhandling.pokemon.update.SetNicknameHandler
 import com.cobblemon.mod.common.net.serverhandling.riding.DismountPokemonPacketHandler
 import com.cobblemon.mod.common.net.serverhandling.riding.DriverInputPacketHandler
 import com.cobblemon.mod.common.net.serverhandling.starter.RequestStarterScreenHandler
@@ -310,6 +312,7 @@ object CobblemonNetwork {
         list.add(PacketRegisterInfo(MarksPotentialUpdatePacket.ID, MarksPotentialUpdatePacket::decode, PokemonUpdatePacketHandler()))
         list.add(PacketRegisterInfo(MarkingsUpdatePacket.ID, MarkingsUpdatePacket::decode, PokemonUpdatePacketHandler()))
         list.add(PacketRegisterInfo(RideBoostsUpdatePacket.ID, RideBoostsUpdatePacket::decode, PokemonUpdatePacketHandler()))
+        list.add(PacketRegisterInfo(RideStaminaUpdatePacket.ID, RideStaminaUpdatePacket::decode, PokemonUpdatePacketHandler()))
 
         // Evolution start
         list.add(PacketRegisterInfo(AddEvolutionPacket.ID, AddEvolutionPacket::decode, PokemonUpdatePacketHandler()))
@@ -388,7 +391,6 @@ object CobblemonNetwork {
         list.add(PacketRegisterInfo(BerryRegistrySyncPacket.ID, BerryRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(SpeciesRegistrySyncPacket.ID, SpeciesRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(PropertiesCompletionRegistrySyncPacket.ID, PropertiesCompletionRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
-        list.add(PacketRegisterInfo(UnlockReloadPacket.ID, UnlockReloadPacket::decode, UnlockReloadPacketHandler))
         list.add(PacketRegisterInfo(StandardSpeciesFeatureSyncPacket.ID, StandardSpeciesFeatureSyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(GlobalSpeciesFeatureSyncPacket.ID, GlobalSpeciesFeatureSyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(SpeciesFeatureAssignmentSyncPacket.ID, SpeciesFeatureAssignmentSyncPacket::decode, DataRegistrySyncPacketHandler()))
@@ -405,6 +407,7 @@ object CobblemonNetwork {
         list.add(PacketRegisterInfo(CosmeticItemAssignmentSyncPacket.ID, CosmeticItemAssignmentSyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(BehaviourSyncPacket.ID, BehaviourSyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(MarkRegistrySyncPacket.ID, MarkRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
+        list.add(PacketRegisterInfo(RideSettingsSyncPacket.ID, RideSettingsSyncPacket::decode, RideSettingsSyncHandler))
 
         // Effects
         list.add(PacketRegisterInfo(SpawnSnowstormParticlePacket.ID, SpawnSnowstormParticlePacket::decode, SpawnSnowstormParticleHandler))
@@ -578,6 +581,7 @@ object CobblemonNetwork {
         list.add(PacketRegisterInfo(ServerboundUpdateRidingStatePacket.ID, ServerboundUpdateRidingStatePacket::decode, ServerboundUpdateRidingStateHandler))
         list.add(PacketRegisterInfo(ServerboundUpdateRidingStatsPacket.ID, ServerboundUpdateRidingStatsPacket::decode, ServerboundUpdateRidingStatsHandler))
         list.add(PacketRegisterInfo(ServerboundUpdateRidingStatRangePacket.ID, ServerboundUpdateRidingStatRangePacket::decode, ServerboundUpdateRidingStatRangeHandler))
+        list.add(PacketRegisterInfo(ServerboundUpdateRidingSettingsPacket.ID, ServerboundUpdateRidingSettingsPacket::decode, ServerboundUpdateRidingSettingsHandler))
         list.add(PacketRegisterInfo(DismountPokemonPacket.ID, DismountPokemonPacket::decode, DismountPokemonPacketHandler))
         list.add(PacketRegisterInfo(ServerboundUpdateDriverInputPacket.ID, ServerboundUpdateDriverInputPacket::decode, DriverInputPacketHandler))
 

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

@@ -26,8 +26,6 @@ object CobblemonPoiTypes: PlatformRegistry<Registry<PoiType>, ResourceKey<Regist
     @JvmField
     val NURSE_KEY = createKey("nurse", CobblemonBlocks.HEALING_MACHINE, 1, 1)
     @JvmField
-    val POKE_SNACK_KEY = createKey("poke_snack", CobblemonBlocks.POKE_SNACK, 0, 1)
-    @JvmField
     val SACCHARINE_LOG_SLATHERED_KEY = createKey("saccharine_log_slathered", CobblemonBlocks.SACCHARINE_LOG_SLATHERED, 0, 1)
     // TODO after 1.7
 //    @JvmField

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

@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common
+
+import com.bedrockk.molang.Expression
+import com.cobblemon.mod.common.CobblemonNetwork.sendPacket
+import com.cobblemon.mod.common.api.data.DataRegistry
+import com.cobblemon.mod.common.api.molang.ExpressionLike
+import com.cobblemon.mod.common.api.reactive.SimpleObservable
+import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviourSettings
+import com.cobblemon.mod.common.api.riding.behaviour.types.air.BirdSettings
+import com.cobblemon.mod.common.api.riding.behaviour.types.air.GliderSettings
+import com.cobblemon.mod.common.api.riding.behaviour.types.air.HelicopterSettings
+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.land.HorseSettings
+import com.cobblemon.mod.common.api.riding.behaviour.types.land.MinekartSettings
+import com.cobblemon.mod.common.api.riding.behaviour.types.land.VehicleSettings
+import com.cobblemon.mod.common.api.riding.behaviour.types.liquid.BoatSettings
+import com.cobblemon.mod.common.api.riding.behaviour.types.liquid.BurstSettings
+import com.cobblemon.mod.common.api.riding.behaviour.types.liquid.DolphinSettings
+import com.cobblemon.mod.common.net.messages.client.data.RideSettingsSyncPacket
+import com.cobblemon.mod.common.util.adapters.ExpressionAdapter
+import com.cobblemon.mod.common.util.adapters.ExpressionLikeAdapter
+import com.cobblemon.mod.common.util.adapters.FloatNumberRangeAdapter
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.google.gson.GsonBuilder
+import net.minecraft.advancements.critereon.MinMaxBounds
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.server.packs.PackType
+import net.minecraft.server.packs.resources.ResourceManager
+
+object CobblemonRideSettings : DataRegistry {
+    override val id: ResourceLocation = cobblemonResource("ride_settings")
+    override val type = PackType.SERVER_DATA
+    override val observable = SimpleObservable<CobblemonRideSettings>()
+    val gson = GsonBuilder()
+        .setPrettyPrinting()
+        .registerTypeAdapter(Expression::class.java, ExpressionAdapter)
+        .registerTypeAdapter(ExpressionLike::class.java, ExpressionLikeAdapter)
+        .registerTypeAdapter(MinMaxBounds.Doubles::class.java, FloatNumberRangeAdapter)
+        .create()
+
+    var bird = BirdSettings()
+    var glider = GliderSettings()
+    var helicopter = HelicopterSettings()
+    var hover = HoverSettings()
+    var jet = JetSettings()
+    var rocket = RocketSettings()
+
+    var horse = HorseSettings()
+    var minekart = MinekartSettings()
+    var vehicle = VehicleSettings()
+
+    var boat = BoatSettings()
+    var burst = BurstSettings()
+    var dolphin = DolphinSettings()
+
+    override fun sync(player: ServerPlayer) {
+        player.sendPacket(
+            RideSettingsSyncPacket(
+                bird = bird,
+                glider = glider,
+                helicopter = helicopter,
+                hover = hover,
+                jet = jet,
+                rocket = rocket,
+                horse = horse,
+                minekart = minekart,
+                vehicle = vehicle,
+                boat = boat,
+                burst = burst,
+                dolphin = dolphin
+            )
+        )
+    }
+
+    override fun reload(manager: ResourceManager) {
+        bird = loadStyle(manager, "bird", BirdSettings::class.java)
+        glider = loadStyle(manager, "glider", GliderSettings::class.java)
+        helicopter = loadStyle(manager, "helicopter", HelicopterSettings::class.java)
+        hover = loadStyle(manager, "hover", HoverSettings::class.java)
+        jet = loadStyle(manager, "jet", JetSettings::class.java)
+        rocket = loadStyle(manager, "rocket", RocketSettings::class.java)
+        horse = loadStyle(manager, "horse", HorseSettings::class.java)
+        minekart = loadStyle(manager, "minekart", MinekartSettings::class.java)
+        vehicle = loadStyle(manager, "vehicle", VehicleSettings::class.java)
+        boat = loadStyle(manager, "boat", BoatSettings::class.java)
+        burst = loadStyle(manager, "burst", BurstSettings::class.java)
+        dolphin = loadStyle(manager, "dolphin", DolphinSettings::class.java)
+    }
+
+    private fun <T : RidingBehaviourSettings> loadStyle(manager: ResourceManager, name: String, clazz: Class<T>): T {
+        manager.getResourceOrThrow(cobblemonResource("ride_settings/$name.json")).open().use {
+            return gson.fromJson(it.reader(), clazz)
+        }
+    }
+}

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

@@ -41,6 +41,8 @@ object CobblemonSensors {
 
     val POKEMON_NEARBY_WANTED_ITEM = register("pokemon_nearby_wanted_item", ::PokemonItemSensor)
 
+    val NEARBY_SACC_LEAVES = register("nearby_sacc_leaves", ::SacLeavesSensor)
+
     fun <E : Entity, U : Sensor<E>> register(id: String, supplier: Supplier<U>): SensorType<U> {
         val sensor = SensorType(supplier)
         sensors[id] = sensor

common/src/main/kotlin/com/cobblemon/mod/common/advancement/criterion/ReelInPokemonCriterionCondition.kt

@@ -22,18 +22,19 @@ class ReelInPokemonContext(val species : ResourceLocation, val baitId: ResourceL
 class ReelInPokemonCriterionCondition(
         playerCtx: Optional<ContextAwarePredicate>,
         val species: String,
-        val baitId: String
+        val baitId: String // also allows "cobblemon:empty_bait" to indicate that no bait is allowed for this criterion to match
 ) : SimpleCriterionCondition<ReelInPokemonContext>(playerCtx) {
 
     companion object {
         val CODEC: Codec<ReelInPokemonCriterionCondition> = RecordCodecBuilder.create { it.group(
             EntityPredicate.ADVANCEMENT_CODEC.optionalFieldOf("player").forGetter { it.playerCtx },
             Codec.STRING.optionalFieldOf("species", "any").forGetter { it.species },
-            Codec.STRING.optionalFieldOf("baitId", "empty_bait").forGetter { it.baitId }
-        ).apply(it, { playerCtx, pokemonId, baitId -> ReelInPokemonCriterionCondition(playerCtx, pokemonId, baitId.ifEmpty { "empty_bait" }) }) }
+            Codec.STRING.optionalFieldOf("baitId", "any").forGetter { it.baitId }
+        ).apply(it, { playerCtx, pokemonId, baitId -> ReelInPokemonCriterionCondition(playerCtx, pokemonId, baitId) }) }
     }
 
     override fun matches(player: ServerPlayer, context: ReelInPokemonContext): Boolean {
-        return (context.species == this.species.asIdentifierDefaultingNamespace() || this.species == "any") && (context.baitId == this.baitId.asIdentifierDefaultingNamespace() || this.baitId == "empty_bait")
+        return (context.species == this.species.asIdentifierDefaultingNamespace() || this.species == "any")
+                && (context.baitId == this.baitId.asIdentifierDefaultingNamespace() || this.baitId == "any")
     }
 }

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

@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.ai
+
+import net.minecraft.server.level.ServerLevel
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.ai.behavior.Behavior
+import net.minecraft.world.entity.ai.memory.MemoryModuleType
+import net.minecraft.world.entity.ai.memory.MemoryStatus
+import net.minecraft.world.entity.schedule.Activity
+
+/**
+ * A [Behavior] subclass that represents tasks that check that the entity is still in one
+ * of the activities that this task is part of. If the entity is no longer doing any of those
+ * activities, the task will be interrupted and you can handle any cleanup in [onInterrupted].
+ *
+ * @author Hiroku
+ * @since October 17th, 2025
+ */
+abstract class ActivityAwareBehavior<E : LivingEntity> : Behavior<E> {
+    constructor(entryCondition: Map<MemoryModuleType<*>, MemoryStatus>) : super(entryCondition)
+    constructor(entryCondition: Map<MemoryModuleType<*>, MemoryStatus>, duration: Int) : super(entryCondition, duration)
+    constructor(entryCondition: Map<MemoryModuleType<*>, MemoryStatus>, minDuration: Int, maxDuration: Int) : super(entryCondition, minDuration, maxDuration)
+
+    val activities: MutableSet<Activity> = mutableSetOf()
+
+    fun isStillDoingActivity(entity: E): Boolean {
+        return activities.any(entity.brain::isActive)
+    }
+
+    override fun canStillUse(level: ServerLevel, entity: E, gameTime: Long) = isStillDoingActivity(entity)
+
+    open fun onInterrupted(level: ServerLevel, entity: E, gameTime: Long) {
+        // No-op
+    }
+
+    override fun stop(level: ServerLevel, entity: E, gameTime: Long) {
+        super.stop(level, entity, gameTime)
+        if (!isStillDoingActivity(entity)) {
+            onInterrupted(level, entity, gameTime)
+        }
+    }
+}

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

@@ -11,7 +11,6 @@ package com.cobblemon.mod.common.api.ai
 import com.google.common.collect.ImmutableList
 import com.mojang.datafixers.util.Pair
 import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.Mob
 import net.minecraft.world.entity.ai.behavior.BehaviorControl
 import net.minecraft.world.entity.schedule.Activity
 
@@ -23,6 +22,13 @@ class ActivityConfigurationContext(val activity: Activity) {
     }
 
     fun apply(entity: LivingEntity) {
+        tasks.forEach {
+            val activityAwareBehavior = it.second as? ActivityAwareBehavior<*>
+                ?: (it.second as? WrapperLivingEntityTask<*>)?.task as? ActivityAwareBehavior
+                ?: return@forEach
+            activityAwareBehavior.activities += activity
+        }
+
         entity.brain.addActivity(activity, ImmutableList.copyOf(tasks))
     }
 }

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

@@ -23,7 +23,7 @@ import net.minecraft.world.entity.schedule.Activity
 
 class ActivityChangeTaskConfig : SingleTaskConfig {
     val activity: Activity = Activity.IDLE
-    val condition: ExpressionLike = "false".asExpressionLike()
+    val condition: ExpressionLike = "true".asExpressionLike()
 
     override fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): List<MoLangConfigVariable> = emptyList()
 

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

@@ -12,11 +12,9 @@ import com.cobblemon.mod.common.CobblemonMemories
 import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
 import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
 import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
 import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.asExpression
-import com.cobblemon.mod.common.util.withQueryValue
 import com.mojang.datafixers.util.Either
 import kotlin.jvm.optionals.getOrNull
 import net.minecraft.world.entity.LivingEntity
@@ -27,7 +25,9 @@ import net.minecraft.world.entity.ai.memory.MemoryModuleType
 import net.minecraft.world.entity.ai.sensing.SensorType
 
 /**
- * Checks nearby entities and counts how many have nominated this entity as their leader.
+ * Checks nearby entities and counts how many have nominated this entity as their leader. We normally update this
+ * as people join and leave the herd, but this is a fallback to make sure we don't get stuck with an incorrect value
+ * like if the entities die or whatever.
  *
  * @author Hiroku
  * @since June 17th, 2025

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

@@ -53,7 +53,7 @@ class FindAirTaskConfig : SingleTaskConfig {
                 it.absent(CobblemonMemories.PATH_COOLDOWN)
             ).apply(it) { walkTarget, pathCooldown ->
                 Trigger { world, entity, time ->
-                    if (!entity.getIsSubmerged()) {
+                    if (!entity.getIsSubmerged() || entity.isInLava) {
                         return@Trigger false
                     }
 

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

@@ -8,17 +8,16 @@
 
 package com.cobblemon.mod.common.api.ai.config.task
 
+import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.CobblemonMemories
 import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
 import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
 import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
 import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
 import com.cobblemon.mod.common.api.storage.party.PartyStore
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.pokemon.ai.ToleratedHerdLeader
 import com.cobblemon.mod.common.util.asExpression
-import com.cobblemon.mod.common.util.withQueryValue
 import com.mojang.datafixers.util.Either
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.ai.behavior.BehaviorControl
@@ -57,21 +56,21 @@ class FindHerdLeaderTaskConfig : SingleTaskConfig {
                         !it.brain.hasMemoryValue(CobblemonMemories.POKEMON_DROWSY)
             }.forEach { possibleLeader ->
                 possibleLeader as PokemonEntity
-                val matchingHerdLeader = entity.behaviour.herd.bestMatchLeader(entity, possibleLeader) ?: return@forEach
-                val alreadyIsALeader = possibleLeader.brain.hasMemoryValue(CobblemonMemories.HERD_SIZE)
-                val nestedHerdTier = currentLeaderEntity?.getHerdTier() ?: 0
-                if (nestedHerdTier >= matchingHerdLeader.tier) {
+                val bestMatchingHerdLeader = entity.behaviour.herd.bestMatchLeader(entity, possibleLeader) ?: return@forEach
+                val possibleLeaderIsAlreadyALeader = possibleLeader.brain.hasMemoryValue(CobblemonMemories.HERD_SIZE)
+                val currentLeaderHerdTier = currentLeaderEntity?.getHerdTier() ?: entity.getHerdTier()
+                if (currentLeaderHerdTier >= bestMatchingHerdLeader.tier) {
                     return@forEach // This leader is following a leader of a higher tier, we can't replace them
                 }
                 val distance = entity.distanceTo(possibleLeader)
-                if (matchingHerdLeader.tier < bestTier) {
+                if (bestMatchingHerdLeader.tier < bestTier) {
                     return@forEach // No need to check further if this leader is worse than the best found so far
-                } else if ((distance > bestDistance && !alreadyIsALeader) && matchingHerdLeader.tier == bestTier) {
+                } else if ((distance > bestDistance && !possibleLeaderIsAlreadyALeader) && bestMatchingHerdLeader.tier == bestTier) {
                     return@forEach // No need to check further if this leader is farther than the best found so far, unless they are already a leader - I'd prefer to join a pack
                 } else {
                     bestLeader = possibleLeader
                     bestDistance = distance
-                    bestTier = matchingHerdLeader.tier
+                    bestTier = bestMatchingHerdLeader.tier
                 }
             }
             return bestLeader ?: currentLeaderEntity
@@ -119,6 +118,7 @@ class FindHerdLeaderTaskConfig : SingleTaskConfig {
 
                     herdLeader.set(bestLeader.uuid.toString())
                     bestLeader.brain.eraseMemory(CobblemonMemories.HERD_LEADER)
+                    bestLeader.adjustHerdSize(1)
                     return@Trigger true
                 }
             }

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

@@ -14,15 +14,19 @@ import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
 import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
 import com.cobblemon.mod.common.api.ai.WrapperLivingEntityTask
 import com.cobblemon.mod.common.api.ai.asVariables
+import com.cobblemon.mod.common.api.molang.ExpressionLike
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.entity.pokemon.ai.tasks.FindRestingPlaceTask
 import com.cobblemon.mod.common.util.asExpression
+import com.cobblemon.mod.common.util.asExpressionLike
+import com.cobblemon.mod.common.util.resolveBoolean
 import com.mojang.datafixers.util.Either
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.ai.behavior.BehaviorControl
 import net.minecraft.world.entity.ai.memory.MemoryModuleType
 
 class FindRestingPlaceTaskConfig : SingleTaskConfig {
+    val condition: ExpressionLike = "true".asExpressionLike()
     val horizontalSearchDistance: ExpressionOrEntityVariable = Either.left("16".asExpression())
     val verticalSearchDistance: ExpressionOrEntityVariable = Either.left("5".asExpression())
 
@@ -31,6 +35,13 @@ class FindRestingPlaceTaskConfig : SingleTaskConfig {
         entity: LivingEntity,
         behaviourConfigurationContext: BehaviourConfigurationContext
     ): BehaviorControl<in LivingEntity>? {
+        if (entity !is PokemonEntity) {
+            return null
+        }
+        if (!behaviourConfigurationContext.runtime.resolveBoolean(condition)) {
+            return null
+        }
+
         behaviourConfigurationContext.addMemories(
             CobblemonMemories.PATH_COOLDOWN,
             CobblemonMemories.POKEMON_DROWSY,

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

@@ -57,7 +57,7 @@ class GoToLandTaskConfig : SingleTaskConfig {
                 it.absent(CobblemonMemories.PATH_COOLDOWN)
             ).apply(it) { walkTarget, pathCooldown ->
                 Trigger { world, entity, time ->
-                    if (!entity.isInLiquid) {
+                    if (!entity.isInWater) {
                         return@Trigger false
                     }
 

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

@@ -11,15 +11,20 @@ package com.cobblemon.mod.common.api.ai.config.task
 import com.cobblemon.mod.common.CobblemonMemories
 import com.cobblemon.mod.common.CobblemonSensors
 import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
+import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
 import com.cobblemon.mod.common.api.ai.WrapperLivingEntityTask
 import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.entity.pokemon.ai.tasks.GoToSleepTask
+import com.cobblemon.mod.common.util.asExpression
+import com.cobblemon.mod.common.util.resolveBoolean
+import com.mojang.datafixers.util.Either
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.ai.behavior.BehaviorControl
 import net.minecraft.world.entity.ai.memory.MemoryModuleType
 
 class GoToSleepTaskConfig : SingleTaskConfig {
+    var onlyFromStatus: ExpressionOrEntityVariable = Either.left("false".asExpression())
     override fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext) = emptyList<MoLangConfigVariable>()
     override fun createTask(
         entity: LivingEntity,
@@ -34,6 +39,6 @@ class GoToSleepTaskConfig : SingleTaskConfig {
             CobblemonMemories.POKEMON_SLEEPING
         )
         behaviourConfigurationContext.addSensors(CobblemonSensors.POKEMON_DROWSY)
-        return WrapperLivingEntityTask(GoToSleepTask.create(), PokemonEntity::class.java)
+        return WrapperLivingEntityTask(GoToSleepTask.create(onlyFromStatus.resolveBoolean(behaviourConfigurationContext.runtime)), PokemonEntity::class.java)
     }
 }

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

@@ -10,17 +10,28 @@ package com.cobblemon.mod.common.api.ai.config.task
 
 import com.cobblemon.mod.common.CobblemonMemories
 import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
+import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
 import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
 import com.cobblemon.mod.common.entity.npc.ai.LookAtSpeakerTask
+import com.cobblemon.mod.common.util.asExpression
+import com.mojang.datafixers.util.Either
 import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.ai.behavior.BehaviorControl
 import net.minecraft.world.entity.ai.memory.MemoryModuleType
 
 class LookAtSpeakerTaskConfig : SingleTaskConfig {
+    val condition: ExpressionOrEntityVariable = Either.left("true".asExpression())
     override fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext) = emptyList<MoLangConfigVariable>()
     override fun createTask(
         entity: LivingEntity,
         behaviourConfigurationContext: BehaviourConfigurationContext
-    ) = LookAtSpeakerTask.create().also {
-        behaviourConfigurationContext.addMemories(MemoryModuleType.LOOK_TARGET, CobblemonMemories.DIALOGUES)
+    ): BehaviorControl<in LivingEntity>? {
+        if (!condition.resolveBoolean(behaviourConfigurationContext.runtime)) {
+            return null
+        }
+
+        return LookAtSpeakerTask.create().also {
+            behaviourConfigurationContext.addMemories(MemoryModuleType.LOOK_TARGET, CobblemonMemories.DIALOGUES)
+        }
     }
 }

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

@@ -8,15 +8,14 @@
 
 package com.cobblemon.mod.common.api.ai.config.task
 
+import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.CobblemonMemories
 import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
 import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
 import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
 import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.asExpression
-import com.cobblemon.mod.common.util.withQueryValue
 import com.mojang.datafixers.util.Either
 import java.util.UUID
 import net.minecraft.world.entity.LivingEntity
@@ -82,6 +81,8 @@ class MaintainHerdLeaderTaskConfig : SingleTaskConfig {
                         if (bestLeader != null && bestLeader != leader) {
                             bestLeader.brain.eraseMemory(CobblemonMemories.HERD_LEADER)
                             entity.brain.setMemory(CobblemonMemories.HERD_LEADER, bestLeader.uuid.toString())
+                            bestLeader.adjustHerdSize(1)
+                            leader.adjustHerdSize(-1)
                         }
                     }
                     return@Trigger true

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

@@ -17,6 +17,7 @@ import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
 import com.cobblemon.mod.common.api.ai.asVariables
 import com.cobblemon.mod.common.entity.npc.NPCEntity
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.util.getMemorySafely
 import com.cobblemon.mod.common.util.resolveString
 import com.mojang.datafixers.util.Either
 import net.minecraft.server.level.ServerLevel
@@ -62,7 +63,7 @@ class MemoryAspectTaskConfig : SingleTaskConfig {
             override fun canStillUse(level: ServerLevel, entity: LivingEntity, gameTime: Long) = true
 
             override fun tick(level: ServerLevel, owner: LivingEntity, gameTime: Long) {
-                val hasMemory = !owner.brain.hasMemoryValue(memory)
+                val hasMemory = owner.brain.hasMemoryValue(memory)
                 if (owner is PokemonEntity) {
                     if (!hasMemory && aspect in owner.pokemon.forcedAspects) {
                         owner.pokemon.forcedAspects -= aspect

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

@@ -8,16 +8,31 @@
 
 package com.cobblemon.mod.common.api.ai.config.task
 
+import com.cobblemon.mod.common.CobblemonMemories
+import com.cobblemon.mod.common.CobblemonSensors
 import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
 import com.cobblemon.mod.common.api.ai.asVariables
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.entity.pokemon.ai.tasks.PathToBeeHiveTask
+import com.cobblemon.mod.common.entity.pokemon.ai.tasks.PlaceHoneyInHiveTask
+import com.cobblemon.mod.common.util.distanceTo
+import com.cobblemon.mod.common.util.getMemorySafely
+import net.minecraft.core.BlockPos
+import net.minecraft.server.level.ServerLevel
 import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.PathfinderMob
+import net.minecraft.world.entity.ai.behavior.Behavior
 import net.minecraft.world.entity.ai.behavior.BehaviorControl
+import net.minecraft.world.entity.ai.behavior.BlockPosTracker
+import net.minecraft.world.entity.ai.memory.MemoryModuleType
+import net.minecraft.world.entity.ai.memory.MemoryStatus
+import net.minecraft.world.entity.ai.memory.WalkTarget
+import net.minecraft.world.phys.Vec3
 
 class PathToBeeHiveTaskConfig : SingleTaskConfig {
     companion object {
         const val HONEY = "honey"
+        const val STAY_OUT_OF_HIVE_COOLDOWN = 400
+
     }
 
     val condition = booleanVariable(HONEY, "can_add_honey", true).asExpressible()
@@ -36,6 +51,107 @@ class PathToBeeHiveTaskConfig : SingleTaskConfig {
         if (!checkCondition(behaviourConfigurationContext.runtime, condition)) {
             return null
         }
-        return PathToBeeHiveTask.create()
+        behaviourConfigurationContext.addSensors(CobblemonSensors.NEARBY_BEE_HIVE)
+        return object : Behavior<LivingEntity>(
+            mapOf(
+                MemoryModuleType.LOOK_TARGET to MemoryStatus.REGISTERED,
+                MemoryModuleType.WALK_TARGET to MemoryStatus.VALUE_ABSENT,
+                CobblemonMemories.HAS_NECTAR to MemoryStatus.REGISTERED,
+                CobblemonMemories.HIVE_LOCATION to MemoryStatus.VALUE_PRESENT,
+                CobblemonMemories.HIVE_COOLDOWN to MemoryStatus.VALUE_ABSENT,
+                CobblemonMemories.HIVE_BLACKLIST to MemoryStatus.REGISTERED,
+            ),
+            400,
+            400
+        ) {
+
+            val maxTicks = 400
+            var traveledTicks = 0
+
+            override fun checkExtraStartConditions(level: ServerLevel, owner: LivingEntity): Boolean {
+                return (owner is PathfinderMob && owner.isAlive  && (owner is PokemonEntity && PlaceHoneyInHiveTask.wantsToEnterHive(owner))) && owner.brain.checkMemory(
+                    MemoryModuleType.WALK_TARGET, MemoryStatus.VALUE_ABSENT)
+            }
+
+            override fun canStillUse(level: ServerLevel, entity: LivingEntity, gameTime: Long): Boolean {
+                if (maxTicks >= traveledTicks) return false
+                val pos = entity.brain.getMemory(CobblemonMemories.HIVE_LOCATION)
+                return !pos.isEmpty && entity.distanceTo(pos.get()) > 1.0
+            }
+
+            override fun start(level: ServerLevel, entity: LivingEntity, gameTime: Long) {
+                super.start(level, entity, gameTime)
+                val hiveLocation = entity.brain.getMemorySafely(CobblemonMemories.HIVE_LOCATION).orElse(null)
+                val world = entity.level()
+                val sidesByClosest = listOf(
+                    hiveLocation.north(),
+                    hiveLocation.south(),
+                    hiveLocation.east(),
+                    hiveLocation.west()
+                ).sortedBy { it.distSqr(entity.blockPosition()) }
+
+                var openSide = BlockPos.ZERO
+                for (side in sidesByClosest) {
+                    if (world.getBlockState(side).isAir) {
+                        openSide = side
+                        break
+                    }
+                }
+                if (openSide == BlockPos.ZERO) {
+                    if (world.getBlockState(hiveLocation.above()).isAir) {
+                        // If the above position is also air, we can use it
+                        openSide = hiveLocation.above() // Fallback to above if no open sides found
+                    } else if (world.getBlockState(hiveLocation.below()).isAir) {
+                        // If the below position is also air, we can use it
+                        openSide = hiveLocation.below() // Fallback to below if no open sides found
+                    } else {
+                        // If no open sides or above/below positions are found, we cannot proceed
+                        return
+                    }
+                }
+                val targetVec = Vec3.atCenterOf(openSide)
+
+                // Set path target toward hive
+                if (pathfindDirectlyTowards(openSide, entity)) {
+                    entity.brain.setMemory(MemoryModuleType.WALK_TARGET,WalkTarget(targetVec, 0.35F, 0))
+                    entity.brain.setMemory(MemoryModuleType.LOOK_TARGET,BlockPosTracker(targetVec.add(0.0, entity.eyeHeight.toDouble(), 0.0)))
+                    traveledTicks = 0
+                } else {
+                    dropAndBlackListHive(entity)
+                }
+            }
+
+            override fun tick(level: ServerLevel, owner: LivingEntity, gameTime: Long) {
+                traveledTicks++
+            }
+
+            override fun stop(level: ServerLevel, entity: LivingEntity, gameTime: Long) {
+                if (maxTicks < traveledTicks) {
+                    dropAndBlackListHive(entity)
+                    entity.brain.setMemoryWithExpiry(CobblemonMemories.HIVE_COOLDOWN, true, 100)
+                }
+            }
+
+            fun dropAndBlackListHive(entity: LivingEntity) {
+                val hivePos = entity.brain.getMemorySafely(CobblemonMemories.HIVE_LOCATION).orElse(null)
+                if (hivePos == null) return
+                val blackList = entity.brain.getMemorySafely(CobblemonMemories.HIVE_BLACKLIST).orElse(emptyList()).toMutableList()
+
+                blackList.add(hivePos)
+                if (blackList.count() > 3) {
+                    blackList.removeFirst()
+                }
+                entity.brain.eraseMemory(CobblemonMemories.HIVE_LOCATION)
+                entity.brain.setMemory(CobblemonMemories.HIVE_BLACKLIST, blackList)
+
+            }
+
+            private fun pathfindDirectlyTowards(pos: BlockPos, entity: LivingEntity): Boolean {
+                if (entity !is PathfinderMob) return false
+                val nav = entity.navigation
+                val path = nav. createPath(pos, 0)
+                return path != null && path.canReach()
+            }
+        }
     }
 }

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

@@ -8,7 +8,6 @@
 
 package com.cobblemon.mod.common.api.ai.config.task
 
-import com.bedrockk.molang.runtime.MoLangRuntime
 import com.cobblemon.mod.common.CobblemonMemories
 import com.cobblemon.mod.common.CobblemonSensors
 import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
@@ -41,12 +40,14 @@ class PathToFlowerTaskConfig : SingleTaskConfig {
             return null
         }
         behaviourConfigurationContext.addMemories(
-            CobblemonMemories.NEARBY_FLOWERS,
+            CobblemonMemories.NEARBY_FLOWER,
+            CobblemonMemories.PATH_TO_NEARBY_FLOWER_COOLDOWN,
             CobblemonMemories.HIVE_COOLDOWN,
             CobblemonMemories.HIVE_LOCATION,
-            CobblemonMemories.POLLINATED
+            CobblemonMemories.HIVE_BLACKLIST,
+            CobblemonMemories.HAS_NECTAR,
         )
-        behaviourConfigurationContext.addSensors(CobblemonSensors.NEARBY_BEE_HIVE, CobblemonSensors.NEARBY_FLOWER)
+        behaviourConfigurationContext.addSensors(CobblemonSensors.NEARBY_FLOWER)
         return PathToFlowerTask.create()
     }
 }

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

@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.ai.config.task
+
+import com.cobblemon.mod.common.CobblemonMemories
+import com.cobblemon.mod.common.CobblemonSensors
+import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
+import com.cobblemon.mod.common.api.ai.asVariables
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.entity.pokemon.ai.tasks.PathToSacLeafTask
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.ai.behavior.BehaviorControl
+
+class PathToSaccLeavesTaskConfig : SingleTaskConfig {
+    companion object {
+        const val POLLINATE = "pollinate"
+    }
+
+    val condition = booleanVariable(POLLINATE, "can_pollinate", true).asExpressible()
+
+    override fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext) = listOf(
+        condition
+    ).asVariables()
+
+    override fun createTask(
+        entity: LivingEntity,
+        behaviourConfigurationContext: BehaviourConfigurationContext
+    ): BehaviorControl<in LivingEntity>? {
+        if (entity !is PokemonEntity) {
+            return null
+        }
+
+        if (!checkCondition(behaviourConfigurationContext.runtime, condition)) {
+            return null
+        }
+        behaviourConfigurationContext.addMemories(
+CobblemonMemories.NEARBY_SACC_LEAVES,
+            CobblemonMemories.HAS_NECTAR
+        )
+        behaviourConfigurationContext.addSensors(CobblemonSensors.NEARBY_SACC_LEAVES, CobblemonSensors.NEARBY_FLOWER)
+        return PathToSacLeafTask.create()
+    }
+}

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

@@ -8,8 +8,8 @@
 
 package com.cobblemon.mod.common.api.ai.config.task
 
-import com.bedrockk.molang.runtime.MoLangRuntime
 import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
+import com.cobblemon.mod.common.api.ai.WrapperLivingEntityTask
 import com.cobblemon.mod.common.api.ai.asVariables
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.entity.pokemon.ai.tasks.PlaceHoneyInHiveTask
@@ -37,6 +37,9 @@ class PlaceHoneyInHiveTaskConfig : SingleTaskConfig {
         if (!checkCondition(behaviourConfigurationContext.runtime, condition)) {
             return null
         }
-        return PlaceHoneyInHiveTask.create()
+        return WrapperLivingEntityTask(
+            PlaceHoneyInHiveTask.create(),
+            PokemonEntity::class.java
+        )
     }
 }

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

@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.ai.config.task
+
+import com.cobblemon.mod.common.CobblemonActivities
+import com.cobblemon.mod.common.CobblemonBlocks
+import com.cobblemon.mod.common.CobblemonMemories
+import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
+import com.cobblemon.mod.common.api.ai.asVariables
+import com.cobblemon.mod.common.block.SaccharineLeafBlock
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.util.getMemorySafely
+import net.minecraft.server.level.ServerLevel
+import net.minecraft.sounds.SoundEvents
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.ai.behavior.Behavior
+import net.minecraft.world.entity.ai.behavior.BehaviorControl
+import net.minecraft.world.entity.ai.memory.MemoryModuleType
+import net.minecraft.world.entity.ai.memory.MemoryStatus
+import net.minecraft.world.phys.Vec3
+
+class PlaceHoneyInSaccLeavesTaskConfig : SingleTaskConfig {
+    companion object {
+        const val POLLINATE = "pollinate"
+        const val MIN_DURATION : Int = 300
+        const val MAX_DURATION : Int = 400
+        const val REQUIRED_SUCCESSFUL_POLLINATION_TICKS = 250
+    }
+
+    val condition = booleanVariable(POLLINATE, "can_pollinate", true).asExpressible()
+
+    override fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext) = listOf(
+        condition
+    ).asVariables()
+
+    override fun createTask(
+        entity: LivingEntity,
+        behaviourConfigurationContext: BehaviourConfigurationContext
+    ): BehaviorControl<in LivingEntity>? {
+        if (entity !is PokemonEntity) {
+            return null
+        }
+        if (!checkCondition(behaviourConfigurationContext.runtime, condition)) {
+            return null
+        }
+
+        return object : Behavior<LivingEntity>(
+            mapOf(
+                CobblemonMemories.NEARBY_SACC_LEAVES to MemoryStatus.VALUE_PRESENT,
+                MemoryModuleType.WALK_TARGET to MemoryStatus.VALUE_ABSENT,
+                CobblemonMemories.HAS_NECTAR to MemoryStatus.VALUE_PRESENT,
+            ),
+            MIN_DURATION,
+            MAX_DURATION
+        ) {
+            var successfulPollinationTicks = 0
+            var lastSoundPlayedTick = 0
+            var hoverPos: Vec3? = null
+
+            override fun checkExtraStartConditions(level: ServerLevel, owner: LivingEntity): Boolean {
+                if (level.isNight || level.isRaining || !(entity.brain.getMemorySafely(CobblemonMemories.HAS_NECTAR).orElse(false))) return false
+                val optionalBlockPos = entity.brain.getMemorySafely(CobblemonMemories.NEARBY_SACC_LEAVES)
+                if (!optionalBlockPos.isPresent || level.getBlockState(optionalBlockPos.get()).block != CobblemonBlocks.SACCHARINE_LEAVES) return false
+                return Vec3.atCenterOf(optionalBlockPos.get()).distanceTo(entity.position()) <= 0.6
+            }
+
+            override fun canStillUse(level: ServerLevel, entity: LivingEntity, gameTime: Long): Boolean {
+                return checkExtraStartConditions(level, entity) && entity.brain.activeActivities.indexOf(
+                    CobblemonActivities.POKEMON_POLLINATION) != -1
+            }
+
+            override fun start(level: ServerLevel, entity: LivingEntity, gameTime: Long) {
+                super.start(level, entity, gameTime)
+                hoverPos = null
+            }
+
+            override fun tick(level: ServerLevel, owner: LivingEntity, gameTime: Long) {
+                ++successfulPollinationTicks
+                if (entity.random.nextFloat() < 0.05f && successfulPollinationTicks > this.lastSoundPlayedTick + 60) {
+                    this.lastSoundPlayedTick = successfulPollinationTicks
+                    entity.playSound(SoundEvents.BEEHIVE_DRIP, 1.0f, 1.0f)
+                }
+                val leavesPos = entity.brain.getMemorySafely(CobblemonMemories.NEARBY_SACC_LEAVES).orElse(null)
+
+                val bl = hoverPos == null || entity.position().distanceTo(hoverPos!!) <= 0.1
+                val bl3 = entity.random.nextInt(40) == 0
+                if (bl && bl3) {
+                    // mimics the wriggling over a flower the vanilla bees do
+                    if (hoverPos == null) {
+                        hoverPos = leavesPos.bottomCenter.add(0.0, 0.4, 0.0)
+                    }
+                    if (leavesPos != null) {
+                        hoverPos = leavesPos.bottomCenter.add(Vec3((entity.random.nextDouble() * 2.0 - 1.0) * (1.0/5.0), 0.3 + (entity.random.nextDouble() * 2.0 - 1.0) * (1.0/7.0), (entity.random.nextDouble() * 2.0 - 1.0) * (1.0/5.0)))
+                        entity.getMoveControl()
+                            .setWantedPosition(hoverPos!!.x(), hoverPos!!.y(), hoverPos!!.z(), 0.35)
+                        entity.lookControl.setLookAt(leavesPos.bottomCenter.add(0.0,0.5,0.0))
+                    }
+                } else if (!bl) {
+                    entity.getMoveControl()
+                        .setWantedPosition(hoverPos!!.x(), hoverPos!!.y(), hoverPos!!.z(), 0.35)
+                }
+            }
+
+            override fun stop(level: ServerLevel, entity: LivingEntity, gameTime: Long) {
+                if (successfulPollinationTicks > REQUIRED_SUCCESSFUL_POLLINATION_TICKS) {
+                    val blockPos = entity.brain.getMemorySafely(CobblemonMemories.NEARBY_SACC_LEAVES).orElse(null)
+                    blockPos.let {
+                        val blockState = level.getBlockState(blockPos)
+                        if (blockState.block == CobblemonBlocks.SACCHARINE_LEAVES) {
+                            val saccAge = blockState.getValue( SaccharineLeafBlock.AGE)
+                            if (saccAge < SaccharineLeafBlock.MAX_AGE) {
+                                entity.brain.eraseMemory(CobblemonMemories.HAS_NECTAR)
+                                val newBlockState = blockState.setValue(SaccharineLeafBlock.AGE,  saccAge + 1)
+                                level.setBlock(blockPos, newBlockState, 3)
+                            }
+                        }
+                    }
+                }
+                successfulPollinationTicks = 0
+                entity.brain.eraseMemory(MemoryModuleType.WALK_TARGET)
+            }
+        }
+    }
+}

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

@@ -8,17 +8,14 @@
 
 package com.cobblemon.mod.common.api.ai.config.task
 
+import com.cobblemon.mod.common.CobblemonActivities
 import com.cobblemon.mod.common.CobblemonMemories
 import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
 import com.cobblemon.mod.common.api.ai.asVariables
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.asExpression
 import com.cobblemon.mod.common.util.getMemorySafely
-import com.cobblemon.mod.common.util.sendParticlesServer
-import com.mojang.datafixers.util.Either
-import net.minecraft.core.particles.ParticleTypes
 import net.minecraft.server.level.ServerLevel
+import net.minecraft.sounds.SoundEvents
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.ai.behavior.Behavior
 import net.minecraft.world.entity.ai.behavior.BehaviorControl
@@ -29,10 +26,11 @@ import net.minecraft.world.phys.Vec3
 class PollinateFlowerTaskConfig : SingleTaskConfig {
     companion object {
         const val POLLINATE = "pollinate"
+        const val PATH_TO_FLOWER_COOLDOWN_TICKS : Long = 200
+        const val HAS_NECTAR_ASPECT = "has_nectar"
     }
 
     val condition = booleanVariable(POLLINATE, "can_pollinate", true).asExpressible()
-    val durationTicks: ExpressionOrEntityVariable = Either.left("30".asExpression())
 
     override fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext) = listOf(
         condition
@@ -51,22 +49,28 @@ class PollinateFlowerTaskConfig : SingleTaskConfig {
 
         return object : Behavior<LivingEntity>(
             mapOf(
-                CobblemonMemories.NEARBY_FLOWERS to MemoryStatus.VALUE_PRESENT,
+                CobblemonMemories.NEARBY_FLOWER to MemoryStatus.VALUE_PRESENT,
                 MemoryModuleType.WALK_TARGET to MemoryStatus.VALUE_ABSENT,
-                CobblemonMemories.POLLINATED to MemoryStatus.VALUE_ABSENT,
+                CobblemonMemories.HAS_NECTAR to MemoryStatus.REGISTERED,
                 CobblemonMemories.HIVE_COOLDOWN to MemoryStatus.VALUE_ABSENT,
             ),
-            15,
-            45
+            600,
+            625
         ) {
+            val REQUIRED_SUCCESSFUL_POLLINATION_TICKS = 400
+            var successfulPollinationTicks = 0
+            var lastSoundPlayedTick = 0
+            var hoverPos: Vec3? = null
+
             override fun checkExtraStartConditions(level: ServerLevel, owner: LivingEntity): Boolean {
-                return entity.brain.getMemorySafely(CobblemonMemories.NEARBY_FLOWERS).orElse(emptyList()).any {
-                    Vec3.atCenterOf(it).distanceTo(entity.position()) <= 1.0
-                }
+                if (level.isNight || level.isRaining || entity.brain.getMemorySafely(CobblemonMemories.HAS_NECTAR).orElse(false)) return false
+                val optionalBlockPos = entity.brain.getMemorySafely(CobblemonMemories.NEARBY_FLOWER)
+                return optionalBlockPos.isPresent && Vec3.atCenterOf(optionalBlockPos.get()).distanceTo(entity.position()) <= 1.0
             }
 
             override fun canStillUse(level: ServerLevel, entity: LivingEntity, gameTime: Long): Boolean {
-                return checkExtraStartConditions(level, entity)
+                return checkExtraStartConditions(level, entity) && entity.brain.activeActivities.indexOf(
+                    CobblemonActivities.POKEMON_POLLINATION) != -1
             }
 
             override fun start(level: ServerLevel, entity: LivingEntity, gameTime: Long) {
@@ -74,20 +78,44 @@ class PollinateFlowerTaskConfig : SingleTaskConfig {
             }
 
             override fun tick(level: ServerLevel, owner: LivingEntity, gameTime: Long) {
-                level.sendParticlesServer(
-                    particleType = ParticleTypes.DRIPPING_HONEY,
-                    position = owner.eyePosition,
-                    particles = 3,
-                    offset = Vec3.ZERO,
-                    speed = 0.0
-                )
+                ++successfulPollinationTicks
+                if (entity.random.nextFloat() < 0.05f && successfulPollinationTicks > this.lastSoundPlayedTick + 60) {
+                    this.lastSoundPlayedTick = successfulPollinationTicks
+                    entity.playSound(SoundEvents.BEE_POLLINATE, 1.0f, 1.0f)
+                }
+                val flowerPos = entity.brain.getMemorySafely(CobblemonMemories.NEARBY_FLOWER).orElse(null)
+
+
+                val bl = hoverPos == null || entity.position().distanceTo(hoverPos!!) <= 0.1
+                val bl3 = entity.random.nextInt(40) == 0
+                if (bl && bl3) {
+                    // mimics the wriggling over a flower the vanilla bees do
+                    if (hoverPos == null) {
+                        hoverPos = flowerPos.bottomCenter.add(0.0, 0.4, 0.0)
+                    }
+
+                    if (flowerPos != null) {
+                        hoverPos = flowerPos.bottomCenter.add(Vec3((entity.random.nextDouble() * 2.0 - 1.0) * (1.0/5.0), 0.3 + (entity.random.nextDouble() * 2.0 - 1.0) * (1.0/7.0), (entity.random.nextDouble() * 2.0 - 1.0) * (1.0/5.0)))
+                        entity.getMoveControl()
+                            .setWantedPosition(hoverPos!!.x(), hoverPos!!.y(), hoverPos!!.z(), 0.35)
+                        entity.lookControl.setLookAt(flowerPos.bottomCenter.add(0.0,0.5,0.0))
+                    }
+                } else if (!bl) {
+                    entity.getMoveControl()
+                        .setWantedPosition(hoverPos!!.x(), hoverPos!!.y(), hoverPos!!.z(), 0.35)
+                }
+                entity.lookControl.setLookAt(flowerPos.bottomCenter.add(0.0,0.5,0.0))
+
             }
 
             override fun stop(level: ServerLevel, entity: LivingEntity, gameTime: Long) {
-                val flowerStillThere = canStillUse(level, entity, gameTime)
-                if (flowerStillThere) {
-                    entity.brain.setMemory(CobblemonMemories.POLLINATED, true)
+
+                if (successfulPollinationTicks > REQUIRED_SUCCESSFUL_POLLINATION_TICKS) {
+                    entity.brain.setMemory(CobblemonMemories.HAS_NECTAR, true)
                 }
+                successfulPollinationTicks = 0
+                entity.brain.setMemoryWithExpiry(CobblemonMemories.PATH_TO_NEARBY_FLOWER_COOLDOWN, true, PATH_TO_FLOWER_COOLDOWN_TICKS)
+
             }
         }
     }

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

@@ -97,7 +97,9 @@ interface TaskConfig {
             cobblemonResource("go_to_land") to GoToLandTaskConfig::class.java,
             cobblemonResource("path_to_hive") to PathToBeeHiveTaskConfig::class.java,
             cobblemonResource("place_honey_in_hive") to PlaceHoneyInHiveTaskConfig::class.java,
+            cobblemonResource("place_honey_in_sacc_leaves") to PlaceHoneyInSaccLeavesTaskConfig::class.java,
             cobblemonResource("path_to_flower") to PathToFlowerTaskConfig::class.java,
+            cobblemonResource("path_to_sacc_leaves") to PathToSaccLeavesTaskConfig::class.java,
             cobblemonResource("pollinate_flower") to PollinateFlowerTaskConfig::class.java,
             cobblemonResource("go_to_land") to GoToLandTaskConfig::class.java,
             cobblemonResource("manage_flight_in_battle") to ManageFlightInBattleTaskConfig::class.java,

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

@@ -14,6 +14,8 @@ import com.cobblemon.mod.common.api.ai.CobblemonWanderControl
 import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
 import com.cobblemon.mod.common.api.ai.asVariables
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
+import com.cobblemon.mod.common.entity.OmniPathingEntity
+import com.cobblemon.mod.common.entity.ai.CobblemonRandomSurfacePos
 import com.cobblemon.mod.common.entity.ai.CobblemonWalkTarget
 import com.cobblemon.mod.common.util.asExpression
 import com.cobblemon.mod.common.util.mainThreadRuntime
@@ -26,6 +28,7 @@ import net.minecraft.server.level.ServerLevel
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.PathfinderMob
 import net.minecraft.world.entity.ai.behavior.BehaviorControl
+import net.minecraft.world.entity.ai.behavior.BehaviorUtils
 import net.minecraft.world.entity.ai.behavior.BlockPosTracker
 import net.minecraft.world.entity.ai.behavior.declarative.BehaviorBuilder
 import net.minecraft.world.entity.ai.behavior.declarative.Trigger
@@ -41,24 +44,27 @@ class WanderTaskConfig : SingleTaskConfig {
     }
 
     val condition = booleanVariable(WANDER, "wanders", true).asExpressible()
-    val wanderChance = numberVariable(WANDER, "wander_chance", 1/(20 * 6F)).asExpressible()
+    val wanderChance = numberVariable(WANDER, "wander_chance", 1 / (20 * 6F)).asExpressible()
     val horizontalRange = numberVariable(WANDER, "horizontal_wander_range", 10).asExpressible()
     val verticalRange = numberVariable(WANDER, "vertical_wander_range", 5).asExpressible()
-    val speedMultiplier = numberVariable(SharedEntityVariables.MOVEMENT_CATEGORY, SharedEntityVariables.WALK_SPEED, 0.35).asExpressible()
-    val avoidTargetingAir: ExpressionOrEntityVariable = Either.left("true".asExpression()) // Whether to avoid air blocks when wandering
+    val speedMultiplier =
+        numberVariable(SharedEntityVariables.MOVEMENT_CATEGORY, SharedEntityVariables.WALK_SPEED, 0.35).asExpressible()
+    val avoidTargetingAir: ExpressionOrEntityVariable =
+        Either.left("true".asExpression()) // Whether to avoid air blocks when wandering
     val minimumHeight: ExpressionOrEntityVariable = Either.left("0".asExpression()) // Height off the ground
     val maximumHeight: ExpressionOrEntityVariable = Either.left("-1".asExpression()) // Height off the ground
 
-    override fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext) = listOf(
-        condition,
-        wanderChance,
-        horizontalRange,
-        verticalRange,
-        speedMultiplier,
-        avoidTargetingAir,
-        minimumHeight,
-        maximumHeight
-    ).asVariables()
+    override fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext) =
+        listOf(
+            condition,
+            wanderChance,
+            horizontalRange,
+            verticalRange,
+            speedMultiplier,
+            avoidTargetingAir,
+            minimumHeight,
+            maximumHeight
+        ).asVariables()
 
     private fun applyHeightConstraints(
         pos: BlockPos,
@@ -77,7 +83,7 @@ class WanderTaskConfig : SingleTaskConfig {
             (1..MAX_LOOK_DOWN_DISTANCE).firstOrNull {
                 val newPos = pos.below(it)
                 if (!world.getBlockState(newPos).isAir) {
-                    return@firstOrNull  true
+                    return@firstOrNull true
                 } else if (newPos.y <= world.minBuildHeight) {
                     // Don't adjust downward into the void (Mostly if we're in the end)
                     // This doesn't stop fliers from wandering off end islands,
@@ -126,7 +132,7 @@ class WanderTaskConfig : SingleTaskConfig {
                 it.registered(CobblemonMemories.WANDER_CONTROL)
             ).apply(it) { walkTarget, lookTarget, pathCooldown, wanderControl ->
                 Trigger { world, entity, time ->
-                    if (entity !is PathfinderMob || entity.isUnderWater) {
+                    if (entity !is PathfinderMob || (entity.isUnderWater && !(entity.canBreatheUnderwater() && !((entity as OmniPathingEntity).canSwimInWater())))) {
                         return@Trigger false
                     }
 
@@ -134,10 +140,9 @@ class WanderTaskConfig : SingleTaskConfig {
                     mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
                     val avoidsTargetingAir = avoidTargetingAir.resolveBoolean(mainThreadRuntime)
                     val wanderChance = mainThreadRuntime.resolveFloat(wanderChanceExpression)
-                    if (wanderChance <= 0 || world.random.nextFloat() > wanderChance || !wanderControl.allowLand) {
+                    if (wanderChance <= 0 || world.random.nextFloat() > wanderChance) {
                         return@Trigger false
                     }
-
                     pathCooldown.setWithExpiry(true, wanderControl.pathCooldownTicks.toLong())
                     val minimumHeight = minimumHeight.resolveInt(mainThreadRuntime)
                     val maximumHeight = maximumHeight.resolveInt(mainThreadRuntime)
@@ -157,14 +162,28 @@ class WanderTaskConfig : SingleTaskConfig {
                                 maximumHeight,
                                 minimumHeight
                             )
+                        } else if (entity.isUnderWater && entity.canBreatheUnderwater() && !((entity as OmniPathingEntity).canSwimInWater())) {
+                            BehaviorUtils.getRandomSwimmablePos(
+                                entity,
+                                horizontalRange.resolveInt(mainThreadRuntime),
+                                verticalRange.resolveInt(mainThreadRuntime)
+                            )
+                        } else if (entity is OmniPathingEntity && (entity.canWalkOnWater() || entity.canWalkOnLava())) {
+                            CobblemonRandomSurfacePos.getPos(
+                                entity,
+                                horizontalRange.resolveInt(mainThreadRuntime),
+                                verticalRange.resolveInt(mainThreadRuntime)
+                            )
                         } else {
-                                LandRandomPos.getPos(
-                                    entity,
-                                    horizontalRange.resolveInt(mainThreadRuntime),
-                                    verticalRange.resolveInt(mainThreadRuntime)
-                                )
+                            LandRandomPos.getPos(
+                                entity,
+                                horizontalRange.resolveInt(mainThreadRuntime),
+                                verticalRange.resolveInt(mainThreadRuntime)
+                            )
                         } ?: continue
 
+                        if (targetVec == null) continue
+
                         pos = applyHeightConstraints(
                             pos = BlockPos.containing(targetVec),
                             minimumHeight = minimumHeight,
@@ -182,8 +201,17 @@ class WanderTaskConfig : SingleTaskConfig {
                             pos = pos,
                             speedModifier = speedMultiplier.resolveFloat(mainThreadRuntime),
                             completionRange = 0,
-                            nodeTypeFilter = { nodeType -> nodeType !in listOf(PathType.WATER, PathType.WATER_BORDER) },
-                            destinationNodeTypeFilter = { nodeType -> !avoidsTargetingAir || nodeType !in listOf(PathType.OPEN) }
+                            nodeTypeFilter = { nodeType ->
+                                entity.canBreatheUnderwater() || nodeType !in listOf(
+                                    PathType.WATER,
+                                    PathType.WATER_BORDER
+                                )
+                            },
+                            destinationNodeTypeFilter = { nodeType ->
+                                !avoidsTargetingAir || nodeType !in listOf(
+                                    PathType.OPEN
+                                )
+                            }
                         )
                     )
                     lookTarget.set(BlockPosTracker(pos.toVec3d().add(0.0, entity.eyeHeight.toDouble(), 0.0)))

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

@@ -31,8 +31,10 @@ import net.minecraft.world.entity.ai.behavior.BlockPosTracker
 import net.minecraft.world.entity.ai.behavior.declarative.BehaviorBuilder
 import net.minecraft.world.entity.ai.behavior.declarative.Trigger
 import net.minecraft.world.entity.ai.memory.MemoryModuleType
+import net.minecraft.world.level.material.Fluids
 import net.minecraft.world.level.pathfinder.PathType
 import net.minecraft.world.phys.Vec3
+import kotlin.math.ceil
 
 class WaterWanderTaskConfig : SingleTaskConfig {
     val condition = booleanVariable(WANDER, "water_wanders", true).asExpressible()
@@ -100,6 +102,33 @@ class WaterWanderTaskConfig : SingleTaskConfig {
                         return@Trigger false
                     }
 
+                    // Move target pos down so that we don't move out of water too much
+                    val requiredDepth = ceil(0.5 + entity.eyeHeight)
+                    // Get the current depth of the block
+                    var depth = 1
+                    var testPos = pos.above()
+                    var blockState = entity.level().getBlockState(testPos)
+                    while (blockState.fluidState.type == Fluids.WATER) {
+                        depth++
+                        testPos = testPos!!.above()
+                        blockState = entity.level().getBlockState(testPos)
+                    }
+
+                    if (depth < requiredDepth) {
+                        // Iterate down until we reach the desired min depth or we reach a non water block
+                        pos = pos.below()
+                        blockState = entity.level().getBlockState(pos)
+                        while (blockState.fluidState.type == Fluids.WATER && depth < requiredDepth) {
+                            depth ++
+                            pos = pos!!.below()
+                            blockState = entity.level().getBlockState(pos)
+                        }
+                    }
+
+                    if (depth < requiredDepth) {
+                        return@Trigger false
+                    }
+
                     walkTarget.set(
                         CobblemonWalkTarget(
                             pos = pos,

common/src/main/kotlin/com/cobblemon/mod/common/api/cooking/Flavour.kt

@@ -8,7 +8,6 @@
 
 package com.cobblemon.mod.common.api.cooking
 
-import net.minecraft.ChatFormatting
 import net.minecraft.util.StringRepresentable
 
 /**
@@ -18,16 +17,16 @@ import net.minecraft.util.StringRepresentable
  * @author Licious
  * @since November 28th, 2022
  */
-enum class Flavour(val colour: Int, val chatFormatting: ChatFormatting): StringRepresentable {
-    SPICY(0x00FF00, ChatFormatting.RED),
-    DRY(0xFF0000, ChatFormatting.DARK_AQUA),
-    SWEET(0x0000FF, ChatFormatting.LIGHT_PURPLE),
-    BITTER(0xFFFF00, ChatFormatting.GREEN),
-    SOUR(0xFF00FF, ChatFormatting.YELLOW),
-    MILD(0xFF00FF, ChatFormatting.DARK_PURPLE);
+enum class Flavour(val colour: Int): StringRepresentable {
+    SPICY(0xFA795E),
+    DRY(0x65AFF3),
+    SWEET(0xFF82CF),
+    BITTER(0x77C96A),
+    SOUR(0xF3D465),
+    MILD(0x9D99BF);
 
     override fun getSerializedName() = name
     companion object {
         val CODEC = StringRepresentable.fromEnum<Flavour> { Flavour.entries.toTypedArray() }
     }
-}
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/cooking/PokePuffUtils.kt

@@ -9,13 +9,11 @@
 package com.cobblemon.mod.common.api.cooking
 
 import com.cobblemon.mod.common.CobblemonItemComponents
-import com.cobblemon.mod.common.item.PokePuffItem
 import com.cobblemon.mod.common.item.PokePuffItem.Companion.DISLIKED_FLAVOR_MULTIPLIER
 import com.cobblemon.mod.common.item.PokePuffItem.Companion.LIKED_FLAVOR_MULTIPLIER
 import com.cobblemon.mod.common.pokemon.Nature
-import net.minecraft.resources.ResourceLocation
-import net.minecraft.world.item.ItemStack
 import net.minecraft.core.registries.BuiltInRegistries
+import net.minecraft.world.item.ItemStack
 
 object PokePuffUtils {
 
@@ -25,11 +23,12 @@ object PokePuffUtils {
 
         val (baseFriendship) = calculateBaseFriendship(stack)
 
-        return when {
-            dominantFlavour == nature.favouriteFlavour -> (baseFriendship / LIKED_FLAVOR_MULTIPLIER).toInt()
-            dominantFlavour == Flavour.MILD && isNeutralNature -> (baseFriendship / 2.0).coerceAtLeast(1.0).toInt()
-            else -> (-baseFriendship / DISLIKED_FLAVOR_MULTIPLIER).toInt()
-        }
+        val multiplier = if (
+            dominantFlavour == nature.favouriteFlavour ||
+            (dominantFlavour == Flavour.MILD && isNeutralNature)
+        ) LIKED_FLAVOR_MULTIPLIER else -DISLIKED_FLAVOR_MULTIPLIER
+
+        return (baseFriendship / multiplier).toInt()
     }
 
     fun calculateBaseFriendship(stack: ItemStack): Pair<Double, Double> {
@@ -77,8 +76,8 @@ object PokePuffUtils {
             Flavour.SPICY -> "attack"
             Flavour.DRY -> "special_attack"
             Flavour.SWEET -> "speed"
-            Flavour.BITTER -> "special_defense"
-            Flavour.SOUR -> "defense"
+            Flavour.BITTER -> "special_defence"
+            Flavour.SOUR -> "defence"
             Flavour.MILD -> "neutral"
         }
     }

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

@@ -18,14 +18,13 @@ import net.minecraft.resources.ResourceLocation
  * @since August 5th, 2022
  */
 interface DataProvider {
-
     /**
      * Registers a [DataRegistry] to listen for updates.
      * The updates will automatically happen on the correct sides based on [DataRegistry.type].
      *
      * @param registry The [DataRegistry] being registered.
      */
-    fun <T : DataRegistry> register(registry: T): T
+    fun <T : DataRegistry> register(registry: T, reloadable: Boolean): T
 
     /**
      * Attempts to find a [DataRegistry] with the given [ResourceLocation].

common/src/main/kotlin/com/cobblemon/mod/common/api/events/CobblemonEvents.kt

@@ -152,6 +152,9 @@ object CobblemonEvents {
     @JvmField
     val RIDE_EVENT_PRE = CancelableObservable<RidePokemonEvent.Pre>()
 
+    @JvmField
+    val RIDE_EVENT_APPLY_STAMINA = EventObservable<RidePokemonEvent.ApplyStamina>()
+
     @JvmField
     val RIDE_EVENT_POST = EventObservable<RidePokemonEvent.Post>()
 

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

@@ -8,9 +8,7 @@
 
 package com.cobblemon.mod.common.api.events.pokemon
 
-import com.cobblemon.mod.common.util.server
 import com.bedrockk.molang.runtime.value.DoubleValue
-import com.bedrockk.molang.runtime.value.MoValue
 import com.cobblemon.mod.common.api.events.Cancelable
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
@@ -49,4 +47,36 @@ interface RidePokemonEvent {
             "pokemon" to pokemon.struct
         )
     }
+
+    /**
+     * Event published when stamina is being applied. At this point you can modify the stamina that will get used on the
+     * mount or you can make the stamina infinite. Handy hey.
+     */
+    class ApplyStamina(
+        override val player: ServerPlayer,
+        override val pokemon: PokemonEntity,
+        var rideStamina: Float
+    ) : RidePokemonEvent {
+        val context = mutableMapOf(
+            "player" to player.asMoLangValue(),
+            "pokemon" to pokemon.struct,
+            "ride_stamina" to DoubleValue(rideStamina)
+        )
+        val functions = moLangFunctionMap(
+            "set_ride_stamina" to { params ->
+                rideStamina = params.getDouble(0).toFloat().coerceIn(0F, 1F)
+                DoubleValue.ONE
+            },
+            "set_infinite_stamina" to { _ ->
+                rideStamina = -1F
+                DoubleValue.ONE
+            },
+        )
+
+        fun setInfiniteStamina() {
+            rideStamina = -1F
+        }
+
+        fun isInfiniteStamina() = rideStamina == -1F
+    }
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/item/HeldItems.kt

@@ -0,0 +1,57 @@
+/*
+ * 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.item
+
+import com.cobblemon.mod.common.api.data.DataRegistry
+import com.cobblemon.mod.common.api.reactive.SimpleObservable
+import com.cobblemon.mod.common.battles.runner.ShowdownService
+import com.cobblemon.mod.common.pokemon.helditem.CobblemonHeldItemManager
+import com.cobblemon.mod.common.util.cobblemonResource
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.server.packs.PackType
+import net.minecraft.server.packs.resources.ResourceManager
+import java.io.File
+
+object HeldItems : DataRegistry {
+
+    override val id = cobblemonResource("held_items")
+    override val type = PackType.SERVER_DATA
+    override val observable = SimpleObservable<HeldItems>()
+    override fun sync(player: ServerPlayer) {}
+
+    // val heldItems = PrioritizedList<BagItemLike>()
+    internal val heldItemsScripts = mutableMapOf<String, String>() // showdown item ID to JavaScript
+    val showdownItems = hashSetOf<String>()
+
+    override fun reload(manager: ResourceManager) {
+        heldItemsScripts.clear()
+        ShowdownService.service.resetRegistryData("heldItem")
+        manager.listResources("held_items") { it.path.endsWith(".js") }.forEach { (identifier, resource) ->
+            resource.open().use { stream ->
+                stream.bufferedReader().use { reader ->
+                    val resolvedIdentifier = ResourceLocation.fromNamespaceAndPath(identifier.namespace, File(identifier.path).nameWithoutExtension)
+                    val js = reader.readText()
+                    heldItemsScripts[resolvedIdentifier.path] = js
+                }
+            }
+        }
+        ShowdownService.service.sendRegistryData(heldItemsScripts, "heldItem")
+
+        val itemsJson = ShowdownService.service.getRegistryData("heldItem")
+        for (i in 0 until itemsJson.size()) {
+            val jsItem = itemsJson[i].asJsonObject
+            showdownItems += jsItem.get("id").asString
+        }
+
+        CobblemonHeldItemManager.load()
+
+        this.observable.emit(this)
+    }
+}

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

@@ -12,7 +12,6 @@ import com.bedrockk.molang.runtime.MoLangEnvironment
 import com.bedrockk.molang.runtime.MoLangRuntime
 import com.bedrockk.molang.runtime.MoParams
 import com.bedrockk.molang.runtime.struct.ArrayStruct
-import com.bedrockk.molang.runtime.struct.MoStruct
 import com.bedrockk.molang.runtime.struct.QueryStruct
 import com.bedrockk.molang.runtime.struct.VariableStruct
 import com.bedrockk.molang.runtime.value.DoubleValue
@@ -40,7 +39,6 @@ import com.cobblemon.mod.common.api.moves.animations.ActionEffectContext
 import com.cobblemon.mod.common.api.moves.animations.ActionEffects
 import com.cobblemon.mod.common.api.moves.animations.NPCProvider
 import com.cobblemon.mod.common.api.moves.animations.TargetsProvider
-import com.cobblemon.mod.common.api.npc.NPCClass
 import com.cobblemon.mod.common.api.npc.NPCClasses
 import com.cobblemon.mod.common.api.npc.configuration.interaction.DialogueNPCInteractionConfiguration
 import com.cobblemon.mod.common.api.npc.configuration.interaction.ScriptNPCInteractionConfiguration
@@ -57,7 +55,6 @@ import com.cobblemon.mod.common.api.pokemon.evolution.Evolution
 import com.cobblemon.mod.common.api.pokemon.experience.SidemodExperienceSource
 import com.cobblemon.mod.common.api.pokemon.moves.LearnsetQuery
 import com.cobblemon.mod.common.api.pokemon.stats.Stats
-import com.cobblemon.mod.common.api.riding.Rideable
 import com.cobblemon.mod.common.api.riding.stats.RidingStat
 import com.cobblemon.mod.common.api.scheduling.ClientTaskTracker
 import com.cobblemon.mod.common.api.scheduling.Schedulable
@@ -137,7 +134,6 @@ import net.minecraft.world.entity.LightningBolt
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.Mob
 import net.minecraft.world.entity.PathfinderMob
-import net.minecraft.world.entity.PlayerRideable
 import net.minecraft.world.entity.TamableAnimal
 import net.minecraft.world.entity.ai.behavior.BlockPosTracker
 import net.minecraft.world.entity.ai.memory.MemoryModuleType
@@ -145,7 +141,6 @@ import net.minecraft.world.entity.ai.memory.MemoryStatus
 import net.minecraft.world.entity.ai.memory.WalkTarget
 import net.minecraft.world.entity.animal.Animal
 import net.minecraft.world.entity.item.ItemEntity
-import net.minecraft.world.entity.monster.Enemy
 import net.minecraft.world.entity.monster.Monster
 import net.minecraft.world.entity.player.Player
 import net.minecraft.world.item.ItemStack
@@ -160,9 +155,6 @@ import net.minecraft.world.level.levelgen.Heightmap
 import net.minecraft.world.level.pathfinder.PathType
 import net.minecraft.world.phys.AABB
 import net.minecraft.world.phys.Vec3
-import kotlin.text.get
-import kotlin.text.toInt
-import kotlin.toString
 
 /**
  * Holds a bunch of useful MoLang trickery that can be used or extended in API
@@ -1185,16 +1177,28 @@ object MoLangFunctions {
                 return@put DoubleValue.ONE
             }
             map.put("has_memory_value") { params ->
-                val memoryTypes = params.params.map {
-                    it.asString().asIdentifierDefaultingNamespace()
-                }.map(BuiltInRegistries.MEMORY_MODULE_TYPE::get)
-                return@put DoubleValue(memoryTypes.all { entity.brain.checkMemory(it, MemoryStatus.VALUE_PRESENT) })
+                for (param in params.params) {
+                    if (!entity.hasMemoryFromString(param.asString())) {
+                        return@put DoubleValue.ZERO
+                    }
+                }
+                return@put DoubleValue.ONE
             }
             map.put("lacks_memory_value") { params ->
-                val memoryTypes = params.params.map {
-                    it.asString().asIdentifierDefaultingNamespace()
-                }.map(BuiltInRegistries.MEMORY_MODULE_TYPE::get)
-                return@put DoubleValue(memoryTypes.none { entity.brain.checkMemory(it, MemoryStatus.VALUE_PRESENT) })
+                for (param in params.params) {
+                    if (entity.hasMemoryFromString(param.asString())) {
+                        return@put DoubleValue.ZERO
+                    }
+                }
+                return@put DoubleValue.ONE
+            }
+            map.put("is_doing_activity") { params ->
+                for (param in params.params) {
+                    if (entity.isDoingActivityFromString(param.asString())) {
+                        return@put DoubleValue.ONE
+                    }
+                }
+                return@put DoubleValue.ZERO
             }
             map.put("can_see") { params ->
                 val target = params.get<MoValue>(0)
@@ -1236,7 +1240,7 @@ object MoLangFunctions {
                     }
                 }
                 map.put("has_walk_target") { _ ->
-                    DoubleValue(entity.brain.getMemory(MemoryModuleType.WALK_TARGET).isPresent || entity.isPathFinding)
+                    DoubleValue(entity.brain.getMemorySafely(MemoryModuleType.WALK_TARGET).isPresent || entity.isPathFinding)
                 }
             }
             map
@@ -1252,15 +1256,6 @@ object MoLangFunctions {
             map.put("in_battle") { DoubleValue(npc.isInBattle()) }
             map.put("battles") { ArrayStruct(npc.battleIds.mapNotNull { BattleRegistry.getBattle(it)?.struct }.mapIndexed { index, value -> "$index" to value }.toMap()) }
             map.put("stop_battles") { _ -> npc.battleIds.forEach { BattleRegistry.getBattle(it)?.stop() } }
-            map.put("is_doing_activity") { params ->
-                val identifiers = params.params.map { it.asString().asIdentifierDefaultingNamespace(namespace = "minecraft") }
-                val activities = identifiers.mapNotNull { identifier -> BuiltInRegistries.ACTIVITY.get(identifier) }
-                if (activities.isNotEmpty()) {
-                    return@put DoubleValue(activities.any { activity -> npc.brain.isActive(activity) })
-                } else {
-                    return@put DoubleValue.ZERO
-                }
-            }
             map.put("run_script_on_client") { params ->
                 val world = npc.level()
                 if (world is ServerLevel) {
@@ -1905,6 +1900,9 @@ object MoLangFunctions {
             map.put("is_holding_item") { DoubleValue(!pokemonEntity.entityData.get(PokemonEntity.SHOWN_HELD_ITEM).let {
                 it.isEmpty || it.`is`(CobblemonItemTags.WEARABLE_HAT_ITEMS) || it.`is`(CobblemonItemTags.WEARABLE_FACE_ITEMS)
             }) }
+            map.put("riding_style") {
+                StringValue(pokemonEntity.ifRidingAvailableSupply("") { behaviour, settings, state -> behaviour.getRidingStyle(settings, state).name })
+            }
             map.put("is_wearing_hat") { DoubleValue(pokemonEntity.entityData.get(PokemonEntity.SHOWN_HELD_ITEM).`is`(CobblemonItemTags.WEARABLE_HAT_ITEMS)) }
             map.put("is_wearing_face") { DoubleValue(pokemonEntity.entityData.get(PokemonEntity.SHOWN_HELD_ITEM).`is`(CobblemonItemTags.WEARABLE_FACE_ITEMS)) }
             map.put("is_pastured") {

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

@@ -15,6 +15,7 @@ import net.minecraft.world.entity.LivingEntity
 import org.joml.Matrix3f
 import org.joml.Quaternionf
 import org.joml.Vector3f
+import kotlin.math.abs
 import kotlin.math.asin
 import kotlin.math.sign
 
@@ -113,7 +114,7 @@ open class OrientationController(val entity: LivingEntity) {
 
     fun applyGlobalPitch(deltaPitchDegrees: Float) = updateOrientation { original ->
         val currQuat = Quaternionf().setFromUnnormalized(original)
-        val horzLeftVector = Vector3f(0.0f, this.upVector.y.sign, 0.0f).cross(this.forwardVector)
+        val horzLeftVector = Vector3f(0.0f, -abs(this.upVector.y.sign), 0.0f).cross(this.forwardVector)
         // Avoid NaN issue when normalizing and the forwardVector and upVector are equal
         val pitchAxis = if (horzLeftVector.lengthSquared() < 0.01) this.leftVector else horzLeftVector
 

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

@@ -131,6 +131,7 @@ open class PokemonProperties {
             props.species = parseSpeciesIdentifier(keyPairs)
             props.form = parseForm(keyPairs)
             props.friendship = parseIntProperty(keyPairs, listOf("friendship"))?.coerceIn(0, Cobblemon.config.maxPokemonFriendship)
+            props.fullness = parseIntProperty(keyPairs, listOf("fullness"))
             props.pokeball = parseIdentifierOfRegistry(keyPairs, listOf("pokeball")) { identifier -> PokeBalls.getPokeBall(identifier)?.name?.toString() }
             props.nature = parseIdentifierOfRegistry(keyPairs, listOf("nature")) { identifier -> Natures.getNature(identifier)?.name?.toString() }
             props.ability = parseStringOfRegistry(keyPairs, listOf("ability")) { Abilities.get(it)?.name }
@@ -326,6 +327,7 @@ open class PokemonProperties {
     var gender: Gender? = null
     var level: Int? = null
     var friendship: Int? = null
+    var fullness: Int? = null
     var pokeball: String? = null
     var nature: String? = null
     var ability: String? = null
@@ -397,6 +399,7 @@ open class PokemonProperties {
                 pokemon.setFriendship(pokemon.form.baseFriendship)
             }
         }
+        fullness?.let { pokemon.currentFullness = it }
         pokeball?.let { PokeBalls.getPokeBall(it.asIdentifierDefaultingNamespace())?.let { pokeball -> pokemon.caughtBall = pokeball } }
         nature?.let  { Natures.getNature(it.asIdentifierDefaultingNamespace())?.let { nature -> pokemon.nature = nature } }
         customProperties.forEach { it.apply(pokemon) }
@@ -504,6 +507,7 @@ open class PokemonProperties {
         nickname?.takeIf { it.string != pokemon.nickname?.string }?.let { return false }
         form?.takeIf { !it.equals(pokemon.form.name, true) }?.let { return false }
         friendship?.takeIf { it != pokemon.friendship }?.let { return false }
+        fullness?.takeIf { it != pokemon.currentFullness }?.let { return false }
         pokeball?.takeIf { it != pokemon.caughtBall.name.toString() }?.let { return false }
         nature?.takeIf { it != pokemon.nature.name.toString() }?.let { return false }
         ability?.takeIf { it != pokemon.ability.name }?.let { return false }
@@ -588,6 +592,7 @@ open class PokemonProperties {
         originalTrainer?.takeIf { it != properties.originalTrainer }?.let{ return false }
         originalTrainerType?.takeIf { it != properties.originalTrainerType }?.let{ return false }
         moves?.takeIf { it.any { move -> properties.moves?.none { it == move } == true } }?.let { return false }
+        fullness?.takeIf { it != properties.fullness }?.let { return false }
         return true
     }
 
@@ -636,6 +641,7 @@ open class PokemonProperties {
         nickname?.let { nbt.putString(DataKeys.POKEMON_NICKNAME, Component.Serializer.toJson(it, registryLookup)) }
         form?.let { nbt.putString(DataKeys.POKEMON_FORM_ID, it) }
         friendship?.let { nbt.putInt(DataKeys.POKEMON_FRIENDSHIP, it) }
+        fullness?.let { nbt.putInt(DataKeys.POKEMON_FULLNESS, it) }
         pokeball?.let { nbt.putString(DataKeys.POKEMON_CAUGHT_BALL, it) }
         nature?.let { nbt.putString(DataKeys.POKEMON_NATURE, it) }
         ability?.let { nbt.putString(DataKeys.POKEMON_ABILITY, it) }
@@ -667,6 +673,7 @@ open class PokemonProperties {
         nickname = if (tag.contains(DataKeys.POKEMON_NICKNAME)) Component.Serializer.fromJson(tag.getString(DataKeys.POKEMON_NICKNAME), registryLookup) else null
         form = if (tag.contains(DataKeys.POKEMON_FORM_ID)) tag.getString(DataKeys.POKEMON_FORM_ID) else null
         friendship = if (tag.contains(DataKeys.POKEMON_FRIENDSHIP)) tag.getInt(DataKeys.POKEMON_FRIENDSHIP) else null
+        fullness = if (tag.contains(DataKeys.POKEMON_FULLNESS)) tag.getInt(DataKeys.POKEMON_FULLNESS) else null
         pokeball = if (tag.contains(DataKeys.POKEMON_CAUGHT_BALL)) tag.getString(DataKeys.POKEMON_CAUGHT_BALL) else null
         nature = if (tag.contains(DataKeys.POKEMON_NATURE)) tag.getString(DataKeys.POKEMON_NATURE) else null
         ability = if (tag.contains(DataKeys.POKEMON_ABILITY)) tag.getString(DataKeys.POKEMON_ABILITY) else null
@@ -700,6 +707,7 @@ open class PokemonProperties {
         //nickname?.let { json.addProperty(DataKeys.POKEMON_NICKNAME, Text.Serialization.toJsonString(it)) }
         form?.let { json.addProperty(DataKeys.POKEMON_FORM_ID, it) }
         friendship?.let { json.addProperty(DataKeys.POKEMON_FRIENDSHIP, it) }
+        fullness?.let {json.addProperty(DataKeys.POKEMON_FULLNESS, it)}
         pokeball?.let { json.addProperty(DataKeys.POKEMON_CAUGHT_BALL, it) }
         nature?.let { json.addProperty(DataKeys.POKEMON_NATURE, it) }
         ability?.let { json.addProperty(DataKeys.POKEMON_ABILITY, it) }
@@ -732,6 +740,7 @@ open class PokemonProperties {
         //nickname = json.get(DataKeys.POKEMON_NICKNAME)?.asString?.let { Text.Serialization.fromJson(it) }
         form = json.get(DataKeys.POKEMON_FORM_ID)?.asString
         friendship = json.get(DataKeys.POKEMON_FRIENDSHIP)?.asInt
+        fullness = json.get(DataKeys.POKEMON_FULLNESS)?.asInt
         pokeball = json.get(DataKeys.POKEMON_CAUGHT_BALL)?.asString
         nature = json.get(DataKeys.POKEMON_NATURE)?.asString
         ability = json.get(DataKeys.POKEMON_ABILITY)?.asString
@@ -763,6 +772,7 @@ open class PokemonProperties {
         shiny?.let { pieces.add("shiny=$it") }
         gender?.let { pieces.add("gender=$it")}
         friendship?.let { pieces.add("friendship=$it") }
+        fullness?.let {pieces.add("fullness=$it")}
         pokeball?.let { pieces.add("pokeball=$it") }
         nature?.let { pieces.add("nature=$it") }
         ability?.let { pieces.add("ability=$it") }
@@ -796,8 +806,8 @@ open class PokemonProperties {
         return PokemonProperties().loadFromJSON(this.saveToJSON())
     }
 
-    // If the config value is at least 1, then do 1/x and use that as the property chance
-    private fun Float.checkRate(): Boolean = if (this >= 1) (Random.Default.nextFloat() < 1 / this) else Random.Default.nextFloat() < this
+    // If the config value is at least 0, then do 1/x and use that as the property chance
+    private fun Float.checkRate(): Boolean = this > 0 && (Random.nextFloat() < 1 / this)
 
     /**
      * Attempts to find an ability by ID and resolve if it should be forced or if it's legal for the given form.

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

@@ -43,7 +43,6 @@ import com.cobblemon.mod.common.api.riding.stats.RidingStatDefinition
 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.battles.runner.ShowdownService
 import com.cobblemon.mod.common.net.messages.client.data.SpeciesRegistrySyncPacket
 import com.cobblemon.mod.common.pokemon.FormData
 import com.cobblemon.mod.common.pokemon.Species
@@ -54,10 +53,8 @@ import com.cobblemon.mod.common.pokemon.ai.ObtainableItemConditionAdapter
 import com.cobblemon.mod.common.pokemon.evolution.adapters.CobblemonEvolutionAdapter
 import com.cobblemon.mod.common.pokemon.evolution.adapters.CobblemonPreEvolutionAdapter
 import com.cobblemon.mod.common.pokemon.evolution.adapters.LegacyItemConditionWrapperAdapter
-import com.cobblemon.mod.common.pokemon.helditem.CobblemonHeldItemManager
 import com.cobblemon.mod.common.util.adapters.*
 import com.cobblemon.mod.common.util.cobblemonResource
-import com.cobblemon.mod.common.util.ifClient
 import com.google.common.collect.HashBasedTable
 import com.google.gson.Gson
 import com.google.gson.GsonBuilder
@@ -65,13 +62,11 @@ import com.google.gson.reflect.TypeToken
 import com.mojang.datafixers.util.Either
 import net.minecraft.advancements.critereon.ItemPredicate
 import net.minecraft.core.registries.BuiltInRegistries
-import net.minecraft.core.registries.Registries
 import net.minecraft.nbt.CompoundTag
 import net.minecraft.network.chat.Component
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.server.packs.PackType
-import net.minecraft.tags.TagKey
 import net.minecraft.world.effect.MobEffect
 import net.minecraft.world.entity.EntityDimensions
 import net.minecraft.world.entity.ai.memory.MemoryModuleType
@@ -151,24 +146,17 @@ object PokemonSpecies : JsonDataRegistry<Species> {
 
     val species: Collection<Species>
         get() = this.speciesByIdentifier.values
-    val implemented = mutableListOf<Species>()
+    val implemented: List<Species>
+        get() = this.species.filter { it.implemented }
 
     init {
         SpeciesAdditions.observable.subscribe {
-            implemented.clear()
             this.species.forEach(Species::initialize)
-            this.species.forEach {
-                if (it.implemented) {
-                    this.implemented.add(it)
-                }
-            }
             this.species.forEach(Species::resolveEvolutionMoves)
             Cobblemon.showdownThread.queue {
                 it.resetRegistryData("species")
                 it.sendRegistryData(allShowdownSpecies(), "species")
                 it.indicateSpeciesInitialized()
-                // Reload this with the mod
-                CobblemonHeldItemManager.load()
                 Cobblemon.LOGGER.info("Loaded {} Pokémon species", this.speciesByIdentifier.size)
                 this.observable.emit(this)
             }
@@ -233,7 +221,6 @@ object PokemonSpecies : JsonDataRegistry<Species> {
 
     override fun reload(data: Map<ResourceLocation, Species>) {
         this.speciesByIdentifier.clear()
-        this.implemented.clear()
         this.speciesByDex.clear()
         data.forEach { (identifier, species) ->
             species.resourceIdentifier = identifier
@@ -241,11 +228,6 @@ object PokemonSpecies : JsonDataRegistry<Species> {
                 this.speciesByDex.remove(old.resourceIdentifier.namespace, old.nationalPokedexNumber)
             }
             this.speciesByDex.put(species.resourceIdentifier.namespace, species.nationalPokedexNumber, species)
-            ifClient {
-                if (species.implemented) {
-                    this.implemented.add(species)
-                }
-            }
         }
     }
 

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

@@ -9,8 +9,9 @@
 package com.cobblemon.mod.common.api.pokemon.aspect
 
 import com.cobblemon.mod.common.CobblemonBlocks
+import com.cobblemon.mod.common.api.ai.config.task.PollinateFlowerTaskConfig
 import com.cobblemon.mod.common.api.spawning.influence.SaccharineLogSlatheredInfluence
-import com.cobblemon.mod.common.api.spawning.prospecting.LurePokeSnackDetector
+import com.cobblemon.mod.common.block.entity.PokeSnackBlockEntity
 import com.cobblemon.mod.common.client.entity.PokemonClientDelegate
 import net.minecraft.core.particles.BlockParticleOption
 import net.minecraft.core.particles.ParticleOptions
@@ -22,11 +23,12 @@ import net.minecraft.resources.ResourceLocation
  */
 val aspectParticleMap: Map<String, ParticleData> = mapOf(
     SaccharineLogSlatheredInfluence.HONEY_DRENCHED_ASPECT to ParticleData.MinecraftParticle(ParticleTypes.FALLING_HONEY, 0.075, 1),
-    LurePokeSnackDetector.POKE_SNACK_CRUMBED_ASPECT to ParticleData.MinecraftParticle(
+    PokeSnackBlockEntity.POKE_SNACK_CRUMBED_ASPECT to ParticleData.MinecraftParticle(
         BlockParticleOption(
             ParticleTypes.BLOCK,
             CobblemonBlocks.POKE_SNACK.defaultBlockState()
         ), 0.05, 3),
+    PollinateFlowerTaskConfig.HAS_NECTAR_ASPECT to ParticleData.MinecraftParticle(ParticleTypes.FALLING_NECTAR, 0.075, 1)
 )
 
 sealed class ParticleData {

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

@@ -8,9 +8,6 @@
 
 package com.cobblemon.mod.common.api.riding
 
-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 net.minecraft.world.entity.PlayerRideableJumping
 
 /**

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

@@ -9,10 +9,7 @@
 package com.cobblemon.mod.common.api.riding
 
 import com.bedrockk.molang.Expression
-import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviourSettings
-import com.cobblemon.mod.common.api.riding.stats.RidingStat
-import com.cobblemon.mod.common.api.riding.stats.RidingStatDefinition
 import com.cobblemon.mod.common.util.*
 import com.cobblemon.mod.common.util.adapters.RidingBehaviourSettingsAdapter
 import net.minecraft.network.RegistryFriendlyByteBuf
@@ -32,10 +29,10 @@ class RidingProperties(
                     { buffer.readEnumConstant(RidingStyle::class.java) },
                     {
                         val key = buffer.readResourceLocation()
-                        val settings = RidingBehaviourSettingsAdapter.types[key]?.getConstructor()?.newInstance()
+                        val behaviour = RidingBehaviourSettingsAdapter.types[key]?.getConstructor()?.newInstance()
                             ?: error("Unknown controller key: $key")
-                        settings.decode(buffer)
-                        settings
+                        behaviour.decode(buffer)
+                        behaviour
                     }
                 )
             }
@@ -51,7 +48,10 @@ class RidingProperties(
             buffer.writeMap(
                 v,
                 { _, style -> buffer.writeEnumConstant(style) },
-                { _, behaviour -> behaviour.encode(buffer) }
+                { _, behaviour ->
+                    buffer.writeResourceLocation(behaviour.key)
+                    behaviour.encode(buffer)
+                }
             )
         }
     }

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

@@ -25,7 +25,8 @@ data class Seat(
     val locator: String?,
     val offset: Vec3?,
     val poseOffsets: MutableList<SeatPoseOffset>?,
-    val poseAnimations: MutableList<SeatPoseAnimations>?
+    val poseAnimations: MutableList<SeatPoseAnimations>?,
+    val handsBusy: Boolean = false,
 ) : Encodable {
     fun getOffset(poseType: PoseType) : Vec3 {
         return poseOffsets?.firstOrNull { poseType in it.poseTypes }?.offset ?: Vec3.ZERO
@@ -40,6 +41,7 @@ data class Seat(
         buffer.writeNullable(poseAnimations) { _, v ->
             buffer.writeCollection(v) { _, animations -> animations.encode(buffer) }
         }
+        buffer.writeBoolean(handsBusy)
     }
 
     companion object {
@@ -48,7 +50,8 @@ data class Seat(
                 buffer.readNullable { buffer.readString() },
                 buffer.readNullable { buffer.readVec3() },
                 buffer.readNullable { buffer.readList { SeatPoseOffset.decode(buffer) } },
-                buffer.readNullable { buffer.readList { SeatPoseAnimations.decode(buffer) } }
+                buffer.readNullable { buffer.readList { SeatPoseAnimations.decode(buffer) } },
+                buffer.readBoolean()
             )
         }
     }

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

@@ -10,10 +10,8 @@ package com.cobblemon.mod.common.api.riding.behaviour
 
 import com.cobblemon.mod.common.api.net.Decodable
 import com.cobblemon.mod.common.api.net.Encodable
-import com.cobblemon.mod.common.api.riding.RidingStyle
 import com.cobblemon.mod.common.api.riding.stats.RidingStat
 import net.minecraft.resources.ResourceLocation
-import net.minecraft.world.phys.Vec3
 
 /**
  * Represents static settings of a riding behaviour.
@@ -21,17 +19,17 @@ import net.minecraft.world.phys.Vec3
  * Typically this will be initialized for each pokemon form during deserialization
  * to determine how they should ride.
  *
+ * These also exist in a datapacked folder, ride_settings, which are used for the fallback
+ * values if non-stat settings are omitted in the pokemon form JSON.
+ *
  * @author landonjw
  */
 interface RidingBehaviourSettings: Encodable, Decodable {
     val key: ResourceLocation
     val stats: MutableMap<RidingStat, IntRange>
 
-    fun calculate(stat: RidingStat, boosts: Int): Float {
+    fun calculate(stat: RidingStat, boostAmount: Float): Float {
         val range = stats[stat] ?: return 0F
-        val boostQuotient = boosts / 255F
-        return range.first + (range.last - range.first) * boostQuotient
+        return (range.first + boostAmount).coerceAtMost(range.endInclusive.toFloat())
     }
-
-    fun hasStat(stat: RidingStat) = stats.containsKey(stat)
 }

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

@@ -18,7 +18,7 @@ import net.minecraft.world.phys.Vec3
  * This is intended to contain mutable state that is passed between the client and server
  * or temporary state that is used during the riding process.
  *
- * This will be destroyed when the a user dismounts the Pokemon.
+ * This will be destroyed when the main rider dismounts the Pokemon.
  *
  * @author landonjw
  */

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

@@ -8,13 +8,18 @@
 
 package com.cobblemon.mod.common.api.riding.behaviour
 
+import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.DoubleJump
 import com.cobblemon.mod.common.api.riding.RidingStyle
+import com.cobblemon.mod.common.client.MountedCameraTypeHandler
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.tags.FluidTags
 import net.minecraft.world.entity.LivingEntity
 import kotlin.collections.get
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.world.entity.player.Player
+import kotlin.collections.get
 
 /**
  * Small wrapper around a RidingBehaviour to provide sane defaults in the event that the behaviour is not active.
@@ -49,6 +54,15 @@ class RidingController(
             if (newTransition != null && behaviourSettings != null) {
                 val newState = RidingBehaviours.get(behaviourSettings.key).createDefaultState(behaviourSettings)
                 context?.let { newState.stamina.set(it.state.stamina.get(), forced = true) }
+                context?.let { newState.rideVelocity.set(it.state.rideVelocity.get(), forced = true) }
+                val previousKey = context?.behaviour
+                val newKey = behaviourSettings.key
+                for (passenger in entity.passengers) {
+                    if (passenger is Player && passenger !is ServerPlayer) {
+                        MountedCameraTypeHandler.handleTransition(previousKey ?: continue, newKey)
+                    }
+                }
+
                 context = ActiveRidingContext(behaviourSettings.key, behaviourSettings, newState, newTransition)
                 lastTransitionAge = entity.ticksLived
             } else {
@@ -96,12 +110,22 @@ class RidingController(
     }
 
     private fun canTransitionToLand(): Boolean {
-        if (entity.isInLiquid || entity.isUnderWater) return false
+        val hasLandController = entity.pokemon.riding.behaviours?.get(RidingStyle.LAND) != null
+        if (hasLandController && (entity.isInLiquid || entity.isUnderWater)) return false
+        if (!hasLandController && (entity.isEyeInFluid(FluidTags.WATER) || entity.isEyeInFluid(FluidTags.LAVA))) return false
         return entity.onGround()
     }
 
     private fun canTransitionToLiquid(): Boolean {
-        return entity.isInLiquid || entity.isUnderWater
+        // If it has a liquid controller to transition to and it isn't currently an air controller then transition on
+        // touching water. If not then check for eyes in water. This allows fliers to fly closely above water and
+        // for walkers that don't have a liquid controller to be able to walk in not deep water
+        return if (entity.pokemon.riding.behaviours?.get(RidingStyle.LIQUID) != null && context?.style != RidingStyle.AIR) {
+            entity.isInLiquid || entity.isUnderWater
+        } else {
+            entity.isEyeInFluid(FluidTags.WATER) || entity.isEyeInFluid(FluidTags.LAVA)
+        }
+
     }
 
     private fun canTransitionToAir(driver: LivingEntity?): Boolean {

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

@@ -11,6 +11,7 @@ package com.cobblemon.mod.common.api.riding.behaviour.types.air
 import com.bedrockk.molang.Expression
 import com.bedrockk.molang.runtime.MoLangMath.lerp
 import com.cobblemon.mod.common.Cobblemon
+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.riding.RidingStyle
@@ -23,15 +24,16 @@ 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.client.Minecraft
 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.player.Player
 import net.minecraft.world.phys.Vec2
 import net.minecraft.world.phys.Vec3
+import net.minecraft.world.phys.shapes.Shapes
 import kotlin.math.*
 
 class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
@@ -48,8 +50,11 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
     val poseProvider = PoseProvider<BirdSettings, BirdState>(PoseType.HOVER)
         .with(PoseOption(PoseType.FLY) { _, state, _ -> state.rideVelocity.get().z > 0.2 })
 
+    val globalBird: BirdSettings
+        get() = CobblemonRideSettings.bird
+
     override fun isActive(settings: BirdSettings, state: BirdState, vehicle: PokemonEntity): Boolean {
-        return true
+        return !(vehicle.isInWater || vehicle.isUnderWater)
     }
 
     override fun pose(settings: BirdSettings, state: BirdState, vehicle: PokemonEntity): PoseType {
@@ -74,6 +79,24 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
     ) {
         if(vehicle.level().isClientSide) {
             tickStamina(settings, state, vehicle, driver)
+            checkUpsideDown(state, vehicle, driver)
+        }
+    }
+
+    private fun checkUpsideDown(
+        state: BirdState,
+        vehicle: PokemonEntity,
+        driver: Player,
+    ) {
+        val controller = (driver 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)
         }
     }
 
@@ -84,15 +107,24 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
         driver: Player
     ) {
         val stam = state.stamina.get()
+        val controller = (driver as OrientationControllable).orientationController
 
         // Grab the boost time in seconds and convert to ticks. Then calculate the drain rate as inversely
         // proportional to the number of ticks of boost thus making a full boost take x ticks
         // in short: "Stamina drains slower at higher values and also replenishes slower"
-        val totalStam = vehicle.runtime.resolveDouble(settings.staminaExpr) * 20.0f
-        val stamDrainRate = (1.0f / totalStam).toFloat()
+        val totalStam = vehicle.runtime.resolveDouble(settings.staminaExpr ?: globalBird.staminaExpr!!) * 20.0f
+        val horzMod = vehicle.runtime.resolveDouble(settings.stamDrainHorzMod ?: globalBird.stamDrainHorzMod!!)
+        val glideMod = vehicle.runtime.resolveFloat(settings.stamDrainPercRateGlide ?: globalBird.stamDrainPercRateGlide!!)
+        val stamDrainPerRateDive = vehicle.runtime.resolveDouble(settings.stamDrainPerRateDive ?: globalBird.stamDrainPerRateDive!!).coerceIn(0.0, 1.0) // Ensure its between 1 and 0 or things get weird
 
-        val newStam = if (driver.zza > 0.0) max(0.0f,stam - stamDrainRate)
-            else min(1.0f,stam + stamDrainRate)
+        val stamDrainHorz = if(vehicle.deltaMovement.horizontalDistance() < 1e-6) horzMod else max(1.0 + ((horzMod - 1.0) * atan( vehicle.deltaMovement.y / vehicle.deltaMovement.horizontalDistance())), 1.0)
+        val diveAmount = sin(controller.pitch.toRadians()).coerceIn(0.0f, 1.0f)// from 0.0 -> 1.0 how steep is the current dive angle
+        val diveMod = ((1.0 - diveAmount) * ( 1.0 - stamDrainPerRateDive ) + stamDrainPerRateDive).toFloat() // smooth between 1.0 and the dive drain mod depending upon how dived the ride is
+        val stamDrainRate = (1.0f / totalStam).toFloat() * stamDrainHorz.toFloat()
+
+        val newStam = if (driver.deltaMovement.length() > 0.1) max(0.0f,stam - stamDrainRate) // Drain at normal fly rate
+            else if (state.gliding.get()) min(1.0f,stam - stamDrainRate * glideMod * diveMod) // Gliding drain logic
+            else max(0.0f,stam - stamDrainRate * 0.5f) // if hovering half the stam drain
 
         state.stamina.set(newStam)
     }
@@ -113,8 +145,6 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
         driver: Player,
         input: Vec3
     ): Vec3 {
-        var yVel = 0.0
-        var leftForce = 0.0
         var upForce = 0.0
         var forwardForce = 0.0
 
@@ -133,7 +163,10 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
             forwardForce += sin(Math.toRadians(controller.pitch.toDouble())) * state.rideVelocity.get().y
         }
 
-        val velocity = Vec3(state.rideVelocity.get().x , upForce, forwardForce)
+        // 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
+
+        val velocity = Vec3(state.rideVelocity.get().x , upForce + extraDownwardForce, forwardForce)
         return velocity
     }
 
@@ -142,9 +175,9 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
     */
     fun calculateRideSpaceVel(settings: BirdSettings, state: BirdState, vehicle: PokemonEntity, driver: Player) {
         // retrieve stats
-        val topSpeed = (vehicle.runtime.resolveDouble(settings.speedExpr) / 20.0)
-        val accel = topSpeed / (vehicle.runtime.resolveDouble(settings.accelerationExpr) * 20.0)
-        val glideTopSpeed = topSpeed * vehicle.runtime.resolveDouble(settings.glidespeedExpr)
+        val topSpeed = (vehicle.runtime.resolveDouble(settings.speedExpr ?: globalBird.speedExpr!!) / 20.0)
+        val accel = topSpeed / (vehicle.runtime.resolveDouble(settings.accelerationExpr ?: globalBird.accelerationExpr!!) * 20.0)
+        val glideTopSpeed = topSpeed * vehicle.runtime.resolveDouble(settings.glideSpeedExpr ?: globalBird.glideSpeedExpr!!)
         var glideSpeedChange = 0.0
         var activeInput = false
 
@@ -155,8 +188,8 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
             newVelocity = newVelocity.normalize().scale(vehicle.deltaMovement.length())
         }
 
-        //speed up and slow down based on input
-        if (driver.zza != 0.0f && state.stamina.get() > 0.0) {
+        // speed up and slow down based on input
+        if (driver.zza != 0.0f && state.stamina.get() > 0.0 && newVelocity.length() < glideTopSpeed) {
             //make sure it can't exceed top speed
             val forwardInput = when {
                 state.stamina.get() == 0.0f -> 0.0
@@ -228,7 +261,7 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
 
         //Check if the ride should be gliding
         if (driver.isLocalPlayer) {
-            if (activeInput && state.stamina.get() > 0.0) {
+            if ((activeInput && state.stamina.get() > 0.0) || state.rideVelocity.get().z < 0.2) {
                 state.gliding.set(false)
             } else {
                 state.gliding.set(true)
@@ -253,21 +286,23 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
         if (driver !is OrientationControllable) return Vec3.ZERO
         val controller = (driver as OrientationControllable).orientationController
 
-        val handling = vehicle.runtime.resolveDouble(settings.handlingExpr)
-        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr) / 20.0
+        val handling = vehicle.runtime.resolveDouble(settings.handlingExpr ?: globalBird.handlingExpr!!)
+        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr ?: globalBird.speedExpr!!) / 20.0
 
-        val yawDeltaDeg =  deltaTime * handling * sin(Math.toRadians(controller.roll.toDouble())).pow(2) * sin(Math.toRadians(controller.roll.toDouble())).sign
-        val trueYawDelt = yawDeltaDeg * abs(cos(Math.toRadians(controller.pitch.toDouble()))) * sqrt(RidingBehaviour.scaleToRange(state.rideVelocity.get().length(), 0.0, topSpeed))
+        val yawDeltaDeg =  deltaTime * handling * sin(Math.toRadians(controller.roll.toDouble())) //* sin(Math.toRadians(controller.roll.toDouble())).sign
+        val trueYawDelt = yawDeltaDeg * abs(cos(Math.toRadians(controller.pitch.toDouble())))// * sqrt(RidingBehaviour.scaleToRange(state.rideVelocity.get().length(), 0.0, topSpeed))
 
         // Dampen yaw when upside down
-        val yawDampen = (1 - abs(min(cos(controller.roll.toRadians()),0.0f)))
+        val yawDampen = (1 - abs(min(cos(controller.roll.toRadians()),0.0f)).pow(2))
         controller.applyGlobalYaw(trueYawDelt.toFloat() * yawDampen)
 
         // Correct orientation when at low speeds
         correctOrientation(settings, state, vehicle, controller, deltaTime)
 
+        controller.applyGlobalPitch(state.currPitchCorrectionForce.get().toRadians())
+
         //yaw, pitch, roll
-        return Vec3(0.0, state.currPitchCorrectionForce.get(), state.currRollCorrectionForce.get())
+        return Vec3(0.0, 0.0, state.currRollCorrectionForce.get())
     }
 
     private fun correctOrientation(
@@ -279,11 +314,11 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
     ) {
         // Calculate correcting roll force.
         // Mult by cos(pitch) to ensure that it doesn't roll correct at when diving or climbing
-        val rollCorrectionTimer = vehicle.runtime.resolveDouble(settings.timeToRollCorrect)
-        val maxRollCorrectionRate = if (state.rideVelocity.get().length() < 0.1) 15.0f else 8.0f * (cos(controller.pitch.toRadians())).pow(2) * ((state.noInputTime.get() - rollCorrectionTimer) * 2).coerceIn(0.0, 1.0).toFloat()
+        val rollCorrectionTimer = vehicle.runtime.resolveDouble(settings.timeToRollCorrect ?: globalBird.timeToRollCorrect!!)
+        val maxRollCorrectionRate = if (state.rideVelocity.get().length() < 0.1) 15.0f else 8.0f * (cos(controller.pitch.toRadians())).pow(2) * ((state.noInputTimeRoll.get() - rollCorrectionTimer)).coerceIn(0.0, 1.0).toFloat()
         val maxRollForce = maxRollCorrectionRate / 40.0
         val rollArrivalDeg = 90.0
-        if(state.rideVelocity.get().length() < 0.1 || state.noInputTime.get() > rollCorrectionTimer) {
+        if(state.rideVelocity.get().length() < 0.1 || state.noInputTimeRoll.get() > rollCorrectionTimer) {
             val arrivalInfluence = (min(rollArrivalDeg,abs(controller.roll).toDouble()) / rollArrivalDeg)
             val desiredRollForce = (0 - controller.roll).sign * maxRollCorrectionRate * arrivalInfluence
             var steeredRollForce = desiredRollForce - state.currRollCorrectionForce.get()
@@ -305,13 +340,15 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
         }
 
         //Calculate correcting pitch force.
-        val maxPitchCorrectionRate = 15
-        val maxPitchForce = maxPitchCorrectionRate / 40.0
-        val pitchArrivalDeg = 90.0
-        if(state.rideVelocity.get().length() < 0.1) {
-            val arrivalInfluence = (min(pitchArrivalDeg,abs(controller.pitch).toDouble()) / pitchArrivalDeg)
-            val desiredPitchForce = (0 - controller.pitch).sign * maxPitchCorrectionRate * arrivalInfluence
-            var steeredPitchForce = desiredPitchForce - state.currPitchCorrectionForce.get()
+        val maxPitchCorrectionRate = if (state.currUpsideDownForce.get() != 0.0) 8f * state.currUpsideDownForce.get() else 15f
+        val maxPitchForce = maxPitchCorrectionRate.toFloat() / 40.0f
+        val pitchArrivalDeg = 45.0f
+        var desiredPitch = if (state.currUpsideDownForce.get() != 0.0) 90.0 else 0.0
+
+        if((state.rideVelocity.get().length() < 0.1 && controller.pitch < 0.0) || state.currUpsideDownForce.get() != 0.0) {
+            val arrivalInfluence = (min(pitchArrivalDeg,abs(Mth.wrapDegrees(desiredPitch.toFloat().angleDifference(controller.pitch)))) / pitchArrivalDeg)
+            val desiredPitchForce = maxPitchCorrectionRate.toFloat() * arrivalInfluence
+            var steeredPitchForce = (desiredPitchForce - state.currPitchCorrectionForce.get())
 
             // Ensure the 'steering' correction force doesn't exceed our maxForce
             if (abs(steeredPitchForce) > maxPitchForce) {
@@ -342,12 +379,23 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
         sensitivity: Double,
         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 (abs(mouseX) < 1 && abs(mouseY) < 1) {
-            state.noInputTime.set(state.noInputTime.get() + deltaTime)
+        if (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 {
+            state.noInputTimeRoll.set(0.0)
+        }
+
+        if (abs(mouseY) < 1) {
+            state.noInputTimePitch.set(state.noInputTimePitch.get() + deltaTime)
         } else {
-            state.noInputTime.set(0.0)
+            state.noInputTimePitch.set(0.0)
         }
 
         return when {
@@ -396,8 +444,8 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
         // Set roll to zero if transitioning to noroll config
         controller.rotateRoll(controller.roll * -1.0f)
 
-        val handling = vehicle.runtime.resolveDouble(settings.handlingExpr)
-        val mouseInputMult = vehicle.runtime.resolveDouble(settings.mouseInputMult)
+        val handling = vehicle.runtime.resolveDouble(settings.handlingExpr ?: globalBird.handlingExpr!!)
+        val mouseInputMult = vehicle.runtime.resolveDouble(settings.mouseInputMult ?: globalBird.mouseInputMult!!)
 
         //Smooth out mouse input.
         val smoothingSpeed = 4.0
@@ -441,11 +489,11 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
         if (driver !is OrientationControllable) return Vec3.ZERO
         val controller = (driver as OrientationControllable).orientationController
 
-        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr) / 20.0
-        val mouseInputMult = vehicle.runtime.resolveDouble(settings.mouseInputMult)
+        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr ?: globalBird.speedExpr!!) / 20.0
+        val mouseInputMult = vehicle.runtime.resolveDouble(settings.mouseInputMult ?: globalBird.mouseInputMult!!)
 
         //Smooth out mouse input.
-        val smoothingSpeed = 4.0
+        val smoothingSpeed = 2.0
         val mouseXc = (mouseX).coerceIn(-45.0, 45.0) * mouseInputMult
         // When upside down apply a pitching force to nudge the player towards a dive. This reduces the 'weirdness'
         // of being upside down
@@ -454,31 +502,41 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
         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 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
-        val yawDampen = abs(cos(controller.pitch.toRadians())).pow(2) * abs(cos(controller.roll.toRadians())).pow(2)
-        val localYaw = if (currSpeed < hoverSpeed) xInput * (1 - sqrt(RidingBehaviour.scaleToRange(currSpeed, hoverSpeed, topSpeed))).coerceIn(0.0, 1.0)
-            else xInput * 0.4 * cos(controller.roll.toRadians()).coerceIn(0.0f, 1.0f) * yawDampen
+        // 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)
+            //xInput * 0.4 * cos(controller.roll.toRadians()).coerceIn(0.0f, 1.0f) * yawDampen
+
+        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)
+        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) RidingBehaviour.scaleToRange(currSpeed, hoverSpeed, topSpeed)
+        localPitch *= 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 // if ( currSpeed > hoverSpeed * 2) 0.4*(abs(yInput - localPitch) * controller.roll.sign * -1.0) else 0.0
-        val rollForce = if (currSpeed > hoverSpeed) xInput * sqrt(abs(RidingBehaviour.scaleToRange(currSpeed, hoverSpeed, topSpeed)).coerceIn(0.0,1.0)) + pitchInfluencedRollCorrection
+        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
+        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
 
+        // 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
+
         //yaw, pitch, roll
-        return Vec3(localYaw, localPitch, rollForce)
+        return Vec3(localYawForce, localPitch, rollForce)
     }
 
 
@@ -525,12 +583,12 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
         vehicle: PokemonEntity,
         driver: Player
     ): Float {
-        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr) / 20.0
-        val glideTopSpeed = topSpeed * vehicle.runtime.resolveDouble(settings.glidespeedExpr)
+        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr ?: globalBird.speedExpr!!) / 20.0
         val currSpeed = state.rideVelocity.get().length()
 
-        // Must I ensure that topspeed is greater than minimum?
-        val normalizedGlideSpeed = RidingBehaviour.scaleToRange(currSpeed, topSpeed, glideTopSpeed)
+        val speedOverTopSpeed = max( 0.0, currSpeed - topSpeed)
+
+        val normalizedGlideSpeed = RidingBehaviour.scaleToRange(speedOverTopSpeed, 0.0, 0.3)
 
         // Only ever want the fov change to be a max of 0.2 and for it to have non linear scaling.
         return 1.0f + normalizedGlideSpeed.pow(2).toFloat() * 0.2f
@@ -588,6 +646,17 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
         return false
     }
 
+    override fun damageOnCollision(
+        settings: BirdSettings,
+        state: BirdState,
+        vehicle: PokemonEntity,
+        impactVec: Vec3
+    ): Boolean {
+        if (!state.gliding.get()) return false
+        val impactSpeed = impactVec.horizontalDistance().toFloat() * 10f
+        return vehicle.causeFallDamage(impactSpeed, 1f, vehicle.damageSources().flyIntoWall())
+    }
+
     override fun getRideSounds(
         settings: BirdSettings,
         state: BirdState,
@@ -603,57 +672,78 @@ class BirdSettings : RidingBehaviourSettings {
     override val key = BirdBehaviour.KEY
     override val stats = mutableMapOf<RidingStat, IntRange>()
 
-    var infiniteAltitude: Expression = "false".asExpression()
+    var infiniteAltitude: Expression? = null
         private set
 
-    var infiniteStamina: Expression = "false".asExpression()
+    var infiniteStamina: Expression? = null
         private set
 
-    var timeToRollCorrect: Expression = "0.5".asExpression()
+    var timeToRollCorrect: Expression? = null
         private set
 
-    var handlingExpr: Expression = "q.get_ride_stats('SKILL', 'AIR', 90.0, 45.0)".asExpression()
-    var horizontalPitchExpr: Expression = "q.get_ride_stats('SKILL', 'AIR', 0.2, 0.1)".asExpression()
-    var mouseInputMult: Expression = "q.get_ride_stats('SKILL', 'AIR', 1.2, 0.8)".asExpression()
-    var speedExpr: Expression = "q.get_ride_stats('SPEED', 'AIR', 14.0, 8.0)".asExpression()
+    var handlingExpr: Expression? = null
+    var horizontalPitchExpr: Expression? = null
+    var mouseInputMult: Expression? = null
+    var speedExpr: Expression? = null
     // Seconds from stationary to top speed
-    var accelerationExpr: Expression = "q.get_ride_stats('ACCELERATION', 'AIR', 2.0, 5.0)".asExpression()
-    var staminaExpr: Expression = "q.get_ride_stats('STAMINA', 'AIR', 22.0, 12.0)".asExpression()
+    var accelerationExpr: Expression? = null
+    var staminaExpr: Expression? = null
 
-    var glidespeedExpr: Expression =  "q.get_ride_stats('JUMP', 'AIR', 2.2, 1.5)".asExpression()
+    var glideSpeedExpr: Expression? = null
         private set
 
+    // debuff to stamina drain (increases stamina drain?) depending on how horizontal you're looking (so just drain more when climbing in altitude)
+    // So for the base 1.5: If looking straight up and holding forward you drain at 150 percent the rate you would if
+    // you were horizontal.
+    var stamDrainHorzMod: Expression? = null
+        private set
+
+    // long ass variable name
+    // Percent of stamina drain during glide (percent of normal drain rate) So base is 25 percent. (change to 0 if you want no drain or negative if you want regen)
+    var stamDrainPercRateGlide: Expression? = null
+        private set
+
+    // Percent of stamina drain as a factor of how hard you're diving. So if its zero then at full dive you drain no stam.
+    // This stacks with `stamDrainPercRateGlide`
+    // This is coerced between 1 and 0 or things would get weird.
+    var stamDrainPerRateDive: Expression? = null
+        private set
     var rideSounds: RideSoundSettingsList = RideSoundSettingsList()
 
     override fun encode(buffer: RegistryFriendlyByteBuf) {
-        buffer.writeResourceLocation(key)
         buffer.writeRidingStats(stats)
         rideSounds.encode(buffer)
-        buffer.writeExpression(infiniteAltitude)
-        buffer.writeExpression(infiniteStamina)
-        buffer.writeExpression(glidespeedExpr)
-        buffer.writeExpression(handlingExpr)
-        buffer.writeExpression(horizontalPitchExpr)
-        buffer.writeExpression(mouseInputMult)
-        buffer.writeExpression(speedExpr)
-        buffer.writeExpression(accelerationExpr)
-        buffer.writeExpression(staminaExpr)
-        buffer.writeExpression(timeToRollCorrect)
+        buffer.writeNullableExpression(infiniteAltitude)
+        buffer.writeNullableExpression(infiniteStamina)
+        buffer.writeNullableExpression(glideSpeedExpr)
+        buffer.writeNullableExpression(handlingExpr)
+        buffer.writeNullableExpression(horizontalPitchExpr)
+        buffer.writeNullableExpression(mouseInputMult)
+        buffer.writeNullableExpression(speedExpr)
+        buffer.writeNullableExpression(accelerationExpr)
+        buffer.writeNullableExpression(staminaExpr)
+        buffer.writeNullableExpression(stamDrainHorzMod)
+        buffer.writeNullableExpression(stamDrainPercRateGlide)
+        buffer.writeNullableExpression(stamDrainPerRateDive)
+        buffer.writeNullableExpression(timeToRollCorrect)
     }
 
     override fun decode(buffer: RegistryFriendlyByteBuf) {
         stats.putAll(buffer.readRidingStats())
         rideSounds = RideSoundSettingsList.decode(buffer)
-        infiniteAltitude = buffer.readExpression()
-        infiniteStamina = buffer.readExpression()
-        glidespeedExpr = buffer.readExpression()
-        handlingExpr = buffer.readExpression()
-        horizontalPitchExpr = buffer.readExpression()
-        mouseInputMult = buffer.readExpression()
-        speedExpr = buffer.readExpression()
-        accelerationExpr = buffer.readExpression()
-        staminaExpr = buffer.readExpression()
-        timeToRollCorrect = buffer.readExpression()
+        infiniteAltitude = buffer.readNullableExpression()
+        infiniteStamina = buffer.readNullableExpression()
+        glideSpeedExpr = buffer.readNullableExpression()
+        handlingExpr = buffer.readNullableExpression()
+        horizontalPitchExpr = buffer.readNullableExpression()
+        mouseInputMult = buffer.readNullableExpression()
+        speedExpr = buffer.readNullableExpression()
+        accelerationExpr = buffer.readNullableExpression()
+        staminaExpr = buffer.readNullableExpression()
+        stamDrainHorzMod = buffer.readNullableExpression()
+        stamDrainPercRateGlide = buffer.readNullableExpression()
+        stamDrainPerRateDive = buffer.readNullableExpression()
+        timeToRollCorrect = buffer.readNullableExpression()
     }
 }
 
@@ -662,11 +752,12 @@ class BirdState : RidingBehaviourState() {
     var lastGlide = ridingState(-100L, Side.CLIENT)
     var currRollCorrectionForce = ridingState(0.0, Side.CLIENT)
     var currPitchCorrectionForce = ridingState(0.0, Side.CLIENT)
-    var noInputTime = 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)
 
     override fun encode(buffer: FriendlyByteBuf) {
         super.encode(buffer)
-        buffer.writeFloat(stamina.get())
         buffer.writeBoolean(gliding.get())
     }
 
@@ -681,7 +772,8 @@ class BirdState : RidingBehaviourState() {
         lastGlide.set(-100L, forced = true)
         currRollCorrectionForce.set(0.0, forced = true)
         currPitchCorrectionForce.set(0.0, forced = true)
-        noInputTime.set(0.0, forced = true)
+        noInputTimeRoll.set(0.0, forced = true)
+        noInputTimePitch.set(0.0, forced = true)
     }
 
     override fun toString(): String {
@@ -695,7 +787,8 @@ class BirdState : RidingBehaviourState() {
         it.lastGlide.set(this.lastGlide.get(), forced = true)
         it.currRollCorrectionForce.set(this.currRollCorrectionForce.get(), forced = true)
         it.currPitchCorrectionForce.set(this.currPitchCorrectionForce.get(), forced = true)
-        it.noInputTime.set(this.noInputTime.get(), forced = true)
+        it.noInputTimeRoll.set(this.noInputTimeRoll.get(), forced = true)
+        it.noInputTimePitch.set(this.noInputTimePitch.get(), forced = true)
     }
 
     override fun shouldSync(previous: RidingBehaviourState): Boolean {
@@ -704,3 +797,16 @@ class BirdState : RidingBehaviourState() {
         return super.shouldSync(previous)
     }
 }
+
+/**
+ * Calculates the shortest difference between two angles.
+ * The result will be in the range [-180, 180].
+ * A positive result indicates a clockwise direction from this angle to the other,
+ * a negative result indicates a counter-clockwise direction.
+ */
+fun Float.angleDifference(other: Float): Float {
+    var diff = other - this
+    while (diff <= -180F) diff += 360F
+    while (diff > 180F) diff -= 360F
+    return diff
+}

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

@@ -10,6 +10,7 @@ package com.cobblemon.mod.common.api.riding.behaviour.types.air
 
 import com.bedrockk.molang.Expression
 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.RidingBehaviourState
@@ -37,6 +38,9 @@ class GliderBehaviour : RidingBehaviour<GliderSettings, RidingBehaviourState> {
 
     override val key = KEY
 
+    val globalGlider: GliderSettings
+        get() = CobblemonRideSettings.glider
+
     override fun getRidingStyle(settings: GliderSettings, state: RidingBehaviourState): RidingStyle {
         return RidingStyle.AIR
     }
@@ -53,7 +57,7 @@ class GliderBehaviour : RidingBehaviour<GliderSettings, RidingBehaviourState> {
     }
 
     override fun speed(settings: GliderSettings, state: RidingBehaviourState, vehicle: PokemonEntity, driver: Player): Float {
-        return vehicle.runtime.resolveFloat(settings.speed)
+        return vehicle.runtime.resolveFloat(settings.speed ?: globalGlider.speed!!)
     }
 
     override fun rotation(
@@ -72,10 +76,9 @@ class GliderBehaviour : RidingBehaviour<GliderSettings, RidingBehaviourState> {
             driver: Player,
             input: Vec3
     ): Vec3 {
-        val xVector = if (vehicle.runtime.resolveBoolean(settings.canStrafe)) driver.xxa.toDouble() else 0.0
-        val yVector = -vehicle.runtime.resolveDouble(settings.glideSpeed)
+        val xVector = if (vehicle.runtime.resolveBoolean(settings.canStrafe ?: globalGlider.canStrafe!!)) driver.xxa.toDouble() else 0.0
+        val yVector = -vehicle.runtime.resolveDouble(settings.glideSpeed ?: globalGlider.glideSpeed!!)
         val zVector = driver.zza.toDouble()
-        val speedStat = settings.calculate(RidingStat.SPEED, 0)
         return Vec3(xVector, yVector, zVector)
     }
 
@@ -196,31 +199,30 @@ class GliderSettings : RidingBehaviourSettings {
     override val key = GliderBehaviour.KEY
     override val stats = mutableMapOf<RidingStat, IntRange>()
 
-    var glideSpeed: Expression = "0.1".asExpression()
+    var glideSpeed: Expression? = null
         private set
 
-    var speed: Expression = "1.0".asExpression()
+    var speed: Expression? = null
         private set
 
-    var canStrafe: Expression = "false".asExpression()
+    var canStrafe: Expression? = null
         private set
 
     var rideSounds: RideSoundSettingsList = RideSoundSettingsList()
 
     override fun encode(buffer: RegistryFriendlyByteBuf) {
-        buffer.writeResourceLocation(key)
         buffer.writeRidingStats(stats)
         rideSounds.encode(buffer)
-        buffer.writeExpression(glideSpeed)
-        buffer.writeExpression(speed)
-        buffer.writeExpression(canStrafe)
+        buffer.writeNullableExpression(glideSpeed)
+        buffer.writeNullableExpression(speed)
+        buffer.writeNullableExpression(canStrafe)
     }
 
     override fun decode(buffer: RegistryFriendlyByteBuf) {
         stats.putAll(buffer.readRidingStats())
         rideSounds = RideSoundSettingsList.decode(buffer)
-        glideSpeed = buffer.readExpression()
-        speed = buffer.readExpression()
-        canStrafe = buffer.readExpression()
+        glideSpeed = buffer.readNullableExpression()
+        speed = buffer.readNullableExpression()
+        canStrafe = buffer.readNullableExpression()
     }
 }

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

@@ -10,6 +10,7 @@ package com.cobblemon.mod.common.api.riding.behaviour.types.air
 
 import com.bedrockk.molang.Expression
 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.RidingBehaviour
@@ -21,7 +22,16 @@ 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
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.*
+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.resolveDouble
+import com.cobblemon.mod.common.util.writeNullableExpression
+import com.cobblemon.mod.common.util.writeRidingStats
+import kotlin.math.abs
+import kotlin.math.pow
+import kotlin.math.sin
 import net.minecraft.network.RegistryFriendlyByteBuf
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.util.SmoothDouble
@@ -30,9 +40,6 @@ import net.minecraft.world.entity.player.Player
 import net.minecraft.world.phys.Vec2
 import net.minecraft.world.phys.Vec3
 import net.minecraft.world.phys.shapes.Shapes
-import kotlin.math.abs
-import kotlin.math.pow
-import kotlin.math.sin
 
 class HelicopterBehaviour : RidingBehaviour<HelicopterSettings, RidingBehaviourState> {
     companion object {
@@ -41,6 +48,8 @@ class HelicopterBehaviour : RidingBehaviour<HelicopterSettings, RidingBehaviourS
     }
 
     override val key = KEY
+    val globalHelicopter: HelicopterSettings
+        get() = CobblemonRideSettings.helicopter
 
     override fun getRidingStyle(settings: HelicopterSettings, state: RidingBehaviourState): RidingStyle {
         return RidingStyle.AIR
@@ -93,8 +102,8 @@ class HelicopterBehaviour : RidingBehaviour<HelicopterSettings, RidingBehaviourS
         val runtime = vehicle.runtime
 
         //If the player is not modulating height then hover
-        var yVel = if (driver.jumping) runtime.resolveDouble(settings.verticalVelocity)
-        else if (driver.isShiftKeyDown) -runtime.resolveDouble(settings.verticalVelocity)
+        var yVel = if (driver.jumping) runtime.resolveDouble(settings.verticalVelocity ?: globalHelicopter.verticalVelocity!!)
+        else if (driver.isShiftKeyDown) -runtime.resolveDouble(settings.verticalVelocity ?: globalHelicopter.verticalVelocity!!)
         else (0.0)
 
         yVel *= 0.25
@@ -290,36 +299,35 @@ class HelicopterSettings : RidingBehaviourSettings {
     override val key = HelicopterBehaviour.KEY
     override val stats = mutableMapOf<RidingStat, IntRange>()
 
-    var gravity: Expression = "1.0".asExpression()
+    var gravity: Expression? = null
         private set
 
-    var horizontalAcceleration: Expression = "0.1".asExpression()
+    var horizontalAcceleration: Expression? = null
         private set
 
-    var verticalVelocity: Expression = "1.0".asExpression()
+    var verticalVelocity: Expression? = null
         private set
 
-    var speed: Expression = "1.0".asExpression()
+    var speed: Expression? = null
         private set
 
     var rideSounds: RideSoundSettingsList = RideSoundSettingsList()
 
     override fun encode(buffer: RegistryFriendlyByteBuf) {
-        buffer.writeResourceLocation(key)
         buffer.writeRidingStats(stats)
         rideSounds.encode(buffer)
-        buffer.writeExpression(gravity)
-        buffer.writeExpression(horizontalAcceleration)
-        buffer.writeExpression(verticalVelocity)
-        buffer.writeExpression(speed)
+        buffer.writeNullableExpression(gravity)
+        buffer.writeNullableExpression(horizontalAcceleration)
+        buffer.writeNullableExpression(verticalVelocity)
+        buffer.writeNullableExpression(speed)
     }
 
     override fun decode(buffer: RegistryFriendlyByteBuf) {
         stats.putAll(buffer.readRidingStats())
         rideSounds = RideSoundSettingsList.decode(buffer)
-        gravity = buffer.readExpression()
-        horizontalAcceleration = buffer.readExpression()
-        verticalVelocity = buffer.readExpression()
-        speed = buffer.readExpression()
+        gravity = buffer.readNullableExpression()
+        horizontalAcceleration = buffer.readNullableExpression()
+        verticalVelocity = buffer.readNullableExpression()
+        speed = buffer.readNullableExpression()
     }
 }

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

@@ -9,10 +9,9 @@
 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.api.riding.RidingStyle
 import com.cobblemon.mod.common.api.riding.behaviour.*
-import com.cobblemon.mod.common.api.riding.behaviour.types.land.HorseSettings
-import com.cobblemon.mod.common.api.riding.behaviour.types.land.HorseState
 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
@@ -27,7 +26,6 @@ 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.Entity
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.player.Player
 import net.minecraft.world.level.ClipContext
@@ -44,6 +42,8 @@ class HoverBehaviour : RidingBehaviour<HoverSettings, HoverState> {
     }
 
     override val key = KEY
+    val globalHover: HoverSettings
+        get() = CobblemonRideSettings.hover
 
     override fun getRidingStyle(settings: HoverSettings, state: HoverState): RidingStyle {
         return RidingStyle.AIR
@@ -97,7 +97,31 @@ class HoverBehaviour : RidingBehaviour<HoverSettings, HoverState> {
         driver: Player,
         input: Vec3
     ) {
-        tickStamina(settings, state, vehicle)
+        if(vehicle.level().isClientSide) {
+            tickStamina(settings, state, vehicle)
+            checkTooHigh(settings, state, vehicle)
+        }
+    }
+
+    fun checkTooHigh(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity,
+    ) {
+        val heightLimit = vehicle.runtime.resolveDouble(settings.jumpExpr ?: globalHover.jumpExpr!!)
+        val pos = vehicle.position()
+        val level = Minecraft.getInstance().player?.level() ?: return
+        val hit = level.clip(
+            ClipContext(
+                pos,
+                pos.subtract(0.0, heightLimit, 0.0),
+                ClipContext.Block.COLLIDER,
+                ClipContext.Fluid.NONE,
+                vehicle
+            )
+        )
+
+        state.tooHigh.set(hit.type == HitResult.Type.MISS)
     }
 
     fun tickStamina(
@@ -105,10 +129,13 @@ class HoverBehaviour : RidingBehaviour<HoverSettings, HoverState> {
         state: HoverState,
         vehicle: PokemonEntity
     ) {
+        if (vehicle.runtime.resolveBoolean(settings.infiniteStamina ?: globalHover.infiniteStamina!!)) {
+            return
+        }
         val stam = state.stamina.get()
-        val stamDrainRate = (1.0f / vehicle.runtime.resolveDouble(settings.staminaExpr)).toFloat() / 20.0f
-
-        val newStam = min(1.0f,stam + stamDrainRate)
+        val stamDrainRate = (1.0f / vehicle.runtime.resolveDouble(settings.staminaExpr ?: globalHover.staminaExpr!!)).toFloat() / 20.0f
+        val stamReplenishRate = (1.0f / vehicle.runtime.resolveDouble(settings.stamReplenishTimeSeconds ?: globalHover.stamReplenishTimeSeconds!!) ).toFloat() / 20.0f // 2 seconds to replenish a full bar of stamina
+        val newStam = if (state.tooHigh.get()) max(0.0f, stam - stamDrainRate) else min(1.0f,stam + stamReplenishRate)
 
         state.stamina.set(newStam)
     }
@@ -154,8 +181,8 @@ class HoverBehaviour : RidingBehaviour<HoverSettings, HoverState> {
         vehicle: PokemonEntity,
         driver: LivingEntity
     ): Float {
-        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr) / 20.0
-        val handling = vehicle.runtime.resolveDouble(settings.handlingExpr) / 20.0
+        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr ?: globalHover.speedExpr!!) / 20.0
+        val handling = vehicle.runtime.resolveDouble(settings.handlingExpr ?: globalHover.handlingExpr!!) / 20.0
         val maxYawDiff = 90.0f
 
         // Normalize the current rotation diff
@@ -190,8 +217,8 @@ class HoverBehaviour : RidingBehaviour<HoverSettings, HoverState> {
         driver: Player
     ): Vec3 {
         // Convert these to their tick values
-        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr) / 20.0
-        val accel = topSpeed / (vehicle.runtime.resolveDouble(settings.accelerationExpr) * 20.0)
+        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr ?: globalHover.speedExpr!!) / 20.0
+        val accel = topSpeed / (vehicle.runtime.resolveDouble(settings.accelerationExpr ?: globalHover.accelerationExpr!!) * 20.0)
 
         var newVelocity = state.rideVelocity.get()
 
@@ -206,6 +233,7 @@ class HoverBehaviour : RidingBehaviour<HoverSettings, HoverState> {
 
         // Vertical movement based on driver input.
         val vertInput = when {
+            state.stamina.get() == 0.0f -> -1.0
             driver.jumping -> 1.0
             driver.isShiftKeyDown -> -1.0
             else -> 0.0
@@ -219,28 +247,6 @@ class HoverBehaviour : RidingBehaviour<HoverSettings, HoverState> {
             driver.zza.sign.toDouble()
         ).normalize()
 
-        /******************************************************
-         * Boosting Logic
-         *****************************************************/
-        if (driver.level().isClientSide) {
-            if(Minecraft.getInstance().options.keySprint.isDown() && state.stamina.get() == 1.0f && !state.isBoosting.get()) {
-                state.isBoosting.set(true)
-                val localBoostVel = if (inputVel.horizontalDistance() == 0.0) Vec3(0.0, 0.0, 1.0) else Vec3(inputVel.x, 0.0, inputVel.z)
-                state.boostVec.set(localBoostVel)
-                state.boostTicks.set(0)
-                state.stamina.set(0.0f)
-            }
-        }
-        val maxBoostTicks = 20
-        val boostPower = (topSpeed * 20) * 0.1 * vehicle.runtime.resolveDouble(settings.jumpExpr)
-        if (state.isBoosting.get() && state.boostTicks.get() < maxBoostTicks) {
-            newVelocity = newVelocity.add(state.boostVec.get().scale(boostPower / maxBoostTicks))
-            state.boostTicks.set(state.boostTicks.get() + 1)
-        } else if (state.isBoosting.get()) {
-            state.isBoosting.set(false)
-        }
-
-
         // Air Friction/Resistance
         // When the dot between friction and input is -1 we want to apply none of it.
         // In short we want to avoid applying friction that opposes our input force.
@@ -427,51 +433,61 @@ class HoverSettings : RidingBehaviourSettings {
     override val key = HoverBehaviour.KEY
     override val stats = mutableMapOf<RidingStat, IntRange>()
 
-    var canJump = "true".asExpression()
+    var infiniteStamina: Expression? = null
+        private set
+
+    var canJump: Expression? = null
+        private set
+
+    var stamReplenishTimeSeconds: Expression? = null
         private set
 
     // Speed in block per second
-    var speedExpr: Expression = "q.get_ride_stats('SPEED', 'AIR', 13.0, 6.0)".asExpression()
+    var speedExpr: Expression? = null
         private set
 
     // Acceleration in number of seconds to top speed
-    var accelerationExpr: Expression =
-        "q.get_ride_stats('ACCELERATION', 'AIR', 2.0, 5.0)".asExpression()
+    var accelerationExpr: Expression? = null
         private set
 
     // Amount of seconds between boosts
-    var staminaExpr: Expression = "q.get_ride_stats('STAMINA', 'AIR', 1, 4)".asExpression()
+    var staminaExpr: Expression? = null
         private set
 
-    // Power of boost as a fraction of top speed
-    var jumpExpr: Expression = "q.get_ride_stats('JUMP', 'AIR', 1.2, 0.2)".asExpression()
+    // Blocks before stamina drain
+    var jumpExpr: Expression? = null
         private set
 
     // Turn rate in degrees per second when stationary
-    var handlingExpr: Expression = "q.get_ride_stats('SKILL', 'AIR', 360.0, 90)".asExpression()
+    var handlingExpr: Expression? = null
         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.writeNullableExpression(infiniteStamina)
+        buffer.writeNullableExpression(canJump)
+        buffer.writeNullableExpression(stamReplenishTimeSeconds)
+        buffer.writeNullableExpression(speedExpr)
+        buffer.writeNullableExpression(accelerationExpr)
+        buffer.writeNullableExpression(staminaExpr)
+        buffer.writeNullableExpression(jumpExpr)
+        buffer.writeNullableExpression(handlingExpr)
     }
 
     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()
+        infiniteStamina = buffer.readNullableExpression()
+        canJump = buffer.readNullableExpression()
+        stamReplenishTimeSeconds = buffer.readNullableExpression()
+        speedExpr = buffer.readNullableExpression()
+        accelerationExpr = buffer.readNullableExpression()
+        staminaExpr = buffer.readNullableExpression()
+        jumpExpr = buffer.readNullableExpression()
+        handlingExpr = buffer.readNullableExpression()
     }
 
 }
@@ -481,17 +497,20 @@ class HoverState : RidingBehaviourState() {
     var isBoosting = ridingState(false, Side.BOTH)
     var boostVec = ridingState(Vec3.ZERO, Side.CLIENT)
     var boostTicks = ridingState(0, Side.CLIENT)
+    var tooHigh = ridingState(false, Side.CLIENT)
 
     override fun encode(buffer: FriendlyByteBuf) {
         super.encode(buffer)
         buffer.writeDouble(speed.get())
         buffer.writeBoolean(isBoosting.get())
+        buffer.writeBoolean(tooHigh.get())
     }
 
     override fun decode(buffer: FriendlyByteBuf) {
         super.decode(buffer)
         speed.set(buffer.readDouble(), forced = true)
         isBoosting.set(buffer.readBoolean(), forced = true)
+        tooHigh.set(buffer.readBoolean(), forced = true)
     }
 
     override fun reset() {
@@ -500,6 +519,7 @@ class HoverState : RidingBehaviourState() {
         isBoosting.set(false, forced = true)
         boostVec.set(Vec3.ZERO, forced = true)
         boostTicks.set(0, forced = true)
+        tooHigh.set(false, forced = true)
     }
 
     override fun copy() = HoverState().also {
@@ -508,6 +528,7 @@ class HoverState : RidingBehaviourState() {
         it.isBoosting.set(this.isBoosting.get(), forced = true)
         it.boostVec.set(this.boostVec.get(), forced = true)
         it.boostTicks.set(this.boostTicks.get(), forced = true)
+        it.tooHigh.set(this.tooHigh.get(), forced = true)
     }
 
     override fun shouldSync(previous: RidingBehaviourState): Boolean {

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

@@ -11,22 +11,35 @@ package com.cobblemon.mod.common.api.riding.behaviour.types.air
 import com.bedrockk.molang.Expression
 import com.bedrockk.molang.runtime.MoLangMath.lerp
 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.*
-import com.cobblemon.mod.common.api.riding.behaviour.types.land.HorseSettings
-import com.cobblemon.mod.common.api.riding.behaviour.types.land.HorseState
+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.entity.PoseType
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.*
-import net.minecraft.network.FriendlyByteBuf
-import net.minecraft.network.RegistryFriendlyByteBuf
 import com.cobblemon.mod.common.api.riding.sound.RideSoundSettingsList
 import com.cobblemon.mod.common.api.riding.stats.RidingStat
-import com.cobblemon.mod.common.config.CobblemonConfig
+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
+import com.cobblemon.mod.common.util.toVec3d
+import com.cobblemon.mod.common.util.writeNullableExpression
+import com.cobblemon.mod.common.util.writeRidingStats
+import kotlin.math.abs
+import kotlin.math.max
+import kotlin.math.min
 import net.minecraft.client.Minecraft
+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
@@ -34,7 +47,7 @@ import net.minecraft.world.entity.player.Player
 import net.minecraft.world.phys.Vec2
 import net.minecraft.world.phys.Vec3
 import net.minecraft.world.phys.shapes.Shapes
-import kotlin.math.*
+import org.joml.Vector3f
 
 class JetBehaviour : RidingBehaviour<JetSettings, JetState> {
     companion object {
@@ -47,6 +60,9 @@ class JetBehaviour : RidingBehaviour<JetSettings, JetState> {
         return RidingStyle.AIR
     }
 
+    val globalJet: JetSettings
+        get() = CobblemonRideSettings.jet
+
     val poseProvider = PoseProvider<JetSettings, JetState>(PoseType.HOVER)
         .with(PoseOption(PoseType.FLY) { _, state, _ -> state.rideVelocity.get().z > 0.1 })
 
@@ -87,7 +103,7 @@ class JetBehaviour : RidingBehaviour<JetSettings, JetState> {
         val boostKeyPressed = Minecraft.getInstance().options.keySprint.isDown()
 
         if(state.stamina.get() != 0.0f && boostKeyPressed) {
-            if (state.stamina.get() >= 0.25f) {
+            if (state.stamina.get() >= 0.0f) {
                 //If on the previous tick the boost key was held then don't change if the ride is boosting
                 if(state.boostIsToggleable.get()) {
                     //flip the boosting state if boost key is pressed
@@ -111,13 +127,19 @@ class JetBehaviour : RidingBehaviour<JetSettings, JetState> {
     ) {
         val stam = state.stamina.get()
         var newStam = stam
-        val stamDrainRate = (1.0f / vehicle.runtime.resolveDouble(settings.staminaExpr)).toFloat() / 20.0f
+        val stamDrainRate = (1.0f / vehicle.runtime.resolveDouble(settings.staminaExpr ?: globalJet.staminaExpr!!)).toFloat() / 20.0f
 
         if (state.boosting.get()) {
-            newStam = max(0.0f,stam - stamDrainRate)
-
+            newStam = max(0.0f,stam - stamDrainRate * 1.5f)
         } else {
-            newStam = min(1.0f,stam + stamDrainRate * 0.25f)
+            newStam = max(0.0f,stam - stamDrainRate)
+        }
+
+        // If out of stamina then increase noStamTickCnt
+        if (newStam == 0.0f) {
+            state.noStamTickCnt.set(state.noStamTickCnt.get() + 1)
+        } else {
+            state.noStamTickCnt.get()
         }
 
         state.stamina.set(newStam)
@@ -139,23 +161,26 @@ class JetBehaviour : RidingBehaviour<JetSettings, JetState> {
         driver: Player,
         input: Vec3
     ): Vec3 {
-        var upForce = 0.0
-        var forwardForce = 0.0
-
         val controller = (driver as? OrientationControllable)?.orientationController
+        if (controller == null || controller.orientation == null) return Vec3.ZERO
 
         //Calculate ride space velocity
         calculateRideSpaceVel(settings, state, vehicle, driver)
 
-        //Translate ride space velocity to world space velocity.
-        if (controller != null) {
-            upForce = -1.0 * sin(Math.toRadians(controller.pitch.toDouble())) * state.rideVelocity.get().z
-            forwardForce = cos(Math.toRadians(controller.pitch.toDouble())) * state.rideVelocity.get().z
-        }
+        // The downward force used to encourage players to stop flying upside down.
+        val maxDownwardForceTickCnt = 20.0
+        val extraDownwardForce = if(state.stamina.get() == 0.0f) -0.3 * (state.noStamTickCnt.get() / maxDownwardForceTickCnt).coerceIn(0.0, 1.0) else 0.0 // 6 blocks a second downward
 
-        val velocity = Vec3(0.0, upForce, forwardForce)
+        // Convert the local velocity vector into a world vector
+        val localVelVec = Vector3f(
+            state.rideVelocity.get().x.toFloat(),
+            (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.
+        worldVelVec =  worldVelVec.add(0.0, extraDownwardForce, 0.0) // Add the stamina depletion force to bring the ride down.
 
-        return velocity
+        return worldVelVec
     }
 
     /*
@@ -167,17 +192,28 @@ class JetBehaviour : RidingBehaviour<JetSettings, JetState> {
         vehicle: PokemonEntity,
         driver: Player
     ) {
-        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr) / 20.0
-        val accel = vehicle.runtime.resolveDouble(settings.accelerationExpr) / 400.0
-        val minSpeed = vehicle.runtime.resolveDouble(settings.minSpeed) / 20.0
-        val speed = state.rideVelocity.get().length()
-        val boostMult = vehicle.runtime.resolveDouble(settings.jumpExpr)
+        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr ?: globalJet.speedExpr!!) / 20.0
+        val accel = topSpeed / (vehicle.runtime.resolveDouble(settings.accelerationExpr ?: globalJet.accelerationExpr!!) * 20.0)
+        val deccel = vehicle.runtime.resolveDouble(settings.deccelRate ?: globalJet.deccelRate!!)//0.005
+        val minSpeed = topSpeed * vehicle.runtime.resolveDouble(settings.minSpeedFactor ?: globalJet.minSpeedFactor!!)
+        val speed = state.rideVelocity.get().z
+        val boostMult = vehicle.runtime.resolveDouble(settings.jumpExpr ?: globalJet.jumpExpr!!)
 
         val boostTopSpeed = topSpeed * boostMult
         val boostAccel = accel * boostMult
 
         //speed up and slow down based on input
-        if (state.boosting.get() && speed < boostTopSpeed) {
+        if (state.stamina.get() == 0.0f) {
+            // Decelerate currently always a constant half of max acceleration.
+            state.rideVelocity.set(
+                Vec3(
+                    state.rideVelocity.get().x,
+                    state.rideVelocity.get().y,
+                    max(state.rideVelocity.get().z - (deccel * 1.3), 0.3 * 0.5)
+                )
+            )
+        }
+        else if (state.boosting.get() && speed < boostTopSpeed) {
             state.rideVelocity.set(
                 Vec3(
                     state.rideVelocity.get().x,
@@ -201,7 +237,7 @@ class JetBehaviour : RidingBehaviour<JetSettings, JetState> {
                 Vec3(
                     state.rideVelocity.get().x,
                     state.rideVelocity.get().y,
-                    max(state.rideVelocity.get().z - ((accel) / 2), minSpeed)
+                    max(state.rideVelocity.get().z - (deccel), minSpeed)
                 )
             )
         } else if (speed > topSpeed) {
@@ -209,6 +245,17 @@ class JetBehaviour : RidingBehaviour<JetSettings, JetState> {
                 state.rideVelocity.get().scale(0.98)
             )
         }
+
+        /****************************************************************************
+         * Kill strafing velocities carried over from controller transition. Don't
+         * kill immediately to give some momentum to transitions.
+         ***************************************************************************/
+        state.rideVelocity.set(Vec3(
+            lerp(state.rideVelocity.get().x, 0.0, 0.03),
+            lerp(state.rideVelocity.get().y, 0.0, 0.03),
+            state.rideVelocity.get().z
+        ))
+
     }
 
     override fun angRollVel(
@@ -225,7 +272,7 @@ class JetBehaviour : RidingBehaviour<JetSettings, JetState> {
         val cappedDeltaTime = min(deltaTime, 0.2)
 
         //Get handling in degrees per second
-        val yawRotRate = vehicle.runtime.resolveDouble(settings.handlingYawExpr)
+        val yawRotRate = vehicle.runtime.resolveDouble(settings.handlingYawExpr ?: globalJet.handlingYawExpr!!)
 
         //Base the change off of deltatime.
         var handlingYaw = yawRotRate * (cappedDeltaTime)
@@ -305,7 +352,8 @@ class JetBehaviour : RidingBehaviour<JetSettings, JetState> {
         state.currMouseYForce.set((state.currMouseYForce.get() + (0.0015 * mouseY)).coerceIn(-1.0, 1.0))
 
         //Get handling in degrees per second
-        var handling = vehicle.runtime.resolveDouble(settings.handlingExpr)
+        val handlingDebuff = if(state.stamina.get() == 0.0f) 0.5 else 1.0
+        var handling = vehicle.runtime.resolveDouble(settings.handlingExpr ?: globalJet.handlingExpr!!) * handlingDebuff
         //convert it to delta time
         handling *= (cappedDeltaTime)
 
@@ -358,7 +406,8 @@ class JetBehaviour : RidingBehaviour<JetSettings, JetState> {
         state.currMouseYForce.set((state.currMouseYForce.get() + (0.0015 * mouseY)).coerceIn(-1.0, 1.0))
 
         //Get handling in degrees per second
-        var handling = vehicle.runtime.resolveDouble(settings.handlingExpr)
+        val handlingDebuff = if(state.stamina.get() == 0.0f) 0.5 else 1.0
+        var handling = vehicle.runtime.resolveDouble(settings.handlingExpr ?: globalJet.handlingExpr!!) * handlingDebuff
 
         //convert it to delta time
         handling *= (cappedDeltaTime)
@@ -434,7 +483,12 @@ class JetBehaviour : RidingBehaviour<JetSettings, JetState> {
         vehicle: PokemonEntity,
         driver: Player
     ): Float {
-        return if (state.boosting.get()) 1.2f else 1.0f
+        val maxDownwardForceTickCnt = 20.0f
+        return when {
+            state.noStamTickCnt.get() != 0 -> 1f - 0.2f*(state.noStamTickCnt.get() / maxDownwardForceTickCnt).coerceIn(0.0f,1.0f)
+            state.boosting.get() -> 1.2f
+            else -> 1.0f
+        }
     }
 
     override fun useAngVelSmoothing(settings: JetSettings, state: JetState, vehicle: PokemonEntity): Boolean {
@@ -507,66 +561,70 @@ class JetSettings : RidingBehaviourSettings {
     override val key = JetBehaviour.KEY
     override val stats = mutableMapOf<RidingStat, IntRange>()
 
-    var gravity: Expression = "0".asExpression()
+    var gravity: Expression? = null
         private set
 
-    var minSpeed: Expression = "12.0".asExpression()
+    var deccelRate: Expression? = null
         private set
 
-    var handlingYawExpr: Expression = "q.get_ride_stats('SKILL', 'AIR', 50.0, 25.0)".asExpression()
+    // Mult to top speed in order to derive minSpeed
+    var minSpeedFactor: Expression? = null
+        private set
+
+    var handlingYawExpr: Expression? = null
         private set
 
     // Make configurable by json
-    var infiniteStamina: Expression = "false".asExpression()
+    var infiniteStamina: Expression? = null
         private set
 
     // Boost power. Mult for top speed and accel while boosting
-    var jumpExpr: Expression = "q.get_ride_stats('JUMP', 'AIR', 1.7, 1.2)".asExpression()
+    var jumpExpr: Expression? = null
         private set
 
     // Turn rate in degrees per second
-    var handlingExpr: Expression = "q.get_ride_stats('SKILL', 'AIR', 120.0, 60.0)".asExpression()
+    var handlingExpr: Expression? = null
         private set
     // Top Speed in blocks per second
-    var speedExpr: Expression = "q.get_ride_stats('SPEED', 'AIR', 36.0, 20.0)".asExpression()
+    var speedExpr: Expression? = null
         private set
-    // Acceleration in blocks per s^2
-    var accelerationExpr: Expression =
-        "q.get_ride_stats('ACCELERATION', 'AIR', 5.0, 2.5)".asExpression()
+    // Seconds to get to top speed
+    var accelerationExpr: Expression? = null
         private set
-    // Time in seconds to drain full bar of stamina when boosting
-    var staminaExpr: Expression = "q.get_ride_stats('STAMINA', 'AIR', 8.0, 4.0)".asExpression()
+    // Time in seconds to drain full bar of stamina flying
+    var staminaExpr: Expression? = null
         private set
 
     var rideSounds: RideSoundSettingsList = RideSoundSettingsList()
 
     override fun encode(buffer: RegistryFriendlyByteBuf) {
-        buffer.writeResourceLocation(key)
         buffer.writeRidingStats(stats)
         rideSounds.encode(buffer)
-        buffer.writeExpression(gravity)
-        buffer.writeExpression(minSpeed)
-        buffer.writeExpression(handlingYawExpr)
-        buffer.writeExpression(infiniteStamina)
-        buffer.writeExpression(jumpExpr)
-        buffer.writeExpression(handlingExpr)
-        buffer.writeExpression(speedExpr)
-        buffer.writeExpression(accelerationExpr)
-        buffer.writeExpression(staminaExpr)
+        buffer.writeNullableExpression(gravity)
+        buffer.writeNullableExpression(deccelRate)
+        buffer.writeNullableExpression(minSpeedFactor)
+        buffer.writeNullableExpression(handlingYawExpr)
+        buffer.writeNullableExpression(infiniteStamina)
+        buffer.writeNullableExpression(jumpExpr)
+        buffer.writeNullableExpression(handlingExpr)
+        buffer.writeNullableExpression(speedExpr)
+        buffer.writeNullableExpression(accelerationExpr)
+        buffer.writeNullableExpression(staminaExpr)
     }
 
     override fun decode(buffer: RegistryFriendlyByteBuf) {
         stats.putAll(buffer.readRidingStats())
         rideSounds = RideSoundSettingsList.decode(buffer)
-        gravity = buffer.readExpression()
-        minSpeed = buffer.readExpression()
-        handlingYawExpr = buffer.readExpression()
-        infiniteStamina = buffer.readExpression()
-        jumpExpr = buffer.readExpression()
-        handlingExpr = buffer.readExpression()
-        speedExpr = buffer.readExpression()
-        accelerationExpr = buffer.readExpression()
-        staminaExpr = buffer.readExpression()
+        gravity = buffer.readNullableExpression()
+        deccelRate = buffer.readNullableExpression()
+        minSpeedFactor = buffer.readNullableExpression()
+        handlingYawExpr = buffer.readNullableExpression()
+        infiniteStamina = buffer.readNullableExpression()
+        jumpExpr = buffer.readNullableExpression()
+        handlingExpr = buffer.readNullableExpression()
+        speedExpr = buffer.readNullableExpression()
+        accelerationExpr = buffer.readNullableExpression()
+        staminaExpr = buffer.readNullableExpression()
     }
 }
 
@@ -577,6 +635,7 @@ class JetState : RidingBehaviourState() {
     var boosting = ridingState(false, Side.BOTH)
     var boostIsToggleable = ridingState(false, Side.BOTH)
     var canSpeedBurst = ridingState(false, Side.BOTH)
+    var noStamTickCnt = ridingState(0, Side.CLIENT) // Value that is increased for every tick you are out of stamina
 
     override fun encode(buffer: FriendlyByteBuf) {
         super.encode(buffer)
@@ -603,6 +662,7 @@ class JetState : RidingBehaviourState() {
         boosting.set(false, forced = true)
         boostIsToggleable.set(false, forced = true)
         canSpeedBurst.set(true, forced = true)
+        noStamTickCnt.set(0, forced = true)
     }
 
     override fun copy() = JetState().also {

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

@@ -10,6 +10,7 @@ package com.cobblemon.mod.common.api.riding.behaviour.types.air
 
 import com.bedrockk.molang.Expression
 import com.bedrockk.molang.runtime.MoLangMath.lerp
+import com.cobblemon.mod.common.CobblemonRideSettings
 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
@@ -40,6 +41,8 @@ class RocketBehaviour : RidingBehaviour<RocketSettings, RocketState> {
     }
 
     override val key = KEY
+    val globalRocket: RocketSettings
+        get() = CobblemonRideSettings.rocket
 
     override fun getRidingStyle(settings: RocketSettings, state: RocketState): RidingStyle {
         return RidingStyle.AIR
@@ -84,9 +87,9 @@ class RocketBehaviour : RidingBehaviour<RocketSettings, RocketState> {
         driver: Player
     ): Float {
         // Use this as a "tick" function and check to see if the driver is "boosting"
-        if(vehicle.level().isClientSide) {
+        if (vehicle.level().isClientSide) {
             handleBoosting(settings, state, vehicle, driver)
-            tickStamina(settings, state, vehicle)
+            tickStamina(settings, state, vehicle, driver)
         }
 
         return state.rideVelocity.get().length().toFloat()
@@ -101,7 +104,6 @@ class RocketBehaviour : RidingBehaviour<RocketSettings, RocketState> {
         //If the forward key is not held then it cannot be boosting
         if(Minecraft.getInstance().options.keyUp.isDown() && state.stamina.get() != 0.0f) {
             val boostKeyPressed = Minecraft.getInstance().options.keySprint.isDown()
-            if (state.stamina.get() >= 0.25f) {
                 //If on the previous tick the boost key was held then don't change if the ride is boosting
                 if(state.boostIsToggleable.get() && boostKeyPressed) {
                     //flip the boosting state if boost key is pressed
@@ -109,7 +111,6 @@ class RocketBehaviour : RidingBehaviour<RocketSettings, RocketState> {
                 }
                 //If the boost key is not held then next tick boosting is toggleable
                 state.boostIsToggleable.set(!boostKeyPressed)
-            }
         } else {
             //Turn off boost and reset boost params
             state.boostIsToggleable.set(true)
@@ -121,18 +122,22 @@ class RocketBehaviour : RidingBehaviour<RocketSettings, RocketState> {
     fun tickStamina(
         settings: RocketSettings,
         state: RocketState,
-        vehicle: PokemonEntity
+        vehicle: PokemonEntity,
+        driver: Player
     ) {
         val stam = state.stamina.get()
 
+        if (vehicle.runtime.resolveBoolean(settings.infiniteStamina ?: globalRocket.infiniteStamina!!)) {
+            return
+        }
+
         // Grab the boost time in seconds and convert to ticks. Then calculate the drain rate as inversely
         // proportional to the number of ticks of boost thus making a full boost take x ticks
         // in short: "Stamina drains slower at higher values and also replenishes slower"
-        val boostTime = vehicle.runtime.resolveDouble(settings.staminaExpr) * 20.0f
+        val boostTime = vehicle.runtime.resolveDouble(settings.staminaExpr ?: globalRocket.staminaExpr!!) * 20.0f
         val stamDrainRate = (1.0f / boostTime).toFloat()
 
-        val newStam = if (state.boosting.get()) max(0.0f,stam - stamDrainRate)
-            else min(1.0f,stam + stamDrainRate)
+        val newStam = if(state.boosting.get() || driver.jumping) max(0.0f,stam - stamDrainRate) else stam
 
         state.stamina.set(newStam)
     }
@@ -181,13 +186,13 @@ class RocketBehaviour : RidingBehaviour<RocketSettings, RocketState> {
 
         var newMomentum = state.turnMomentum.get().toDouble()
         // Degrees per tick
-        val maxTurnMomentum = vehicle.runtime.resolveDouble(settings.maxTurnRate) / 20.0f
+        val maxTurnMomentum = vehicle.runtime.resolveDouble(settings.maxTurnRate ?: globalRocket.maxTurnRate!!) / 20.0f
         // Turn rate increase per tick. Based off number of seconds to get to max turn rate
-        val turningAcceleration = maxTurnMomentum / (vehicle.runtime.resolveDouble(settings.handlingExpr) * 20.0f)
+        val turningAcceleration = maxTurnMomentum / (vehicle.runtime.resolveDouble(settings.handlingExpr ?: globalRocket.handlingExpr!!) * 20.0f)
         val turnInput =  (driver.xxa *-1.0f) * turningAcceleration
 
         // Base boost stats off of normal turning stats
-        val boostHandlingMod = vehicle.runtime.resolveDouble(settings.boostHandlingMod)
+        val boostHandlingMod = vehicle.runtime.resolveDouble(settings.boostHandlingMod ?: globalRocket.boostHandlingMod!!)
         val boostMaxTurnMomentum = maxTurnMomentum * boostHandlingMod
         val boostTurnInput = turnInput * boostHandlingMod
 
@@ -232,9 +237,9 @@ class RocketBehaviour : RidingBehaviour<RocketSettings, RocketState> {
         vehicle: PokemonEntity,
         driver: Player
     ): Vec3 {
-        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr)
-        val accel = vehicle.runtime.resolveDouble(settings.accelerationExpr)
-        val jump = vehicle.runtime.resolveDouble(settings.jumpExpr)
+        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr ?: globalRocket.speedExpr!!)
+        val accel = vehicle.runtime.resolveDouble(settings.accelerationExpr ?: globalRocket.accelerationExpr!!)
+        val jump = vehicle.runtime.resolveDouble(settings.jumpExpr ?: globalRocket.jumpExpr!!)
 
         var newVelocity = vehicle.deltaMovement
 
@@ -258,7 +263,7 @@ class RocketBehaviour : RidingBehaviour<RocketSettings, RocketState> {
                 (newVelocity.z + (accel * forwardInput.toDouble())))
 
         } else if ((state.boosting.get())) {
-            val boostMod = vehicle.runtime.resolveDouble(settings.boostSpeedMod)
+            val boostMod = vehicle.runtime.resolveDouble(settings.boostSpeedMod ?: globalRocket.boostSpeedMod!!)
             val boostSpeed = topSpeed * boostMod
             val boostAccel = if(newVelocity.length() < boostSpeed) accel * (boostMod/1.5) else 0.0
             val forwardInput = 1.0f
@@ -266,7 +271,7 @@ class RocketBehaviour : RidingBehaviour<RocketSettings, RocketState> {
 
             if(state.canSpeedBurst.get()) {
                 burst = 0.5f
-                state.stamina.set(max(0.0f,state.stamina.get() - 0.1f))
+                state.stamina.set(max(0.0f,state.stamina.get() - 0.05f))
                 state.canSpeedBurst.set(false)
             }
 
@@ -301,7 +306,7 @@ class RocketBehaviour : RidingBehaviour<RocketSettings, RocketState> {
         } else {
             if (driver.jumping && !(vehicle.deltaMovement.y > maxVertSpeed && (newVelocity.y.sign.toFloat() > 0.0))) {
                 // More force if traveling downwards to allow for quicker fall stops
-                vertInput = if (newVelocity.y < 0) jump * 3 else jump
+                vertInput = (if (state.stamina.get() == 0.0f) -1.0f else if(newVelocity.y < 0) jump.toFloat() * 3.0f else jump.toFloat()).toDouble()
                 // Reset falldistance if upward motion is detected
                 vehicle.resetFallDistance()
                 newVelocity = Vec3(
@@ -400,8 +405,8 @@ class RocketBehaviour : RidingBehaviour<RocketSettings, RocketState> {
         driver: Player
     ): Float {
         if (state.boosting.get()) {
-            val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr)
-            val boostMod = vehicle.runtime.resolveDouble(settings.boostSpeedMod)
+            val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr ?: globalRocket.speedExpr!!)
+            val boostMod = vehicle.runtime.resolveDouble(settings.boostSpeedMod ?: globalRocket.boostSpeedMod!!)
             val normalizedBoostSpeed = RidingBehaviour.scaleToRange(state.rideVelocity.get().length(), topSpeed, topSpeed * boostMod)
             return 1.0f + normalizedBoostSpeed.pow(2).toFloat() * 0.2f
         } else {
@@ -474,6 +479,18 @@ class RocketBehaviour : RidingBehaviour<RocketSettings, RocketState> {
         return false
     }
 
+
+    override fun damageOnCollision(
+        settings: RocketSettings,
+        state: RocketState,
+        vehicle: PokemonEntity,
+        impactVec: Vec3
+    ): Boolean {
+        if (!state.boosting.get()) return false
+        val impactSpeed = impactVec.horizontalDistance().toFloat() * 10f
+        return vehicle.causeFallDamage(impactSpeed, 1f, vehicle.damageSources().flyIntoWall())
+    }
+
     override fun getRideSounds(
         settings: RocketSettings,
         state: RocketState,
@@ -489,60 +506,67 @@ class RocketSettings : RidingBehaviourSettings {
     override val key = RocketBehaviour.KEY
     override val stats = mutableMapOf<RidingStat, IntRange>()
 
+    var infiniteStamina: Expression? = null
+        private set
     // Boost multiplier for speed
-    var boostSpeedMod: Expression = "5.0".asExpression()
+    var boostSpeedMod: Expression? = null
         private set
 
     // Boost multiplier for handling
-    var boostHandlingMod: Expression = "0.3".asExpression()
+    var boostHandlingMod: Expression? = null
         private set
 
     // Max turn rate in degrees per second
-    var maxTurnRate: Expression = "100.0".asExpression()
+    var maxTurnRate: Expression? = null
         private set
 
-    var speedExpr: Expression = "q.get_ride_stats('SPEED', 'AIR', 1.2, 0.6)".asExpression()
+    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 =
-        "q.get_ride_stats('ACCELERATION', 'AIR', (1.0 / (20.0 * 1.5)), (1.0 / (20.0 * 3.0))) * 0.5".asExpression()
+    var accelerationExpr: Expression? = null
         private set
 
-    // Boost time in seconds
-    var staminaExpr: Expression = "q.get_ride_stats('STAMINA', 'AIR', 7.5, 2.5)".asExpression()
+    // air time in seconds
+    var staminaExpr: Expression? = null
         private set
 
-    var jumpExpr: Expression = "q.get_ride_stats('JUMP', 'AIR', 2.0, 1.0)".asExpression()
+    var jumpExpr: Expression? = null
         private set
 
     // How long it takes to get to max turn rate from rest (in seconds)
-    var handlingExpr: Expression = "q.get_ride_stats('SKILL', 'AIR', 0.5, 3.0)".asExpression()
+    var handlingExpr: Expression? = null
         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.writeNullableExpression(infiniteStamina)
+        buffer.writeNullableExpression(boostSpeedMod)
+        buffer.writeNullableExpression(boostHandlingMod)
+        buffer.writeNullableExpression(maxTurnRate)
+        buffer.writeNullableExpression(speedExpr)
+        buffer.writeNullableExpression(accelerationExpr)
+        buffer.writeNullableExpression(staminaExpr)
+        buffer.writeNullableExpression(jumpExpr)
+        buffer.writeNullableExpression(handlingExpr)
     }
 
     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()
+        infiniteStamina = buffer.readNullableExpression()
+        boostSpeedMod = buffer.readNullableExpression()
+        boostHandlingMod = buffer.readNullableExpression()
+        maxTurnRate = buffer.readNullableExpression()
+        speedExpr = buffer.readNullableExpression()
+        accelerationExpr = buffer.readNullableExpression()
+        staminaExpr = buffer.readNullableExpression()
+        jumpExpr = buffer.readNullableExpression()
+        handlingExpr = buffer.readNullableExpression()
     }
-
 }
 
 class RocketState : RidingBehaviourState() {

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

@@ -387,9 +387,10 @@ open class CompositeSettings : RidingBehaviourSettings {
 
     override fun encode(buffer: RegistryFriendlyByteBuf) {
         buffer.writeRidingStats(stats)
-        buffer.writeResourceLocation(key)
         buffer.writeResourceLocation(transitionStrategy)
+        buffer.writeResourceLocation(defaultBehaviour.key)
         defaultBehaviour.encode(buffer)
+        buffer.writeResourceLocation(alternateBehaviour.key)
         alternateBehaviour.encode(buffer)
     }
 

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

@@ -41,6 +41,10 @@ interface CompositeRidingStrategy<T : CompositeSettings> {
         toState: RidingBehaviourState,
         toSettings: RidingBehaviourSettings
     ) {
+        if (vehicle.level().isClientSide) {
+            val fromSettings = if (settings.defaultBehaviour == toSettings) settings.alternateBehaviour else settings.defaultBehaviour
+
+        }
         toState.stamina.set(fromState.stamina.get())
         toState.rideVelocity.set(fromState.rideVelocity.get())
         fromState.reset()

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

@@ -9,15 +9,34 @@
 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.api.riding.RidingStyle
-import com.cobblemon.mod.common.api.riding.behaviour.*
+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.entity.PoseType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.*
+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 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.network.FriendlyByteBuf
 import net.minecraft.network.RegistryFriendlyByteBuf
@@ -30,7 +49,6 @@ import net.minecraft.world.entity.player.Player
 import net.minecraft.world.phys.Vec2
 import net.minecraft.world.phys.Vec3
 import net.minecraft.world.phys.shapes.Shapes
-import kotlin.math.*
 
 class HorseBehaviour : RidingBehaviour<HorseSettings, HorseState> {
     companion object {
@@ -38,6 +56,8 @@ class HorseBehaviour : RidingBehaviour<HorseSettings, HorseState> {
     }
 
     override val key = KEY
+    val globalHorse: HorseSettings
+        get() = CobblemonRideSettings.horse
 
     override fun getRidingStyle(settings: HorseSettings, state: HorseState): RidingStyle {
         return RidingStyle.LAND
@@ -132,8 +152,13 @@ class HorseBehaviour : RidingBehaviour<HorseSettings, HorseState> {
         vehicle: PokemonEntity,
     ) {
         val stam = state.stamina.get()
+
+        if (vehicle.runtime.resolveBoolean(settings.infiniteStamina ?: globalHorse.infiniteStamina!!)) {
+            return
+        }
+
         var newStam = stam
-        val stamDrainRate = (1.0f / vehicle.runtime.resolveDouble(settings.staminaExpr)).toFloat() / 20.0f
+        val stamDrainRate = (1.0f / vehicle.runtime.resolveDouble(settings.staminaExpr ?: globalHorse.staminaExpr!!)).toFloat() / 20.0f
 
         if (state.sprinting.get()) {
             newStam = max(0.0f,stam - stamDrainRate)
@@ -183,10 +208,10 @@ class HorseBehaviour : RidingBehaviour<HorseSettings, HorseState> {
         vehicle: PokemonEntity,
         driver: LivingEntity
     ): Float {
-        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr)
-        val handling = vehicle.runtime.resolveDouble(settings.handlingExpr)
+        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr ?: globalHorse.speedExpr!!)
+        val handling = vehicle.runtime.resolveDouble(settings.handlingExpr ?: globalHorse.handlingExpr!!)
         val walkHandlingBoost = 5
-        val maxYawDiff = vehicle.runtime.resolveFloat(settings.lookYawLimit)
+        val maxYawDiff = vehicle.runtime.resolveFloat(settings.lookYawLimit ?: globalHorse.lookYawLimit!!)
 
         // Normalize the current rotation diff
         val rotDiff = Mth.wrapDegrees(driver.yRot - vehicle.yRot).coerceIn(-maxYawDiff,maxYawDiff)
@@ -230,21 +255,34 @@ class HorseBehaviour : RidingBehaviour<HorseSettings, HorseState> {
         vehicle: PokemonEntity,
         driver: Player
     ): Vec3 {
-        val canSprint = vehicle.runtime.resolveBoolean(settings.canSprint)
-        val canJump = vehicle.runtime.resolveBoolean(settings.canJump)
-        val jumpForce = vehicle.runtime.resolveDouble(settings.jumpExpr) * 0.75
-        val rideTopSpeed = vehicle.runtime.resolveDouble(settings.speedExpr)
+        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 accel = topSpeed / (vehicle.runtime.resolveDouble(settings.accelerationExpr) * 20.0)
+        val accel = topSpeed / (vehicle.runtime.resolveDouble(settings.accelerationExpr ?: globalHorse.accelerationExpr!!) * 20.0)
         var activeInput = false
 
         /******************************************************
          * Gather the previous velocity and check for horizontal
          * collisions
          *****************************************************/
+        val dmSpeed = vehicle.deltaMovement.length()
+        val rvSpeed = state.rideVelocity.get().length()
         var newVelocity = state.rideVelocity.get() //.normalize().scale(vehicle.deltaMovement.horizontalDistance())
 
+        /******************************************************
+         * Gather the previous velocity and check for horizontal
+         * collisions
+         *****************************************************/
+//        if (dmSpeed > rvSpeed) {
+//            // align the velocity vector to be in local vehicle space
+//            newVelocity = vehicle.deltaMovement
+//            val yawAligned = Matrix3f().rotateY(-vehicle.yRot.toRadians())
+//            newVelocity = (newVelocity.toVector3f().mul(yawAligned)).toVec3d()
+//        }
+
         if (vehicle.horizontalCollision) {
             newVelocity = newVelocity.normalize().scale(vehicle.deltaMovement.length())
         }
@@ -256,7 +294,7 @@ class HorseBehaviour : RidingBehaviour<HorseSettings, HorseState> {
 
             // 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)
+            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)
@@ -498,59 +536,67 @@ class HorseSettings : RidingBehaviourSettings {
     override val key = HorseBehaviour.KEY
     override val stats = mutableMapOf<RidingStat, IntRange>()
 
-    var canJump = "true".asExpression()
+    var infiniteStamina: Expression? = null
+        private set
+    var canJump: Expression? = null
         private set
 
-    var canSprint = "true".asExpression()
+    var canSprint: Expression? = null
         private set
 
-    var lookYawLimit = "90.0f".asExpression()
+    var lookYawLimit: Expression? = null
         private set
 
-    var speedExpr: Expression = "q.get_ride_stats('SPEED', 'LAND', 1.0, 0.4)".asExpression()
+    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 =
-        "q.get_ride_stats('ACCELERATION', 'LAND', 0.5, 2.0)".asExpression()
+    var accelerationExpr: Expression? = null
         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()
+    var staminaExpr: Expression? = null
         private set
 
     //Between a one block jump and a six block jump
-    var jumpExpr: Expression = "q.get_ride_stats('JUMP', 'LAND', 1.2, 0.45)".asExpression()
+    var jumpExpr: Expression? = null
         private set
 
-    var handlingExpr: Expression = "q.get_ride_stats('SKILL', 'LAND', 180.0, 40.0)".asExpression()
+    var handlingExpr: Expression? = null
         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)
+        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)
-        speedExpr = buffer.readExpression()
-        accelerationExpr = buffer.readExpression()
-        staminaExpr = buffer.readExpression()
-        jumpExpr = buffer.readExpression()
-        handlingExpr = buffer.readExpression()
-        canJump = buffer.readExpression()
-        canSprint = buffer.readExpression()
+        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()
     }
 }
 

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

@@ -10,18 +10,36 @@ package com.cobblemon.mod.common.api.riding.behaviour.types.land
 
 import com.bedrockk.molang.Expression
 import com.bedrockk.molang.runtime.MoLangMath.lerp
-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.*
+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.SidedRidingState
+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.entity.PoseType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.*
+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.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 kotlin.math.abs
+import kotlin.math.max
+import kotlin.math.min
+import kotlin.math.pow
+import kotlin.math.sign
 import net.minecraft.core.Direction
 import net.minecraft.network.FriendlyByteBuf
 import net.minecraft.network.RegistryFriendlyByteBuf
@@ -32,12 +50,6 @@ import net.minecraft.world.entity.player.Player
 import net.minecraft.world.phys.Vec2
 import net.minecraft.world.phys.Vec3
 import net.minecraft.world.phys.shapes.Shapes
-import org.joml.Matrix3f
-import kotlin.math.abs
-import kotlin.math.max
-import kotlin.math.min
-import kotlin.math.pow
-import kotlin.math.sign
 
 class MinekartBehaviour : RidingBehaviour<MinekartSettings, MinekartState> {
     companion object {
@@ -45,6 +57,8 @@ class MinekartBehaviour : RidingBehaviour<MinekartSettings, MinekartState> {
     }
 
     override val key = KEY
+    val globalMinekart: MinekartSettings
+        get() = CobblemonRideSettings.minekart
 
     override fun getRidingStyle(settings: MinekartSettings, state: MinekartState): RidingStyle {
         return RidingStyle.LAND
@@ -84,7 +98,7 @@ class MinekartBehaviour : RidingBehaviour<MinekartSettings, MinekartState> {
         driver: Player
     ): Float {
 
-        val boostMax = vehicle.runtime.resolveFloat(settings.boostLimit)
+        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
         val boostLoss = 40.0f
@@ -142,8 +156,8 @@ class MinekartBehaviour : RidingBehaviour<MinekartSettings, MinekartState> {
         var newMomentum = state.turnMomentum.get().toDouble()
 
         //TODO: maybe tie this to max turnspeeds rather than the turn acceleration
-        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr)
-        val turningAcceleration = (vehicle.runtime.resolveDouble(settings.handlingExpr) * 1.5 / 20.0f) / 20.0f * 4.0
+        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr ?: globalMinekart.speedExpr!!)
+        val turningAcceleration = (vehicle.runtime.resolveDouble(settings.handlingExpr ?: globalMinekart.handlingExpr!!) * 1.5 / 20.0f) / 20.0f * 4.0
         val turnInput =  (driver.xxa *-1.0f) * turningAcceleration
         val driftInput = turnInput * 0.25f
 
@@ -202,9 +216,9 @@ class MinekartBehaviour : RidingBehaviour<MinekartSettings, MinekartState> {
     ): Vec3 {
 
         // Check to see if the ride should be walking or sprinting
-        val rideTopSpeed = vehicle.runtime.resolveDouble(settings.speedExpr) * 0.6 * 2.0
+        val rideTopSpeed = vehicle.runtime.resolveDouble(settings.speedExpr ?: globalMinekart.speedExpr!!) * 0.6 * 2.0
         val topSpeed = if (state.drifting.get()) rideTopSpeed * 0.7 else rideTopSpeed
-        val accel = vehicle.runtime.resolveDouble(settings.accelerationExpr) * 0.3 * 3 * 2.0
+        val accel = vehicle.runtime.resolveDouble(settings.accelerationExpr ?: globalMinekart.accelerationExpr!!) * 0.3 * 3 * 2.0
         val driftAngle = 20.0f
 
         //Align the direction of this vector with the vehicles current heading.
@@ -327,7 +341,7 @@ class MinekartBehaviour : RidingBehaviour<MinekartSettings, MinekartState> {
         vehicle: PokemonEntity,
         driver: Player
     ): Boolean {
-        return vehicle.runtime.resolveBoolean(settings.canJump)
+        return vehicle.runtime.resolveBoolean(settings.canJump ?: globalMinekart.canJump!!)
     }
 
     override fun setRideBar(
@@ -447,45 +461,57 @@ class MinekartSettings : RidingBehaviourSettings {
     override val key = MinekartBehaviour.KEY
     override val stats = mutableMapOf<RidingStat, IntRange>()
 
-    var canJump = "true".asExpression()
+    var infiniteStamina: Expression? = null
+        private set
+    var canJump: Expression? = null
         private set
 
-    var boostLimit = "100.0f".asExpression()
+    var boostLimit: Expression? = null
         private set
 
-    var speedExpr: Expression = "q.get_ride_stats('SPEED', 'LAND', 1.0, 0.3)".asExpression()
+    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 =
-        "q.get_ride_stats('ACCELERATION', 'LAND', (1.0 / (20.0 * 1.5)), (1.0 / (20.0 * 5.0)))".asExpression()
+    var accelerationExpr: Expression? = null
         private set
 
-    var staminaExpr: Expression = "q.get_ride_stats('STAMINA', 'LAND', 30.0, 10.0)".asExpression()
+    var staminaExpr: Expression? = null
         private set
 
     //Between a one block jump and a ten block jump
-    var jumpExpr: Expression = "q.get_ride_stats('JUMP', 'LAND', 10.0, 1.0)".asExpression()
+    var jumpExpr: Expression? = null
         private set
 
-    var handlingExpr: Expression = "q.get_ride_stats('SKILL', 'LAND', 140.0, 20.0)".asExpression()
+    var handlingExpr: Expression? = null
         private set
 
     var rideSounds: RideSoundSettingsList = RideSoundSettingsList()
 
     override fun encode(buffer: RegistryFriendlyByteBuf) {
-        buffer.writeResourceLocation(key)
         buffer.writeRidingStats(stats)
         rideSounds.encode(buffer)
-        buffer.writeExpression(canJump)
-        buffer.writeExpression(boostLimit)
+        buffer.writeNullableExpression(infiniteStamina)
+        buffer.writeNullableExpression(canJump)
+        buffer.writeNullableExpression(boostLimit)
+        buffer.writeNullableExpression(speedExpr)
+        buffer.writeNullableExpression(accelerationExpr)
+        buffer.writeNullableExpression(staminaExpr)
+        buffer.writeNullableExpression(jumpExpr)
+        buffer.writeNullableExpression(handlingExpr)
     }
 
     override fun decode(buffer: RegistryFriendlyByteBuf) {
         stats.putAll(buffer.readRidingStats())
         rideSounds = RideSoundSettingsList.decode(buffer)
-        canJump = buffer.readExpression()
-        boostLimit = buffer.readExpression()
+        infiniteStamina = buffer.readNullableExpression()
+        canJump = buffer.readNullableExpression()
+        boostLimit = buffer.readNullableExpression()
+        speedExpr = buffer.readNullableExpression()
+        accelerationExpr = buffer.readNullableExpression()
+        staminaExpr = buffer.readNullableExpression()
+        jumpExpr = buffer.readNullableExpression()
+        handlingExpr = buffer.readNullableExpression()
     }
 }
 

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

@@ -10,18 +10,35 @@ package com.cobblemon.mod.common.api.riding.behaviour.types.land
 
 import com.bedrockk.molang.Expression
 import com.bedrockk.molang.runtime.MoLangMath.lerp
-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.*
+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.SidedRidingState
+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.entity.PoseType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.*
+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.resolveBoolean
+import com.cobblemon.mod.common.util.resolveDouble
+import com.cobblemon.mod.common.util.toVec3d
+import com.cobblemon.mod.common.util.writeNullableExpression
+import com.cobblemon.mod.common.util.writeRidingStats
+import kotlin.math.abs
+import kotlin.math.max
+import kotlin.math.min
+import kotlin.math.sign
 import net.minecraft.core.Direction
 import net.minecraft.network.FriendlyByteBuf
 import net.minecraft.network.RegistryFriendlyByteBuf
@@ -33,10 +50,6 @@ import net.minecraft.world.phys.Vec2
 import net.minecraft.world.phys.Vec3
 import net.minecraft.world.phys.shapes.Shapes
 import org.joml.Matrix3f
-import kotlin.math.abs
-import kotlin.math.max
-import kotlin.math.min
-import kotlin.math.sign
 
 class VehicleBehaviour : RidingBehaviour<VehicleSettings, VehicleState> {
     companion object {
@@ -44,6 +57,8 @@ class VehicleBehaviour : RidingBehaviour<VehicleSettings, VehicleState> {
     }
 
     override val key = KEY
+    val globalVehicle: VehicleSettings
+        get() = CobblemonRideSettings.vehicle
 
     override fun getRidingStyle(settings: VehicleSettings, state: VehicleState): RidingStyle {
         return RidingStyle.LAND
@@ -126,7 +141,7 @@ class VehicleBehaviour : RidingBehaviour<VehicleSettings, VehicleState> {
         var newMomentum = state.turnMomentum.get().toDouble()
 
         // Grab turningAcceleration and divide 20 twice to get
-        val turningAcceleration = (vehicle.runtime.resolveDouble(settings.handlingExpr) * 1.5 / 20.0f) / 20.0f * 4.0
+        val turningAcceleration = (vehicle.runtime.resolveDouble(settings.handlingExpr ?: globalVehicle.handlingExpr!!) * 1.5 / 20.0f) / 20.0f * 4.0
         val turnInput =  (driver.xxa *-1.0f) * turningAcceleration
 
         val maxTurnMomentum = 80.0f / 20.0f
@@ -137,7 +152,7 @@ class VehicleBehaviour : RidingBehaviour<VehicleSettings, VehicleState> {
 
         if(state.drifting.get() || state.inAir.get()) {
             if( newMomentum < driftMaxTurnMomentum) {
-                driftTurnInput = driftTurnInput * (vehicle.deltaMovement.horizontalDistance() / vehicle.runtime.resolveDouble(settings.speedExpr))
+                driftTurnInput = driftTurnInput * (vehicle.deltaMovement.horizontalDistance() / vehicle.runtime.resolveDouble(settings.speedExpr ?: globalVehicle.speedExpr!!))
                 newMomentum += driftTurnInput
             }
             newMomentum = lerp(newMomentum, 0.0, 0.03)
@@ -177,10 +192,10 @@ class VehicleBehaviour : RidingBehaviour<VehicleSettings, VehicleState> {
 
         // Check to see if the ride should be walking or sprinting
         //val walkSpeed = getWalkSpeed(vehicle)
-        val rideTopSpeed = vehicle.runtime.resolveDouble(settings.speedExpr) * 0.6 * 2.0
+        val rideTopSpeed = vehicle.runtime.resolveDouble(settings.speedExpr ?: globalVehicle.speedExpr!!) * 0.6 * 2.0
         val topSpeed = if (state.drifting.get()) rideTopSpeed * 0.5 else rideTopSpeed
 
-        val accel = vehicle.runtime.resolveDouble(settings.accelerationExpr) * 0.3 * 3 * 2.0
+        val accel = vehicle.runtime.resolveDouble(settings.accelerationExpr ?: globalVehicle.accelerationExpr!!) * 0.3 * 3 * 2.0
 
         //Flag for determining if player is actively inputting
         var activeInput = false
@@ -250,7 +265,7 @@ class VehicleBehaviour : RidingBehaviour<VehicleSettings, VehicleState> {
         }
 
         //TODO: Change this so its tied to a jumping stat and representative of the amount of jumps
-        val canJump = vehicle.runtime.resolveBoolean(settings.canJump)
+        val canJump = vehicle.runtime.resolveBoolean(settings.canJump ?: globalVehicle.canJump!!)
         //Jump the thang!
         if (driver.jumping && vehicle.onGround() && canJump) {
             val jumpForce = 0.5
@@ -296,7 +311,7 @@ class VehicleBehaviour : RidingBehaviour<VehicleSettings, VehicleState> {
         vehicle: PokemonEntity,
         driver: Player
     ): Boolean {
-        return vehicle.runtime.resolveBoolean(settings.canJump)
+        return vehicle.runtime.resolveBoolean(settings.canJump ?: globalVehicle.canJump!!)
     }
 
     override fun setRideBar(
@@ -412,66 +427,79 @@ class VehicleSettings : RidingBehaviourSettings {
     override val key = VehicleBehaviour.KEY
     override val stats = mutableMapOf<RidingStat, IntRange>()
 
-    var canJump = "true".asExpression()
+    var infiniteStamina: Expression? = null
         private set
 
-    var speed = "0.3".asExpression()
+    var canJump: Expression? = null
         private set
 
-    var driveFactor = "1.0".asExpression()
+    var speed: Expression? = null
         private set
 
-    var reverseDriveFactor = "0.25".asExpression()
+    var driveFactor: Expression? = null
         private set
 
-    var rotationSpeed = "45/20".asExpression()
+    var reverseDriveFactor: Expression? = null
         private set
 
-    var lookYawLimit = "101".asExpression()
+    var rotationSpeed: Expression? = null
         private set
 
-    var speedExpr: Expression = "q.get_ride_stats('SPEED', 'LAND', 1.0, 0.3)".asExpression()
+    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 =
-        "q.get_ride_stats('ACCELERATION', 'LAND', (1.0 / (20.0 * 1.5)), (1.0 / (20.0 * 5.0)))".asExpression()
+    var accelerationExpr: Expression? = null
         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()
+    var staminaExpr: Expression? = null
         private set
 
     //Between a one block jump and a ten block jump
-    var jumpExpr: Expression = "q.get_ride_stats('JUMP', 'LAND', 10.0, 1.0)".asExpression()
+    var jumpExpr: Expression? = null
         private set
 
-    var handlingExpr: Expression = "q.get_ride_stats('SKILL', 'LAND', 140.0, 20.0)".asExpression()
+    var handlingExpr: Expression? = null
         private set
 
     var rideSounds: RideSoundSettingsList = RideSoundSettingsList()
 
     override fun encode(buffer: RegistryFriendlyByteBuf) {
-        buffer.writeResourceLocation(key)
         buffer.writeRidingStats(stats)
         rideSounds.encode(buffer)
-        buffer.writeExpression(canJump)
-        buffer.writeExpression(speed)
-        buffer.writeExpression(driveFactor)
-        buffer.writeExpression(reverseDriveFactor)
-        buffer.writeExpression(rotationSpeed)
-        buffer.writeExpression(lookYawLimit)
+        buffer.writeNullableExpression(infiniteStamina)
+        buffer.writeNullableExpression(canJump)
+        buffer.writeNullableExpression(speed)
+        buffer.writeNullableExpression(driveFactor)
+        buffer.writeNullableExpression(reverseDriveFactor)
+        buffer.writeNullableExpression(rotationSpeed)
+        buffer.writeNullableExpression(lookYawLimit)
+        buffer.writeNullableExpression(speedExpr)
+        buffer.writeNullableExpression(accelerationExpr)
+        buffer.writeNullableExpression(staminaExpr)
+        buffer.writeNullableExpression(jumpExpr)
+        buffer.writeNullableExpression(handlingExpr)
     }
 
     override fun decode(buffer: RegistryFriendlyByteBuf) {
         stats.putAll(buffer.readRidingStats())
         rideSounds = RideSoundSettingsList.decode(buffer)
-        canJump = buffer.readExpression()
-        speed = buffer.readExpression()
-        driveFactor = buffer.readExpression()
-        reverseDriveFactor = buffer.readExpression()
-        rotationSpeed = buffer.readExpression()
-        lookYawLimit = buffer.readExpression()
+        infiniteStamina = buffer.readNullableExpression()
+        canJump = buffer.readNullableExpression()
+        speed = buffer.readNullableExpression()
+        driveFactor = buffer.readNullableExpression()
+        reverseDriveFactor = buffer.readNullableExpression()
+        rotationSpeed = buffer.readNullableExpression()
+        lookYawLimit = buffer.readNullableExpression()
+        speedExpr = buffer.readNullableExpression()
+        accelerationExpr = buffer.readNullableExpression()
+        staminaExpr = buffer.readNullableExpression()
+        jumpExpr = buffer.readNullableExpression()
+        handlingExpr = buffer.readNullableExpression()
     }
 }
 

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

@@ -8,16 +8,34 @@
 
 package com.cobblemon.mod.common.api.riding.behaviour.types.liquid
 
+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.*
+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.entity.PoseType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.*
+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 kotlin.math.abs
+import kotlin.math.max
+import kotlin.math.min
+import net.minecraft.core.BlockPos
 import net.minecraft.network.RegistryFriendlyByteBuf
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.util.Mth
@@ -27,9 +45,6 @@ import net.minecraft.world.entity.player.Player
 import net.minecraft.world.phys.Vec2
 import net.minecraft.world.phys.Vec3
 import net.minecraft.world.phys.shapes.Shapes
-import kotlin.math.abs
-import kotlin.math.max
-import kotlin.math.min
 
 class BoatBehaviour : RidingBehaviour<BoatSettings, BoatState> {
     companion object {
@@ -37,6 +52,8 @@ class BoatBehaviour : RidingBehaviour<BoatSettings, BoatState> {
     }
 
     override val key = KEY
+    val globalBoat: BoatSettings
+        get() = CobblemonRideSettings.boat
 
     override fun getRidingStyle(settings: BoatSettings, state: BoatState): RidingStyle {
         return RidingStyle.LIQUID
@@ -86,12 +103,12 @@ class BoatBehaviour : RidingBehaviour<BoatSettings, BoatState> {
 
         if (!state.isVehicleSprinting.get()) {
             if (state.staminaBuffer.get() >= 20) {
-                val staminaIncrease = vehicle.runtime.resolveDouble(settings.staminaIncreaseExpr)
-                state.stamina.set(min(1.0f, state.stamina.get() + 0.01f * staminaIncrease.toFloat()))
+                val staminaIncrease = (1.0f / vehicle.runtime.resolveDouble(settings.stamReplenishTimeSeconds ?: globalBoat.stamReplenishTimeSeconds!!) ).toFloat() / 20.0f
+                state.stamina.set(min(1.0f, state.stamina.get() + staminaIncrease))
             }
         }
         else if (abs(state.rideVelocity.get().z) > 0.1 && state.isVehicleSprinting.get()) {
-            consumeStamina(vehicle, driver, settings, state, 0.01f)
+            consumeStamina(vehicle, driver, settings, state)
         }
         state.staminaBuffer.set(state.staminaBuffer.get() + 1)
         super.tick(settings, state, vehicle, driver, input)
@@ -133,14 +150,14 @@ class BoatBehaviour : RidingBehaviour<BoatSettings, BoatState> {
     }
 
     private fun applyVelocityFromInput(velocity: Vec3, vehicle: PokemonEntity, driver: Player, settings: BoatSettings, state: BoatState): Vec3 {
-        val speed = vehicle.runtime.resolveDouble(settings.speedExpr)
-        val acceleration = vehicle.runtime.resolveDouble(settings.accelerationExpr)
+        val speed = vehicle.runtime.resolveDouble(settings.speedExpr ?: globalBoat.speedExpr!!)
+        val acceleration = speed / (vehicle.runtime.resolveDouble(settings.accelerationExpr ?: globalBoat.accelerationExpr!!) * 20)
 
         if (state.jumpBuffer.get() != -1 || !(vehicle.isInWater || vehicle.isUnderWater)) {
             return velocity
         }
 
-        val sprintModifier = vehicle.runtime.resolveDouble(settings.sprintSpeedModifier)
+        val sprintModifier = vehicle.runtime.resolveDouble(settings.sprintSpeedModifier ?: globalBoat.sprintSpeedModifier!!)
         val activeSprintModifier = if (state.isVehicleSprinting.get() && hasStamina(state)) sprintModifier else 1.0
         val forwardInput = driver.zza.toDouble()
         val delta = when {
@@ -163,23 +180,34 @@ class BoatBehaviour : RidingBehaviour<BoatSettings, BoatState> {
         if (!driver.jumping) return velocity // Not jumping
         if (state.jumpBuffer.get() != -1) return velocity // Already jumped very recently
 
-        val jumpStrength = vehicle.runtime.resolveDouble(settings.jumpStrengthExpr)
+        val jumpStrength = vehicle.runtime.resolveDouble(settings.jumpStrengthExpr ?: globalBoat.jumpStrengthExpr!!)
         state.jumpBuffer.set(0)
         return Vec3(velocity.x, velocity.y + jumpStrength, velocity.z)
     }
 
     private fun applyGravity(velocity: Vec3, vehicle: PokemonEntity, settings: BoatSettings, state: BoatState): Vec3 {
         if (state.jumpBuffer.get() == -1 && (vehicle.isInWater || vehicle.isUnderWater)) {
-            val verticalVelocity = if (vehicle.isUnderWater) 0.5 else 0.0
-            return Vec3(velocity.x, verticalVelocity, velocity.z)
+            if (shouldFloatHigher(vehicle, settings)) {
+                return Vec3(velocity.x, 0.5, velocity.z)
+            }
+            else {
+                return Vec3(velocity.x, 0.0, velocity.z)
+            }
         }
-        val terminalVelocity = vehicle.runtime.resolveDouble(settings.terminalVelocity)
+        val terminalVelocity = vehicle.runtime.resolveDouble(settings.terminalVelocity ?: globalBoat.terminalVelocity!!)
         val gravity = (9.8 / ( 20.0)) * 0.2
         return Vec3(velocity.x, max(velocity.y - gravity, terminalVelocity), velocity.z)
     }
 
+    private fun shouldFloatHigher(vehicle: PokemonEntity, settings: BoatSettings): Boolean {
+        val surfaceOffset = vehicle.runtime.resolveFloat(settings.surfaceLevelOffset ?: globalBoat.surfaceLevelOffset!!)
+        val blockPos = BlockPos.containing(vehicle.x, vehicle.eyeY + surfaceOffset, vehicle.z)
+        val fluidState = vehicle.level().getFluidState(blockPos)
+        return !fluidState.isEmpty
+    }
+
     private fun applyStrafeRotation(vehicle: PokemonEntity, driver: Player, settings: BoatSettings, state: BoatState) {
-        val skillModifier = vehicle.runtime.resolveDouble(settings.rotationspeedModifierExpr)
+        val skillModifier = vehicle.runtime.resolveDouble(settings.rotationSpeedModifierExpr ?: globalBoat.rotationSpeedModifierExpr!!)
         val strafe = driver.xxa
         if (abs(strafe) > 0) {
             val increase = if (strafe > 0) -1 else 1
@@ -191,9 +219,12 @@ class BoatBehaviour : RidingBehaviour<BoatSettings, BoatState> {
         return state.stamina.get() != 0f
     }
 
-    private fun consumeStamina(vehicle: PokemonEntity, driver: Player, settings: BoatSettings, state: BoatState, drain: Float) {
-        val staminaModifier = vehicle.runtime.resolveFloat(settings.staminaDecreaseExpr)
-        state.stamina.set(max(0f, state.stamina.get() - drain / staminaModifier))
+    private fun consumeStamina(vehicle: PokemonEntity, driver: Player, settings: BoatSettings, state: BoatState) {
+        if (vehicle.runtime.resolveBoolean(settings.infiniteStamina ?: globalBoat.infiniteStamina!!)) {
+            return
+        }
+        val stamDrainRate = (1.0f / vehicle.runtime.resolveDouble(settings.staminaExpr ?: globalBoat.staminaExpr!!)).toFloat() / 20.0f
+        state.stamina.set(max(0f, state.stamina.get() - stamDrainRate))
         if (state.stamina.get() == 0f) {
             state.isVehicleSprinting.set(false)
             driver.isSprinting = false
@@ -298,7 +329,7 @@ class BoatBehaviour : RidingBehaviour<BoatSettings, BoatState> {
         vehicle: PokemonEntity,
         driver: Player
     ): Float {
-        val sprintFov = vehicle.runtime.resolveFloat(settings.sprintFovModifier)
+        val sprintFov = vehicle.runtime.resolveFloat(settings.sprintFovModifier ?: globalBoat.sprintFovModifier!!)
         return if (state.isVehicleSprinting.get()) sprintFov else 1.0f
     }
 
@@ -343,7 +374,7 @@ class BoatBehaviour : RidingBehaviour<BoatSettings, BoatState> {
         state: BoatState,
         vehicle: PokemonEntity
     ): Boolean {
-        return vehicle.runtime.resolveBoolean(settings.rotatePokemonHead)
+        return vehicle.runtime.resolveBoolean(settings.rotatePokemonHead ?: globalBoat.rotatePokemonHead!!)
     }
 
     override fun shouldRotateRiderHead(
@@ -373,46 +404,72 @@ class BoatSettings : RidingBehaviourSettings {
     override val stats = mutableMapOf<RidingStat, IntRange>()
     var rideSounds: RideSoundSettingsList = RideSoundSettingsList()
 
-    var terminalVelocity = "-2.0".asExpression()
+    var infiniteStamina: Expression? = null
         private set
 
-    var rotatePokemonHead = "true".asExpression()
+    var terminalVelocity: Expression? = null
         private set
 
-    var staminaIncreaseExpr = "q.get_ride_stats('STAMINA', 'LIQUID', 2.0, 1.0)".asExpression()
+    var rotatePokemonHead: Expression? = null
         private set
 
-    var staminaDecreaseExpr = "q.get_ride_stats('STAMINA', 'LIQUID', 5.0, 1.0)".asExpression()
+    var stamReplenishTimeSeconds: Expression? = null
         private set
 
-    var rotationspeedModifierExpr = "q.get_ride_stats('SKILL', 'LIQUID', 1.5, 0.5)".asExpression()
+    var staminaExpr: Expression? = null
         private set
 
-    var jumpStrengthExpr = "q.get_ride_stats('JUMP', 'LIQUID', 2.5, 1.0)".asExpression()
+    var rotationSpeedModifierExpr: Expression? = null
         private set
 
-    var speedExpr = "q.get_ride_stats('SPEED', 'LIQUID', 2.0, 0.5)".asExpression()
+    var jumpStrengthExpr: Expression? = null
         private set
 
-    var accelerationExpr = "q.get_ride_stats('ACCELERATION', 'LIQUID', 0.5, 0.05)".asExpression()
+    var speedExpr: Expression? = null
         private set
 
-    var sprintSpeedModifier = "1.5".asExpression()
+    var accelerationExpr: Expression? = null
         private set
 
-    var sprintFovModifier = "1.2".asExpression()
+    var sprintSpeedModifier: Expression? = null
+        private set
+
+    var sprintFovModifier: Expression? = null
+
+    var surfaceLevelOffset: Expression? = null
 
     override fun encode(buffer: RegistryFriendlyByteBuf) {
-        buffer.writeResourceLocation(key)
         buffer.writeRidingStats(stats)
         rideSounds.encode(buffer)
-        buffer.writeExpression(terminalVelocity)
+        buffer.writeNullableExpression(infiniteStamina)
+        buffer.writeNullableExpression(terminalVelocity)
+        buffer.writeNullableExpression(rotatePokemonHead)
+        buffer.writeNullableExpression(stamReplenishTimeSeconds)
+        buffer.writeNullableExpression(staminaExpr)
+        buffer.writeNullableExpression(rotationSpeedModifierExpr)
+        buffer.writeNullableExpression(jumpStrengthExpr)
+        buffer.writeNullableExpression(speedExpr)
+        buffer.writeNullableExpression(accelerationExpr)
+        buffer.writeNullableExpression(sprintSpeedModifier)
+        buffer.writeNullableExpression(sprintFovModifier)
+        buffer.writeNullableExpression(surfaceLevelOffset)
     }
 
     override fun decode(buffer: RegistryFriendlyByteBuf) {
         stats.putAll(buffer.readRidingStats())
         rideSounds = RideSoundSettingsList.decode(buffer)
-        terminalVelocity = buffer.readExpression()
+        infiniteStamina = buffer.readNullableExpression()
+        terminalVelocity = buffer.readNullableExpression()
+        rotatePokemonHead = buffer.readNullableExpression()
+        stamReplenishTimeSeconds = buffer.readNullableExpression()
+        staminaExpr = buffer.readNullableExpression()
+        rotationSpeedModifierExpr = buffer.readNullableExpression()
+        jumpStrengthExpr = buffer.readNullableExpression()
+        speedExpr = buffer.readNullableExpression()
+        accelerationExpr = buffer.readNullableExpression()
+        sprintSpeedModifier = buffer.readNullableExpression()
+        sprintFovModifier = buffer.readNullableExpression()
+        surfaceLevelOffset = buffer.readNullableExpression()
     }
 }
 

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

@@ -8,10 +8,14 @@
 
 package com.cobblemon.mod.common.api.riding.behaviour.types.liquid
 
-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.*
+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
@@ -21,6 +25,7 @@ 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.readRidingStats
+import com.cobblemon.mod.common.util.writeNullable
 import com.cobblemon.mod.common.util.writeRidingStats
 import net.minecraft.network.RegistryFriendlyByteBuf
 import net.minecraft.resources.ResourceLocation
@@ -38,6 +43,8 @@ class BurstBehaviour : RidingBehaviour<BurstSettings, BurstState> {
     }
 
     override val key = KEY
+    val globalBurst: BurstSettings
+        get() = CobblemonRideSettings.burst
 
     override fun getRidingStyle(settings: BurstSettings, state: BurstState): RidingStyle {
         return RidingStyle.LIQUID
@@ -67,7 +74,7 @@ class BurstBehaviour : RidingBehaviour<BurstSettings, BurstState> {
         vehicle: PokemonEntity,
         driver: Player
     ): Float {
-        if(state.dashing.get()) {
+        if (state.dashing.get()) {
             state.ticks.set(state.ticks.get() + 1)
             if(state.ticks.get() >= DASH_TICKS) {
                 state.dashing.set(false)
@@ -77,7 +84,7 @@ class BurstBehaviour : RidingBehaviour<BurstSettings, BurstState> {
         }
 
         state.dashing.set(true)
-        return settings.dashSpeed
+        return settings.dashSpeed ?: globalBurst.dashSpeed!!
     }
 
     override fun rotation(
@@ -239,22 +246,21 @@ class BurstSettings : RidingBehaviourSettings {
     override val key = BurstBehaviour.KEY
     override val stats = mutableMapOf<RidingStat, IntRange>()
 
-    var dashSpeed = 1F
+    var dashSpeed: Float? = null
         private set
 
     var rideSounds: RideSoundSettingsList = RideSoundSettingsList()
 
     override fun encode(buffer: RegistryFriendlyByteBuf) {
-        buffer.writeResourceLocation(key)
         buffer.writeRidingStats(stats)
         rideSounds.encode(buffer)
-        buffer.writeFloat(dashSpeed)
+        buffer.writeNullable(dashSpeed) { buf, speed -> buf.writeFloat(speed) }
     }
 
     override fun decode(buffer: RegistryFriendlyByteBuf) {
         stats.putAll(buffer.readRidingStats())
         rideSounds = RideSoundSettingsList.decode(buffer)
-        dashSpeed = buffer.readFloat()
+        dashSpeed = buffer.readNullable { buf -> buf.readFloat() }
     }
 }
 

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

@@ -10,21 +10,33 @@ package com.cobblemon.mod.common.api.riding.behaviour.types.liquid
 
 import com.bedrockk.molang.Expression
 import com.bedrockk.molang.runtime.MoLangMath.lerp
-import com.bedrockk.molang.runtime.value.DoubleValue
 import com.cobblemon.mod.common.Cobblemon
+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.riding.RidingStyle
-import com.cobblemon.mod.common.api.riding.behaviour.*
+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.entity.PoseType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.*
+import com.cobblemon.mod.common.util.cobblemonResource
 import com.cobblemon.mod.common.util.math.geometry.toDegrees
 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
+import com.cobblemon.mod.common.util.resolveDouble
+import com.cobblemon.mod.common.util.toVec3d
+import com.cobblemon.mod.common.util.writeNullableExpression
+import com.cobblemon.mod.common.util.writeRidingStats
+import kotlin.math.*
 import net.minecraft.client.Minecraft
 import net.minecraft.network.FriendlyByteBuf
 import net.minecraft.network.RegistryFriendlyByteBuf
@@ -35,18 +47,6 @@ 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 net.minecraft.world.phys.shapes.Shapes
-import org.joml.Vector3f
-import kotlin.math.abs
-import kotlin.math.asin
-import kotlin.math.cos
-import kotlin.math.hypot
-import kotlin.math.max
-import kotlin.math.min
-import kotlin.math.pow
-import kotlin.math.sign
-import kotlin.math.sin
-import kotlin.math.sqrt
 
 class DolphinBehaviour : RidingBehaviour<DolphinSettings, DolphinState> {
     companion object {
@@ -54,6 +54,8 @@ class DolphinBehaviour : RidingBehaviour<DolphinSettings, DolphinState> {
     }
 
     override val key = KEY
+    val globalDolphin: DolphinSettings
+        get() = CobblemonRideSettings.dolphin
 
     override fun getRidingStyle(settings: DolphinSettings, state: DolphinState): RidingStyle {
         return RidingStyle.LIQUID
@@ -117,10 +119,14 @@ class DolphinBehaviour : RidingBehaviour<DolphinSettings, DolphinState> {
     ) {
         val stam = state.stamina.get()
 
+        if (vehicle.runtime.resolveBoolean(settings.infiniteStamina ?: globalDolphin.infiniteStamina!!)) {
+            return
+        }
+
         // Grab the boost time in seconds and convert to ticks. Then calculate the drain rate as inversely
         // proportional to the number of ticks of boost thus making a full boost take x ticks
         // in short: "Stamina drains slower at higher values and also replenishes slower"
-        val boostTime = vehicle.runtime.resolveDouble(settings.staminaExpr) * 20.0f
+        val boostTime = vehicle.runtime.resolveDouble(settings.staminaExpr ?: globalDolphin.staminaExpr!!) * 20.0f
         val stamDrainRate = (1.0f / boostTime).toFloat()
 
         val newStam = if (state.boosting.get()) max(0.0f,stam - stamDrainRate)
@@ -149,9 +155,9 @@ class DolphinBehaviour : RidingBehaviour<DolphinSettings, DolphinState> {
         val controller = (driver as OrientationControllable).orientationController
 
         val runtime = vehicle.runtime
-        val boostMod = if (state.boosting.get()) runtime.resolveDouble(settings.jumpExpr) else 1.0
-        val topSpeed = (vehicle.runtime.resolveDouble(settings.speedExpr) / 20.0) * boostMod
-        val accel = (topSpeed / (vehicle.runtime.resolveDouble(settings.accelerationExpr) * 20.0)) * boostMod
+        val boostMod = if (state.boosting.get()) runtime.resolveDouble(settings.jumpExpr ?: globalDolphin.jumpExpr!!) else 1.0
+        val topSpeed = (vehicle.runtime.resolveDouble(settings.speedExpr ?: globalDolphin.speedExpr!!) / 20.0) * boostMod
+        val accel = (topSpeed / (vehicle.runtime.resolveDouble(settings.accelerationExpr ?: globalDolphin.accelerationExpr!!) * 20.0)) * boostMod
 
         /*********************************************
          * Breaching logic
@@ -189,8 +195,8 @@ class DolphinBehaviour : RidingBehaviour<DolphinSettings, DolphinState> {
         }
 
         val currSpeed = state.speed.get()
-        val strafeFactor = runtime.resolveDouble(settings.strafeFactor)
-        val reverseDriveFactor = runtime.resolveDouble(settings.reverseDriveFactor)
+        val strafeFactor = runtime.resolveDouble(settings.strafeFactor ?: globalDolphin.strafeFactor!!)
+        val reverseDriveFactor = runtime.resolveDouble(settings.reverseDriveFactor ?: globalDolphin.reverseDriveFactor!!)
         val f = -driver.xxa * strafeFactor
         when {
             driver.zza > 0.0 -> state.speed.set(min(topSpeed, currSpeed + accel))
@@ -225,8 +231,8 @@ class DolphinBehaviour : RidingBehaviour<DolphinSettings, DolphinState> {
 
         val currSpeed = vehicle.deltaMovement.length()
 
-        val handling = vehicle.runtime.resolveDouble(settings.handlingExpr)
-        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr) / 20.0
+        val handling = vehicle.runtime.resolveDouble(settings.handlingExpr ?: globalDolphin.handlingExpr!!)
+        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr ?: globalDolphin.speedExpr!!) / 20.0
 
         val yawDeltaDeg =  deltaTime * handling * sin(Math.toRadians(controller.roll.toDouble())).pow(2) * sin(Math.toRadians(controller.roll.toDouble())).sign
         val trueYawDelt = yawDeltaDeg * abs(cos(Math.toRadians(controller.pitch.toDouble()))) * sqrt(RidingBehaviour.scaleToRange(currSpeed, 0.0, topSpeed))
@@ -253,7 +259,7 @@ class DolphinBehaviour : RidingBehaviour<DolphinSettings, DolphinState> {
         // Calculate correcting roll force.
         // Mult by cos(pitch) to ensure that it doesn't roll correct at when diving or climbing
         val currSpeed = vehicle.deltaMovement.length()
-        val rollCorrectionTimer = vehicle.runtime.resolveDouble(settings.timeToRollCorrect)
+        val rollCorrectionTimer = vehicle.runtime.resolveDouble(settings.timeToRollCorrect ?: globalDolphin.timeToRollCorrect!!)
         val maxRollCorrectionRate = if (!(vehicle.isInWater || vehicle.isUnderWater)) 15.0f
             else 10.0f * (cos(controller.pitch.toRadians())).pow(2) * ((state.noInputTime.get() - rollCorrectionTimer) * 2).coerceIn(0.0, 1.0).toFloat()
         val maxRollForce = maxRollCorrectionRate / 40.0
@@ -374,8 +380,8 @@ class DolphinBehaviour : RidingBehaviour<DolphinSettings, DolphinState> {
         controller.rotateRoll(controller.roll * -1.0f)
 
         val boostingHandleDebuff = if (state.boosting.get()) 0.2 else 1.0
-        val handling = vehicle.runtime.resolveDouble(settings.handlingExpr) * boostingHandleDebuff
-        val mouseInputMult = vehicle.runtime.resolveDouble(settings.mouseInputMult)
+        val handling = vehicle.runtime.resolveDouble(settings.handlingExpr ?: globalDolphin.handlingExpr!!) * boostingHandleDebuff
+        val mouseInputMult = vehicle.runtime.resolveDouble(settings.mouseInputMult ?: globalDolphin.mouseInputMult!!)
 
         //Smooth out mouse input.
         val smoothingSpeed = 4.0
@@ -418,9 +424,9 @@ class DolphinBehaviour : RidingBehaviour<DolphinSettings, DolphinState> {
     ): Vec3 {
         if (driver !is OrientationControllable) return Vec3.ZERO
         val controller = (driver as OrientationControllable).orientationController
-        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr) / 20.0
+        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr ?: globalDolphin.speedExpr!!) / 20.0
         val boostingHandleDebuff = if (state.boosting.get()) 0.2 else 1.0
-        val mouseInputMult = vehicle.runtime.resolveDouble(settings.mouseInputMult) * boostingHandleDebuff
+        val mouseInputMult = vehicle.runtime.resolveDouble(settings.mouseInputMult ?: globalDolphin.mouseInputMult!!) * boostingHandleDebuff
 
         //Smooth out mouse input.
         val smoothingSpeed = 4.0
@@ -439,7 +445,7 @@ class DolphinBehaviour : RidingBehaviour<DolphinSettings, DolphinState> {
         // - 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)
+        val p = 1.0 - vehicle.runtime.resolveDouble(settings.horizontalPitchExpr ?: globalDolphin.horizontalPitchExpr!!)
         val localPitch = yInput * (1 - abs(sin(controller.roll.toRadians())) * p * hypot(controller.forwardVector.x.toDouble(), controller.forwardVector.z.toDouble()).toFloat())
 //        localPitch *= if (currSpeed > hoverSpeed) RidingBehaviour.scaleToRange(currSpeed, hoverSpeed, topSpeed)
 //        else 0.0
@@ -560,62 +566,68 @@ class DolphinSettings : RidingBehaviourSettings {
     override val key = DolphinBehaviour.KEY
     override val stats = mutableMapOf<RidingStat, IntRange>()
 
-    var canJump = "true".asExpression()
+    var infiniteStamina: Expression? = null
         private set
 
-    var reverseDriveFactor = "0.25".asExpression()
+    var canJump: Expression? = null
         private set
 
-    var strafeFactor = "0.2".asExpression()
+    var reverseDriveFactor: Expression? = null
         private set
 
-    var timeToRollCorrect: Expression = "0.5".asExpression()
+    var strafeFactor: Expression? = null
+        private set
+
+    var timeToRollCorrect: Expression? = null
         private set
 
     // Boost influence when boosting
-    var jumpExpr: Expression = "q.get_ride_stats('JUMP', 'LIQUID', 2.2, 1.2)".asExpression()
+    var jumpExpr: Expression? = null
     // Yaw rate in degrees per second
-    var handlingExpr: Expression = "q.get_ride_stats('SKILL', 'LIQUID', 100.0, 45.0)".asExpression()
-    var horizontalPitchExpr: Expression = "q.get_ride_stats('SKILL', 'LIQUID', 0.3, 0.2)".asExpression()
-    var mouseInputMult: Expression = "q.get_ride_stats('SKILL', 'LIQUID', 1.2, 0.8)".asExpression()
+    var handlingExpr: Expression? = null
+    var horizontalPitchExpr: Expression? = null
+    var mouseInputMult: Expression? = null
     // Top speed in Bl/s
-    var speedExpr: Expression = "q.get_ride_stats('SPEED', 'LIQUID', 15.0, 5.0)".asExpression()
+    var speedExpr: Expression? = null
     // Seconds to get to top speed
-    var accelerationExpr: Expression = "q.get_ride_stats('ACCELERATION', 'LIQUID', 2.0, 5.0)".asExpression()
+    var accelerationExpr: Expression? = null
     // Seconds of boost
-    var staminaExpr: Expression = "q.get_ride_stats('STAMINA', 'LIQUID', 7.0, 3.0)".asExpression()
+    var staminaExpr: Expression? = null
 
     var rideSounds: RideSoundSettingsList = RideSoundSettingsList()
 
     override fun encode(buffer: RegistryFriendlyByteBuf) {
-        buffer.writeResourceLocation(key)
         buffer.writeRidingStats(stats)
         rideSounds.encode(buffer)
-        buffer.writeExpression(canJump)
-        buffer.writeExpression(reverseDriveFactor)
-        buffer.writeExpression(strafeFactor)
-        buffer.writeExpression(jumpExpr)
-        buffer.writeExpression(handlingExpr)
-        buffer.writeExpression(horizontalPitchExpr)
-        buffer.writeExpression(mouseInputMult)
-        buffer.writeExpression(speedExpr)
-        buffer.writeExpression(accelerationExpr)
-        buffer.writeExpression(staminaExpr)
+        buffer.writeNullableExpression(infiniteStamina)
+        buffer.writeNullableExpression(canJump)
+        buffer.writeNullableExpression(reverseDriveFactor)
+        buffer.writeNullableExpression(strafeFactor)
+        buffer.writeNullableExpression(timeToRollCorrect)
+        buffer.writeNullableExpression(jumpExpr)
+        buffer.writeNullableExpression(handlingExpr)
+        buffer.writeNullableExpression(horizontalPitchExpr)
+        buffer.writeNullableExpression(mouseInputMult)
+        buffer.writeNullableExpression(speedExpr)
+        buffer.writeNullableExpression(accelerationExpr)
+        buffer.writeNullableExpression(staminaExpr)
     }
 
     override fun decode(buffer: RegistryFriendlyByteBuf) {
         stats.putAll(buffer.readRidingStats())
         rideSounds = RideSoundSettingsList.decode(buffer)
-        canJump = buffer.readExpression()
-        reverseDriveFactor = buffer.readExpression()
-        strafeFactor = buffer.readExpression()
-        jumpExpr = buffer.readExpression()
-        handlingExpr = buffer.readExpression()
-        horizontalPitchExpr = buffer.readExpression()
-        mouseInputMult = buffer.readExpression()
-        speedExpr = buffer.readExpression()
-        accelerationExpr = buffer.readExpression()
-        staminaExpr = buffer.readExpression()
+        infiniteStamina = buffer.readNullableExpression()
+        canJump = buffer.readNullableExpression()
+        reverseDriveFactor = buffer.readNullableExpression()
+        strafeFactor = buffer.readNullableExpression()
+        timeToRollCorrect = buffer.readNullableExpression()
+        jumpExpr = buffer.readNullableExpression()
+        handlingExpr = buffer.readNullableExpression()
+        horizontalPitchExpr = buffer.readNullableExpression()
+        mouseInputMult = buffer.readNullableExpression()
+        speedExpr = buffer.readNullableExpression()
+        accelerationExpr = buffer.readNullableExpression()
+        staminaExpr = buffer.readNullableExpression()
     }
 }
 

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/sound/RideLoopSound.kt

@@ -42,9 +42,10 @@ class RideLoopSound(val ride: PokemonEntity, val soundSettings: RideSoundSetting
     var fade: Float = 0.0f
     var shouldMuffle: Boolean = soundSettings.muffleEnabled
     var rideAttenuation: RideAttenuationModel = soundSettings.attenuationModel
-    var muffleAmount: Float = 1.0f // Currently slightly misleading. 1.0 is on muffle and 0.0 is full hFgain muting
-    // TODO: revisit below flag once multi passenger support is enabled
-    var isPassenger: Boolean = Minecraft.getInstance().player?.id == ride.controllingPassenger?.id
+    var muffleAmount: Float = 1.0f // Currently slightly misleading. 1.0 is no muffle and 0.0 is full hFgain muting
+    var isPassenger: Boolean = ride.passengers.any { passenger ->
+        Minecraft.getInstance().player?.id == passenger.id
+    }
 
     init {
         this.looping = true

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/stats/RidingStat.kt

@@ -21,11 +21,11 @@ import net.minecraft.network.chat.Component
 enum class RidingStat(
     val flavour: Flavour
 ) {
-    SPEED(Flavour.SWEET),
     ACCELERATION(Flavour.SPICY),
     SKILL(Flavour.DRY),
-    JUMP(Flavour.BITTER),
-    STAMINA(Flavour.SOUR);
+    SPEED(Flavour.SWEET),
+    STAMINA(Flavour.SOUR),
+    JUMP(Flavour.BITTER);
 
     companion object {
         fun getByName(name: String) = RidingStat.entries.firstOrNull { it.name.equals(name, ignoreCase = true) }

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

@@ -18,18 +18,11 @@ import com.cobblemon.mod.common.api.spawning.condition.SeafloorSpawningCondition
 import com.cobblemon.mod.common.api.spawning.condition.SpawningCondition
 import com.cobblemon.mod.common.api.spawning.condition.SubmergedSpawningCondition
 import com.cobblemon.mod.common.api.spawning.condition.SurfaceSpawningCondition
-import com.cobblemon.mod.common.api.spawning.position.calculators.GroundedSpawnablePositionCalculator
-import com.cobblemon.mod.common.api.spawning.position.calculators.LavafloorSpawnablePositionCalculator
-import com.cobblemon.mod.common.api.spawning.position.calculators.SeafloorSpawnablePositionCalculator
-import com.cobblemon.mod.common.api.spawning.position.calculators.SpawnablePositionCalculator
-import com.cobblemon.mod.common.api.spawning.position.calculators.SubmergedSpawnablePositionCalculator
-import com.cobblemon.mod.common.api.spawning.position.calculators.SurfaceSpawnablePositionCalculator
 import com.cobblemon.mod.common.api.spawning.detail.NPCSpawnDetail
 import com.cobblemon.mod.common.api.spawning.detail.PokemonHerdSpawnDetail
 import com.cobblemon.mod.common.api.spawning.detail.PokemonSpawnDetail
 import com.cobblemon.mod.common.api.spawning.detail.SpawnAction
 import com.cobblemon.mod.common.api.spawning.detail.SpawnDetail
-import com.cobblemon.mod.common.api.spawning.fishing.FishingSpawner
 import com.cobblemon.mod.common.api.spawning.influence.SpawningInfluence
 import com.cobblemon.mod.common.api.spawning.position.AreaSpawnablePositionResolver
 import com.cobblemon.mod.common.api.spawning.position.FishingSpawnablePosition
@@ -39,16 +32,21 @@ import com.cobblemon.mod.common.api.spawning.position.SeafloorSpawnablePosition
 import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
 import com.cobblemon.mod.common.api.spawning.position.SubmergedSpawnablePosition
 import com.cobblemon.mod.common.api.spawning.position.SurfaceSpawnablePosition
+import com.cobblemon.mod.common.api.spawning.position.calculators.GroundedSpawnablePositionCalculator
+import com.cobblemon.mod.common.api.spawning.position.calculators.LavafloorSpawnablePositionCalculator
+import com.cobblemon.mod.common.api.spawning.position.calculators.SeafloorSpawnablePositionCalculator
+import com.cobblemon.mod.common.api.spawning.position.calculators.SpawnablePositionCalculator
+import com.cobblemon.mod.common.api.spawning.position.calculators.SubmergedSpawnablePositionCalculator
+import com.cobblemon.mod.common.api.spawning.position.calculators.SurfaceSpawnablePositionCalculator
 import com.cobblemon.mod.common.api.spawning.preset.BasicSpawnDetailPreset
 import com.cobblemon.mod.common.api.spawning.preset.BestSpawnerConfig
 import com.cobblemon.mod.common.api.spawning.preset.PokemonSpawnDetailPreset
 import com.cobblemon.mod.common.api.spawning.selection.SpawningSelector
-import com.cobblemon.mod.common.api.spawning.spawner.AreaSpawner
+import com.cobblemon.mod.common.api.spawning.spawner.BasicSpawner
 import com.cobblemon.mod.common.api.spawning.spawner.FixedAreaSpawner
 import com.cobblemon.mod.common.api.spawning.spawner.PlayerSpawner
 import com.cobblemon.mod.common.api.spawning.spawner.PlayerSpawnerFactory
 import com.cobblemon.mod.common.api.spawning.spawner.Spawner
-import com.cobblemon.mod.common.api.spawning.spawner.TickingSpawner
 import com.cobblemon.mod.common.entity.pokemon.CobblemonAgingDespawner
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import net.minecraft.server.MinecraftServer
@@ -66,14 +64,13 @@ import net.minecraft.server.MinecraftServer
  * In the case of more specialized use, the creation of a [SpawnablePosition] that motivates most of the spawn
  * process can be created manually, skipping the first two steps.
  *
- * An individually spawnable entity is defined as a [SpawnDetail]. A processor handling this process is a [Spawner].
- * Various subclasses exist for more specialized cases. A spawner that is constantly ticking and will spawn things
- * without prompts is a [TickingSpawner], and one of those which occurs within a defined area is a [AreaSpawner]. If
+ * An individually spawnable thing is defined as a [SpawnDetail]. A processor handling this process is a [Spawner].
+ * Some subclasses exist for more specialized cases. If you are spawning in a fixed area and the spawner controlling
  * that area is unmoving then it is a [FixedAreaSpawner] whereas if it is actively following the player it is a
- * [PlayerSpawner].
+ * [PlayerSpawner]. You can also use a [BasicSpawner] for more general-purpose spawning without any issue.
  *
- * Spawning is coordinated and ticked using a [SpawnerManager], and all the current managers are accessible from
- * [BestSpawner.spawnerManagers].
+ * PlayerSpawners are stored inside ServerPlayers using a mixin and tick at the end of a player's tick. The [PlayerSpawnerFactory]
+ * is used to build those. An extension function exists for getting the spawner for a player.
  *
  * Spawners and spawnable positions are often put under the effects of [SpawningInfluence]s which can be used to make
  * temporary or lasting changes to spawning for whatever component they are attached to (whether that is a spawner or a
@@ -87,9 +84,9 @@ import net.minecraft.server.MinecraftServer
  */
 object BestSpawner {
     var config = BestSpawnerConfig()
-    val spawnerManagers = mutableListOf<SpawnerManager>(CobblemonWorldSpawnerManager)
+
     lateinit var defaultPokemonDespawner: Despawner<PokemonEntity>
-    lateinit var fishingSpawner: FishingSpawner
+    lateinit var fishingSpawner: BasicSpawner
 
     fun init() {
         LOGGER.info("Starting the Best Spawner...")
@@ -137,12 +134,13 @@ object BestSpawner {
 
     fun reloadConfig() {
         loadConfig()
-        spawnerManagers.forEach(SpawnerManager::onConfigReload)
     }
 
     fun onServerStarted(server: MinecraftServer) {
         CobblemonSpawnPools.onServerLoad(server)
-        spawnerManagers.forEach(SpawnerManager::onServerStarted)
-        fishingSpawner = FishingSpawner()
+        fishingSpawner = BasicSpawner(
+            name = "fishing",
+            spawnPool = CobblemonSpawnPools.WORLD_SPAWN_POOL
+        )
     }
 }

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

@@ -34,13 +34,12 @@ object CobblemonSpawnPools {
                 SpawnablePositionTypePrecalculation,
                 BucketPrecalculation,
                 BiomePrecalculation
-            )
+            ), reloadable = true
         )
     }
 
     fun onServerLoad(server: MinecraftServer) {
         Cobblemon.LOGGER.info("Optimizing spawn pools...")
-        WORLD_SPAWN_POOL.forEach { it.onServerLoad(server) }
-        WORLD_SPAWN_POOL.precalculate()
+        WORLD_SPAWN_POOL.onServerLoad(server)
     }
 }

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

@@ -1,76 +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.api.spawning
-
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.api.spawning.spawner.PlayerSpawner
-import com.cobblemon.mod.common.api.spawning.spawner.PlayerSpawnerFactory
-import com.cobblemon.mod.common.platform.events.PlatformEvents
-import com.cobblemon.mod.common.world.gamerules.CobblemonGameRules
-import net.minecraft.server.level.ServerLevel
-import java.util.UUID
-import net.minecraft.server.level.ServerPlayer
-
-/**
- * The [SpawnerManager] that handles Cobblemon's world spawner, which is made up
- * of [PlayerSpawner] instances. This manager listens for login and logout and
- * cleans up where relevant.
- *
- * @author Hiroku
- * @since February 14th, 2022
- */
-object CobblemonWorldSpawnerManager : SpawnerManager() {
-
-    var spawnersForPlayers = mutableMapOf<UUID, PlayerSpawner>()
-
-    init {
-        PlatformEvents.SERVER_PLAYER_LOGIN.subscribe { this.onPlayerLogin(it.player) }
-        PlatformEvents.SERVER_PLAYER_LOGOUT.subscribe { this.onPlayerLogout(it.player) }
-        PlatformEvents.CHANGE_DIMENSION.subscribe { this.onDimensionChange(it.player, it.origin, it.destination) }
-    }
-
-    fun onPlayerLogin(player: ServerPlayer) {
-        // Disables spawning
-        if (!Cobblemon.config.enableSpawning || player.level().gameRules.getBoolean(CobblemonGameRules.DO_POKEMON_SPAWNING) == false) {
-            return;
-        }
-
-        registerPlayerSpawner(player)
-    }
-
-    fun onPlayerLogout(player: ServerPlayer) {
-        unregisterPlayerSpawner(player)
-    }
-
-    fun onDimensionChange(player: ServerPlayer, origin: ServerLevel?, destination: ServerLevel?) {
-        fun getSpawnRule(level: ServerLevel?) = level?.gameRules?.getBoolean(CobblemonGameRules.DO_POKEMON_SPAWNING)
-
-        if (!Cobblemon.config.enableSpawning || getSpawnRule(origin) == getSpawnRule(destination)) {
-            return
-        }
-
-        val spawnerAction = if (destination?.gameRules?.getBoolean(CobblemonGameRules.DO_POKEMON_SPAWNING) == false) {
-            ::unregisterPlayerSpawner
-        } else {
-            ::registerPlayerSpawner
-        }
-        spawnerAction(player)
-    }
-
-    private fun unregisterPlayerSpawner(player: ServerPlayer) {
-        spawnersForPlayers.remove(player.uuid)?.let { unregisterSpawner(it) }
-    }
-
-    private fun registerPlayerSpawner(player: ServerPlayer) {
-        PlayerSpawnerFactory.create(this, player).also {
-            spawnersForPlayers[player.uuid] = it
-            registerSpawner(it)
-        }
-    }
-}

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

@@ -17,16 +17,21 @@ import net.minecraft.world.entity.EntityType
 open class SpawnCause(
     val spawner: Spawner,
     entity: Entity? = null
-): SpawningInfluence {
+) : SpawningInfluence {
     val entityWorldId = entity?.level()?.dimension()
     val entityId = entity?.id
     val entityUUID = entity?.uuid
     val entityType = entity?.type
 
     val entity: Entity?
-        get() = if (entityType == EntityType.PLAYER) {
-            server()?.playerList?.getPlayer(entityUUID!!)
-        } else {
-            server()?.getLevel(entityWorldId!!)?.getEntity(entityId!!)
-        }
+        get() =
+            if (entityType == EntityType.PLAYER) {
+                entityUUID?.let {
+                    server()?.playerList?.getPlayer(it)
+                }
+            } else if (entityWorldId != null && entityId != null) {
+                server()?.getLevel(entityWorldId)?.getEntity(entityId)
+            } else {
+                null
+            }
 }

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

@@ -1,85 +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.api.spawning
-
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.api.spawning.influence.SpawningInfluence
-import com.cobblemon.mod.common.api.spawning.spawner.PlayerSpawner
-import com.cobblemon.mod.common.api.spawning.spawner.Spawner
-import com.cobblemon.mod.common.api.spawning.spawner.TickingSpawner
-import com.cobblemon.mod.common.util.server
-import com.cobblemon.mod.common.world.gamerules.CobblemonGameRules.DO_POKEMON_SPAWNING
-
-/**
- * A manager of various spawners. This is a class in which you should register
- * ticking spawners so that they can be automatically ticked by the server.
- * This also supports registering [SpawningInfluence]s to apply to each spawner
- * that is registered.
- *
- * @author Hiroku
- * @since February 5th, 2022
- */
-open class SpawnerManager {
-    val spawners = mutableListOf<Spawner>()
-        get() {
-            if (server()?.isSameThread == false) {
-                Cobblemon.LOGGER.error("Illegal access to spawners list from non-server thread!")
-                Exception().printStackTrace()
-            }
-            return field
-        }
-    val influences = mutableListOf<SpawningInfluence>()
-        get() {
-            if (server()?.isSameThread == false) {
-                Cobblemon.LOGGER.error("Illegal access to influences from non-server thread!")
-                Exception().printStackTrace()
-            }
-            return field
-        }
-    inline fun <reified T : Spawner> getSpawnersOfType() = spawners.filterIsInstance<T>()
-    open fun getSpawnerByName(name: String) = spawners.find { it.name == name }
-
-    open fun registerSpawner(spawner: Spawner) {
-        spawners.add(spawner)
-        if (spawner !is TickingSpawner) {
-            spawner.influences.addAll(influences)
-        }
-    }
-
-    open fun unregisterSpawner(spawner: Spawner) {
-        spawners.remove(spawner)
-        if (spawner !is TickingSpawner) {
-            spawner.influences.removeAll(influences)
-        }
-    }
-
-    open fun onConfigReload() {
-        spawners.filterIsInstance<PlayerSpawner>().forEach {
-            it.ticksBetweenSpawns = Cobblemon.config.ticksBetweenSpawnAttempts
-        }
-    }
-
-    open fun onServerStarted() {
-        spawners.clear()
-    }
-
-    open fun onServerTick() {
-        // Disables spawning
-        if (!Cobblemon.config.enableSpawning) {
-            return
-        }
-        influences.removeIf { it.isExpired() }
-        getSpawnersOfType<TickingSpawner>().forEach {
-            if (it.getCauseEntity()?.level()?.gameRules?.getBoolean(DO_POKEMON_SPAWNING) == false) {
-                return@forEach
-            }
-            it.tick()
-        }
-    }
-}

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

@@ -39,9 +39,13 @@ import net.minecraft.server.MinecraftServer
  */
 abstract class SpawnDetail : ModDependant {
     companion object {
+        val pokemonTypes = mutableListOf<String>()
         val spawnDetailTypes = mutableMapOf<String, RegisteredSpawnDetail<*>>()
         fun <T : SpawnDetail> registerSpawnType(name: String, detailClass: Class<T>) {
             spawnDetailTypes[name] = RegisteredSpawnDetail(detailClass)
+            if (detailClass == PokemonSpawnDetail::class.java || detailClass == PokemonHerdSpawnDetail::class.java) {
+                pokemonTypes.add(name)
+            }
         }
     }