Add locator rotation to camera bob (still needs work)

Make head moving actually stop this time.

See merge request cable-mc/cobblemon!1596

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

@@ -63,6 +63,10 @@ public abstract class CameraMixin {
     private BlockGetter level;
 
     @Shadow private float partialTickTime;
+
+    @Shadow public abstract void tick();
+
+    @Shadow private boolean detached;
     @Unique private float returnTimer = 0;
     @Unique private float rollAngleStart = 0;
     @Unique Minecraft minecraft = Minecraft.getInstance();
@@ -92,25 +96,38 @@ public abstract class CameraMixin {
                 this.returnTimer += .05F;
                 ci.cancel();
             } else {
+                cobblemon$applyRotation();
                 this.returnTimer = 1;
                 controller.reset();
             }
             return;
         }
-        if (controller.getOrientation() == null) return;
         cobblemon$applyRotation();
 
         this.returnTimer = 0;
-        this.rollAngleStart = controller.getRoll();
+        if (controller.getOrientation() != null) {
+            this.rollAngleStart = controller.getRoll();
+        }
+
+        if (!(entity.getVehicle() instanceof PokemonEntity)) return;
         ci.cancel();
     }
 
+    @Inject(method = "setup", at = @At("HEAD"))
+    private void cobblemon$prepAnimation(BlockGetter level, Entity entity, boolean detached, boolean thirdPersonReverse, float partialTick, CallbackInfo ci) {
+        Entity vehicle = entity.getVehicle();
+        MountedPokemonAnimationRenderController.INSTANCE.reset();
+
+        if (vehicle instanceof PokemonEntity pokemon) {
+            MountedPokemonAnimationRenderController.INSTANCE.setup(pokemon, partialTick);
+        }
+    }
+
     //If you want to move this to a delagate you need an AW for position
     @WrapOperation(method = "setup", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/Camera;setPosition(DDD)V"))
     public void cobblemon$positionCamera(Camera instance, double x, double y, double z, Operation<Void> original, @Local(ordinal = 1, argsOnly = true) boolean thirdPersonReverse) {
         Entity entity = instance.getEntity();
         Entity vehicle = entity.getVehicle();
-        MountedPokemonAnimationRenderController.INSTANCE.reset();
 
         if(vehicle instanceof Rideable){
             //RidingCameraDelagate.INSTANCE.positionCamera(instance, x, y, z, original);
@@ -125,7 +142,6 @@ public abstract class CameraMixin {
                     Mth.lerp(instance.getPartialTickTime(), pokemon.yOld, pokemon.getY()),
                     Mth.lerp(instance.getPartialTickTime(), pokemon.zOld, pokemon.getZ())
             );
-            MountedPokemonAnimationRenderController.INSTANCE.setup(pokemon, partialTickTime);
             int seatIndex = pokemon.getPassengers().indexOf(entity);
             Seat seat = pokemon.getSeats().get(seatIndex);
 
@@ -186,18 +202,71 @@ public abstract class CameraMixin {
 
     @Unique
     private void cobblemon$applyRotation(){
-        if (!(this.entity instanceof OrientationControllable controllable) || controllable.getOrientationController().getOrientation() == null) return;
+        if (!(this.entity instanceof OrientationControllable controllable) || controllable.getOrientationController().getOrientation() == null || !controllable.getOrientationController().isActive()) {
+            Quaternionf newRotation = null;
+            var vehicle = entity.getVehicle();
+            if (vehicle instanceof PokemonEntity pokemon) {
+                var delegate = (PokemonClientDelegate) pokemon.getDelegate();
+                int seatIndex = pokemon.getPassengers().indexOf(entity);
+                Seat seat = pokemon.getSeats().get(seatIndex);
+                MatrixWrapper locator = delegate.getLocatorStates().get(seat.getLocator());
+                if (locator != null && !detached) {
+                    var scale = locator.getMatrix().getScale(new Vector3f());
+                    if (scale.length() > 0.1) {
+                        newRotation = locator.getMatrix().getUnnormalizedRotation(new Quaternionf()).normalize();
+                    }
+                }
+            }
+            if (newRotation != null) {
+                if (this.minecraft.options.getCameraType().isMirrored()) {
+                    newRotation.rotateY((float)Math.toRadians(180));
+                }
+
+                this.rotation.set(newRotation);
+
+                var forwardVector = newRotation.transform(OrientationController.Companion.getFORWARDS(), new Vector3f());
+                var upVector = newRotation.transform(OrientationController.Companion.getUP(), new Vector3f());
+                var leftVector = newRotation.transform(OrientationController.Companion.getLEFT(), new Vector3f());
+                this.xRot = (float)Mth.wrapDegrees(-Math.toDegrees(Math.asin(forwardVector.y)));
+                this.yRot = Mth.wrapDegrees((float)-Math.toDegrees(OrientationController.Companion.getFORWARDS().angleSigned(forwardVector, OrientationController.Companion.getUP())) + 180);
+                this.forwards.set(forwardVector);
+                this.up.set(upVector);
+                this.left.set(leftVector);
+            }
+            return;
+        }
+
         var controller = controllable.getOrientationController();
         var newRotation = controller.getOrientation().normal(new Matrix3f()).getNormalizedRotation(new Quaternionf());
+
+        var vehicle = entity.getVehicle();
+        if (vehicle instanceof PokemonEntity pokemon) {
+            var delegate = (PokemonClientDelegate) pokemon.getDelegate();
+            int seatIndex = pokemon.getPassengers().indexOf(entity);
+            Seat seat = pokemon.getSeats().get(seatIndex);
+            MatrixWrapper locator = delegate.getLocatorStates().get(seat.getLocator());
+            if (locator != null && !detached) {
+                var scale = locator.getMatrix().getScale(new Vector3f());
+                if (scale.length() > 0.1) {
+                    newRotation = locator.getMatrix().getUnnormalizedRotation(new Quaternionf()).normalize();
+                }
+            }
+        }
+
         if (this.minecraft.options.getCameraType().isMirrored()) {
             newRotation.rotateY((float)Math.toRadians(180));
         }
+
         this.rotation.set(newRotation);
-        this.xRot = controller.getPitch();
-        this.yRot = controller.getYaw();
-        this.forwards.set(controller.getForwardVector());
-        this.up.set(controller.getUpVector());
-        this.left.set(controller.getLeftVector());
+
+        var forwardVector = newRotation.transform(OrientationController.Companion.getFORWARDS(), new Vector3f());
+        var upVector = newRotation.transform(OrientationController.Companion.getUP(), new Vector3f());
+        var leftVector = newRotation.transform(OrientationController.Companion.getLEFT(), new Vector3f());
+        this.xRot = (float)Mth.wrapDegrees(-Math.toDegrees(Math.asin(forwardVector.y)));
+        this.yRot = Mth.wrapDegrees((float)-Math.toDegrees(OrientationController.Companion.getFORWARDS().angleSigned(forwardVector, OrientationController.Companion.getUP())) + 180);
+        this.forwards.set(forwardVector);
+        this.up.set(upVector);
+        this.left.set(leftVector);
     }
 
     @WrapOperation(method = "setup", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/Camera;move(FFF)V", ordinal = 0))

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

@@ -59,8 +59,21 @@ public class HumanoidModelMixin {
         }
 
         Entity vehicle = entity.getVehicle();
-        if (vehicle instanceof PokemonEntity && entity instanceof AbstractClientPlayer) {
-            MountedPlayerRenderer.INSTANCE.animate((PokemonEntity) vehicle, (AbstractClientPlayer) entity, relevantPartsByName, netHeadYaw, headPitch, ageInTicks, limbSwing, limbSwingAmount);
+        if (vehicle instanceof PokemonEntity pokemonEntity && entity instanceof AbstractClientPlayer) {
+            var shouldRotatePlayerHead = pokemonEntity.ifRidingAvailableSupply(false, (behaviour, settings, state) -> {
+                return behaviour.shouldRotatePlayerHead(settings, state, pokemonEntity);
+            });
+
+            if (!shouldRotatePlayerHead) {
+                netHeadYaw = 0f;
+                headPitch = 0f;
+                if (this.head != null) {
+                    this.head.yRot = 0f;
+                    this.head.xRot = 0f;
+                }
+            }
+
+            MountedPlayerRenderer.INSTANCE.animate(pokemonEntity, (AbstractClientPlayer) entity, relevantPartsByName, netHeadYaw, headPitch, ageInTicks, limbSwing, limbSwingAmount);
         }
     }
 }

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

@@ -1,38 +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.mixin.client;
-
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
-import net.minecraft.client.model.PlayerModel;
-import net.minecraft.world.entity.Entity;
-import net.minecraft.world.entity.LivingEntity;
-import net.minecraft.world.entity.player.Player;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-@Mixin(PlayerModel.class)
-public class PlayerModelMixin {
-    @Inject(method = "setupAnim(Lnet/minecraft/world/entity/LivingEntity;FFFFF)V", at = @At(value = "HEAD"))
-    private void cobblemon$setHeadRotation(LivingEntity entity, float limbSwing, float limbSwingAmount, float ageInTicks, float netHeadYaw, float headPitch, CallbackInfo ci) {
-        if (!(entity instanceof Player)) return;
-        Entity vehicle = entity.getVehicle();
-
-        if (!(vehicle instanceof PokemonEntity pokemonEntity)) return;
-
-        var shouldRotatePlayerHead = pokemonEntity.ifRidingAvailableSupply(false, (behaviour, settings, state) -> {
-            return behaviour.shouldRotatePlayerHead(settings, state, pokemonEntity);
-        });
-        if (shouldRotatePlayerHead) return;
-
-        netHeadYaw = 0f;
-        headPitch = 0f;
-    }
-}

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

@@ -832,6 +832,7 @@ object MoLangFunctions {
             map.put("is_moving") { DoubleValue((pokemonEntity.moveControl as? PokemonMoveControl)?.hasWanted() == true) }
             map.put("is_flying") { DoubleValue(pokemonEntity.getBehaviourFlag(PokemonBehaviourFlag.FLYING)) }
             map.put("is_gliding") { DoubleValue(pokemonEntity.useRidingAltPose()) }
+            map.put("is_ridden") { DoubleValue(pokemonEntity.hasControllingPassenger()) }
             map.put("has_aspect") { DoubleValue(it.getString(0) in pokemonEntity.aspects) }
             map.put("is_pokemon") { DoubleValue.ONE }
             map.put("is_holding_item") { DoubleValue(!pokemonEntity.entityData.get(PokemonEntity.SHOWN_HELD_ITEM).let {

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

@@ -107,4 +107,22 @@ open class OrientationController(val entity: LivingEntity) {
     val roll: Float
         get() = Mth.wrapDegrees(-upVector.angleSigned(UP, forwardVector).toDegrees())
 
+    fun applyGlobalYaw(deltaYawDegrees: Float) = updateOrientation { original ->
+        val euler = Vector3f()
+        original.getEulerAnglesXYZ(euler)
+        val pitch0 = euler.x
+        val roll0 = euler.z
+
+        val unroll = Matrix3f().rotateZ(-roll0)
+        val unpitch = Matrix3f().rotateX(-pitch0)
+        val flattened = Matrix3f(original).mul(unroll).mul(unpitch)
+
+        //Flip to reflect current acceptance of what direction is pos for yaw
+        val globalYaw = Matrix3f().rotationY(-1.0f * deltaYawDegrees.toRadians())
+        val rePitch = Matrix3f().rotateX(pitch0)
+        val reRoll = Matrix3f().rotateZ(roll0)
+
+        return@updateOrientation Matrix3f(globalYaw).mul(flattened).mul(rePitch).mul(reRoll)
+    }
+
 }

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

@@ -24,11 +24,11 @@ import net.minecraft.world.phys.Vec3
  */
 open class RidingBehaviourState {
     open val rideVelocity: SidedRidingState<Vec3> = ridingState(Vec3.ZERO, Side.BOTH)
-    open val stamina: SidedRidingState<Float> = ridingState(0F, Side.BOTH)
+    open val stamina: SidedRidingState<Float> = ridingState(1.0F, Side.BOTH)
 
     open fun reset() {
         rideVelocity.set(Vec3.ZERO, true)
-        stamina.set(0F, true)
+        stamina.set(1.0F, true)
     }
 
     open fun copy(): RidingBehaviourState {

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

@@ -25,6 +25,7 @@ object RidingBehaviours {
         register(JetAirBehaviour.KEY, JetAirBehaviour())
         register(SwimDashBehaviour.KEY, SwimDashBehaviour())
         register(VehicleLandBehaviour.KEY, VehicleLandBehaviour())
+        register(HoverBehaviour.KEY, HoverBehaviour())
         register(CompositeBehaviour.KEY, CompositeBehaviour())
     }
 

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

@@ -41,6 +41,11 @@ class RidingController<Settings : RidingBehaviourSettings, State : RidingBehavio
         return behaviour.speed(settings, state, vehicle, driver)
     }
 
+    override fun clampPassengerRotation(settings: Settings, state: State, vehicle: PokemonEntity, driver: LivingEntity) {
+        if (!isActive(settings, state, vehicle)) return
+        return behaviour.clampPassengerRotation(settings, state, vehicle, driver)
+    }
+
     override fun rotation(settings: Settings, state: State, vehicle: PokemonEntity, driver: LivingEntity): Vec2 {
         if (!isActive(settings, state, vehicle)) return driver.rotationVector
         return behaviour.rotation(settings, state, vehicle, driver)

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

@@ -27,6 +27,9 @@ import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.player.Player
 import net.minecraft.world.phys.Vec2
 import net.minecraft.world.phys.Vec3
+import org.joml.Matrix3f
+import org.joml.Quaternionf
+import org.joml.Vector3f
 import kotlin.math.*
 
 class BirdAirBehaviour : RidingBehaviour<BirdAirSettings, BirdAirState> {
@@ -179,26 +182,26 @@ class BirdAirBehaviour : RidingBehaviour<BirdAirSettings, BirdAirState> {
         }
 
         //Lateral movement based on driver input.
-        val latTopSpeed = topSpeed / 2.0
-        if (driver.xxa != 0.0f && state.stamina.get() > 0.0) {
-            newVelocity = Vec3(
-                (newVelocity.x + (accel * driver.xxa)).coerceIn(-latTopSpeed, latTopSpeed),
-                newVelocity.y,
-                newVelocity.z)
-            activeInput = true
-        }
-        else {
-            newVelocity = Vec3(
-                lerp(newVelocity.x, 0.0, latTopSpeed / 20.0),
-                newVelocity.y,
-                newVelocity.z)
-        }
+//        val latTopSpeed = topSpeed / 2.0
+//        if (driver.xxa != 0.0f && state.stamina.get() > 0.0) {
+//            newVelocity = Vec3(
+//                (newVelocity.x + (accel * driver.xxa)).coerceIn(-latTopSpeed, latTopSpeed),
+//                newVelocity.y,
+//                newVelocity.z)
+//            activeInput = true
+//        }
+//        else {
+//            newVelocity = Vec3(
+//                lerp(newVelocity.x, 0.0, latTopSpeed / 20.0),
+//                newVelocity.y,
+//                newVelocity.z)
+//        }
 
         //Vertical movement based on driver input.
         val vertTopSpeed = topSpeed / 2.0
         val vertInput = when {
-            driver.jumping -> 1.0
-            driver.isShiftKeyDown -> -1.0
+            driver.jumping && state.rideVelocity.get().length() < 0.3 -> 1.0
+            driver.isShiftKeyDown && state.rideVelocity.get().length() < 0.3  -> -1.0
             else -> 0.0
         }
 
@@ -225,23 +228,24 @@ class BirdAirBehaviour : RidingBehaviour<BirdAirSettings, BirdAirState> {
             }
         }
 
-        //Only perform stamina logic if the ride does not have infinite stamina
-        if (!vehicle.runtime.resolveBoolean(settings.infiniteStamina)) {
-            if (activeInput) {
-                state.stamina.set(state.stamina.get() - (0.05 / staminaStat).toFloat())
-            }
-
-            //Lose a base amount of stamina just for being airborne
-            state.stamina.set(state.stamina.get() - (0.01 / staminaStat).toFloat())
-        }
-        else
-        {
-            state.stamina.set(1.0f)
-        }
+        //TODO: Reintroduce stamina drain once stats start to be polished and tweaked
+//        //Only perform stamina logic if the ride does not have infinite stamina
+//        if (!vehicle.runtime.resolveBoolean(settings.infiniteStamina)) {
+//            if (activeInput) {
+//                state.stamina.set(state.stamina.get() - (0.05 / staminaStat).toFloat())
+//            }
+//
+//            //Lose a base amount of stamina just for being airborne
+//            state.stamina.set(state.stamina.get() - (0.01 / staminaStat).toFloat())
+//        }
+//        else
+//        {
+//            state.stamina.set(1.0f)
+//        }
 
         //air resistance
         if( abs(newVelocity.z) > 0) {
-            newVelocity = newVelocity.subtract(0.0, 0.0, min(0.003 * newVelocity.z.sign, newVelocity.z))
+            newVelocity = newVelocity.subtract(0.0, 0.0, min(0.0015 * newVelocity.z.sign, newVelocity.z))
         }
         state.rideVelocity.set(newVelocity)
     }
@@ -256,10 +260,17 @@ class BirdAirBehaviour : RidingBehaviour<BirdAirSettings, BirdAirState> {
         if (driver !is OrientationControllable) return Vec3.ZERO
         val controller = (driver as OrientationControllable).orientationController
 
-        //TODO: Tie into handling
+        //limit rolling based on handling and current speed.
+        //modulated by speed so that when flapping idle in air you are ont wobbling around to look around
+        //TODO: Tie handling into yaw rate
         val handling = vehicle.runtime.resolveDouble(settings.handlingExpr)
         val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr)
-        val rotationChangeRate = 10.0
+        //This rotation limit will be used to know if the ride has exceeded it and its needs correcting.
+        val rotMin = 15.0
+        val rotLimit = max(handling * sqrt(normalizeVal(state.rideVelocity.get().length(), 0.0, topSpeed)), rotMin)
+
+
+        val rotationChangeRate = 100.0
 
         var yawForce =  rotationChangeRate * sin(Math.toRadians(controller.roll.toDouble()))
         //for a bit of correction on the rolls limit it to a quarter the amount
@@ -269,7 +280,28 @@ class BirdAirBehaviour : RidingBehaviour<BirdAirSettings, BirdAirState> {
         yawForce *= abs(cos(Math.toRadians(controller.pitch.toDouble())))
         pitchForce *= abs(cos(Math.toRadians(controller.pitch.toDouble()))) * 1.5
 
-        return Vec3(yawForce, pitchForce, 0.0)
+        var yawDeltaDeg =  deltaTime * rotationChangeRate * sin(Math.toRadians(controller.roll.toDouble())) //sin(Math.toRadians(controller.roll.toDouble())) * abs(cos(Math.toRadians(controller.pitch.toDouble())))
+        val trueYawDelt = yawDeltaDeg * abs(cos(Math.toRadians(controller.pitch.toDouble())))
+        //val pitchedYawDelt = yawDeltaDeg - trueYawDelt
+
+        controller.applyGlobalYaw(trueYawDelt.toFloat())
+
+        val correctionRate = 5.0
+        //Calculate correcting roll force.
+        if(abs(controller.roll) > rotLimit) {
+            state.currRollCorrectionForce.set(
+                state.currRollCorrectionForce.get() + ((abs(controller.roll) - rotLimit) / 180 - rotLimit) * controller.roll.sign * correctionRate * deltaTime * 0.01
+            )
+        } else {
+            state.currRollCorrectionForce.set(
+                //reduce rollCorrection gradually and make sure to
+                //state.currRollCorrectionForce.get() - max(correctionRate * deltaTime * 0.04, abs(state.currRollCorrectionForce.get())) * state.currRollCorrectionForce.get().sign
+                lerp(state.currRollCorrectionForce.get(), 0.0, deltaTime * 0.98)
+            )
+        }
+
+        //yaw, pitch, roll
+        return Vec3(0.0, 0.0, state.currRollCorrectionForce.get())
     }
 
     override fun rotationOnMouseXY(
@@ -303,13 +335,14 @@ class BirdAirBehaviour : RidingBehaviour<BirdAirSettings, BirdAirState> {
         //modulated by speed so that when flapping idle in air you are ont wobbling around to look around
         val rotMin = 15.0
         var rollForce = xInput
-        val rotLimit = max(handling * normalizeVal(state.rideVelocity.get().length(), 0.0, topSpeed).pow(3), rotMin)
+        val rotLimit = max(handling * sqrt(normalizeVal(state.rideVelocity.get().length(), 0.0, topSpeed)), rotMin)
 
         //Limit roll by non linearly decreasing inputs towards
         // a rotation limit based on the current distance from
         // that rotation limit
         if (abs(controller.roll + rollForce) < rotLimit) {
             if (sign(rollForce) == sign(controller.roll).toDouble()) {
+                //Grab how far the current roll is away from the roll limit
                 val d = abs(abs(controller.roll) - rotLimit)
                 rollForce *= (d.pow(2)) / (rotLimit.pow(2))
             }
@@ -318,10 +351,18 @@ class BirdAirBehaviour : RidingBehaviour<BirdAirSettings, BirdAirState> {
         }
 
         //Give the ability to yaw with x mouse input when at low speeds.
-        val yawForce = xInput * ( 1.0 - normalizeVal(state.rideVelocity.get().length(), 0.0, topSpeed).pow(3))
+        val yawForce = xInput * ( 1.0 - sqrt(normalizeVal(state.rideVelocity.get().length(), 0.0, topSpeed)))
+
+        //Yaw locally a bit when up or down so that its more intuitive to make it out of a dive or a straight vertical
+        //climb
+        val yawForcePitched = xInput * sin(Math.toRadians(abs(controller.pitch.toDouble()))) * 0.25
+
+
+        //Apply yaw globally as we don't want roll or pitch changes due to local yaw when looking up or down.
+        controller.applyGlobalYaw(yawForce.toFloat())
 
         //yaw, pitch, roll
-        return Vec3(yawForce, yInput, rollForce)
+        return Vec3(yawForcePitched, yInput, rollForce)
     }
 
     /*
@@ -486,6 +527,7 @@ class BirdAirSettings : RidingBehaviourSettings {
 class BirdAirState : RidingBehaviourState() {
     var gliding = ridingState(false, Side.CLIENT)
     var lastGlide = ridingState(-100L, Side.CLIENT)
+    var currRollCorrectionForce = ridingState(0.0, Side.CLIENT)
 
     override fun encode(buffer: FriendlyByteBuf) {
         super.encode(buffer)
@@ -502,6 +544,7 @@ class BirdAirState : RidingBehaviourState() {
         super.reset()
         gliding.set(false, forced = true)
         lastGlide.set(-100L, forced = true)
+        currRollCorrectionForce.set(0.0, forced = true)
     }
 
     override fun toString(): String {
@@ -513,11 +556,12 @@ class BirdAirState : RidingBehaviourState() {
         it.stamina.set(this.stamina.get(), forced = true)
         it.gliding.set(this.gliding.get(), forced = true)
         it.lastGlide.set(this.lastGlide.get(), forced = true)
+        it.currRollCorrectionForce.set(this.currRollCorrectionForce.get(), forced = true)
     }
 
     override fun shouldSync(previous: RidingBehaviourState): Boolean {
         if (previous !is BirdAirState) return false
-        if (previous.gliding != gliding) return true
+        if (previous.gliding.get() != gliding.get()) return true
         return super.shouldSync(previous)
     }
 }

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

@@ -9,7 +9,7 @@
 package com.cobblemon.mod.common.api.riding.behaviour.types
 
 import com.bedrockk.molang.Expression
-import com.bedrockk.molang.runtime.value.DoubleValue
+import com.bedrockk.molang.runtime.MoLangMath.lerp
 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
@@ -18,15 +18,14 @@ import com.cobblemon.mod.common.entity.PoseType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.*
 import net.minecraft.network.RegistryFriendlyByteBuf
+import net.minecraft.util.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.max
-import kotlin.math.min
-import kotlin.math.pow
+import kotlin.math.*
 
 class GenericLandBehaviour : RidingBehaviour<GenericLandSettings, GenericLandState> {
     companion object {
@@ -38,7 +37,7 @@ class GenericLandBehaviour : RidingBehaviour<GenericLandSettings, GenericLandSta
 
     val poseProvider = PoseProvider<GenericLandSettings, GenericLandState>(PoseType.STAND)
         .with(PoseOption(PoseType.WALK) { _, state, _ ->
-            return@PoseOption state.rideVelocity.get().z > 0.1
+            return@PoseOption abs(state.rideVelocity.get().z) > 0.2
         })
 
     override fun isActive(
@@ -77,15 +76,99 @@ class GenericLandBehaviour : RidingBehaviour<GenericLandSettings, GenericLandSta
         return state.rideVelocity.get().length().toFloat()
     }
 
+    override fun updatePassengerRotation(
+        settings: GenericLandSettings,
+        state: GenericLandState,
+        vehicle: PokemonEntity,
+        driver: LivingEntity
+    ) {
+
+        //Take the inverse so that it cancels out how
+        //much the entity rotates.
+        val turnAmount = calcRotAmount(settings, state, vehicle, driver)
+
+        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr)
+        val maxYawDiff = 90.0f
+
+        //Normalize the current rotation diff
+        val rotMod = Mth.wrapDegrees(driver.yRot - vehicle.yRot) / maxYawDiff
+
+        val rotAmount = 10.0f
+
+        //Take the inverse so that you turn more at higher speeds
+        val normSpeed = 1.0f - 0.5f*normalizeVal(state.rideVelocity.get().length(), 0.0, topSpeed).toFloat()
+
+        //driver.yRot += (entity.riding.deltaRotation.y - turnAmount)
+        //driver.setYHeadRot(driver.yHeadRot + (entity.riding.deltaRotation.y) - turnAmount)
+    }
+
+    override fun clampPassengerRotation(
+        settings: GenericLandSettings,
+        state: GenericLandState,
+        vehicle: PokemonEntity,
+        driver: LivingEntity
+    ) {
+        val f = Mth.wrapDegrees(driver.yRot - vehicle.yRot)
+        val lookYawLimit = 90.0f
+        val g = Mth.clamp(f, -lookYawLimit, lookYawLimit)
+        driver.yRotO += g - f
+        driver.yRot = driver.yRot + g - f
+        driver.setYHeadRot(driver.yRot)
+    }
+
+
     override fun rotation(
         settings: GenericLandSettings,
         state: GenericLandState,
         vehicle: PokemonEntity,
         driver: LivingEntity
     ): Vec2 {
-        return Vec2(driver.xRot * 0.5f, driver.yRot)
+        val turnAmount =  calcRotAmount(settings, state, vehicle, driver)
+
+        return Vec2(vehicle.xRot, vehicle.yRot + turnAmount )
+
     }
 
+    /*
+   *  Calculates the rotation amount given the difference between
+   *  the current player y rot and entity y rot. This gives the
+   *  affect of influencing a rides rotation through the mouse
+   *  without it being instant.
+   */
+    fun calcRotAmount(
+        settings: GenericLandSettings,
+        state: GenericLandState,
+        vehicle: PokemonEntity,
+        driver: LivingEntity
+    ): Float {
+        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr)
+        //In degrees per second
+        val handling = vehicle.runtime.resolveDouble(settings.handlingExpr)
+        val maxYawDiff = 90.0f
+
+        //Normalize the current rotation diff
+        val rotDiff = Mth.wrapDegrees(driver.yRot - vehicle.yRot)
+        val rotDiffNorm = rotDiff / maxYawDiff
+
+        //Take the square root so that the ride levels out quicker when at lower differences between entity
+        //y and driver y
+        //This influences the speed of the turn based on how far in one direction you're looking
+        val rotDiffMod = (sqrt(abs(rotDiffNorm)) * rotDiffNorm.sign)
+
+        //Take the inverse so that you turn less at higher speeds
+        val normSpeed = 1.0f // = 1.0f - 0.5f*normalizeVal(state.rideVelocityocity.length(), 0.0, topSpeed).toFloat()
+
+        // TODO: This needs to be tweaked with in game results and testing
+        val turnRate = (handling.toFloat() / 20.0f) * 2
+
+        //Ensure you only ever rotate as much difference as there is between the angles.
+        val turnSpeed = turnRate  * rotDiffMod * normSpeed
+        val rotAmount = turnSpeed.coerceIn(-abs(rotDiff), abs(rotDiff))
+
+        return rotAmount
+    }
+
+
     override fun velocity(
         settings: GenericLandSettings,
         state: GenericLandState,
@@ -93,24 +176,16 @@ class GenericLandBehaviour : RidingBehaviour<GenericLandSettings, GenericLandSta
         driver: Player,
         input: Vec3
     ): Vec3 {
-        val runtime = vehicle.runtime
-        val driveFactor = runtime.resolveFloat(settings.driveFactor)
-        val strafeFactor = runtime.resolveFloat(settings.strafeFactor)
-        val f = driver.xxa * strafeFactor
-        var g = driver.zza * driveFactor
-        if (g <= 0.0f) {
-            g *= runtime.resolveFloat(settings.reverseDriveFactor)
-        }
-        val gravity = -1.0
+        //Limit horizontal velocity that may have accumulated through alternate behaviour
+        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr)
+        val currVel = state.rideVelocity.get()
+//        state.rideVelocity.set(Vec3(
+//            max(currVel.x, topSpeed),
+//            currVel.y,
+//            max(currVel.z, topSpeed)
+//        ))
 
-        val newVelocity = calculateRideSpaceVel(settings, state, vehicle, driver)
-
-        //Jump the thang!
-        if (driver.jumping && vehicle.onGround()) {
-            state.rideVelocity.set(Vec3(newVelocity.x, 2.0, newVelocity.z))
-        } else {
-            state.rideVelocity.set(newVelocity)
-        }
+        state.rideVelocity.set(calculateRideSpaceVel(settings, state, vehicle, driver))
 
         //This is cheap.
         //Also make it stop quicker the slower it is.
@@ -129,35 +204,59 @@ class GenericLandBehaviour : RidingBehaviour<GenericLandSettings, GenericLandSta
         vehicle: PokemonEntity,
         driver: Player
     ): Vec3 {
-        val topSpeed = vehicle.runtime.resolveDouble(settings.topSpeedExpr)
-        val accel = vehicle.runtime.resolveDouble(settings.accelExpr)
+        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr)
+        val accel = vehicle.runtime.resolveDouble(settings.accelerationExpr)
         val speed = state.rideVelocity.get().length()
 
-        val minSpeed = 0.0
+        //Flag for determining if player is actively inputting
+        var activeInput = false
 
         var newVelocity = Vec3(state.rideVelocity.get().x, state.rideVelocity.get().y, state.rideVelocity.get().z)
 
-        //speed up and slow down based on input
-        if (driver.zza > 0.0 && speed <= topSpeed && state.stamina.get() > 0.0f) {
-            //modify acceleration to be slower when at closer speeds to top speed
-            val accelMod = max((normalizeSpeed(speed, minSpeed, topSpeed) - 1).pow(2), 0.1)
-            newVelocity = Vec3(newVelocity.x, newVelocity.y, min(newVelocity.z + (accel * accelMod), topSpeed))
-        } else if (driver.zza >= 0.0 && state.stamina.get() == 0.0f || speed > topSpeed) {
-            newVelocity = Vec3(newVelocity.x, newVelocity.y, max(newVelocity.z - ((accel) / 4), minSpeed))
-        } else if (driver.zza < 0.0 && speed > minSpeed) {
-            //modify deccel to be slower when at closer speeds to minimum speed
-            val deccelMod = max(-(normalizeSpeed(speed, minSpeed, topSpeed)) + 1, 0.0)
 
-            //Decelerate currently always a constant half of max acceleration.
-            newVelocity =
-                Vec3(newVelocity.x, newVelocity.y, max(newVelocity.z - ((accel * deccelMod) / 2), minSpeed))
+        //speed up and slow down based on input
+        if (driver.zza != 0.0f && state.stamina.get() > 0.0) {
+            //make sure it can't exceed top speed
+            val forwardInput = when {
+                driver.zza > 0 && newVelocity.z > topSpeed -> 0.0
+                driver.zza < 0 && newVelocity.z < (-topSpeed / 3.0) -> 0.0
+                else -> driver.zza.sign
+            }
+
+            newVelocity = Vec3(
+                newVelocity.x,
+                newVelocity.y,
+                (newVelocity.z + (accel * forwardInput.toDouble())))
+
+            activeInput = true
         }
 
+        //Gravity logic
         if (vehicle.onGround()) {
             newVelocity = Vec3(newVelocity.x, 0.0, newVelocity.z)
         } else {
-            newVelocity = Vec3(newVelocity.x, max(newVelocity.y - 0.2, -1.0), newVelocity.z)
+            val gravity = (9.8 / ( 20.0)) * 0.2
+            val terminalVel = 2.0
+
+            val fallingForce = gravity -  ( newVelocity.z.sign *gravity *(abs(newVelocity.z) / 2.0))
+            newVelocity = Vec3(newVelocity.x, max(newVelocity.y - fallingForce, -terminalVel), newVelocity.z)
         }
+
+        //ground Friction
+        if( abs(newVelocity.z) > 0 && vehicle.onGround() && !activeInput) {
+            newVelocity = newVelocity.subtract(0.0, 0.0, min(0.03 * newVelocity.z.sign, newVelocity.z))
+        }
+
+        //Jump the thang!
+        if (driver.jumping && vehicle.onGround()) {
+            val jumpVel = 1.0
+            newVelocity = newVelocity.add(0.0, 1.0, 0.0)
+
+            //Ensure this doesn't add unwanted forward velocity
+            val mag = if(newVelocity.length() < topSpeed) newVelocity.length() else topSpeed
+            newVelocity = newVelocity.normalize().scale(mag)
+        }
+
         return newVelocity
     }
 
@@ -165,7 +264,7 @@ class GenericLandBehaviour : RidingBehaviour<GenericLandSettings, GenericLandSta
     *  Normalizes the current speed between minSpeed and maxSpeed.
     *  The result is clamped between 0.0 and 1.0, where 0.0 represents minSpeed and 1.0 represents maxSpeed.
     */
-    private fun normalizeSpeed(currSpeed: Double, minSpeed: Double, maxSpeed: Double): Double {
+    private fun normalizeVal(currSpeed: Double, minSpeed: Double, maxSpeed: Double): Double {
         require(maxSpeed > minSpeed) { "maxSpeed must be greater than minSpeed" }
         return ((currSpeed - minSpeed) / (maxSpeed - minSpeed)).coerceIn(0.0, 1.0)
     }
@@ -217,8 +316,6 @@ class GenericLandBehaviour : RidingBehaviour<GenericLandSettings, GenericLandSta
         driver: Player
     ): Float {
         //Retrieve stamina from state and tick up at a rate of 0.1 a second
-        val staminaGain = (1.0 / 20.0) * 0.1
-        state.stamina.set(min(state.stamina.get() + staminaGain, 1.0).toFloat())
         return (state.stamina.get() / 1.0f)
     }
 
@@ -229,10 +326,7 @@ class GenericLandBehaviour : RidingBehaviour<GenericLandSettings, GenericLandSta
         driver: Player,
         jumpStrength: Int
     ): Vec3 {
-        val runtime = vehicle.runtime
-        runtime.environment.query.addFunction("jump_strength") { DoubleValue(jumpStrength.toDouble()) }
-        val jumpVector = settings.jumpVector.map { runtime.resolveFloat(it) }
-        return Vec3(jumpVector[0].toDouble(), jumpVector[1].toDouble(), jumpVector[2].toDouble())
+        return Vec3.ZERO
     }
 
     override fun gravity(
@@ -324,24 +418,15 @@ class GenericLandBehaviour : RidingBehaviour<GenericLandSettings, GenericLandSta
 class GenericLandSettings : RidingBehaviourSettings {
     override val key = GenericLandBehaviour.KEY
 
-    var driveFactor = "1.0".asExpression()
+    var canJump = "true".asExpression()
         private set
 
-    var strafeFactor = "0.2".asExpression()
-        private set
-
-    var reverseDriveFactor = "0.25".asExpression()
-        private set
-
-    var topSpeedExpr: Expression = "q.get_ride_stats('SPEED', 'LAND', 1.0, 0.3)".asExpression()
+    var speedExpr: Expression = "q.get_ride_stats('SPEED', 'LAND', 1.0, 0.3)".asExpression()
         private set
 
     // Max accel is a whole 1.0 in 1 second. The conversion in the function below is to convert seconds to ticks
-    var accelExpr: Expression =
-        "q.get_ride_stats('ACCELERATION', 'LAND', (1.0 / (20.0 * 0.5)), (1.0 / (20.0 * 5.0)))".asExpression()
-        private set
-
-    var jumpVector = listOf("0".asExpression(), "0.3".asExpression(), "0".asExpression())
+    var accelerationExpr: Expression =
+        "q.get_ride_stats('ACCELERATION', 'LAND', (1.0 / (20.0 * 1.5)), (1.0 / (20.0 * 5.0)))".asExpression()
         private set
 
     // Between 30 seconds and 10 seconds at the lowest when at full speed.
@@ -357,30 +442,16 @@ class GenericLandSettings : RidingBehaviourSettings {
 
     override fun encode(buffer: RegistryFriendlyByteBuf) {
         buffer.writeResourceLocation(key)
-        buffer.writeExpression(driveFactor)
-        buffer.writeExpression(strafeFactor)
-        buffer.writeExpression(reverseDriveFactor)
-        buffer.writeExpression(topSpeedExpr)
-        buffer.writeExpression(accelExpr)
-        buffer.writeExpression(jumpVector[0])
-        buffer.writeExpression(jumpVector[1])
-        buffer.writeExpression(jumpVector[2])
+        buffer.writeExpression(speedExpr)
+        buffer.writeExpression(accelerationExpr)
         buffer.writeExpression(staminaExpr)
         buffer.writeExpression(jumpExpr)
         buffer.writeExpression(handlingExpr)
     }
 
     override fun decode(buffer: RegistryFriendlyByteBuf) {
-        driveFactor = buffer.readExpression()
-        strafeFactor = buffer.readExpression()
-        reverseDriveFactor = buffer.readExpression()
-        topSpeedExpr = buffer.readExpression()
-        accelExpr = buffer.readExpression()
-        jumpVector = listOf(
-            buffer.readExpression(),
-            buffer.readExpression(),
-            buffer.readExpression()
-        )
+        speedExpr = buffer.readExpression()
+        accelerationExpr = buffer.readExpression()
         staminaExpr = buffer.readExpression()
         jumpExpr = buffer.readExpression()
         handlingExpr = buffer.readExpression()
@@ -394,7 +465,6 @@ class GenericLandState : RidingBehaviourState() {
     override fun copy() = GenericLandState().also {
         it.rideVelocity.set(this.rideVelocity.get(), forced = true)
         it.stamina.set(this.stamina.get(), forced = true)
-        it.currSpeed.set(this.currSpeed.get(), forced = true)
     }
 
     override fun shouldSync(previous: RidingBehaviourState): Boolean {

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

@@ -0,0 +1,479 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.riding.behaviour.types
+
+import com.bedrockk.molang.Expression
+import com.bedrockk.molang.runtime.MoLangMath.lerp
+import com.cobblemon.mod.common.api.riding.RidingStyle
+import com.cobblemon.mod.common.api.riding.behaviour.*
+import com.cobblemon.mod.common.api.riding.posing.PoseOption
+import com.cobblemon.mod.common.api.riding.posing.PoseProvider
+import com.cobblemon.mod.common.entity.PoseType
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.util.*
+import net.minecraft.network.RegistryFriendlyByteBuf
+import net.minecraft.util.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 HoverBehaviour : RidingBehaviour<HoverSettings, HoverState> {
+    companion object {
+        val KEY = cobblemonResource("air/hover")
+    }
+
+    override val key = KEY
+    override val style = RidingStyle.AIR
+
+    val poseProvider = PoseProvider<HoverSettings, HoverState>(PoseType.STAND)
+        .with(PoseOption(PoseType.WALK) { _, state, _ ->
+            return@PoseOption abs(state.rideVelocity.get().z) > 0.2
+        })
+
+    override fun isActive(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity
+    ): Boolean {
+        return Shapes.create(vehicle.boundingBox).blockPositionsAsListRounded().any {
+            //Need to check other fluids
+            if (vehicle.isInWater || vehicle.isUnderWater) {
+                return@any false
+            }
+            //This might not actually work, depending on what the yPos actually is. yPos of the middle of the entity? the feet?
+            if (it.y.toDouble() == (vehicle.position().y)) {
+                val blockState = vehicle.level().getBlockState(it.below())
+                return@any !blockState.isAir && blockState.fluidState.isEmpty
+            }
+            true
+        }
+    }
+
+    override fun pose(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity
+    ): PoseType {
+        return this.poseProvider.select(settings, state, vehicle)
+    }
+
+    override fun speed(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity,
+        driver: Player
+    ): Float {
+        return state.rideVelocity.get().length().toFloat()
+    }
+
+    override fun updatePassengerRotation(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity,
+        driver: LivingEntity
+    ) {
+
+        //Take the inverse so that it cancels out how
+        //much the entity rotates.
+        val turnAmount = calcRotAmount(settings, state, vehicle, driver)
+
+        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr)
+        val maxYawDiff = 90.0f
+
+        //Normalize the current rotation diff
+        val rotMod = Mth.wrapDegrees(driver.yRot - vehicle.yRot) / maxYawDiff
+
+        val rotAmount = 10.0f
+
+        //Take the inverse so that you turn more at higher speeds
+        val normSpeed = 1.0f - 0.5f*normalizeVal(state.rideVelocity.get().length(), 0.0, topSpeed).toFloat()
+
+        //driver.yRot += (entity.riding.deltaRotation.y - turnAmount)
+        //driver.setYHeadRot(driver.yHeadRot + (entity.riding.deltaRotation.y) - turnAmount)
+    }
+
+    override fun clampPassengerRotation(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity,
+        driver: LivingEntity
+    ) {
+        val f = Mth.wrapDegrees(driver.yRot - vehicle.yRot)
+        val lookYawLimit = 90.0f
+        val g = Mth.clamp(f, -lookYawLimit, lookYawLimit)
+        driver.yRotO += g - f
+        driver.yRot = driver.yRot + g - f
+        driver.setYHeadRot(driver.yRot)
+    }
+
+
+    override fun rotation(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity,
+        driver: LivingEntity
+    ): Vec2 {
+        val turnAmount =  calcRotAmount(settings, state, vehicle, driver)
+
+        return Vec2(driver.xRot, vehicle.yRot + turnAmount )
+
+    }
+
+    /*
+   *  Calculates the rotation amount given the difference between
+   *  the current player y rot and entity y rot. This gives the
+   *  affect of influencing a rides rotation through the mouse
+   *  without it being instant.
+   */
+    fun calcRotAmount(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity,
+        driver: LivingEntity
+    ): Float {
+        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr)
+        //In degrees per second
+        val handling = vehicle.runtime.resolveDouble(settings.handlingExpr)
+        val maxYawDiff = 90.0f
+
+        //Normalize the current rotation diff
+        val rotDiff = Mth.wrapDegrees(driver.yRot - vehicle.yRot)
+        val rotDiffNorm = rotDiff / maxYawDiff
+
+        //Take the square root so that the ride levels out quicker when at lower differences between entity
+        //y and driver y
+        //This influences the speed of the turn based on how far in one direction you're looking
+        val rotDiffMod = (sqrt(abs(rotDiffNorm)) * rotDiffNorm.sign)
+
+        //Take the inverse so that you turn less at higher speeds
+        val normSpeed = 1.0f // = 1.0f - 0.5f*normalizeVal(state.rideVelocityocity.length(), 0.0, topSpeed).toFloat()
+
+        // TODO: This needs to be tweaked with in game results and testing
+        val turnRate = (handling.toFloat() / 20.0f) * 2
+
+        //Ensure you only ever rotate as much difference as there is between the angles.
+        val turnSpeed = turnRate  * rotDiffMod * normSpeed
+        val rotAmount = turnSpeed.coerceIn(-abs(rotDiff), abs(rotDiff))
+
+        return rotAmount
+    }
+
+
+    override fun velocity(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        input: Vec3
+    ): Vec3 {
+
+        val strafeFactor = 0.2
+        val f = driver.xxa * strafeFactor
+        var g = driver.zza
+        if (g <= 0.0f) {
+            g *= -1.0f
+        }
+
+        return calculateRideSpaceVel(settings, state, vehicle, driver).scale(10.0)
+    }
+
+    private fun calculateRideSpaceVel(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity,
+        driver: Player
+    ): Vec3 {
+        val topSpeed = vehicle.runtime.resolveDouble(settings.speedExpr)
+        val accel = vehicle.runtime.resolveDouble(settings.accelerationExpr)
+        val speed = state.rideVelocity.get().length()
+
+        //Flag for determining if player is actively inputting
+        var activeInput = false
+
+        val minSpeed = 0.0
+
+        var newVelocity = Vec3(state.rideVelocity.get().x, state.rideVelocity.get().y, state.rideVelocity.get().z)
+
+        var jumpVec = Vec3.ZERO
+
+
+        //speed up and slow down based on input
+        if (driver.zza != 0.0f && state.stamina.get() > 0.0) {
+            //make sure it can't exceed top speed
+            val forwardInput = when {
+                driver.zza > 0 && newVelocity.z > topSpeed -> 0.0
+                driver.zza < 0 && newVelocity.z < (-topSpeed / 3.0) -> 0.0
+                else -> driver.zza.sign
+            }
+
+            newVelocity = Vec3(
+                newVelocity.x,
+                newVelocity.y,
+                (newVelocity.z + (accel * forwardInput.toDouble())))
+
+            activeInput = true
+            jumpVec = jumpVec.add(0.0, 0.0, forwardInput.toDouble())
+        }
+
+        //speed up and slow down based on input
+        if (driver.xxa != 0.0f && state.stamina.get() > 0.0) {
+            //make sure it can't exceed top speed
+            val forwardInput = when {
+                driver.xxa > 0 && newVelocity.x > topSpeed -> 0.0
+                driver.xxa < 0 && newVelocity.x < (-topSpeed / 3.0) -> 0.0
+                else -> driver.xxa.sign
+            }
+
+            newVelocity = Vec3(
+                newVelocity.x + (accel * forwardInput.toDouble()),
+                newVelocity.y,
+                (newVelocity.z ))
+
+            activeInput = true
+        }
+
+        //Vertical movement based on driver input.
+        val vertTopSpeed = topSpeed / 2.0
+        val vertInput = when {
+            driver.jumping -> 1.0
+            driver.isShiftKeyDown -> -1.0
+            else -> 0.0
+        }
+
+        if (vertInput != 0.0 && state.stamina.get() > 0.0) {
+            newVelocity = Vec3(
+                newVelocity.x,
+                (newVelocity.y + (accel * vertInput)).coerceIn(-vertTopSpeed, vertTopSpeed),
+                newVelocity.z)
+            activeInput = true
+        }
+
+
+        //air Friction
+
+
+
+        return newVelocity
+    }
+
+    /*
+    *  Normalizes the current speed between minSpeed and maxSpeed.
+    *  The result is clamped between 0.0 and 1.0, where 0.0 represents minSpeed and 1.0 represents maxSpeed.
+    */
+    private fun normalizeVal(currSpeed: Double, minSpeed: Double, maxSpeed: Double): Double {
+        require(maxSpeed > minSpeed) { "maxSpeed must be greater than minSpeed" }
+        return ((currSpeed - minSpeed) / (maxSpeed - minSpeed)).coerceIn(0.0, 1.0)
+    }
+
+    override fun angRollVel(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        deltaTime: Double
+    ): Vec3 {
+        return Vec3.ZERO
+    }
+
+    override fun rotationOnMouseXY(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        mouseY: Double,
+        mouseX: Double,
+        mouseYSmoother: SmoothDouble,
+        mouseXSmoother: SmoothDouble,
+        sensitivity: Double,
+        deltaTime: Double
+    ): Vec3 {
+        //Smooth out mouse input.
+        val smoothingSpeed = 4
+        val xInput = mouseXSmoother.getNewDeltaValue(mouseX * 0.1, deltaTime * smoothingSpeed);
+        val yInput = mouseYSmoother.getNewDeltaValue(mouseY * 0.1, deltaTime * smoothingSpeed);
+
+        //yaw, pitch, roll
+        return Vec3(0.0, yInput, xInput)
+    }
+
+    override fun canJump(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity,
+        driver: Player
+    ): Boolean {
+        return false
+    }
+
+    override fun setRideBar(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity,
+        driver: Player
+    ): Float {
+        //Retrieve stamina from state and use it to set the "stamina bar"
+        return (state.stamina.get() / 1.0f)
+    }
+
+    override fun jumpForce(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity,
+        driver: Player,
+        jumpStrength: Int
+    ): Vec3 {
+        return Vec3.ZERO
+    }
+
+    override fun gravity(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity,
+        regularGravity: Double
+    ): Double {
+        return 0.0
+    }
+
+    override fun rideFovMultiplier(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity,
+        driver: Player
+    ): Float {
+        return 1.0f
+    }
+
+    override fun useAngVelSmoothing(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity
+    ): Boolean {
+        return false
+    }
+
+    override fun useRidingAltPose(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity,
+        driver: Player
+    ): Boolean {
+        return false
+    }
+
+    override fun inertia(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity
+    ): Double {
+        return 0.05
+    }
+
+    override fun shouldRoll(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity
+    ): Boolean {
+        return false
+    }
+
+    override fun turnOffOnGround(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity
+    ): Boolean {
+        return false
+    }
+
+    override fun dismountOnShift(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity
+    ): Boolean {
+        return false
+    }
+
+    override fun shouldRotatePokemonHead(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity
+    ): Boolean {
+        return false
+    }
+
+    override fun shouldRotatePlayerHead(
+        settings: HoverSettings,
+        state: HoverState,
+        vehicle: PokemonEntity
+    ): Boolean {
+        return false
+    }
+
+    override fun createDefaultState(settings: HoverSettings) = HoverState()
+}
+
+class HoverSettings : RidingBehaviourSettings {
+    override val key = HoverBehaviour.KEY
+
+    var canJump = "true".asExpression()
+        private set
+
+    var speedExpr: Expression = "q.get_ride_stats('SPEED', 'AIR', 1.0, 0.3)".asExpression()
+        private set
+
+    // Max accel is a whole 1.0 in 1 second. The conversion in the function below is to convert seconds to ticks
+    var accelerationExpr: Expression =
+        "q.get_ride_stats('ACCELERATION', 'AIR', (1.0 / (20.0 * 0.5)), (1.0 / (20.0 * 5.0)))".asExpression()
+        private set
+
+    // Between 30 seconds and 10 seconds at the lowest when at full speed.
+    var staminaExpr: Expression = "q.get_ride_stats('STAMINA', 'AIR', 30.0, 10.0)".asExpression()
+        private set
+
+    //Between a one block jump and a ten block jump
+    var jumpExpr: Expression = "q.get_ride_stats('JUMP', 'AIR', 10.0, 1.0)".asExpression()
+        private set
+
+    var handlingExpr: Expression = "q.get_ride_stats('SKILL', 'AIR', 140.0, 20.0)".asExpression()
+        private set
+
+    override fun encode(buffer: RegistryFriendlyByteBuf) {
+        buffer.writeResourceLocation(key)
+        buffer.writeExpression(speedExpr)
+        buffer.writeExpression(accelerationExpr)
+        buffer.writeExpression(staminaExpr)
+        buffer.writeExpression(jumpExpr)
+        buffer.writeExpression(handlingExpr)
+    }
+
+    override fun decode(buffer: RegistryFriendlyByteBuf) {
+        speedExpr = buffer.readExpression()
+        accelerationExpr = buffer.readExpression()
+        staminaExpr = buffer.readExpression()
+        jumpExpr = buffer.readExpression()
+        handlingExpr = buffer.readExpression()
+    }
+
+}
+
+class HoverState : RidingBehaviourState() {
+
+    override fun copy() = HoverState().also {
+        it.rideVelocity.set(this.rideVelocity.get(), forced = true)
+        it.stamina.set(this.stamina.get(), forced = true)
+    }
+
+    override fun shouldSync(previous: RidingBehaviourState): Boolean {
+        if (previous !is HoverState) return false
+        return super.shouldSync(previous)
+    }
+}

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

@@ -26,6 +26,7 @@ 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 JetAirBehaviour : RidingBehaviour<JetAirSettings, JetAirState> {
@@ -40,7 +41,18 @@ class JetAirBehaviour : RidingBehaviour<JetAirSettings, JetAirState> {
         .with(PoseOption(PoseType.FLY) { _, state, _ -> state.rideVelocity.get().z > 0.1 })
 
     override fun isActive(settings: JetAirSettings, state: JetAirState, vehicle: PokemonEntity): Boolean {
-        return true
+        return Shapes.create(vehicle.boundingBox).blockPositionsAsListRounded().any {
+            //Need to check other fluids
+            if (vehicle.isInWater || vehicle.isUnderWater) {
+                return@any false
+            }
+            //This might not actually work, depending on what the yPos actually is. yPos of the middle of the entity? the feet?
+            if (it.y.toDouble() == (vehicle.position().y)) {
+                val blockState = vehicle.level().getBlockState(it.below())
+                return@any !(!blockState.isAir && blockState.fluidState.isEmpty)
+            }
+            true
+        }
     }
 
     override fun pose(settings: JetAirSettings, state: JetAirState, vehicle: PokemonEntity): PoseType {
@@ -55,22 +67,24 @@ class JetAirBehaviour : RidingBehaviour<JetAirSettings, JetAirState> {
         //retrieve minSpeed
         val minSpeed = vehicle.runtime.resolveDouble(settings.minSpeed)
 
-        //Reduce stamina unless stamina is infinite
-        if (!vehicle.runtime.resolveBoolean(settings.infiniteStamina)) {
-            //Calculate stamina loss due to speed
-            //At max speed it will tick down 0.1 a second so the stamina will last ten seconds
-            //There has got to be a better way to express this equation. It interpolates between 0.5 and 1.0
-            var staminaRate = (normalizeSpeed(state.rideVelocity.get().length(), minSpeed, topSpeed))
-
-            //interpolate between 0.25 and 1.0 so that you always have at least a min of 0.25 stam loss
-            staminaRate = 0.25 + (0.75 * staminaRate.pow(3))
-
-            //Calculate stamina loss in seconds achievable at top speed
-            val staminaLoss = staminaRate * (1.0 / (20.0 * staminaStat))
-            state.stamina.set(max(state.stamina.get() - staminaLoss, 0.0).toFloat())
-        } else {
-            state.stamina.set(1.0f)
-        }
+        //TODO: Reintroduce stamina drain once stats start to be polished and tweaked
+        state.stamina.set(1.0f)
+//        //Reduce stamina unless stamina is infinite
+//        if (!vehicle.runtime.resolveBoolean(settings.infiniteStamina)) {
+//            //Calculate stamina loss due to speed
+//            //At max speed it will tick down 0.1 a second so the stamina will last ten seconds
+//            //There has got to be a better way to express this equation. It interpolates between 0.5 and 1.0
+//            var staminaRate = (normalizeSpeed(state.rideVelocity.get().length(), minSpeed, topSpeed))
+//
+//            //interpolate between 0.25 and 1.0 so that you always have at least a min of 0.25 stam loss
+//            staminaRate = 0.25 + (0.75 * staminaRate.pow(3))
+//
+//            //Calculate stamina loss in seconds achievable at top speed
+//            val staminaLoss = staminaRate * (1.0 / (20.0 * staminaStat))
+//            state.stamina.set(max(state.stamina.get() - staminaLoss, 0.0).toFloat())
+//        } else {
+//            state.stamina.set(1.0f)
+//        }
 
         return state.rideVelocity.get().length().toFloat()
     }
@@ -160,7 +174,7 @@ class JetAirBehaviour : RidingBehaviour<JetAirSettings, JetAirState> {
             state.rideVelocity.set(Vec3(state.rideVelocity.get().x, state.rideVelocity.get().y, max(state.rideVelocity.get().z - ((accel) / 4), minSpeed)))
         } else if (driver.zza < 0.0 && speed > minSpeed) {
             //modify deccel to be slower when at closer speeds to minimum speed
-            val deccelMod = max((normalizeSpeed(speed, minSpeed, topSpeed) - 1).pow(2), 0.1)
+            val deccelMod = max((normalizeSpeed(speed, minSpeed, topSpeed) - 1).pow(2) * 8, 0.1)
 
             //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 - ((accel * deccelMod) / 2), minSpeed)))
@@ -212,8 +226,13 @@ class JetAirBehaviour : RidingBehaviour<JetAirSettings, JetAirState> {
         val invertRoll = if (Cobblemon.config.invertRoll) -1 else 1
         val invertPitch = if (Cobblemon.config.invertPitch) -1 else 1
 
-        // Accumulate the mouse input
-        state.currMouseXForce.set((state.currMouseXForce.get() + (0.0015 * mouseX * invertRoll)).coerceIn(-1.0, 1.0))
+        // Smooth out and accumulate roll input
+        val smoothingSpeed = 4.0
+        val mouseXc = (mouseX).coerceIn(-60.0, 60.0)
+        val xInput = mouseXSmoother.getNewDeltaValue(mouseXc * 0.1 * invertRoll, deltaTime * smoothingSpeed);
+
+        // Accumulate the y mouse input for pitch
+        //state.currMouseXForce.set((state.currMouseXForce.get() + (0.0015 * mouseX * invertRoll)).coerceIn(-1.0, 1.0))
         state.currMouseYForce.set((state.currMouseYForce.get() + (0.0015 * mouseY * invertPitch)).coerceIn(-1.0, 1.0))
 
         //Get handling in degrees per second
@@ -235,8 +254,9 @@ class JetAirBehaviour : RidingBehaviour<JetAirSettings, JetAirState> {
         val pitchRot = handling * state.currMouseYForce.get()
 
         //Roll is 1.5 times as fast as pitch
-        val rollRot = handling * 1.5 * state.currMouseXForce.get()
 
+        //val rollRot = handling * 1.5 * state.currMouseXForce.get()
+        val rollRot = handling * 1.5 * xInput.coerceIn(-1.0,1.0)
         //yaw, pitch, roll
         return Vec3(0.0, pitchRot, rollRot)
     }
@@ -345,10 +365,10 @@ class JetAirSettings : RidingBehaviourSettings {
     var gravity: Expression = "0".asExpression()
         private set
 
-    var minSpeed: Expression = "1.2".asExpression()
+    var minSpeed: Expression = "0.8".asExpression()
         private set
 
-    var handlingYawExpr: Expression = "q.get_ride_stats('SKILL', 'AIR', 25.0, 8.0)".asExpression()
+    var handlingYawExpr: Expression = "q.get_ride_stats('SKILL', 'AIR', 50.0, 25.0)".asExpression()
         private set
 
     // Make configurable by json
@@ -362,7 +382,7 @@ class JetAirSettings : RidingBehaviourSettings {
         private set
     var handlingExpr: Expression =  "q.get_ride_stats('SKILL', 'AIR', 140.0, 20.0)".asExpression()
         private set
-    var speedExpr: Expression =  "q.get_ride_stats('SPEED', 'AIR', 2.5, 1.0)".asExpression()
+    var speedExpr: Expression =  "q.get_ride_stats('SPEED', 'AIR', 1.8, 1.0)".asExpression()
         private set
     var accelerationExpr: Expression = "q.get_ride_stats('ACCELERATION', 'AIR', (1.0 / (20.0 * 1.0)), (1.0 / (20.0 * 5.0)))".asExpression()
         private set
@@ -399,8 +419,8 @@ class JetAirSettings : RidingBehaviourSettings {
 
 class JetAirState : RidingBehaviourState() {
     var currSpeed = ridingState(0.0, Side.CLIENT)
-    var currMouseXForce = ridingState(0.0, Side.BOTH)
-    var currMouseYForce = ridingState(0.0, Side.BOTH)
+    var currMouseXForce = ridingState(0.0, Side.CLIENT)
+    var currMouseYForce = ridingState(0.0, Side.CLIENT)
 
     override fun encode(buffer: FriendlyByteBuf) {
         super.encode(buffer)
@@ -424,8 +444,8 @@ class JetAirState : RidingBehaviourState() {
         it.currSpeed.set(currSpeed.get(), forced = true)
         it.stamina.set(stamina.get(), forced = true)
         it.rideVelocity.set(rideVelocity.get(), forced = true)
-        it.currMouseXForce.set(currMouseXForce.get(), forced = true)
-        it.currMouseYForce.set(currMouseYForce.get(), forced = true)
+//        it.currMouseXForce.set(currMouseXForce.get(), forced = true)
+//        it.currMouseYForce.set(currMouseYForce.get(), forced = true)
     }
 
     override fun shouldSync(previous: RidingBehaviourState): Boolean {

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

@@ -387,6 +387,8 @@ class CompositeState(
         super.reset()
         activeController.set(defaultBehaviour, forced = true)
         lastTransition.set(-100L, forced = true)
+        defaultBehaviourState.reset()
+        alternateBehaviourState.reset()
     }
 
     override fun copy(): CompositeState {
@@ -402,17 +404,23 @@ class CompositeState(
     override fun shouldSync(previous: RidingBehaviourState): Boolean {
         if (previous !is CompositeState) return false
         if (previous.activeController.get() != activeController.get()) return true
+        if (defaultBehaviourState.shouldSync(previous.defaultBehaviourState)) return true
+        if (alternateBehaviourState.shouldSync(previous.alternateBehaviourState)) return true
         return super.shouldSync(previous)
     }
 
     override fun encode(buffer: FriendlyByteBuf) {
         super.encode(buffer)
         buffer.writeResourceLocation(activeController.get())
+        defaultBehaviourState.encode(buffer)
+        alternateBehaviourState.encode(buffer)
     }
 
     override fun decode(buffer: FriendlyByteBuf) {
         super.decode(buffer)
         activeController.set(buffer.readResourceLocation(), forced = true)
+        defaultBehaviourState.decode(buffer)
+        alternateBehaviourState.decode(buffer)
     }
 
 }

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

@@ -43,6 +43,7 @@ interface CompositeRidingStrategy<T : CompositeSettings> {
     ) {
         toState.stamina.set(fromState.stamina.get())
         toState.rideVelocity.set(fromState.rideVelocity.get())
+        fromState.reset()
         state.activeController.set(toSettings.key)
         state.lastTransition.set(vehicle.level().gameTime)
         val behaviour = RidingBehaviours.get(toSettings.key)

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

@@ -46,9 +46,11 @@ object RunStrategy : CompositeRidingStrategy<CompositeSettings> {
         driver: Player
     ): Boolean {
         if (state.activeController.get() == defaultSettings.key) return false
+        if (!entity.onGround()) return false
         if (state.lastTransition.get() + 20 >= entity.level().gameTime) return false
         val defaultBehaviour = RidingBehaviours.get(defaultSettings.key)
-        return !driver.isSprinting || defaultBehaviour.isActive(defaultSettings, state.defaultBehaviourState, entity)
+        val ret = defaultBehaviour.isActive(defaultSettings, state.defaultBehaviourState, entity)
+        return ret
     }
 
     private fun shouldTransitionToAlternate(

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

@@ -0,0 +1,143 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.riding.util
+
+import com.cobblemon.mod.common.OrientationControllable
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.util.math.geometry.toRadians
+import net.minecraft.util.Mth
+import net.minecraft.world.phys.Vec3
+import org.joml.Matrix3f
+import org.joml.Quaternionf
+import org.joml.Vector3f
+
+/**
+ * Class to handle the updating and containment of ride data used in animation.
+ *
+ * @author Jackowes
+ * @since April 7th, 2025
+ */
+
+
+class RidingAnimationData
+{
+    var prevOrientation: Matrix3f = Matrix3f()
+    var prevRot: Vec3 = Vec3.ZERO
+    var velocitySpring: Vec3Spring = Vec3Spring()
+    var rotSpring: Vec3Spring = Vec3Spring()
+    var rotDeltaSpring: Vec3Spring = Vec3Spring()
+    var localVelocitySpring: Vec3Spring = Vec3Spring()
+
+    fun update(entity: PokemonEntity) {
+
+        var currRot = Vec3.ZERO
+        var angDelta = Vec3.ZERO
+
+//        val stiffness = 90.0
+//        val damping = 18.0
+        val stiffness = 16.0
+        val damping = 8.0
+
+        // Update velocity first
+        val currentVelocity = Vec3(
+            entity.x - entity.xOld,
+            entity.y - entity.yOld,
+            entity.z - entity.zOld
+        )
+
+        val r = entity.ifRidingAvailableSupply(false) { behaviour, settings, state ->
+            behaviour.shouldRoll(settings, state, entity);
+        }
+        if( r ) {
+            //TODO: should this return?
+            val controller = (entity.firstPassenger as? OrientationControllable)?.orientationController ?: return
+            val orientation = controller.orientation ?: Matrix3f()
+
+            val currPitch = controller.pitch
+            val currYaw = controller.yaw
+            val currRoll = controller.roll
+            currRot = Vec3(currPitch.toDouble(), currYaw.toDouble(), currRoll.toDouble())
+
+            val currOrientation = orientation
+
+            /******************************************************
+             * Calculate current 3d euler rotation deltas in the
+             * entities local space
+             *****************************************************/
+
+            // Get current and previous orientation as quaternions
+            val currQuat = Quaternionf().setFromUnnormalized(currOrientation)
+            val prevQuat = Quaternionf().setFromUnnormalized(prevOrientation)
+
+            // Compute deltaQuat = current * inverse(previous)
+            val deltaQuat = Quaternionf(currQuat).mul(Quaternionf(prevQuat).invert())
+
+            // Transform delta into the local space of the current orientation
+            val localDeltaQuat = Quaternionf(currQuat).invert().mul(deltaQuat).mul(currQuat)
+
+            // Convert delta rotation to Euler angles
+            val euler = Vector3f()
+            localDeltaQuat.getEulerAnglesXYZ(euler) // Angles are in radians
+
+            // Convert to degrees
+            val pitchDegrees = Math.toDegrees(euler.x.toDouble()) // Rotation around X axis = pitch
+            val yawDegrees = Math.toDegrees(euler.y.toDouble())   // Rotation around Y axis = yaw
+            val rollDegrees = Math.toDegrees(euler.z.toDouble())  // Rotation around Z axis = roll
+            //Scale rotation delta by 20 to represent degree per second instead of tick
+            angDelta = Vec3(pitchDegrees, yawDegrees, rollDegrees).scale(20.0)
+
+            /******************************************************
+             * Calculate ride local velocity
+             *****************************************************/
+            val velocityWorldF = Vector3f(currentVelocity.x.toFloat(), currentVelocity.y.toFloat(), currentVelocity.z.toFloat())
+
+            val localVelocityF = Matrix3f(orientation).transpose().transform(velocityWorldF)
+            val localVelocity = Vec3(localVelocityF.x.toDouble(), localVelocityF.y.toDouble(), localVelocityF.z.toDouble())
+
+            localVelocitySpring.update(localVelocity, stiffness, damping)
+
+            // Update previous values
+            prevOrientation.set(currOrientation)
+        } else {
+            val currPitch = entity.xRot
+            val currYaw = entity.yRot
+            val currRoll = 0.0f
+            currRot = Vec3(currPitch.toDouble(), currYaw.toDouble(), currRoll.toDouble())
+
+            //Scale rotation delta by 20 to represent degree per second instead of tick
+            angDelta = Vec3(
+                (currRot.x - prevRot.x),
+                Mth.degreesDifference(currRot.y.toFloat(), prevRot.y.toFloat()).toDouble(),
+                Mth.degreesDifference(currRot.z.toFloat(), prevRot.z.toFloat()).toDouble()
+            ).scale(20.0)
+
+            /******************************************************
+             * Calculate ride local velocity
+             *****************************************************/
+            val yaw360 = -1.0 * (entity.yRot + 360.0f) % 360.0f
+            val orientationNonRollable = Matrix3f().rotateY(yaw360.toRadians())
+
+            //Convert to Vector3f
+            var velocityWorldF = Vector3f(currentVelocity.x.toFloat(), currentVelocity.y.toFloat(), currentVelocity.z.toFloat())
+
+            val localVelocityF = Matrix3f(orientationNonRollable).transpose().transform(velocityWorldF)
+            val localVelocity = Vec3(localVelocityF.x.toDouble(), localVelocityF.y.toDouble(), localVelocityF.z.toDouble())
+
+            localVelocitySpring.update(localVelocity, stiffness, damping)
+        }
+
+        /******************************************************
+         * Update springs
+         *****************************************************/
+        rotDeltaSpring.update(angDelta, stiffness, damping)
+        velocitySpring.update(currentVelocity, stiffness, damping)
+        rotSpring.update(currRot, stiffness, damping)
+        prevRot = currRot
+    }
+}

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

@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.riding.util
+
+import net.minecraft.world.phys.Vec3
+import kotlin.math.min
+
+/**
+ * A spring-based smoother for Vec3 values, designed for applying damped spring motion to riding data.
+ * Stores the previous and current values, along with a history buffer for lookback-based interpolation.
+ *
+ * @author Jackowes
+ * @since March 27th, 2025
+ */
+
+
+class Vec3Spring(
+    var value: Vec3 = Vec3.ZERO,
+    var velocity: Vec3 = Vec3.ZERO
+) {
+    val history = ArrayDeque<Vec3>()
+    //Hold up to a seconds worth of values
+    val lookBackSize = 20
+
+    fun update(target: Vec3, stiffness: Double, damping: Double) {
+
+        //Hooke's Law f = kx where:
+        //f is force
+        //k is the spring constant or stiffness of this spring
+        //x is the distance from rest and in this case the difference between the most recent
+        //rotation delta ( the target ) and the springs current value for delta rot
+        val force = target.subtract(value).scale(stiffness)
+
+        //Now calculate acceleration and apply damping
+        val accel = force.subtract(velocity.scale(damping))
+
+        velocity = velocity.add(accel.scale(1.0/20.0))
+        value = value.add(velocity.scale(1.0/20.0))
+
+        history.addFirst(value)
+        //Adding one since if we want to check max look back point it needs something to interp with.
+        if( history.size > lookBackSize + 1) {
+            history.removeLast()
+        }
+    }
+
+    fun getInterpolated(partialTick: Double, lookBackTick: Int): Vec3 {
+        if (history.size < 2) {
+            return value // or Vec3.ZERO if you prefer
+        }
+
+        val tick = min(lookBackTick, history.size - 2)
+        var ret = Vec3.ZERO
+        for( i in 0..tick) {
+            val older = history.get(i + 1).scale(1.0)
+            val newer = history.get(i).scale(1.0)
+            ret = ret.add(older.add(newer.subtract(older).scale(partialTick)))
+        }
+
+        return ret.scale(1.0/(tick+1))
+    }
+}

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

@@ -35,6 +35,7 @@ import com.cobblemon.mod.common.client.render.models.blockbench.quirk.ModelQuirk
 import com.cobblemon.mod.common.client.render.models.blockbench.quirk.QuirkData
 import com.cobblemon.mod.common.entity.PosableEntity
 import com.cobblemon.mod.common.entity.PoseType
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
 import com.mojang.brigadier.StringReader
 import com.mojang.brigadier.exceptions.CommandSyntaxException
@@ -131,8 +132,137 @@ abstract class PosableState : Schedulable {
     /** A list of items to be rendered on a PosableModel during an animation */
     val animationItems = mutableMapOf<String, ItemStack>()
 
+    /** All of the MoLang functions that can be expose current riding data. */
+    val ridingFunctions = QueryStruct(hashMapOf())
+        .addFunction("pitch") { params ->
+            val lookBackTick = params.getInt(0)
+
+            val pokemon = getEntity() as? PokemonEntity ?: return@addFunction DoubleValue(0.0)
+            val partialTickPitch = pokemon.ridingAnimationData.rotSpring.getInterpolated(currentPartialTicks.toDouble(), lookBackTick).x
+            val maxPitch = 90.0
+            return@addFunction DoubleValue((partialTickPitch / maxPitch).coerceIn(-1.0,1.0))
+        }
+        .addFunction("yaw") { params ->
+            val lookBackTick = params.getInt(0)
+
+            val pokemon = getEntity() as? PokemonEntity ?: return@addFunction DoubleValue(0.0)
+            val partialTickYaw = pokemon.ridingAnimationData.rotSpring.getInterpolated(currentPartialTicks.toDouble(), lookBackTick).y
+            val maxYaw = 180.0
+            return@addFunction DoubleValue((partialTickYaw / maxYaw).coerceIn(-1.0,1.0))
+        }
+        .addFunction("roll") { params ->
+            val lookBackTick = params.getInt(0)
+
+            val pokemon = getEntity() as? PokemonEntity ?: return@addFunction DoubleValue(0.0)
+            val partialTickRoll = pokemon.ridingAnimationData.rotSpring.getInterpolated(currentPartialTicks.toDouble(), lookBackTick).z
+            val maxRoll = 180.0
+            return@addFunction DoubleValue((partialTickRoll / maxRoll).coerceIn(-1.0,1.0))
+        }
+        .addFunction("pitch_change") { params ->
+            val lookBackTick = params.getInt(0)
+
+            val pokemon = getEntity() as? PokemonEntity ?: return@addFunction DoubleValue(0.0)
+            val partialTickPitchDelta = pokemon.ridingAnimationData.rotDeltaSpring.getInterpolated(currentPartialTicks.toDouble(), lookBackTick).x
+            //TODO: hook back up the retrieval of the current behaviors stat for this and the following functions
+            val maxRotRate = 140.0//pokemon.riding.getController(pokemon)?.getStat(pokemon, RidingStat.SKILL)
+            //?: return@addFunction DoubleValue(0.0)
+            return@addFunction DoubleValue((partialTickPitchDelta / maxRotRate).coerceIn(-1.0,1.0))
+        }
+        .addFunction("yaw_change") { params ->
+            val lookBackTick = params.getInt(0)
+            val pokemon = getEntity() as? PokemonEntity ?: return@addFunction DoubleValue(0.0)
+            val partialTickYawDelta = pokemon.ridingAnimationData.rotDeltaSpring.getInterpolated(currentPartialTicks.toDouble(), lookBackTick).y
+            //TODO: make this not hardcoded
+            val maxRotRate = 140.0 //pokemon.riding.getController(pokemon)?.getStat(pokemon, RidingStat.SKILL)
+            //?: return@addFunction DoubleValue(0.0)
+            return@addFunction DoubleValue((partialTickYawDelta / maxRotRate).coerceIn(-1.0,1.0))
+        }
+        .addFunction("roll_change") { params ->
+            val lookBackTick = params.getInt(0)
+
+            val pokemon = getEntity() as? PokemonEntity ?: return@addFunction DoubleValue(0.0)
+            val partialTickRollDelta = pokemon.ridingAnimationData.rotDeltaSpring.getInterpolated(currentPartialTicks.toDouble(), lookBackTick).z
+            val maxRotRate = 140.0 //pokemon.riding.getController(pokemon)?.getStat(pokemon, RidingStat.SKILL)
+            //?: return@addFunction DoubleValue(0.0)
+            return@addFunction DoubleValue((partialTickRollDelta / maxRotRate).coerceIn(-1.0,1.0))
+        }
+        .addFunction("speed") { params ->
+            val lookBackTick = params.getInt(0)
+            val pokemon = getEntity() as? PokemonEntity ?: return@addFunction DoubleValue(0.0)
+
+            val partialTickSpeed = pokemon.ridingAnimationData.velocitySpring.getInterpolated(currentPartialTicks.toDouble(), lookBackTick).length()
+            val topSpeed = 1.0//pokemon.riding.getController(pokemon)?.getStat(pokemon, RidingStat.SPEED)
+            //?: return@addFunction DoubleValue(0.0)
+
+            return@addFunction DoubleValue((partialTickSpeed / topSpeed).coerceIn(-1.0,1.0))
+        }
+        .addFunction("velocity_x") { params ->
+            val lookBackTick = params.getInt(0)
+            val pokemon = getEntity() as? PokemonEntity ?: return@addFunction DoubleValue(0.0)
+
+            val partialTickXVel = pokemon.ridingAnimationData.velocitySpring.getInterpolated(currentPartialTicks.toDouble(), lookBackTick).x
+
+            val topSpeed = 1.0//pokemon.riding.getController(pokemon)?.getStat(pokemon, RidingStat.SPEED)
+            //?: return@addFunction DoubleValue(0.0)
+            return@addFunction DoubleValue((partialTickXVel / topSpeed).coerceIn(-1.0,1.0))
+        }
+        .addFunction("velocity_y") { params ->
+            val lookBackTick = params.getInt(0)
+            val pokemon = getEntity() as? PokemonEntity ?: return@addFunction DoubleValue(0.0)
+
+            val partialTickYVel = pokemon.ridingAnimationData.velocitySpring.getInterpolated(currentPartialTicks.toDouble(), lookBackTick).y
+
+            val topSpeed = 1.0//pokemon.riding.getController(pokemon)?.getStat(pokemon, RidingStat.SPEED)
+            //?: return@addFunction DoubleValue(0.0)
+            return@addFunction DoubleValue((partialTickYVel / topSpeed).coerceIn(-1.0,1.0))
+        }
+        .addFunction("velocity_z") { params ->
+            val lookBackTick = params.getInt(0)
+            val pokemon = getEntity() as? PokemonEntity ?: return@addFunction DoubleValue(0.0)
+
+            val partialTickZVel = pokemon.ridingAnimationData.velocitySpring.getInterpolated(currentPartialTicks.toDouble(), lookBackTick).z
+
+            val topSpeed = 1.0//pokemon.riding.getController(pokemon)?.getStat(pokemon, RidingStat.SPEED)
+            //?: return@addFunction DoubleValue(0.0)
+            return@addFunction DoubleValue((partialTickZVel / topSpeed).coerceIn(-1.0,1.0))
+        }
+        .addFunction("velocity_right") { params ->
+            val lookBackTick = params.getInt(0)
+            val pokemon = getEntity() as? PokemonEntity ?: return@addFunction DoubleValue(0.0)
+
+            val partialTickZVel = pokemon.ridingAnimationData.localVelocitySpring.getInterpolated(currentPartialTicks.toDouble(), lookBackTick).x
+
+            val topSpeed = 1.0//pokemon.riding.getController(pokemon)?.getStat(pokemon, RidingStat.SPEED)
+            //?: return@addFunction DoubleValue(0.0)
+            return@addFunction DoubleValue((partialTickZVel / topSpeed).coerceIn(-1.0,1.0) * -1.0)
+        }
+        .addFunction("velocity_upward") { params ->
+            val lookBackTick = params.getInt(0)
+            val pokemon = getEntity() as? PokemonEntity ?: return@addFunction DoubleValue(0.0)
+
+            val partialTickZVel = pokemon.ridingAnimationData.localVelocitySpring.getInterpolated(currentPartialTicks.toDouble(), lookBackTick).y
+
+            val topSpeed = 1.0//pokemon.riding.getController(pokemon)?.getStat(pokemon, RidingStat.SPEED)
+            //?: return@addFunction DoubleValue(0.0)
+            return@addFunction DoubleValue((partialTickZVel / topSpeed).coerceIn(-1.0,1.0))
+        }
+        .addFunction("velocity_forward") { params ->
+            val lookBackTick = params.getInt(0)
+            val pokemon = getEntity() as? PokemonEntity ?: return@addFunction DoubleValue(0.0)
+
+            val partialTickZVel = pokemon.ridingAnimationData.localVelocitySpring.getInterpolated(currentPartialTicks.toDouble(), lookBackTick).z
+
+            val topSpeed = 1.0//pokemon.riding.getController(pokemon)?.getStat(pokemon, RidingStat.SPEED)
+            //?: return@addFunction DoubleValue(0.0)
+            return@addFunction DoubleValue((partialTickZVel / topSpeed).coerceIn(-1.0,1.0))
+        }
+
+
     /** All of the MoLang functions that can be applied to something with this state. */
-    val functions = QueryStruct(hashMapOf())
+    val functions = QueryStruct(hashMapOf(
+        "riding" to java.util.function.Function { ridingFunctions },
+        "r" to java.util.function.Function { ridingFunctions }
+    ))
         .addFunction("anim_time") {
             reusableAnimTime.value = animationSeconds.toDouble()
             reusableAnimTime

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen7/MudsdaleModel.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.client.render.models.blockbench.pokemon.gen7
-
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonPosableModel
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.HeadedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.QuadrupedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.CryProvider
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
-import com.cobblemon.mod.common.entity.PoseType
-import net.minecraft.client.model.geom.ModelPart
-import net.minecraft.world.phys.Vec3
-
-class MudsdaleModel (root: ModelPart) : PokemonPosableModel(root), HeadedFrame, QuadrupedFrame {
-    override val rootPart = root.registerChildWithAllChildren("mudsdale")
-    override val head = getPart("neck")
-
-    override val foreLeftLeg = getPart("leg_front_left")
-    override val foreRightLeg = getPart("leg_front_right")
-    override val hindLeftLeg = getPart("leg_back_left")
-    override val hindRightLeg = getPart("leg_back_right")
-
-    override var portraitScale = 1.5F
-    override var portraitTranslation = Vec3(-1.0, 1.76, 0.0)
-
-    override var profileScale = 0.5F
-    override var profileTranslation = Vec3(0.0, 1.0, 0.0)
-
-    lateinit var standing: Pose
-    lateinit var walk: Pose
-    lateinit var sleep: Pose
-
-    override val cryAnimation = CryProvider { bedrockStateful("mudsdale", "cry") }
-
-    override fun registerPoses() {
-        val blink = quirk { bedrockStateful("mudsdale", "blink") }
-
-        sleep = registerPose(
-            poseType = PoseType.SLEEP,
-            animations = arrayOf(bedrock("mudsdale", "sleep"))
-        )
-
-        standing = registerPose(
-            poseName = "standing",
-            poseTypes = PoseType.STATIONARY_POSES + PoseType.UI_POSES,
-            transformTicks = 10,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(disableY = true),
-                bedrock("mudsdale", "ground_idle")
-            )
-        )
-
-        walk = registerPose(
-            poseName = "walk",
-            poseTypes = PoseType.MOVING_POSES,
-            transformTicks = 10,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(disableY = true),
-                bedrock("mudsdale", "ground_walk")
-            )
-        )
-    }
-
-//    override fun getFaintAnimation(
-//        pokemonEntity: PokemonEntity,
-//        state: PosableState<PokemonEntity>
-//    ) = if (state.isPosedIn(standing, walk)) bedrockStateful("mudsdale", "faint") else null
-}

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

@@ -481,7 +481,6 @@ object VaryingModelRepository {
         inbuilt("taillow", ::TaillowModel)
         inbuilt("swellow", ::SwellowModel)
         inbuilt("mudbray", ::MudbrayModel)
-        inbuilt("mudsdale", ::MudsdaleModel)
         inbuilt("comfey", ::ComfeyModel)
         inbuilt("tandemaus", ::TandemausModel)
         inbuilt("maushold", ::MausholdModel)

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

@@ -49,6 +49,8 @@ import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviourState
 import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviours
 import com.cobblemon.mod.common.api.riding.events.SelectDriverEvent
 import com.cobblemon.mod.common.api.riding.stats.RidingStat
+import com.cobblemon.mod.common.api.riding.util.RidingAnimationData
+import com.cobblemon.mod.common.api.riding.util.Vec3Spring
 import com.cobblemon.mod.common.api.scheduling.Schedulable
 import com.cobblemon.mod.common.api.scheduling.SchedulingTracker
 import com.cobblemon.mod.common.api.scheduling.afterOnServer
@@ -251,6 +253,7 @@ open class PokemonEntity(
 
     var enablePoseTypeRecalculation = true
 
+    val ridingAnimationData: RidingAnimationData = RidingAnimationData()
 
     var previousRidingState: RidingBehaviourState? = null
     var ridingState: RidingBehaviourState? = null
@@ -483,6 +486,11 @@ open class PokemonEntity(
         entityData.get(MOVING)
 
         super.tick()
+
+        if (passengers.isNotEmpty()) {
+            ridingAnimationData.update(this)
+        }
+
         flyDistO = flyDist
 
         if (isBattling) {
@@ -1565,6 +1573,8 @@ open class PokemonEntity(
                     inp.z * g.toDouble() + inp.x * f.toDouble()
                 )
 
+
+
                 val diff = v.subtract(this.deltaMovement)
 
                 val inertia = ifRidingAvailableSupply(fallback = 0.5) { behaviour, settings, state ->
@@ -1924,7 +1934,7 @@ open class PokemonEntity(
 //    }
 
     override fun onPassengerTurned(entityToUpdate: Entity) {
-        if (entityToUpdate !is LivingEntity) return
+         if (entityToUpdate !is LivingEntity) return
         ifRidingAvailable { behaviour, settings, state ->
             behaviour.clampPassengerRotation(settings, state, this, entityToUpdate)
         }
@@ -1942,6 +1952,22 @@ open class PokemonEntity(
         }
     }
 
+    // When riding mimic RemotePlayers logic for rendering players at farther
+    // distances than usual. Otherwise the player may render when the pokemon
+    // entity is not, causing a floating player.
+    override fun shouldRenderAtSqrDistance(distance: Double): Boolean {
+        if (!passengers.isEmpty()) {
+            var d = (boundingBox.getSize() * 10.0)
+            if (d.isNaN()) {
+                d = 1.0
+            }
+            val scale = 64.0 * getViewScale()
+            return distance < d * scale * scale
+        }
+
+        return super.shouldRenderAtSqrDistance(distance)
+    }
+
     override fun getControllingPassenger(): LivingEntity? {
         val riders = this.passengers.filterIsInstance<LivingEntity>()
         if (riders.isEmpty()) {

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

@@ -38,6 +38,7 @@ object RidingBehaviourSettingsAdapter : JsonDeserializer<RidingBehaviourSettings
         JetAirBehaviour.KEY to JetAirSettings::class.java,
         SwimDashBehaviour.KEY to SwimDashSettings::class.java,
         VehicleLandBehaviour.KEY to VehicleLandSettings::class.java,
+        HoverBehaviour.KEY to HoverSettings::class.java,
         CompositeBehaviour.KEY to CompositeSettings::class.java,
 
         /*

common/src/main/resources/assets/cobblemon/bedrock/npcs/animations/ride_test.animation.json

@@ -0,0 +1,28 @@
+{
+	"format_version": "1.8.0",
+	"animations": {
+		"animation.ride_test.sitting": {
+			"loop": true,
+			"bones": {
+				"body": {
+					"position": [0, -9, 0]
+				},
+				"torso": {
+					"rotation": [25, 0, 0]
+				},
+				"arm_right": {
+					"rotation": [0, 0, 22.5]
+				},
+				"arm_left": {
+					"rotation": [0, 0, -27.5]
+				},
+				"leg_right": {
+					"rotation": [-90, 20, 0]
+				},
+				"leg_left": {
+					"rotation": [-90, -20, 0]
+				}
+			}
+		}
+	}
+}

common/src/main/resources/assets/cobblemon/bedrock/pokemon/animations/0006_charizard/charizard.animation.json

@@ -2272,23 +2272,59 @@
 				"eyelid_right": {
 					"position": {
 						"0.0": [0, 0, 0],
-						"0.4167": {"pre": [0, 0, 0], "post": [-0.1, 0.1, 0]},
-						"0.5833": {"pre": [-0.1, 0.1, 0], "post": [0, 0, 0]},
-						"2.0417": {"pre": [0, 0, 0], "post": [-0.1, 0.1, 0]},
-						"2.375": {"pre": [-0.1, 0.1, 0], "post": [0, 0, 0]},
-						"3.0": {"pre": [0, 0, 0], "post": [-0.1, 0.1, 0]},
-						"5.875": {"pre": [-0.1, 0.1, 0], "post": [0, 0, 0]}
+						"0.4167": {
+							"pre": [0, 0, 0],
+							"post": [-0.1, 0.1, 0]
+						},
+						"0.5833": {
+							"pre": [-0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						},
+						"2.0417": {
+							"pre": [0, 0, 0],
+							"post": [-0.1, 0.1, 0]
+						},
+						"2.375": {
+							"pre": [-0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						},
+						"3.0": {
+							"pre": [0, 0, 0],
+							"post": [-0.1, 0.1, 0]
+						},
+						"5.875": {
+							"pre": [-0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						}
 					}
 				},
 				"eyelid_left": {
 					"position": {
 						"0.0": [0, 0, 0],
-						"0.4167": {"pre": [0, 0, 0], "post": [0.1, 0.1, 0]},
-						"0.5833": {"pre": [0.1, 0.1, 0], "post": [0, 0, 0]},
-						"2.0417": {"pre": [0, 0, 0], "post": [0.1, 0.1, 0]},
-						"2.375": {"pre": [0.1, 0.1, 0], "post": [0, 0, 0]},
-						"3.0": {"pre": [0, 0, 0], "post": [0.1, 0.1, 0]},
-						"5.875": {"pre": [0.1, 0.1, 0], "post": [0, 0, 0]}
+						"0.4167": {
+							"pre": [0, 0, 0],
+							"post": [0.1, 0.1, 0]
+						},
+						"0.5833": {
+							"pre": [0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						},
+						"2.0417": {
+							"pre": [0, 0, 0],
+							"post": [0.1, 0.1, 0]
+						},
+						"2.375": {
+							"pre": [0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						},
+						"3.0": {
+							"pre": [0, 0, 0],
+							"post": [0.1, 0.1, 0]
+						},
+						"5.875": {
+							"pre": [0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						}
 					}
 				}
 			}
@@ -2553,15 +2589,27 @@
 				"eyelid_right": {
 					"position": {
 						"0.0": [0, 0, 0],
-						"1.25": {"pre": [0, 0, 0], "post": [-0.1, 0.1, 0]},
-						"3.6667": {"pre": [-0.1, 0.1, 0], "post": [0, 0, 0]}
+						"1.25": {
+							"pre": [0, 0, 0],
+							"post": [-0.1, 0.1, 0]
+						},
+						"3.6667": {
+							"pre": [-0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						}
 					}
 				},
 				"eyelid_left": {
 					"position": {
 						"0.0": [0, 0, 0],
-						"1.25": {"pre": [0, 0, 0], "post": [0.1, 0.1, 0]},
-						"3.6667": {"pre": [0.1, 0.1, 0], "post": [0, 0, 0]}
+						"1.25": {
+							"pre": [0, 0, 0],
+							"post": [0.1, 0.1, 0]
+						},
+						"3.6667": {
+							"pre": [0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						}
 					}
 				},
 				"jaw": {
@@ -8763,19 +8811,43 @@
 				"eyelid_right": {
 					"position": {
 						"0.0": [0, 0, 0],
-						"0.25": {"pre": [0, 0, 0], "post": [-0.1, 0.1, 0]},
-						"0.5": {"pre": [-0.1, 0.1, 0], "post": [0, 0, 0]},
-						"2.25": {"pre": [0, 0, 0], "post": [-0.1, 0.1, 0]},
-						"2.4583": {"pre": [-0.1, 0.1, 0], "post": [0, 0, 0]}
+						"0.25": {
+							"pre": [0, 0, 0],
+							"post": [-0.1, 0.1, 0]
+						},
+						"0.5": {
+							"pre": [-0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						},
+						"2.25": {
+							"pre": [0, 0, 0],
+							"post": [-0.1, 0.1, 0]
+						},
+						"2.4583": {
+							"pre": [-0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						}
 					}
 				},
 				"eyelid_left": {
 					"position": {
 						"0.0": [0, 0, 0],
-						"0.25": {"pre": [0, 0, 0], "post": [0.1, 0.1, 0]},
-						"0.5": {"pre": [0.1, 0.1, 0], "post": [0, 0, 0]},
-						"2.25": {"pre": [0, 0, 0], "post": [0.1, 0.1, 0]},
-						"2.4583": {"pre": [0.1, 0.1, 0], "post": [0, 0, 0]}
+						"0.25": {
+							"pre": [0, 0, 0],
+							"post": [0.1, 0.1, 0]
+						},
+						"0.5": {
+							"pre": [0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						},
+						"2.25": {
+							"pre": [0, 0, 0],
+							"post": [0.1, 0.1, 0]
+						},
+						"2.4583": {
+							"pre": [0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						}
 					}
 				}
 			}
@@ -11221,23 +11293,59 @@
 				"eyelid_right": {
 					"position": {
 						"0.0": [0, 0, 0],
-						"0.25": {"pre": [0, 0, 0], "post": [-0.1, 0.1, 0]},
-						"0.4167": {"pre": [-0.1, 0.1, 0], "post": [0, 0, 0]},
-						"0.8333": {"pre": [0, 0, 0], "post": [-0.1, 0.1, 0]},
-						"1.125": {"pre": [-0.1, 0.1, 0], "post": [0, 0, 0]},
-						"2.5417": {"pre": [0, 0, 0], "post": [-0.1, 0.1, 0]},
-						"2.6667": {"pre": [-0.1, 0.1, 0], "post": [0, 0, 0]}
+						"0.25": {
+							"pre": [0, 0, 0],
+							"post": [-0.1, 0.1, 0]
+						},
+						"0.4167": {
+							"pre": [-0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						},
+						"0.8333": {
+							"pre": [0, 0, 0],
+							"post": [-0.1, 0.1, 0]
+						},
+						"1.125": {
+							"pre": [-0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						},
+						"2.5417": {
+							"pre": [0, 0, 0],
+							"post": [-0.1, 0.1, 0]
+						},
+						"2.6667": {
+							"pre": [-0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						}
 					}
 				},
 				"eyelid_left": {
 					"position": {
 						"0.0": [0, 0, 0],
-						"0.25": {"pre": [0, 0, 0], "post": [0.1, 0.1, 0]},
-						"0.4167": {"pre": [0.1, 0.1, 0], "post": [0, 0, 0]},
-						"0.8333": {"pre": [0, 0, 0], "post": [0.1, 0.1, 0]},
-						"1.125": {"pre": [0.1, 0.1, 0], "post": [0, 0, 0]},
-						"2.5417": {"pre": [0, 0, 0], "post": [0.1, 0.1, 0]},
-						"2.6667": {"pre": [0.1, 0.1, 0], "post": [0, 0, 0]}
+						"0.25": {
+							"pre": [0, 0, 0],
+							"post": [0.1, 0.1, 0]
+						},
+						"0.4167": {
+							"pre": [0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						},
+						"0.8333": {
+							"pre": [0, 0, 0],
+							"post": [0.1, 0.1, 0]
+						},
+						"1.125": {
+							"pre": [0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						},
+						"2.5417": {
+							"pre": [0, 0, 0],
+							"post": [0.1, 0.1, 0]
+						},
+						"2.6667": {
+							"pre": [0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						}
 					}
 				},
 				"locator_target": {
@@ -13529,19 +13637,43 @@
 				"eyelid_right": {
 					"position": {
 						"0.0": [0, 0, 0],
-						"0.3333": {"pre": [0, 0, 0], "post": [-0.1, 0.1, 0]},
-						"1.2083": {"pre": [-0.1, 0.1, 0], "post": [0, 0, 0]},
-						"2.5417": {"pre": [0, 0, 0], "post": [-0.1, 0.1, 0]},
-						"2.7083": {"pre": [-0.1, 0.1, 0], "post": [0, 0, 0]}
+						"0.3333": {
+							"pre": [0, 0, 0],
+							"post": [-0.1, 0.1, 0]
+						},
+						"1.2083": {
+							"pre": [-0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						},
+						"2.5417": {
+							"pre": [0, 0, 0],
+							"post": [-0.1, 0.1, 0]
+						},
+						"2.7083": {
+							"pre": [-0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						}
 					}
 				},
 				"eyelid_left": {
 					"position": {
 						"0.0": [0, 0, 0],
-						"0.3333": {"pre": [0, 0, 0], "post": [0.1, 0.1, 0]},
-						"1.2083": {"pre": [0.1, 0.1, 0], "post": [0, 0, 0]},
-						"2.5417": {"pre": [0, 0, 0], "post": [0.1, 0.1, 0]},
-						"2.7083": {"pre": [0.1, 0.1, 0], "post": [0, 0, 0]}
+						"0.3333": {
+							"pre": [0, 0, 0],
+							"post": [0.1, 0.1, 0]
+						},
+						"1.2083": {
+							"pre": [0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						},
+						"2.5417": {
+							"pre": [0, 0, 0],
+							"post": [0.1, 0.1, 0]
+						},
+						"2.7083": {
+							"pre": [0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						}
 					}
 				},
 				"locator_mouth": {
@@ -13740,14 +13872,20 @@
 					"position": {
 						"0.0": [-0.1, 0.1, 0],
 						"0.125": [-0.1, 0.1, 0],
-						"0.1667": {"pre": [-0.1, 0.1, 0], "post": [0, 0, 0]}
+						"0.1667": {
+							"pre": [-0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						}
 					}
 				},
 				"eyelid_left": {
 					"position": {
 						"0.0": [0.1, 0.1, 0],
 						"0.125": [0.1, 0.1, 0],
-						"0.1667": {"pre": [0.1, 0.1, 0], "post": [0, 0, 0]}
+						"0.1667": {
+							"pre": [0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						}
 					}
 				},
 				"jaw": {
@@ -14543,7 +14681,7 @@
 					"rotation": [0, -6, -15]
 				},
 				"wing_right_elbow": {
-					"rotation": [0, "-6", -15],
+					"rotation": [0, "-6+", -15],
 					"position": [0.45, 0.1, 0]
 				},
 				"wing_right_membrane": {
@@ -16036,7 +16174,7 @@
 			"animation_length": 4,
 			"bones": {
 				"body": {
-					"rotation": [22.5, 0, "math.sin(q.anim_time*90*1-90)*-0.5"],
+					"rotation": ["22.5 + q.riding.pitch(0)*-90", 0, "math.sin(q.anim_time*90*1-90)*-0.5"],
 					"position": ["math.cos(q.anim_time*90*1-60)*1", "12+math.cos((q.anim_time*90*2-60)+math.sin(q.anim_time*90*2)*20)*3", 0]
 				},
 				"torso": {
@@ -17357,6 +17495,14 @@
 				"locator_top": {
 					"position": [0, 13, 0]
 				}
+			},
+			"sound_effects": {
+				"1.125": {
+					"effect": "animation.leather.wing_flap.medium"
+				},
+				"3.1667": {
+					"effect": "animation.leather.wing_flap.medium"
+				}
 			}
 		},
 		"animation.charizard.air_fly": {
@@ -18633,6 +18779,17 @@
 				},
 				"locator_top": {
 					"position": [0, -1, 0]
+				},
+				"locator_seat_1": {
+					"rotation": [-60, 0, 0]
+				}
+			},
+			"sound_effects": {
+				"1.0833": {
+					"effect": "animation.leather.wing_flap.medium"
+				},
+				"3.0833": {
+					"effect": "animation.leather.wing_flap.medium"
 				}
 			}
 		},
@@ -18898,6 +19055,9 @@
 				},
 				"locator_top": {
 					"position": [0, -6, 0]
+				},
+				"locator_seat_1": {
+					"rotation": [-60, 0, 0]
 				}
 			}
 		},
@@ -19097,23 +19257,59 @@
 				"eyelid_right": {
 					"position": {
 						"0.0": [0, 0, 0],
-						"0.4167": {"pre": [0, 0, 0], "post": [-0.1, 0.1, 0]},
-						"0.5833": {"pre": [-0.1, 0.1, 0], "post": [0, 0, 0]},
-						"2.4167": {"pre": [0, 0, 0], "post": [-0.1, 0.1, 0]},
-						"2.5833": {"pre": [-0.1, 0.1, 0], "post": [0, 0, 0]},
-						"3.9167": {"pre": [0, 0, 0], "post": [-0.1, 0.1, 0]},
-						"4.0833": {"pre": [-0.1, 0.1, 0], "post": [0, 0, 0]}
+						"0.4167": {
+							"pre": [0, 0, 0],
+							"post": [-0.1, 0.1, 0]
+						},
+						"0.5833": {
+							"pre": [-0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						},
+						"2.4167": {
+							"pre": [0, 0, 0],
+							"post": [-0.1, 0.1, 0]
+						},
+						"2.5833": {
+							"pre": [-0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						},
+						"3.9167": {
+							"pre": [0, 0, 0],
+							"post": [-0.1, 0.1, 0]
+						},
+						"4.0833": {
+							"pre": [-0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						}
 					}
 				},
 				"eyelid_left": {
 					"position": {
 						"0.0": [0, 0, 0],
-						"0.4167": {"pre": [0, 0, 0], "post": [0.1, 0.1, 0]},
-						"0.5833": {"pre": [0.1, 0.1, 0], "post": [0, 0, 0]},
-						"2.4167": {"pre": [0, 0, 0], "post": [0.1, 0.1, 0]},
-						"2.5833": {"pre": [0.1, 0.1, 0], "post": [0, 0, 0]},
-						"3.9167": {"pre": [0, 0, 0], "post": [0.1, 0.1, 0]},
-						"4.0833": {"pre": [0.1, 0.1, 0], "post": [0, 0, 0]}
+						"0.4167": {
+							"pre": [0, 0, 0],
+							"post": [0.1, 0.1, 0]
+						},
+						"0.5833": {
+							"pre": [0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						},
+						"2.4167": {
+							"pre": [0, 0, 0],
+							"post": [0.1, 0.1, 0]
+						},
+						"2.5833": {
+							"pre": [0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						},
+						"3.9167": {
+							"pre": [0, 0, 0],
+							"post": [0.1, 0.1, 0]
+						},
+						"4.0833": {
+							"pre": [0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						}
 					}
 				}
 			}
@@ -22458,7 +22654,10 @@
 						},
 						"0.5": [0.78, -10.13, 0.45],
 						"0.5417": [-0.45, -8.03, 0.45],
-						"0.5833": {"pre": [-0.45, -8.03, 0.45], "post": [-0.45, "-7.79+360", 0.45]},
+						"0.5833": {
+							"pre": [-0.45, -8.03, 0.45],
+							"post": [-0.45, "-7.79+360", 0.45]
+						},
 						"0.625": [-2.7, 355.37, 0.45],
 						"1.0": {
 							"pre": [-9.46, "10.71+360", 0.5],
@@ -26129,23 +26328,59 @@
 				"eyelid_right": {
 					"position": {
 						"0.0": [0, 0, 0],
-						"0.0833": {"pre": [0, 0, 0], "post": [-0.1, 0.1, 0]},
-						"0.3333": {"pre": [-0.1, 0.1, 0], "post": [0, 0, 0]},
-						"1.625": {"pre": [0, 0, 0], "post": [-0.1, 0.1, 0]},
-						"1.8333": {"pre": [-0.1, 0.1, 0], "post": [0, 0, 0]},
-						"2.5": {"pre": [0, 0, 0], "post": [-0.1, 0.1, 0]},
-						"2.625": {"pre": [-0.1, 0.1, 0], "post": [0, 0, 0]}
+						"0.0833": {
+							"pre": [0, 0, 0],
+							"post": [-0.1, 0.1, 0]
+						},
+						"0.3333": {
+							"pre": [-0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						},
+						"1.625": {
+							"pre": [0, 0, 0],
+							"post": [-0.1, 0.1, 0]
+						},
+						"1.8333": {
+							"pre": [-0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						},
+						"2.5": {
+							"pre": [0, 0, 0],
+							"post": [-0.1, 0.1, 0]
+						},
+						"2.625": {
+							"pre": [-0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						}
 					}
 				},
 				"eyelid_left": {
 					"position": {
 						"0.0": [0, 0, 0],
-						"0.0833": {"pre": [0, 0, 0], "post": [0.1, 0.1, 0]},
-						"0.3333": {"pre": [0.1, 0.1, 0], "post": [0, 0, 0]},
-						"1.625": {"pre": [0, 0, 0], "post": [0.1, 0.1, 0]},
-						"1.8333": {"pre": [0.1, 0.1, 0], "post": [0, 0, 0]},
-						"2.5": {"pre": [0, 0, 0], "post": [0.1, 0.1, 0]},
-						"2.625": {"pre": [0.1, 0.1, 0], "post": [0, 0, 0]}
+						"0.0833": {
+							"pre": [0, 0, 0],
+							"post": [0.1, 0.1, 0]
+						},
+						"0.3333": {
+							"pre": [0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						},
+						"1.625": {
+							"pre": [0, 0, 0],
+							"post": [0.1, 0.1, 0]
+						},
+						"1.8333": {
+							"pre": [0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						},
+						"2.5": {
+							"pre": [0, 0, 0],
+							"post": [0.1, 0.1, 0]
+						},
+						"2.625": {
+							"pre": [0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						}
 					}
 				},
 				"locator_root": {
@@ -29385,9 +29620,15 @@
 				"brow": {
 					"position": {
 						"0.9583": [0, 0, 0],
-						"1.1667": {"pre": [0, 0, 0], "post": [0, 0, -0.3]},
+						"1.1667": {
+							"pre": [0, 0, 0],
+							"post": [0, 0, -0.3]
+						},
 						"2.2917": [0, 0, -0.3],
-						"2.5417": {"pre": [0, 0, -0.3], "post": [0, 0, 0]}
+						"2.5417": {
+							"pre": [0, 0, -0.3],
+							"post": [0, 0, 0]
+						}
 					}
 				},
 				"jaw": {
@@ -29722,19 +29963,43 @@
 				"eyelid_right": {
 					"position": {
 						"0.0": [0, 0, 0],
-						"0.3333": {"pre": [0, 0, 0], "post": [-0.1, 0.1, 0]},
-						"1.2083": {"pre": [-0.1, 0.1, 0], "post": [0, 0, 0]},
-						"2.375": {"pre": [0, 0, 0], "post": [-0.1, 0.1, 0]},
-						"2.6667": {"pre": [-0.1, 0.1, 0], "post": [0, 0, 0]}
+						"0.3333": {
+							"pre": [0, 0, 0],
+							"post": [-0.1, 0.1, 0]
+						},
+						"1.2083": {
+							"pre": [-0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						},
+						"2.375": {
+							"pre": [0, 0, 0],
+							"post": [-0.1, 0.1, 0]
+						},
+						"2.6667": {
+							"pre": [-0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						}
 					}
 				},
 				"eyelid_left": {
 					"position": {
 						"0.0": [0, 0, 0],
-						"0.3333": {"pre": [0, 0, 0], "post": [0.1, 0.1, 0]},
-						"1.2083": {"pre": [0.1, 0.1, 0], "post": [0, 0, 0]},
-						"2.375": {"pre": [0, 0, 0], "post": [0.1, 0.1, 0]},
-						"2.6667": {"pre": [0.1, 0.1, 0], "post": [0, 0, 0]}
+						"0.3333": {
+							"pre": [0, 0, 0],
+							"post": [0.1, 0.1, 0]
+						},
+						"1.2083": {
+							"pre": [0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						},
+						"2.375": {
+							"pre": [0, 0, 0],
+							"post": [0.1, 0.1, 0]
+						},
+						"2.6667": {
+							"pre": [0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						}
 					}
 				},
 				"locator_root": {
@@ -29753,6 +30018,106 @@
 				}
 			}
 		},
+		"animation.charizard.ride_air_look": {
+			"loop": true,
+			"bones": {
+				"body": {
+					"rotation": ["q.riding.pitch_change(0)*-0", "q.riding.yaw_change(0)*-15", "q.riding.roll_change(0)*15"]
+				},
+				"neck": {
+					"rotation": ["math.clamp(q.riding.pitch_change(0),-0.5,1.0)*-20", 0, "q.riding.yaw_change(0)*7"]
+				},
+				"neck2": {
+					"rotation": ["math.clamp(q.riding.pitch_change(0),-0.5,1.0)*-12", 0, "q.riding.yaw_change(0)*12"]
+				},
+				"neck3": {
+					"rotation": ["q.riding.pitch_change(0)*-7", 0, "q.riding.yaw_change(0)*7"]
+				},
+				"neck4": {
+					"rotation": ["q.riding.pitch_change(0)*-7", 0, "q.riding.yaw_change(0)*7"]
+				},
+				"head_angle": {
+					"rotation": ["q.riding.pitch_change(0)*-7", 0, "q.riding.yaw_change(0)*7"]
+				},
+				"shoulder_right": {
+					"rotation": [0, "-12.5*q.riding.pitch_change(0)", "27.5*q.riding.yaw_change(0)"]
+				},
+				"arm_right": {
+					"rotation": [0, "15*q.riding.yaw_change(0)", 0]
+				},
+				"forearm_right": {
+					"rotation": [0, "15*q.riding.yaw_change(0)", "-12.5*q.riding.pitch_change(0)"]
+				},
+				"shoulder_left": {
+					"rotation": [0, "12.5*q.riding.pitch_change(0)", "27.5*q.riding.yaw_change(0)"]
+				},
+				"arm_left": {
+					"rotation": [0, "15*q.riding.yaw_change(0)", 0]
+				},
+				"forearm_left": {
+					"rotation": [0, "15*q.riding.yaw_change(0)", "12.5*q.riding.pitch_change(0)"]
+				},
+				"wing_right_base": {
+					"rotation": ["-5*q.riding.pitch_change(0)", 0, 0]
+				},
+				"wing_right_bend": {
+					"rotation": ["10*q.riding.yaw_change(0)", "7.5*q.riding.pitch_change(0)", "10*q.riding.yaw_change(0)"]
+				},
+				"wing_right_mid": {
+					"rotation": ["-5*q.riding.pitch_change(0)", 0, 0]
+				},
+				"wing_right_elbow": {
+					"rotation": ["-2.5*q.riding.pitch_change(0)", "5*q.riding.pitch_change(0)", 0]
+				},
+				"wing_left_base": {
+					"rotation": ["-5*q.riding.pitch_change(0)", 0, 0]
+				},
+				"wing_left_bend": {
+					"rotation": ["-10*q.riding.yaw_change(0)", "-7.5*q.riding.pitch_change(0)", "-10*q.riding.yaw_change(0)"]
+				},
+				"wing_left_mid": {
+					"rotation": ["-5*q.riding.pitch_change(0)", 0, 0]
+				},
+				"wing_left_elbow": {
+					"rotation": ["-2.5*q.riding.pitch_change(0)", "-(5*q.riding.pitch_change(0))", 0]
+				},
+				"tail": {
+					"rotation": ["q.riding.pitch_change(0)*7", 0, "q.riding.yaw_change(0)*-10"]
+				},
+				"tail2": {
+					"rotation": ["q.riding.pitch_change(0)*7", "q.riding.yaw_change(0)*15", 0]
+				},
+				"tail3": {
+					"rotation": ["q.riding.pitch_change(0)*7", "q.riding.yaw_change(0)*20", 0]
+				},
+				"tail4": {
+					"rotation": ["q.riding.pitch_change(0)*7", "q.riding.yaw_change(0)*20", 0]
+				},
+				"tail5": {
+					"rotation": ["q.riding.pitch_change(0)*8", "q.riding.yaw_change(0)*20", 0]
+				},
+				"leg_right": {
+					"rotation": ["-12.5*q.riding.pitch_change(0)", "q.riding.yaw_change(0)*20", 0],
+					"position": ["-1.5*q.riding.yaw_change(0)", 0, 0]
+				},
+				"knee_right": {
+					"rotation": ["-12.5*q.riding.pitch_change(0)", 0, 0]
+				},
+				"foot_right": {
+					"rotation": ["-12.5*q.riding.pitch_change(0)", 0, 0]
+				},
+				"leg_left": {
+					"rotation": ["-12.5*q.riding.pitch_change(0)", "q.riding.yaw_change(0)*20", 0],
+					"position": ["-1.5*q.riding.yaw_change(0)", 0, 0]
+				},
+				"knee_left": {
+					"rotation": ["-12.5*q.riding.pitch_change(0)", 0, 0]
+				},
+				"foot_left": {
+					"rotation": ["-12.5*q.riding.pitch_change(0)", 0, 0]
+				}
+			}
+		},
 		"animation.charizard.air_status": {
 			"animation_length": 3,
 			"bones": {
@@ -32994,19 +33359,43 @@
 				"eyelid_right": {
 					"position": {
 						"0.0": [0, 0, 0],
-						"0.3333": {"pre": [0, 0, 0], "post": [-0.1, 0.1, 0]},
-						"1.2083": {"pre": [-0.1, 0.1, 0], "post": [0, 0, 0]},
-						"2.2083": {"pre": [0, 0, 0], "post": [-0.1, 0.1, 0]},
-						"2.4583": {"pre": [-0.1, 0.1, 0], "post": [0, 0, 0]}
+						"0.3333": {
+							"pre": [0, 0, 0],
+							"post": [-0.1, 0.1, 0]
+						},
+						"1.2083": {
+							"pre": [-0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						},
+						"2.2083": {
+							"pre": [0, 0, 0],
+							"post": [-0.1, 0.1, 0]
+						},
+						"2.4583": {
+							"pre": [-0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						}
 					}
 				},
 				"eyelid_left": {
 					"position": {
 						"0.0": [0, 0, 0],
-						"0.3333": {"pre": [0, 0, 0], "post": [0.1, 0.1, 0]},
-						"1.2083": {"pre": [0.1, 0.1, 0], "post": [0, 0, 0]},
-						"2.2083": {"pre": [0, 0, 0], "post": [0.1, 0.1, 0]},
-						"2.4583": {"pre": [0.1, 0.1, 0], "post": [0, 0, 0]}
+						"0.3333": {
+							"pre": [0, 0, 0],
+							"post": [0.1, 0.1, 0]
+						},
+						"1.2083": {
+							"pre": [0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						},
+						"2.2083": {
+							"pre": [0, 0, 0],
+							"post": [0.1, 0.1, 0]
+						},
+						"2.4583": {
+							"pre": [0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						}
 					}
 				},
 				"locator_root": {
@@ -34432,14 +34821,20 @@
 					"position": {
 						"0.0": [-0.1, 0.1, 0],
 						"0.125": [-0.1, 0.1, 0],
-						"0.1667": {"pre": [-0.1, 0.1, 0], "post": [0, 0, 0]}
+						"0.1667": {
+							"pre": [-0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						}
 					}
 				},
 				"eyelid_left": {
 					"position": {
 						"0.0": [0.1, 0.1, 0],
 						"0.125": [0.1, 0.1, 0],
-						"0.1667": {"pre": [0.1, 0.1, 0], "post": [0, 0, 0]}
+						"0.1667": {
+							"pre": [0.1, 0.1, 0],
+							"post": [0, 0, 0]
+						}
 					}
 				}
 			}

common/src/main/resources/assets/cobblemon/bedrock/pokemon/animations/0018_pidgeot/pidgeot.animation.json

@@ -535,6 +535,11 @@
 						}
 					}
 				}
+			},
+			"sound_effects": {
+				"0.5": {
+					"effect": "animation.plumage.wing_flap.medium"
+				}
 			}
 		},
 		"animation.pidgeot.air_fly": {
@@ -710,6 +715,9 @@
 				},
 				"wing_open_right4": {
 					"rotation": [0, 0, "7.5+math.sin(q.anim_time*90*0.8-240)*-10+math.sin(q.anim_time*90*12-120)*0.4"]
+				},
+				"locator_seat1": {
+					"position": [0, 1.5, -4]
 				}
 			}
 		},
@@ -1566,6 +1574,11 @@
 						}
 					}
 				}
+			},
+			"sound_effects": {
+				"1.375": {
+					"effect": "animation.plumage.wing_flap.medium"
+				}
 			}
 		},
 		"animation.pidgeot.air_fly_quirk2": {
@@ -2721,6 +2734,14 @@
 						}
 					}
 				}
+			},
+			"sound_effects": {
+				"1.4583": {
+					"effect": "animation.plumage.wing_flap.medium"
+				},
+				"3.0833": {
+					"effect": "animation.plumage.wing_flap.medium"
+				}
 			}
 		},
 		"animation.pidgeot.blink": {

common/src/main/resources/assets/cobblemon/bedrock/pokemon/animations/0142_aerodactyl/aerodactyl.animation.json

@@ -467,6 +467,7 @@
 		},
 		"animation.aerodactyl.air_idle": {
 			"loop": true,
+			"animation_length": 1.33333,
 			"bones": {
 				"aerodactyl": {
 					"position": [0, 3, 0]
@@ -642,10 +643,16 @@
 				"right_wing_membrane": {
 					"rotation": [0, "0+math.sin(q.anim_time*90*3+90)*3", "0+math.sin(q.anim_time*90*3+90)*1.5"]
 				}
+			},
+			"sound_effects": {
+				"1.0833": {
+					"effect": "animation.leather.wing_flap.medium"
+				}
 			}
 		},
 		"animation.aerodactyl.air_fly": {
 			"loop": true,
+			"animation_length": 1.33333,
 			"bones": {
 				"aerodactyl": {
 					"position": [0, 3, 0]
@@ -827,6 +834,11 @@
 				"right_horn": {
 					"rotation": ["math.sin(q.anim_time*90*12-160)*2", 0, 0]
 				}
+			},
+			"sound_effects": {
+				"0.9583": {
+					"effect": "animation.leather.wing_flap.medium"
+				}
 			}
 		},
 		"animation.aerodactyl.sleep": {

common/src/main/resources/assets/cobblemon/bedrock/pokemon/animations/0149_dragonite/dragonite.animation.json

@@ -1237,6 +1237,20 @@
 					"rotation": ["-math.sin(q.anim_time*90*2-120)*4", 0, 0],
 					"position": [0, "7.8+math.sin(q.anim_time*90*2)*2", -5.6]
 				}
+			},
+			"sound_effects": {
+				"1.5": {
+					"effect": "animation.leather.wing_flap.medium"
+				},
+				"3.5": {
+					"effect": "animation.leather.wing_flap.medium"
+				},
+				"5.5": {
+					"effect": "animation.leather.wing_flap.medium"
+				},
+				"7.5": {
+					"effect": "animation.leather.wing_flap.medium"
+				}
 			}
 		},
 		"animation.dragonite.water_idle": {
@@ -2053,6 +2067,89 @@
 					"effect": "pokemon.dragonite.cry"
 				}
 			}
+		},
+		"animation.dragonite.shock": {
+			"loop": true,
+			"bones": {
+				"pupil_left": {
+					"scale": [0.7, 0.7, 1]
+				},
+				"eye_shine_left": {
+					"position": [0, -0.5, 0]
+				},
+				"pupil_right": {
+					"scale": [0.7, 0.7, 1]
+				},
+				"eye_shine_right": {
+					"position": [0, -0.5, 0]
+				},
+				"jaw": {
+					"rotation": [27.5, 0, 0]
+				},
+				"eye_left": {
+					"position": [0, 0, 0],
+					"scale": 1
+				},
+				"eye_shocked_left": {
+					"position": [0.25, 0, -0.26]
+				},
+				"eye_shocked_right": {
+					"position": [-0.125, 0, -0.18]
+				}
+			}
+		},
+		"animation.dragonite.angry": {
+			"loop": true,
+			"bones": {
+				"eye_angry_left": {
+					"position": [0.1, 0, -0.1]
+				},
+				"eye_shine_left": {
+					"position": [0, -1, 0]
+				},
+				"eye_shine_right": {
+					"position": [0, -1, 0]
+				},
+				"eye_angry_right": {
+					"position": [-0.1, 0, -0.1]
+				}
+			}
+		},
+		"animation.dragonite.sad": {
+			"loop": true,
+			"bones": {
+				"eye_sad_left": {
+					"position": [0.1, 0, -0.1]
+				},
+				"eye_sad_right": {
+					"position": [-0.1, 0, -0.1]
+				}
+			}
+		},
+		"animation.dragonite.happy": {
+			"loop": true,
+			"bones": {
+				"eyelid_happy_left": {
+					"position": [0.1, 0, -0.1]
+				},
+				"eyelid_happy_right": {
+					"position": [-0.1, 0, -0.1]
+				},
+				"jaw": {
+					"rotation": [27.5, 0, 0]
+				}
+			}
+		},
+		"animation.dragonite.hurt": {
+			"loop": true,
+			"bones": {
+				"eyelid_recoil_left": {
+					"position": [0.1, 0, -0.1]
+				},
+				"eyelid_recoil_right": {
+					"position": [-0.1, 0, -0.1]
+				}
+			}
 		}
 	}
 }

common/src/main/resources/assets/cobblemon/bedrock/pokemon/animations/0462_magnezone/magnezone.animation.json

@@ -5,7 +5,11 @@
 			"loop": true,
 			"bones": {
 				"body": {
-					"rotation": [0, "0 - Math.Sin(((q.anim_time + 0.1) * 180 * 0.5) * 1) * 5", "Math.Sin(((q.anim_time + 0.4) * 180 * 0.5) * 1) * 5"],
+					"rotation": [
+						"45*q.riding.velocity_forward(0)",
+						"0 - Math.Sin(((q.anim_time + 0.1) * 180 * 0.5) * 1) * 5",
+						"Math.Sin(((q.anim_time + 0.4) * 180 * 0.5) * 1) * 5 + 45*q.riding.velocity_right(0)"
+					],
 					"position": ["Math.Sin((q.anim_time * 180 * 0.5) * 1) * 1.5", "7+Math.Sin((q.anim_time * 90 * 0.5) * 1) * 1.5", 0]
 				},
 				"magnet_back_rotation": {
@@ -45,7 +49,11 @@
 			"loop": true,
 			"bones": {
 				"body": {
-					"rotation": [15, "0 - Math.Sin(((q.anim_time + 0.1) * 180 * 0.5) * 1) * 5", "Math.Sin(((q.anim_time + 0.4) * 180 * 0.5) * 1) * 5"],
+					"rotation": [
+						"2.5 + 45*q.riding.velocity_forward(0)",
+						"- Math.Sin(((q.anim_time + 0.1) * 180 * 0.5) * 1) * 5",
+						"Math.Sin(((q.anim_time + 0.4) * 180 * 0.5) * 1) * 5 - 45*q.riding.velocity_right(0)"
+					],
 					"position": ["Math.Sin((q.anim_time * 180 * 0.5) * 1) * 1.5", "7+Math.Sin((q.anim_time * 90 * 0.5) * 1) * 1.5", 0]
 				},
 				"magnet_back_rotation": {
@@ -266,45 +274,117 @@
 				"pupil_left": {
 					"position": {
 						"0.0": [0, 0, 0],
-						"0.5": {"pre": [0, 0, 0], "post": [0, 0, 0]},
-						"0.5417": {"pre": [0, 0, 0], "post": [0, 0, 0.1]},
-						"1.75": {"pre": [0, 0, 0.1], "post": [0, 0, 0.1]},
-						"1.7917": {"pre": [0, 0, 0.1], "post": [0, 0, 0]},
-						"2.0833": {"pre": [0, 0, 0], "post": [0, 0, 0]},
-						"2.125": {"pre": [0, 0, 0], "post": [0, 0, 0.1]}
+						"0.5": {
+							"pre": [0, 0, 0],
+							"post": [0, 0, 0]
+						},
+						"0.5417": {
+							"pre": [0, 0, 0],
+							"post": [0, 0, 0.1]
+						},
+						"1.75": {
+							"pre": [0, 0, 0.1],
+							"post": [0, 0, 0.1]
+						},
+						"1.7917": {
+							"pre": [0, 0, 0.1],
+							"post": [0, 0, 0]
+						},
+						"2.0833": {
+							"pre": [0, 0, 0],
+							"post": [0, 0, 0]
+						},
+						"2.125": {
+							"pre": [0, 0, 0],
+							"post": [0, 0, 0.1]
+						}
 					}
 				},
 				"pupil_closed_left": {
 					"position": {
 						"0.0": [0, 0, 0],
-						"0.5": {"pre": [0, 0, 0], "post": [0, 0, 0]},
-						"0.5417": {"pre": [0, 0, 0], "post": [0, 0, -0.1]},
-						"1.75": {"pre": [0, 0, -0.1], "post": [0, 0, -0.1]},
-						"1.7917": {"pre": [0, 0, -0.1], "post": [0, 0, 0]},
-						"2.0833": {"pre": [0, 0, 0], "post": [0, 0, 0]},
-						"2.125": {"pre": [0, 0, 0], "post": [0, 0, -0.1]}
+						"0.5": {
+							"pre": [0, 0, 0],
+							"post": [0, 0, 0]
+						},
+						"0.5417": {
+							"pre": [0, 0, 0],
+							"post": [0, 0, -0.1]
+						},
+						"1.75": {
+							"pre": [0, 0, -0.1],
+							"post": [0, 0, -0.1]
+						},
+						"1.7917": {
+							"pre": [0, 0, -0.1],
+							"post": [0, 0, 0]
+						},
+						"2.0833": {
+							"pre": [0, 0, 0],
+							"post": [0, 0, 0]
+						},
+						"2.125": {
+							"pre": [0, 0, 0],
+							"post": [0, 0, -0.1]
+						}
 					}
 				},
 				"pupil_right": {
 					"position": {
 						"0.0": [0, 0, 0],
-						"0.2083": {"pre": [0, 0, 0], "post": [0, 0, 0]},
-						"0.25": {"pre": [0, 0, 0], "post": [0, 0, 0.1]},
-						"0.5": {"pre": [0, 0, 0.1], "post": [0, 0, 0.1]},
-						"0.5417": {"pre": [0, 0, 0.1], "post": [0, 0, 0]},
-						"1.9583": {"pre": [0, 0, 0], "post": [0, 0, 0]},
-						"2.0": {"pre": [0, 0, 0], "post": [0, 0, 0.1]}
+						"0.2083": {
+							"pre": [0, 0, 0],
+							"post": [0, 0, 0]
+						},
+						"0.25": {
+							"pre": [0, 0, 0],
+							"post": [0, 0, 0.1]
+						},
+						"0.5": {
+							"pre": [0, 0, 0.1],
+							"post": [0, 0, 0.1]
+						},
+						"0.5417": {
+							"pre": [0, 0, 0.1],
+							"post": [0, 0, 0]
+						},
+						"1.9583": {
+							"pre": [0, 0, 0],
+							"post": [0, 0, 0]
+						},
+						"2.0": {
+							"pre": [0, 0, 0],
+							"post": [0, 0, 0.1]
+						}
 					}
 				},
 				"pupil_closed_right": {
 					"position": {
 						"0.0": [0, 0, 0],
-						"0.2083": {"pre": [0, 0, 0], "post": [0, 0, 0]},
-						"0.25": {"pre": [0, 0, 0], "post": [0, 0, -0.1]},
-						"0.5": {"pre": [0, 0, -0.1], "post": [0, 0, -0.1]},
-						"0.5417": {"pre": [0, 0, -0.1], "post": [0, 0, 0]},
-						"1.9583": {"pre": [0, 0, 0], "post": [0, 0, 0]},
-						"2.0": {"pre": [0, 0, 0], "post": [0, 0, -0.1]}
+						"0.2083": {
+							"pre": [0, 0, 0],
+							"post": [0, 0, 0]
+						},
+						"0.25": {
+							"pre": [0, 0, 0],
+							"post": [0, 0, -0.1]
+						},
+						"0.5": {
+							"pre": [0, 0, -0.1],
+							"post": [0, 0, -0.1]
+						},
+						"0.5417": {
+							"pre": [0, 0, -0.1],
+							"post": [0, 0, 0]
+						},
+						"1.9583": {
+							"pre": [0, 0, 0],
+							"post": [0, 0, 0]
+						},
+						"2.0": {
+							"pre": [0, 0, 0],
+							"post": [0, 0, -0.1]
+						}
 					}
 				}
 			},

common/src/main/resources/assets/cobblemon/bedrock/pokemon/animations/0750_mudsdale/mudsdale.animation.json

@@ -155,6 +155,9 @@
 				"back_neck_braid_right4": {
 					"rotation": [2.5, 0, -10],
 					"position": [-0.5, 0, 0]
+				},
+				"body": {
+					"rotation": ["q.riding.velocity_y(0)*-90", 0, 0]
 				}
 			}
 		},
@@ -650,7 +653,7 @@
 					}
 				},
 				"neck2": {
-					"rotation": ["5+math.sin(q.anim_time*90*4-60)*2", 0, 0]
+					"rotation": ["5+math.sin(q.anim_time*90*4-60)*2 - math.pow(q.riding.yaw_change(0),2)*20", "q.riding.yaw_change(0)*-10", "q.riding.yaw_change(0)*10"]
 				},
 				"tail5": {
 					"rotation": ["-7.5+math.sin(q.anim_time*90*4-90)*2", "math.sin(q.anim_time*90*2)*1", "math.sin(q.anim_time*90*2)*4"]
@@ -677,7 +680,7 @@
 					}
 				},
 				"neck": {
-					"rotation": ["3+math.sin(q.anim_time*90*4-30)*1", 0, "math.sin(q.anim_time*90*2-30)*2"]
+					"rotation": ["3+math.sin(q.anim_time*90*4-30)*1", "q.riding.yaw_change(0)*-10", "math.sin(q.anim_time*90*2-30)*2 + q.riding.yaw_change(0)*10"]
 				},
 				"front_neck_braid_left": {
 					"rotation": ["5+math.sin(q.anim_time*90*4-60)*1", 0.5, 5]
@@ -844,6 +847,7 @@
 					"position": [-0.5, 0, 0]
 				},
 				"body": {
+					"rotation": ["q.riding.velocity_y(0)*-90", 0, 0],
 					"position": {
 						"0.0": [0, 0, 0],
 						"0.0417": [0, -0.25, 0],
@@ -1257,7 +1261,7 @@
 					}
 				},
 				"neck2": {
-					"rotation": ["math.sin(q.anim_time*90*4-60)*4", 0, 0]
+					"rotation": ["math.sin(q.anim_time*90*4-60)*4 - math.pow(q.riding.yaw_delta(0),2)*20", "q.riding.yaw_delta(0)*-10", "q.riding.yaw_delta(0)*10"]
 				},
 				"tail5": {
 					"rotation": ["-10+math.sin(q.anim_time*90*4-100)*6", "math.sin(q.anim_time*90*4-40)*2", "math.sin(q.anim_time*90*4-20)*1"]
@@ -1279,7 +1283,7 @@
 					}
 				},
 				"neck": {
-					"rotation": ["13+math.sin(q.anim_time*90*4-30)*7", 0, 0],
+					"rotation": ["13+math.sin(q.anim_time*90*4-30)*7", "q.riding.yaw_delta(0)*-10", "q.riding.yaw_delta(0)*10"],
 					"position": [0, 0, "-0.5+math.sin(q.anim_time*90*4-30)*0.2"]
 				},
 				"front_neck_braid_left": {

common/src/main/resources/assets/cobblemon/bedrock/pokemon/models/0006_charizard/charizard.geo.json

@@ -7,8 +7,8 @@
 				"texture_width": 256,
 				"texture_height": 128,
 				"visible_bounds_width": 10,
-				"visible_bounds_height": 5,
-				"visible_bounds_offset": [0, 1.5, 0]
+				"visible_bounds_height": 6,
+				"visible_bounds_offset": [0, 2, 0]
 			},
 			"bones": [
 				{
@@ -20,7 +20,7 @@
 					"parent": "charizard",
 					"pivot": [0, 0, -1],
 					"locators": {
-						"root": [0, 0, 0]
+						"root": [0, 0, -1]
 					}
 				},
 				{
@@ -28,7 +28,7 @@
 					"parent": "charizard",
 					"pivot": [0, 41, -1],
 					"locators": {
-						"top": [0, 41, 0]
+						"top": [0, 41, -1]
 					}
 				},
 				{
@@ -116,7 +116,8 @@
 				{
 					"name": "head_correction",
 					"parent": "head",
-					"pivot": [0, 43.5, -0.5]
+					"pivot": [0, 43.5, -0.5],
+					"rotation": [-95, 0, 0]
 				},
 				{
 					"name": "head_ai",
@@ -127,20 +128,15 @@
 					"name": "head_angle",
 					"parent": "head_ai",
 					"pivot": [0, 43.5, -0.5],
+					"rotation": [95, 0, 0],
 					"cubes": [
 						{"origin": [-3.5, 41.5, -2], "size": [7, 7, 5], "uv": [48, 0]},
-						{"origin": [-3.5, 41.5, -4], "size": [7, 4, 2], "uv": [95, 64]}
+						{"origin": [-3.5, 41.5, -4], "size": [7, 4, 2], "uv": [95, 64]},
+						{"origin": [-2.5, 48, -2], "size": [5, 5, 2], "inflate": 0.02, "uv": [37, 31]},
+						{"origin": [-2, 51.48744, -3.03033], "size": [0, 1, 1], "inflate": 0.01, "pivot": [-2, 52.51777, -2], "rotation": [45, 0, 15], "uv": [43, 42]},
+						{"origin": [2, 51.48744, -3.03033], "size": [0, 1, 1], "inflate": 0.01, "pivot": [2, 52.51777, -2], "rotation": [45, 0, -15], "uv": [41, 42]}
 					]
 				},
-				{
-					"name": "item_hat",
-					"parent": "head_angle",
-					"pivot": [0, 45, 3],
-					"rotation": [-90, 0, 0],
-					"locators": {
-						"item_hat": [0, 45, 3]
-					}
-				},
 				{
 					"name": "locator_head",
 					"parent": "head_angle",
@@ -150,51 +146,59 @@
 						"head": [0, 46.5, 3]
 					}
 				},
-				{
-					"name": "locator_face",
-					"parent": "head_angle",
-					"pivot": [0, 53.75, -0.25],
-					"rotation": [-90, 0, 0],
-					"locators": {
-						"face": [0, 53.75, -0.25]
-					}
-				},
-				{
-					"name": "locator_item_face",
-					"parent": "head_angle",
-					"pivot": [0, 48.5, 0.5],
-					"rotation": [-90, 0, 0],
-					"locators": {
-						"item_face": [0, 48.5, 0.5]
-					}
-				},
 				{
 					"name": "locator_mouth",
 					"parent": "head_angle",
-					"pivot": [0, 45.75, -2],
+					"pivot": [0, 48.75, -3],
 					"rotation": [-90, 0, 0],
 					"locators": {
-						"mouth": [0, 45.75, -2],
-						"special": [0, 45.75, -2]
+						"mouth": [0, 48.75, -3]
 					}
 				},
 				{
-					"name": "eyes",
+					"name": "locator_special_attack",
 					"parent": "head_angle",
-					"pivot": [0, -3.5, 1.5]
+					"pivot": [0, 48.75, -3],
+					"rotation": [-90, 0, 0],
+					"locators": {
+						"special_attack": [0, 48.75, -3]
+					}
+				},
+				{
+					"name": "locator_jaw_upper",
+					"parent": "head_angle",
+					"pivot": [0, 51.75, -2.25],
+					"rotation": [-90, 0, 0],
+					"locators": {
+						"jaw1": [0, 51.75, -2.25]
+					}
 				},
 				{
 					"name": "brow",
-					"parent": "eyes",
+					"parent": "head_angle",
 					"pivot": [0, 48.275, 1.765],
 					"cubes": [
 						{"origin": [-2.5, 48.55, 1], "size": [5, 0, 1], "uv": [0, 14]},
 						{"origin": [-3.5, 47.5, 1.53], "size": [7, 1, 1], "inflate": 0.04, "uv": [0, 12]}
 					]
 				},
+				{
+					"name": "eye",
+					"parent": "head_angle",
+					"pivot": [0, -3.5, 1.5]
+				},
+				{
+					"name": "locator_face",
+					"parent": "eye",
+					"pivot": [0, 53.75, -0.25],
+					"rotation": [-90, 0, 0],
+					"locators": {
+						"face": [0, 53.75, -0.25]
+					}
+				},
 				{
 					"name": "eye_right",
-					"parent": "eyes",
+					"parent": "eye",
 					"pivot": [-2.75, 47.75, 0.875],
 					"cubes": [
 						{"origin": [-3.5, 47.5, 0], "size": [2, 1, 2], "inflate": 0.01, "uv": [106, 36]},
@@ -222,7 +226,7 @@
 				},
 				{
 					"name": "eye_left",
-					"parent": "eyes",
+					"parent": "eye",
 					"pivot": [2.75, 47.75, 0.875],
 					"cubes": [
 						{"origin": [1.5, 47.5, 0], "size": [2, 1, 2], "inflate": 0.01, "uv": [44, 82]},
@@ -251,91 +255,6 @@
 						{"origin": [2.41, 46.4, 0.5], "size": [1, 1, 1], "inflate": 0.03, "uv": [39, 86]}
 					]
 				},
-				{
-					"name": "muzzle",
-					"parent": "head_angle",
-					"pivot": [-3, 48.5, -2],
-					"cubes": [
-						{"origin": [-2.5, 48, -2], "size": [5, 5, 2], "inflate": 0.02, "uv": [37, 31]},
-						{"origin": [-2, 51.48744, -3.03033], "size": [0, 1, 1], "inflate": 0.01, "pivot": [-2, 52.51777, -2], "rotation": [45, 0, 15], "uv": [43, 42]},
-						{"origin": [2, 51.48744, -3.03033], "size": [0, 1, 1], "inflate": 0.01, "pivot": [2, 52.51777, -2], "rotation": [45, 0, -15], "uv": [41, 42]}
-					]
-				},
-				{
-					"name": "locator_jaw_upper",
-					"parent": "muzzle",
-					"pivot": [0, 51.75, -2.25],
-					"rotation": [-90, 0, 0],
-					"locators": {
-						"jaw1": [0, 51.75, -2.25]
-					}
-				},
-				{
-					"name": "nose",
-					"parent": "muzzle",
-					"pivot": [0, 53, 0],
-					"rotation": [-40, 0, 0],
-					"cubes": [
-						{"origin": [-2.5, 51.36698, -1.67861], "size": [5, 2, 2], "inflate": 0.03, "uv": [48, 12]},
-						{"origin": [-2, 53.40698, -1.17861], "size": [4, 0, 1], "uv": [0, 15]}
-					]
-				},
-				{
-					"name": "jaw",
-					"parent": "head_angle",
-					"pivot": [0, 45.5, -2],
-					"cubes": [
-						{"origin": [-3.5, 45.5, -4], "size": [7, 3, 2], "inflate": 0.01, "uv": [76, 20]}
-					]
-				},
-				{
-					"name": "jaw2",
-					"parent": "jaw",
-					"pivot": [0, 48.5, -4],
-					"rotation": [-7.5, 0, 0],
-					"cubes": [
-						{"origin": [-2, 48.49, -4], "size": [4, 4, 2], "uv": [0, 51]},
-						{"origin": [-1.5, 48.5, -2], "size": [3, 4, 0], "uv": [90, 0]},
-						{"origin": [1.5, 51.49749, -3.03033], "size": [0, 1, 1], "pivot": [1.5, 52.52782, -2], "rotation": [45, 0, -7.5], "uv": [37, 39]},
-						{"origin": [-1.5, 51.49749, -3.03033], "size": [0, 1, 1], "pivot": [-1.5, 52.52782, -2], "rotation": [45, 0, 7.5], "uv": [37, 38]}
-					]
-				},
-				{
-					"name": "locator_jaw_lower",
-					"parent": "jaw2",
-					"pivot": [0, 51.75, -1.75],
-					"locators": {
-						"jaw2": {
-							"offset": [0, 51.75, -1.75],
-							"rotation": [-90, 0, 0]
-						}
-					}
-				},
-				{
-					"name": "tongue",
-					"parent": "jaw",
-					"pivot": [0, 45.5, -2],
-					"cubes": [
-						{"origin": [-1.5, 45.5, -2], "size": [3, 3, 0], "uv": [87, 29]}
-					]
-				},
-				{
-					"name": "tongue2",
-					"parent": "tongue",
-					"pivot": [0, 48.5, -2],
-					"cubes": [
-						{"origin": [-1, 48.5, -2], "size": [2, 2, 0], "inflate": 0.01, "uv": [46, 38]}
-					]
-				},
-				{
-					"name": "tongue3",
-					"parent": "tongue2",
-					"pivot": [0, 50.5, -2],
-					"cubes": [
-						{"origin": [-1, 50.5, -2], "size": [2, 1, 0], "uv": [37, 43]},
-						{"origin": [-0.5, 51.5, -2], "size": [1, 1, 0], "uv": [45, 43]}
-					]
-				},
 				{
 					"name": "horns",
 					"parent": "head_angle",
@@ -381,6 +300,72 @@
 						"horn2": [2.5, 39, 2]
 					}
 				},
+				{
+					"name": "nose",
+					"parent": "head_angle",
+					"pivot": [0, 53, 0],
+					"rotation": [-40, 0, 0],
+					"cubes": [
+						{"origin": [-2.5, 51.36698, -1.67861], "size": [5, 2, 2], "inflate": 0.03, "uv": [48, 12]},
+						{"origin": [-2, 53.40698, -1.17861], "size": [4, 0, 1], "uv": [0, 15]}
+					]
+				},
+				{
+					"name": "jaw",
+					"parent": "head_angle",
+					"pivot": [0, 45.5, -2],
+					"cubes": [
+						{"origin": [-3.5, 45.5, -4], "size": [7, 3, 2], "inflate": 0.01, "uv": [76, 20]}
+					]
+				},
+				{
+					"name": "jaw2",
+					"parent": "jaw",
+					"pivot": [0, 48.5, -4],
+					"rotation": [-7.5, 0, 0],
+					"cubes": [
+						{"origin": [-2, 48.49, -4], "size": [4, 4, 2], "uv": [0, 51]},
+						{"origin": [-1.5, 48.5, -1.99], "size": [3, 4, 0], "uv": [90, 0]},
+						{"origin": [1.5, 51.49749, -3.03033], "size": [0, 1, 1], "pivot": [1.5, 52.52782, -2], "rotation": [45, 0, -7.5], "uv": [37, 39]},
+						{"origin": [-1.5, 51.49749, -3.03033], "size": [0, 1, 1], "pivot": [-1.5, 52.52782, -2], "rotation": [45, 0, 7.5], "uv": [37, 38]}
+					]
+				},
+				{
+					"name": "locator_jaw_lower",
+					"parent": "jaw2",
+					"pivot": [0, 51.75, -1.75],
+					"locators": {
+						"jaw2": {
+							"offset": [0, 51.75, -1.75],
+							"rotation": [-90, 0, 0]
+						}
+					}
+				},
+				{
+					"name": "tongue",
+					"parent": "jaw",
+					"pivot": [0, 45.5, -2],
+					"cubes": [
+						{"origin": [-1.5, 45.5, -2], "size": [3, 3, 0], "uv": [87, 29]}
+					]
+				},
+				{
+					"name": "tongue2",
+					"parent": "tongue",
+					"pivot": [0, 48.5, -2],
+					"cubes": [
+						{"origin": [-1, 48.5, -2], "size": [2, 2, 0], "inflate": 0.01, "uv": [46, 38]}
+					]
+				},
+				{
+					"name": "tongue3",
+					"parent": "tongue2",
+					"pivot": [0, 50.5, -2],
+					"cubes": [
+						{"origin": [-1, 50.5, -2], "size": [2, 1, 0], "uv": [37, 43]},
+						{"origin": [-0.5, 51.5, -2], "size": [1, 1, 0], "uv": [45, 43]}
+					]
+				},
 				{
 					"name": "arms",
 					"parent": "torso2",
@@ -418,14 +403,6 @@
 						{"origin": [-21.5, 22, -1.5], "size": [3, 2, 3], "inflate": 0.1, "uv": [0, 58]}
 					]
 				},
-				{
-					"name": "locator_item",
-					"parent": "hand_right",
-					"pivot": [-21.6, 23, 0],
-					"locators": {
-						"item": [-21.6, 23, 0]
-					}
-				},
 				{
 					"name": "locator_hand_primary",
 					"parent": "hand_right",
@@ -936,14 +913,6 @@
 						{"origin": [0, 9.5, 58.5], "size": [0, 13, 7], "pivot": [0, 14.45, 62], "rotation": [0, 90, 0], "uv": [0, 92]}
 					]
 				},
-				{
-					"name": "locator_fire",
-					"parent": "fire2",
-					"pivot": [0, 11, 62],
-					"locators": {
-						"fire": [0, 11, 62]
-					}
-				},
 				{
 					"name": "legs",
 					"parent": "body",
@@ -976,10 +945,9 @@
 				{
 					"name": "locator_foot_primary",
 					"parent": "foot_right",
-					"pivot": [-9, 1.5, -5],
-					"rotation": [90, 0, 0],
+					"pivot": [-9, 1.5, -7],
 					"locators": {
-						"foot_primary": [-9, 1.5, -5]
+						"foot_primary": [-9, 1.5, -7]
 					}
 				},
 				{
@@ -1041,10 +1009,9 @@
 				{
 					"name": "locator_foot_secondary",
 					"parent": "foot_left",
-					"pivot": [9, 1.5, -5],
-					"rotation": [90, 0, 0],
+					"pivot": [9, 1.5, -7],
 					"locators": {
-						"foot_secondary": [9, 1.5, -5]
+						"foot_secondary": [9, 1.5, -7]
 					}
 				},
 				{

common/src/main/resources/assets/cobblemon/bedrock/pokemon/models/0462_magnezone/magnezone.geo.json

@@ -405,6 +405,14 @@
 					"cubes": [
 						{"origin": [-5, 6.5, 25.92], "size": [10, 3, 0], "uv": [77, 7]}
 					]
+				},
+				{
+					"name": "locator_seat_1",
+					"parent": "body",
+					"pivot": [0, 0, 0],
+					"locators": {
+						"seat_1": [0, 17.5, 4]
+					}
 				}
 			]
 		}

common/src/main/resources/assets/cobblemon/bedrock/pokemon/models/0750_mudsdale/mudsdale.geo.json

@@ -7,8 +7,8 @@
 				"texture_width": 128,
 				"texture_height": 128,
 				"visible_bounds_width": 6,
-				"visible_bounds_height": 4.5,
-				"visible_bounds_offset": [0, 1.75, 0]
+				"visible_bounds_height": 5,
+				"visible_bounds_offset": [0, 1.5, 0]
 			},
 			"bones": [
 				{
@@ -480,6 +480,14 @@
 						{"origin": [-4.5, 24.5, 26.5], "size": [9, 9, 7], "uv": [66, 109]}
 					]
 				},
+				{
+					"name": "locator_seat_1",
+					"parent": "torso",
+					"pivot": [0, 0, 0],
+					"locators": {
+						"seat_1": [0, 30, 0]
+					}
+				},
 				{
 					"name": "legs",
 					"parent": "body",

common/src/main/resources/assets/cobblemon/bedrock/pokemon/posers/0006_charizard/charizard.json

@@ -99,7 +99,14 @@
       "poseTypes": ["FLY"],
       "isBattle": false,
       "condition": "!q.is_gliding",
-      "animations": ["q.look('head_ai')", "q.bedrock('charizard', 'air_fly')"],
+      "animations": [
+        "q.look('head_ai')",
+        "q.bedrock('charizard', 'air_fly')",
+        {
+          "condition": "q.is_ridden",
+          "animation": "q.bedrock('charizard', 'ride_air_look')"
+        }
+      ],
       "quirks": [
         "q.bedrock_quirk('charizard', 'blink')",
         "q.bedrock_quirk('charizard', 'air_fly_quirk')"
@@ -109,7 +116,14 @@
       "poseTypes": ["FLY"],
       "isBattle": false,
       "condition": "q.is_gliding",
-      "animations": ["q.look('head_ai')", "q.bedrock('charizard', 'air_glide_TEST')"],
+      "animations": [
+        "q.look('head_ai')",
+        "q.bedrock('charizard', 'air_glide_TEST')",
+        {
+          "condition": "q.is_ridden",
+          "animation": "q.bedrock('charizard', 'ride_air_look')"
+        }
+      ],
       "quirks": [
         "q.bedrock_quirk('charizard', 'blink')"
       ]

common/src/main/resources/assets/cobblemon/bedrock/pokemon/posers/0357_tropius/tropius.json

@@ -4,6 +4,18 @@
   "profileScale": 0.28,
   "profileTranslation": [ 0, 1.26, 0 ],
   "rootBone": "tropius",
+  "seatToCameraOffset": {
+    "seat_1": [
+      0,
+      5,
+      10
+    ],
+    "seat_1_reverse": [
+      0,
+      2,
+      4
+    ]
+  },
    "animations": {
      "faint": "q.bedrock_primary('tropius', 'faint', q.curve('one'))",
      "cry": "q.bedrock_stateful('tropius', 'cry')",

common/src/main/resources/assets/cobblemon/bedrock/pokemon/posers/0445_garchomp/garchomp.json

@@ -139,8 +139,7 @@
       "poseTypes": ["FLY"],
       "animations": ["q.look('head')", "q.bedrock('garchomp', 'air_fly')"],
       "quirks": [
-        "q.bedrock_quirk('garchomp', 'blink')",
-        "q.bedrock_quirk('garchomp', q.array('air_fly_quirk1', 'air_fly_quirk2'), 5, 10, 1)"
+        "q.bedrock_quirk('garchomp', 'blink')"
       ],
       "transformedParts": [
         {

common/src/main/resources/assets/cobblemon/bedrock/pokemon/posers/0750_mudsdale/mudsdale.json

@@ -0,0 +1,36 @@
+{
+    "portraitScale": 1.5,
+    "portraitTranslation": [-1.0, 1.76, 0.0],
+    "profileScale": 0.5,
+    "profileTranslation": [0.0, 1.0, 0.0],
+    "rootBone": "mudsdale",
+    "animations": {
+      "cry": "q.bedrock_stateful('mudsdale', 'cry')"
+    },
+    "poses": {
+      "sleep": {
+        "poseName": "sleep",
+        "poseTypes": ["SLEEP"],
+        "animations": ["q.bedrock('mudsdale', 'sleep')"]
+      },
+      "standing": {
+        "poseName": "standing",
+        "poseTypes": ["STAND", "FLOAT", "NONE", "PORTRAIT", "PROFILE"],
+        "animations": [
+          "q.look('head')",
+          "q.bedrock('mudsdale', 'ground_idle')",
+          "q.bedrock_stateful('mudsdale', 'blink')"
+        ]
+      },
+      "walk": {
+        "poseName": "walk",
+        "poseTypes": ["WALK", "SWIM"],
+        "animations": [
+          "q.look('head')",
+          "q.bedrock('mudsdale', 'ground_walk')",
+          "q.bedrock_stateful('mudsdale', 'blink')"
+        ]
+      }
+    }
+  }
+  

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

@@ -1026,6 +1026,50 @@
       { "name": "cobblemon:shiny/wild_shiny_ambient_chime_4", "volume": 0.8, "attenuation_distance": 128.0 }
     ]
   },
+  "animation.plumage.wing_flap.small": {
+    "sounds": [
+      { "name": "cobblemon:animation/wings/plumage_wing_flap_small_1", "volume": 0.25 },
+      { "name": "cobblemon:animation/wings/plumage_wing_flap_small_2", "volume": 0.25 },
+      { "name": "cobblemon:animation/wings/plumage_wing_flap_small_3", "volume": 0.25 },
+      { "name": "cobblemon:animation/wings/plumage_wing_flap_small_4", "volume": 0.25 },
+      { "name": "cobblemon:animation/wings/plumage_wing_flap_small_5", "volume": 0.25 },
+      { "name": "cobblemon:animation/wings/plumage_wing_flap_small_6", "volume": 0.25 },
+      { "name": "cobblemon:animation/wings/plumage_wing_flap_small_7", "volume": 0.25 }
+    ]
+  },
+  "animation.plumage.wing_flap.medium": {
+    "sounds": [
+      { "name": "cobblemon:animation/wings/plumage_wing_flap_medium_1", "volume": 0.3 },
+      { "name": "cobblemon:animation/wings/plumage_wing_flap_medium_2", "volume": 0.3 },
+      { "name": "cobblemon:animation/wings/plumage_wing_flap_medium_3", "volume": 0.3 },
+      { "name": "cobblemon:animation/wings/plumage_wing_flap_medium_4", "volume": 0.3 },
+      { "name": "cobblemon:animation/wings/plumage_wing_flap_medium_5", "volume": 0.3 },
+      { "name": "cobblemon:animation/wings/plumage_wing_flap_medium_6", "volume": 0.3 },
+      { "name": "cobblemon:animation/wings/plumage_wing_flap_medium_7", "volume": 0.3 }
+    ]
+  },
+  "animation.leather.wing_flap.small": {
+    "sounds": [
+      { "name": "cobblemon:animation/wings/leather_wing_flap_small_1", "volume": 0.25 },
+      { "name": "cobblemon:animation/wings/leather_wing_flap_small_2", "volume": 0.25 },
+      { "name": "cobblemon:animation/wings/leather_wing_flap_small_3", "volume": 0.25 },
+      { "name": "cobblemon:animation/wings/leather_wing_flap_small_4", "volume": 0.25 },
+      { "name": "cobblemon:animation/wings/leather_wing_flap_small_5", "volume": 0.25 },
+      { "name": "cobblemon:animation/wings/leather_wing_flap_small_6", "volume": 0.25 },
+      { "name": "cobblemon:animation/wings/leather_wing_flap_small_7", "volume": 0.25 }
+    ]
+  },
+  "animation.leather.wing_flap.medium": {
+    "sounds": [
+      { "name": "cobblemon:animation/wings/leather_wing_flap_medium_1", "volume": 0.3 },
+      { "name": "cobblemon:animation/wings/leather_wing_flap_medium_2", "volume": 0.3 },
+      { "name": "cobblemon:animation/wings/leather_wing_flap_medium_3", "volume": 0.3 },
+      { "name": "cobblemon:animation/wings/leather_wing_flap_medium_4", "volume": 0.3 },
+      { "name": "cobblemon:animation/wings/leather_wing_flap_medium_5", "volume": 0.3 },
+      { "name": "cobblemon:animation/wings/leather_wing_flap_medium_6", "volume": 0.3 },
+      { "name": "cobblemon:animation/wings/leather_wing_flap_medium_7", "volume": 0.3 }
+    ]
+  },
   "pokemon.bulbasaur.ambient": {
     "sounds": [ "cobblemon:pokemon/bulbasaur/bulbasaur_ambient" ]
   },

common/src/main/resources/data/cobblemon/species/generation3/tropius.json

@@ -65,6 +65,134 @@
       }
     }
   },
+  "riding": {
+    "stats": {
+      "SPEED": {
+        "displayName": "Speed",
+        "description": "Its top speed",
+        "ranges": {
+          "LAND": "40-60",
+          "AIR": "100-101"
+        }
+      },
+      "ACCELERATION": {
+        "displayName": "Acceleration",
+        "description": "How fast it can speed up",
+        "ranges": {
+          "LAND": "40-60",
+          "AIR": "100-101"
+        }
+      },
+      "SKILL": {
+        "displayName": "Handling",
+        "description": "How fast it can turn",
+        "ranges": {
+          "LAND": "40-60",
+          "AIR": "100-101"
+        }
+      },
+      "JUMP": {
+        "displayName": "Altitude",
+        "description": "How high it can fly",
+        "ranges": {
+          "LAND": "40-60",
+          "AIR": "100-101"
+        }
+      },
+      "STAMINA": {
+        "displayName": "Fuel/Stamina",
+        "description": "How long it can stay off the ground",
+        "ranges": {
+          "LAND": "40-60",
+          "AIR": "100-101"
+        }
+      }
+    },
+    "behaviour": {
+      "key": "cobblemon:composite",
+      "transitionStrategy": "cobblemon:strategy/jump",
+      "defaultBehaviour": {
+        "key": "cobblemon:land/generic",
+        "gravity": "q.gravity * (0.1 + (q.passenger_count - 1) * 0.1)",
+        "speed": "Math.clamp(q.entity.velocity.horizontal_magnitude + 0.33, 0, 1)",
+        "jumpVector": [
+          0,
+          "0.3*q.jump_strength/50",
+          "-1 * 0.5*q.jump_strength/50"
+        ]
+      },
+      "alternateBehaviour": {
+        "key": "cobblemon:air/bird",
+        "gravity": "q.gravity * (0.1 + (q.passenger_count - 1) * 0.1)",
+        "speed": "Math.clamp(q.entity.velocity.horizontal_magnitude + 0.33, 0, 1)",
+        "jumpVector": [
+          0,
+          "0.3*q.jump_strength/50",
+          0
+        ]
+      }
+    },
+    "seats": [
+      {
+        "offset": {
+          "x": 0,
+          "y": 1.5,
+          "z": -0.5
+        },
+        "poseOffsets": [
+          {
+            "poseTypes": [
+              "HOVER"
+            ],
+            "offset": {
+              "x": 0,
+              "y": 0.7,
+              "z": -1
+            }
+          },
+          {
+            "poseTypes": [
+              "FLY"
+            ],
+            "offset": {
+              "x": 0,
+              "y": 0.2,
+              "z": -1
+            }
+          }
+        ]
+      },
+      {
+        "offset": {
+          "x": 0,
+          "y": 1.5,
+          "z": -1.5
+        },
+        "poseOffsets": [
+          {
+            "poseTypes": [
+              "HOVER"
+            ],
+            "offset": {
+              "x": 0,
+              "y": 0.4,
+              "z": -1
+            }
+          },
+          {
+            "poseTypes": [
+              "FLY"
+            ],
+            "offset": {
+              "x": 0,
+              "y": 0.2,
+              "z": -0.2
+            }
+          }
+        ]
+      }
+    ]
+  },
   "drops": {
     "amount": 2,
     "entries": [

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

@@ -67,6 +67,69 @@
       "light": "0-4"
     }
   },
+  "riding": {
+    "stats": {
+      "SPEED": {
+        "displayName": "Speed",
+        "description": "Its top speed",
+        "ranges": {
+          "AIR": "100-101"
+        }
+      },
+      "ACCELERATION": {
+        "displayName": "Acceleration",
+        "description": "How fast it can speed up",
+        "ranges": {
+          "AIR": "100-101"
+        }
+      },
+      "SKILL": {
+        "displayName": "Handling",
+        "description": "How fast it can turn",
+        "ranges": {
+          "AIR": "100-101"
+        }
+      },
+      "JUMP": {
+        "displayName": "Altitude",
+        "description": "How high it can jump",
+        "ranges": {
+          "AIR": "100-101"
+        }
+      },
+      "STAMINA": {
+        "displayName": "Fuel/Stamina",
+        "description": "How long it can sprint",
+        "ranges": {
+          "AIR": "100-101"
+        }
+      }
+    },
+    "behaviour": {
+      "key": "cobblemon:air/hover"
+    },
+    "seats": [
+      {
+        "offset": {
+          "x": 0,
+          "y": 0.4,
+          "z": 0
+        },
+        "poseOffsets": [
+          {
+            "poseTypes": [
+              "FLY"
+            ],
+            "offset": {
+              "x": 0,
+              "y": 0.0,
+              "z": 0
+            }
+          }
+        ]
+      }
+    ]
+  },
   "drops": {
     "amount": 6,
     "entries": [

common/src/main/resources/data/cobblemon/species/generation7/mudsdale.json

@@ -59,6 +59,69 @@
       }
     }
   },
+  "riding": {
+    "stats": {
+      "SPEED": {
+        "displayName": "Speed",
+        "description": "Its top speed",
+        "ranges": {
+          "LAND": "100-101"
+        }
+      },
+      "ACCELERATION": {
+        "displayName": "Acceleration",
+        "description": "How fast it can speed up",
+        "ranges": {
+          "LAND": "100-101"
+        }
+      },
+      "SKILL": {
+        "displayName": "Handling",
+        "description": "How fast it can turn",
+        "ranges": {
+          "LAND": "100-101"
+        }
+      },
+      "JUMP": {
+        "displayName": "Altitude",
+        "description": "How high it can jump",
+        "ranges": {
+          "LAND": "100-101"
+        }
+      },
+      "STAMINA": {
+        "displayName": "Fuel/Stamina",
+        "description": "How long it can sprint",
+        "ranges": {
+          "LAND": "100-101"
+        }
+      }
+    },
+    "behaviour": {
+      "key": "cobblemon:land/generic"
+    },
+    "seats": [
+      {
+        "offset": {
+          "x": 0,
+          "y": 0.4,
+          "z": 0
+        },
+        "poseOffsets": [
+          {
+            "poseTypes": [
+              "FLY"
+            ],
+            "offset": {
+              "x": 0,
+              "y": 0.0,
+              "z": 0
+            }
+          }
+        ]
+      }
+    ]
+  },
   "drops": {
     "amount": 6,
     "entries": [

common/src/main/resources/mixins.cobblemon-common.json

@@ -14,19 +14,18 @@
     "VillagerProfessionLayerMixin",
     "accessor.EntryListWidgetAccessor",
     "accessor.KeyBindingAccessor",
+    "client.AbstractClientPlayerMixin",
+    "client.CameraMixin",
+    "client.EntryListWidgetMixin",
     "client.GameRendererMixin",
+    "client.HumanoidModelMixin",
     "client.ItemInHandRendererMixin",
     "client.ItemRendererMixin",
+    "client.LocalPlayerMixin",
     "client.ModelLoaderMixin",
     "client.ModelPartMixin",
     "client.MouseHandlerMixin",
     "client.PlayerRendererMixin",
-    "client.HumanoidModelMixin",
-    "client.AbstractClientPlayerMixin",
-    "client.EntryListWidgetMixin",
-    "client.LocalPlayerMixin",
-    "client.PlayerModelMixin",
-    "client.CameraMixin",
     "invoker.ClientPlayNetworkHandlerInvoker",
     "riding.JetMixin"
   ],
@@ -47,8 +46,9 @@
     "PiglinEntityMixin",
     "PlayerAdvancementsMixin",
     "PlayerMixin",
-    "ServerPlayerMixin",
+    "PointedDripstoneBlockMixin",
     "ServerEntityMixin",
+    "ServerPlayerMixin",
     "ShearsDispenserBehaviorMixin",
     "StructurePoolAccessor",
     "StructurePoolGeneratorMixin",