Camera changes for riding. Need to find a better system for being "unlocked" (in third person only) to make the animations feel better.

Added scraper for riding sheet

See merge request cable-mc/cobblemon!1546

CHANGELOG-RIDING.md

@@ -0,0 +1,3 @@
+### Additions
+
+- Added the ability to ride Pokémon by shift-right clicking and selecting the ride option.

CHANGELOG.md

@@ -7,6 +7,8 @@
 - Added `blacklisted_items_to_hold` and `whitelisted_items_to_hold` tags to allow for controlling which items players can give to their Pokémon. If the whitelist is empty, it will consider all item as allowed (unless they are in the blacklist).
 - Pokémon now follow the mouse cursor on the Summary screen, with an option to disable this in the settings.
 - Pokémon's held items can now be rendered, with a visibility toggle in the Summary screen.
+- Added cosmetic item functionality for Pokémon. Certain cosmetic items can be given to applicable Pokémon via the interact menu.
+  - Added the various log blocks as cosmetic items for Timburr and Komala.
 - Added `visibility/hidden`, `visibility/hat` and `visibility/face` tags to control where and how certain items are rendered.
 
 ### Changes
@@ -24,6 +26,14 @@
 - Fixed evolutions sometimes preventing players from logging in to servers
 - Fixed rendering of shoulder-mounted Pokémon desyncing between clients
 - Fixed apricorn chest boats forgetting their inventories when being unloaded
+- Fixed moves not updating correctly between form changes resulting in illegal movesets
+- Fixed crash sometimes occurring with the "Oritech" mod
+- Fixed crashes due to an incorrect Java version handing out an obscure crash.
+- Fixed some berries being able to rarely get too many berries and cause a crash.
+- Fixed status curing berries not playing the berry eating sound, same for healing berries used mid-battle.
+- Fixed owned Pokémon sometimes being un-interactable after the player relogs fast
+- Fixed field name in evolution requirements for Spewpa Pokeball.
+- Fixed LevelUpCriterion logic to correctly check that the Pokémon is a preEvo.
 
 ### Developer
 - A finished battle now has winners and losers set inside of `PokemonBattle` instead of them always being empty.
@@ -37,11 +47,13 @@
 
 ### Changes
 - When using the `cobblemon` or `generation_9` capture calculators a critical capture with a single shake will always play for successful captures when you've already registered the Pokémon as caught in your Pokédex.
+
 ### MoLang & Datapacks
 - The following usages for item predicates can now use item conditions like advancements do, you can learn about them in the [Minecraft wiki](https://minecraft.wiki/w/Advancement_definition#minecraft:filled_bucket)
   - The `requiredContext` for an item interaction evolution
   - The `itemCondition` for a held item evolution requirement
   - The `fossils` for a fossil entry
+- Added MoLang flows for `poke_ball_capture_calculated`, `evolution_tested`, `evolution_accepted`, `evolution_completed`
 
 ## [1.6.1 (January 26th, 2025)](#1-6-1)
 
@@ -2162,4 +2174,4 @@ Thank you so much to all of our community translators that bring the mod to the
 - Added species, ability, and move translations for `ko_ko`, `jp_jp`, `fr_fr`, `es_es`, `it_it`, and `zh_cn`.
 
 ## [1.0.0 (November 12th, 2022)](#1-0-0)
-- Initial release.
+- Initial release.

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

@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common;
+
+import net.minecraft.util.Mth;
+import org.jetbrains.annotations.Nullable;
+import org.joml.Matrix3f;
+import org.joml.Vector3f;
+
+import java.util.function.Function;
+
+public interface Rollable {
+
+    // From Minecraft's Camera
+    Vector3f FORWARDS = new Vector3f(0.0F, 0.0F, -1.0F);
+    Vector3f UP = new Vector3f(0.0F, 1.0F, 0.0F);
+    Vector3f LEFT = new Vector3f(-1.0F, 0.0F, 0.0F);
+
+    @Nullable Matrix3f getOrientation();
+
+    Rollable updateOrientation(Function<Matrix3f, Matrix3f> update);
+
+    /**
+     * @return The forward vector (0, 0, -1) after the rotation matrix is applied.
+     */
+    default Vector3f getForwardVector() {
+        if (getOrientation() == null) return new Vector3f(FORWARDS);
+        return getOrientation().transform(FORWARDS, new Vector3f());
+    }
+
+    /**
+     * @return The left vector (-1, 0, 0) after the rotation matrix is applied.
+     */
+    default Vector3f getLeftVector() {
+        if (getOrientation() == null) return new Vector3f(LEFT);
+        return getOrientation().transform(LEFT, new Vector3f());
+    }
+
+    /**
+     * @return The up vector (0, 1, 0) after the rotation matrix is applied.
+     */
+    default Vector3f getUpVector() {
+        if (getOrientation() == null) return new Vector3f(UP);
+        return getOrientation().transform(UP, new Vector3f());
+    }
+
+    /**
+     *
+     * @param yaw change in degrees
+     * @return The Rollable object this method was called on
+     */
+
+    default Rollable rotateYaw(float yaw) {
+        return updateOrientation(prev -> prev.rotateY((float) Math.toRadians(-yaw)));
+    }
+
+    /**
+     *
+     * @param pitch change in degrees
+     * @return The Rollable object this method was called on
+     */
+
+    default Rollable rotatePitch(float pitch) {
+        return updateOrientation(prev -> prev.rotateX((float) Math.toRadians(-pitch)));
+    }
+
+    /**
+     *
+     * @param roll change in degrees
+     * @return The Rollable object this method was called on
+     */
+    default Rollable rotateRoll(float roll) {
+        return updateOrientation(prev -> prev.rotateZ((float) Math.toRadians(-roll)));
+    }
+
+
+    /**
+     * Order matters when rotating an object. If you need a different order, individually call rotateYaw, rotatePitch, and rotateRoll
+     *
+     * @param yaw change in degrees
+     * @param pitch change in degrees
+     * @param roll change in degrees
+     * @return The Rollable object this method was called on
+     */
+    default Rollable rotate(float yaw, float pitch, float roll) {
+        return rotateYaw(yaw).rotatePitch(pitch).rotateRoll(roll);
+    }
+
+    /**
+     * @return The pitch angle in degrees as a float.
+     * Value is between [-180, 180] with 0 being South, 90 being West, 180/-180 being North, and -90 being East
+     */
+    default float getYaw() {
+        return (float) Mth.wrapDegrees(-Math.toDegrees(FORWARDS.angleSigned(getForwardVector(), UP)) + 180);
+    }
+
+    /**
+     * @return The yaw angle in degrees as a float.
+     * Value is between [-90, 90] with 0 being straight forward, 90 being straight down, and -90 being straight up
+     */
+    default float getPitch() {
+        return (float) Mth.wrapDegrees(-Math.toDegrees(Math.asin(getForwardVector().y)));
+    }
+
+    /**
+     * @return The roll angle in degrees as a float.
+     * Value is between [-180, 180] with 0 being no roll (normal), 90 being 90 degrees CW, 180/-180 being 180 degrees CW/CCW, and -90 being 90 degrees CCW
+     */
+    default float getRoll() {
+        //Cobblemon.LOGGER.info("{}", (float) Math.toDegrees(getUpVector().angleSigned(UP, getForwardVector())));
+        return (float) Mth.wrapDegrees(-Math.toDegrees(getUpVector().angleSigned(UP, getForwardVector())));
+    }
+
+    boolean shouldRoll();
+
+    void clearRotation();
+
+}

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

@@ -10,12 +10,15 @@ package com.cobblemon.mod.common.mixin;
 
 import com.cobblemon.mod.common.Cobblemon;
 import com.cobblemon.mod.common.CobblemonItems;
+import com.cobblemon.mod.common.Rollable;
 import com.cobblemon.mod.common.api.events.CobblemonEvents;
 import com.cobblemon.mod.common.api.events.item.LeftoversCreatedEvent;
 import com.cobblemon.mod.common.api.pokemon.PokemonSpecies;
+import com.cobblemon.mod.common.api.riding.Rideable;
 import com.cobblemon.mod.common.api.storage.party.PartyStore;
 import com.cobblemon.mod.common.api.storage.party.PlayerPartyStore;
 import com.cobblemon.mod.common.api.tags.CobblemonItemTags;
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
 import com.cobblemon.mod.common.pokedex.scanner.PokedexEntityData;
 import com.cobblemon.mod.common.pokedex.scanner.ScannableEntity;
 import com.cobblemon.mod.common.pokemon.FormData;
@@ -26,6 +29,10 @@ import com.cobblemon.mod.common.util.CompoundTagExtensionsKt;
 import com.cobblemon.mod.common.util.CompoundTagUtilities;
 import com.cobblemon.mod.common.util.DataKeys;
 import com.cobblemon.mod.common.world.gamerules.CobblemonGameRules;
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.player.LocalPlayer;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.nbt.Tag;
 import net.minecraft.network.chat.Component;
@@ -38,8 +45,10 @@ import net.minecraft.world.entity.item.ItemEntity;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.food.FoodProperties;
 import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
 import net.minecraft.world.level.Level;
 import org.jetbrains.annotations.Nullable;
+import org.joml.Matrix3f;
 import org.objectweb.asm.Opcodes;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
@@ -53,10 +62,11 @@ import java.util.List;
 import java.util.Objects;
 import java.util.Set;
 import java.util.UUID;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
 @Mixin(Player.class)
-public abstract class PlayerMixin extends LivingEntity implements ScannableEntity {
+public abstract class PlayerMixin extends LivingEntity implements Rollable, ScannableEntity {
 
     @Shadow public abstract CompoundTag getShoulderEntityLeft();
 
@@ -74,6 +84,7 @@ public abstract class PlayerMixin extends LivingEntity implements ScannableEntit
 
     @Shadow public abstract void displayClientMessage(Component message, boolean overlay);
 
+    @Unique private Matrix3f orientation = null;
 
     protected PlayerMixin(EntityType<? extends LivingEntity> p_20966_, Level p_20967_) {
         super(p_20966_, p_20967_);
@@ -167,8 +178,7 @@ public abstract class PlayerMixin extends LivingEntity implements ScannableEntit
 
     @Inject(method = "isInvulnerableTo", at = @At("HEAD"), cancellable = true)
     public void isInvulnerableTo(DamageSource source, CallbackInfoReturnable<Boolean> ci) {
-        if (!level().isClientSide) {
-            ServerPlayer player = (ServerPlayer)(Object)this;
+        if (!level().isClientSide && (Object) this instanceof ServerPlayer player) {
             boolean invulnerableInBattle = this.level().getGameRules().getBoolean(CobblemonGameRules.BATTLE_INVULNERABILITY);
             boolean inBattle = Cobblemon.INSTANCE.getBattleRegistry().getBattleByParticipatingPlayer(player) != null;
             if (invulnerableInBattle && inBattle) {
@@ -225,4 +235,81 @@ public abstract class PlayerMixin extends LivingEntity implements ScannableEntit
     public LivingEntity resolveEntityScan() {
         return this;
     }
-}
+
+    @Override
+    public void absMoveTo(double x, double y, double z, float yaw, float pitch) {
+        if (shouldRoll()) {
+            this.absMoveTo(x, y, z);
+            this.setYRot(yaw % 360.0f);
+            this.setXRot(pitch % 360.0f);
+            this.yRotO = this.getYRot();
+            this.xRotO = this.getXRot();
+        }
+        else {
+            this.absMoveTo(x, y, z);
+            this.absRotateTo(yaw, pitch);
+        }
+    }
+
+    @Inject(method = "tick", at = @At("HEAD"))
+    public void tick(CallbackInfo ci) {
+        if (this.shouldRoll()) {
+            // Proof of concept for yaw movement
+            if (this.getMainHandItem().is(Items.STICK)) {
+                this.rotateYaw(2);
+            }
+            else if (this.getMainHandItem().is(Items.BLAZE_ROD)) {
+                this.rotateYaw(-2);
+            }
+        }
+    }
+
+    @Override
+    public Matrix3f getOrientation() {
+        return orientation;
+    }
+
+    @Override
+    public Rollable updateOrientation(Function<Matrix3f, Matrix3f> update) {
+        if (!shouldRoll()) return this;
+
+        if (this.orientation == null) {
+            this.orientation = new Matrix3f();
+            this.rotate(getYRot() - 180, getXRot(), 0);
+        }
+        this.orientation = update.apply(this.orientation);
+        setYRot(this.getYaw());
+        setXRot(this.getPitch());
+        return this;
+    }
+
+    @Override
+    public boolean shouldRoll() {
+        LocalPlayer player = Minecraft.getInstance().player;
+        if (!this.equals(player)) return false;
+        if (player.isHolding(Items.DIAMOND)) return true;
+
+        var playerVehicle = player.getVehicle();
+        if (playerVehicle == null) return false;
+        if (!(playerVehicle instanceof PokemonEntity pokemonEntity)) return false;
+
+        return pokemonEntity.getRiding().shouldRoll(pokemonEntity);
+    }
+
+    @Override
+    public void clearRotation() {
+        this.orientation = null;
+    }
+
+    @WrapOperation(
+            method = "rideTick()V",
+            at = @At(value = "INVOKE", target = "Lnet/minecraft/world/entity/player/Player;wantsToStopRiding()Z")
+    )
+    public boolean delegateDismountToController(Player instance, Operation<Boolean> original) {
+        if (this.getVehicle() instanceof Rideable vehicle) {
+            return vehicle.getRiding().dismountOnShift() && original.call(instance);
+        }
+        return original.call(instance);
+    }
+
+}

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

@@ -1,28 +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;
-
-import com.cobblemon.mod.common.client.render.ClientPlayerIcon;
-import com.mojang.blaze3d.vertex.PoseStack;
-import net.minecraft.client.player.AbstractClientPlayer;
-import net.minecraft.client.renderer.MultiBufferSource;
-import net.minecraft.client.renderer.entity.player.PlayerRenderer;
-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(PlayerRenderer.class)
-public class PlayerRendererMixin {
-
-    @Inject(method = "render", at = @At(value = "TAIL"))
-    public void renderPlayer(AbstractClientPlayer player, float f, float g, PoseStack poseStack, MultiBufferSource multiBufferSource, int i, CallbackInfo ci) {
-        ClientPlayerIcon.Companion.onRenderPlayer(player);
-    }
-}

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

@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin.client;
+
+import com.cobblemon.mod.common.Rollable;
+import com.cobblemon.mod.common.api.riding.Rideable;
+import com.cobblemon.mod.common.api.riding.Seat;
+import com.cobblemon.mod.common.client.entity.PokemonClientDelegate;
+import com.cobblemon.mod.common.client.render.MatrixWrapper;
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import net.minecraft.client.Camera;
+import net.minecraft.client.Minecraft;
+import net.minecraft.util.Mth;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.phys.Vec3;
+import org.joml.Matrix3f;
+import org.joml.Quaternionf;
+import org.joml.Vector3f;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(Camera.class)
+public abstract class CameraMixin {
+    @Shadow @Final private static float DEFAULT_CAMERA_DISTANCE;
+
+    @Shadow private Entity entity;
+    @Shadow @Final private Quaternionf rotation;
+    @Shadow @Final private Vector3f forwards;
+    @Shadow @Final private Vector3f up;
+    @Shadow @Final private Vector3f left;
+    @Shadow private float xRot;
+    @Shadow private float yRot;
+
+    @Shadow public abstract float getXRot();
+    @Shadow public abstract float getYRot();
+
+    @Shadow private Vec3 position;
+    @Shadow private float eyeHeight;
+    @Shadow private float eyeHeightOld;
+
+    @Unique private float returnTimer = 0;
+    @Unique private float rollAngleStart = 0;
+    @Unique Minecraft minecraft = Minecraft.getInstance();
+
+    @Unique boolean disableRollableCameraDebug = false;
+
+    @Inject(method = "setRotation", at = @At("HEAD"), cancellable = true)
+    public void open_camera$setRotation(float f, float g, CallbackInfo ci) {
+        if (!(this.entity instanceof Rollable rollable) || disableRollableCameraDebug) return;
+        if (!rollable.shouldRoll() && rollable.getOrientation() != null) {
+            if(this.returnTimer < 1) {
+                //Rotation is taken from entity since we no longer handle mouse ourselves
+                //Stops a period of time when you can't input anything.
+                rollable.getOrientation().set(
+                        new Matrix3f()
+                                .rotateY((float) Math.toRadians(180 - this.entity.getYRot()))
+                                .rotateX((float) Math.toRadians(-this.entity.getXRot()))
+                );
+                if(rollAngleStart == 0){
+                    this.returnTimer = 1;
+                    rollable.clearRotation();
+                    return;
+                }
+                rollable.getOrientation().rotateZ((float) Math.toRadians(-rollAngleStart*(1-returnTimer)));
+                applyRotation();
+                this.returnTimer += .05F;
+                ci.cancel();
+            } else {
+                this.returnTimer = 1;
+                rollable.clearRotation();
+            }
+            return;
+        }
+        if (rollable.getOrientation() == null) return;
+        applyRotation();
+
+        this.returnTimer = 0;
+        this.rollAngleStart = rollable.getRoll();
+        ci.cancel();
+    }
+
+    //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 positionCamera(Camera instance, double x, double y, double z, Operation<Void> original){
+        Entity entity = instance.getEntity();
+        Entity vehicle = entity.getVehicle();
+
+        if(vehicle instanceof Rideable){
+            //RidingCameraDelagate.INSTANCE.positionCamera(instance, x, y, z, original);
+            if(!(vehicle instanceof PokemonEntity)){
+                original.call(instance, x, y, z);
+                return;
+            }
+            PokemonEntity pokemon = (PokemonEntity) vehicle;
+
+            int seatIndex = pokemon.getPassengers().indexOf(entity);
+            Seat seat = pokemon.getSeats().get(seatIndex);
+            PokemonClientDelegate delegate = (PokemonClientDelegate) pokemon.getDelegate();
+            MatrixWrapper locator = delegate.getLocatorStates().get(seat.getLocator());
+            if(locator == null){
+                original.call(instance, x, y, z);
+                return;
+            }
+
+            Vec3 locatorOffset = new Vec3(locator.getMatrix().getTranslation(new Vector3f()));
+
+            Vec3 entityPos = new Vec3(
+                    Mth.lerp(instance.getPartialTickTime(), pokemon.xOld, pokemon.getX()),
+                    Mth.lerp(instance.getPartialTickTime(), pokemon.yOld, pokemon.getY()),
+                    Mth.lerp(instance.getPartialTickTime(), pokemon.zOld, pokemon.getZ())
+            );
+
+            Rollable rollable = (Rollable) entity;
+            float currEyeHeight = Mth.lerp(instance.getPartialTickTime(), eyeHeightOld, eyeHeight);
+            Matrix3f orientation = rollable.shouldRoll() && rollable.getOrientation() != null ? rollable.getOrientation() : new Matrix3f();
+            Vec3 rotatedEyeHeight = new Vec3(orientation.transform(new Vector3f(0f, currEyeHeight, 0f)));
+
+            position = locatorOffset.add(entityPos).add(rotatedEyeHeight);
+        } else {
+            original.call(instance, x, y, z);
+        }
+    }
+
+    @Unique
+    private void applyRotation(){
+        if (!(this.entity instanceof Rollable rollable) || rollable.getOrientation() == null) return;
+        var newRotation = rollable.getOrientation().normal(new Matrix3f()).getNormalizedRotation(new Quaternionf());
+        if (this.minecraft.options.getCameraType().isMirrored()) {
+            newRotation.rotateY((float)Math.toRadians(180));
+        }
+        this.rotation.set(newRotation);
+        this.xRot = rollable.getPitch();
+        this.yRot = rollable.getYaw();
+        this.forwards.set(rollable.getForwardVector());
+        this.up.set(rollable.getUpVector());
+        this.left.set(rollable.getLeftVector());
+    }
+}

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

@@ -6,7 +6,7 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-package com.cobblemon.mod.common.mixin;
+package com.cobblemon.mod.common.mixin.client;
 
 import com.cobblemon.mod.common.api.scheduling.ClientTaskTracker;
 import net.minecraft.client.DeltaTracker;

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

@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin.client;
+
+import com.cobblemon.mod.common.client.render.player.MountedPlayerRenderer;
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import net.minecraft.client.model.HumanoidModel;
+import net.minecraft.client.model.geom.ModelPart;
+import net.minecraft.client.player.AbstractClientPlayer;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.LivingEntity;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import java.util.HashMap;
+
+@Mixin(HumanoidModel.class)
+public class HumanoidModelMixin {
+    @Unique HashMap<String, ModelPart> relevantPartsByName = new HashMap<>();
+
+    @Shadow @Final
+    public ModelPart head;
+    @Shadow @Final
+    public ModelPart rightArm;
+    @Shadow @Final
+    public ModelPart leftArm;
+    @Shadow @Final
+    public ModelPart rightLeg;
+    @Shadow @Final
+    public ModelPart leftLeg;
+
+    @Inject(method = "setupAnim*", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/model/geom/ModelPart;copyFrom(Lnet/minecraft/client/model/geom/ModelPart;)V", shift = At.Shift.BEFORE))
+    public void cobblemon$animateRiders(
+        LivingEntity entity,
+        float limbSwing,
+        float limbSwingAmount,
+        float ageInTicks,
+        float netHeadYaw,
+        float headPitch,
+        CallbackInfo ci
+    ) {
+        if (relevantPartsByName.isEmpty()) {
+            relevantPartsByName.put("arm_left", leftArm);
+            relevantPartsByName.put("arm_right", rightArm);
+            relevantPartsByName.put("leg_left", leftLeg);
+            relevantPartsByName.put("leg_right", rightLeg);
+            relevantPartsByName.put("head", head);
+        }
+
+        Entity vehicle = entity.getVehicle();
+        if (vehicle instanceof PokemonEntity && entity instanceof AbstractClientPlayer) {
+            MountedPlayerRenderer.INSTANCE.animate((PokemonEntity) vehicle, (AbstractClientPlayer) entity, relevantPartsByName, netHeadYaw, headPitch, ageInTicks, limbSwing, limbSwingAmount);
+        }
+    }
+}

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

@@ -6,18 +6,22 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-package com.cobblemon.mod.common.mixin;
+package com.cobblemon.mod.common.mixin.client;
 
+import com.cobblemon.mod.common.Rollable;
 import com.cobblemon.mod.common.item.PokedexItem;
 import com.mojang.blaze3d.vertex.PoseStack;
+import net.minecraft.client.Minecraft;
 import net.minecraft.client.player.AbstractClientPlayer;
 import net.minecraft.client.renderer.ItemInHandRenderer;
 import net.minecraft.client.renderer.MultiBufferSource;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.item.ItemStack;
+import org.joml.Quaternionf;
 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.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 @Mixin(ItemInHandRenderer.class)
@@ -27,5 +31,15 @@ public class ItemInHandRendererMixin {
         if (abstractClientPlayer.isUsingItem() && abstractClientPlayer.getUseItem().getItem() instanceof PokedexItem) {
             ci.cancel();
         }
+        else if (abstractClientPlayer instanceof Rollable rollable && rollable.shouldRoll()) {
+
+        }
+    }
+
+    @Redirect(method = "renderHandsWithItems", at = @At(value = "INVOKE", target = "Lcom/mojang/blaze3d/vertex/PoseStack;mulPose(Lorg/joml/Quaternionf;)V", ordinal = 1))
+    private void cobblemon$renderHandswithItems(PoseStack instance, Quaternionf quaternion) {
+        if (!(Minecraft.getInstance().player instanceof Rollable rollable && rollable.shouldRoll())) {
+            instance.mulPose(quaternion);
+        }
     }
 }

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

@@ -6,7 +6,7 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-package com.cobblemon.mod.common.mixin;
+package com.cobblemon.mod.common.mixin.client;
 
 import com.cobblemon.mod.common.Cobblemon;
 import com.cobblemon.mod.common.ModAPI;
@@ -40,7 +40,8 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
  */
 @Mixin(ItemRenderer.class)
 public abstract class ItemRendererMixin {
-    @Unique private final String MODEL_PATH = Cobblemon.implementation.getModAPI() == ModAPI.FABRIC ? "fabric_resource" : "standalone";
+    // ignore the hint saying implmentation is never null, if something crashes then it is null and causes red herrings
+    @Unique private final String MODEL_PATH = (Cobblemon.implementation != null && Cobblemon.implementation.getModAPI() == ModAPI.FABRIC) ? "fabric_resource" : "standalone";
 
     @Shadow @Final private ItemModelShaper itemModelShaper;
 

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

@@ -0,0 +1,43 @@
+/*
+ * 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.CobblemonNetwork;
+import com.cobblemon.mod.common.Rollable;
+import com.cobblemon.mod.common.net.messages.server.orientation.C2SUpdateOrientationPacket;
+import net.minecraft.client.player.LocalPlayer;
+import org.joml.Matrix3f;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(LocalPlayer.class)
+public class LocalPlayerMixin {
+
+    @Unique Matrix3f cobblemon$lastOrientation;
+
+    @Inject(method = "sendPosition", at = @At("TAIL"))
+    private void cobblemon_updateRotationMatrix(CallbackInfo ci) {
+        if (!(this instanceof Rollable rollable)) return;
+        if (rollable.getOrientation() == cobblemon$lastOrientation) return;
+        cobblemon$lastOrientation = rollable.getOrientation() != null ? new Matrix3f(rollable.getOrientation()) : null;
+        CobblemonNetwork.INSTANCE.sendToServer(new C2SUpdateOrientationPacket(rollable.getOrientation()));
+    }
+
+    @Inject(method = "tick", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/multiplayer/ClientPacketListener;send(Lnet/minecraft/network/protocol/Packet;)V"))
+    private void cobblemon_updateRotationMatrixPassenger(CallbackInfo ci) {
+        if (!(this instanceof Rollable rollable)) return;
+        if (rollable.getOrientation() == cobblemon$lastOrientation) return;
+        cobblemon$lastOrientation = rollable.getOrientation() != null ? new Matrix3f(rollable.getOrientation()) : null;
+        CobblemonNetwork.INSTANCE.sendToServer(new C2SUpdateOrientationPacket(rollable.getOrientation()));
+    }
+
+}

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

@@ -6,7 +6,7 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-package com.cobblemon.mod.common.mixin;
+package com.cobblemon.mod.common.mixin.client;
 
 import com.cobblemon.mod.common.client.CobblemonBakingOverrides;
 import java.util.List;

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

@@ -6,7 +6,7 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-package com.cobblemon.mod.common.mixin;
+package com.cobblemon.mod.common.mixin.client;
 
 import com.cobblemon.mod.common.client.render.models.blockbench.pose.Bone;
 import com.cobblemon.mod.common.client.render.models.blockbench.repository.RenderContext;

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

@@ -6,8 +6,9 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-package com.cobblemon.mod.common.mixin;
+package com.cobblemon.mod.common.mixin.client;
 
+import com.cobblemon.mod.common.Rollable;
 import com.cobblemon.mod.common.client.CobblemonClient;
 import com.cobblemon.mod.common.client.keybind.keybinds.PartySendBinding;
 import com.cobblemon.mod.common.pokedex.scanner.PokedexUsageContext;
@@ -22,17 +23,19 @@ import org.objectweb.asm.Opcodes;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 @Mixin(MouseHandler.class)
 public class MouseHandlerMixin {
-    @Shadow
-    private double accumulatedScrollY;
-
+    @Shadow private double accumulatedScrollY;
     @Shadow @Final private Minecraft minecraft;
 
+    @Unique SmoothDouble pitchSmoother = new SmoothDouble();
+    @Unique SmoothDouble rollSmoother = new SmoothDouble();
+
     @Shadow @Final private SmoothDouble smoothTurnY;
 
     @Shadow @Final private SmoothDouble smoothTurnX;
@@ -93,7 +96,6 @@ public class MouseHandlerMixin {
             )
     )
     public boolean cobblemon$modifyRotation(LocalPlayer player, double cursorDeltaX, double cursorDeltaY, @Local(argsOnly = true) double d) {
-        // I know this technically doesn't need to be a WrapWithCondition, but it'll make things easier later for riding.
         PokedexUsageContext usageContext = CobblemonClient.INSTANCE.getPokedexUsageContext();
         if (usageContext.getScanningGuiOpen()) {
             this.smoothTurnY.reset();
@@ -105,7 +107,30 @@ public class MouseHandlerMixin {
             player.turn(this.accumulatedDX * sensitivity, (this.accumulatedDY * sensitivity));
             return false;
         }
-        return true;
+
+        if (!(player instanceof Rollable rollable)) return true;
+        if (!rollable.shouldRoll()) {
+            pitchSmoother.reset();
+            rollSmoother.reset();
+            return true;
+        }
+
+        var pitch = pitchSmoother.getNewDeltaValue(cursorDeltaY * 0.15f, d);
+        var roll = rollSmoother.getNewDeltaValue(cursorDeltaX * 0.15f, d);
+        rollable.rotate(0.0F, (float)pitch, (float)roll);
+        return false;
+    }
+
+    @Inject(method = "handleAccumulatedMovement", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/MouseHandler;isMouseGrabbed()Z", ordinal = 0))
+    private void cobblemon$maintainMovementWhenInScreens(CallbackInfo ci, @Local(ordinal = 1) double e) {
+        if (minecraft.player == null) return;
+        if (!(minecraft.player instanceof Rollable rollable)) return;
+        if (!rollable.shouldRoll()) return;
+        if (minecraft.isPaused()) return;
+
+        var pitch = pitchSmoother.getNewDeltaValue(0, e);
+        var roll = rollSmoother.getNewDeltaValue(0, e);
+        rollable.rotate(0.0F, (float)pitch, (float)roll);
     }
 
 }

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

@@ -0,0 +1,36 @@
+/*
+ * 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.api.riding.Rideable;
+import com.cobblemon.mod.common.api.riding.RidingManager;
+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)) return;
+        RidingManager ridingManager = ((Rideable) vehicle).getRiding();
+        if (ridingManager.shouldRotatePlayerHead((PokemonEntity) vehicle)) return;
+
+        netHeadYaw = 0f;
+        headPitch = 0f;
+    }
+}

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

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin.client;
+
+import com.cobblemon.mod.common.client.render.ClientPlayerIcon;
+import com.cobblemon.mod.common.client.render.player.MountedPlayerRenderer;
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import com.mojang.blaze3d.vertex.PoseStack;
+import net.minecraft.client.player.AbstractClientPlayer;
+import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.client.renderer.entity.player.PlayerRenderer;
+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(PlayerRenderer.class)
+public class PlayerRendererMixin {
+    @Inject(method = "render(Lnet/minecraft/world/entity/LivingEntity;FFLcom/mojang/blaze3d/vertex/PoseStack;Lnet/minecraft/client/renderer/MultiBufferSource;I)V", at = @At(value = "TAIL"))
+    public void cobblemon$clientPlayerIcon(LivingEntity entity, float entityYaw, float partialTicks, PoseStack poseStack, MultiBufferSource buffer, int packedLight, CallbackInfo ci) {
+        ClientPlayerIcon.Companion.onRenderPlayer((Player) entity);
+    }
+
+    @Inject(
+            method = "setupRotations(Lnet/minecraft/client/player/AbstractClientPlayer;Lcom/mojang/blaze3d/vertex/PoseStack;FFFF)V",
+            at = @At("HEAD")
+    )
+    private void cobblemon$modifyRoll(AbstractClientPlayer player, PoseStack poseStack, float a, float b, float partialTicks, float i, CallbackInfo ci) {
+        if (player.isPassenger()) {
+            var vehicle = player.getVehicle();
+            if (vehicle instanceof PokemonEntity entity) {
+                MountedPlayerRenderer.INSTANCE.render(player, entity, poseStack, a, b, partialTicks, i);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin.entity;
+
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import net.minecraft.world.entity.Entity;
+import org.jetbrains.annotations.Nullable;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(Entity.class)
+public abstract class EntityMixin {
+
+    @Shadow @Nullable public abstract Entity getVehicle();
+
+    @Inject(method = "updateInWaterStateAndDoWaterCurrentPushing", at = @At(value = "FIELD", target = "Lnet/minecraft/world/entity/Entity;wasTouchingWater:Z", ordinal = 1), cancellable = true)
+    public void cobblemon$verifyActuallyTouchingWater(CallbackInfo ci) {
+        if(this.getVehicle() instanceof PokemonEntity) {
+            ci.cancel();
+        }
+    }
+
+}

common/src/main/java/com/cobblemon/mod/common/mixin/riding/JetMixin.java

@@ -0,0 +1,62 @@
+/*
+ * 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.riding;
+
+import net.minecraft.client.player.LocalPlayer;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
+
+@Mixin(LocalPlayer.class)
+public class JetMixin {
+
+    @Shadow private int jumpRidingTicks;
+    @Shadow private float jumpRidingScale;
+
+    private float jetStrength;
+
+//    @Redirect(method = "tickMovement", at = @At(target = "Lnet/minecraft/entity/JumpingMount;getJumpCooldown()I", value = "INVOKE"))
+//    public int cobblemon$tryHandlingJet(JumpingMount mount) {
+//        if(mount instanceof PokemonEntity pokemon) {
+////            if(pokemon.getDataTracker().get(PokemonEntity.MOVING)) {
+////                ++this.field_3938;
+////                if (this.field_3938 < 11) {
+////                    this.jetStrength = (float) this.field_3938 * 0.1F;
+////                } else {
+//                    this.mountJumpStrength = 0.8F + 2.0F / (float) (this.field_3938 - 9) * 0.1F;
+////                }
+////            } else {
+////                this.field_3938 = 0;
+////                this.jetStrength = 0;
+////            }
+//
+////            return -1;
+//        }
+//
+//        return 0;
+//    }
+
+    @Inject(
+            method = "aiStep",
+            at = @At(
+                    target = "Lnet/minecraft/client/player/LocalPlayer;jumpRidingScale:F",
+                    value = "FIELD",
+                    ordinal = 4,
+                    shift = At.Shift.AFTER
+            ),
+            locals = LocalCapture.CAPTURE_FAILSOFT
+    )
+    public void cobblemon$applyCachedJumpStrength(CallbackInfo ci) {
+        this.jumpRidingScale = this.jetStrength;
+    }
+
+}

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

@@ -80,6 +80,7 @@ import com.cobblemon.mod.common.net.messages.client.settings.ServerSettingsPacke
 import com.cobblemon.mod.common.permission.LaxPermissionValidator
 import com.cobblemon.mod.common.platform.events.PlatformEvents
 import com.cobblemon.mod.common.pokemon.Pokemon
+import com.cobblemon.mod.common.pokemon.aspects.COSMETIC_SLOT_ASPECT
 import com.cobblemon.mod.common.pokemon.aspects.GENDER_ASPECT
 import com.cobblemon.mod.common.pokemon.aspects.SHINY_ASPECT
 import com.cobblemon.mod.common.pokemon.evolution.variants.BlockClickEvolution
@@ -278,6 +279,7 @@ object Cobblemon {
 
         SHINY_ASPECT.register()
         GENDER_ASPECT.register()
+        COSMETIC_SLOT_ASPECT.register()
 
         SpeciesFeatures.types["choice"] = ChoiceSpeciesFeatureProvider::class.java
         SpeciesFeatures.types["flag"] = FlagSpeciesFeatureProvider::class.java

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

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common
+
+import com.cobblemon.mod.common.api.conditional.RegistryLikeCondition
+import com.cobblemon.mod.common.api.data.JsonDataRegistry
+import com.cobblemon.mod.common.api.pokemon.PokemonProperties
+import com.cobblemon.mod.common.api.reactive.SimpleObservable
+import com.cobblemon.mod.common.net.messages.client.data.CosmeticItemAssignmentSyncPacket
+import com.cobblemon.mod.common.pokemon.Pokemon
+import com.cobblemon.mod.common.pokemon.cosmetic.CosmeticItemAssignment
+import com.cobblemon.mod.common.util.adapters.IdentifierAdapter
+import com.cobblemon.mod.common.util.adapters.ItemLikeConditionAdapter
+import com.cobblemon.mod.common.util.adapters.PokemonPropertiesAdapter
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.google.gson.GsonBuilder
+import com.google.gson.reflect.TypeToken
+import net.minecraft.core.RegistryAccess
+import net.minecraft.core.registries.Registries
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.server.packs.PackType
+import net.minecraft.world.item.Item
+import net.minecraft.world.item.ItemStack
+
+object CobblemonCosmeticItems : JsonDataRegistry<CosmeticItemAssignment> {
+    override val id = cobblemonResource("cosmetic_items")
+    override val type = PackType.SERVER_DATA
+    override val observable = SimpleObservable<CobblemonCosmeticItems>()
+    override val typeToken = TypeToken.get(CosmeticItemAssignment::class.java)
+    override val resourcePath = "cosmetic_items"
+
+    override val gson = GsonBuilder()
+        .setPrettyPrinting()
+        .registerTypeAdapter(PokemonProperties::class.java, PokemonPropertiesAdapter(saveLong = false))
+        .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Item::class.java).type, ItemLikeConditionAdapter)
+        .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
+        .create()
+
+    val cosmeticItems = mutableListOf<CosmeticItemAssignment>()
+
+    override fun reload(data: Map<ResourceLocation, CosmeticItemAssignment>) {
+        cosmeticItems.clear()
+        data.entries.forEach { (id, value) -> value.id = id }
+        cosmeticItems.addAll(data.values)
+    }
+
+    override fun sync(player: ServerPlayer) {
+        CosmeticItemAssignmentSyncPacket(cosmeticItems).sendToPlayer(player)
+    }
+
+    fun findValidForPokemon(pokemon: Pokemon) = cosmeticItems.filter { it.pokemon.any { it.matches(pokemon) } }
+    fun findValidCosmeticForPokemonAndItem(registryAccess: RegistryAccess, pokemon: Pokemon, itemStack: ItemStack) = cosmeticItems
+        .filter { it.pokemon.any { it.matches(pokemon) } }
+        .flatMap { it.cosmeticItems }
+        .firstOrNull { it.consumedItem.fits(itemStack.item, registryAccess.registryOrThrow(Registries.ITEM)) }
+}

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

@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common
 
 import com.bedrockk.molang.runtime.MoLangRuntime
+import com.bedrockk.molang.runtime.MoParams
 import com.bedrockk.molang.runtime.value.MoValue
 import com.cobblemon.mod.common.CobblemonNetwork.sendPacket
 import com.cobblemon.mod.common.api.data.DataRegistry
@@ -86,13 +87,20 @@ object CobblemonFlows : DataRegistry {
         observable.emit(this)
     }
 
-    fun run(eventResourceLocation: ResourceLocation, context: Map<String, MoValue>, cancelable: Cancelable? = null) {
+    fun run(
+        eventResourceLocation: ResourceLocation,
+        context: Map<String, MoValue>,
+        functions: Map<String, (MoParams) -> Any> = emptyMap(),
+        cancelable: Cancelable? = null
+    ) {
         if (cancelable == null) {
             runtime.environment.query.functions.remove("cancel")
         } else {
             runtime.environment.query.addFunction("cancel") { cancelable }
         }
 
+        functions.forEach { (name, function) -> runtime.environment.query.addFunction(name, function) }
+
         flows[eventResourceLocation]?.forEach {
             if (cancelable != null && cancelable.isCanceled) {
                 return

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

@@ -47,7 +47,14 @@ import com.cobblemon.mod.common.client.net.storage.party.SetPartyPokemonHandler
 import com.cobblemon.mod.common.client.net.storage.party.SetPartyReferenceHandler
 import com.cobblemon.mod.common.client.net.storage.pc.*
 import com.cobblemon.mod.common.client.net.toast.ToastPacketHandler
-import com.cobblemon.mod.common.client.net.trade.*
+import com.cobblemon.mod.common.client.net.trade.TradeAcceptanceChangedHandler
+import com.cobblemon.mod.common.client.net.trade.TradeCancelledHandler
+import com.cobblemon.mod.common.client.net.trade.TradeCompletedHandler
+import com.cobblemon.mod.common.client.net.trade.TradeOfferExpiredHandler
+import com.cobblemon.mod.common.client.net.trade.TradeOfferNotificationHandler
+import com.cobblemon.mod.common.client.net.trade.TradeProcessStartedHandler
+import com.cobblemon.mod.common.client.net.trade.TradeStartedHandler
+import com.cobblemon.mod.common.client.net.trade.TradeUpdatedHandler
 import com.cobblemon.mod.common.net.PacketRegisterInfo
 import com.cobblemon.mod.common.net.messages.client.PlayerInteractOptionsPacket
 import com.cobblemon.mod.common.net.messages.client.SetClientPlayerDataPacket
@@ -87,17 +94,41 @@ import com.cobblemon.mod.common.net.messages.client.storage.party.InitializePart
 import com.cobblemon.mod.common.net.messages.client.storage.party.MoveClientPartyPokemonPacket
 import com.cobblemon.mod.common.net.messages.client.storage.party.SetPartyPokemonPacket
 import com.cobblemon.mod.common.net.messages.client.storage.party.SetPartyReferencePacket
-import com.cobblemon.mod.common.net.messages.client.storage.pc.*
+import com.cobblemon.mod.common.net.messages.client.storage.pc.ClosePCPacket
+import com.cobblemon.mod.common.net.messages.client.storage.pc.InitializePCPacket
+import com.cobblemon.mod.common.net.messages.client.storage.pc.MoveClientPCPokemonPacket
+import com.cobblemon.mod.common.net.messages.client.storage.pc.OpenPCPacket
+import com.cobblemon.mod.common.net.messages.client.storage.pc.RenamePCBoxPacket
+import com.cobblemon.mod.common.net.messages.client.storage.pc.SetPCBoxPacket
+import com.cobblemon.mod.common.net.messages.client.storage.pc.SetPCPokemonPacket
 import com.cobblemon.mod.common.net.messages.client.storage.pc.wallpaper.ChangePCBoxWallpaperPacket
 import com.cobblemon.mod.common.net.messages.client.storage.pc.wallpaper.RequestPCBoxWallpapersPacket
 import com.cobblemon.mod.common.net.messages.client.storage.pc.wallpaper.SetPCBoxWallpapersPacket
 import com.cobblemon.mod.common.net.messages.client.toast.ToastPacket
-import com.cobblemon.mod.common.net.messages.client.trade.*
+import com.cobblemon.mod.common.net.messages.client.trade.TradeAcceptanceChangedPacket
+import com.cobblemon.mod.common.net.messages.client.trade.TradeCancelledPacket
+import com.cobblemon.mod.common.net.messages.client.trade.TradeCompletedPacket
+import com.cobblemon.mod.common.net.messages.client.trade.TradeOfferExpiredPacket
+import com.cobblemon.mod.common.net.messages.client.trade.TradeOfferNotificationPacket
+import com.cobblemon.mod.common.net.messages.client.trade.TradeProcessStartedPacket
+import com.cobblemon.mod.common.net.messages.client.trade.TradeStartedPacket
+import com.cobblemon.mod.common.net.messages.client.trade.TradeUpdatedPacket
 import com.cobblemon.mod.common.net.messages.client.ui.InteractPokemonUIPacket
 import com.cobblemon.mod.common.net.messages.client.ui.PokedexUIPacket
 import com.cobblemon.mod.common.net.messages.client.ui.SummaryUIPacket
-import com.cobblemon.mod.common.net.messages.server.*
-import com.cobblemon.mod.common.net.messages.server.battle.*
+import com.cobblemon.mod.common.net.messages.server.BattleChallengePacket
+import com.cobblemon.mod.common.net.messages.server.BattleChallengeResponsePacket
+import com.cobblemon.mod.common.net.messages.server.BenchMovePacket
+import com.cobblemon.mod.common.net.messages.server.RequestMoveSwapPacket
+import com.cobblemon.mod.common.net.messages.server.RequestPlayerInteractionsPacket
+import com.cobblemon.mod.common.net.messages.server.SelectStarterPacket
+import com.cobblemon.mod.common.net.messages.server.SendOutPokemonPacket
+import com.cobblemon.mod.common.net.messages.server.battle.BattleSelectActionsPacket
+import com.cobblemon.mod.common.net.messages.server.battle.BattleTeamLeavePacket
+import com.cobblemon.mod.common.net.messages.server.battle.BattleTeamRequestPacket
+import com.cobblemon.mod.common.net.messages.server.battle.BattleTeamResponsePacket
+import com.cobblemon.mod.common.net.messages.server.battle.RemoveSpectatorPacket
+import com.cobblemon.mod.common.net.messages.server.battle.SpectateBattlePacket
 import com.cobblemon.mod.common.net.messages.server.block.AdjustBlockEntityViewerCountPacket
 import com.cobblemon.mod.common.net.messages.server.callback.move.MoveSelectCancelledPacket
 import com.cobblemon.mod.common.net.messages.server.callback.move.MoveSelectedPacket
@@ -108,6 +139,7 @@ import com.cobblemon.mod.common.net.messages.server.callback.partymove.PartyPoke
 import com.cobblemon.mod.common.net.messages.server.dialogue.EscapeDialoguePacket
 import com.cobblemon.mod.common.net.messages.server.dialogue.InputToDialoguePacket
 import com.cobblemon.mod.common.net.messages.server.npc.SaveNPCPacket
+import com.cobblemon.mod.common.net.messages.server.orientation.C2SUpdateOrientationPacket
 import com.cobblemon.mod.common.net.messages.server.pasture.PasturePokemonPacket
 import com.cobblemon.mod.common.net.messages.server.pasture.UnpastureAllPokemonPacket
 import com.cobblemon.mod.common.net.messages.server.pasture.UnpasturePokemonPacket
@@ -122,19 +154,22 @@ import com.cobblemon.mod.common.net.messages.server.storage.SwapPCPartyPokemonPa
 import com.cobblemon.mod.common.net.messages.server.storage.party.MovePartyPokemonPacket
 import com.cobblemon.mod.common.net.messages.server.storage.party.ReleasePartyPokemonPacket
 import com.cobblemon.mod.common.net.messages.server.storage.party.SwapPartyPokemonPacket
-import com.cobblemon.mod.common.net.messages.server.storage.pc.MovePCPokemonPacket
-import com.cobblemon.mod.common.net.messages.server.storage.pc.MovePCPokemonToPartyPacket
-import com.cobblemon.mod.common.net.messages.server.storage.pc.MovePartyPokemonToPCPacket
-import com.cobblemon.mod.common.net.messages.server.storage.pc.PCBoxWallpapersPacket
-import com.cobblemon.mod.common.net.messages.server.storage.pc.ReleasePCPokemonPacket
-import com.cobblemon.mod.common.net.messages.server.storage.pc.RequestChangePCBoxWallpaperPacket
-import com.cobblemon.mod.common.net.messages.server.storage.pc.RequestRenamePCBoxPacket
-import com.cobblemon.mod.common.net.messages.server.storage.pc.SortPCBoxPacket
-import com.cobblemon.mod.common.net.messages.server.storage.pc.SwapPCPokemonPacket
-import com.cobblemon.mod.common.net.messages.server.storage.pc.UnlinkPlayerFromPCPacket
-import com.cobblemon.mod.common.net.messages.server.trade.*
-import com.cobblemon.mod.common.net.serverhandling.*
-import com.cobblemon.mod.common.net.serverhandling.battle.*
+import com.cobblemon.mod.common.net.messages.server.storage.pc.*
+import com.cobblemon.mod.common.net.messages.server.trade.AcceptTradeRequestPacket
+import com.cobblemon.mod.common.net.messages.server.trade.CancelTradePacket
+import com.cobblemon.mod.common.net.messages.server.trade.ChangeTradeAcceptancePacket
+import com.cobblemon.mod.common.net.messages.server.trade.OfferTradePacket
+import com.cobblemon.mod.common.net.messages.server.trade.PerformTradePacket
+import com.cobblemon.mod.common.net.messages.server.trade.UpdateTradeOfferPacket
+import com.cobblemon.mod.common.net.serverhandling.ChallengeHandler
+import com.cobblemon.mod.common.net.serverhandling.ChallengeResponseHandler
+import com.cobblemon.mod.common.net.serverhandling.RequestInteractionsHandler
+import com.cobblemon.mod.common.net.serverhandling.battle.BattleSelectActionsHandler
+import com.cobblemon.mod.common.net.serverhandling.battle.RemoveSpectatorHandler
+import com.cobblemon.mod.common.net.serverhandling.battle.SpectateBattleHandler
+import com.cobblemon.mod.common.net.serverhandling.battle.TeamLeaveHandler
+import com.cobblemon.mod.common.net.serverhandling.battle.TeamRequestHandler
+import com.cobblemon.mod.common.net.serverhandling.battle.TeamRequestResponseHandler
 import com.cobblemon.mod.common.net.serverhandling.block.AdjustBlockEntityViewerCountHandler
 import com.cobblemon.mod.common.net.serverhandling.callback.move.MoveSelectCancelledHandler
 import com.cobblemon.mod.common.net.serverhandling.callback.move.MoveSelectedHandler
@@ -146,6 +181,7 @@ import com.cobblemon.mod.common.net.serverhandling.dialogue.EscapeDialogueHandle
 import com.cobblemon.mod.common.net.serverhandling.dialogue.InputToDialogueHandler
 import com.cobblemon.mod.common.net.serverhandling.evolution.AcceptEvolutionHandler
 import com.cobblemon.mod.common.net.serverhandling.npc.SaveNPCHandler
+import com.cobblemon.mod.common.net.serverhandling.orientation.OrientationPacketHandler
 import com.cobblemon.mod.common.net.serverhandling.pasture.PasturePokemonHandler
 import com.cobblemon.mod.common.net.serverhandling.pasture.UnpastureAllPokemonHandler
 import com.cobblemon.mod.common.net.serverhandling.pasture.UnpasturePokemonHandler
@@ -164,7 +200,12 @@ import com.cobblemon.mod.common.net.serverhandling.storage.party.MovePartyPokemo
 import com.cobblemon.mod.common.net.serverhandling.storage.party.ReleasePCPokemonHandler
 import com.cobblemon.mod.common.net.serverhandling.storage.party.SwapPartyPokemonHandler
 import com.cobblemon.mod.common.net.serverhandling.storage.pc.*
-import com.cobblemon.mod.common.net.serverhandling.trade.*
+import com.cobblemon.mod.common.net.serverhandling.trade.AcceptTradeRequestHandler
+import com.cobblemon.mod.common.net.serverhandling.trade.CancelTradeHandler
+import com.cobblemon.mod.common.net.serverhandling.trade.ChangeTradeAcceptanceHandler
+import com.cobblemon.mod.common.net.serverhandling.trade.OfferTradeHandler
+import com.cobblemon.mod.common.net.serverhandling.trade.PerformTradeHandler
+import com.cobblemon.mod.common.net.serverhandling.trade.UpdateTradeOfferHandler
 import com.cobblemon.mod.common.util.server
 import net.minecraft.server.level.ServerPlayer
 
@@ -177,13 +218,11 @@ import net.minecraft.server.level.ServerPlayer
  * @since November 27th, 2021
  */
 object CobblemonNetwork {
-    //private val logger = LogUtils.getLogger()
 
     fun ServerPlayer.sendPacket(packet: NetworkPacket<*>) {
         sendPacketToPlayer(this, packet)
     }
     fun sendToServer(packet: NetworkPacket<*>) {
-        //logger.info("[C->S] ${packet.type()}")
         Cobblemon.implementation.networkManager.sendToServer(packet)
     }
     fun sendToAllPlayers(packet: NetworkPacket<*>) = sendPacketToPlayers(server()!!.playerList.players, packet)
@@ -222,6 +261,7 @@ object CobblemonNetwork {
         list.add(PacketRegisterInfo(TeraTypeUpdatePacket.ID, TeraTypeUpdatePacket::decode, PokemonUpdatePacketHandler()))
         list.add(PacketRegisterInfo(DmaxLevelUpdatePacket.ID, DmaxLevelUpdatePacket::decode, PokemonUpdatePacketHandler()))
         list.add(PacketRegisterInfo(GmaxFactorUpdatePacket.ID, GmaxFactorUpdatePacket::decode, PokemonUpdatePacketHandler()))
+        list.add(PacketRegisterInfo(CosmeticItemUpdatePacket.ID, CosmeticItemUpdatePacket::decode, PokemonUpdatePacketHandler()))
 
         // Evolution start
         list.add(PacketRegisterInfo(AddEvolutionPacket.ID, AddEvolutionPacket::decode, PokemonUpdatePacketHandler()))
@@ -312,6 +352,7 @@ object CobblemonNetwork {
         list.add(PacketRegisterInfo(DexEntrySyncPacket.ID, DexEntrySyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(FishingBaitRegistrySyncPacket.ID, FishingBaitRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(FlowRegistrySyncPacket.ID, FlowRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
+        list.add(PacketRegisterInfo(CosmeticItemAssignmentSyncPacket.ID, CosmeticItemAssignmentSyncPacket::decode, DataRegistrySyncPacketHandler()))
 
         // Effects
         list.add(PacketRegisterInfo(SpawnSnowstormParticlePacket.ID, SpawnSnowstormParticlePacket::decode, SpawnSnowstormParticleHandler))
@@ -458,11 +499,13 @@ object CobblemonNetwork {
         // NPC packets
         list.add(PacketRegisterInfo(SaveNPCPacket.ID, SaveNPCPacket::decode, SaveNPCHandler))
 
+        // Orientation packet(s)
+        list.add(PacketRegisterInfo(C2SUpdateOrientationPacket.ID, C2SUpdateOrientationPacket::decode, OrientationPacketHandler))
+
         return list
     }
 
     fun sendPacketToPlayer(player: ServerPlayer, packet: NetworkPacket<*>) {
-        //logger.info("[S->C] ${packet.type()}")
         Cobblemon.implementation.networkManager.sendPacketToPlayer(player, packet)
     }
-}
+}

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

@@ -33,7 +33,7 @@ class LevelUpCriterion(
     }
 
     override fun matches(player: ServerPlayer, context: LevelUpContext): Boolean {
-        val preEvo = context.pokemon.preEvolution == null
+        val preEvo = context.pokemon.preEvolution != null
         val hasEvolution = !context.pokemon.evolutions.none()
         var evolutionCheck = true
         if (preEvo || hasEvolution) {
@@ -43,27 +43,3 @@ class LevelUpCriterion(
     }
 
 }
-
-/*class LevelUpCriterionCondition(id: Identifier, entity: LootContextPredicate) : SimpleCriterionCondition<LevelUpContext>(id, entity) {
-    var level = 0
-    var evolved = true
-    override fun toJson(json: JsonObject) {
-        json.addProperty("level", level)
-        json.addProperty("has_evolved", evolved)
-    }
-
-    override fun fromJson(json: JsonObject) {
-        level = json.get("level")?.asInt ?: 0
-        evolved = json.get("has_evolved")?.asBoolean ?: true
-    }
-
-    override fun matches(player: ServerPlayer, context: LevelUpContext): Boolean {
-        val preEvo = context.pokemon.preEvolution == null
-        val hasEvolution = !context.pokemon.evolutions.none()
-        var evolutionCheck = true
-        if (preEvo || hasEvolution) {
-            evolutionCheck = !(preEvo == hasEvolution)
-        }
-        return level == context.level && evolutionCheck == evolved
-    }
-}*/

common/src/main/kotlin/com/cobblemon/mod/common/api/battles/interpreter/BattleContext.kt

@@ -8,6 +8,9 @@
 
 package com.cobblemon.mod.common.api.battles.interpreter
 
+import com.bedrockk.molang.runtime.value.DoubleValue
+import com.bedrockk.molang.runtime.value.StringValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.queryStructOf
 import com.cobblemon.mod.common.battles.pokemon.BattlePokemon
 
 /**
@@ -30,6 +33,13 @@ interface BattleContext {
     /** The [BattlePokemon] that directly or indirectly caused this [BattleContext]. */
     val origin: BattlePokemon?
 
+    fun getStruct() = queryStructOf(
+        "type" to { StringValue(type.name) },
+        "origin" to { origin?.struct ?: DoubleValue(0.0) },
+        "id" to { StringValue(id) },
+        "turn_created" to { DoubleValue(turn.toDouble()) }
+    )
+
     /**
      * The type of [BattleContext].
      *

common/src/main/kotlin/com/cobblemon/mod/common/api/berry/Berry.kt

@@ -99,7 +99,6 @@ class Berry(
     val weight: Float,
     val boneMealChance: Float
 ) {
-
     @Transient
     var identifier: ResourceLocation = identifier
         internal set
@@ -159,7 +158,7 @@ class Berry(
      * Calculates the yield for a berry tree being planted or replanted after a life cycle.
      * Triggers [BerryYieldCalculationEvent].
      *
-     * @param world The [World] the tree is present in.
+     * @param world The [Level] the tree is present in.
      * @param state The [BlockState] of the tree.
      * @param pos The [BlockPos] of the tree.
      * @param placer The [LivingEntity] tending to the tree, if any.
@@ -173,9 +172,10 @@ class Berry(
         if (BerryBlock.getMulch(treeEntity) == MulchVariant.RICH) {
             //I hope the upper bound isnt exclusive, especially when there's a method called nextBetweenExclusive
             // update: it was meant to be exclusive, which caused #1124. I've lowered the upper bound from 3 to 2.
-            yield += world.random.nextIntBetweenInclusive(1, 2)
+            yield += world.random.nextIntBetweenInclusive(RICH_MULCH_MIN, RICH_MULCH_MAX)
             treeEntity.decrementMulchDuration(world, pos, state)
         }
+        yield = yield.coerceAtMost(growthPoints.size)
         val event = BerryYieldCalculationEvent(this, world, state, pos, placer, yield, bonus.second)
         CobblemonEvents.BERRY_YIELD.post(event) { yield = it.yield }
         return yield
@@ -193,7 +193,7 @@ class Berry(
      *
      * @return The maximum possible yield.
      */
-    fun maxYield() = this.baseYield.last + this.growthFactors.sumOf { it.maxYield() }
+    fun maxYield() = this.baseYield.last + this.growthFactors.sumOf { it.maxYield() } + RICH_MULCH_MAX
 
     /**
      * Checks if this berry can mutate with the given [partner].
@@ -231,6 +231,7 @@ class Berry(
     }
 
     // A cheat since gson doesn't invoke init block
+    // well I actually suspect it does but
     internal fun validate() {
         if (this.baseYield.first < 0 || this.baseYield.last < 0) {
             throw IllegalArgumentException("A berry base yield must be a positive range")
@@ -247,10 +248,6 @@ class Berry(
         }
          */
         this.growthFactors.forEach { it.validateArguments() }
-        val maxYield = this.maxYield()
-        if (this.growthPoints.size < maxYield) {
-            throw IllegalArgumentException("Anchor points must have enough elements for the max possible yield of $maxYield you've provided ${this.growthPoints.size} points")
-        }
         this.shapedFlower = hashMapOf()
         this.shapedFruit = hashMapOf()
         this.sproutShape = this.createAndUniteShapes(this.sproutShapeBoxes)
@@ -339,6 +336,8 @@ class Berry(
     }
 
     companion object {
+        const val RICH_MULCH_MIN = 1
+        const val RICH_MULCH_MAX = 2
 
         internal fun decode(buffer: RegistryFriendlyByteBuf): Berry {
             val identifier = buffer.readIdentifier()

common/src/main/kotlin/com/cobblemon/mod/common/api/berry/Flavor.kt

@@ -15,12 +15,10 @@ package com.cobblemon.mod.common.api.berry
  * @author Licious
  * @since November 28th, 2022
  */
-enum class Flavor {
-
-    SPICY,
-    DRY,
-    SWEET,
-    BITTER,
-    SOUR
-
+enum class Flavor(val colour: Int) {
+    SPICY(0x00FF00),
+    DRY(0xFF0000),
+    SWEET(0x0000FF),
+    BITTER(0xFFFF00),
+    SOUR(0xFF00FF);
 }

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

@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.conditional
+
+import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
+import com.cobblemon.mod.common.util.codec.CodecUtils
+import com.mojang.serialization.Codec
+import net.minecraft.core.Registry
+import net.minecraft.core.registries.Registries
+import net.minecraft.resources.ResourceKey
+import net.minecraft.tags.TagKey
+
+val ITEM_REGISTRY_LIKE_CODEC = makeCodecForRegistryLikeCondition("item", Registries.ITEM)
+
+fun <T : Any> makeCodecForRegistryLikeCondition(name: String, registryKey: ResourceKey<Registry<T>>): Codec<RegistryLikeCondition<T>> {
+    return CodecUtils.createByStringCodec(
+        from = { str ->
+            if (str.startsWith("#")) {
+                return@createByStringCodec RegistryLikeTagCondition<T>(TagKey.create(registryKey, str.substring(1).asIdentifierDefaultingNamespace()))
+            } else {
+                return@createByStringCodec RegistryLikeIdentifierCondition<T>(str.asIdentifierDefaultingNamespace())
+            }
+        },
+        to = { condition ->
+            if (condition is RegistryLikeTagCondition) {
+                "#${condition.tag.location}"
+            } else {
+                (condition as RegistryLikeIdentifierCondition).identifier.toString()
+            }
+        },
+        errorSupplier = { "Unknown $name condition: $it. Should be # followed by a tag, or $name resource location e.g. #minecraft:ladders or minecraft:grass_block." }
+    )
+}

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

@@ -26,13 +26,13 @@ open class RegistryLikeTagCondition<T : Any>(val tag: TagKey<T>) : RegistryLikeC
     companion object {
         const val PREFIX = "#"
         fun <T : Any> resolver(
-            ResourceKey: ResourceKey<Registry<T>>,
+            resourceKey: ResourceKey<Registry<T>>,
             constructor: (TagKey<T>) -> RegistryLikeTagCondition<T>
         ): (JsonElement) -> RegistryLikeTagCondition<T>? = {
             val firstSymbol = it.asString.substring(0, 1)
             if (firstSymbol == PREFIX) {
                 val identifier = ResourceLocation.parse(it.asString.substring(1))
-                constructor(TagKey.create(ResourceKey, identifier))
+                constructor(TagKey.create(resourceKey, identifier))
             } else {
                 null
             }

common/src/main/kotlin/com/cobblemon/mod/common/api/entity/PokemonSideDelegate.kt

@@ -11,6 +11,8 @@ package com.cobblemon.mod.common.api.entity
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.pokemon.Pokemon
 import net.minecraft.world.damagesource.DamageSource
+import net.minecraft.world.entity.Entity
+import net.minecraft.world.entity.Entity.MoveFunction
 import net.minecraft.world.entity.player.Player
 
 interface PokemonSideDelegate : EntitySideDelegate<PokemonEntity> {

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

@@ -8,6 +8,10 @@
 
 package com.cobblemon.mod.common.api.events
 
+import com.bedrockk.molang.runtime.MoParams
+import com.bedrockk.molang.runtime.value.DoubleValue
+import com.bedrockk.molang.runtime.value.MoValue
+
 /**
  * Something that can be canceled. This is a highly complex class and should only be read by professional engineers.
  *
@@ -21,4 +25,9 @@ abstract class Cancelable {
     fun cancel() {
         isCanceled = true
     }
+
+    val cancelFunc: Pair<String, (MoParams) -> MoValue> = "cancel" to {
+        cancel()
+        DoubleValue.ONE
+    }
 }

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

@@ -52,6 +52,7 @@ import com.cobblemon.mod.common.api.reactive.EventObservable
 import com.cobblemon.mod.common.api.reactive.Observable.Companion.filter
 import com.cobblemon.mod.common.api.reactive.Observable.Companion.map
 import com.cobblemon.mod.common.api.reactive.SimpleObservable
+import com.cobblemon.mod.common.api.riding.events.SelectDriverEvent
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import net.minecraft.server.level.ServerPlayer
 
@@ -211,6 +212,10 @@ object CobblemonEvents {
     val HELD_ITEM_PRE = CancelableObservable<HeldItemEvent.Pre>()
     @JvmField
     val HELD_ITEM_POST = EventObservable<HeldItemEvent.Post>()
+    @JvmField
+    val COSMETIC_ITEM_PRE = CancelableObservable<HeldItemEvent.Pre>()
+    @JvmField
+    val COSMETIC_ITEM_POST = EventObservable<HeldItemEvent.Post>()
 
     @JvmField
     val POKEMON_GAINED = EventObservable<PokemonGainedEvent>()
@@ -253,4 +258,12 @@ object CobblemonEvents {
     val HATCH_EGG_PRE = CancelableObservable<HatchEggEvent.Pre>()
     @JvmField
     val HATCH_EGG_POST = EventObservable<HatchEggEvent.Post>()
+
+    // -------------------------------------------------------------------------------------
+    //
+    // Riding
+    //
+    // -------------------------------------------------------------------------------------
+    @JvmField
+    val SELECT_DRIVER = EventObservable<SelectDriverEvent>()
 }

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

@@ -8,16 +8,12 @@
 
 package com.cobblemon.mod.common.api.events.battles
 
-import com.bedrockk.molang.runtime.struct.QueryStruct
-import com.bedrockk.molang.runtime.value.DoubleValue
 import com.bedrockk.molang.runtime.value.MoValue
-import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.battles.interpreter.BattleContext
 import com.cobblemon.mod.common.api.battles.model.PokemonBattle
 import com.cobblemon.mod.common.api.battles.model.actor.ActorType
 import com.cobblemon.mod.common.battles.pokemon.BattlePokemon
 import com.cobblemon.mod.common.util.asArrayValue
-import java.util.function.Function
 
 /**
  * Event fired when a [BattlePokemon] faints. Exposes the [BattlePokemon] that fainted and the [BattleContext]
@@ -37,13 +33,6 @@ data class BattleFaintedEvent(
         "npcs" to battle.actors.filter { it.type == ActorType.NPC }.asArrayValue { it.struct },
         "wild_pokemon" to battle.actors.filter { it.type == ActorType.WILD }.asArrayValue { it.struct },
         "pokemon" to killed.struct,
-        "context" to QueryStruct(
-            hashMapOf(
-                "type" to Function { StringValue(context.type.name) },
-                "origin" to Function { context.origin?.struct ?: DoubleValue(0.0) },
-                "id" to Function { StringValue(context.id) },
-                "turn_created" to Function { DoubleValue(context.turn.toDouble()) },
-            )
-        )
+        "context" to context.getStruct()
     )
 }

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

@@ -11,6 +11,7 @@ package com.cobblemon.mod.common.api.events.battles
 import com.cobblemon.mod.common.api.battles.model.PokemonBattle
 import com.cobblemon.mod.common.api.battles.model.actor.ActorType
 import com.cobblemon.mod.common.api.events.Cancelable
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.util.asArrayValue
 import net.minecraft.network.chat.MutableComponent
 
@@ -30,6 +31,8 @@ data class BattleStartedPreEvent (override val battle: PokemonBattle, var reason
         "npcs" to battle.actors.filter { it.type == ActorType.NPC }.asArrayValue { it.struct },
         "wild_pokemon" to battle.actors.filter { it.type == ActorType.WILD }.asArrayValue { it.struct }
     )
+
+    val functions = moLangFunctionMap(cancelFunc)
 }
 
 /**

common/src/main/kotlin/com/cobblemon/mod/common/api/events/battles/instruction/TerastallizationEvent.kt

@@ -26,7 +26,7 @@ data class TerastallizationEvent(
     val battle: PokemonBattle,
     val pokemon: BattlePokemon,
     val teraType: TeraType
-    ) {
+) {
     val context = mutableMapOf<String, MoValue>(
         "battle" to battle.struct,
         "players" to battle.actors.filter { it.type == ActorType.PLAYER }.asArrayValue { it.struct },

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

@@ -8,9 +8,15 @@
 
 package com.cobblemon.mod.common.api.events.pokeball
 
+import com.bedrockk.molang.runtime.value.DoubleValue
+import com.bedrockk.molang.runtime.value.MoValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.api.pokeball.catching.CaptureContext
 import com.cobblemon.mod.common.entity.pokeball.EmptyPokeBallEntity
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.util.getBooleanOrNull
+import com.cobblemon.mod.common.util.getIntOrNull
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.world.entity.LivingEntity
 
@@ -32,4 +38,34 @@ class PokeBallCaptureCalculatedEvent(
             action(this, thrower)
         }
     }
+
+    val context = mutableMapOf<String, MoValue>(
+        "thrower" to thrower.asMostSpecificMoLangValue(),
+        "pokemon" to pokemonEntity.struct,
+        "poke_ball" to pokeBallEntity.struct,
+        "is_successful_capture" to DoubleValue(captureResult.isSuccessfulCapture),
+        "is_critical_capture" to DoubleValue(captureResult.isCriticalCapture),
+    )
+
+    val functions = moLangFunctionMap(
+        "set_shakes" to { params ->
+            val numShakes = params.getInt(0)
+            val successful = params.getBooleanOrNull(1) ?: (numShakes == 4)
+            captureResult = CaptureContext(
+                numberOfShakes = numShakes,
+                isSuccessfulCapture = successful,
+                isCriticalCapture = false
+            )
+            DoubleValue.ONE
+        },
+        "set_critical_capture" to { params ->
+            val numShakes = params.getIntOrNull(0) ?: 1
+            captureResult = CaptureContext(
+                numberOfShakes = numShakes,
+                isSuccessfulCapture = true,
+                isCriticalCapture = true
+            )
+            DoubleValue.ONE
+        }
+    )
 }

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

@@ -20,8 +20,7 @@ import com.cobblemon.mod.common.pokemon.Pokemon
 data class FriendshipUpdatedEvent(
     val pokemon: Pokemon,
     val newFriendshipInitial: Int
-)
-{
+) {
     var newFriendship: Int = newFriendshipInitial
         set(value) {
             field = value.coerceIn(0, Cobblemon.config.maxPokemonFriendship)

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

@@ -9,13 +9,11 @@
 package com.cobblemon.mod.common.api.events.pokemon
 
 import com.cobblemon.mod.common.api.events.Cancelable
-import com.cobblemon.mod.common.api.events.pokemon.HeldItemEvent.Post
-import com.cobblemon.mod.common.api.events.pokemon.HeldItemEvent.Pre
 import com.cobblemon.mod.common.pokemon.Pokemon
 import net.minecraft.world.item.ItemStack
 
 /**
- * The base for all the events related to held items.
+ * The base for all the events related to held items and cosmetic items.
  *
  * @see [Pre]
  * @see [Post]
@@ -28,7 +26,7 @@ interface HeldItemEvent {
     val pokemon: Pokemon
 
     /**
-     * Fired at the start of [Pokemon.swapHeldItem].
+     * Fired at the start of [Pokemon.swapHeldItem] and [Pokemon.swapCosmeticItem].
      *
      * This event should be used to mutate the results of this transaction.
      *
@@ -44,7 +42,7 @@ interface HeldItemEvent {
     data class Pre(override val pokemon: Pokemon, var receiving: ItemStack, var returning: ItemStack, var decrement: Boolean) : HeldItemEvent, Cancelable()
 
     /**
-     * Fired at the end of [Pokemon.swapHeldItem].
+     * Fired at the end of [Pokemon.swapHeldItem] and [Pokemon.swapCosmeticItem].
      *
      * @property pokemon The [Pokemon] triggering this event.
      * @property received The [ItemStack] considered as received and set to the [pokemon]. This is a copy and mutation will not be taken into account.

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

@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.api.events.pokemon
 
 import com.bedrockk.molang.runtime.value.DoubleValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.pokemon.Pokemon
 
 /**
@@ -23,4 +24,11 @@ class LevelUpEvent(val pokemon: Pokemon, val oldLevel: Int, var newLevel: Int) {
         "old_level" to DoubleValue(oldLevel.toDouble()),
         "new_level" to DoubleValue(newLevel.toDouble())
     )
+
+    val functions = moLangFunctionMap(
+        "set_new_level" to {
+            newLevel = it.getInt(0)
+            DoubleValue.ONE
+        }
+    )
 }

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

@@ -13,6 +13,7 @@ import com.bedrockk.molang.runtime.value.MoValue
 import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.events.Cancelable
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.api.pokedex.AbstractPokedexManager
 import com.cobblemon.mod.common.api.pokedex.FormDexRecord
 import com.cobblemon.mod.common.api.pokedex.PokedexEntryProgress
@@ -47,7 +48,9 @@ sealed interface PokedexDataChangedEvent {
         override val knowledge: PokedexEntryProgress,
         override val playerUUID: UUID,
         override val record: FormDexRecord
-    ) : PokedexDataChangedEvent, Cancelable()
+    ) : PokedexDataChangedEvent, Cancelable() {
+        val functions = moLangFunctionMap(cancelFunc)
+    }
 
     class Post(
         override val dataSource: PokedexEntityData,

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

@@ -8,8 +8,12 @@
 
 package com.cobblemon.mod.common.api.events.pokemon
 
+import com.bedrockk.molang.runtime.value.DoubleValue
 import com.bedrockk.molang.runtime.value.StringValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.pokemon.Pokemon
+import com.cobblemon.mod.common.util.server
 import java.util.UUID
 
 data class PokemonGainedEvent(
@@ -20,4 +24,8 @@ data class PokemonGainedEvent(
         "player_id" to StringValue(playerId.toString()),
         "pokemon" to pokemon.struct
     )
+
+    val functions = moLangFunctionMap(
+        "player" to { server()?.playerList?.getPlayer(playerId)?.asMoLangValue() ?: DoubleValue.ZERO },
+    )
 }

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

@@ -8,7 +8,10 @@
 
 package com.cobblemon.mod.common.api.events.pokemon.evolution
 
+import com.bedrockk.molang.runtime.value.MoValue
 import com.cobblemon.mod.common.api.events.Cancelable
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.api.pokemon.evolution.Evolution
 import com.cobblemon.mod.common.pokemon.Pokemon
 
@@ -25,4 +28,11 @@ import com.cobblemon.mod.common.pokemon.Pokemon
 data class EvolutionAcceptedEvent(
     override val pokemon: Pokemon,
     override val evolution: Evolution
-) : Cancelable(), EvolutionEvent
+) : Cancelable(), EvolutionEvent {
+    val context = mutableMapOf<String, MoValue>(
+        "pokemon" to pokemon.struct,
+        "evolution" to evolution.asMoLangValue()
+    )
+
+    val functions = moLangFunctionMap(cancelFunc)
+}

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

@@ -8,6 +8,8 @@
 
 package com.cobblemon.mod.common.api.events.pokemon.evolution
 
+import com.bedrockk.molang.runtime.value.MoValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.api.pokemon.evolution.Evolution
 import com.cobblemon.mod.common.pokemon.Pokemon
 
@@ -23,4 +25,9 @@ import com.cobblemon.mod.common.pokemon.Pokemon
 data class EvolutionCompleteEvent(
     override val pokemon: Pokemon,
     override val evolution: Evolution
-) : EvolutionEvent
+) : EvolutionEvent {
+    val context = mutableMapOf<String, MoValue>(
+        "pokemon" to pokemon.struct,
+        "evolution" to evolution.asMoLangValue()
+    )
+}

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

@@ -8,8 +8,13 @@
 
 package com.cobblemon.mod.common.api.events.pokemon.evolution
 
+import com.bedrockk.molang.runtime.value.DoubleValue
+import com.bedrockk.molang.runtime.value.MoValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.api.pokemon.evolution.Evolution
 import com.cobblemon.mod.common.pokemon.Pokemon
+import com.cobblemon.mod.common.util.getBoolean
 
 /**
  * An event fired when [Evolution.test] has been performed.
@@ -25,4 +30,18 @@ data class EvolutionTestedEvent(
     override val evolution: Evolution,
     val originalResult: Boolean,
     var result: Boolean
-) : EvolutionEvent
+) : EvolutionEvent {
+    val context = mutableMapOf<String, MoValue>(
+        "pokemon" to pokemon.struct,
+        "evolution" to evolution.asMoLangValue(),
+        "original_result" to DoubleValue(originalResult),
+    )
+
+    val functions = moLangFunctionMap(
+        "result" to { DoubleValue(result) },
+        "set_result" to {
+            result = it.getBoolean(0)
+            DoubleValue.ONE
+        }
+    )
+}

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

@@ -16,6 +16,9 @@ import java.util.UUID
 data class PokemonInteractionGUICreationEvent(
     val pokemonID: UUID,
     val mountShoulder: Boolean,
+    val giveHeld: Boolean,
+    val giveCosmetic: Boolean,
+    val canRide: Boolean,
     val options: Multimap<Orientation, InteractWheelOption>
 ) {
     fun addFillingOption(option: InteractWheelOption) {

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

@@ -36,6 +36,8 @@ import com.cobblemon.mod.common.api.pokedex.PokedexEntryProgress
 import com.cobblemon.mod.common.api.pokedex.PokedexManager
 import com.cobblemon.mod.common.api.pokedex.SeenCount
 import com.cobblemon.mod.common.api.pokedex.SeenPercent
+import com.cobblemon.mod.common.api.pokemon.PokemonProperties
+import com.cobblemon.mod.common.api.pokemon.evolution.Evolution
 import com.cobblemon.mod.common.api.pokemon.stats.Stats
 import com.cobblemon.mod.common.api.scripting.CobblemonScripts
 import com.cobblemon.mod.common.api.spawning.context.SpawningContext
@@ -60,8 +62,12 @@ import com.cobblemon.mod.common.net.messages.client.animation.PlayPosableAnimati
 import com.cobblemon.mod.common.net.messages.client.effect.RunPosableMoLangPacket
 import com.cobblemon.mod.common.net.messages.client.effect.SpawnSnowstormEntityParticlePacket
 import com.cobblemon.mod.common.net.messages.client.effect.SpawnSnowstormParticlePacket
+import com.cobblemon.mod.common.pokemon.Gender
 import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.pokemon.Species
+import com.cobblemon.mod.common.pokemon.evolution.variants.ItemInteractionEvolution
+import com.cobblemon.mod.common.pokemon.evolution.variants.LevelUpEvolution
+import com.cobblemon.mod.common.pokemon.evolution.variants.TradeEvolution
 import com.cobblemon.mod.common.util.*
 import com.mojang.datafixers.util.Either
 import java.util.UUID
@@ -1002,6 +1008,82 @@ object MoLangFunctions {
         }
     )
 
+    val pokemonPropertiesFunctions: MutableList<(PokemonProperties) -> HashMap<String, java.util.function.Function<MoParams, Any>>> = mutableListOf(
+        { props ->
+            val map = hashMapOf<String, java.util.function.Function<MoParams, Any>>()
+
+            map.put("level") { DoubleValue(props.level?.toDouble() ?: 0) }
+            map.put("set_level") { params ->
+                props.level = params.getIntOrNull(0)
+                return@put DoubleValue.ONE
+            }
+            map.put("shiny") { DoubleValue(props.shiny) }
+            map.put("set_shiny") { params ->
+                props.shiny = params.getBooleanOrNull(0)
+                return@put DoubleValue.ONE
+            }
+            map.put("species") { props.species?.let { StringValue(it) } ?: DoubleValue.ZERO }
+            map.put("set_species") { params ->
+                props.species = params.getStringOrNull(0)
+                return@put DoubleValue.ONE
+            }
+            map.put("gender") { props.gender?.let { StringValue(it.name) } ?: DoubleValue.ZERO }
+            map.put("set_gender") { params ->
+                props.gender = params.getStringOrNull(0)?.let { Gender.valueOf(it) }
+                return@put DoubleValue.ONE
+            }
+            map.put("form") { props.form?.let { StringValue(it) } ?: DoubleValue.ZERO }
+            map.put("ivs") {
+                val ivs = props.ivs
+                if (ivs == null) {
+                    return@put DoubleValue.ZERO
+                } else {
+                    return@put ivs.struct
+                }
+            }
+            map.put("evs") {
+                val evs = props.evs
+                if (evs == null) {
+                    return@put DoubleValue.ZERO
+                } else {
+                    return@put evs.struct
+                }
+            }
+            map.put("friendship") { DoubleValue(props.friendship?.toDouble() ?: DoubleValue.ZERO) }
+            map.put("set_friendship") { params ->
+                props.friendship = params.getIntOrNull(0)
+                return@put DoubleValue.ONE
+            }
+            map.put("create") { params ->
+                val pokemon = props.create()
+                return@put pokemon.struct
+            }
+
+            map
+        }
+    )
+
+    val evolutionFunctions: MutableList<(Evolution) -> HashMap<String, java.util.function.Function<MoParams, Any>>> = mutableListOf(
+        { evolution ->
+            val map = hashMapOf<String, java.util.function.Function<MoParams, Any>>()
+
+            map.put("result") { evolution.result.asMoLangValue() }
+
+            if (evolution is LevelUpEvolution) {
+                map.put("is_level_up") { DoubleValue.ONE }
+            } else if (evolution is TradeEvolution) {
+                map.put("is_trade") { DoubleValue.ONE }
+            } else if (evolution is ItemInteractionEvolution) {
+                map.put("is_item") { DoubleValue.ONE }
+            }
+
+            map.put("is_optional") { DoubleValue(evolution.optional) }
+            map.put("consumes_held_item") { DoubleValue(evolution.consumeHeldItem) }
+
+            map
+        }
+    )
+
     fun Holder<Biome>.asBiomeMoLangValue() = asMoLangValue(Registries.BIOME).addFunctions(biomeFunctions.flatMap { it(this).entries.map { it.key to it.value } }.toMap())
     fun Holder<Level>.asWorldMoLangValue() = asMoLangValue(Registries.DIMENSION).addFunctions(worldFunctions.flatMap { it(this).entries.map { it.key to it.value } }.toMap())
     fun Holder<Block>.asBlockMoLangValue() = asMoLangValue(Registries.BLOCK).addFunctions(blockFunctions.flatMap { it(this).entries.map { it.key to it.value } }.toMap())
@@ -1034,6 +1116,24 @@ object MoLangFunctions {
         return value
     }
 
+    fun PokemonProperties.asMoLangValue(): ObjectValue<PokemonProperties> {
+        val value = ObjectValue(
+            obj = this,
+            stringify = { it.asString() }
+        )
+        value.addFunctions(pokemonPropertiesFunctions.flatMap { it(this).entries.map { it.key to it.value } }.toMap())
+        return value
+    }
+
+    fun Evolution.asMoLangValue(): ObjectValue<Evolution> {
+        val value = ObjectValue(
+            obj = this,
+            stringify = { it.toString() }
+        )
+        value.addFunctions(evolutionFunctions.flatMap { it(this).entries.map { it.key to it.value } }.toMap())
+        return value
+    }
+
     fun PCStore.asMoLangValue(): ObjectValue<PCStore> {
         val value = ObjectValue(
             obj = this,
@@ -1170,6 +1270,24 @@ object MoLangFunctions {
         return this
     }
 
+    fun moLangFunctionMap(
+        vararg functions: Pair<String, (MoParams) -> MoValue>
+    ): Map<String, (MoParams) -> MoValue> {
+        return functions.toMap()
+    }
+
+    fun queryStructOf(
+        vararg functions: Pair<String, (MoParams) -> MoValue>
+    ): QueryStruct {
+        return QueryStruct(
+            hashMapOf<String, java.util.function.Function<MoParams, Any>>(
+                *functions.map { (name, func) ->
+                    name to java.util.function.Function<MoParams, Any> { params -> func(params) }
+                }.toTypedArray()
+            )
+        )
+    }
+
     fun MoLangRuntime.setup(): MoLangRuntime {
         environment.query.addStandardFunctions()
         return this

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

@@ -8,9 +8,6 @@
 
 package com.cobblemon.mod.common.api.pokemon
 
-import com.bedrockk.molang.runtime.struct.VariableStruct
-import com.bedrockk.molang.runtime.value.DoubleValue
-import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.api.abilities.Abilities
 import com.cobblemon.mod.common.api.abilities.Ability
@@ -775,17 +772,6 @@ open class PokemonProperties {
         return pieces.joinToString(separator)
     }
 
-    fun asStruct(): VariableStruct {
-        val struct = VariableStruct()
-        species?.let { struct.setDirectly("species", StringValue(it)) }
-        level?.let { struct.setDirectly("level", DoubleValue(it)) }
-        shiny?.let { struct.setDirectly("shiny", DoubleValue(it)) }
-        // add more of the optional properties to the struct as doubles or strings
-        gender?.let { struct.setDirectly("gender", StringValue(it.name)) }
-        friendship?.let { struct.setDirectly("friendship", DoubleValue(it)) }
-        return struct
-    }
-
     fun updateAspects() {
         val aspects = mutableSetOf<String>()
         AspectProvider.providers.forEach { aspects.addAll(it.provide(this)) }

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

@@ -8,6 +8,7 @@
 
 package com.cobblemon.mod.common.api.pokemon
 
+import com.bedrockk.molang.Expression
 import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.api.abilities.AbilityPool
 import com.cobblemon.mod.common.api.abilities.AbilityTemplate
@@ -32,6 +33,8 @@ import com.cobblemon.mod.common.api.pokemon.moves.Learnset
 import com.cobblemon.mod.common.api.pokemon.stats.Stat
 import com.cobblemon.mod.common.api.pokemon.stats.Stats
 import com.cobblemon.mod.common.api.reactive.SimpleObservable
+import com.cobblemon.mod.common.api.riding.controller.RideController
+import com.cobblemon.mod.common.api.riding.stats.RidingStatDefinition
 import com.cobblemon.mod.common.api.spawning.TimeRange
 import com.cobblemon.mod.common.api.types.ElementalType
 import com.cobblemon.mod.common.api.types.adapters.ElementalTypeAdapter
@@ -45,6 +48,7 @@ import com.cobblemon.mod.common.pokemon.evolution.adapters.CobblemonRequirementA
 import com.cobblemon.mod.common.pokemon.evolution.adapters.LegacyItemConditionWrapperAdapter
 import com.cobblemon.mod.common.pokemon.helditem.CobblemonHeldItemManager
 import com.cobblemon.mod.common.util.adapters.*
+import com.cobblemon.mod.common.util.adapters.RideControllerAdapter
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.google.common.collect.HashBasedTable
 import com.google.gson.Gson
@@ -53,6 +57,7 @@ import com.google.gson.reflect.TypeToken
 import net.minecraft.advancements.critereon.ItemPredicate
 import net.minecraft.core.registries.BuiltInRegistries
 import net.minecraft.nbt.CompoundTag
+import net.minecraft.network.chat.Component
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.server.packs.PackType
@@ -93,6 +98,7 @@ object PokemonSpecies : JsonDataRegistry<Species> {
         .registerTypeAdapter(DropEntry::class.java, DropEntryAdapter)
         .registerTypeAdapter(CompoundTag::class.java, NbtCompoundAdapter)
         .registerTypeAdapter(ExpressionLike::class.java, ExpressionLikeAdapter)
+        .registerTypeAdapter(Component::class.java, TextAdapter)
         .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Biome::class.java).type, BiomeLikeConditionAdapter)
         .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Block::class.java).type, BlockLikeConditionAdapter)
         .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Item::class.java).type, ItemLikeConditionAdapter)
@@ -100,6 +106,9 @@ object PokemonSpecies : JsonDataRegistry<Species> {
         .registerTypeAdapter(EggGroup::class.java, EggGroupAdapter)
         .registerTypeAdapter(MobEffect::class.java, RegistryElementAdapter<MobEffect>(BuiltInRegistries::MOB_EFFECT))
         .registerTypeAdapter(ItemPredicate::class.java, LegacyItemConditionWrapperAdapter)
+        .registerTypeAdapter(RideController::class.java, RideControllerAdapter)
+        .registerTypeAdapter(RidingStatDefinition::class.java, RidingStatDefinitionAdapter)
+        .registerTypeAdapter(Expression::class.java, ExpressionAdapter)
         .disableHtmlEscaping()
         .enableComplexMapKeySerialization()
         .create()

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

@@ -0,0 +1,25 @@
+/*
+ * 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
+
+import net.minecraft.world.entity.PlayerRideableJumping
+
+/**
+ * Represents an entity that supports riding.
+ *
+ * @since 1.7.0
+ */
+interface Rideable : PlayerRideableJumping {
+
+    /**
+     * Denotes the manager responsible for handling any instance of riding taking place on an entity
+     */
+    val riding: RidingManager
+
+}

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

@@ -0,0 +1,128 @@
+/*
+ * 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
+
+import com.bedrockk.molang.runtime.MoLangRuntime
+import com.bedrockk.molang.runtime.value.DoubleValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.setup
+import com.cobblemon.mod.common.api.riding.controller.RideController
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.util.withQueryValue
+import net.minecraft.resources.ResourceLocation
+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
+
+data class RidingManager(val entity: PokemonEntity) {
+    var lastSpeed = 0F
+    var states: MutableMap<ResourceLocation, RidingState> = mutableMapOf()
+    var deltaRotation = Vec2.ZERO
+
+    val runtime: MoLangRuntime by lazy {
+        MoLangRuntime()
+            .setup()
+            .withQueryValue("entity", entity.struct)
+            .also {
+                it.environment.query.addFunction("passenger_count") { DoubleValue(entity.passengers.size.toDouble()) }
+            }
+    }
+
+    fun <T : RidingState> getState(id: ResourceLocation, constructor: (PokemonEntity) -> T): T {
+        val storedState = states[id]
+        if (storedState == null) {
+            val newState = constructor(entity)
+            states[id] = newState
+            return newState
+        }
+
+        return storedState as T
+    }
+
+    fun getController(entity: PokemonEntity): RideController? {
+        return entity.pokemon.riding.controller?.takeIf { it.condition.invoke(entity) }
+    }
+
+    /**
+     * Responsible for handling riding conditions and transitions amongst controllers. This will tick
+     * whenever the entity receives a tickControlled interaction.
+     */
+    fun tick(entity: PokemonEntity, driver: Player, input: Vec3) {
+        val controller = getController(entity) ?: return
+
+        val pose = controller.pose(entity)
+        entity.entityData.set(PokemonEntity.POSE_TYPE, pose)
+
+//        driver.displayClientMessage(Component.literal("Speed: ").withStyle { it.withColor(ChatFormatting.GREEN) }.append(Component.literal("$lastSpeed b/t")), true)
+    }
+
+    fun speed(entity: PokemonEntity, driver: Player): Float {
+        val controller = getController(entity) ?: return 0.05F
+        this.lastSpeed = controller.speed(entity, driver)
+        return this.lastSpeed
+    }
+
+    fun controlledRotation(entity: PokemonEntity, driver: Player): Vec2 {
+        val controller = getController(entity) ?: return entity.rotationVector
+        val previousRotation = entity.rotationVector
+        val rotation = controller.rotation(entity, driver)
+        this.deltaRotation = Vec2(rotation.x - previousRotation.x, rotation.y - previousRotation.y)
+        return rotation
+    }
+
+    fun clampPassengerRotation(entity: PokemonEntity, driver: LivingEntity) {
+        val controller = getController(entity) ?: return
+        return controller.clampPassengerRotation(entity, driver)
+    }
+
+    fun updatePassengerRotation(entity: PokemonEntity, driver: LivingEntity) {
+        val controller = getController(entity) ?: return
+        return controller.updatePassengerRotation(entity, driver)
+    }
+
+    fun velocity(entity: PokemonEntity, driver: Player, input: Vec3): Vec3 {
+        val controller = getController(entity) ?: return Vec3.ZERO
+        return controller.velocity(entity, driver, input)
+    }
+
+    fun canJump(entity: PokemonEntity, driver: Player): Boolean {
+        val controller = getController(entity) ?: return false
+        return controller.canJump(entity, driver)
+    }
+
+    fun jumpVelocity(entity: PokemonEntity, driver: Player, jumpStrength: Int): Vec3 {
+        val controller = getController(entity) ?: return Vec3.ZERO
+        return controller.jumpForce(entity, driver, jumpStrength)
+    }
+
+    fun gravity(entity: PokemonEntity, regularGravity: Double): Double? {
+        val controller = getController(entity) ?: return null
+        return controller.gravity(entity, regularGravity)
+    }
+
+    fun shouldRoll(entity: PokemonEntity): Boolean {
+        val controller = getController(entity) ?: return false
+        return controller.shouldRoll(entity)
+    }
+
+    fun shouldRotatePlayerHead(entity: PokemonEntity): Boolean {
+        val controller = getController(entity) ?: return false
+        return controller.shouldRotatePlayerHead()
+    }
+
+    fun shouldRotatePokemonHead(entity: PokemonEntity): Boolean {
+        val controller = getController(entity) ?: return false
+        return controller.shouldRotatePokemonHead()
+    }
+
+    //FIXME: Make this not just be false for all controllers lol
+    fun dismountOnShift(): Boolean {
+        return false
+    }
+}

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

@@ -0,0 +1,70 @@
+/*
+ * 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
+
+import com.bedrockk.molang.Expression
+import com.cobblemon.mod.common.api.riding.controller.RideController
+import com.cobblemon.mod.common.api.riding.stats.RidingStat
+import com.cobblemon.mod.common.api.riding.stats.RidingStatDefinition
+import com.cobblemon.mod.common.util.adapters.RideControllerAdapter
+import com.cobblemon.mod.common.util.asExpression
+import com.cobblemon.mod.common.util.getString
+import com.cobblemon.mod.common.util.readIdentifier
+import com.cobblemon.mod.common.util.readString
+import com.cobblemon.mod.common.util.writeString
+import net.minecraft.network.RegistryFriendlyByteBuf
+
+class RidingProperties(
+    val stats: Map<RidingStat, RidingStatDefinition> = mapOf(),
+    val seats: List<Seat> = listOf(),
+    val conditions: List<Expression> = listOf(),
+    val controller: RideController? = null
+) {
+    companion object {
+        fun decode(buffer: RegistryFriendlyByteBuf): RidingProperties {
+            val stats: Map<RidingStat, RidingStatDefinition> = buffer.readMap(
+                { buffer.readEnum<RidingStat>(RidingStat::class.java) },
+                { RidingStatDefinition.decode(buffer) }
+            )
+            val seats: List<Seat> = buffer.readList { _ -> Seat.decode(buffer) }
+            val conditions = buffer.readList { buffer.readString().asExpression() }
+            val controller = buffer.readNullable { _ ->
+                val key = buffer.readIdentifier()
+                val controller = RideControllerAdapter.types[key]?.getConstructor()?.newInstance() ?: error("Unknown controller key: $key")
+                controller.decode(buffer)
+                return@readNullable controller
+            }
+
+            return RidingProperties(stats = stats, seats = seats, conditions = conditions, controller = controller)
+        }
+    }
+
+    val canRide: Boolean
+        get() = seats.isNotEmpty() && controller != null
+
+    fun encode(buffer: RegistryFriendlyByteBuf) {
+        buffer.writeMap(
+            stats,
+            { _, stat -> buffer.writeEnum(stat) },
+            { _, stat -> stat.encode(buffer) }
+        )
+        buffer.writeCollection(seats) { _, seat -> seat.encode(buffer) }
+        buffer.writeCollection(conditions) { _, condition -> buffer.writeString(condition.getString()) }
+        buffer.writeNullable(controller) { _, controller -> controller.encode(buffer) }
+    }
+
+    fun calculate(stat: RidingStat, style: RidingStyle, boosts: Int): Float {
+        val definitions = stats[stat] ?: return 0F
+        return definitions.calculate(style, boosts)
+    }
+
+    fun hasStat(stat: RidingStat, style: RidingStyle): Boolean {
+        return stats[stat]?.ranges?.containsKey(style) == true
+    }
+}

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

@@ -0,0 +1,18 @@
+/*
+ * 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
+
+/**
+ * Honestly having a base interface is probably unnecessary I'm just considering whether there's going to be some
+ * kind of shared state later.
+ *
+ * @author Hiroku
+ * @since October 6th, 2024
+ */
+interface RidingState

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

@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.riding
+
+/**
+ * A general medium for riding. Mainly used for categorizing which stats to pull from and for
+ * presenting a simplified view of riding to users.
+ *
+ * @author Hiroku
+ * @since February 17th, 2025
+ */
+enum class RidingStyle {
+    LAND,
+    LIQUID,
+    AIR
+}

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

@@ -0,0 +1,91 @@
+/*
+ * 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
+
+import com.cobblemon.mod.common.api.net.Encodable
+import com.cobblemon.mod.common.api.riding.controller.RidingAnimation
+import com.cobblemon.mod.common.entity.PoseType
+import com.cobblemon.mod.common.util.readString
+import com.cobblemon.mod.common.util.writeString
+import net.minecraft.network.RegistryFriendlyByteBuf
+import net.minecraft.world.phys.Vec3
+
+/**
+ * Seat Properties are responsible for the base information that would then be used to construct a Seat on an entity.
+ */
+data class Seat(
+    val locator: String = "seat_1",
+    val offset: Vec3 = Vec3.ZERO,
+    val poseOffsets: MutableList<SeatPoseOffset> = mutableListOf(),
+    val poseAnimations: MutableList<SeatPoseAnimations> = mutableListOf()
+) : Encodable {
+    fun getOffset(poseType: PoseType) : Vec3 {
+        return poseOffsets.firstOrNull { poseType in it.poseTypes }?.offset ?: offset
+    }
+
+    override fun encode(buffer: RegistryFriendlyByteBuf) {
+        buffer.writeString(locator)
+        buffer.writeDouble(offset.x)
+        buffer.writeDouble(offset.y)
+        buffer.writeDouble(offset.z)
+        buffer.writeCollection(poseOffsets) { _, offset -> offset.encode(buffer) }
+        buffer.writeCollection(poseAnimations) { _, animations -> animations.encode(buffer) }
+    }
+
+    companion object {
+        fun decode(buffer: RegistryFriendlyByteBuf) : Seat {
+            return Seat(
+                buffer.readString(),
+                Vec3(buffer.readDouble(), buffer.readDouble(), buffer.readDouble()),
+                buffer.readList { SeatPoseOffset.decode(buffer) },
+                buffer.readList { SeatPoseAnimations.decode(buffer) }
+            )
+        }
+    }
+}
+
+class SeatPoseOffset {
+    val poseTypes = mutableSetOf<PoseType>()
+    var offset = Vec3.ZERO
+
+    fun encode(buffer: RegistryFriendlyByteBuf) {
+        buffer.writeCollection(poseTypes) { _, poseType -> buffer.writeString(poseType.name) }
+        buffer.writeDouble(offset.x)
+        buffer.writeDouble(offset.y)
+        buffer.writeDouble(offset.z)
+    }
+
+    companion object {
+        fun decode(buffer: RegistryFriendlyByteBuf) : SeatPoseOffset {
+            val offset = SeatPoseOffset()
+            offset.poseTypes.addAll(buffer.readList { buffer.readString().let { PoseType.valueOf(it) } })
+            offset.offset = Vec3(buffer.readDouble(), buffer.readDouble(), buffer.readDouble())
+            return offset
+        }
+    }
+}
+
+class SeatPoseAnimations {
+    val poseTypes = mutableSetOf<PoseType>()
+    var animations = mutableListOf<RidingAnimation>()
+
+    fun encode(buffer: RegistryFriendlyByteBuf) {
+        buffer.writeCollection(poseTypes) { _, poseType -> buffer.writeString(poseType.name) }
+        buffer.writeCollection(animations) { _, animation -> animation.encode(buffer) }
+    }
+
+    companion object {
+        fun decode(buffer: RegistryFriendlyByteBuf) : SeatPoseAnimations {
+            val animations = SeatPoseAnimations()
+            animations.poseTypes.addAll(buffer.readList { buffer.readString().let { PoseType.valueOf(it) } })
+            animations.animations = buffer.readList { RidingAnimation.decode(buffer) }
+            return animations
+        }
+    }
+}

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

@@ -0,0 +1,106 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.riding.controller
+
+import com.cobblemon.mod.common.api.net.Decodable
+import com.cobblemon.mod.common.api.net.Encodable
+import com.cobblemon.mod.common.api.riding.RidingState
+import com.cobblemon.mod.common.api.riding.controller.posing.PoseProvider
+import com.cobblemon.mod.common.entity.PoseType
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.util.writeIdentifier
+import net.minecraft.network.RegistryFriendlyByteBuf
+import net.minecraft.resources.ResourceLocation
+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
+
+/**
+ * A riding controller is the internal control mechanism for determining how a pokemon
+ * handles during riding. Controllers come into play once the pokemon being ridden has
+ * established the path it's capable of. For instance, a land based controller could have
+ * the pokemon experience drifting after movement, or generic movement. It's up to the
+ * controller to decide how the pokemon behaves.
+ *
+ * @since 1.7.0
+ */
+interface RideController : Encodable, Decodable {
+
+    /** A reference key used to denote the individual controller */
+    val key: ResourceLocation
+
+    /**
+     * Specifies the provider of poses which helps control updating the current pose on the pokemon
+     * being ridden. Controllers are expected to define the pose types responsible for posing the entity
+     * through all expected conditions. It should define a default pose, that will be used in all cases
+     * where a pose does not meet the current conditions for the current mount. Typically, this will be
+     * an idle pose.
+     */
+    val poseProvider: PoseProvider
+
+    /**
+     * Represents a condition that must be met for this controller to be active. For instance, this can be used
+     * to evaluate things such as current velocity or block state of the entity.
+     */
+    val condition: (PokemonEntity) -> Boolean
+
+    /**
+     * Specifies the pose the ridden mount should be positioned in. This queries the pose provider using
+     * the entity as a means of determining the conditions the entity is currently under. This allows for
+     * dynamic pose updates.
+     */
+    fun pose(entity: PokemonEntity) : PoseType {
+        return this.poseProvider.select(entity)
+    }
+
+    /**
+     * Calculates the current speed of the mount.
+     */
+    fun speed(entity: PokemonEntity, driver: Player) : Float
+
+    /**
+     * Sets the rotation of the mount. This is typically based on the controlling driver and is manipulated as
+     * necessary.
+     */
+    fun rotation(entity: PokemonEntity, driver: LivingEntity) : Vec2
+
+    fun clampPassengerRotation(entity: PokemonEntity, driver: LivingEntity) {}
+
+    fun updatePassengerRotation(entity: PokemonEntity, driver: LivingEntity) {
+        driver.yRot = entity.yRot
+    }
+
+    /**
+     * Manipulates the movement input as necessary by the controller. This is primarily used to apply limits
+     * to the types of movements. For instance, we can apply limits to any sort of sideways movement input, so that
+     * it would otherwise be slower than normal forward movement.
+     */
+    fun velocity(entity: PokemonEntity, driver: Player, input: Vec3) : Vec3
+
+    fun canJump(entity: PokemonEntity, driver: Player) : Boolean
+    fun jumpForce(entity: PokemonEntity, driver: Player, jumpStrength: Int) : Vec3
+
+    fun gravity(entity: PokemonEntity, regularGravity: Double) : Double? = null
+
+    fun shouldRoll(entity: PokemonEntity): Boolean = false
+
+    fun getRuntime(entity: PokemonEntity) = entity.riding.runtime
+
+    fun shouldRotatePokemonHead(): Boolean = false
+    fun shouldRotatePlayerHead(): Boolean = false
+
+    fun <T : RidingState> getState(entity: PokemonEntity, constructor: (PokemonEntity) -> T): T {
+        return entity.riding.getState(key, constructor)
+    }
+
+    override fun encode(buffer: RegistryFriendlyByteBuf) {
+        buffer.writeIdentifier(this.key)
+    }
+}

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

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.riding.controller
+
+import com.cobblemon.mod.common.util.readString
+import com.cobblemon.mod.common.util.writeString
+import net.minecraft.network.RegistryFriendlyByteBuf
+
+class RidingAnimation(
+    val fileName: String,
+    val animationName: String
+) {
+    fun encode(buffer: RegistryFriendlyByteBuf) {
+        buffer.writeString(fileName)
+        buffer.writeString(animationName)
+    }
+
+    companion object {
+        fun decode(buffer: RegistryFriendlyByteBuf) : RidingAnimation {
+            return RidingAnimation(
+                buffer.readString(),
+                buffer.readString()
+            )
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/controller/posing/PoseOption.kt

@@ -0,0 +1,15 @@
+/*
+ * 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.controller.posing
+
+import com.cobblemon.mod.common.entity.PoseType
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import java.util.function.Predicate
+
+data class PoseOption(val pose: PoseType, val condition: Predicate<PokemonEntity>)

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/controller/posing/PoseProvider.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.riding.controller.posing
+
+import com.cobblemon.mod.common.entity.PoseType
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+
+class PoseProvider(private val fallback: PoseType) {
+
+    private val options = mutableListOf<PoseOption>()
+
+    fun select(entity: PokemonEntity) : PoseType {
+        return this.options.stream()
+            .filter { it.condition.test(entity) }
+            .map { it.pose }
+            .findFirst()
+            .orElse(this.fallback)
+    }
+
+    fun with(option: PoseOption) : PoseProvider {
+        this.options.add(option)
+        return this
+    }
+
+}

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

@@ -0,0 +1,33 @@
+/*
+ * 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.events
+
+import net.minecraft.world.entity.LivingEntity
+
+data class SelectDriverEvent(val options: Set<LivingEntity>) {
+
+    private var result: DriverSuggestion? = null
+
+    fun result(): LivingEntity? {
+        return this.result?.entity
+    }
+
+    /**
+     * Suggests a particular living entity as a potential driver. Only non-negative
+     * values are permitted by this function. All priority values with lesser priorities
+     * will be outright ignored.
+     */
+    fun suggest(target: LivingEntity, priority: Int) {
+        if (priority >= 0 && priority > (this.result?.priority ?: -1)) {
+            this.result = DriverSuggestion(target, priority)
+        }
+    }
+
+    data class DriverSuggestion(val entity: LivingEntity, val priority: Int)
+}

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

@@ -0,0 +1,38 @@
+/*
+ * 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.stats
+
+import com.cobblemon.mod.common.api.berry.Flavor
+import com.cobblemon.mod.common.util.lang
+import net.minecraft.network.chat.Component
+
+/**
+ * A stat that is used for riding Pokémon. The exact implementation of each of these depends on the [com.cobblemon.mod.common.api.riding.controller.RideController].
+ *
+ * @author Hiroku
+ * @since February 17th, 2025
+ */
+enum class RidingStat(
+    val flavour: Flavor
+) {
+    SPEED(Flavor.SWEET),
+    ACCELERATION(Flavor.SPICY),
+    SKILL(Flavor.DRY),
+    JUMP(Flavor.BITTER),
+    STAMINA(Flavor.SOUR);
+
+    companion object {
+        fun getByName(name: String) = RidingStat.entries.firstOrNull { it.name.equals(name, ignoreCase = true) }
+    }
+
+    val displayName: Component
+        get() = lang("riding.stat.${name.lowercase()}.name")
+    val description: Component
+        get() = lang("riding.stat.${name.lowercase()}.desc")
+}

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

@@ -0,0 +1,70 @@
+/*
+ * 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.stats
+
+import com.cobblemon.mod.common.api.riding.RidingStyle
+import com.cobblemon.mod.common.net.IntSize
+import com.cobblemon.mod.common.util.readSizedInt
+import com.cobblemon.mod.common.util.readText
+import com.cobblemon.mod.common.util.writeSizedInt
+import com.cobblemon.mod.common.util.writeText
+import net.minecraft.network.RegistryFriendlyByteBuf
+import net.minecraft.network.chat.Component
+
+/**
+ * The definition of all the different information related to a specific [RidingStat] on a Pokémon species.
+ *
+ * @author Hiroku
+ * @since February 17th, 2025
+ */
+class RidingStatDefinition {
+    // This object gets read from a JSON adapter manually (field-by-field) so don't add fields without updating the adapter.
+
+    /** A map from [RidingStyle] to a minimum and maximum value for this stat. */
+    val ranges = mutableMapOf<RidingStyle, IntRange>()
+    /** Display name for the stat, if null falls back to [RidingStat.displayName]. */
+    var displayName: Component? = null
+    /** Description for the stat, if null falls back to [RidingStat.description]. */
+    var description: Component? = null
+
+    fun calculate(style: RidingStyle, aprijuiceBoost: Int): Float {
+        val range = ranges[style] ?: ranges[RidingStyle.LAND] ?: return 0F
+        val boostQuotient = aprijuiceBoost / 255F
+        return range.first + (range.last - range.first) * boostQuotient
+    }
+
+    fun encode(buffer: RegistryFriendlyByteBuf) {
+        buffer.writeNullable(displayName) { _, it -> buffer.writeText(it) }
+        buffer.writeNullable(description) { _, it -> buffer.writeText(it) }
+        buffer.writeMap(
+            ranges,
+            { _, it -> buffer.writeEnum(it) },
+            { _, it ->
+                buffer.writeSizedInt(IntSize.U_BYTE, it.first)
+                buffer.writeSizedInt(IntSize.U_BYTE, it.last)
+            }
+        )
+    }
+
+    companion object {
+        fun decode(buffer: RegistryFriendlyByteBuf): RidingStatDefinition {
+            val displayName = buffer.readNullable { buffer.readText() }
+            val description = buffer.readNullable { buffer.readText() }
+            val ranges = buffer.readMap<RidingStyle, IntRange>(
+                { buffer.readEnum<RidingStyle>(RidingStyle::class.java) },
+                { IntRange(buffer.readSizedInt(IntSize.U_BYTE), buffer.readSizedInt(IntSize.U_BYTE)) }
+            )
+            return RidingStatDefinition().apply {
+                this.displayName = displayName
+                this.description = description
+                this.ranges.putAll(ranges)
+            }
+        }
+    }
+}

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

@@ -8,9 +8,11 @@
 
 package com.cobblemon.mod.common.api.spawning.detail
 
+import com.bedrockk.molang.runtime.value.DoubleValue
 import com.cobblemon.mod.common.Cobblemon.LOGGER
 import com.cobblemon.mod.common.Cobblemon.config
 import com.cobblemon.mod.common.api.drop.DropTable
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.api.pokemon.PokemonProperties
 import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
 import com.cobblemon.mod.common.api.spawning.context.SpawningContext
@@ -20,8 +22,8 @@ import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
 import com.cobblemon.mod.common.util.asTranslated
 import com.cobblemon.mod.common.util.lang
 import com.google.gson.annotations.SerializedName
-import net.minecraft.network.chat.MutableComponent
 import kotlin.math.ceil
+import net.minecraft.network.chat.MutableComponent
 
 /**
  * A [SpawnDetail] for spawning a [PokemonEntity].
@@ -69,7 +71,9 @@ class PokemonSpawnDetail : SpawnDetail() {
     }
 
     override fun autoLabel() {
-        val pokemonStruct = pokemon.asStruct()
+        struct.addFunction("pokemon") { pokemon.asMoLangValue() }
+        struct.addFunction("min_level") { DoubleValue(getDerivedLevelRange().start.toDouble()) }
+        struct.addFunction("max_level") { DoubleValue(getDerivedLevelRange().endInclusive.toDouble()) }
         if (pokemon.species != null) {
             val species = PokemonSpecies.getByIdentifier(pokemon.species!!.asIdentifierDefaultingNamespace())
             if (species != null) {
@@ -88,7 +92,6 @@ class PokemonSpawnDetail : SpawnDetail() {
             }
         }
 
-        struct.setDirectly("pokemon", pokemonStruct)
         super.autoLabel()
     }
 

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

@@ -8,12 +8,12 @@
 
 package com.cobblemon.mod.common.api.spawning.detail
 
-import com.bedrockk.molang.runtime.struct.ArrayStruct
-import com.bedrockk.molang.runtime.struct.VariableStruct
+import com.bedrockk.molang.runtime.struct.QueryStruct
 import com.bedrockk.molang.runtime.value.DoubleValue
 import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.Cobblemon.LOGGER
 import com.cobblemon.mod.common.api.ModDependant
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.queryStructOf
 import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.condition.CompositeSpawningCondition
 import com.cobblemon.mod.common.api.spawning.condition.SpawningCondition
@@ -21,6 +21,7 @@ import com.cobblemon.mod.common.api.spawning.context.RegisteredSpawningContext
 import com.cobblemon.mod.common.api.spawning.context.SpawningContext
 import com.cobblemon.mod.common.api.spawning.multiplier.WeightMultiplier
 import com.cobblemon.mod.common.api.text.text
+import com.cobblemon.mod.common.util.asArrayValue
 import com.cobblemon.mod.common.util.asTranslated
 
 /**
@@ -55,21 +56,21 @@ abstract class SpawnDetail : ModDependant {
 
     var labels = mutableListOf<String>()
 
-    val struct: VariableStruct = VariableStruct()
+    val struct: QueryStruct = queryStructOf(
+        "weight" to { DoubleValue(weight) },
+        "percentage" to { DoubleValue(percentage) },
+        "id" to { StringValue(id) },
+        "bucket" to { StringValue(bucket.name) },
+        "width" to { DoubleValue(width.toDouble()) },
+        "height" to { DoubleValue(height.toDouble()) },
+        "context" to { StringValue(context.name) },
+        "labels" to { labels.asArrayValue { StringValue(it) } }
+    )
 
     override var neededInstalledMods = listOf<String>()
     override var neededUninstalledMods = listOf<String>()
 
-    open fun autoLabel() {
-        struct.setDirectly("weight", DoubleValue(weight.toDouble()))
-        struct.setDirectly("percentage", DoubleValue(percentage.toDouble()))
-        struct.setDirectly("id", StringValue(id))
-        struct.setDirectly("bucket", StringValue(bucket.name))
-        struct.setDirectly("width", DoubleValue(width.toDouble()))
-        struct.setDirectly("height", DoubleValue(height.toDouble()))
-        struct.setDirectly("context", StringValue(context.name))
-        struct.setDirectly("labels", ArrayStruct(labels.mapIndexed { index, s -> "$index" to StringValue(s) }.toMap()))
-    }
+    open fun autoLabel() {}
 
     open fun getName() = displayName?.asTranslated() ?: id.text()
 

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

@@ -109,7 +109,7 @@ class BerryBlock(private val berryIdentifier: ResourceLocation, settings: Proper
             determineMutation(world, random, pos, newState)
         }
 
-        world.setBlock(pos, newState, Block.UPDATE_CLIENTS)
+        world.setBlock(pos, newState, UPDATE_CLIENTS)
         convertMulchToEntity(world, newState, pos)
         treeEntity.goToNextStageTimer(FRUIT_AGE - curAge)
         treeEntity.setChanged()

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

@@ -102,7 +102,7 @@ class BerryBlockEntity(pos: BlockPos, state: BlockState) : BlockEntity(Cobblemon
         mulchDuration = if (newDuration <= 0) {
             mulchVariant = MulchVariant.NONE
             this.setChanged()
-            world.sendBlockUpdated(pos, state, state, Block.UPDATE_CLIENTS)
+            world.sendBlockUpdated(pos, state, state, UPDATE_CLIENTS)
             0
         } else {
             newDuration
@@ -313,6 +313,10 @@ class BerryBlockEntity(pos: BlockPos, state: BlockState) : BlockEntity(Cobblemon
         val berryPoints = arrayListOf<Pair<Berry, GrowthPoint>>()
         val sequenceIndices = growthPointSequence.toCharArray().filter { it.digitToInt(16) < baseBerry.growthPoints.size }
         for ((index, identifier) in this.growthPoints.withIndex()) {
+            // Don't brick old broken worlds that had too many
+            if (index >= sequenceIndices.size) {
+                break
+            }
             val berry = Berries.getByIdentifier(identifier) ?: continue
             val sequenceIndexHex = sequenceIndices[index].digitToInt(16)
             berryPoints.add(berry to baseBerry.growthPoints[sequenceIndexHex])

common/src/main/kotlin/com/cobblemon/mod/common/client/entity/PokemonClientDelegate.kt

@@ -13,8 +13,8 @@ import com.bedrockk.molang.runtime.value.DoubleValue
 import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.CobblemonSounds
+import com.cobblemon.mod.common.Rollable
 import com.cobblemon.mod.common.api.entity.PokemonSideDelegate
-import com.cobblemon.mod.common.api.molang.MoLangFunctions.addEntityFunctions
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.addFunctions
 import com.cobblemon.mod.common.api.pokeball.PokeBalls
 import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
@@ -42,8 +42,11 @@ import net.minecraft.sounds.SoundEvent
 import net.minecraft.sounds.SoundSource
 import net.minecraft.world.InteractionHand
 import net.minecraft.world.entity.Entity
+import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.player.Player
 import net.minecraft.world.phys.Vec3
+import org.joml.Matrix3f
+import org.joml.Vector3f
 
 class PokemonClientDelegate : PosableState(), PokemonSideDelegate {
     companion object {

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

@@ -8,22 +8,25 @@
 
 package com.cobblemon.mod.common.client.gui
 
+import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.CobblemonItems
 import com.cobblemon.mod.common.api.gui.blitk
-import com.cobblemon.mod.common.api.gui.drawPosablePortrait
 import com.cobblemon.mod.common.api.text.darkGray
 import com.cobblemon.mod.common.api.text.red
 import com.cobblemon.mod.common.api.text.text
 import com.cobblemon.mod.common.client.CobblemonClient
 import com.cobblemon.mod.common.client.CobblemonResources
 import com.cobblemon.mod.common.client.gui.battle.BattleGUI
+import com.cobblemon.mod.common.client.gui.portrait.FullyAnimatedPortraitDrawer
+import com.cobblemon.mod.common.client.gui.portrait.SelectedAnimatedPortraitDrawer
+import com.cobblemon.mod.common.client.gui.portrait.InanimatePortraitDrawer
+import com.cobblemon.mod.common.client.gui.portrait.PortraitStyle
 import com.cobblemon.mod.common.client.gui.toast.CobblemonToast
 import com.cobblemon.mod.common.client.keybind.boundKey
 import com.cobblemon.mod.common.client.keybind.keybinds.HidePartyBinding
 import com.cobblemon.mod.common.client.keybind.keybinds.SummaryBinding
 import com.cobblemon.mod.common.client.render.drawScaledText
 import com.cobblemon.mod.common.client.render.getDepletableRedGreen
-import com.cobblemon.mod.common.client.render.models.blockbench.FloatingState
 import com.cobblemon.mod.common.client.render.renderScaledGuiItemIcon
 import com.cobblemon.mod.common.pokemon.Gender
 import com.cobblemon.mod.common.util.cobblemonResource
@@ -55,7 +58,10 @@ class PartyOverlay : Gui(Minecraft.getInstance()) {
         private val genderIconMale = cobblemonResource("textures/gui/party/party_gender_male.png")
         private val genderIconFemale = cobblemonResource("textures/gui/party/party_gender_female.png")
         private val portraitBackground = cobblemonResource("textures/gui/party/party_slot_portrait_background.png")
-        val state = FloatingState()
+
+        private val inanimatePortraitDrawer = InanimatePortraitDrawer()
+        private val selectedAnimatedPortraitDrawer = SelectedAnimatedPortraitDrawer()
+        private val fullyAnimatedPortraitDrawer = FullyAnimatedPortraitDrawer()
     }
 
     private val screenExemptions: List<Class<out Screen>> = listOf(
@@ -84,6 +90,7 @@ class PartyOverlay : Gui(Minecraft.getInstance()) {
 
     override fun render(context: GuiGraphics, tickCounter: DeltaTracker) {
         val partialDeltaTicks = tickCounter.realtimeDeltaTicks
+
         val minecraft = Minecraft.getInstance()
 
         // Hiding if a Screen is open and not exempt
@@ -153,15 +160,14 @@ class PartyOverlay : Gui(Minecraft.getInstance()) {
                     0.0
                 )
 
-                state.currentAspects = pokemon.aspects
+                val portraitDrawer = when (Cobblemon.config.partyPortraitAnimations) {
+                    PortraitStyle.NEVER_ANIMATE -> inanimatePortraitDrawer
+                    PortraitStyle.ANIMATE_SELECTED -> selectedAnimatedPortraitDrawer
+                    PortraitStyle.ALWAYS_ANIMATE -> fullyAnimatedPortraitDrawer
+                }
+
+                portraitDrawer.draw(pokemon, matrices, partialDeltaTicks, selectedSlot == index, index)
 
-                drawPosablePortrait(
-                    identifier = pokemon.species.resourceIdentifier,
-                    matrixStack = matrices,
-                    partialTicks = 0F, // partialDeltaTicks, //Before you get any funny ideas about party animated pokemon, make sure they each get their own state instead of sharing.
-                    contextScale = pokemon.form.baseScale,
-                    state = state
-                )
                 matrices.popPose()
                 context.disableScissor()
             }

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/interact/wheel/InteractTypePokemon.kt

@@ -0,0 +1,16 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.client.gui.interact.wheel
+
+enum class InteractTypePokemon {
+    SHOULDER,
+    HELD_ITEM,
+    COSMETIC_ITEM,
+    RIDE;
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/interact/wheel/InteractWheelButton.kt

@@ -36,7 +36,7 @@ class InteractWheelButton(
         const val BUTTON_SIZE = 69
         const val TEXTURE_HEIGHT = BUTTON_SIZE * 2
         const val ICON_SIZE = 32
-        const val ICON_SCALE = 0.5f
+        const val ICON_SCALE = 0.5F
         const val ICON_OFFSET = 26.5
     }
 
@@ -55,10 +55,10 @@ class InteractWheelButton(
             height = BUTTON_SIZE,
             vOffset = if (isHovered(mouseX.toFloat(), mouseY.toFloat()) && isEnabled) BUTTON_SIZE else 0,
             textureHeight = TEXTURE_HEIGHT,
-            alpha = if (isEnabled) 1f else 0.4f
+            alpha = if (isEnabled) 1f else 0.4F
         )
 
-        if(isHovered(mouseX.toFloat(), mouseY.toFloat())){
+        if(isEnabled && isHovered(mouseX.toFloat(), mouseY.toFloat())){
             tooltipText?.let {
                 context.renderTooltip(Minecraft.getInstance().font, Component.translatable(it), mouseX, mouseY)
             }
@@ -74,7 +74,7 @@ class InteractWheelButton(
                 y = iconY,
                 width = ICON_SIZE,
                 height = ICON_SIZE,
-                alpha = if (isEnabled) 1f else 0.4f,
+                alpha = if (isEnabled) 1F else 0.2F,
                 red = colour.x,
                 green = colour.y,
                 blue = colour.z,
@@ -93,7 +93,7 @@ class InteractWheelButton(
                         y = (iconY.toFloat() - ICON_SIZE),
                         width = ICON_SIZE,
                         height = ICON_SIZE,
-                        alpha = if (isEnabled) 1f else 0.4f,
+                        alpha = if (isEnabled) 1F else 0.4F,
                         red = colour.x,
                         green = colour.y,
                         blue = colour.z,

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/interact/wheel/InteractWheelGUI.kt

@@ -104,7 +104,7 @@ class InteractWheelGUI(private val options: Multimap<Orientation, InteractWheelO
             tooltipText = option?.tooltipText,
             x = x,
             y = y,
-            isEnabled = option != null,
+            isEnabled = option != null && option.enabled,
             colour = option?.colour ?: { null },
             onPress = { option?.onPress?.invoke() },
             canHover = { a: Double, b: Double -> !isMouseInCenter(a, b)}

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/interact/wheel/InteractWheelGuiFactory.kt

@@ -21,36 +21,70 @@ import com.cobblemon.mod.common.net.messages.server.trade.OfferTradePacket
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.google.common.collect.ArrayListMultimap
 import com.google.common.collect.Multimap
+import java.util.UUID
 import net.minecraft.client.Minecraft
 import net.minecraft.network.chat.Component
-import java.util.*
 import org.joml.Vector3f
 
-fun createPokemonInteractGui(pokemonID: UUID, canMountShoulder: Boolean): InteractWheelGUI {
+fun createPokemonInteractGui(pokemonID: UUID, canMountShoulder: Boolean, canGiveHeld: Boolean, canGiveCosmetic: Boolean, canRide: Boolean): InteractWheelGUI {
     val mountShoulder = InteractWheelOption(
         iconResource = cobblemonResource("textures/gui/interact/icon_shoulder.png"),
         tooltipText = "cobblemon.ui.interact.mount.shoulder",
+        enabled = canMountShoulder,
         onPress = {
             if (canMountShoulder) {
-                InteractPokemonPacket(pokemonID, true).sendToServer()
+                InteractPokemonPacket(pokemonID, InteractTypePokemon.SHOULDER).sendToServer()
                 closeGUI()
             }
         }
     )
-    val giveItem = InteractWheelOption(
+    val giveHeldItem = InteractWheelOption(
         iconResource = cobblemonResource("textures/gui/interact/icon_held_item.png"),
         tooltipText = "cobblemon.ui.interact.give.item",
+        enabled = canGiveHeld,
         onPress = {
-            InteractPokemonPacket(pokemonID, false).sendToServer()
-            closeGUI()
+            if (canGiveHeld) {
+                InteractPokemonPacket(pokemonID, InteractTypePokemon.HELD_ITEM).sendToServer()
+                closeGUI()
+            }
         }
     )
+    val giveCosmeticItem = InteractWheelOption(
+        iconResource = cobblemonResource("textures/gui/interact/icon_cosmetic_item.png"),
+        tooltipText = "cobblemon.ui.interact.give.cosmetic_item",
+        enabled = canGiveCosmetic,
+        onPress = {
+            if (canGiveCosmetic) {
+                InteractPokemonPacket(pokemonID, InteractTypePokemon.COSMETIC_ITEM).sendToServer()
+                closeGUI()
+            }
+        }
+    )
+
+    val ride = InteractWheelOption(
+        iconResource = cobblemonResource("textures/gui/interact/icon_ride.png"),
+        tooltipText = "cobblemon.ui.interact.ride",
+        onPress = {
+            if (canRide) {
+                InteractPokemonPacket(pokemonID, InteractTypePokemon.RIDE).sendToServer()
+                closeGUI()
+            }
+        }
+    )
+
     val options: Multimap<Orientation, InteractWheelOption> = ArrayListMultimap.create()
-    options.put(Orientation.TOP_RIGHT, giveItem)
-    if (canMountShoulder) {
-        options.put(Orientation.TOP_LEFT, mountShoulder)
-    }
-    CobblemonEvents.POKEMON_INTERACTION_GUI_CREATION.post(PokemonInteractionGUICreationEvent(pokemonID, canMountShoulder, options))
+    options.put(Orientation.TOP_RIGHT, giveHeldItem)
+    options.put(Orientation.BOTTOM_RIGHT, giveCosmeticItem)
+    options.put(Orientation.BOTTOM_LEFT, ride)
+    options.put(Orientation.TOP_LEFT, mountShoulder)
+    CobblemonEvents.POKEMON_INTERACTION_GUI_CREATION.post(PokemonInteractionGUICreationEvent(
+        pokemonID = pokemonID,
+        mountShoulder = canMountShoulder,
+        giveHeld = canGiveHeld,
+        giveCosmetic = canGiveCosmetic,
+        canRide = canRide,
+        options = options
+    ))
     return InteractWheelGUI(options, Component.translatable("cobblemon.ui.interact.pokemon"))
 }
 

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/interact/wheel/InteractWheelOption.kt

@@ -14,6 +14,7 @@ import org.joml.Vector3f
 data class InteractWheelOption(
     val iconResource: ResourceLocation,
     val secondaryIconResource: ResourceLocation? = null,
+    val enabled: Boolean = true,
     val tooltipText: String?,
     val colour: () -> Vector3f? = { null },
     val onPress: () -> Unit

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

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.client.gui.portrait
+
+import com.cobblemon.mod.common.api.gui.drawPosablePortrait
+import com.cobblemon.mod.common.client.render.models.blockbench.FloatingState
+import com.cobblemon.mod.common.pokemon.Pokemon
+import com.mojang.blaze3d.vertex.PoseStack
+import java.util.UUID
+
+/**
+ * Base logic for a [PortraitDrawer] that animates a portrait based on conditions.
+ */
+abstract class AnimatedPortraitDrawer : PortraitDrawer {
+
+    private val state = FloatingState()
+
+    private val stateAtIndex = hashMapOf<Int, Pair<UUID, FloatingState>>()
+
+    override fun draw(pokemon: Pokemon, poseStack: PoseStack, partialTicks: Float, isSelected: Boolean, index: Int) {
+        drawPosablePortrait(
+            identifier = pokemon.species.resourceIdentifier,
+            matrixStack = poseStack,
+            partialTicks = this.ticksFor(pokemon, isSelected, partialTicks),
+            contextScale = pokemon.form.baseScale,
+            state = this.stateFor(pokemon, isSelected, index)
+        )
+    }
+
+    protected abstract fun shouldAnimate(pokemon: Pokemon, isSelected: Boolean): Boolean
+
+    protected open fun ticksFor(pokemon: Pokemon, isSelected: Boolean, partialTicks: Float): Float {
+        return if (this.shouldAnimate(pokemon, isSelected)) partialTicks else 0F
+    }
+
+    protected open fun stateFor(pokemon: Pokemon, isSelected: Boolean, index: Int): FloatingState {
+        if (!this.shouldAnimate(pokemon, isSelected)) {
+            return this.state
+        }
+        val state = this.stateAtIndex.getOrPut(index) { pokemon.uuid to this.createState(pokemon) }
+        if (state.first != pokemon.uuid) {
+            val newState = this.createState(pokemon)
+            this.stateAtIndex[index] = pokemon.uuid to newState
+            return newState
+        }
+        return state.second
+    }
+
+    protected open fun createState(pokemon: Pokemon): FloatingState {
+        val state = FloatingState()
+        state.currentAspects = pokemon.aspects
+        return state
+    }
+
+
+
+}

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

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.client.gui.portrait
+
+import com.cobblemon.mod.common.pokemon.Pokemon
+import net.minecraft.client.GraphicsStatus
+
+/**
+ * Draws portraits if the Pokemon is not fainted.
+ *
+ * Meant for client with [GraphicsStatus.FABULOUS].
+ */
+class FullyAnimatedPortraitDrawer : AnimatedPortraitDrawer() {
+
+    override fun shouldAnimate(pokemon: Pokemon, isSelected: Boolean): Boolean {
+        return !pokemon.isFainted()
+    }
+
+}

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

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.client.gui.portrait
+
+import com.cobblemon.mod.common.api.gui.drawPosablePortrait
+import com.cobblemon.mod.common.client.render.models.blockbench.FloatingState
+import com.cobblemon.mod.common.pokemon.Pokemon
+import com.mojang.blaze3d.vertex.PoseStack
+import net.minecraft.client.GraphicsStatus
+
+/**
+ * The simplest implementation, the Pokemon is drawn staying still.
+ *
+ * Meant for client with [GraphicsStatus.FAST].
+ */
+class InanimatePortraitDrawer : PortraitDrawer {
+
+    private val state = FloatingState()
+
+    override fun draw(pokemon: Pokemon, poseStack: PoseStack, partialTicks: Float, isSelected: Boolean, index: Int) {
+        state.currentAspects = pokemon.aspects
+        drawPosablePortrait(
+            identifier = pokemon.species.resourceIdentifier,
+            matrixStack = poseStack,
+            partialTicks = 0F,
+            contextScale = pokemon.form.baseScale,
+            state = this.state
+        )
+    }
+
+}

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

@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.client.gui.portrait
+
+import com.cobblemon.mod.common.pokemon.Pokemon
+import com.mojang.blaze3d.vertex.PoseStack
+
+/**
+ * Responsible for drawing a Pokemon portrait.
+ *
+ * Keep in mind any scaling and handling of the [PoseStack] must be done on the implementations using this system.
+ */
+fun interface PortraitDrawer {
+
+    /**
+     * Draws the portrait.
+     *
+     * @param pokemon The [Pokemon] being drawn.
+     * @param poseStack The [PoseStack] being used.
+     * @param partialTicks The partial ticks of the screen using this.
+     * @param isSelected If the [pokemon] is considered in a selected state for example hovered or the current party member.
+     * @param index The index of the [pokemon] in the screen using this.
+     */
+    fun draw(
+        pokemon: Pokemon,
+        poseStack: PoseStack,
+        partialTicks: Float,
+        isSelected: Boolean,
+        index: Int
+    )
+
+}

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

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.client.gui.portrait
+
+import com.mojang.serialization.Codec
+import net.minecraft.util.StringRepresentable
+
+enum class PortraitStyle : StringRepresentable {
+
+    NEVER_ANIMATE,
+    ANIMATE_SELECTED,
+    ALWAYS_ANIMATE;
+
+    override fun getSerializedName(): String = this.name
+
+    companion object {
+
+        @JvmStatic
+        val CODEC: Codec<PortraitStyle> = StringRepresentable.fromEnum(PortraitStyle::values)
+
+    }
+
+}

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

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.client.gui.portrait
+
+import com.cobblemon.mod.common.pokemon.Pokemon
+import net.minecraft.client.GraphicsStatus
+
+/**
+ * Draws portraits if the Pokemon is not fainted and selected.
+ *
+ * Meant for client with [GraphicsStatus.FANCY].
+ */
+class SelectedAnimatedPortraitDrawer : AnimatedPortraitDrawer() {
+
+    override fun shouldAnimate(pokemon: Pokemon, isSelected: Boolean): Boolean {
+        return !pokemon.isFainted() && isSelected
+    }
+
+}

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

@@ -97,6 +97,8 @@ class Summary private constructor(party: Collection<Pokemon?>, private val edita
         private val tabIconMoves = cobblemonResource("textures/gui/summary/summary_tab_icon_moves.png")
         private val tabIconStats = cobblemonResource("textures/gui/summary/summary_tab_icon_stats.png")
         val iconShinyResource = cobblemonResource("textures/gui/summary/icon_shiny.png")
+        val iconHeldItemResource = cobblemonResource("textures/gui/summary/icon_item_held.png")
+        val iconCosmeticItemResource = cobblemonResource("textures/gui/summary/icon_item_cosmetic.png")
 
         /**
          * Attempts to open this screen for a client.
@@ -124,6 +126,7 @@ class Summary private constructor(party: Collection<Pokemon?>, private val edita
     private lateinit var modelWidget: ModelWidget
     private lateinit var nicknameEntryWidget: NicknameEntryWidget
     private val summaryTabs = mutableListOf<SummaryTab>()
+    private var showCosmeticItem = false
     private var mainScreenIndex = INFO
     var sideScreenIndex = PARTY
     private val party = ArrayList(party)
@@ -173,38 +176,43 @@ class Summary private constructor(party: Collection<Pokemon?>, private val edita
         )
 
         //Item Visibility Button
-        val hideHeldItemBtn = SummaryButton(
-            buttonX = x + 22f,
-            buttonY = y + 101f,
-            buttonWidth = 13,
-            buttonHeight = 9,
+        val HeldItemVisibilityButton = SummaryButton(
+            buttonX = x + 3F,
+            buttonY = y + 104F,
+            buttonWidth = 32,
+            buttonHeight = 32,
+            scale = 0.5F,
+            resource = itemVisibleResource,
+            activeResource = itemHiddenResource,
             clickAction = {
-                selectedPokemon.heldItemVisible=!selectedPokemon.heldItemVisible
+                selectedPokemon.heldItemVisible = !selectedPokemon.heldItemVisible
+                (it as SummaryButton).buttonActive = !selectedPokemon.heldItemVisible
                 modelWidget.heldItem = if (selectedPokemon.heldItemVisible) selectedPokemon.heldItem else null
                 // Send item visibility update to server
-                sendToServer(
-                    SetItemHiddenPacket(
-                        selectedPokemon.uuid,
-                        selectedPokemon.heldItemVisible
-                    )
-                )
+                sendToServer(SetItemHiddenPacket(selectedPokemon.uuid, selectedPokemon.heldItemVisible))
             },
-            resource = itemVisibleResource,
-            renderRequirement = { selectedPokemon.heldItemVisible },
-            clickRequirement = { true },
+            renderRequirement = { !selectedPokemon.heldItemNoCopy().isEmpty && !showCosmeticItem },
+            clickRequirement = { !selectedPokemon.heldItemNoCopy().isEmpty && !showCosmeticItem }
         )
-        val showHeldItemBtn = SummaryButton(
-            buttonX = x + 22f,
-            buttonY = y + 101f,
-            buttonWidth = 13,
-            buttonHeight = 9,
-            clickAction = { },
-            resource = itemHiddenResource,
-            renderRequirement = { !selectedPokemon.heldItemVisible },
-            clickRequirement = { false },
+
+        addRenderableWidget(HeldItemVisibilityButton)
+
+        // Held/Cosmetic Item Button
+        addRenderableWidget(
+            SummaryButton(
+                buttonX = x + 67F,
+                buttonY = y + 113F,
+                buttonWidth = 12,
+                buttonHeight = 12,
+                scale = 0.5F,
+                resource = iconCosmeticItemResource,
+                activeResource = iconHeldItemResource,
+                clickAction = {
+                    showCosmeticItem = !showCosmeticItem
+                    (it as SummaryButton).buttonActive = showCosmeticItem
+                }
+            )
         )
-        addRenderableWidget(showHeldItemBtn)
-        addRenderableWidget(hideHeldItemBtn)
 
         // Init Tabs
         summaryTabs.clear()
@@ -581,19 +589,19 @@ class Summary private constructor(party: Collection<Pokemon?>, private val edita
             scale = SCALE
         )
 
-        // Held Item
-        val heldItem = selectedPokemon.heldItemNoCopy()
+        // Held/Cosmetic Item
+        val displayedItem = if (showCosmeticItem) selectedPokemon.cosmeticItem else selectedPokemon.heldItemNoCopy()
         val itemX = x + 3
         val itemY = y + 104
-        if (!heldItem.isEmpty) {
-            context.renderItem(heldItem, itemX, itemY)
-            context.renderItemDecorations(Minecraft.getInstance().font, heldItem, itemX, itemY)
+        if (!displayedItem.isEmpty) {
+            context.renderItem(displayedItem, itemX, itemY)
+            context.renderItemDecorations(Minecraft.getInstance().font, displayedItem, itemX, itemY)
         }
 
         drawScaledText(
             context = context,
-            text = lang("held_item"),
-            x = x + 27,
+            text = lang("${if (showCosmeticItem) "cosmetic" else "held"}_item"),
+            x = x + 24,
             y = y + 114.5,
             scale = SCALE
         )
@@ -616,14 +624,19 @@ class Summary private constructor(party: Collection<Pokemon?>, private val edita
             scale = SCALE
         )
 
+        matrices.pushPose()
+        // Prevent widgets from being overlapped by other components
+        matrices.translate(0.0, 0.0, 1000.0)
+
         // Render all added Widgets
         super.render(context, mouseX, mouseY, delta)
 
         // Render Item Tooltip
-        if (!heldItem.isEmpty) {
+        if (!displayedItem.isEmpty) {
             val itemHovered = mouseX.toFloat() in (itemX.toFloat()..(itemX.toFloat() + 16)) && mouseY.toFloat() in (itemY.toFloat()..(itemY.toFloat() + 16))
-            if (itemHovered) context.renderTooltip(Minecraft.getInstance().font, heldItem, mouseX, mouseY)
+            if (itemHovered) context.renderTooltip(Minecraft.getInstance().font, displayedItem, mouseX, mouseY)
         }
+        matrices.popPose()
     }
 
     /**

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

@@ -38,7 +38,8 @@ class SummaryButton(
     private val silent: Boolean = false,
     private val boldText: Boolean = true,
     private val largeText: Boolean = true,
-    private val textScale: Float = 1F
+    private val textScale: Float = 1F,
+    private val scale: Float = 1F
 ): Button(buttonX.toInt(), buttonY.toInt(), buttonWidth.toInt(), buttonHeight.toInt(), text, clickAction, DEFAULT_NARRATION), CobblemonRenderable {
 
     companion object {
@@ -62,12 +63,13 @@ class SummaryButton(
         blitk(
             matrixStack = matrices,
             texture = if (buttonActive && activeResource != null) activeResource else resource,
-            x = buttonX,
-            y = buttonY,
+            x = buttonX / scale,
+            y = buttonY / scale,
             width = buttonWidth,
             height = buttonHeight,
-            vOffset = if (hoverTexture && isHovered) buttonHeight else 0,
+            vOffset = if (hoverTexture && isButtonHovered(pMouseX, pMouseY)) buttonHeight else 0,
             textureHeight = if (hoverTexture) (buttonHeight.toFloat() * 2) else buttonHeight,
+            scale = scale
         )
 
         // Render Text
@@ -84,7 +86,7 @@ class SummaryButton(
     }
 
     override fun mouseClicked(mouseX: Double, mouseY: Double, button: Int): Boolean {
-        if (this.clickRequirement.invoke(this)) {
+        if (this.clickRequirement.invoke(this) && isButtonHovered(mouseX, mouseY)) {
             super.mouseClicked(mouseX, mouseY, button)
         }
         return false
@@ -102,4 +104,9 @@ class SummaryButton(
         this.buttonX = x
         this.buttonY = y
     }
+
+    fun isButtonHovered(mouseX: Number, mouseY: Number): Boolean {
+        return mouseX.toFloat() in (buttonX..(buttonX + (buttonWidth.toFloat() * scale)))
+                && mouseY.toFloat() in (buttonY..(buttonY + (buttonHeight.toFloat() * scale)))
+    }
 }

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

@@ -15,6 +15,12 @@ import net.minecraft.client.Minecraft
 
 object InteractPokemonUIPacketHandler: ClientNetworkPacketHandler<InteractPokemonUIPacket> {
     override fun handle(packet: InteractPokemonUIPacket, client: Minecraft) {
-        client.setScreen(createPokemonInteractGui(packet.pokemonID, packet.canMountShoulder))
+        client.setScreen(createPokemonInteractGui(
+            packet.pokemonID,
+            packet.canMountShoulder,
+            packet.canGiveHeld,
+            packet.canGiveCosmetic,
+            packet.canRide
+        ))
     }
 }

common/src/main/kotlin/com/cobblemon/mod/common/client/render/item/HeldItemRenderer.kt

@@ -28,7 +28,6 @@ class HeldItemRenderer() {
     private val itemRenderer = Minecraft.getInstance().itemRenderer
     private var displayContext = ItemDisplayContext.FIXED
     private var scale = 1.0f
-    private var prevItem = ItemStack.EMPTY
 
     fun render(
         entity: PokemonEntity?,
@@ -40,26 +39,24 @@ class HeldItemRenderer() {
         seed: Int
     ) {
         if (item.isEmpty) return
-        val locatorName: String
+        displayContext = ItemDisplayContext.FIXED
 
         poseStack.pushPose()
         when {
             (locators.containsKey("item_face") && item.`is`(WEARABLE_FACE_ITEMS)) -> {
-                locatorName="item_face"
                 displayContext = ItemDisplayContext.HEAD
                 poseStack.mulPose(locators["item_face"]!!.matrix)
                 poseStack.translate(0f, 0f, .28f * scale)
                 poseStack.scale(0.7f * scale, 0.7f * scale, 0.7f * scale)
             }
             (locators.containsKey("item_hat") && item.`is`(WEARABLE_HAT_ITEMS)) -> {
-                locatorName="item_hat"
                 displayContext = ItemDisplayContext.HEAD
                 poseStack.mulPose(locators["item_hat"]!!.matrix)
                 poseStack.translate(0f, -0.26f * scale, 0f)
                 poseStack.scale(.68f * scale, .68f * scale, .68f * scale)
             }
             (locators.containsKey("item")) -> {
-                locatorName="item"
+                updateModifiers("item",locators)
                 poseStack.mulPose(locators["item"]!!.matrix)
                 when(displayContext) {
                     ItemDisplayContext.FIXED -> {
@@ -83,11 +80,6 @@ class HeldItemRenderer() {
                 return
             }
         }
-        //Modifiers only need to be updated once if the item changes
-        if (!ItemStack.isSameItemSameComponents(prevItem, item)) {
-            updateModifiers(locatorName,locators)
-            prevItem=item
-        }
 
         itemRenderer.renderStatic(entity, item, displayContext, false, poseStack, buffer, null, light, OverlayTexture.NO_OVERLAY, seed)
         poseStack.popPose()

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

@@ -11,6 +11,7 @@ package com.cobblemon.mod.common.client.render.models.blockbench
 import com.bedrockk.molang.runtime.MoLangRuntime
 import com.bedrockk.molang.runtime.struct.QueryStruct
 import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.Rollable
 import com.cobblemon.mod.common.api.molang.ExpressionLike
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.addFunctions
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.setup
@@ -50,8 +51,11 @@ import net.minecraft.client.renderer.MultiBufferSource
 import net.minecraft.client.renderer.RenderStateShard
 import net.minecraft.client.renderer.RenderType
 import net.minecraft.resources.ResourceLocation
+import net.minecraft.util.Mth
 import net.minecraft.world.entity.Entity
 import net.minecraft.world.phys.Vec3
+import org.joml.Matrix4f
+import org.joml.Vector3f
 
 /**
  * A model that can be posed and animated using [PoseAnimation]s and [ActiveAnimation]s. This
@@ -562,14 +566,16 @@ open class PosableModel(@Transient override val rootPart: Bone) : ModelFrame {
         applyPose(state, pose, 1F)
 
         val primaryAnimation = state.primaryAnimation
+        val shouldRotateHead = if(entity is PokemonEntity) entity.riding.shouldRotatePokemonHead(entity) else true
 
         // Quirks will run if there is no primary animation running and quirks are enabled for this context.
         if (primaryAnimation == null && context.request(RenderContext.DO_QUIRKS) != false) {
             // Remove any quirk animations that don't exist in our current pose
             state.quirks.keys.filterNot(pose.quirks::contains).forEach(state.quirks::remove)
+
             // Tick all the quirks
             pose.quirks.forEach {
-                it.apply(context, this, state, limbSwing, limbSwingAmount, ageInTicks, headYaw, headPitch, 1F)
+                it.apply(context, this, state, limbSwing, limbSwingAmount, ageInTicks, if(shouldRotateHead) headYaw else 0f, if(shouldRotateHead) headPitch else 0f, 1F)
             }
         }
 
@@ -577,6 +583,7 @@ open class PosableModel(@Transient override val rootPart: Bone) : ModelFrame {
             // The pose intensity is the complement of the primary animation's curve. This is used to blend the primary.
             state.poseIntensity = 1 - primaryAnimation.curve((state.animationSeconds - primaryAnimation.started) / primaryAnimation.duration)
             // If the primary animation is done after running we're going to clean things up.
+            //Set headYaw and headPitch to zero if Pokemon shouldn't move head during riding
             if (!primaryAnimation.run(
                     context,
                     this,
@@ -584,8 +591,8 @@ open class PosableModel(@Transient override val rootPart: Bone) : ModelFrame {
                     limbSwing,
                     limbSwingAmount,
                     ageInTicks,
-                    headYaw,
-                    headPitch,
+                    if(shouldRotateHead) headYaw else 0f,
+                    if(shouldRotateHead) headPitch else 0f,
                     1 - state.poseIntensity
                 )
             ) {
@@ -597,11 +604,11 @@ open class PosableModel(@Transient override val rootPart: Bone) : ModelFrame {
 
         // Run active animations and return back any that are done and can be removed.
         val removedActiveAnimations = state.activeAnimations.toList()
-            .filterNot { it.run(context, this, state, limbSwing, limbSwingAmount, ageInTicks, headYaw, headPitch, 1F) }
+            .filterNot { it.run(context, this, state, limbSwing, limbSwingAmount, ageInTicks, if(shouldRotateHead) headYaw else 0f, if(shouldRotateHead) headPitch else 0f, 1F) }
         state.activeAnimations.removeAll(removedActiveAnimations)
         // Applies the pose's animations.
         state.currentPose?.let(poses::get)
-            ?.apply(context, this, state, limbSwing, limbSwingAmount, ageInTicks, headYaw, headPitch)
+            ?.apply(context, this, state, limbSwing, limbSwingAmount, ageInTicks, if(shouldRotateHead) headYaw else 0f, if(shouldRotateHead) headPitch else 0f)
         // Updates the locator positions now that all the animations are in effect. This is the last thing we do!
         updateLocators(entity, state)
     }
@@ -673,24 +680,42 @@ open class PosableModel(@Transient override val rootPart: Bone) : ModelFrame {
         var scale = 1F
         // We could improve this to be generalized for other entities. First we'd have to figure out wtf is going on, though.
         if (entity is PokemonEntity) {
-            matrixStack.mulPose(Axis.YP.rotationDegrees(180 - entity.yBodyRot))
+            if(entity.passengers.isNotEmpty() && entity.controllingPassenger is Rollable && (entity.controllingPassenger as Rollable).orientation != null){
+                val controllingPassenger = entity.controllingPassenger
+                val transformationMatrix = Matrix4f()
+                val center = Vector3f(0f, entity.bbHeight/2, 0f)
+                transformationMatrix.translate(center)
+                transformationMatrix.mul(Matrix4f((controllingPassenger as Rollable).orientation!!))
+                transformationMatrix.translate(center.negate())
+                matrixStack.mulPose(transformationMatrix)
+            } else {
+                var yRot = Mth.lerp(state.getPartialTicks(), entity.yBodyRotO, entity.yBodyRot)
+                yRot = Mth.wrapDegrees(yRot)
+                matrixStack.mulPose(Axis.YP.rotationDegrees(180 - yRot))
+            }
             matrixStack.pushPose()
             matrixStack.scale(-1F, -1F, 1F)
             scale = entity.pokemon.form.baseScale * entity.pokemon.scaleModifier * (entity.delegate as PokemonClientDelegate).entityScaleModifier
             matrixStack.scale(scale, scale, scale)
         } else if (entity is EmptyPokeBallEntity) {
-            matrixStack.mulPose(Axis.YP.rotationDegrees(entity.yRot))
+            var yRot = Mth.lerp(state.getPartialTicks(), entity.yRot, entity.yRotO)
+            yRot = Mth.wrapDegrees(yRot)
+            matrixStack.mulPose(Axis.YP.rotationDegrees(yRot))
             matrixStack.pushPose()
             matrixStack.scale(1F, -1F, -1F)
             scale = 0.7F
             matrixStack.scale(scale, scale, scale)
         } else if (entity is GenericBedrockEntity) {
-            matrixStack.mulPose(Axis.YP.rotationDegrees(entity.yRot))
+            var yRot = Mth.lerp(state.getPartialTicks(), entity.yRot, entity.yRotO)
+            yRot = Mth.wrapDegrees(yRot)
+            matrixStack.mulPose(Axis.YP.rotationDegrees(yRot))
             matrixStack.pushPose()
             // Not 100% convinced we need the -1 on Y but if we needed it for the Poke Ball then probably?
             matrixStack.scale(1F, -1F, 1F)
         } else if (entity is NPCEntity) {
-            matrixStack.mulPose(Axis.YP.rotationDegrees(180 - entity.yBodyRot))
+            var yRot = Mth.lerp(state.getPartialTicks(), entity.yBodyRotO, entity.yBodyRot)
+            yRot = Mth.wrapDegrees(yRot)
+            matrixStack.mulPose(Axis.YP.rotationDegrees(180 - yRot))
             matrixStack.pushPose()
             matrixStack.scale(-1F, -1F, 1F)
         }

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

@@ -51,7 +51,7 @@ open class BedrockActiveAnimation(
         headPitch: Float,
         intensity: Float
     ): Boolean {
-        return animation.run(context, model, state, state.animationSeconds - startedSeconds, limbSwing, limbSwingAmount, ageInTicks, intensity).also {
+        return animation.run(model, state, state.animationSeconds - startedSeconds, limbSwing, limbSwingAmount, ageInTicks, intensity).also {
             if (!it) {
                 afterAction(context, state)
             }

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

@@ -14,15 +14,17 @@ import com.bedrockk.molang.runtime.value.DoubleValue
 import com.cobblemon.mod.common.api.molang.ExpressionLike
 import com.cobblemon.mod.common.api.snowstorm.BedrockParticleOptions
 import com.cobblemon.mod.common.client.particle.ParticleStorm
-import com.cobblemon.mod.common.client.render.MatrixWrapper
 import com.cobblemon.mod.common.client.render.models.blockbench.PosableModel
 import com.cobblemon.mod.common.client.render.models.blockbench.PosableState
+import com.cobblemon.mod.common.client.render.models.blockbench.pose.Bone
 import com.cobblemon.mod.common.client.render.models.blockbench.repository.RenderContext
 import com.cobblemon.mod.common.util.effectiveName
 import com.cobblemon.mod.common.util.genericRuntime
 import com.cobblemon.mod.common.util.getString
 import com.cobblemon.mod.common.util.math.geometry.toRadians
 import com.cobblemon.mod.common.util.resolveDouble
+import java.util.SortedMap
+import java.util.TreeMap
 import net.minecraft.CrashReport
 import net.minecraft.ReportedException
 import net.minecraft.client.Minecraft
@@ -33,8 +35,6 @@ import net.minecraft.resources.ResourceLocation
 import net.minecraft.sounds.SoundEvent
 import net.minecraft.world.entity.Entity
 import net.minecraft.world.phys.Vec3
-import org.joml.Matrix4f
-import java.util.*
 
 data class BedrockAnimationGroup(
     val formatVersion: String,
@@ -149,7 +149,40 @@ data class BedrockAnimation(
     /** Useful to have, gets set after loading the animation. */
     var name: String = ""
 
-    fun run(context: RenderContext, model: PosableModel, state: PosableState, animationSeconds: Float, limbSwing: Float, limbSwingAmount: Float, ageInTicks: Float, intensity: Float): Boolean {
+
+    fun run(
+        model: PosableModel,
+        state: PosableState,
+        animationSeconds: Float,
+        limbSwing: Float,
+        limbSwingAmount: Float,
+        ageInTicks: Float,
+        intensity: Float
+    ): Boolean {
+        return run(
+            model.context,
+            model.relevantPartsByName,
+            model.rootPart,
+            state,
+            animationSeconds,
+            limbSwing,
+            limbSwingAmount,
+            ageInTicks,
+            intensity
+        )
+    }
+
+    fun run(
+        context: RenderContext?,
+        relevantPartsByName: Map<String, ModelPart>,
+        rootPart: Bone?,
+        state: PosableState,
+        animationSeconds: Float,
+        limbSwing: Float,
+        limbSwingAmount: Float,
+        ageInTicks: Float,
+        intensity: Float
+    ): Boolean {
         var animationSeconds = animationSeconds
         if (shouldLoop) {
             animationSeconds %= animationLength.toFloat()
@@ -164,7 +197,7 @@ data class BedrockAnimation(
         runtime.environment.setSimpleVariable("age_in_ticks", DoubleValue(ageInTicks.toDouble()))
 
         boneTimelines.forEach { (boneName, timeline) ->
-            val part = model.relevantPartsByName[boneName] ?: if (boneName == "root_part") (model.rootPart as ModelPart) else null
+            val part = relevantPartsByName[boneName] ?: if (boneName == "root_part") (rootPart as? ModelPart) else null
             if (part !== null) {
                 if (!timeline.position.isEmpty()) {
                     val position = timeline.position.resolve(animationSeconds.toDouble(), runtime).scale(intensity.toDouble())
@@ -184,7 +217,7 @@ data class BedrockAnimation(
                             zRot += rotation.z.toFloat().toRadians()
                         }
                     } catch (e: Exception) {
-                        val exception = IllegalStateException("Bad animation for entity: ${(model.context.request(RenderContext.ENTITY))!!.effectiveName().string}", e)
+                        val exception = IllegalStateException("Bad animation for entity: ${(context?.request(RenderContext.ENTITY))?.effectiveName()?.string ?: "unknown entity (riding animation?)"}", e)
                         val crash = CrashReport("Cobblemon encountered an unexpected crash", exception)
                         val section = crash.addCategory("Animation Details")
                         section.setDetail("Pose", state.currentPose!!)

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

@@ -34,7 +34,7 @@ class BedrockPoseAnimation(val animation: BedrockAnimation) : PoseAnimation() {
     }
 
     override fun setupAnim(context: RenderContext, model: PosableModel, state: PosableState, limbSwing: Float, limbSwingAmount: Float, ageInTicks: Float, headYaw: Float, headPitch: Float, intensity: Float) {
-        animation.run(context, model, state, state.animationSeconds, limbSwing, limbSwingAmount, ageInTicks, intensity)
+        animation.run(model, state, state.animationSeconds, limbSwing, limbSwingAmount, ageInTicks, intensity)
     }
 
     override fun applyEffects(entity: Entity?, state: PosableState, previousSeconds: Float, newSeconds: Float) {

common/src/main/kotlin/com/cobblemon/mod/common/client/render/player/MountedPlayerRenderer.kt

@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.client.render.player
+
+import com.bedrockk.molang.runtime.value.DoubleValue
+import com.cobblemon.mod.common.Rollable
+import com.cobblemon.mod.common.api.riding.Rideable
+import com.cobblemon.mod.common.client.entity.PokemonClientDelegate
+import com.cobblemon.mod.common.client.render.models.blockbench.bedrock.animation.BedrockAnimationRepository
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.mojang.blaze3d.vertex.PoseStack
+import com.mojang.math.Axis
+import net.minecraft.client.model.geom.ModelPart
+import net.minecraft.client.player.AbstractClientPlayer
+import net.minecraft.util.Mth
+import net.minecraft.world.phys.Vec3
+import org.joml.Matrix4f
+import org.joml.Vector3f
+
+/**
+ * @author landonjw
+ */
+object MountedPlayerRenderer {
+    const val disableRollableRenderDebug: Boolean = false
+
+    fun render(player: AbstractClientPlayer, entity: PokemonEntity, stack: PoseStack, bob: Float, yBodyRot: Float, partialTicks: Float, i: Float) {
+        if(player.vehicle !is Rideable) return
+        val matrix = stack.last().pose()
+
+        val vehicle = player.vehicle as Rideable?
+        val entity = vehicle!!.riding.entity
+        val seatIndex = entity.passengers.indexOf(player)
+        val seat = entity.seats[seatIndex]
+        val delegate = entity.delegate as PokemonClientDelegate
+        val locator = delegate.locatorStates[seat.locator]
+
+        //Positions player
+        if (locator != null) {
+            val locatorOffset = locator.matrix.getTranslation(Vector3f())
+
+            val center = Vector3f(0f, entity.bbHeight/2, 0f)
+            val locatorOffsetToCenter = locatorOffset.sub(center, Vector3f())
+
+            val transformationMatrix = Matrix4f()
+            //if (player is Rollable && player.shouldRoll()){
+                //transformationMatrix.rotate(Axis.YP.rotationDegrees(-yBodyRot))
+                //transformationMatrix.mulLocal(player.orientation)
+            //}
+
+            val rotatedOffset = transformationMatrix.transformPosition(locatorOffsetToCenter, Vector3f()).add(center).sub(Vector3f(0f, player.bbHeight/2, 0f))
+            matrix.translate(rotatedOffset)
+
+            //Undo seat position
+            val playerPos = Vec3(
+                Mth.lerp(partialTicks.toDouble(), player.xOld, player.x),
+                Mth.lerp(partialTicks.toDouble(), player.yOld, player.y),
+                Mth.lerp(partialTicks.toDouble(), player.zOld, player.z),
+            )
+
+            val entityPos = Vec3(
+                Mth.lerp(partialTicks.toDouble(), entity.xOld, entity.x),
+                Mth.lerp(partialTicks.toDouble(), entity.yOld, entity.y),
+                Mth.lerp(partialTicks.toDouble(), entity.zOld, entity.z),
+            )
+
+            matrix.translate(playerPos.subtract(entityPos).toVector3f().negate())
+        }
+
+        //Rotates player
+        if (player is Rollable && player.shouldRoll() && !disableRollableRenderDebug) {
+            val center = Vector3f(0f, player.bbHeight / 2, 0f)
+            val transformationMatrix = Matrix4f()
+            transformationMatrix.translate(center)
+
+            transformationMatrix.mul(Matrix4f(player.orientation))
+
+            transformationMatrix.translate(center.negate(Vector3f()))
+            //Pre-Undo Yaw
+            transformationMatrix.rotate(Axis.YP.rotationDegrees(yBodyRot+180f))
+            matrix.mul(transformationMatrix)
+        }
+        matrix.translate(0f, 0.5f, 0f)
+    }
+
+    fun animate(
+        pokemonEntity: PokemonEntity,
+        player: AbstractClientPlayer,
+        relevantPartsByName: Map<String, ModelPart>,
+        headYaw: Float,
+        headPitch: Float,
+        ageInTicks: Float,
+        limbSwing: Float,
+        limbSwingAmount: Float
+    ) {
+        val seatIndex = pokemonEntity.passengers.indexOf(player).takeIf { it != -1 && it < pokemonEntity.seats.size } ?: return
+        val seat = pokemonEntity.seats[seatIndex]
+        val animations = seat.poseAnimations.firstOrNull { it.poseTypes.isEmpty() || it.poseTypes.contains(pokemonEntity.getCurrentPoseType()) }?.animations
+            ?: return
+        val state = pokemonEntity.delegate as PokemonClientDelegate
+
+        relevantPartsByName.values.forEach {
+            it.xRot = 0F
+            it.yRot = 0F
+            it.zRot = 0F
+        }
+
+        state.runtime.environment.setSimpleVariable("age_in_ticks", DoubleValue(ageInTicks.toDouble()))
+        state.runtime.environment.setSimpleVariable("limb_swing", DoubleValue(limbSwing.toDouble()))
+        state.runtime.environment.setSimpleVariable("limb_swing_amount", DoubleValue(limbSwingAmount.toDouble()))
+
+        // TODO add the q.player reference, requires a cached thing or something on the client idk
+
+        for (animation in animations) {
+            val bedrockAnimation = BedrockAnimationRepository.getAnimationOrNull(animation.fileName, animation.animationName) ?: continue
+            bedrockAnimation.run(
+                context = null,
+                relevantPartsByName = relevantPartsByName,
+                rootPart = null,
+                state = state,
+                animationSeconds = state.animationSeconds,
+                limbSwing = limbSwing,
+                limbSwingAmount = limbSwingAmount,
+                ageInTicks = ageInTicks,
+                intensity = 1F
+            )
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/pokemon/PokemonRenderer.kt

@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.client.render.pokemon
 
 import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.Rollable
 import com.cobblemon.mod.common.api.pokedex.PokedexEntryProgress
 import com.cobblemon.mod.common.client.CobblemonClient
 import com.cobblemon.mod.common.client.battle.ClientBallDisplay
@@ -56,10 +57,7 @@ import net.minecraft.resources.ResourceLocation
 import net.minecraft.util.Mth
 import net.minecraft.world.entity.Entity
 import net.minecraft.world.phys.Vec3
-import org.joml.Math
-import org.joml.Quaternionf
-import org.joml.Vector3f
-import org.joml.Vector4f
+import org.joml.*
 import kotlin.math.*
 
 class PokemonRenderer(
@@ -81,6 +79,7 @@ class PokemonRenderer(
 
         private const val SPACE = " "
 
+        private const val DISABLE_ROLLING_DEBUG = false
     }
 
     val ballContext = RenderContext().also {
@@ -143,7 +142,12 @@ class PokemonRenderer(
         modelNow.setLayerContext(buffer, clientDelegate, VaryingModelRepository.getLayers(entity.pokemon.species.resourceIdentifier, clientDelegate))
 
 
-        super.render(entity, entityYaw, partialTicks, poseMatrix, buffer, packedLight)
+        if (entity.passengers.isNotEmpty()) {
+            renderRiding(entity, partialTicks, poseMatrix, buffer, packedLight)
+        }
+        else {
+            super.render(entity, entityYaw, partialTicks, poseMatrix, buffer, packedLight)
+        }
 
         modelNow.green = 1F
         modelNow.blue = 1F
@@ -163,6 +167,38 @@ class PokemonRenderer(
         )
     }
 
+    fun renderRiding(
+        entity: PokemonEntity,
+        partialTicks: Float,
+        poseMatrix: PoseStack,
+        buffer: MultiBufferSource,
+        packedLight: Int
+    ) {
+        val driver = entity.firstPassenger ?: return
+        val rollable = driver as? Rollable ?: return
+
+        poseMatrix.pushPose()
+
+        if(!DISABLE_ROLLING_DEBUG && rollable.shouldRoll()){
+            val matrix = poseMatrix.last().pose()
+            val yaw = Mth.rotLerp(partialTicks, entity.yBodyRotO, entity.yBodyRot)
+            val center = Vector3f(0f, entity.bbHeight/2, 0f)
+            val transformationMatrix = Matrix4f()
+            //Move origin to center of Pokemon
+            transformationMatrix.translate(center)
+            transformationMatrix.mul(Matrix4f(rollable.orientation))
+            //Move origin to base of the entity
+            transformationMatrix.translate(center.negate(Vector3f()))
+
+            //Pre-undo yaw rotation
+            transformationMatrix.rotate(Axis.YP.rotationDegrees(yaw+180f))
+            matrix.mul(transformationMatrix)
+        }
+
+        super.render(entity, 0f, partialTicks, poseMatrix, buffer, packedLight)
+        poseMatrix.popPose()
+    }
+
     fun renderTransition(
         modelNow: PosableModel,
         beamMode: Int,
@@ -468,4 +504,4 @@ class PokemonRenderer(
 
         matrixStack.popPose()
     }
-}
+}

common/src/main/kotlin/com/cobblemon/mod/common/config/CobblemonConfig.kt

@@ -11,6 +11,7 @@ package com.cobblemon.mod.common.config
 import com.cobblemon.mod.common.api.drop.ItemDropMethod
 import com.cobblemon.mod.common.api.pokeball.catching.calculators.CaptureCalculator
 import com.cobblemon.mod.common.api.pokemon.status.Statuses
+import com.cobblemon.mod.common.client.gui.portrait.PortraitStyle
 import com.cobblemon.mod.common.config.constraint.IntConstraint
 import com.cobblemon.mod.common.pokeball.catching.calculators.CobblemonCaptureCalculator
 import com.cobblemon.mod.common.util.adapters.CaptureCalculatorAdapter
@@ -255,6 +256,9 @@ class CobblemonConfig {
     @CobblemonConfigField(Category.Interface, lang = "summary_pokemon_follow_cursor")
     var summaryPokemonFollowCursor = true
 
+    @CobblemonConfigField(Category.Interface, lang = "party_portrait_animations")
+    var partyPortraitAnimations = PortraitStyle.NEVER_ANIMATE
+
     @CobblemonConfigField(Category.Debug, lang = "enable_debug_keys")
     var enableDebugKeys = false
 

common/src/main/kotlin/com/cobblemon/mod/common/data/CobblemonDataProvider.kt

@@ -10,6 +10,7 @@ package com.cobblemon.mod.common.data
 
 import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.Cobblemon.LOGGER
+import com.cobblemon.mod.common.CobblemonCosmeticItems
 import com.cobblemon.mod.common.CobblemonFlows
 import com.cobblemon.mod.common.CobblemonBrainConfigs
 import com.cobblemon.mod.common.CobblemonMechanics
@@ -92,6 +93,7 @@ object CobblemonDataProvider : DataProvider {
         this.register(DexEntryAdditions)
         this.register(Dexes)
         this.register(DexAdditions)
+        this.register(CobblemonCosmeticItems)
         this.register(CobblemonFlows)
 
         CobblemonSpawnPools.load()

common/src/main/kotlin/com/cobblemon/mod/common/entity/PoseType.kt

@@ -8,7 +8,9 @@
 
 package com.cobblemon.mod.common.entity
 
-import java.util.EnumSet
+import com.cobblemon.mod.common.util.cobblemonResource
+import java.util.*
+import net.minecraft.resources.ResourceLocation
 
 /**
  * The type of a pose. Used for normalizing pose swapping for all models.
@@ -46,5 +48,11 @@ enum class PoseType {
         val UI_POSES = EnumSet.of(PROFILE, PORTRAIT)
         val MOVING_POSES = EnumSet.of(WALK, SWIM, FLY)
         val STATIONARY_POSES = EnumSet.of(STAND, FLOAT, HOVER)
+
+        fun identified() : List<ResourceLocation> {
+            return ALL_POSES.stream()
+                .map { cobblemonResource(it.name.lowercase(Locale.getDefault())) }
+                .toList()
+        }
     }
 }

common/src/main/kotlin/com/cobblemon/mod/common/entity/pokeball/EmptyPokeBallEntity.kt

@@ -103,7 +103,7 @@ class EmptyPokeBallEntity : ThrowableItemProjectile, PosableEntity, WaterDragMod
     var capturingPokemon: PokemonEntity? = null
     val captureFuture = CompletableFuture<Boolean>()
     var captureState: CaptureState
-        get() = CaptureState.values()[entityData.get(CAPTURE_STATE).toInt()]
+        get() = CaptureState.entries[entityData.get(CAPTURE_STATE).toInt()]
         set(value) { entityData.set(CAPTURE_STATE, value.ordinal.toByte()) }
     var aspects: Set<String>
         get() = entityData.get(ASPECTS)

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

@@ -8,11 +8,10 @@
 
 package com.cobblemon.mod.common.entity.pokemon
 
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.CobblemonEntities
-import com.cobblemon.mod.common.CobblemonItems
+import com.cobblemon.mod.common.*
 import com.cobblemon.mod.common.CobblemonNetwork.sendPacket
 import com.cobblemon.mod.common.CobblemonSounds
+import com.cobblemon.mod.common.Rollable
 import com.cobblemon.mod.common.api.drop.DropTable
 import com.cobblemon.mod.common.api.entity.Despawner
 import com.cobblemon.mod.common.api.entity.PokemonSender
@@ -37,6 +36,10 @@ import com.cobblemon.mod.common.api.pokemon.feature.StringSpeciesFeature
 import com.cobblemon.mod.common.api.pokemon.status.Statuses
 import com.cobblemon.mod.common.api.reactive.ObservableSubscription
 import com.cobblemon.mod.common.api.reactive.SimpleObservable
+import com.cobblemon.mod.common.api.riding.Rideable
+import com.cobblemon.mod.common.api.riding.RidingManager
+import com.cobblemon.mod.common.api.riding.Seat
+import com.cobblemon.mod.common.api.riding.events.SelectDriverEvent
 import com.cobblemon.mod.common.api.scheduling.Schedulable
 import com.cobblemon.mod.common.api.scheduling.SchedulingTracker
 import com.cobblemon.mod.common.api.scheduling.afterOnServer
@@ -80,8 +83,14 @@ import com.cobblemon.mod.common.pokemon.evolution.variants.ItemInteractionEvolut
 import com.cobblemon.mod.common.pokemon.feature.StashHandler
 import com.cobblemon.mod.common.pokemon.properties.UncatchableProperty
 import com.cobblemon.mod.common.util.*
+import com.cobblemon.mod.common.util.math.geometry.toRadians
 import com.cobblemon.mod.common.world.gamerules.CobblemonGameRules
 import com.mojang.serialization.Codec
+import java.util.EnumSet
+import java.util.Optional
+import java.util.UUID
+import java.util.concurrent.CompletableFuture
+import kotlin.math.PI
 import net.minecraft.core.BlockPos
 import net.minecraft.core.registries.BuiltInRegistries
 import net.minecraft.core.registries.Registries
@@ -112,7 +121,15 @@ import net.minecraft.world.InteractionResult
 import net.minecraft.world.damagesource.DamageSource
 import net.minecraft.world.damagesource.DamageTypes
 import net.minecraft.world.effect.MobEffects
-import net.minecraft.world.entity.*
+import net.minecraft.world.entity.AgeableMob
+import net.minecraft.world.entity.Entity
+import net.minecraft.world.entity.EntityDimensions
+import net.minecraft.world.entity.EntityType
+import net.minecraft.world.entity.EquipmentSlot
+import net.minecraft.world.entity.ExperienceOrb
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.Pose
+import net.minecraft.world.entity.Shearable
 import net.minecraft.world.entity.ai.attributes.AttributeSupplier
 import net.minecraft.world.entity.ai.attributes.Attributes
 import net.minecraft.world.entity.ai.control.MoveControl
@@ -130,16 +147,17 @@ import net.minecraft.world.level.gameevent.GameEvent
 import net.minecraft.world.level.material.FluidState
 import net.minecraft.world.level.pathfinder.PathType
 import net.minecraft.world.phys.AABB
+import net.minecraft.world.phys.Vec2
 import net.minecraft.world.phys.Vec3
-import java.util.*
-import java.util.concurrent.CompletableFuture
+import org.joml.Matrix3f
+import org.joml.Vector3f
 
 @Suppress("unused")
 open class PokemonEntity(
     world: Level,
     pokemon: Pokemon = Pokemon().apply { isClient = world.isClientSide },
     type: EntityType<out PokemonEntity> = CobblemonEntities.POKEMON,
-) : ShoulderRidingEntity(type, world), PosableEntity, Shearable, Schedulable, ScannableEntity {
+) : ShoulderRidingEntity(type, world), PosableEntity, Shearable, Schedulable, Rideable, ScannableEntity {
     companion object {
         @JvmStatic val SPECIES = SynchedEntityData.defineId(PokemonEntity::class.java, EntityDataSerializers.STRING)
         @JvmStatic val NICKNAME = SynchedEntityData.defineId(PokemonEntity::class.java, EntityDataSerializers.COMPONENT)
@@ -168,7 +186,7 @@ open class PokemonEntity(
         const val BATTLE_LOCK = "battle"
         const val EVOLUTION_LOCK = "evolving"
 
-        fun createAttributes(): AttributeSupplier.Builder = LivingEntity.createLivingAttributes()
+        fun createAttributes(): AttributeSupplier.Builder = createLivingAttributes()
             .add(Attributes.FOLLOW_RANGE)
             .add(Attributes.ATTACK_KNOCKBACK)
     }
@@ -218,6 +236,8 @@ open class PokemonEntity(
         get() = entityData.get(BATTLE_ID).isPresent
     val friendship: Int
         get() = entityData.get(FRIENDSHIP)
+    val seats: List<Seat>
+        get() = form.riding.seats
 
     var shownItem: ItemStack
         get() = entityData.get(SHOWN_HELD_ITEM)
@@ -227,10 +247,13 @@ open class PokemonEntity(
 
     var tethering: PokemonPastureBlockEntity.Tethering? = null
 
+    // TODO review if we still want this
     var queuedToDespawn = false
 
     var enablePoseTypeRecalculation = true
 
+    override val riding: RidingManager = RidingManager(this)
+
     /**
      * The amount of steps this entity has traveled.
      */
@@ -288,7 +311,6 @@ open class PokemonEntity(
             .addPokemonEntityFunctions(this)
     }
 
-
     init {
         delegate.initialize(this)
         delegate.changePokemon(pokemon)
@@ -335,7 +357,7 @@ open class PokemonEntity(
             SPECIES -> refreshDimensions()
             POSE_TYPE -> {
                 val value = entityData.get(data) as PoseType
-                if (value == PoseType.FLY || value == PoseType.HOVER) {
+                if ((value == PoseType.FLY || value == PoseType.HOVER) && passengers.isEmpty()) {
                     setNoGravity(true)
                 } else {
                     setNoGravity(false)
@@ -445,6 +467,9 @@ open class PokemonEntity(
             this.tethering = null
             this.pokemon.recall()
         }
+
+        jumping = false
+
         //This is so that pokemon in the pasture block are ALWAYS in sync with the pokemon box
         //Before, pokemon entities in pastures would hold an old ref to a pokemon obj and changes to that would not appear to the underlying file
         if (this.tethering != null && age % 20 == 0) {
@@ -517,10 +542,6 @@ open class PokemonEntity(
         return super.isInvulnerableTo(damageSource)
     }
 
-    override fun canRide(vehicle: Entity): Boolean {
-        return platform == PlatformType.NONE && super.canRide(vehicle)
-    }
-
     /**
      * A utility method that checks if this Pokémon has the [UncatchableProperty.uncatchable] property.
      *
@@ -922,10 +943,15 @@ open class PokemonEntity(
         }
 
         if (hand == InteractionHand.MAIN_HAND && player is ServerPlayer && pokemon.getOwnerPlayer() == player) {
+            val cosmeticItemDefinition = CobblemonCosmeticItems.findValidCosmeticForPokemonAndItem(player.level().registryAccess(), pokemon, itemStack)
             if (player.isShiftKeyDown) {
-                InteractPokemonUIPacket(this.getUUID(), canSitOnShoulder() && pokemon in player.party()).sendToPlayer(
-                    player
-                )
+                InteractPokemonUIPacket(
+                    this.getUUID(),
+                    canSitOnShoulder() && pokemon in player.party(),
+                    !(pokemon.heldItemNoCopy().isEmpty && itemStack.isEmpty),
+                    (!pokemon.cosmeticItem.isEmpty && itemStack.isEmpty) || cosmeticItemDefinition != null,
+                    this.canRide(player) && pokemon.riding.canRide
+                ).sendToPlayer(player)
             } else {
                 // TODO #105
                 if (this.attemptItemInteraction(player, player.getItemInHand(hand))) return InteractionResult.SUCCESS
@@ -1094,37 +1120,56 @@ open class PokemonEntity(
     }
 
     fun offerHeldItem(player: Player, stack: ItemStack): Boolean {
+        return offerItem(player, stack, isCosmetic = false)
+    }
+
+    fun offerCosmeticItem(player: Player, stack: ItemStack): Boolean {
+        return offerItem(player, stack, isCosmetic = true)
+    }
+
+    fun offerItem(
+        player: Player,
+        stack: ItemStack,
+        isCosmetic: Boolean
+    ): Boolean {
         if (player !is ServerPlayer || this.isBusy || this.pokemon.getOwnerPlayer() != player) {
             return false
         }
 
-        if (!stack.isEmpty && (isBlacklisted(stack) || !isWhitelisted(stack))) {
+        if (!stack.isEmpty && !isCosmetic && (isBlacklisted(stack) || !isWhitelisted(stack))) {
             player.sendSystemMessage(lang("held_item.forbidden", stack.hoverName, this.pokemon.getDisplayName()))
             return false
         }
 
-        // We want the count of 1 in order to match the ItemStack#areEqual
+        val possibleReturn = if (isCosmetic) this.pokemon.cosmeticItem.copy() else this.pokemon.heldItemNoCopy()
         val giving = stack.copy().apply { count = 1 }
-        val possibleReturn = this.pokemon.heldItemNoCopy()
-        if (stack.isEmpty && possibleReturn.isEmpty) {
+
+        if (ItemStack.isSameItem(giving, possibleReturn)) {
+            val message = if (isCosmetic) {
+                lang("cosmetic_item.already_wearing", this.pokemon.getDisplayName(), stack.hoverName)
+            } else {
+                lang("held_item.already_holding", this.pokemon.getDisplayName(), stack.hoverName)
+            }
+            player.sendSystemMessage(message)
             return false
         }
 
-        if (ItemStack.isSameItem(giving, possibleReturn)) {
-            player.sendSystemMessage(lang("held_item.already_holding", this.pokemon.getDisplayName(), stack.hoverName))
-            return true
+        val returned = if (isCosmetic) {
+            this.pokemon.swapCosmeticItem(stack = stack, decrement = !player.isCreative)
+        } else {
+            this.pokemon.swapHeldItem(stack = stack, decrement = !player.isCreative)
         }
 
-        val returned = this.pokemon.swapHeldItem(stack = stack, decrement = !player.isCreative)
         val text = when {
-            giving.isEmpty -> lang("held_item.take", returned.hoverName, this.pokemon.getDisplayName())
-            returned.isEmpty -> lang("held_item.give", this.pokemon.getDisplayName(), giving.hoverName)
-            else -> lang("held_item.replace", returned.hoverName, this.pokemon.getDisplayName(), giving.hoverName)
+            isCosmetic && giving.isEmpty -> lang("cosmetic_item.take", returned.hoverName, this.pokemon.getDisplayName())
+            isCosmetic && returned.isEmpty -> lang("cosmetic_item.give", this.pokemon.getDisplayName(), returned.hoverName)
+            !isCosmetic && giving.isEmpty -> lang("held_item.take", returned.hoverName, this.pokemon.getDisplayName())
+            !isCosmetic && returned.isEmpty -> lang("held_item.give", this.pokemon.getDisplayName(), returned.hoverName)
+            isCosmetic -> lang("cosmetic_item.replace", returned.hoverName, this.pokemon.getDisplayName(), returned.hoverName)
+            else -> lang("held_item.replace", returned.hoverName, this.pokemon.getDisplayName(), returned.hoverName)
         }
 
-        player.giveOrDropItemStack(returned)
         player.sendSystemMessage(text)
-
         this.level().playSoundServer(
             position = this.position(),
             sound = SoundEvents.ITEM_PICKUP,
@@ -1420,7 +1465,7 @@ open class PokemonEntity(
 
     /**
      * If this Pokémon has a nickname, then the nickname is returned.
-     * Otherwise, [getDefaultName] is returned
+     * Otherwise, [getDisplayName] is returned
      *
      * @return The current display name of this entity.
      */
@@ -1453,8 +1498,7 @@ open class PokemonEntity(
      *
      * @return If the backing [pokemon] has a non-null [Pokemon.nickname].
      */
-    override fun hasCustomName(): Boolean =
-        pokemon.nickname != null && pokemon.nickname?.contents != PlainTextContents.EMPTY
+    override fun hasCustomName(): Boolean = pokemon.nickname != null && pokemon.nickname?.contents != PlainTextContents.EMPTY
 
     /**
      * This method toggles the visibility of the entity name,
@@ -1560,24 +1604,17 @@ open class PokemonEntity(
     }
 
     override fun stopSeenByPlayer(player: ServerPlayer) {
-        if (player == null) {
-            return
-        }
-
         if (this.ownerUUID == player.uuid && tethering == null) {
-            queuedToDespawn = true
+            // queuedToDespawn = true
+            this.remove(RemovalReason.DISCARDED)
             return
         }
-//
-//            val chunkPos = ChunkPos(BlockPos(x.toInt(), y.toInt(), z.toInt()))
-//            (world as ServerWorld).chunkManager
-//                .addTicket(ChunkTicketType.POST_TELEPORT, chunkPos, 0, id)
-//            this.goalSelector.tick()
-//            if(distanceTo(player.blockPos) > 100) pokemon.recall()
-//        }
     }
 
     override fun canBeLeashed() = true
+//    override fun canBeLeashedBy(player: Player): Boolean {
+//        return this.ownerUuid == null || this.ownerUuid == player.uuid
+//    }
 
     override fun setLeashedTo(entity: Entity, bl: Boolean) {
         super.setLeashedTo(entity, bl)
@@ -1596,6 +1633,192 @@ open class PokemonEntity(
      */
     private fun createSidedPokemon(): Pokemon = Pokemon().apply { isClient = this@PokemonEntity.level().isClientSide }
 
+    override fun canRide(entity: Entity): Boolean {
+        return platform == PlatformType.NONE && super.canRide(entity)
+    }
+
+    override fun canAddPassenger(passenger: Entity): Boolean {
+        return passengers.size < seats.size
+    }
+
+    fun getIsJumping() = jumping
+    fun setIsJumping(value: Boolean) {
+        jumping = value
+    }
+
+    override fun tickRidden(driver: Player, movementInput: Vec3) {
+        super.tickRidden(driver, movementInput)
+        this.riding.tick(this, driver, movementInput)
+        val rotation = this.getControlledRotation(driver)
+        setRot(rotation.y, rotation.x)
+        this.yHeadRot = this.yRot
+        this.yBodyRot = this.yRot
+        this.yRotO = this.yRot
+
+        if (this.riding.canJump(this, driver)) {
+            if (this.onGround()) {
+                if (this.jumpInputStrength > 0) {
+//                this.jump(this.jumpStrength, movementInput)
+//                this.jump()
+                    val f = PI.toFloat() - this.yRot * PI.toFloat() / 180
+                    val jumpVector = riding.jumpVelocity(this, driver, this.jumpInputStrength)
+                    val velocity = jumpVector.yRot(f)
+                    // Rotate the jump vector f degrees around the Y axis
+//                val velocity = Vec3d(-sin(f) * jumpVector.x, jumpVector.y, cos(f) * jumpVector.z)
+
+                    this.addDeltaMovement(velocity)
+                    hasImpulse = true
+                    jumping = false
+                }
+
+                this.jumpInputStrength = 0
+            }
+        }
+
+//        val lookAngle: Vec3 = driver.getLookAngle()
+//        if (!driver.isNearGround() || lookAngle.y >= 0.3) {
+//            setBehaviourFlag(PokemonBehaviourFlag.FLYING, true)
+//            entityData.set(POSE_TYPE, PoseType.HOVER)
+//
+//            val deltaMovement = this.deltaMovement
+//            this.setDeltaMovement(
+//                lookAngle.x * 0.1 + (lookAngle.x * 1.5 - deltaMovement.x) * 1,
+//                lookAngle.y * 0.1 + (lookAngle.y * 1.5 - deltaMovement.y) * 1,
+//                lookAngle.z * 0.1 + (lookAngle.z * 1.5 - deltaMovement.z) * 1
+//            )
+//        }
+//        else {
+//            setBehaviourFlag(PokemonBehaviourFlag.FLYING, false)
+//            this.setDeltaMovement(0.0, 0.0, 0.0)
+//        }
+    }
+
+    fun Entity.isNearGround(): Boolean {
+        val blockBelow: BlockPos = this.blockPosition().below()
+        return this.level().getBlockState(blockBelow).isSolid()
+    }
+
+//    override fun jump() {
+////        val vec3d = this.velocity
+////
+////
+////
+////        this.setVelocity(vec3d.x, this.jumpVelocity.toDouble(), vec3d.z)
+////        if (this.isSprinting) {
+////            val f = this.yaw * 0.017453292f
+////            this.velocity =
+////                velocity.add((-MathHelper.sin(f) * 0.2f).toDouble(), 0.0, (MathHelper.cos(f) * 0.2f).toDouble())
+////        }
+////
+////        this.velocityDirty = true
+//    }
+
+    private fun getControlledRotation(controller: LivingEntity): Vec2 {
+        return this.riding.controlledRotation(this, controller as Player)
+    }
+
+    override fun onPassengerTurned(entityToUpdate: Entity) {
+        return this.riding.clampPassengerRotation(this, entityToUpdate as? LivingEntity ?: return)
+    }
+
+    override fun positionRider(passenger: Entity, positionUpdater: MoveFunction) {
+        if (this.hasPassenger(passenger)) {
+            val index = this.passengers.indexOf(passenger).takeIf { it >= 0 && it < this.seats.size } ?: return
+            val seat = this.seats[index]
+            val seatOffset = seat.getOffset(this.getCurrentPoseType()).toVector3f()
+            val center = Vector3f(0f, this.bbHeight/2, 0f)
+
+            val seatToCenter = center.sub(seatOffset, Vector3f())
+            val matrix = (this.passengers.first() as Rollable).orientation ?: Matrix3f().rotate((180f-passenger.yRot).toRadians(), Vector3f(0f, 1f, 0f))
+            val rotatedOffset = matrix.transform(seatToCenter, Vector3f()).add(center).sub(Vector3f(0f, passenger.bbHeight/2, 0f))
+
+            positionUpdater.accept(passenger, this.x + rotatedOffset.x, this.y + rotatedOffset.y, this.z + rotatedOffset.z)
+            if (passenger is LivingEntity) {
+                this.riding.updatePassengerRotation(this, passenger)
+                this.riding.clampPassengerRotation(this, passenger)
+            }
+        }
+    }
+
+    override fun getControllingPassenger(): LivingEntity? {
+        val riders = this.passengers.filterIsInstance<LivingEntity>()
+        if (riders.isEmpty()) {
+            riding.states.clear()
+            return null
+        }
+
+        val event = SelectDriverEvent(riders.toSet())
+        val owner = riders.find { it.uuid == ownerUUID }
+        if (owner != null) {
+            event.suggest(owner, 0)
+        }
+
+        CobblemonEvents.SELECT_DRIVER.emit(event)
+        return event.result()
+    }
+
+    override fun getDismountLocationForPassenger(passenger: LivingEntity): Vec3 {
+//        val seat = this.riding.seats.firstOrNull { it.occupant() == passenger }
+//        seat?.dismount()
+        return super.getDismountLocationForPassenger(passenger)
+    }
+
+    override fun getRiddenInput(controller: Player, movementInput: Vec3): Vec3 {
+        return this.riding.velocity(this, controller, movementInput)
+    }
+
+    override fun getRiddenSpeed(controller: Player): Float {
+        return this.riding.speed(this, controller)
+    }
+
+    var jumpInputStrength: Int = 0 // move this
+    override fun onPlayerJump(strength: Int) {
+        // See if this controls the hot bar element
+        var strength = strength
+        if (strength < 0) {
+            strength = 0
+        } else {
+//            this.jumping = true
+            // update anger? hunwah
+        }
+
+        this.jumpInputStrength = strength
+
+        if (strength >= 90) {
+//            this.jumpStrength = 1.0f
+        } else {
+//            this.jumpStrength = 0.4f + 0.4f * strength.toFloat() / 90.0f
+        }
+
+    }
+
+    override fun canJump(): Boolean {
+        return true
+    }
+
+    override fun handleStartJump(height: Int) {
+        this.jumping = true
+    }
+
+    fun side() = if (delegate is PokemonServerDelegate) "SERVER" else "CLIENT"
+
+    override fun handleStopJump() {
+        jumping = false
+        // Set back to land pose type?
+    }
+
+    override fun dismountsUnderwater(): Boolean {
+        return true
+    }
+
+    override fun getDefaultGravity(): Double {
+        val regularGravity = super.getDefaultGravity()
+        if (this.passengers.isEmpty()) {
+            return regularGravity
+        }
+        return riding.gravity(this, regularGravity) ?: regularGravity
+    }
+
     /**
      * A utility method to resolve the [Codec] of [Pokemon] aware if the [world] is client sided or not.
      *
@@ -1618,5 +1841,4 @@ open class PokemonEntity(
     override fun resolveEntityScan(): LivingEntity {
         return this
     }
-}
-
+}

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

@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.entity.pokemon
 
 import com.cobblemon.mod.common.CobblemonSounds
+import com.cobblemon.mod.common.Rollable
 import com.cobblemon.mod.common.api.entity.PokemonSender
 import com.cobblemon.mod.common.api.entity.PokemonSideDelegate
 import com.cobblemon.mod.common.api.pokemon.PokemonProperties
@@ -22,6 +23,7 @@ import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.pokemon.activestate.ActivePokemonState
 import com.cobblemon.mod.common.pokemon.activestate.SentOutState
 import com.cobblemon.mod.common.util.getIsSubmerged
+import com.cobblemon.mod.common.util.math.geometry.toRadians
 import com.cobblemon.mod.common.util.playSoundServer
 import com.cobblemon.mod.common.util.update
 import com.cobblemon.mod.common.world.gamerules.CobblemonGameRules
@@ -32,9 +34,12 @@ import net.minecraft.server.level.ServerLevel
 import net.minecraft.network.chat.Component
 import net.minecraft.network.syncher.EntityDataAccessor
 import net.minecraft.world.damagesource.DamageSource
+import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.ai.attributes.Attributes
 import net.minecraft.world.item.ItemStack
 import net.minecraft.world.level.pathfinder.PathType
+import org.joml.Matrix3f
+import org.joml.Vector3f
 
 /** Handles purely server logic for a Pokémon */
 class PokemonServerDelegate : PokemonSideDelegate {
@@ -211,7 +216,7 @@ class PokemonServerDelegate : PokemonSideDelegate {
     }
 
     fun updatePoseType() {
-        if (!entity.enablePoseTypeRecalculation) {
+        if (!entity.enablePoseTypeRecalculation || entity.passengers.isNotEmpty()) {
             return
         }
 

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

@@ -19,7 +19,7 @@ object FlowHandler {
     fun setup() {
         CobblemonEvents.POKEMON_CAPTURED.subscribe { CobblemonFlows.run(cobblemonResource("pokemon_captured"), it.context) }
         CobblemonEvents.BATTLE_VICTORY.subscribe { CobblemonFlows.run(cobblemonResource("battle_victory"), it.context) }
-        CobblemonEvents.POKEDEX_DATA_CHANGED_PRE.subscribe { CobblemonFlows.run(cobblemonResource("pokedex_data_changed_pre"), it.getContext(), it) }
+        CobblemonEvents.POKEDEX_DATA_CHANGED_PRE.subscribe { CobblemonFlows.run(cobblemonResource("pokedex_data_changed_pre"), it.getContext(), it.functions) }
         CobblemonEvents.POKEDEX_DATA_CHANGED_POST.subscribe { CobblemonFlows.run(cobblemonResource("pokedex_data_changed_post"), it.getContext()) }
         CobblemonEvents.FORME_CHANGE.subscribe { CobblemonFlows.run(cobblemonResource("forme_change"), it.context) }
         CobblemonEvents.MEGA_EVOLUTION.subscribe { CobblemonFlows.run(cobblemonResource("mega_evolution"), it.context) }
@@ -27,13 +27,17 @@ object FlowHandler {
         CobblemonEvents.TERASTALLIZATION.subscribe { CobblemonFlows.run(cobblemonResource("terastallization"), it.context) }
         CobblemonEvents.BATTLE_FAINTED.subscribe { CobblemonFlows.run(cobblemonResource("battle_fainted"), it.structContext) }
         CobblemonEvents.BATTLE_FLED.subscribe { CobblemonFlows.run(cobblemonResource("battle_fled"), it.context) }
-        CobblemonEvents.BATTLE_STARTED_PRE.subscribe { CobblemonFlows.run(cobblemonResource("battle_started_pre"), it.context, it) }
+        CobblemonEvents.BATTLE_STARTED_PRE.subscribe { CobblemonFlows.run(cobblemonResource("battle_started_pre"), it.context, it.functions) }
         CobblemonEvents.BATTLE_STARTED_POST.subscribe { CobblemonFlows.run(cobblemonResource("battle_started_post"), it.context) }
         CobblemonEvents.APRICORN_HARVESTED.subscribe { CobblemonFlows.run(cobblemonResource("apricorn_harvested"), it.context) }
         CobblemonEvents.THROWN_POKEBALL_HIT.subscribe { CobblemonFlows.run(cobblemonResource("thrown_pokeball_hit"), it.context) }
-        CobblemonEvents.LEVEL_UP_EVENT.subscribe { CobblemonFlows.run(cobblemonResource("level_up"), it.context) }
+        CobblemonEvents.LEVEL_UP_EVENT.subscribe { CobblemonFlows.run(cobblemonResource("level_up"), it.context, it.functions) }
         CobblemonEvents.POKEMON_FAINTED.subscribe { CobblemonFlows.run(cobblemonResource("pokemon_fainted"), it.context) }
-        CobblemonEvents.POKEMON_GAINED.subscribe { CobblemonFlows.run(cobblemonResource("pokemon_gained"), it.context) }
+        CobblemonEvents.POKEMON_GAINED.subscribe { CobblemonFlows.run(cobblemonResource("pokemon_gained"), it.context, it.functions) }
+        CobblemonEvents.POKE_BALL_CAPTURE_CALCULATED.subscribe { CobblemonFlows.run(cobblemonResource("poke_ball_capture_calculated"), it.context, it.functions) }
+        CobblemonEvents.EVOLUTION_TESTED.subscribe { CobblemonFlows.run(cobblemonResource("evolution_tested"), it.context, it.functions) }
+        CobblemonEvents.EVOLUTION_ACCEPTED.subscribe { CobblemonFlows.run(cobblemonResource("evolution_accepted"), it.context, it.functions) }
+        CobblemonEvents.EVOLUTION_COMPLETE.subscribe { CobblemonFlows.run(cobblemonResource("evolution_completed"), it.context) }
     }
 }
 

common/src/main/kotlin/com/cobblemon/mod/common/item/berry/HealingBerryItem.kt

@@ -64,7 +64,7 @@ class HealingBerryItem(block: BerryBlock, val amount: () -> ExpressionLike): Ber
 
     override fun applyToBattlePokemon(player: ServerPlayer, stack: ItemStack, battlePokemon: BattlePokemon) {
         super.applyToBattlePokemon(player, stack, battlePokemon)
-        player.playSound(CobblemonSounds.BERRY_EAT, 1F, 1F)
+        battlePokemon.entity?.playSound(CobblemonSounds.BERRY_EAT, 1F, 1F)
     }
 
     override fun use(world: Level, user: Player, hand: InteractionHand): InteractionResultHolder<ItemStack> {

common/src/main/kotlin/com/cobblemon/mod/common/item/berry/StatusCuringBerryItem.kt

@@ -48,7 +48,7 @@ class StatusCuringBerryItem(block: BerryBlock, vararg val status: Status): Berry
         val currentStatus = pokemon.status?.status
         return if (currentStatus != null && (status.isEmpty() || currentStatus in status)) {
             pokemon.status = null
-            player.playSound(CobblemonSounds.BERRY_EAT, 1F, 1F)
+            pokemon.entity?.playSound(CobblemonSounds.BERRY_EAT, 1F, 1F)
             if (!player.isCreative) {
                 stack.shrink(1)
             }
@@ -60,7 +60,7 @@ class StatusCuringBerryItem(block: BerryBlock, vararg val status: Status): Berry
 
     override fun applyToBattlePokemon(player: ServerPlayer, stack: ItemStack, battlePokemon: BattlePokemon) {
         super.applyToBattlePokemon(player, stack, battlePokemon)
-        player.playSound(CobblemonSounds.BERRY_EAT, 1F, 1F)
+        battlePokemon.entity?.playSound(CobblemonSounds.BERRY_EAT, 1F, 1F)
     }
 
     override fun use(world: Level, user: Player, hand: InteractionHand): InteractionResultHolder<ItemStack> {

common/src/main/kotlin/com/cobblemon/mod/common/net/messages/client/PlayerInteractOptionsPacket.kt

@@ -27,7 +27,7 @@ class PlayerInteractOptionsPacket(
     val targetId: UUID,
     val numericTargetId: Int,
     val selectedPokemonId: UUID,
-    ) : NetworkPacket<PlayerInteractOptionsPacket> {
+) : NetworkPacket<PlayerInteractOptionsPacket> {
     companion object {
         val ID = cobblemonResource("player_interactions")
         fun decode(buffer: RegistryFriendlyByteBuf) = PlayerInteractOptionsPacket(

common/src/main/kotlin/com/cobblemon/mod/common/net/messages/client/data/CosmeticItemAssignmentSyncPacket.kt

@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.net.messages.client.data
+
+import com.cobblemon.mod.common.CobblemonCosmeticItems
+import com.cobblemon.mod.common.pokemon.cosmetic.CosmeticItemAssignment
+import com.cobblemon.mod.common.util.cobblemonResource
+import net.minecraft.network.RegistryFriendlyByteBuf
+
+class CosmeticItemAssignmentSyncPacket(
+    assignments: Collection<CosmeticItemAssignment>
+) : DataRegistrySyncPacket<CosmeticItemAssignment, CosmeticItemAssignmentSyncPacket>(assignments) {
+
+    override val id = ID
+
+    override fun encodeEntry(buffer: RegistryFriendlyByteBuf, entry: CosmeticItemAssignment) {
+        CosmeticItemAssignment.PACKET_CODEC.encode(buffer, entry)
+    }
+
+    override fun decodeEntry(buffer: RegistryFriendlyByteBuf): CosmeticItemAssignment? {
+        return CosmeticItemAssignment.PACKET_CODEC.decode(buffer)
+    }
+
+    override fun synchronizeDecoded(entries: Collection<CosmeticItemAssignment>) {
+        CobblemonCosmeticItems.reload(entries.associateBy { it.id })
+    }
+
+    companion object {
+        val ID = cobblemonResource("cosmetic_item_assignment_sync")
+        fun decode(buffer: RegistryFriendlyByteBuf) = CosmeticItemAssignmentSyncPacket(emptyList()).apply { decodeBuffer(buffer) }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/net/messages/client/pokemon/update/CosmeticItemUpdatePacket.kt

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.net.messages.client.pokemon.update
+
+import com.cobblemon.mod.common.pokemon.Pokemon
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.cobblemon.mod.common.util.readItemStack
+import com.cobblemon.mod.common.util.writeItemStack
+import net.minecraft.network.RegistryFriendlyByteBuf
+import net.minecraft.world.item.ItemStack
+
+class CosmeticItemUpdatePacket(pokemon: () -> Pokemon, value: ItemStack) : SingleUpdatePacket<ItemStack, CosmeticItemUpdatePacket>(pokemon, value) {
+    override val id = ID
+
+    override fun encodeValue(buffer: RegistryFriendlyByteBuf) {
+        buffer.writeItemStack(this.value)
+    }
+
+    override fun set(pokemon: Pokemon, value: ItemStack) {
+        pokemon.cosmeticItem = value
+    }
+
+    companion object {
+        val ID = cobblemonResource("cosmetic_item_update")
+        fun decode(buffer: RegistryFriendlyByteBuf): CosmeticItemUpdatePacket {
+            val pokemon = decodePokemon(buffer)
+            val cosmeticItem = buffer.readItemStack()
+            return CosmeticItemUpdatePacket(pokemon, cosmeticItem)
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/net/messages/client/ui/InteractPokemonUIPacket.kt

@@ -24,17 +24,32 @@ import java.util.UUID
  * @author Village
  * @since January 7th, 2023
  */
-class InteractPokemonUIPacket(val pokemonID: UUID, val canMountShoulder: Boolean): NetworkPacket<InteractPokemonUIPacket> {
+class InteractPokemonUIPacket(
+    val pokemonID: UUID,
+    val canMountShoulder: Boolean,
+    val canGiveHeld: Boolean,
+    val canGiveCosmetic: Boolean,
+    val canRide: Boolean
+): NetworkPacket<InteractPokemonUIPacket> {
 
     override val id = ID
 
     override fun encode(buffer: RegistryFriendlyByteBuf) {
         buffer.writeUUID(pokemonID)
         buffer.writeBoolean(canMountShoulder)
+        buffer.writeBoolean(canGiveHeld)
+        buffer.writeBoolean(canGiveCosmetic)
+        buffer.writeBoolean(canRide)
     }
 
     companion object {
         val ID = cobblemonResource("interact_pokemon_ui")
-        fun decode(buffer: RegistryFriendlyByteBuf) = InteractPokemonUIPacket(buffer.readUUID(), buffer.readBoolean())
+        fun decode(buffer: RegistryFriendlyByteBuf) = InteractPokemonUIPacket(
+            buffer.readUUID(),
+            buffer.readBoolean(),
+            buffer.readBoolean(),
+            buffer.readBoolean(),
+            buffer.readBoolean()
+        )
     }
 }