last commit before cleanup and MR

commit 9497175627
Author: JacksonB <78700961+jackowes@users.noreply.github.com>
Date:   Thu Feb 13 00:05:03 2025 -0600

    mk2 bird flight controller

commit 0defd2614f
Author: JacksonB <78700961+jackowes@users.noreply.github.com>
Date:   Wed Feb 12 20:01:57 2025 -0600

    Initial bird controller changes and refactoring of how riding controllers control rotation mouse+rotVel

commit 181af6847d
Author: JacksonB <78700961+jackowes@users.noreply.github.com>
Date:   Wed Feb 12 12:29:35 2025 -0600

    Add updated version of Helicopter ride controller. Tie in some static pokemonentity functions to be riding configurable. Modify the cameramixins, currently there is a temp change to them on this branch.

commit ac1cdb0ba6
Author: JacksonB <78700961+jackowes@users.noreply.github.com>
Date:   Sat Feb 8 03:02:35 2025 -0600

    Add angular velocity constant modifier (roll can now influence yaw so the dolphin can turn). Spruce up dolphin swim controller.

commit 59190209a2
Author: JacksonB <78700961+jackowes@users.noreply.github.com>
Date:   Wed Feb 5 19:30:21 2025 -0600

    initial commit with a bunch of poking around code

CHANGELOG-PC.md

@@ -0,0 +1,16 @@
+### Additions
+
+- Added ability to rename PC Boxes by clicking on the name of a box
+- Added ability to set wallpapers per PC Box by clicking the button right to the box name
+- Added sorting by Name, Level and type by clicking the button left of the box name (shift reverses order)
+- Added filtering/search functionality in PC UI, which also supports pokemon properties (e.g. shiny=yes shows all shinies)
+- Added /changewallpaper <player> <boxNumber> <wallpaper> command to change a wallpaper through commands
+- Added /renamebox <player> <boxNumber> <name> command to rename a PC box through commands
+
+### Developer
+
+- Added RenamePCBoxEvent.Pre/Post events to prevent players from renaming a box or change their input
+- Added ChangePCBoxWallpaperEvent.Pre/Post to prevent players from changing to a wallpaper or change their selection
+- Added WallpaperCollectionEvent which gets called when clients connect to a server, allowing the server which of the clients found wallpapers it's allowed to move (collected wallpapers can be removed for example to make it "vanish" client-side)
+- Wallpapers are loaded from `assets/<namespace>/textures/gui/pc/wallpaper/` and all wallpapers in this folder are available to the client to  choose by default
+- Renamed `SetPCBoxPokemonPacket` and the respective handler to `SetPCBoxPacket`

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-SHARED-MODEL-REPO.md

@@ -0,0 +1,10 @@
+
+### Additions
+- Added support for NPCs to use Pokémon models and vice versa. This will require changes in addons that add fossil types due to naming conflicts between fossils and the Pokémon species.
+- Added `/changejointscale` command to change the scale of a joint in a model. Unbelievably funny.
+
+### Developer
+- Removed all VaryingModelRepository subclasses into the parent class. 
+
+### Addons
+- Added `transformedParts` to the root of poser JSONs so it now exists in both poses and the model overall. 

CHANGELOG.md

@@ -1,4 +1,45 @@
 # Changelog
+## [1.7.0 (Month xth, 2025)](#1-7-0)
+
+### Additions
+- Added an in-game configuration screen, allowing all settings from `main.json` to be edited directly in-game.
+- Added `/cobblemonconfig reload` command to reload `main.json` configuration. **Note:** Some settings require a server restart to take effect; use this command cautiously.
+- 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.
+
+### Changes
+- Renamed `chargeGainedPerTick` config to `secondsToChargeHealingMachine`.
+
+### Fixes
+- Fixed Particles sometimes facing the wrong direction (looking at you, Swords Dance)
+- Fixed PCs always opening at box 2 instead of box 1.
+- Fixed not being able to do complex item requirements aside from just NBT with evolution conditions, requirements and fossil items.
+- Fixed the usage `hiddenability` in `pokegive` or other spawn commands resulting in a forced hidden ability
+- Fixed the consumption of friendship berries (or EV berries) not making any noise
+- Fixed Instantly breaking and replacing a fossil analyzer with any block entity crashing the game in a complete multi-structure
+- Fixed players getting disconnected when sidemods update a Pokémon's teratype
+- Fixed fling not using Item Names for minecraft held items that substitute Pokémon items
+- Fixed evolutions sometimes preventing players from logging in to servers
+- Fixed rendering of shoulder-mounted Pokémon desyncing between clients
+
+### Developer
+- A finished battle now has winners and losers set inside of `PokemonBattle` instead of them always being empty.
+- Dialogues are correctly removed from memory when they are stopped.
+- Dialogues with variably-set initial pages now properly start timeout tracking.
+- Added `EvGainedEvent.Pre` and `EvGainedEvent.Post`.
+- Deprecated `EVs#add(Stat, Int)`, you will not be able to compile against this code please migrate to the `EVs#add(Stat, Int, EvSource)` you most likely want to use `SidemodEvSource` but please check other implementations or make your own.
+- Removed the NbtItemPredicate class, all the mod usages now use the vanilla item predicate solution, this causes breaking changes on Fossil, HeldItemRequirement & ItemInteractionEvolution
+- Renamed Cobblemon's creative tabs to start with "Cobblemon: " to distinguish Cobblemon's tabs from tabs for other mods.
+- Various items now have a rarity value.
+
+### 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
+
 ## [1.6.1 (January 26th, 2025)](#1-6-1)
 
 ### Additions
@@ -12,6 +53,22 @@
 - Added config setting `maxPokedexScanningDetectionRange` to control from what distance the player can scan Pokémon using the Pokédex.
 - Added config setting `hideUnimplementedPokemonInThePokedex` which hides unimplemented Pokémon from the Pokédex when set to true. 
 - Added debug renderer for posable entity locators.
+- Added crossover paintings from Close Combat, Premonition, Altar, Slumber, and Nomad.
+- Added optional box argument to the /pc command
+
+### Changes
+- Pokémon will now be dynamically revealed to the Pokédex as they're seen instead of revealing entire parties at the end of battle regardless.
+- Unseen wild Pokémon will update their name from '???' to their real name as soon as a battle starts to reflect the battle UI showing the actual species name.
+- Pokémon under the illusion effect will reveal their disguise to the Pokédex first and then the base Pokémon once the disguise is broken.
+- Added more support for a variety of Fabric/NeoForge Convention tags.
+- Reformatted some tags to be more consistent.
+- Edited some recipes to utilize tags instead of direct item ids, for greater mod compatibility.
+- Berries will drop if broken at age 0
+- Improved Fortune drops on Mint Seeds
+- New Slowpoke shiny texture.
+- Updated drops for many Pokémon.
+- Completely resynced Pokémon move and stat data based on later games. Learnsets have changed considerably to maximise available moves.
+- Cobblemon save data now saves .old files where applicable as a means to recover from file corruption due to crashes or similar abrupt stops
 
 ### Pokémon Added
 
@@ -175,7 +232,7 @@
 - Added `hideNameTag` field and `HideNPCNameTag` nbt tag to `NPCEntity` to allow hiding the name tag of the NPC.
 - Added the player to `PokerodReelEvent` so you know who is doing the reeling.
 
-### MoLang & Datapacks  
+### MoLang & Datapacks
 - Added flows for:
   - `forme_change`: Triggered when a Pokémon changes form in battle.
   - `mega_evolution`: Triggered when a Pokémon mega evolves in battle. (Note: Third-party mods are required for this feature currently)

common/build.gradle.kts

@@ -41,7 +41,7 @@ dependencies {
 
     // Integrations
     compileOnlyApi(libs.jei.api)
-    modCompileOnly(libs.bundles.fabric.integrations.compileOnly) {
+    modCompileOnly(libs.bundles.common.integrations.compileOnly) {
         isTransitive = false
     }
     // Flywheel has no common dep so just pick one and don't use any platform specific code in common

common/config/cobblemon/main.json

@@ -0,0 +1,81 @@
+{
+  "lastSavedVersion": "1.7.0",
+  "maxPokemonLevel": 100,
+  "maxPokemonFriendship": 255,
+  "announceDropItems": true,
+  "defaultDropItemMethod": "on-entity",
+  "ambientPokemonCryTicks": 1080,
+  "defaultBoxCount": 30,
+  "pokemonSaveIntervalSeconds": 30,
+  "storageFormat": "nbt",
+  "preventCompletePartyDeposit": false,
+  "mongoDBConnectionString": "mongodb://localhost:27017",
+  "mongoDBDatabaseName": "cobblemon",
+  "maxVerticalCorrectionBlocks": 64,
+  "minimumLevelRangeMax": 10,
+  "enableSpawning": true,
+  "minimumDistanceBetweenEntities": 8.0,
+  "maxNearbyBlocksHorizontalRange": 4,
+  "maxNearbyBlocksVerticalRange": 2,
+  "maxVerticalSpace": 8,
+  "worldSliceDiameter": 8,
+  "worldSliceHeight": 16,
+  "ticksBetweenSpawnAttempts": 20.0,
+  "minimumSliceDistanceFromPlayer": 16.0,
+  "maximumSliceDistanceFromPlayer": 64.0,
+  "exportSpawnConfig": false,
+  "savePokemonToWorld": true,
+  "exportStarterConfig": false,
+  "autoUpdateShowdown": true,
+  "defaultFleeDistance": 32.0,
+  "allowExperienceFromPvP": true,
+  "experienceShareMultiplier": 0.5,
+  "luckyEggMultiplier": 1.5,
+  "allowSpectating": true,
+  "experienceMultiplier": 2.0,
+  "pokemonPerChunk": 1.0,
+  "passiveStatuses": {
+    "cobblemon:poison": "180-300",
+    "cobblemon:poisonbadly": "180-300",
+    "cobblemon:paralysis": "180-300",
+    "cobblemon:frozen": "180-300",
+    "cobblemon:sleep": "180-300",
+    "cobblemon:burn": "180-300"
+  },
+  "infiniteHealerCharge": false,
+  "maxHealerCharge": 6.0,
+  "secondsToChargeHealingMachine": 900.0,
+  "defaultFaintTimer": 300,
+  "faintAwakenHealthPercent": 0.2,
+  "healPercent": 0.05,
+  "healTimer": 60,
+  "baseApricornTreeGenerationChance": 0.1,
+  "displayEntityLevelLabel": true,
+  "displayEntityNameLabel": true,
+  "displayNameForUnknownPokemon": false,
+  "displayEntityLabelsWhenCrouchingOnly": false,
+  "shinyRate": 8192.0,
+  "shinyNoticeParticlesDistance": 24.0,
+  "captureCalculator": "cobblemon",
+  "playerDamagePokemon": true,
+  "appleLeftoversChance": 0.025,
+  "maxRootsInArea": 5,
+  "bigRootPropagationChance": 0.1,
+  "energyRootChance": 0.25,
+  "maxDynamaxLevel": 10,
+  "teraTypeRate": 20.0,
+  "defaultPasturedPokemonLimit": 16,
+  "pastureBlockUpdateTicks": 40,
+  "pastureMaxWanderDistance": 64,
+  "pastureMaxPerChunk": 4.0,
+  "maxInsertedFossilItems": 2,
+  "walkingInBattleAnimations": false,
+  "battleWildMaxDistance": 12.0,
+  "tradeMaxDistance": 12.0,
+  "battlePvPMaxDistance": 32.0,
+  "battleSpectateMaxDistance": 64.0,
+  "maxPokedexScanningDetectionRange": 10.0,
+  "hideUnimplementedPokemonInThePokedex": false,
+  "summaryPokemonFollowCursor": true,
+  "enableDebugKeys": false
+}

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

@@ -0,0 +1,141 @@
+/*
+ * 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 net.minecraft.util.SmoothDouble;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.phys.Vec3;
+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())));
+    }
+
+    /**
+     * Get the angular velocity in degrees per second as a Vec3
+     */
+    Vec3 angRollVel( double deltaTime );
+
+    public Vec3 rotationOnMouseXY(double yMouse,
+                                  double xMouse,
+                                  SmoothDouble yMouseSmoother,
+                                  SmoothDouble xMouseSmoother,
+                                  double sensitivity,
+                                  double deltaTime );
+
+    boolean shouldRoll();
+
+    boolean useAngVelSmoothing();
+
+    void clearRotation();
+
+}

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

@@ -0,0 +1,97 @@
+/*
+ * 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.Rollable;
+import net.minecraft.client.Camera;
+import net.minecraft.client.Minecraft;
+import net.minecraft.world.entity.Entity;
+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();
+
+    @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();
+    }
+
+    @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/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;
+
+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/ItemInHandRendererMixin.java

@@ -8,16 +8,21 @@
 
 package com.cobblemon.mod.common.mixin;
 
+import com.cobblemon.mod.common.Rollable;
 import com.cobblemon.mod.common.item.PokedexItem;
 import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.math.Axis;
+import net.minecraft.client.Minecraft;
 import net.minecraft.client.player.AbstractClientPlayer;
 import net.minecraft.client.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 +32,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/LivingEntityMixin.java

@@ -12,9 +12,15 @@ import com.cobblemon.mod.common.api.pokemon.effect.ShoulderEffectRegistry;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.effect.MobEffectInstance;
 import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.phys.Vec3;
 import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Overwrite;
+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.ModifyArg;
+import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 @Mixin(LivingEntity.class)
@@ -28,4 +34,70 @@ public abstract class LivingEntityMixin {
         }
     }
 
+    /*
+    @Inject(method = "travelRidden", at = @At(value = "HEAD"))
+    private void cobblemon$altTravelRidden(Player player, Vec3 travelVector)
+    {
+        this.setSpeed(this.getRiddenSpeed(player));
+        this.travel(vec3);
+    }
+
+    /*
+    // Shadow the original method so we can call it.
+    @Shadow
+    protected abstract boolean isControlledByLocalInstance();
+
+    /**
+     * Redirect the call to isControlledByLocalInstance() within travelRidden.
+     * When travelRidden calls isControlledByLocalInstance(), it will get our modified result.
+     */
+
+    /*
+    @Redirect(
+            method = "travelRidden(Lnet/minecraft/world/entity/player/Player;Lnet/minecraft/world/phys/Vec3;)V",
+            at = @At(
+                    value = "INVOKE",
+                    target = "Lnet/minecraft/world/entity/LivingEntity;isControlledByLocalInstance()Z"
+            )
+    )
+    private boolean redirectIsControlledByLocalInstance(LivingEntity instance) {
+        // Return true if either the original method returns true or our custom condition is true.
+        return this.isControlledByLocalInstance() || this.b;
+    }
+
+
+
+    @Overwrite
+    private void travelRidden(Player player, Vec3 travelVector) {
+        Vec3 vec3 = this.getRiddenInput(player, travelVector);
+        this.tickRidden(player, vec3);
+        if (this.isControlledByLocalInstance()) {
+            this.setSpeed(this.getRiddenSpeed(player));
+            this.travel(vec3);
+        } else {
+            this.calculateEntityAnimation(false);
+            this.setDeltaMovement(Vec3.ZERO);
+            this.tryCheckInsideBlocks();
+        }
+    }
+
+
+    @ModifyArg(
+            method = "travelRidden",
+            at = @At(
+                    value = "INVOKE",
+                    target = "setDeltaMovement(Lnet/minecraft/world/phys/Vec3;)V"
+            ),
+            index = 0 // the first (and only) argument
+    )
+    private Vec3 modifyDeltaMovementArgument(Vec3 original) {
+        // Optionally, check if original is Vec3.ZERO, to only replace that call:
+        if (original.equals(Vec3.ZERO)) {
+            // Return your custom vector instead of Vec3.ZERO
+            return original;
+        }
+        // Otherwise, return the original value
+        return original;
+    }
+     */
 }

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

@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import net.minecraft.client.player.LocalPlayer;
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+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.CallbackInfoReturnable;
+
+@Mixin(LocalPlayer.class)
+public abstract class LocalPlayerMixin {
+    @Shadow
+    private float jumpRidingScale;
+
+    @Inject(method = "getJumpRidingScale", at = @At("HEAD"), cancellable = true)
+    public void modifyJumpRidingScale(CallbackInfoReturnable<Float> cir) {
+
+        LocalPlayer player = (LocalPlayer) (Object) this;
+        if (player.isPassenger() && player.getVehicle() instanceof PokemonEntity) {
+            PokemonEntity ride = (PokemonEntity) player.getVehicle();
+            //ride.getRiding().canJump()
+            if( !ride.getRiding().canJump(ride, player))
+            {
+                cir.setReturnValue(0.5f);
+            }
+        }
+
+
+        // Check if the player is riding your custom entity (for example, a Pokemon)
+        /*
+        if (player.isRiding() && player.getVehicle() instanceof PokemonEntity) {
+            PokemonEntity rideable = (PokemonEntity) player.getVehicle();
+            // Get your custom fuel ratio (a value from 0.0 to 1.0)
+            float fuelRatio = rideable.getRidingFuelRatio();
+            cir.setReturnValue(fuelRatio);
+        }
+        */
+    }
+}

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

@@ -8,31 +8,39 @@
 
 package com.cobblemon.mod.common.mixin;
 
+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;
 import com.llamalad7.mixinextras.injector.v2.WrapWithCondition;
 import com.llamalad7.mixinextras.sugar.Local;
+import com.mojang.blaze3d.Blaze3D;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.MouseHandler;
 import net.minecraft.client.player.LocalPlayer;
 import net.minecraft.util.Mth;
 import net.minecraft.util.SmoothDouble;
+import net.minecraft.world.phys.Vec3;
 import org.objectweb.asm.Opcodes;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 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 xMouseSmoother = new SmoothDouble();
+    @Unique SmoothDouble yMouseSmoother = new SmoothDouble();
+    @Unique SmoothDouble pitchSmoother = new SmoothDouble();
+    @Unique SmoothDouble rollSmoother = new SmoothDouble();
+    @Unique SmoothDouble yawSmoother = new SmoothDouble();
+
     @Shadow @Final private SmoothDouble smoothTurnY;
 
     @Shadow @Final private SmoothDouble smoothTurnX;
@@ -41,6 +49,8 @@ public class MouseHandlerMixin {
 
     @Shadow private double accumulatedDY;
 
+    @Shadow private double accumulatedScrollX;
+
     @Inject(
             method = "onScroll",
             at = @At(
@@ -92,8 +102,12 @@ public class MouseHandlerMixin {
                     target = "Lnet/minecraft/client/player/LocalPlayer;turn(DD)V"
             )
     )
-    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.
+    public boolean cobblemon$modifyRotation(LocalPlayer player,
+                                            double cursorDeltaX,
+                                            double cursorDeltaY,
+                                            @Local(argsOnly = true) double d,
+                                            @Local(argsOnly = true) double movementTime
+                                            ) {
         PokedexUsageContext usageContext = CobblemonClient.INSTANCE.getPokedexUsageContext();
         if (usageContext.getScanningGuiOpen()) {
             this.smoothTurnY.reset();
@@ -105,7 +119,106 @@ 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()) {
+            xMouseSmoother.reset();
+            yMouseSmoother.reset();
+            pitchSmoother.reset();
+            rollSmoother.reset();
+            yawSmoother.reset();
+            return true;
+        }
+
+        //maybe have a rollable x mouse and rollable y mouse that take the xmousesmoother
+        //and y mouse smoother ( which are right now named pichsmoother and roll smoother)
+        // values and feed it to those rollable functions which will be called by the
+        //specific ride controller where rollable.rotate can then be called and used
+        //controller specific.
+
+        //return a vec3 of the yaw pitch and roll that are wanted.
+        //multiply by sensitivity before passing it in
+
+        //var xMouse = xMouseSmoother.getNewDeltaValue(cursorDeltaX * 0.05f, d);
+        //var yMouse = yMouseSmoother.getNewDeltaValue(cursorDeltaY * 0.05f, d);
+
+        var defaultSensitivity = this.minecraft.options.sensitivity().get() * 0.6000000238418579 + 0.20000000298023224;
+        var ridingSensitivity = Math.pow(defaultSensitivity, 3);
+
+        Vec3 angVecMouse = rollable.rotationOnMouseXY
+                ( cursorDeltaY,
+                cursorDeltaX ,
+                yMouseSmoother,
+                xMouseSmoother,
+                ridingSensitivity,
+                movementTime );
+
+        //make this configurable maybe?
+
+        //var mRoll = rollSmoother.getNewDeltaValue(angVecMouse.z * 0.15f, d);
+
+        rollable.rotate((float) angVecMouse.x,
+                    (float) angVecMouse.y,
+                    (float) angVecMouse.z);
+
+        //var yMouse = yMouseSmoother.getNewDeltaValue(angVecMouse.y * 0.15f, d);
+        //var xMouse = xMouseSmoother.getNewDeltaValue(cursorDeltaX * 0.15f, d);
+
+        //get the current angular velocity requested to be applied
+        //by the ride controller
+        var angRot = rollable.angRollVel(movementTime);
+
+        if( rollable.useAngVelSmoothing() )
+        {
+            //get the current angular velocity requested to be applied
+            //by the ride controller
+
+            //Multiply against deltatime to get a consistent turn
+            //independent of framerate
+            if( angRot != null ) {
+                //var yaw = angRot.x * d;
+                //Add the yaw to the mouse here... this all needs changed. It should
+                //just map which 0 1 or 2 of the three it is going to modulate with
+                //what
+
+                var yaw = yawSmoother.getNewDeltaValue(angRot.x * 0.5f, d);
+                var pitch = pitchSmoother.getNewDeltaValue(angRot.y * 0.5f, d);
+                var roll = rollSmoother.getNewDeltaValue(angRot.z * 0.5f, d);
+                rollable.rotate((float) yaw, (float) pitch, (float) roll);
+            }
+
+        }
+        else
+        {
+            //Multiply against deltatime to get a consistent turn
+            //independent of framerate
+            if( angRot != null ) {
+                //var yaw = angRot.x * d;
+                //Add the yaw to the mouse here... this all needs changed. It should
+                //just map which 0 1 or 2 of the three it is going to modulate with
+                //what
+
+                rollable.rotate((float) (angRot.x * 10 * d),
+                        (float) (angRot.y * 10 * d),
+                        (float) (angRot.z * 10 * d));
+            }
+        }
+        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/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,11 +29,16 @@ 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;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.util.SmoothDouble;
 import net.minecraft.world.damagesource.DamageSource;
 import net.minecraft.world.entity.EntityType;
 import net.minecraft.world.entity.LivingEntity;
@@ -38,14 +46,18 @@ 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 net.minecraft.world.phys.Vec3;
 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;
 import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.ModifyArg;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
@@ -53,10 +65,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 +87,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_);
@@ -225,4 +239,137 @@ 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) {
+        //Disabled to allow non mouse inputs to modify roll
+        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 Vec3 rotationOnMouseXY(double yMouse,
+                                  double xMouse,
+                                  SmoothDouble yMouseSmoother,
+                                  SmoothDouble xMouseSmoother,
+                                  double sensitivity,
+                                  double deltaTime )
+    {
+        LocalPlayer player = Minecraft.getInstance().player;
+        if (!this.equals(player)) return Vec3.ZERO;
+
+        var playerVehicle = player.getVehicle();
+        if (playerVehicle == null) return Vec3.ZERO;
+        if (!(playerVehicle instanceof PokemonEntity pokemonEntity)) return Vec3.ZERO;
+
+        //this is ridiculous. There likely needs to be some sort of mouseInfo class.
+        return pokemonEntity.getRiding().rotationOnMouseXY
+                (
+                pokemonEntity,
+                player,
+                yMouse,
+                xMouse,
+                yMouseSmoother,
+                xMouseSmoother,
+                sensitivity,
+                deltaTime );
+    }
+
+    @Override
+    public boolean useAngVelSmoothing() {
+        LocalPlayer player = Minecraft.getInstance().player;
+        if (!this.equals(player)) return true;
+        if (player.isHolding(Items.DIAMOND)) return false;
+
+        var playerVehicle = player.getVehicle();
+        if (playerVehicle == null) return true;
+        if (!(playerVehicle instanceof PokemonEntity pokemonEntity)) return true;
+
+        return pokemonEntity.getRiding().useAngVelSmoothing(pokemonEntity);
+    }
+
+    @Override
+    public Vec3 angRollVel( double deltaTime ) {
+        var ret = new Vec3(0.0, 0.0, 0.0);
+        LocalPlayer player = Minecraft.getInstance().player;
+        if (!this.equals(player)) return ret;
+
+        var playerVehicle = player.getVehicle();
+        if (playerVehicle == null) return ret;
+        if (!(playerVehicle instanceof PokemonEntity pokemonEntity)) return ret;
+
+        return pokemonEntity.getRiding().angRollVel( pokemonEntity, player, deltaTime );
+    }
+
+
+    @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

@@ -9,10 +9,14 @@
 package com.cobblemon.mod.common.mixin;
 
 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;
@@ -20,9 +24,21 @@ 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 = "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);
+    @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/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/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/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/renderer/LivingEntityRendererMixin.java

@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin.renderer;
+
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import net.minecraft.client.renderer.entity.LivingEntityRenderer;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+
+/**
+ * @author landonjw
+ */
+@Mixin(LivingEntityRenderer.class)
+public abstract class LivingEntityRendererMixin {
+//    @Redirect(
+//            method = "render(Lnet/minecraft/entity/LivingEntity;FFLnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;I)V",
+//            at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/LivingEntity;hasVehicle()Z"),
+//            slice = @Slice(
+//                    from = @At(value = "INVOKE", target = "Lnet/minecraft/util/math/MathHelper;lerpAngleDegrees(FFF)F"),
+//                    to = @At(value = "TAIL")
+//            )
+//    )
+//    private boolean dodgeRenderer(LivingEntity instance) {
+//        return false;
+//    }
+
+    /*@WrapOperation(
+        method = "render(Lnet/minecraft/world/entity/LivingEntity;FFLcom/mojang/blaze3d/vertex/PoseStack;Lnet/minecraft/client/renderer/MultiBufferSource;I)V",
+        at = @At(value = "INVOKE", target = "Lnet/minecraft/util/Mth;wrapDegrees(F)F")
+    )
+    private float replaceWrapValue(float angle, Operation<Float> original){
+        if(origin){
+            return 0f;
+        } else {
+            return original.call(angle);
+        }
+    }*/
+}

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-templates/CobblemonBuildDetails.kt.peb

@@ -12,6 +12,14 @@ object CobblemonBuildDetails {
     const val BRANCH = "{{ branch | default("Not Specified") }}"
 
     fun smallCommitHash(): String {
+        if(this.GIT_COMMIT.equals("Not Specified")) {
+            return "Unknown"
+        }
+
         return this.GIT_COMMIT.substring(0, 7)
     }
+
+    fun version(): String {
+        return this.VERSION + if(this.SNAPSHOT) "+${this.smallCommitHash()}" else ""
+    }
 }

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

@@ -62,11 +62,7 @@ import com.cobblemon.mod.common.api.storage.player.adapter.PlayerDataMongoBacken
 import com.cobblemon.mod.common.api.storage.player.factory.CachedPlayerDataStoreFactory
 import com.cobblemon.mod.common.api.tags.CobblemonEntityTypeTags
 import com.cobblemon.mod.common.api.tags.CobblemonItemTags
-import com.cobblemon.mod.common.battles.BagItems
-import com.cobblemon.mod.common.battles.BattleFormat
-import com.cobblemon.mod.common.battles.BattleRegistry
-import com.cobblemon.mod.common.battles.BattleSide
-import com.cobblemon.mod.common.battles.ShowdownThread
+import com.cobblemon.mod.common.battles.*
 import com.cobblemon.mod.common.battles.actor.PokemonBattleActor
 import com.cobblemon.mod.common.battles.pokemon.BattlePokemon
 import com.cobblemon.mod.common.client.CobblemonPack
@@ -89,22 +85,11 @@ import com.cobblemon.mod.common.pokemon.aspects.SHINY_ASPECT
 import com.cobblemon.mod.common.pokemon.evolution.variants.BlockClickEvolution
 import com.cobblemon.mod.common.pokemon.feature.TagSeasonResolver
 import com.cobblemon.mod.common.pokemon.helditem.CobblemonHeldItemManager
-import com.cobblemon.mod.common.pokemon.properties.AspectPropertyType
-import com.cobblemon.mod.common.pokemon.properties.BattleCloneProperty
-import com.cobblemon.mod.common.pokemon.properties.FreezeFrameProperty
-import com.cobblemon.mod.common.pokemon.properties.HiddenAbilityPropertyType
-import com.cobblemon.mod.common.pokemon.properties.NoAIProperty
-import com.cobblemon.mod.common.pokemon.properties.UnaspectPropertyType
-import com.cobblemon.mod.common.pokemon.properties.UncatchableProperty
+import com.cobblemon.mod.common.pokemon.properties.*
 import com.cobblemon.mod.common.pokemon.properties.tags.PokemonFlagProperty
 import com.cobblemon.mod.common.pokemon.stat.CobblemonStatProvider
 import com.cobblemon.mod.common.starter.CobblemonStarterHandler
-import com.cobblemon.mod.common.util.DataKeys
-import com.cobblemon.mod.common.util.cobblemonResource
-import com.cobblemon.mod.common.util.ifDedicatedServer
-import com.cobblemon.mod.common.util.isLaterVersion
-import com.cobblemon.mod.common.util.party
-import com.cobblemon.mod.common.util.server
+import com.cobblemon.mod.common.util.*
 import com.cobblemon.mod.common.world.feature.CobblemonPlacedFeatures
 import com.cobblemon.mod.common.world.feature.ore.CobblemonOrePlacedFeatures
 import com.cobblemon.mod.common.world.gamerules.CobblemonGameRules
@@ -112,25 +97,27 @@ import com.mongodb.ConnectionString
 import com.mongodb.MongoClientSettings
 import com.mongodb.client.MongoClient
 import com.mongodb.client.MongoClients
-import java.io.File
-import java.io.FileReader
-import java.io.FileWriter
-import java.io.PrintWriter
-import java.util.UUID
-import kotlin.math.roundToInt
-import kotlin.properties.Delegates
-import kotlin.reflect.full.memberProperties
-import kotlin.reflect.jvm.isAccessible
-import kotlin.reflect.jvm.javaField
 import net.minecraft.client.Minecraft
 import net.minecraft.commands.synchronization.SingletonArgumentInfo
 import net.minecraft.resources.ResourceKey
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.server.level.ServerPlayer
 import net.minecraft.server.packs.PackType
 import net.minecraft.world.item.NameTagItem
 import net.minecraft.world.level.Level
 import net.minecraft.world.level.storage.LevelResource
 import org.apache.logging.log4j.LogManager
 import org.apache.logging.log4j.Logger
+import java.io.File
+import java.io.FileReader
+import java.io.FileWriter
+import java.io.PrintWriter
+import java.util.*
+import kotlin.math.roundToInt
+import kotlin.properties.Delegates
+import kotlin.reflect.full.memberProperties
+import kotlin.reflect.jvm.isAccessible
+import kotlin.reflect.jvm.javaField
 
 object Cobblemon {
     const val MODID = CobblemonBuildDetails.MOD_ID
@@ -164,6 +151,7 @@ object Cobblemon {
     var permissionValidator: PermissionValidator by Delegates.observable(LaxPermissionValidator().also { it.initialize() }) { _, _, newValue -> newValue.initialize() }
     var statProvider: StatProvider = CobblemonStatProvider
     var seasonResolver: SeasonResolver = TagSeasonResolver
+    var wallpapers = mapOf<UUID, List<ResourceLocation>>()
 
     @JvmStatic
     val builtinPacks = listOf<CobblemonPack>(
@@ -220,7 +208,8 @@ object Cobblemon {
             storage.onPlayerDataSync(it)
             playerDataManager.syncAllToPlayer(it)
             starterHandler.handleJoin(it)
-            ServerSettingsPacket(this.config.preventCompletePartyDeposit, this.config.displayEntityLevelLabel, this.config.displayEntityNameLabel, this.config.maxPokemonLevel, this.config.maxPokemonFriendship, this.config.maxDynamaxLevel).sendToPlayer(it)
+            it.requestWallpapers()
+            sendServerSettingsPacketToPlayer(it)
         }
         PlatformEvents.SERVER_PLAYER_LOGOUT.subscribe {
             PCLinkManager.removeLink(it.player.uuid)
@@ -268,8 +257,17 @@ object Cobblemon {
         }
 
         HeldItemProvider.register(CobblemonHeldItemManager, Priority.LOWEST)
+    }
 
-
+    fun sendServerSettingsPacketToPlayer(player: ServerPlayer) {
+        ServerSettingsPacket(
+            this.config.preventCompletePartyDeposit,
+            this.config.displayEntityLevelLabel,
+            this.config.displayEntityNameLabel,
+            this.config.maxPokemonLevel,
+            this.config.maxPokemonFriendship,
+            this.config.maxDynamaxLevel,
+        ).sendToPlayer(player)
     }
 
     fun initialize() {
@@ -429,7 +427,23 @@ object Cobblemon {
         }
     }
 
+    private fun initializeConfig() {
+        loadCobblemonConfig()
+        saveConfig(this.config)
+        PokemonSpecies.observable.subscribe { starterConfig = this.loadStarterConfig() }
+    }
+
     fun loadConfig() {
+        initializeConfig()
+        bestSpawner.init()
+    }
+
+    fun reloadConfig() {
+        initializeConfig()
+        bestSpawner.reloadConfig()
+    }
+
+    private fun loadCobblemonConfig() {
         val configFile = File(CONFIG_PATH)
         configFile.parentFile.mkdirs()
 
@@ -472,12 +486,6 @@ object Cobblemon {
         } else {
             this.config = CobblemonConfig()
         }
-
-        config.lastSavedVersion = VERSION
-        this.saveConfig()
-
-        bestSpawner.loadConfig()
-        PokemonSpecies.observable.subscribe { starterConfig = this.loadStarterConfig() }
     }
 
     fun loadStarterConfig(): StarterConfig {
@@ -500,12 +508,14 @@ object Cobblemon {
         }
     }
 
-    fun saveConfig() {
+    fun saveConfig(config: CobblemonConfig) {
+        config.lastSavedVersion = VERSION
+
         try {
             val configFile = File(CONFIG_PATH)
             val fileWriter = FileWriter(configFile)
             // Put the config to json then flush the writer to commence writing.
-            CobblemonConfig.GSON.toJson(this.config, fileWriter)
+            CobblemonConfig.GSON.toJson(config, fileWriter)
             fileWriter.flush()
             fileWriter.close()
         } catch (exception: Exception) {
@@ -527,4 +537,4 @@ object Cobblemon {
         this.implementation.registerCommandArgument(cobblemonResource("npc_class"), NPCClassArgumentType::class, SingletonArgumentInfo.contextFree(NPCClassArgumentType::npcClass))
     }
 
-}
+}

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

@@ -23,6 +23,7 @@ object CobblemonCommands {
         ChangeEyeHeight.register(dispatcher)
         ChangeScaleAndSize.register(dispatcher)
         ChangeWalkSpeed.register(dispatcher)
+        ChangeJointScaleCommand.register(dispatcher)
         TestCommand.register(dispatcher)
         ReloadShowdownCommand.register(dispatcher)
         ClickTextCommand.register(dispatcher)
@@ -56,7 +57,10 @@ object CobblemonCommands {
         AbandonMultiTeam.register(dispatcher)
         FreezePokemonCommand.register(dispatcher)
         ApplyPlayerTextureCommand.register(dispatcher)
+        RenameBoxCommand.register(dispatcher)
+        ChangeBoxWallpaperCommand.register(dispatcher)
         RunMolangScriptCommand.register(dispatcher)
+        CobblemonConfigCommand.register(dispatcher)
 
         // Possibly lock down registration if and only if under dev environment or running in an environment
         // with a certain system environment variable set

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

@@ -35,7 +35,6 @@ import com.cobblemon.mod.common.pokeball.PokeBall
 import com.cobblemon.mod.common.pokemon.helditem.CobblemonHeldItemManager
 import com.cobblemon.mod.common.util.cobblemonResource
 import net.minecraft.core.Registry
-import net.minecraft.core.component.DataComponents
 import net.minecraft.core.registries.BuiltInRegistries
 import net.minecraft.core.registries.Registries
 import net.minecraft.network.chat.Component
@@ -269,7 +268,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val MONITOR = blockItem("monitor", CobblemonBlocks.MONITOR)
     @JvmField
-    val HEALING_MACHINE = blockItem("healing_machine", CobblemonBlocks.HEALING_MACHINE)
+    val HEALING_MACHINE = blockItem("healing_machine", CobblemonBlocks.HEALING_MACHINE, Rarity.UNCOMMON)
     @JvmField
     val PC = blockItem("pc", CobblemonBlocks.PC)
     @JvmField
@@ -398,7 +397,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
 
     // Medicine
     @JvmField
-    val RARE_CANDY = candyItem("rare_candy") { _, pokemon -> pokemon.getExperienceToNextLevel() }
+    val RARE_CANDY = candyItem("rare_candy", Rarity.RARE) { _, pokemon -> pokemon.getExperienceToNextLevel() }
     @JvmField
     val EXPERIENCE_CANDY_XS = candyItem("exp_candy_xs") { _, _ -> CandyItem.DEFAULT_XS_CANDY_YIELD }
     @JvmField
@@ -883,48 +882,48 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
 
     // Archaeology
     @JvmField
-    val ARMOR_FOSSIL = noSettingsItem("armor_fossil")
+    val ARMOR_FOSSIL = itemWithRarity("armor_fossil", Rarity.UNCOMMON)
     @JvmField
-    val FOSSILIZED_BIRD = noSettingsItem("fossilized_bird")
+    val FOSSILIZED_BIRD = itemWithRarity("fossilized_bird", Rarity.UNCOMMON)
     @JvmField
-    val CLAW_FOSSIL = noSettingsItem("claw_fossil")
+    val CLAW_FOSSIL = itemWithRarity("claw_fossil", Rarity.UNCOMMON)
     @JvmField
-    val COVER_FOSSIL = noSettingsItem("cover_fossil")
+    val COVER_FOSSIL = itemWithRarity("cover_fossil", Rarity.UNCOMMON)
     @JvmField
-    val FOSSILIZED_DINO = noSettingsItem("fossilized_dino")
+    val FOSSILIZED_DINO = itemWithRarity("fossilized_dino", Rarity.UNCOMMON)
     @JvmField
-    val DOME_FOSSIL = noSettingsItem("dome_fossil")
+    val DOME_FOSSIL = itemWithRarity("dome_fossil", Rarity.UNCOMMON)
     @JvmField
-    val FOSSILIZED_DRAKE = noSettingsItem("fossilized_drake")
+    val FOSSILIZED_DRAKE = itemWithRarity("fossilized_drake", Rarity.UNCOMMON)
     @JvmField
-    val FOSSILIZED_FISH = noSettingsItem("fossilized_fish")
+    val FOSSILIZED_FISH = itemWithRarity("fossilized_fish", Rarity.UNCOMMON)
     @JvmField
-    val HELIX_FOSSIL = noSettingsItem("helix_fossil")
+    val HELIX_FOSSIL = itemWithRarity("helix_fossil", Rarity.UNCOMMON)
     @JvmField
-    val JAW_FOSSIL = noSettingsItem("jaw_fossil")
+    val JAW_FOSSIL = itemWithRarity("jaw_fossil", Rarity.UNCOMMON)
     @JvmField
-    val OLD_AMBER_FOSSIL = noSettingsItem("old_amber_fossil")
+    val OLD_AMBER_FOSSIL = itemWithRarity("old_amber_fossil", Rarity.UNCOMMON)
     @JvmField
-    val PLUME_FOSSIL = noSettingsItem("plume_fossil")
+    val PLUME_FOSSIL = itemWithRarity("plume_fossil", Rarity.UNCOMMON)
     @JvmField
-    val ROOT_FOSSIL = noSettingsItem("root_fossil")
+    val ROOT_FOSSIL = itemWithRarity("root_fossil", Rarity.UNCOMMON)
     @JvmField
-    val SAIL_FOSSIL = noSettingsItem("sail_fossil")
+    val SAIL_FOSSIL = itemWithRarity("sail_fossil", Rarity.UNCOMMON)
     @JvmField
-    val SKULL_FOSSIL = noSettingsItem("skull_fossil")
+    val SKULL_FOSSIL = itemWithRarity("skull_fossil", Rarity.UNCOMMON)
 
     @JvmField
-    val BYGONE_SHERD = noSettingsItem("bygone_sherd")
+    val BYGONE_SHERD = itemWithRarity("bygone_sherd", Rarity.UNCOMMON)
     @JvmField
-    val CAPTURE_SHERD = noSettingsItem("capture_sherd")
+    val CAPTURE_SHERD = itemWithRarity("capture_sherd",Rarity.UNCOMMON)
     @JvmField
-    val DOME_SHERD = noSettingsItem("dome_sherd")
+    val DOME_SHERD = itemWithRarity("dome_sherd", Rarity.UNCOMMON)
     @JvmField
-    val HELIX_SHERD = noSettingsItem("helix_sherd")
+    val HELIX_SHERD = itemWithRarity("helix_sherd", Rarity.UNCOMMON)
     @JvmField
-    val NOSTALGIC_SHERD = noSettingsItem("nostalgic_sherd")
+    val NOSTALGIC_SHERD = itemWithRarity("nostalgic_sherd",Rarity.UNCOMMON)
     @JvmField
-    val SUSPICIOUS_SHERD = noSettingsItem("suspicious_sherd")
+    val SUSPICIOUS_SHERD = itemWithRarity("suspicious_sherd", Rarity.UNCOMMON)
 
     @JvmField
     val TUMBLESTONE = this.create("tumblestone", TumblestoneItem(Item.Properties(), CobblemonBlocks.SMALL_BUDDING_TUMBLESTONE))
@@ -1144,11 +1143,11 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val DREAM_ROD = pokerodItem(cobblemonResource("dream_rod"))
     @JvmField
-    val BEAST_ROD = pokerodItem(cobblemonResource("beast_rod"))
+    val BEAST_ROD = pokerodItem(cobblemonResource("beast_rod"), Rarity.RARE)
     @JvmField
-    val MASTER_ROD = pokerodItem(cobblemonResource("master_rod"))
+    val MASTER_ROD = pokerodItem(cobblemonResource("master_rod"), Rarity.EPIC)
     @JvmField
-    val CHERISH_ROD = pokerodItem(cobblemonResource("cherish_rod"))
+    val CHERISH_ROD = pokerodItem(cobblemonResource("cherish_rod"), Rarity.EPIC)
     @JvmField
     val ANCIENT_POKE_ROD = pokerodItem(cobblemonResource("ancient_poke_rod"))
     @JvmField
@@ -1180,7 +1179,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val ANCIENT_GIGATON_ROD = pokerodItem(cobblemonResource("ancient_gigaton_rod"))
     @JvmField
-    val ANCIENT_ORIGIN_ROD = pokerodItem(cobblemonResource("ancient_origin_rod"))
+    val ANCIENT_ORIGIN_ROD = pokerodItem(cobblemonResource("ancient_origin_rod"), Rarity.EPIC)
 
     // Misc
     @JvmField
@@ -1232,10 +1231,12 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     //@JvmField
     //val BINDING_SOIL = blockItem("binding_soil", CobblemonBlocks.BINDING_SOIL)
 
-    private fun blockItem(name: String, block: Block): BlockItem = this.create(name, BlockItem(block, Item.Properties()))
+    private fun blockItem(name: String, block: Block, rarity: Rarity = Rarity.COMMON): BlockItem = this.create(name, BlockItem(block, Item.Properties().rarity(rarity)))
 
     private fun noSettingsItem(name: String): CobblemonItem = this.create(name, CobblemonItem(Item.Properties()))
 
+    private fun itemWithRarity(name: String, rarity: Rarity): CobblemonItem = this.create(name, CobblemonItem(Item.Properties().rarity(rarity)))
+    
     fun berries() = this.berries.toMap()
 
     private fun mulchItem(name: String, mulchVariant: MulchVariant): MulchItem = this.create(name, MulchItem(mulchVariant))
@@ -1247,10 +1248,10 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
         return item
     }
 
-    private fun candyItem(name: String, calculator: CandyItem.Calculator): CandyItem  = this.create(name, CandyItem(calculator))
+    private fun candyItem(name: String, rarity: Rarity = Rarity.COMMON, calculator: CandyItem.Calculator): CandyItem  = this.create(name, CandyItem(rarity, calculator))
 
-    private fun pokerodItem(pokeRodId: ResourceLocation): PokerodItem {
-        val settings = Item.Properties().stacksTo(1).durability(256)
+    private fun pokerodItem(pokeRodId: ResourceLocation, rarity: Rarity = Rarity.COMMON): PokerodItem {
+        val settings = Item.Properties().stacksTo(1).durability(256).rarity(rarity)
         val item = create(pokeRodId.path, PokerodItem(pokeRodId, settings))
         pokeRods.add(item)
         return item

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

@@ -34,6 +34,7 @@ import com.cobblemon.mod.common.client.net.pasture.PokemonPasturedHandler
 import com.cobblemon.mod.common.client.net.pasture.PokemonUnpasturedHandler
 import com.cobblemon.mod.common.client.net.pokedex.ServerConfirmedRegisterHandler
 import com.cobblemon.mod.common.client.net.pokemon.update.PokemonUpdatePacketHandler
+import com.cobblemon.mod.common.client.net.settings.OpenCobblemonConfigEditorHandler
 import com.cobblemon.mod.common.client.net.settings.ServerSettingsPacketHandler
 import com.cobblemon.mod.common.client.net.sound.UnvalidatedPlaySoundS2CPacketHandler
 import com.cobblemon.mod.common.client.net.spawn.SpawnExtraDataEntityHandler
@@ -44,14 +45,16 @@ import com.cobblemon.mod.common.client.net.storage.party.InitializePartyHandler
 import com.cobblemon.mod.common.client.net.storage.party.MoveClientPartyPokemonHandler
 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.ClosePCHandler
-import com.cobblemon.mod.common.client.net.storage.pc.InitializePCHandler
-import com.cobblemon.mod.common.client.net.storage.pc.MoveClientPCPokemonHandler
-import com.cobblemon.mod.common.client.net.storage.pc.OpenPCHandler
-import com.cobblemon.mod.common.client.net.storage.pc.SetPCBoxPokemonHandler
-import com.cobblemon.mod.common.client.net.storage.pc.SetPCPokemonHandler
+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
@@ -66,9 +69,6 @@ import com.cobblemon.mod.common.net.messages.client.dialogue.DialogueOpenedPacke
 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.net.messages.client.fishing.FishingBaitRegistrySyncPacket
-import com.cobblemon.mod.common.net.messages.client.fossil.FossilRegistrySyncPacket
-import com.cobblemon.mod.common.net.messages.client.fossil.NaturalMaterialRegistrySyncPacket
 import com.cobblemon.mod.common.net.messages.client.npc.CloseNPCEditorPacket
 import com.cobblemon.mod.common.net.messages.client.npc.OpenNPCEditorPacket
 import com.cobblemon.mod.common.net.messages.client.pasture.ClosePasturePacket
@@ -80,6 +80,7 @@ import com.cobblemon.mod.common.net.messages.client.pokemon.update.*
 import com.cobblemon.mod.common.net.messages.client.pokemon.update.evolution.AddEvolutionPacket
 import com.cobblemon.mod.common.net.messages.client.pokemon.update.evolution.ClearEvolutionsPacket
 import com.cobblemon.mod.common.net.messages.client.pokemon.update.evolution.RemoveEvolutionPacket
+import com.cobblemon.mod.common.net.messages.client.settings.OpenCobblemonConfigScreenPacket
 import com.cobblemon.mod.common.net.messages.client.settings.ServerSettingsPacket
 import com.cobblemon.mod.common.net.messages.client.sound.UnvalidatedPlaySoundS2CPacket
 import com.cobblemon.mod.common.net.messages.client.spawn.SpawnGenericBedrockPacket
@@ -93,14 +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
@@ -111,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
@@ -124,15 +153,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.ReleasePCPokemonPacket
-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
@@ -144,6 +180,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
@@ -160,13 +197,13 @@ import com.cobblemon.mod.common.net.serverhandling.storage.SwapPCPartyPokemonHan
 import com.cobblemon.mod.common.net.serverhandling.storage.party.MovePartyPokemonHandler
 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.MovePCPokemonHandler
-import com.cobblemon.mod.common.net.serverhandling.storage.pc.MovePCPokemonToPartyHandler
-import com.cobblemon.mod.common.net.serverhandling.storage.pc.MovePartyPokemonToPCHandler
-import com.cobblemon.mod.common.net.serverhandling.storage.pc.ReleasePartyPokemonHandler
-import com.cobblemon.mod.common.net.serverhandling.storage.pc.SwapPCPokemonHandler
-import com.cobblemon.mod.common.net.serverhandling.storage.pc.UnlinkPlayerFromPCHandler
-import com.cobblemon.mod.common.net.serverhandling.trade.*
+import com.cobblemon.mod.common.net.serverhandling.storage.pc.*
+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
 
@@ -179,13 +216,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)
@@ -221,6 +256,9 @@ object CobblemonNetwork {
         list.add(PacketRegisterInfo(SpeciesFeatureUpdatePacket.ID, SpeciesFeatureUpdatePacket::decode, PokemonUpdatePacketHandler()))
         list.add(PacketRegisterInfo(OriginalTrainerUpdatePacket.ID, OriginalTrainerUpdatePacket::decode, PokemonUpdatePacketHandler()))
         list.add(PacketRegisterInfo(FormUpdatePacket.ID, FormUpdatePacket::decode, PokemonUpdatePacketHandler()))
+        list.add(PacketRegisterInfo(TeraTypeUpdatePacket.ID, TeraTypeUpdatePacket::decode, PokemonUpdatePacketHandler()))
+        list.add(PacketRegisterInfo(DmaxLevelUpdatePacket.ID, DmaxLevelUpdatePacket::decode, PokemonUpdatePacketHandler()))
+        list.add(PacketRegisterInfo(GmaxFactorUpdatePacket.ID, GmaxFactorUpdatePacket::decode, PokemonUpdatePacketHandler()))
 
         // Evolution start
         list.add(PacketRegisterInfo(AddEvolutionPacket.ID, AddEvolutionPacket::decode, PokemonUpdatePacketHandler()))
@@ -235,13 +273,18 @@ object CobblemonNetwork {
         list.add(PacketRegisterInfo(SetPartyReferencePacket.ID, SetPartyReferencePacket::decode, SetPartyReferenceHandler))
         list.add(PacketRegisterInfo(InitializePCPacket.ID, InitializePCPacket::decode, InitializePCHandler))
         list.add(PacketRegisterInfo(MoveClientPCPokemonPacket.ID, MoveClientPCPokemonPacket::decode, MoveClientPCPokemonHandler))
-        list.add(PacketRegisterInfo(SetPCBoxPokemonPacket.ID, SetPCBoxPokemonPacket::decode, SetPCBoxPokemonHandler))
+        list.add(PacketRegisterInfo(SetPCBoxPacket.ID, SetPCBoxPacket::decode, SetPCBoxHandler))
         list.add(PacketRegisterInfo(SetPCPokemonPacket.ID, SetPCPokemonPacket::decode, SetPCPokemonHandler))
         list.add(PacketRegisterInfo(OpenPCPacket.ID, OpenPCPacket::decode, OpenPCHandler))
         list.add(PacketRegisterInfo(ClosePCPacket.ID, ClosePCPacket::decode, ClosePCHandler))
         list.add(PacketRegisterInfo(SwapClientPokemonPacket.ID, SwapClientPokemonPacket::decode, SwapClientPokemonHandler))
         list.add(PacketRegisterInfo(RemoveClientPokemonPacket.ID, RemoveClientPokemonPacket::decode, RemoveClientPokemonHandler))
 
+        list.add(PacketRegisterInfo(RenamePCBoxPacket.ID, RenamePCBoxPacket::decode, RenamePCBoxHandler))
+        list.add(PacketRegisterInfo(RequestPCBoxWallpapersPacket.ID, RequestPCBoxWallpapersPacket::decode, RequestPCBoxWallpapersHandler))
+        list.add(PacketRegisterInfo(SetPCBoxWallpapersPacket.ID, SetPCBoxWallpapersPacket::decode, SetPCBoxWallpapersHandler))
+        list.add(PacketRegisterInfo(ChangePCBoxWallpaperPacket.ID, ChangePCBoxWallpaperPacket::decode, ChangePCBoxWallpaperHandler))
+
         // UI Packets
         list.add(PacketRegisterInfo(SummaryUIPacket.ID, SummaryUIPacket::decode, SummaryUIPacketHandler))
         list.add(PacketRegisterInfo(InteractPokemonUIPacket.ID, InteractPokemonUIPacket::decode, InteractPokemonUIPacketHandler))
@@ -279,11 +322,13 @@ object CobblemonNetwork {
         // MultiBattleTeam Packets
         list.add(PacketRegisterInfo(TeamRequestNotificationPacket.ID, TeamRequestNotificationPacket::decode, TeamRequestNotificationHandler))
         list.add(PacketRegisterInfo(TeamRequestExpiredPacket.ID, TeamRequestExpiredPacket::decode, TeamRequestExpiredHandler))
+        list.add(PacketRegisterInfo(TeamMemberAddNotificationPacket.ID, TeamMemberAddNotificationPacket::decode, TeamMemberAddNotificationHandler))
         list.add(PacketRegisterInfo(TeamMemberRemoveNotificationPacket.ID, TeamMemberRemoveNotificationPacket::decode, TeamMemberRemoveNotificationHandler))
         list.add(PacketRegisterInfo(TeamJoinNotificationPacket.ID, TeamJoinNotificationPacket::decode, TeamJoinNotificationHandler))
 
         // Settings packets
         list.add(PacketRegisterInfo(ServerSettingsPacket.ID, ServerSettingsPacket::decode, ServerSettingsPacketHandler))
+        list.add(PacketRegisterInfo(OpenCobblemonConfigScreenPacket.ID, OpenCobblemonConfigScreenPacket::decode, OpenCobblemonConfigEditorHandler))
 
         // Data registries
         list.add(PacketRegisterInfo(AbilityRegistrySyncPacket.ID, AbilityRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
@@ -387,6 +432,10 @@ object CobblemonNetwork {
         list.add(PacketRegisterInfo(ReleasePCPokemonPacket.ID, ReleasePCPokemonPacket::decode, ReleasePCPokemonHandler))
         list.add(PacketRegisterInfo(UnlinkPlayerFromPCPacket.ID, UnlinkPlayerFromPCPacket::decode, UnlinkPlayerFromPCHandler))
 
+        list.add(PacketRegisterInfo(RequestRenamePCBoxPacket.Companion.ID, RequestRenamePCBoxPacket.Companion::decode, RequestRenamePCBoxHandler))
+        list.add(PacketRegisterInfo(PCBoxWallpapersPacket.ID, PCBoxWallpapersPacket::decode, PCBoxWallpapersHandler))
+        list.add(PacketRegisterInfo(RequestChangePCBoxWallpaperPacket.ID, RequestChangePCBoxWallpaperPacket::decode, RequestChangePCBoxWallpaperHandler))
+
         // Starter packets
         list.add(PacketRegisterInfo(SelectStarterPacket.ID, SelectStarterPacket::decode, SelectStarterPacketHandler))
         list.add(PacketRegisterInfo(RequestStarterScreenPacket.ID, RequestStarterScreenPacket::decode, RequestStarterScreenHandler))
@@ -399,6 +448,8 @@ object CobblemonNetwork {
 
         list.add(PacketRegisterInfo(SwapPCPartyPokemonPacket.ID, SwapPCPartyPokemonPacket::decode, SwapPCPartyPokemonHandler))
 
+        list.add(PacketRegisterInfo(SortPCBoxPacket.ID, SortPCBoxPacket::decode, SortPCBoxHandler))
+
         // Battle packets
         list.add(PacketRegisterInfo(BattleSelectActionsPacket.ID, BattleSelectActionsPacket::decode, BattleSelectActionsHandler))
         list.add(PacketRegisterInfo(SpectateBattlePacket.ID, SpectateBattlePacket::decode, SpectateBattleHandler))
@@ -443,11 +494,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/api/ai/SleepDepth.kt

@@ -43,7 +43,8 @@ interface SleepDepth {
             "comatose" to comatose,
             "normal" to normal
         )
-        val adapter = StringIdentifiedObjectAdapter { depths[it] ?: throw IllegalArgumentException("Unknown sleep depth: $it") }
+
+        val adapter = StringIdentifiedObjectAdapter({ depths[it] ?: throw IllegalArgumentException("Unknown sleep depth: $it") })
     }
 
     fun canSleep(pokemonEntity: PokemonEntity): Boolean

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

@@ -23,6 +23,7 @@ import com.cobblemon.mod.common.api.events.CobblemonEvents
 import com.cobblemon.mod.common.api.events.battles.BattleFledEvent
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.api.net.NetworkPacket
+import com.cobblemon.mod.common.api.pokemon.stats.BattleEvSource
 import com.cobblemon.mod.common.api.storage.party.PlayerPartyStore
 import com.cobblemon.mod.common.api.tags.CobblemonItemTags
 import com.cobblemon.mod.common.api.text.red
@@ -272,7 +273,7 @@ open class PokemonBattle(
                             opponent.awardExperience(opponentPokemon, experience)
                         }
                         Cobblemon.evYieldCalculator.calculate(opponentPokemon, faintedPokemon).forEach { (stat, amount) ->
-                            pokemon.evs.add(stat, amount)
+                            pokemon.evs.add(stat, amount, BattleEvSource(this, opponentPokemon.facedOpponents.toList(), pokemon))
                         }
 
                     }

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/dialogue/ActiveDialogue.kt

@@ -55,6 +55,7 @@ class ActiveDialogue(var playerEntity: ServerPlayer, var dialogueReference: Dial
         )
 
         dialogueReference.initializationAction.invoke(this)
+        setPage(currentPage)
 
         if (!completion.isDone) {
             val packet = DialogueOpenedPacket(this, true)

common/src/main/kotlin/com/cobblemon/mod/common/api/dialogue/DialogueManager.kt

@@ -52,6 +52,6 @@ object DialogueManager {
     fun stopDialogue(playerEntity: ServerPlayer) {
         val activeDialogue = playerEntity.activeDialogue ?: return
         DialogueClosedPacket(activeDialogue.dialogueId).sendToPlayer(playerEntity)
-        activeDialogues.remove(activeDialogue.dialogueId)
+        activeDialogues.remove(playerEntity.uuid)
     }
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/drop/ItemDropMethod.kt

@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.api.drop
 
 import com.cobblemon.mod.common.api.serialization.StringIdentifiedObjectAdapter
+import com.google.gson.annotations.SerializedName
 
 /**
  * The way an item will be dropped.
@@ -28,6 +29,9 @@ enum class ItemDropMethod(val methodName: String) {
     TO_INVENTORY("to-inventory");
 
     companion object {
-        val adapter = StringIdentifiedObjectAdapter { str -> values().firstOrNull { it.methodName == str } }
+        val adapter = StringIdentifiedObjectAdapter(
+            { str -> ItemDropMethod.entries.firstOrNull { it.methodName == str } },
+            { value -> (value ?: ON_ENTITY).methodName },
+        )
     }
 }

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/CobblemonEvents.kt

@@ -42,13 +42,17 @@ import com.cobblemon.mod.common.api.events.pokemon.healing.PokemonHealedEvent
 import com.cobblemon.mod.common.api.events.pokemon.interaction.ExperienceCandyUseEvent
 import com.cobblemon.mod.common.api.events.pokemon.interaction.PokemonInteractionGUICreationEvent
 import com.cobblemon.mod.common.api.events.starter.StarterChosenEvent
+import com.cobblemon.mod.common.api.events.storage.ChangePCBoxWallpaperEvent
 import com.cobblemon.mod.common.api.events.storage.ReleasePokemonEvent
+import com.cobblemon.mod.common.api.events.storage.RenamePCBoxEvent
+import com.cobblemon.mod.common.api.events.storage.WallpaperCollectionEvent
 import com.cobblemon.mod.common.api.events.world.BigRootPropagatedEvent
 import com.cobblemon.mod.common.api.reactive.CancelableObservable
 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
 
@@ -158,11 +162,29 @@ object CobblemonEvents {
     @JvmField
     val EXPERIENCE_CANDY_USE_POST = EventObservable<ExperienceCandyUseEvent.Post>()
 
+    @JvmField
+    val EV_GAINED_EVENT_PRE = CancelableObservable<EvGainedEvent.Pre>()
+    @JvmField
+    val EV_GAINED_EVENT_POST = EventObservable<EvGainedEvent.Post>()
+
     @JvmField
     val POKEMON_RELEASED_EVENT_PRE = CancelableObservable<ReleasePokemonEvent.Pre>()
     @JvmField
     val POKEMON_RELEASED_EVENT_POST = EventObservable<ReleasePokemonEvent.Post>()
 
+    @JvmField
+    val RENAME_PC_BOX_EVENT_PRE = CancelableObservable<RenamePCBoxEvent.Pre>()
+    @JvmField
+    val RENAME_PC_BOX_EVENT_POST = EventObservable<RenamePCBoxEvent.Post>()
+
+    @JvmField
+    val WALLPAPER_COLLECTION_EVENT = EventObservable<WallpaperCollectionEvent>()
+
+    @JvmField
+    val CHANGE_PC_BOX_WALLPAPER_EVENT_PRE = CancelableObservable<ChangePCBoxWallpaperEvent.Pre>()
+    @JvmField
+    val CHANGE_PC_BOX_WALLPAPER_EVENT_POST = EventObservable<ChangePCBoxWallpaperEvent.Post>()
+
     @JvmField
     val LOOT_DROPPED = CancelableObservable<LootDroppedEvent>()
     @JvmField
@@ -232,4 +254,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/pokemon/EvGainedEvent.kt

@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.events.pokemon
+
+import com.cobblemon.mod.common.api.events.Cancelable
+import com.cobblemon.mod.common.api.pokemon.stats.EvSource
+import com.cobblemon.mod.common.api.pokemon.stats.Stat
+import com.cobblemon.mod.common.pokemon.Pokemon
+
+/**
+ * Fired during EV mutation.
+ *
+ * @see [Pre]
+ * @see [Post]
+ */
+interface EvGainedEvent {
+
+    /**
+     * The [Stat] having EVs added to itself.
+     */
+    val stat: Stat
+
+    /**
+     * @see EvSource.pokemon
+     */
+    val pokemon: Pokemon get() = this.source.pokemon
+
+    /**
+     * The [EvSource] that fired this event.
+     */
+    val source: EvSource
+
+    /**
+     * Fired before EV mutation occurs, cancelling will cause the mutation to be flagged as not successful (returns 0).
+     *
+     * @property stat See [EvGainedEvent.stat].
+     * @property amount The amount of EVs that will be gained.
+     * @property source See [EvGainedEvent.source].
+     */
+    class Pre(override val stat: Stat, var amount: Int, override val source: EvSource) : EvGainedEvent, Cancelable()
+
+    /**
+     * Fired after EV mutation occurs, this is purely for notification purposes.
+     *
+     * @property stat See [EvGainedEvent.stat].
+     * @property amount The final amount of EVs gained.
+     * @property source See [EvGainedEvent.source].
+     */
+    class Post(override val stat: Stat, val amount: Int, override val source: EvSource) : EvGainedEvent
+
+}

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

@@ -0,0 +1,52 @@
+/*
+ * 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.events.storage
+
+import com.cobblemon.mod.common.api.events.Cancelable
+import com.cobblemon.mod.common.api.storage.pc.PCBox
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.server.level.ServerPlayer
+
+/**
+ * Events fired whenever a player changes their PC Wallpaper.
+ * Has a cancelable [Pre] event and a [Post] which gets fired after the change.
+ *
+ * @author JustAHuman-xD
+ * @since February 14th, 2025
+ */
+interface ChangePCBoxWallpaperEvent {
+
+    /**
+     * The [ServerPlayer] who is changing their wallpaper
+     */
+    val player: ServerPlayer
+
+    /**
+     * The [PCBox] whose wallpaper is being changed
+     */
+    val box: PCBox
+
+    /**
+     * The location of the wallpaper that is being changed to. Can be modified in the [Pre] event.
+     * NOTE: Changing this to a wallpaper that does not exist on the client, will result in a purple/black fallback texture being displayed.
+     */
+    val wallpaper: ResourceLocation
+
+    class Pre(
+        override val player: ServerPlayer,
+        override val box: PCBox,
+        override var wallpaper: ResourceLocation
+    ) : ChangePCBoxWallpaperEvent, Cancelable()
+
+    class Post(
+        override val player: ServerPlayer,
+        override val box: PCBox,
+        override val wallpaper: ResourceLocation
+    ) : ChangePCBoxWallpaperEvent
+}

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

@@ -0,0 +1,50 @@
+/*
+ * 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.events.storage
+
+import com.cobblemon.mod.common.api.events.Cancelable
+import com.cobblemon.mod.common.api.storage.pc.PCBox
+import net.minecraft.server.level.ServerPlayer
+
+/**
+ * Events fired whenever a player renames one of their PC boxes.
+ * Has a cancelable [Pre] event and a [Post] which gets fired after the change.
+ *
+ * @author JustAHuman-xD
+ * @since February 14th, 2025
+ */
+interface RenamePCBoxEvent {
+
+    /**
+     * The [ServerPlayer] who is changing their wallpaper
+     */
+    val player: ServerPlayer
+
+    /**
+     * The [PCBox] whose wallpaper is being changed
+     */
+    val box: PCBox
+
+    /**
+     * The new box name being used. This can be modified in the [Pre] event.
+     */
+    val name: String
+
+    class Pre(
+        override val player: ServerPlayer,
+        override val box: PCBox,
+        override var name: String
+    ) : RenamePCBoxEvent, Cancelable()
+
+    class Post(
+        override val player: ServerPlayer,
+        override val box: PCBox,
+        override val name: String
+    ) : RenamePCBoxEvent
+}

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

@@ -0,0 +1,26 @@
+/*
+ * 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.events.storage
+
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.server.level.ServerPlayer
+
+/**
+ * Event being fired whenever the client connects to a server and "requests" what wallpapers are available for it to choose from.
+ * Mods can listen to this event and remove available options from the client when they connect, essentially causing them to not exist client-side
+ *
+ * NOTE: Adding wallpapers here that do not exist on the client, will result in the purple/black fallback texture being displayed client-side.
+ *
+ * @author JustAHuman-xD
+ * @since February 14th, 2025
+ */
+data class WallpaperCollectionEvent(
+    val player: ServerPlayer,
+    val wallpapers: MutableList<ResourceLocation>
+)

common/src/main/kotlin/com/cobblemon/mod/common/api/fishing/FishingBaits.kt

@@ -11,7 +11,7 @@ package com.cobblemon.mod.common.api.fishing
 import com.cobblemon.mod.common.CobblemonItemComponents
 import com.cobblemon.mod.common.api.data.JsonDataRegistry
 import com.cobblemon.mod.common.api.reactive.SimpleObservable
-import com.cobblemon.mod.common.net.messages.client.fishing.FishingBaitRegistrySyncPacket
+import com.cobblemon.mod.common.net.messages.client.data.FishingBaitRegistrySyncPacket
 import com.cobblemon.mod.common.util.adapters.IdentifierAdapter
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.google.gson.Gson

common/src/main/kotlin/com/cobblemon/mod/common/api/fossil/Fossil.kt

@@ -9,7 +9,7 @@
 package com.cobblemon.mod.common.api.fossil
 
 import com.cobblemon.mod.common.api.pokemon.PokemonProperties
-import com.cobblemon.mod.common.pokemon.evolution.predicate.NbtItemPredicate
+import net.minecraft.advancements.critereon.ItemPredicate
 import net.minecraft.network.chat.Component
 import net.minecraft.network.chat.MutableComponent
 import net.minecraft.resources.ResourceLocation
@@ -19,7 +19,7 @@ import net.minecraft.world.item.ItemStack
 class Fossil(
     identifier: ResourceLocation,
     val result: PokemonProperties,
-    val fossils: List<NbtItemPredicate>
+    val fossils: List<ItemPredicate>
 ): StringRepresentable {
 
     @Transient

common/src/main/kotlin/com/cobblemon/mod/common/api/fossil/Fossils.kt

@@ -13,15 +13,15 @@ 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.fossil.FossilRegistrySyncPacket
-import com.cobblemon.mod.common.pokemon.evolution.adapters.NbtItemPredicateAdapter
-import com.cobblemon.mod.common.pokemon.evolution.predicate.NbtItemPredicate
+import com.cobblemon.mod.common.net.messages.client.data.FossilRegistrySyncPacket
+import com.cobblemon.mod.common.pokemon.evolution.adapters.LegacyItemConditionWrapperAdapter
 import com.cobblemon.mod.common.util.adapters.IdentifierAdapter
 import com.cobblemon.mod.common.util.adapters.ItemLikeConditionAdapter
 import com.cobblemon.mod.common.util.adapters.pokemonPropertiesShortAdapter
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.google.gson.GsonBuilder
 import com.google.gson.reflect.TypeToken
+import net.minecraft.advancements.critereon.ItemPredicate
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.server.packs.PackType
@@ -40,7 +40,7 @@ object Fossils: JsonDataRegistry<Fossil> {
         .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
         .registerTypeAdapter(PokemonProperties::class.java, pokemonPropertiesShortAdapter)
         .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Item::class.java).type, ItemLikeConditionAdapter)
-        .registerTypeAdapter(NbtItemPredicate::class.java, NbtItemPredicateAdapter)
+        .registerTypeAdapter(ItemPredicate::class.java, LegacyItemConditionWrapperAdapter)
         .create()
 
     override val typeToken: TypeToken<Fossil> = TypeToken.get(Fossil::class.java)

common/src/main/kotlin/com/cobblemon/mod/common/api/fossil/NaturalMaterials.kt

@@ -10,7 +10,7 @@ package com.cobblemon.mod.common.api.fossil
 
 import com.cobblemon.mod.common.api.data.JsonDataRegistry
 import com.cobblemon.mod.common.api.reactive.SimpleObservable
-import com.cobblemon.mod.common.net.messages.client.fossil.NaturalMaterialRegistrySyncPacket
+import com.cobblemon.mod.common.net.messages.client.data.NaturalMaterialRegistrySyncPacket
 import com.cobblemon.mod.common.registry.ItemTagCondition
 import com.cobblemon.mod.common.util.adapters.IdentifierAdapter
 import com.cobblemon.mod.common.util.adapters.ItemLikeConditionAdapter

common/src/main/kotlin/com/cobblemon/mod/common/api/gui/GuiUtils.kt

@@ -12,12 +12,10 @@ import com.cobblemon.mod.common.api.text.font
 import com.cobblemon.mod.common.client.gui.battle.BattleOverlay.Companion.PORTRAIT_DIAMETER
 import com.cobblemon.mod.common.client.render.SpriteType
 import com.cobblemon.mod.common.client.render.models.blockbench.PosableState
-import com.cobblemon.mod.common.client.render.models.blockbench.repository.PokemonModelRepository
 import com.cobblemon.mod.common.client.render.models.blockbench.repository.RenderContext
 import com.cobblemon.mod.common.client.render.models.blockbench.repository.VaryingModelRepository
 import com.cobblemon.mod.common.entity.PoseType
 import com.cobblemon.mod.common.util.toHex
-import com.mojang.authlib.minecraft.client.MinecraftClient
 import com.mojang.blaze3d.platform.GlStateManager
 import com.mojang.blaze3d.platform.Lighting
 import com.mojang.blaze3d.systems.RenderSystem
@@ -209,7 +207,6 @@ fun drawPosablePortrait(
     contextScale: Float = 1F,
     reversed: Boolean = false,
     state: PosableState,
-    repository: VaryingModelRepository<*>,
     partialTicks: Float,
     limbSwing: Float = 0F,
     limbSwingAmount: Float = 0F,
@@ -227,16 +224,16 @@ fun drawPosablePortrait(
     matrixStack.scale(scale, scale, -scale)
     matrixStack.translate(0.0, -PORTRAIT_DIAMETER / 18.0, 0.0)
 
-    val sprite = repository.getSprite(identifier, state, SpriteType.PORTRAIT);
+    val sprite = VaryingModelRepository.getSprite(identifier, state, SpriteType.PORTRAIT);
 
     if (sprite == null) {
-        val model = repository.getPoser(identifier, state)
+        val model = VaryingModelRepository.getPoser(identifier, state)
         state.currentModel = model
-        val texture = repository.getTexture(identifier, state)
+        val texture = VaryingModelRepository.getTexture(identifier, state)
 
         val context = RenderContext()
         model.context = context
-        repository.getTextureNoSubstitute(identifier, state).let { context.put(RenderContext.TEXTURE, it) }
+        VaryingModelRepository.getTextureNoSubstitute(identifier, state).let { context.put(RenderContext.TEXTURE, it) }
         context.put(RenderContext.SCALE, contextScale)
         context.put(RenderContext.SPECIES, identifier)
         context.put(RenderContext.ASPECTS, state.currentAspects)
@@ -255,7 +252,7 @@ fun drawPosablePortrait(
 
         matrixStack.translate(
             model.portraitTranslation.x * if (reversed) -1F else 1F,
-            model.portraitTranslation.y,
+            model.portraitTranslation.y + 1.5 * model.portraitScale,
             model.portraitTranslation.z - 4
         )
         matrixStack.scale(model.portraitScale, model.portraitScale, 1 / model.portraitScale)
@@ -272,7 +269,7 @@ fun drawPosablePortrait(
         val packedLight = LightTexture.pack(11, 7)
 
         val colour = toHex(r, g, b, a)
-        model.withLayerContext(immediate, state, repository.getLayers(identifier, state)) {
+        model.withLayerContext(immediate, state, VaryingModelRepository.getLayers(identifier, state)) {
             model.render(context, matrixStack, buffer, packedLight, OverlayTexture.NO_OVERLAY, colour)
             immediate.endBatch()
         }
@@ -288,7 +285,6 @@ fun drawPosablePortrait(
 }
 
 fun drawProfile(
-    repository: VaryingModelRepository<*>,
     resourceIdentifier: ResourceLocation,
     matrixStack: PoseStack,
     state: PosableState,
@@ -298,16 +294,16 @@ fun drawProfile(
     RenderSystem.applyModelViewMatrix()
     matrixStack.scale(scale, scale, -scale)
 
-    val sprite = repository.getSprite(resourceIdentifier, state, SpriteType.PROFILE)
+    val sprite = VaryingModelRepository.getSprite(resourceIdentifier, state, SpriteType.PROFILE)
 
     if (sprite == null) {
 
-        val model = repository.getPoser(resourceIdentifier, state)
-        val texture = repository.getTexture(resourceIdentifier, state)
+        val model = VaryingModelRepository.getPoser(resourceIdentifier, state)
+        val texture = VaryingModelRepository.getTexture(resourceIdentifier, state)
 
         val context = RenderContext()
         model.context = context
-        repository.getTextureNoSubstitute(resourceIdentifier, state).let { context.put(RenderContext.TEXTURE, it) }
+        VaryingModelRepository.getTextureNoSubstitute(resourceIdentifier, state).let { context.put(RenderContext.TEXTURE, it) }
         context.put(RenderContext.SCALE, 1F)
         context.put(RenderContext.SPECIES, resourceIdentifier)
         context.put(RenderContext.ASPECTS, state.currentAspects)
@@ -319,7 +315,11 @@ fun drawProfile(
         state.setPoseToFirstSuitable(PoseType.PORTRAIT)
         state.updatePartialTicks(partialTicks)
         model.applyAnimations(null, state, 0F, 0F, 0F, 0F, 0F)
-        matrixStack.translate(model.profileTranslation.x, model.profileTranslation.y, model.profileTranslation.z - 4.0)
+        matrixStack.translate(
+            model.profileTranslation.x,
+            model.profileTranslation.y + 1.5 * model.profileScale,
+            model.profileTranslation.z - 4.0
+        )
         matrixStack.scale(model.profileScale, model.profileScale, 1 / model.profileScale)
 //    matrixStack.multiply(rotation)
         val quaternion1 = Axis.YP.rotationDegrees(-32F * if (false) -1F else 1F)
@@ -337,7 +337,7 @@ fun drawProfile(
         RenderSystem.setShaderLights(light1, light2)
         val packedLight = LightTexture.pack(11, 7)
 
-        model.withLayerContext(bufferSource, state, repository.getLayers(resourceIdentifier, state)) {
+        model.withLayerContext(bufferSource, state, VaryingModelRepository.getLayers(resourceIdentifier, state)) {
             model.render(context, matrixStack, buffer, packedLight, OverlayTexture.NO_OVERLAY, -0x1)
             bufferSource.endBatch()
         }

common/src/main/kotlin/com/cobblemon/mod/common/api/permission/CobblemonPermissions.kt

@@ -8,8 +8,6 @@
 
 package com.cobblemon.mod.common.api.permission
 
-import com.cobblemon.mod.common.command.AbandonMultiTeam
-
 object CobblemonPermissions {
 
     private const val COMMAND_PREFIX = "command."
@@ -18,6 +16,7 @@ object CobblemonPermissions {
     val CHANGE_EYE_HEIGHT = this.create("${COMMAND_PREFIX}changeeyeheight", PermissionLevel.ALL_COMMANDS)
     val CHANGE_SCALE_AND_SIZE = this.create("${COMMAND_PREFIX}changescaleandsize", PermissionLevel.ALL_COMMANDS)
     val CHANGE_WALK_SPEED = this.create("${COMMAND_PREFIX}changewalkspeed", PermissionLevel.ALL_COMMANDS)
+    val CHANGE_JOINT_SCALE = this.create("${COMMAND_PREFIX}changejointscale", PermissionLevel.ALL_COMMANDS)
     val CHECKSPAWNS = this.create("${COMMAND_PREFIX}checkspawns", PermissionLevel.CHEAT_COMMANDS_AND_COMMAND_BLOCKS)
 
     val GET_NBT = this.create("${COMMAND_PREFIX}getnbt", PermissionLevel.ALL_COMMANDS)
@@ -64,6 +63,9 @@ object CobblemonPermissions {
 
     val POKEBOX = this.create("${COMMAND_PREFIX}pokebox", PermissionLevel.CHEAT_COMMANDS_AND_COMMAND_BLOCKS)
 
+    val RENAMEBOX = this.create("${COMMAND_PREFIX}renamebox", PermissionLevel.CHEAT_COMMANDS_AND_COMMAND_BLOCKS)
+    val CHANGE_WALLPAPER = this.create("${COMMAND_PREFIX}changewallpaper", PermissionLevel.CHEAT_COMMANDS_AND_COMMAND_BLOCKS)
+
     val TEST_STORE = this.create("${COMMAND_PREFIX}teststore", PermissionLevel.CHEAT_COMMANDS_AND_COMMAND_BLOCKS)
 
     val QUERY_LEARNSET = this.create("${COMMAND_PREFIX}querylearnset", PermissionLevel.CHEAT_COMMANDS_AND_COMMAND_BLOCKS)
@@ -84,6 +86,8 @@ object CobblemonPermissions {
 
     val RUN_MOLANG_SCRIPT = this.create("${COMMAND_PREFIX}runmolangscript", PermissionLevel.CHEAT_COMMANDS_AND_COMMAND_BLOCKS)
 
+    val COBBLEMON_CONFIG_RELOAD = this.create("${COMMAND_PREFIX}cobblemonconfig.reload", PermissionLevel.CHEAT_COMMANDS_AND_COMMAND_BLOCKS)
+
     fun all(): Iterable<Permission> = this.permissions
 
     private fun create(node: String, level: PermissionLevel): Permission {

common/src/main/kotlin/com/cobblemon/mod/common/api/pokeball/catching/calculators/PokedexStatusCaptureInfluencer.kt

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.pokeball.catching.calculators
+
+import com.cobblemon.mod.common.api.pokeball.catching.CaptureContext
+import com.cobblemon.mod.common.api.pokedex.PokedexEntryProgress
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.util.pokedex
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.world.entity.LivingEntity
+
+/**
+ * An influencer on capture results based on Pokedex data.
+ */
+interface PokedexStatusCaptureInfluencer {
+
+    /**
+     * Attempts to influence the [context] of a capture.
+     *
+     * @param thrower The [LivingEntity] that threw the Pokeball
+     * @param target The [PokemonEntity] attempting to capture.
+     * @param context The calculated [CaptureContext].
+     * @return The final [CaptureContext].
+     */
+    fun influence(thrower: LivingEntity, target: PokemonEntity, context: CaptureContext): CaptureContext {
+        if (!context.isSuccessfulCapture) {
+            return context
+        }
+        val player = thrower as? ServerPlayer ?: return context
+        val pokedex = player.pokedex()
+        val speciesId = target.pokemon.species.resourceIdentifier
+        val formName = target.pokemon.form.name
+        val hasCaughtStatus = pokedex.getOrCreateSpeciesRecord(speciesId)
+            .getOrCreateFormRecord(formName)
+            .knowledge == PokedexEntryProgress.CAUGHT
+        // In modern games when the catch is a success and the Pokémon has already been registered to the Pokédex
+        // the catch becomes a critical capture and only requires one shake
+        return if (hasCaughtStatus) {
+            CaptureContext(
+                numberOfShakes = 1,
+                isSuccessfulCapture = true,
+                isCriticalCapture = true
+            )
+        } else context
+    }
+
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/pokemon/PokemonSortMode.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.pokemon
+
+import com.cobblemon.mod.common.pokemon.Pokemon
+
+enum class PokemonSortMode(val comparator: Comparator<Pokemon?>, val reverseComparator: Comparator<Pokemon?>) {
+    NAME( { it?.getDisplayName()?.string } ),
+    LEVEL( { it?.level } ),
+    TYPE( { it?.primaryType?.name } );
+
+    constructor(mapper: (Pokemon?) -> Comparable<*>?) : this(compareBy({ it == null }, mapper),
+        compareBy<Pokemon?> { it == null }.thenComparing(compareBy(mapper).reversed()))
+
+    fun comparator(descending: Boolean) = if (descending) reverseComparator else comparator
+}

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,7 @@ 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.spawning.TimeRange
 import com.cobblemon.mod.common.api.types.ElementalType
 import com.cobblemon.mod.common.api.types.adapters.ElementalTypeAdapter
@@ -42,17 +44,19 @@ import com.cobblemon.mod.common.pokemon.SpeciesAdditions
 import com.cobblemon.mod.common.pokemon.evolution.adapters.CobblemonEvolutionAdapter
 import com.cobblemon.mod.common.pokemon.evolution.adapters.CobblemonPreEvolutionAdapter
 import com.cobblemon.mod.common.pokemon.evolution.adapters.CobblemonRequirementAdapter
-import com.cobblemon.mod.common.pokemon.evolution.adapters.NbtItemPredicateAdapter
-import com.cobblemon.mod.common.pokemon.evolution.predicate.NbtItemPredicate
+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.riding.RideControllerAdapter
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.google.common.collect.HashBasedTable
 import com.google.gson.Gson
 import com.google.gson.GsonBuilder
 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,13 +97,16 @@ 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)
         .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Structure::class.java).type, StructureLikeConditionAdapter)
         .registerTypeAdapter(EggGroup::class.java, EggGroupAdapter)
         .registerTypeAdapter(MobEffect::class.java, RegistryElementAdapter<MobEffect>(BuiltInRegistries::MOB_EFFECT))
-        .registerTypeAdapter(NbtItemPredicate::class.java, NbtItemPredicateAdapter)
+        .registerTypeAdapter(ItemPredicate::class.java, LegacyItemConditionWrapperAdapter)
+        .registerTypeAdapter(RideController::class.java, RideControllerAdapter)
+        .registerTypeAdapter(Expression::class.java, ExpressionAdapter)
         .disableHtmlEscaping()
         .enableComplexMapKeySerialization()
         .create()

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

@@ -105,6 +105,9 @@ interface Evolution : EvolutionLike {
      * @param pokemon The [Pokemon] being evolved.
      */
     fun evolve(pokemon: Pokemon): Boolean {
+        if (this.consumeHeldItem) {
+            pokemon.swapHeldItem(ItemStack.EMPTY)
+        }
         if (this.optional) {
             // All the networking is handled under the hood, see EvolutionController.
             return pokemon.evolutionProxy.server().add(this)
@@ -220,10 +223,6 @@ interface Evolution : EvolutionLike {
 
         this.shed(pokemon)
 
-        if (this.consumeHeldItem) {
-            pokemon.swapHeldItem(ItemStack.EMPTY)
-        }
-
         val ownerPlayer = pokemon.getOwnerPlayer()
         if (ownerPlayer != null && ownerPlayer.level().gameRules.getBoolean(CobblemonGameRules.DO_POKEMON_LOOT)) {
             drops.drop(

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

@@ -0,0 +1,76 @@
+/*
+ * 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.pokemon.stats
+
+import com.cobblemon.mod.common.api.battles.model.PokemonBattle
+import com.cobblemon.mod.common.battles.pokemon.BattlePokemon
+import com.cobblemon.mod.common.pokemon.Pokemon
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.world.item.ItemStack
+
+interface EvSource {
+
+    /**
+     * The [Pokemon] being affected.
+     */
+    val pokemon: Pokemon
+
+    /**
+     * Utility function that checks if the source is an implementation of [BattleEvSource].
+     */
+    fun isBattle() = this is BattleEvSource
+
+    /**
+     * Utility function that checks if the source is an implementation of [ItemEvSource].
+     */
+    fun isInteraction() = this is ItemEvSource
+
+    /**
+     * Utility function that checks if the source is an implementation of [SidemodEvSource].
+     */
+    fun isSidemod() = this is SidemodEvSource
+
+}
+
+/**
+ * Triggered by sidemods.
+ *
+ * @property sidemodId The mod ID of the sidemod triggering this source.
+ * @property pokemon See [EvSource.pokemon].
+ */
+open class SidemodEvSource(
+    val sidemodId: String,
+    override val pokemon: Pokemon
+) : EvSource
+
+/**
+ * An Ev source fired when using Ev mutating items.
+ *
+ * @property player The [ServerPlayer] using the item.
+ * @property stack The [ItemStack] being consumed.
+ * @property pokemon See [EvSource.pokemon].
+ */
+open class ItemEvSource(
+    val player: ServerPlayer,
+    val stack: ItemStack,
+    override val pokemon: Pokemon
+) : EvSource
+
+/**
+ * An Ev source fired in battles.
+ *
+ * @property battle The associated [PokemonBattle].
+ * @property facedPokemon The [BattlePokemon]s that the [pokemon] faced.
+ * @property pokemon See [EvSource.pokemon], comes from the original [BattlePokemon.effectedPokemon].
+ */
+open class BattleEvSource(
+    val battle: PokemonBattle,
+    val facedPokemon: List<BattlePokemon>,
+    override val pokemon: Pokemon
+) : EvSource

common/src/main/kotlin/com/cobblemon/mod/common/api/reactive/EventObservables.kt

@@ -45,4 +45,15 @@ open class CancelableObservable<T : Cancelable> : EventObservable<T>() {
             }
         }
     }
+
+    inline fun postThenFinally(event: T, ifCanceled: (T) -> Unit = {}, finally: (T) -> Unit = {},ifSucceeded: (T) -> Unit) {
+        post(event) {
+            if (it.isCanceled) {
+                ifCanceled(it)
+            } else {
+                ifSucceeded(it)
+            }
+            finally(it)
+        }
+    }
 }

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.5.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,197 @@
+/*
+ * 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.Rollable
+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.ChatFormatting
+import net.minecraft.network.chat.Component
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.util.SmoothDouble
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.player.Player
+import net.minecraft.world.phys.Vec2
+import net.minecraft.world.phys.Vec3
+import kotlin.math.sin
+
+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)
+        //val speedPlayer = driver.deltaMovement.horizontalDistance()
+        //driver.displayClientMessage(Component.literal("Speed player: ").withStyle { it.withColor(ChatFormatting.GREEN) }.append(Component.literal("$speedPlayer b/t")), true)
+        //val speedEntity = entity.deltaMovement.length()  //* 20 * 60 * 60) / ( 1000 )
+        //println(speedEntity)
+        //driver.displayClientMessage(Component.literal("Speed: ").withStyle { it.withColor(ChatFormatting.GREEN) }.append(Component.literal("${String.format("%.2f", speedEntity)} km/h")), 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 fuelBar(entity: PokemonEntity, driver: Player): Float {
+        val controller = getController(entity) ?: return 0.0f
+        return controller.fuelBar(entity, driver)
+    }
+
+    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)
+    }
+
+    /**
+     * Used to supply the dela for the lerp() between velocity
+     * vectors. Called inertia for now as the way it feels when
+     * affecting the ride is somewhat akin to inertia.
+     */
+    fun inertia(entity: PokemonEntity): Double {
+        val controller = getController(entity) ?: return 0.5
+        return controller.inertia(entity)
+    }
+
+    //Can be accomplished through the velocity controls
+    fun gravity(entity: PokemonEntity, regularGravity: Double): Double? {
+        val controller = getController(entity) ?: return null
+        return controller.gravity(entity, regularGravity)
+    }
+
+    //Maybe should be changed to be a function that conveys:
+    // "turn on use our camera system function"
+    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()
+    }
+
+    //this is called just as often as
+    fun rotationOnMouseXY
+                ( entity: PokemonEntity,
+                  driver: Player,
+                  yMouse: Double,
+                  xMouse: Double,
+                  yMouseSmoother: SmoothDouble,
+                  xMouseSmoother: SmoothDouble,
+                  sensitivity: Double,
+                  deltaTime: Double ): Vec3
+    {
+        val controller = getController(entity) ?: return Vec3.ZERO
+        return controller.rotationOnMouseXY( entity,
+                                            driver,
+                                            yMouse,
+                                            xMouse,
+                                            yMouseSmoother,
+                                            xMouseSmoother,
+                                            sensitivity,
+                                            deltaTime )
+    }
+
+    /**
+     * Determines whether mouse input will affect the rotation of
+     * the rollable object. Need to remove this as it's not used anymore
+     */
+    //I think this might better serve as a "use smoothing on angular velocity"useAngVelSmoothing
+    fun useAngVelSmoothing(entity: PokemonEntity): Boolean {
+        val controller = getController(entity) ?: return true
+        return controller.useAngVelSmoothing(entity)
+    }
+
+    fun turnOffOnGround(entity: PokemonEntity): Boolean {
+        val controller = getController(entity) ?: return false
+        return controller.turnOffOnGround(entity)
+    }
+
+    fun angRollVel(entity: PokemonEntity, driver: Player, deltaTime: Double): Vec3 {
+        val controller = getController(entity) ?: return Vec3(0.0, 0.0, 0.0)
+        return controller.angRollVel(entity, driver, deltaTime)
+    }
+
+    fun dismountOnShift(): Boolean {
+        val controller = getController(entity) ?: return false
+        return controller.dismountOnShift(entity)
+    }
+}

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.RidingStatDefinitions
+import com.cobblemon.mod.common.util.adapters.riding.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, RidingStatDefinitions> = 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, RidingStatDefinitions> = buffer.readMap(
+                { buffer.readEnum<RidingStat>(RidingStat::class.java) },
+                { RidingStatDefinitions.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,146 @@
+/*
+ * 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.Rollable
+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.util.SmoothDouble
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.player.Player
+import net.minecraft.world.phys.Vec2
+import net.minecraft.world.phys.Vec3
+
+/**
+ * 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 x.x.x
+ */
+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
+
+    /**
+     * Sets the change current change in rotation for that tick in three
+     * dimensions
+     */
+    fun angRollVel(entity: PokemonEntity, driver: Player, deltaTime: Double): Vec3 {
+        return Vec3(0.0, 0.0, 0.0)
+    }
+
+    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 fuelBar(entity: PokemonEntity, driver: Player): Float = 0.0f
+
+    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 inertia(entity: PokemonEntity ) : Double = 0.5
+
+    fun shouldRoll(entity: PokemonEntity): Boolean = false
+
+    fun useAngVelSmoothing(entity: PokemonEntity): Boolean = false
+
+    //If function is not overwritten by controllers then just perform the defualt
+    //rolling function which is roll on mousex and pitch on mousey
+    fun rotationOnMouseXY
+                (entity: PokemonEntity,
+                 driver: Player,
+                 yMouse: Double,
+                 xMouse: Double,
+                 yMouseSmoother: SmoothDouble,
+                 xMouseSmoother: SmoothDouble,
+                 sensitivity: Double,
+                 deltaTime: Double ): Vec3
+    {
+        if(driver !is Rollable) return Vec3.ZERO
+
+        //Might need to add the somothing here for default.
+        val rollable = driver as Rollable
+        return Vec3(0.0, yMouse, xMouse )
+    }
+
+    fun turnOffOnGround(entity: PokemonEntity): Boolean = false
+
+    fun dismountOnShift(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/RidingStatDefinitions.kt

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

common/src/main/kotlin/com/cobblemon/mod/common/api/serialization/StringIdentifiedObjectAdapter.kt

@@ -11,6 +11,9 @@ package com.cobblemon.mod.common.api.serialization
 import com.google.gson.JsonDeserializationContext
 import com.google.gson.JsonDeserializer
 import com.google.gson.JsonElement
+import com.google.gson.JsonPrimitive
+import com.google.gson.JsonSerializationContext
+import com.google.gson.JsonSerializer
 import java.lang.reflect.Type
 
 /**
@@ -19,6 +22,13 @@ import java.lang.reflect.Type
  * @author Hiroku
  * @since July 18th, 2022
  */
-class StringIdentifiedObjectAdapter<T>(val fromString: (String) -> T) : JsonDeserializer<T> {
+class StringIdentifiedObjectAdapter<T>(
+    val fromString: (String) -> T,
+    val toString: ((T) -> String)? = null,
+) : JsonDeserializer<T>, JsonSerializer<T> {
     override fun deserialize(json: JsonElement, type: Type, ctx: JsonDeserializationContext) = fromString(json.asString)
+    override fun serialize(src: T, type: Type?, ctx: JsonSerializationContext?): JsonElement? {
+        val stringValue = toString?.invoke(src) ?: throw IllegalStateException("No toString function provided for serialization.")
+        return JsonPrimitive(stringValue)
+    }
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/snowstorm/ParticleCameraMode.kt

@@ -498,7 +498,7 @@ class LookAtDirection : ParticleCameraMode {
         rotation.hamiltonProduct(Axis.ZP.rotationDegrees(particleAngle))
 
         // Minecraft in 1.21 or 1.20.4 or something fucked with vertex draw order, and it flipped everything.
-        rotation.hamiltonProduct(Axis.YP.rotationDegrees(180F))
+        rotation.hamiltonProduct(Axis.XP.rotationDegrees(180F))
 
         return rotation
     }

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

@@ -83,8 +83,9 @@ object BestSpawner {
     var defaultPokemonDespawner: Despawner<PokemonEntity> = CobblemonAgingDespawner(getAgeTicks = { it.ticksLived })
     lateinit var fishingSpawner: FishingSpawner
 
-    fun loadConfig() {
+    fun init() {
         LOGGER.info("Starting the Best Spawner...")
+
         SpawningCondition.register(BasicSpawningCondition.NAME, BasicSpawningCondition::class.java)
         SpawningCondition.register(AreaSpawningCondition.NAME, AreaSpawningCondition::class.java)
         SpawningCondition.register(SubmergedSpawningCondition.NAME, SubmergedSpawningCondition::class.java)
@@ -94,6 +95,7 @@ object BestSpawner {
         SpawningCondition.register(FishingSpawningCondition.NAME, FishingSpawningCondition::class.java)
 
         LOGGER.info("Loaded ${SpawningCondition.conditionTypes.size} spawning condition types.")
+
         SpawningContextCalculator.register(GroundedSpawningContextCalculator)
         SpawningContextCalculator.register(SeafloorSpawningContextCalculator)
         SpawningContextCalculator.register(LavafloorSpawningContextCalculator)
@@ -113,14 +115,23 @@ object BestSpawner {
         SpawnDetail.registerSpawnType(name = NPCSpawnDetail.TYPE, NPCSpawnDetail::class.java)
         LOGGER.info("Loaded ${SpawnDetail.spawnDetailTypes.size} spawn detail types.")
 
-        config = BestSpawnerConfig.load()
+        loadConfig()
 
         SpawnDetailPresets.registerPresetType(BasicSpawnDetailPreset.NAME, BasicSpawnDetailPreset::class.java)
         SpawnDetailPresets.registerPresetType(PokemonSpawnDetailPreset.NAME, PokemonSpawnDetailPreset::class.java)
     }
 
+    fun loadConfig() {
+        config = BestSpawnerConfig.load()
+    }
+
+    fun reloadConfig() {
+        loadConfig()
+        spawnerManagers.forEach(SpawnerManager::onConfigReload)
+    }
+
     fun onServerStarted() {
         spawnerManagers.forEach(SpawnerManager::onServerStarted)
         fishingSpawner = FishingSpawner()
     }
-}
+}

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

@@ -96,4 +96,4 @@ object SpawnDetailPresets : JsonDataRegistry<SpawnDetailPreset> {
         this.presets = data.toMutableMap()
         Cobblemon.LOGGER.info("Loaded ${presets.size} spawn detail presets.")
     }
-}
+}

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

@@ -10,6 +10,7 @@ package com.cobblemon.mod.common.api.spawning
 
 import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.api.spawning.influence.SpawningInfluence
+import com.cobblemon.mod.common.api.spawning.spawner.PlayerSpawner
 import com.cobblemon.mod.common.api.spawning.spawner.Spawner
 import com.cobblemon.mod.common.api.spawning.spawner.TickingSpawner
 import com.cobblemon.mod.common.util.server
@@ -58,6 +59,12 @@ open class SpawnerManager {
         }
     }
 
+    open fun onConfigReload() {
+        spawners.filterIsInstance<PlayerSpawner>().forEach {
+            it.ticksBetweenSpawns = Cobblemon.config.ticksBetweenSpawnAttempts
+        }
+    }
+
     open fun onServerStarted() {
         spawners.clear()
     }

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

@@ -161,4 +161,4 @@ abstract class SpawningCondition<T : SpawningContext> {
             return false
         return true
     }
-}
+}

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

@@ -221,4 +221,4 @@ abstract class SpawningContext {
         }
         return false
     }
-}
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/context/calculators/SpawningContextCalculator.kt

@@ -64,4 +64,4 @@ open class SpawningContextInput(
     val cause: SpawnCause,
     /** The [Level] the spawning context exists in. */
     val world: ServerLevel
-)
+)

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

@@ -103,4 +103,4 @@ abstract class SpawnDetail : ModDependant {
     }
 
     abstract fun doSpawn(ctx: SpawningContext): SpawnAction<*>
-}
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/rules/component/FilterRuleComponent.kt

@@ -11,6 +11,7 @@ package com.cobblemon.mod.common.api.spawning.rules.component
 import com.bedrockk.molang.Expression
 import com.bedrockk.molang.ast.BooleanExpression
 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.spawning.context.SpawningContext
 import com.cobblemon.mod.common.api.spawning.detail.SpawnDetail
@@ -33,7 +34,7 @@ class FilterRuleComponent : SpawnRuleComponent {
 
     val spawnSelector: SpawnDetailSelector = AllSpawnDetailSelector
     val contextSelector: SpawningContextSelector = AllSpawningContextSelector
-    val allow: Expression = BooleanExpression(true)
+    val allow: Expression = BooleanExpression(false)
 
     override fun affectSpawnable(detail: SpawnDetail, ctx: SpawningContext): Boolean {
         return if (spawnSelector.selects(detail) && contextSelector.selects(ctx)) {

common/src/main/kotlin/com/cobblemon/mod/common/api/storage/adapter/flatfile/JSONStoreAdapter.kt

@@ -46,16 +46,16 @@ open class JSONStoreAdapter(
 
     override fun <E, T : PokemonStore<E>> load(file: File, storeClass: Class<out T>, uuid: UUID, registryAccess: RegistryAccess): T? {
         return try {
-            val br = BufferedReader(FileReader(file))
-            val json = gson.fromJson<JsonObject>(br)
-            br.close()
-            val store = try {
-                storeClass.getConstructor(UUID::class.java, UUID::class.java).newInstance(uuid, uuid)
-            } catch (exception: NoSuchMethodException) {
-                storeClass.getConstructor(UUID::class.java).newInstance(uuid)
+            file.reader().use {
+                val json = gson.fromJson<JsonObject>(it)
+                val store = try {
+                    storeClass.getConstructor(UUID::class.java, UUID::class.java).newInstance(uuid, uuid)
+                } catch (exception: NoSuchMethodException) {
+                    storeClass.getConstructor(UUID::class.java).newInstance(uuid)
+                }
+                store.loadFromJSON(json, registryAccess)
+                store
             }
-            store.loadFromJSON(json, registryAccess)
-            store
         } catch (e: Exception) {
             null
         }

common/src/main/kotlin/com/cobblemon/mod/common/api/storage/adapter/flatfile/OneToOneFileStoreAdapter.kt

@@ -42,6 +42,7 @@ abstract class OneToOneFileStoreAdapter<S>(
 ) : FileStoreAdapter<S>, CobblemonAdapterParent<S>() {
     abstract fun save(file: File, serialized: S)
     abstract fun <E, T : PokemonStore<E>> load(file: File, storeClass: Class<out T>, uuid: UUID, registryAccess: RegistryAccess): T?
+
     fun getFile(storeClass: Class<out PokemonStore<*>>, uuid: UUID): File {
         val className = storeClass.simpleName.lowercase()
         val subfolder1 = if (folderPerClass) "$className/" else ""
@@ -56,34 +57,54 @@ abstract class OneToOneFileStoreAdapter<S>(
     override fun save(storeClass: Class<out PokemonStore<*>>, uuid: UUID, serialized: S) {
         val file = getFile(storeClass, uuid)
         val tempFile = File(file.absolutePath + ".temp")
+        val oldFile = File(file.absolutePath + ".old")
         tempFile.createNewFile()
         save(tempFile, serialized)
+        if (file.exists()) {
+            file.copyTo(oldFile, overwrite = true)
+        }
         tempFile.copyTo(file, overwrite = true)
         tempFile.delete()
     }
 
     override fun <E : StorePosition, T : PokemonStore<E>> provide(storeClass: Class<T>, uuid: UUID, registryAccess: RegistryAccess): T? {
         val file = getFile(storeClass, uuid)
-        val tempFile = File(file.absolutePath + ".temp")
-        if (tempFile.exists()) {
-            try {
-                val tempLoaded = load(tempFile, storeClass, uuid, registryAccess)
-                if (tempLoaded != null) {
-                    save(file, serialize(tempLoaded, registryAccess))
-                    return tempLoaded
-                }
-            } finally {
-                tempFile.delete()
-            }
-        }
+        val oldFile = File(file.absolutePath + ".old")
 
-        return if (file.exists()) {
+        return if (file.exists() && file.length() > 0L) {
             load(file, storeClass, uuid, registryAccess)
                 ?: let {
-                    LOGGER.error("Pokémon save file for ${storeClass.simpleName} ($uuid) was corrupted. A fresh file will be created.")
-                    storeClass.getConstructor(UUID::class.java).newInstance(uuid)
+                    file.delete()
+                    if (oldFile.exists() && oldFile.length() > 0L) {
+                        var result = load(oldFile, storeClass, uuid, registryAccess) ?: let {
+                            LOGGER.error("Pokémon save file for ${storeClass.simpleName} ($uuid) was corrupted. A fresh file will be created.")
+                            var result = storeClass.getConstructor(UUID::class.java).newInstance(uuid)
+                            save(storeClass, uuid, serialize(result, registryAccess))
+                            oldFile.delete()
+                            return result
+                        }
+                        LOGGER.warn("Loading old Pokémon save file for ${storeClass.simpleName} ($uuid) due to corruption of current file.")
+                        oldFile.copyTo(file, overwrite = true)
+                        result
+                    }
+                    else {
+                        storeClass.getConstructor(UUID::class.java).newInstance(uuid)
+                        var result = storeClass.getConstructor(UUID::class.java).newInstance(uuid)
+                        save(storeClass, uuid, serialize(result, registryAccess))
+                        oldFile.delete()
+                        result
+                    }
                 }
         } else {
+            file.delete()
+            if (oldFile.exists() && oldFile.length() > 0L) {
+                var result = load(oldFile, storeClass, uuid, registryAccess) ?: let {
+                    oldFile.delete()
+                    return null
+                }
+                oldFile.copyTo(file, overwrite = true)
+                result
+            }
             null
         }
     }

common/src/main/kotlin/com/cobblemon/mod/common/api/storage/party/PlayerPartyStore.kt

@@ -167,10 +167,10 @@ open class PlayerPartyStore(
         }
 
         // Shoulder validation code
-        if (player.shoulderEntityLeft.isPokemonEntity() && !validateShoulder(player.shoulderEntityLeft, true)) {
+        if (player.shoulderEntityLeft.isPokemonEntity() && !validateShoulder(player, true)) {
             player.respawnEntityOnShoulder(player.shoulderEntityLeft)
         }
-        if (player.shoulderEntityRight.isPokemonEntity() && !validateShoulder(player.shoulderEntityRight, false)) {
+        if (player.shoulderEntityRight.isPokemonEntity() && !validateShoulder(player, false)) {
             player.respawnEntityOnShoulder(player.shoulderEntityRight)
         }
 
@@ -182,11 +182,14 @@ open class PlayerPartyStore(
         }
     }
 
-    fun validateShoulder(shoulderEntity: CompoundTag, isLeft: Boolean): Boolean {
+    private fun validateShoulder(player: ServerPlayer, isLeft: Boolean): Boolean {
+        val shoulderEntity = if(isLeft) player.shoulderEntityLeft else player.shoulderEntityRight
         val pokemon = find { it.uuid == shoulderEntity.getCompound("Pokemon").getUUID(DataKeys.POKEMON_UUID) }
-        if (pokemon == null || (pokemon.state as? ShoulderedState)?.isLeftShoulder != isLeft) {
+        // No longer valid if (in order): not in party, not the correct shoulder, no longer shoulder mountable
+        if (pokemon == null || (pokemon.state as? ShoulderedState)?.isLeftShoulder != isLeft || !pokemon.form.shoulderMountable) {
             return false
         }
+        player.updateShoulderNbt(pokemon)
         return true
     }
 

common/src/main/kotlin/com/cobblemon/mod/common/api/storage/pc/PCBox.kt

@@ -8,16 +8,19 @@
 
 package com.cobblemon.mod.common.api.storage.pc
 
+import com.cobblemon.mod.common.api.pokemon.PokemonSortMode
 import com.cobblemon.mod.common.api.reactive.Observable.Companion.stopAfter
 import com.cobblemon.mod.common.api.reactive.SimpleObservable
 import com.cobblemon.mod.common.api.storage.InvalidSpeciesException
 import com.cobblemon.mod.common.api.storage.StoreCoordinates
-import com.cobblemon.mod.common.net.messages.client.storage.pc.SetPCBoxPokemonPacket
+import com.cobblemon.mod.common.net.messages.client.storage.pc.SetPCBoxPacket
 import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.util.DataKeys
+import com.cobblemon.mod.common.util.cobblemonResource
 import com.google.gson.JsonObject
 import net.minecraft.core.RegistryAccess
 import net.minecraft.nbt.CompoundTag
+import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerPlayer
 
 /**
@@ -34,6 +37,18 @@ open class PCBox(val pc: PCStore) : Iterable<Pokemon> {
 
     protected var emit = true
 
+    var name : String? = null
+        set(value) {
+            field = value
+            if (emit) boxChangeEmitter.emit(Unit)
+        }
+
+    var wallpaper : ResourceLocation = cobblemonResource("textures/gui/pc/pc_screen_overlay.png")
+        set(value) {
+            field = value
+            if (emit) boxChangeEmitter.emit(Unit)
+        }
+
     protected val pokemon = Array<Pokemon?>(POKEMON_PER_BOX) { null }
 
     open operator fun get(index: Int): Pokemon? {
@@ -88,6 +103,13 @@ open class PCBox(val pc: PCStore) : Iterable<Pokemon> {
         boxChangeEmitter.subscribe { pc.pcChangeObservable.emit(Unit) }
     }
 
+    fun sort(sortMode: PokemonSortMode, descending: Boolean) {
+        pokemon.sortWith(sortMode.comparator(descending))
+        pokemon.forEachIndexed { slot, pokemon ->
+            pokemon?.storeCoordinates?.set(StoreCoordinates(pc, PCPosition(boxNumber, slot)))
+        }
+    }
+
     fun trackPokemon(pokemon: Pokemon) {
         pokemon.getChangeObservable()
             .pipe(
@@ -100,10 +122,14 @@ open class PCBox(val pc: PCStore) : Iterable<Pokemon> {
     }
 
     fun sendTo(player: ServerPlayer) {
-        SetPCBoxPokemonPacket(this).sendToPlayer(player)
+        SetPCBoxPacket(this).sendToPlayer(player)
     }
 
     open fun saveToNBT(nbt: CompoundTag, registryAccess: RegistryAccess): CompoundTag {
+        name?.let {
+            nbt.putString(DataKeys.STORE_BOX_NAME, it)
+        }
+        nbt.putString(DataKeys.STORE_BOX_WALLPAPER, wallpaper.toString())
         for (slot in 0 until POKEMON_PER_BOX) {
             val pokemon = pokemon[slot] ?: continue
             nbt.put(DataKeys.STORE_SLOT + slot, pokemon.saveToNBT(registryAccess))
@@ -112,6 +138,10 @@ open class PCBox(val pc: PCStore) : Iterable<Pokemon> {
     }
 
     open fun saveToJSON(json: JsonObject, registryAccess: RegistryAccess): JsonObject {
+        name?.let {
+            json.addProperty(DataKeys.STORE_BOX_NAME, it)
+        }
+        json.addProperty(DataKeys.STORE_BOX_WALLPAPER, wallpaper.toString())
         for (slot in 0 until POKEMON_PER_BOX) {
             val pokemon = pokemon[slot] ?: continue
             json.add(DataKeys.STORE_SLOT + slot, pokemon.saveToJSON(registryAccess))
@@ -119,7 +149,16 @@ open class PCBox(val pc: PCStore) : Iterable<Pokemon> {
         return json
     }
 
+
     open fun loadFromJSON(json: JsonObject, registryAccess: RegistryAccess): PCBox {
+        if (json.has(DataKeys.STORE_BOX_NAME)) {
+            name = json.getAsJsonPrimitive(DataKeys.STORE_BOX_NAME).asString
+        }
+
+        if (json.has(DataKeys.STORE_BOX_WALLPAPER)) {
+            wallpaper = ResourceLocation.parse(json.getAsJsonPrimitive(DataKeys.STORE_BOX_WALLPAPER).asString)
+        }
+
         for (slot in 0 until POKEMON_PER_BOX) {
             if (json.has(DataKeys.STORE_SLOT + slot)) {
                 val pokemonJson = json.getAsJsonObject(DataKeys.STORE_SLOT + slot)
@@ -134,6 +173,14 @@ open class PCBox(val pc: PCStore) : Iterable<Pokemon> {
     }
 
     open fun loadFromNBT(nbt: CompoundTag, registryAccess: RegistryAccess): PCBox {
+        if (nbt.contains(DataKeys.STORE_BOX_NAME)) {
+            name = nbt.getString(DataKeys.STORE_BOX_NAME)
+        }
+
+        if (nbt.contains(DataKeys.STORE_BOX_WALLPAPER)) {
+            wallpaper = ResourceLocation.parse(nbt.getString(DataKeys.STORE_BOX_WALLPAPER))
+        }
+
         for (slot in 0 until POKEMON_PER_BOX) {
             if (nbt.contains(DataKeys.STORE_SLOT + slot)) {
                 val pokemonNBT = nbt.getCompound(DataKeys.STORE_SLOT + slot)

common/src/main/kotlin/com/cobblemon/mod/common/api/storage/pc/search/PokemonFilter.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.storage.pc.search
+
+import com.cobblemon.mod.common.pokemon.Pokemon
+
+/**
+ * Functional interface used in [Search]es
+ */
+fun interface PokemonFilter {
+    fun test(pokemon: Pokemon): Boolean
+
+    fun inverted(): PokemonFilter {
+        return PokemonFilter { pokemon -> !this.test(pokemon) }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/storage/pc/search/Search.kt

@@ -0,0 +1,71 @@
+/*
+ * 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.storage.pc.search
+
+import com.cobblemon.mod.common.api.pokemon.PokemonProperties
+import com.cobblemon.mod.common.pokemon.Pokemon
+import java.util.HashSet
+import java.util.Locale
+import java.util.UUID
+
+/**
+ * Client-side class containing currently applied filters, and cached results of which Pokémon pass or fail those filters.
+ * Used in [com.cobblemon.mod.common.client.gui.pc.PCGUI]
+ */
+class Search(
+    private val filters: Set<PokemonFilter>,
+    private val passed: MutableSet<UUID> = HashSet(),
+    private val failed: MutableSet<UUID> = HashSet()
+) {
+    companion object {
+        val DEFAULT = Search(setOf())
+        fun of(search: String): Search {
+            if (search.isBlank()) return DEFAULT
+
+            val split = search.lowercase(Locale.ROOT).trim().split(" ")
+            val filters = HashSet<PokemonFilter>()
+
+            for (piece in split) {
+                var filter = piece
+                val inverted = filter.startsWith("!")
+                if (inverted) {
+                    filter = filter.substring(1)
+                }
+                
+                val pokemonFilter: PokemonFilter = when (filter) {
+                    "holding" -> PokemonFilter { pokemon -> !pokemon.heldItem().isEmpty }
+                    "fainted" -> PokemonFilter { pokemon -> pokemon.isFainted() }
+                    "legendary" -> PokemonFilter { pokemon -> pokemon.isLegendary() }
+                    "mythical" -> PokemonFilter { pokemon -> pokemon.isMythical() }
+                    "ultrabeast", "ultra_beast" -> PokemonFilter { pokemon -> pokemon.isUltraBeast() }
+                    else -> PokemonFilter { pokemon -> PokemonProperties.parse(filter).matches(pokemon) }
+                }
+
+                if (inverted) {
+                    filters.add(pokemonFilter.inverted())
+                } else {
+                    filters.add(pokemonFilter)
+                }
+            }
+
+            return Search(filters)
+        }
+    }
+
+    fun passes(pokemon: Pokemon?): Boolean {
+        if (pokemon == null) return false
+        val uuid = pokemon.uuid
+        if (passed.contains(uuid)) return true
+        if (failed.contains(uuid)) return false
+        val passes = filters.all { it.test(pokemon) }
+        val set = if (passes) passed else failed
+        set.add(uuid)
+        return passes
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/storage/player/adapter/FileBasedPlayerDataStoreBackend.kt

@@ -8,10 +8,12 @@
 
 package com.cobblemon.mod.common.api.storage.player.adapter
 
+import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.api.storage.player.InstancedPlayerData
 import com.cobblemon.mod.common.api.storage.player.PlayerInstancedDataStoreType
 import net.minecraft.server.MinecraftServer
 import net.minecraft.world.level.storage.LevelResource
+import java.io.File
 import java.nio.file.Path
 import java.util.UUID
 
@@ -35,15 +37,70 @@ abstract class FileBasedPlayerDataStoreBackend<T : InstancedPlayerData>(
         savePath = server.getWorldPath(LevelResource.PLAYER_DATA_DIR).parent
     }
 
-    //TODO: Set file extension to be a field
-    fun getSubFile(uuid: UUID): String {
-        return if (useNestedStructure) {
-            "${uuid.toString().substring(0, 2)}/$uuid.$fileExt"
+    protected fun postSaveFileMoving(playerData: T) {
+        val tempFile = filePath(playerData.uuid, TEMPORARY_FILE_EXTENSION)
+        val oldFile = filePath(playerData.uuid, OLD_FILE_EXTENSION)
+        val file = filePath(playerData.uuid)
+        if (file.exists()) {
+            file.copyTo(oldFile, overwrite = true)
+        }
+        tempFile.copyTo(file, overwrite = true)
+        tempFile.delete()
+    }
+
+    protected fun loadWithFallback(uuid: UUID, loadFunction: (File) -> T): T {
+        val playerFile = filePath(uuid)
+        val playerFileOld = filePath(uuid, OLD_FILE_EXTENSION)
+        playerFile.parentFile.mkdirs()
+        val loadFallback: () -> T = {
+            playerFile.delete()
+            if (playerFileOld.exists() && playerFileOld.length() > 0L) {
+                try {
+                    var result = loadFunction(playerFileOld)
+                    playerFileOld.copyTo(playerFile)
+                    Cobblemon.LOGGER.debug("Loaded .old {} for {}", subfolder, uuid)
+                    result
+                } catch (e: Exception) {
+                    Cobblemon.LOGGER.error("Failed to load .old $subfolder for $uuid due to ${e.message}. Data is lost")
+                    Cobblemon.LOGGER.error(e)
+                    playerFileOld.delete()
+                    defaultData.invoke(uuid).also(::save)
+                }
+            }
+            else {
+                Cobblemon.LOGGER.error(".old File $subfolder for $uuid is corrupt or missing. Data is lost")
+                playerFileOld.delete()
+                defaultData.invoke(uuid).also(::save)
+            }
+        }
+        return if (playerFile.exists() && playerFile.length() > 0L) {
+            try {
+                loadFunction(playerFile)
+            }
+            catch (e: Exception) {
+                Cobblemon.LOGGER.warn("Failed to load $subfolder for $uuid due to ${e.message}")
+                Cobblemon.LOGGER.warn(e)
+                loadFallback()
+            }
         } else {
-            "$uuid.$fileExt"
+            loadFallback()
+        }.also { it.initialize() }
+    }
+
+    @JvmOverloads
+    fun getSubFile(uuid: UUID, extension: String? = null): String {
+        return if (useNestedStructure) {
+            "${uuid.toString().substring(0, 2)}/$uuid.$fileExt${if (extension != null) ".$extension" else ""}"
+        } else {
+            "$uuid.$fileExt.${if (extension != null) ".$extension" else ""}"
         }
     }
 
-    fun filePath(uuid: UUID) = savePath.resolve("$subfolder/${getSubFile(uuid)}").toFile()
+    @JvmOverloads
+    fun filePath(uuid: UUID, extension: String? = null): File = savePath.resolve("$subfolder/${getSubFile(uuid, extension)}").toFile()
 
+    companion object {
+        const val OLD_FILE_EXTENSION = "old"
+        const val TEMPORARY_FILE_EXTENSION = "tmp"
+    }
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/storage/player/adapter/JsonBackedPlayerDataStoreBackend.kt

@@ -28,29 +28,26 @@ abstract class JsonBackedPlayerDataStoreBackend<T : InstancedPlayerData>(
     abstract val classToken: TypeToken<T>
 
     override fun save(playerData: T) {
-        val file = filePath(playerData.uuid)
-        file.parentFile.mkdirs()
-        val pw = PrintWriter(filePath(playerData.uuid))
-        pw.write(gson.toJson(playerData))
-        pw.flush()
-        pw.close()
+        val fileTmp = filePath(playerData.uuid, TEMPORARY_FILE_EXTENSION)
+        fileTmp.parentFile.mkdirs()
+        fileTmp.printWriter().use { pw ->
+            pw.write(gson.toJson(playerData))
+        }
+        postSaveFileMoving(playerData)
     }
 
     override fun load(uuid: UUID): T {
-        val playerFile = filePath(uuid)
-        playerFile.parentFile.mkdirs()
-        return if (playerFile.exists() && playerFile.length() > 0L) {
-            gson.fromJson(BufferedReader(FileReader(playerFile)), classToken).also {
-                // Resolves old data that's missing new properties
-                val newProps = it::class.memberProperties.filterIsInstance<KMutableProperty<*>>().filter { member -> member.getter.call(it) == null }
-                if (newProps.isNotEmpty()) {
-                    val defaultData = defaultData(uuid)
-                    newProps.forEach { member -> member.setter.call(it, member.getter.call(defaultData)) }
+        return loadWithFallback(uuid) {
+            it.reader().use { reader ->
+                gson.fromJson(reader, classToken).also {
+                    // Resolves old data that's missing new properties
+                    val newProps = it::class.memberProperties.filterIsInstance<KMutableProperty<*>>().filter { member -> member.getter.call(it) == null }
+                    if (newProps.isNotEmpty()) {
+                        val defaultData = defaultData(uuid)
+                        newProps.forEach { member -> member.setter.call(it, member.getter.call(defaultData)) }
+                    }
                 }
             }
-        } else {
-            defaultData.invoke(uuid).also(::save)
-        }.also { it.initialize() }
+        }
     }
-
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/storage/player/adapter/NbtBackedPlayerData.kt

@@ -24,29 +24,24 @@ abstract class NbtBackedPlayerData<T : InstancedPlayerData>(
     type: PlayerInstancedDataStoreType
 ) : FileBasedPlayerDataStoreBackend<T>(subfolder, type, "nbt") {
     abstract val codec: Codec<T>
+
     override fun save(playerData: T) {
-        val file = filePath(playerData.uuid)
-        file.parentFile.mkdirs()
-        val os = DataOutputStream(FileOutputStream(filePath(playerData.uuid)))
-        val encodeResult = NbtOps.INSTANCE.withEncoder(codec).apply(playerData)
-        NbtIo.write(encodeResult.result().get() as CompoundTag, os)
-        os.flush()
-        os.close()
+        val fileTmp = filePath(playerData.uuid, TEMPORARY_FILE_EXTENSION)
+        fileTmp.parentFile.mkdirs()
+        val encodeResult = codec.encodeStart(NbtOps.INSTANCE, playerData)
+        NbtIo.write(encodeResult.result().get() as CompoundTag, fileTmp.toPath())
+        postSaveFileMoving(playerData)
     }
 
     override fun load(uuid: UUID): T {
-        val playerFile = filePath(uuid)
-        playerFile.parentFile.mkdirs()
-        return if (playerFile.exists() && playerFile.length() > 0L) {
-            val input = NbtIo.read(playerFile.toPath())
-            val decodeResult = NbtOps.INSTANCE.withDecoder(codec).apply(input)
-            decodeResult.getPartialOrThrow {
+        return loadWithFallback(uuid) {
+            val input = NbtIo.read(it.toPath())
+            val decodeResult = codec.decode(NbtOps.INSTANCE, input)
+            decodeResult.getOrThrow {
                 Cobblemon.LOGGER.error("Error decoding $subfolder for player uuid $uuid")
                 Cobblemon.LOGGER.error(it)
                 throw UnsupportedOperationException()
             }.first
-        } else {
-            defaultData.invoke(uuid).also(::save)
-        }.also { it.initialize() }
+        }
     }
 }

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

@@ -111,6 +111,9 @@ object CobblemonItemTags {
     @JvmField val EXPERIENCE_SHARE = create("held/experience_share")
     @JvmField val IS_FRIENDSHIP_BOOSTER = create("is_friendship_booster")
     @JvmField val ANY_HELD_ITEM = create("held/is_held_item")
+    @JvmField val BLACKLISTED_ITEMS_TO_HOLD = create("held/blacklisted_items_to_hold")
+    @JvmField val WHITELISTED_ITEMS_TO_HOLD = create("held/whitelisted_items_to_hold")
+
     /** Tag that flags items as being able to "create" [CobblemonItems.LEFTOVERS]. */
     @JvmField val LEAVES_LEFTOVERS = create("held/leaves_leftovers")
     @JvmField val LUCKY_EGG = create("held/lucky_egg")

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

@@ -68,6 +68,8 @@ class WinInstruction(val message: BattleMessage): InterpreterInstruction {
             }
         }
         battle.dispatchGo {
+            battle.winners = winners
+            battle.losers = losers
             battle.end()
             CobblemonEvents.BATTLE_VICTORY.post(BattleVictoryEvent(battle, winners, losers, wasCaught))
             ShowdownInterpreter.lastCauser.remove(battle.battleId)

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

@@ -42,7 +42,7 @@ open class FossilMultiblockEntity(
             if(masterBlockPos != null && masterBlockPos != blockPos) {
                 val chunkPos = ChunkPos(masterBlockPos)
                 if (level?.chunkSource?.hasChunk(chunkPos.x, chunkPos.z) == true) {
-                    val entity: FossilMultiblockEntity? = level?.getBlockEntity(masterBlockPos) as FossilMultiblockEntity?
+                    val entity: FossilMultiblockEntity? = level?.getBlockEntity(masterBlockPos) as? FossilMultiblockEntity?
                     field = entity?.multiblockStructure
                 }
             }

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

@@ -308,9 +308,12 @@ class HealingMachineBlockEntity(
             } else {
                 // Recharging
                 if (blockEntity.healingCharge < blockEntity.maxCharge) {
-                    val chargePerTick = (Cobblemon.config.chargeGainedPerTick).coerceAtLeast(0F)
+                    val secondsToChargeHealingMachine = (Cobblemon.config.secondsToChargeHealingMachine).coerceAtLeast(0.0)
+                    val totalTicks = secondsToChargeHealingMachine * 20
+                    val chargePerTick = if (totalTicks > 0) blockEntity.maxCharge / totalTicks else 0.0
+
                     blockEntity.healingCharge =
-                        (blockEntity.healingCharge + chargePerTick).coerceIn(0F..blockEntity.maxCharge)
+                        (blockEntity.healingCharge + chargePerTick.toFloat()).coerceIn(0F..blockEntity.maxCharge)
                     blockEntity.updateBlockChargeLevel()
                     blockEntity.updateRedstoneSignal()
                     blockEntity.markUpdated()

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

@@ -40,13 +40,8 @@ import com.cobblemon.mod.common.client.render.item.PokemonItemRenderer
 import com.cobblemon.mod.common.client.render.layer.PokemonOnShoulderRenderer
 import com.cobblemon.mod.common.client.render.models.blockbench.bedrock.animation.BedrockAnimationRepository
 import com.cobblemon.mod.common.client.render.models.blockbench.repository.BerryModelRepository
-import com.cobblemon.mod.common.client.render.models.blockbench.repository.BlockEntityModelRepository
-import com.cobblemon.mod.common.client.render.models.blockbench.repository.FossilModelRepository
-import com.cobblemon.mod.common.client.render.models.blockbench.repository.GenericBedrockEntityModelRepository
 import com.cobblemon.mod.common.client.render.models.blockbench.repository.MiscModelRepository
-import com.cobblemon.mod.common.client.render.models.blockbench.repository.NPCModelRepository
-import com.cobblemon.mod.common.client.render.models.blockbench.repository.PokeBallModelRepository
-import com.cobblemon.mod.common.client.render.models.blockbench.repository.PokemonModelRepository
+import com.cobblemon.mod.common.client.render.models.blockbench.repository.VaryingModelRepository
 import com.cobblemon.mod.common.client.render.npc.NPCRenderer
 import com.cobblemon.mod.common.client.render.pokeball.PokeBallRenderer
 import com.cobblemon.mod.common.client.render.pokemon.PokemonRenderer
@@ -77,10 +72,12 @@ import net.minecraft.client.renderer.blockentity.SignRenderer
 import net.minecraft.client.renderer.entity.EntityRenderer
 import net.minecraft.client.renderer.entity.LivingEntityRenderer
 import net.minecraft.client.resources.PlayerSkin
+import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.packs.resources.ResourceManager
 import net.minecraft.world.InteractionHand
 import net.minecraft.world.entity.player.Player
 import net.minecraft.world.phys.AABB
+import java.util.UUID
 
 object CobblemonClient {
 
@@ -94,15 +91,6 @@ object CobblemonClient {
     var checkedStarterScreen = false
     var requests = ClientPlayerActionRequests()
     var teamData = ClientPlayerTeamData()
-    var posableModelRepositories = listOf(
-        PokemonModelRepository,
-        PokeBallModelRepository,
-        NPCModelRepository,
-        FossilModelRepository,
-        BlockEntityModelRepository,
-        GenericBedrockEntityModelRepository
-    )
-
     val overlay: PartyOverlay by lazy { PartyOverlay() }
     val battleOverlay: BattleOverlay by lazy { BattleOverlay() }
     val pokedexUsageContext: PokedexUsageContext by lazy { PokedexUsageContext() }
@@ -330,9 +318,9 @@ object CobblemonClient {
         // Animations come next because models need them.
         BedrockAnimationRepository.loadAnimations(
             resourceManager = resourceManager,
-            directories = posableModelRepositories.flatMap { it.animationDirectories }
+            directories = VaryingModelRepository.animationDirectories
         )
-        posableModelRepositories.forEach { it.reload(resourceManager) }
+        VaryingModelRepository.reload(resourceManager)
 
         BerryModelRepository.reload(resourceManager)
         MiscModelRepository.reload(resourceManager)

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

@@ -10,8 +10,7 @@ package com.cobblemon.mod.common.client.entity
 
 import com.cobblemon.mod.common.api.entity.EntitySideDelegate
 import com.cobblemon.mod.common.client.render.models.blockbench.PosableState
-import com.cobblemon.mod.common.client.render.models.blockbench.repository.GenericBedrockEntityModelRepository
-import com.cobblemon.mod.common.client.render.models.blockbench.repository.RenderContext
+import com.cobblemon.mod.common.client.render.models.blockbench.repository.VaryingModelRepository
 import com.cobblemon.mod.common.entity.generic.GenericBedrockEntity
 
 class GenericBedrockClientDelegate : EntitySideDelegate<GenericBedrockEntity>, PosableState() {
@@ -24,7 +23,7 @@ class GenericBedrockClientDelegate : EntitySideDelegate<GenericBedrockEntity>, P
         super.initialize(entity)
         this.currentEntity = entity
         this.age = entity.tickCount
-        this.currentModel = GenericBedrockEntityModelRepository.getPoser(entity.category, entity.delegate as GenericBedrockClientDelegate)
+        this.currentModel = VaryingModelRepository.getPoser(entity.category, entity.delegate as GenericBedrockClientDelegate)
         currentModel!!.updateLocators(entity, this)
         updateLocatorPosition(entity.position())
 

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
@@ -29,7 +29,7 @@ import com.cobblemon.mod.common.client.render.MatrixWrapper
 import com.cobblemon.mod.common.client.render.models.blockbench.PosableState
 import com.cobblemon.mod.common.client.render.models.blockbench.animation.ActiveAnimation
 import com.cobblemon.mod.common.client.render.models.blockbench.animation.PrimaryAnimation
-import com.cobblemon.mod.common.client.render.models.blockbench.repository.PokemonModelRepository
+import com.cobblemon.mod.common.client.render.models.blockbench.repository.VaryingModelRepository
 import com.cobblemon.mod.common.client.render.pokemon.PokemonRenderer.Companion.ease
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.pokemon.Pokemon
@@ -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 {
@@ -99,7 +102,7 @@ class PokemonClientDelegate : PosableState(), PokemonSideDelegate {
                 currentPose = null
                 currentEntity.pokemon.species = PokemonSpecies.getByIdentifier(identifier)!! // TODO exception handling
                 // force a model update - handles edge case where the PosableState's tracked PosableModel isn't updated until the LivingEntityRenderer render is run
-                currentModel = PokemonModelRepository.getPoser(identifier, this)
+                currentModel = VaryingModelRepository.getPoser(identifier, this)
             } else if (data == PokemonEntity.ASPECTS) {
                 currentAspects = currentEntity.entityData.get(PokemonEntity.ASPECTS)
                 currentEntity.pokemon.shiny = currentAspects.contains("shiny")

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

@@ -24,7 +24,6 @@ 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.models.blockbench.repository.PokemonModelRepository
 import com.cobblemon.mod.common.client.render.renderScaledGuiItemIcon
 import com.cobblemon.mod.common.pokemon.Gender
 import com.cobblemon.mod.common.util.cobblemonResource
@@ -161,7 +160,6 @@ class PartyOverlay : Gui(Minecraft.getInstance()) {
                     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,
-                    repository = PokemonModelRepository,
                     state = state
                 )
                 matrices.popPose()

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

@@ -12,10 +12,11 @@ import com.cobblemon.mod.common.api.gui.renderSprite
 import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
 import com.cobblemon.mod.common.client.render.SpriteType
 import com.cobblemon.mod.common.client.render.models.blockbench.PosableState
-import com.cobblemon.mod.common.client.render.models.blockbench.repository.PokemonModelRepository
 import com.cobblemon.mod.common.client.render.models.blockbench.repository.RenderContext
+import com.cobblemon.mod.common.client.render.models.blockbench.repository.VaryingModelRepository
 import com.cobblemon.mod.common.entity.PoseType
 import com.cobblemon.mod.common.pokemon.RenderablePokemon
+import com.cobblemon.mod.common.util.math.toEulerXYZDegrees
 import com.cobblemon.mod.common.util.toHex
 import com.mojang.blaze3d.platform.Lighting
 import com.mojang.blaze3d.systems.RenderSystem
@@ -25,8 +26,10 @@ import net.minecraft.client.renderer.LightTexture
 import net.minecraft.client.renderer.RenderType
 import net.minecraft.client.renderer.texture.OverlayTexture
 import net.minecraft.resources.ResourceLocation
+import net.minecraft.util.Mth
 import org.joml.Quaternionf
 import org.joml.Vector3f
+import kotlin.math.atan
 
 fun drawProfilePokemon(
     renderablePokemon: RenderablePokemon,
@@ -41,7 +44,9 @@ fun drawProfilePokemon(
     r: Float = 1F,
     g: Float = 1F,
     b: Float = 1F,
-    a: Float = 1F
+    a: Float = 1F,
+    headYaw: Float = 0f,
+    headPitch: Float = 0f,
 ) = drawProfilePokemon(
     species = renderablePokemon.species.resourceIdentifier,
     matrixStack = matrixStack,
@@ -56,6 +61,8 @@ fun drawProfilePokemon(
     g = g,
     b = b,
     a = a,
+    headYaw = headYaw,
+    headPitch = headPitch,
 )
 
 fun drawProfilePokemon(
@@ -71,21 +78,23 @@ fun drawProfilePokemon(
     r: Float = 1F,
     g: Float = 1F,
     b: Float = 1F,
-    a: Float = 1F
+    a: Float = 1F,
+    headYaw: Float = 0f,
+    headPitch: Float = 0f,
 ) {
     RenderSystem.applyModelViewMatrix()
     matrixStack.scale(scale, scale, -scale)
 
-    val sprite = PokemonModelRepository.getSprite(species, state, SpriteType.PROFILE)
+    val sprite = VaryingModelRepository.getSprite(species, state, SpriteType.PROFILE)
 
     if (sprite == null) {
 
-        val model = PokemonModelRepository.getPoser(species, state)
-        val texture = PokemonModelRepository.getTexture(species, state)
+        val model = VaryingModelRepository.getPoser(species, state)
+        val texture = VaryingModelRepository.getTexture(species, state)
 
         val context = RenderContext()
         model.context = context
-        PokemonModelRepository.getTextureNoSubstitute(species, state).let { context.put(RenderContext.TEXTURE, it) }
+        VaryingModelRepository.getTextureNoSubstitute(species, state).let { context.put(RenderContext.TEXTURE, it) }
         val baseScale = PokemonSpecies.getByIdentifier(species)!!.getForm(state.currentAspects).baseScale
         context.put(RenderContext.SCALE, baseScale)
         context.put(RenderContext.SPECIES, species)
@@ -100,9 +109,13 @@ fun drawProfilePokemon(
 
         state.setPoseToFirstSuitable(poseType)
         state.updatePartialTicks(partialTicks)
-        model.applyAnimations(null, state, 0F, 0F, 0F, 0F, 0F)
+
         if (applyProfileTransform) {
-            matrixStack.translate(model.profileTranslation.x, model.profileTranslation.y, model.profileTranslation.z - 4.0)
+            matrixStack.translate(
+                model.profileTranslation.x,
+                model.profileTranslation.y + 1.5 * model.profileScale,
+                model.profileTranslation.z - 4.0
+            )
             matrixStack.scale(model.profileScale, model.profileScale, 1 / model.profileScale)} else {
             matrixStack.translate(0F, 0F, -4.0F)
             if (applyBaseScale) {
@@ -110,6 +123,9 @@ fun drawProfilePokemon(
             }
         }
         matrixStack.mulPose(rotation)
+
+        model.applyAnimations(null, state, 0F, 0F, 0F, headYaw, headPitch)
+
         Lighting.setupForEntityInInventory()
         val entityRenderDispatcher = Minecraft.getInstance().entityRenderDispatcher
         rotation.conjugate()
@@ -124,7 +140,7 @@ fun drawProfilePokemon(
         val packedLight = LightTexture.pack(11, 7)
 
         val colour = toHex(r, g, b, a)
-        model.withLayerContext(bufferSource, state, PokemonModelRepository.getLayers(species, state)) {
+        model.withLayerContext(bufferSource, state, VaryingModelRepository.getLayers(species, state)) {
             model.render(context, matrixStack, buffer, packedLight, OverlayTexture.NO_OVERLAY, colour)
             bufferSource.endBatch()
         }
@@ -136,3 +152,29 @@ fun drawProfilePokemon(
     }
 }
 
+const val HEAD_YAW_FACTOR = 40f
+const val HEAD_PITCH_FACTOR = 20f
+const val SMOOTHING_FACTOR = 0.05f
+
+fun calculateHeadYawAndPitch(
+    xCoordinate: Float,
+    yCoordinate: Float,
+    rotation: Quaternionf,
+    mouseX: Int,
+    mouseY: Int,
+    currentYaw: Float,
+    currentPitch: Float,
+    resetToCenter: Boolean,
+): Pair<Float, Float> {
+    val horizontalAngle = atan(((xCoordinate - mouseX) / 40.0f).toDouble()).toFloat()
+    val verticalAngle = atan(((yCoordinate - mouseY) / 40.0f).toDouble()).toFloat()
+
+    val eulerXYZRotationDegrees = rotation.toEulerXYZDegrees()
+    val targetYaw = if (!resetToCenter) horizontalAngle * HEAD_YAW_FACTOR - eulerXYZRotationDegrees.y else 0f
+    val targetPitch = if (!resetToCenter) -verticalAngle * HEAD_PITCH_FACTOR - eulerXYZRotationDegrees.x else 0f
+
+    val newYaw = Mth.rotLerp(SMOOTHING_FACTOR, currentYaw, targetYaw)
+    val newPitch = Mth.rotLerp(SMOOTHING_FACTOR, currentPitch, targetPitch)
+
+    return Pair(newYaw, newPitch)
+}

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

@@ -26,9 +26,8 @@ import com.cobblemon.mod.common.client.render.drawScaledText
 import com.cobblemon.mod.common.client.render.drawScaledTextJustifiedRight
 import com.cobblemon.mod.common.client.render.getDepletableRedGreen
 import com.cobblemon.mod.common.client.render.models.blockbench.PosableState
-import com.cobblemon.mod.common.client.render.models.blockbench.repository.PokeBallModelRepository
-import com.cobblemon.mod.common.client.render.models.blockbench.repository.PokemonModelRepository
 import com.cobblemon.mod.common.client.render.models.blockbench.repository.RenderContext
+import com.cobblemon.mod.common.client.render.models.blockbench.repository.VaryingModelRepository
 import com.cobblemon.mod.common.client.render.models.blockbench.wavefunction.sineFunction
 import com.cobblemon.mod.common.entity.PoseType
 import com.cobblemon.mod.common.entity.pokeball.EmptyPokeBallEntity
@@ -321,7 +320,6 @@ class BattleOverlay : Gui(Minecraft.getInstance()), Schedulable {
                 matrixStack = matrixStack,
                 scale = 18F * (ballState?.scale ?: 1F) * if (isCompact) 0.65F else 1.0f,
                 contextScale = species.getForm(state.currentAspects).baseScale,
-                repository = PokemonModelRepository,
                 reversed = reversed,
                 state = state,
                 partialTicks = partialTicks
@@ -490,8 +488,8 @@ class BattleOverlay : Gui(Minecraft.getInstance()), Schedulable {
         reversed: Boolean = false
     ) {
         val context = RenderContext()
-        val model = PokeBallModelRepository.getPoser(state.pokeBall.name, state)
-        val texture = PokeBallModelRepository.getTexture(state.pokeBall.name, state)
+        val model = VaryingModelRepository.getPoser(state.pokeBall.name, state)
+        val texture = VaryingModelRepository.getTexture(state.pokeBall.name, state)
         val renderType = RenderType.entityCutout(texture)//model.getLayer(texture)
 
         RenderSystem.applyModelViewMatrix()

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

@@ -0,0 +1,113 @@
+/*
+ * 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.config
+
+import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.client.gui.CobblemonRenderable
+import com.cobblemon.mod.common.config.CobblemonConfig
+import com.cobblemon.mod.common.util.asTranslated
+import com.cobblemon.mod.common.util.lang
+import net.minecraft.client.Minecraft
+import net.minecraft.client.gui.components.Button
+import net.minecraft.client.gui.components.EditBox
+import net.minecraft.client.gui.components.StringWidget
+import net.minecraft.client.gui.layouts.HeaderAndFooterLayout
+import net.minecraft.client.gui.layouts.LinearLayout
+import net.minecraft.client.gui.screens.Screen
+import net.minecraft.network.chat.CommonComponents
+
+class CobblemonConfigScreen(
+    private val previousScreen: Screen?,
+) : Screen("gui.cobblemon_config.title".asTranslated()), CobblemonRenderable {
+
+    companion object {
+        const val HEIGHT = 240
+        const val HEADER_HEIGHT = 45
+        const val FOOTER_HEIGHT = 33
+        const val PADDING = 4
+        const val SLOT_WIDTH = 340
+        const val SLOT_HEIGHT = 22
+        const val HALF_SLOT_WIDTH = SLOT_WIDTH / 2
+        const val RESET_SLOT_WIDTH = 40
+        const val WIDGET_WIDTH = 110 - RESET_SLOT_WIDTH - PADDING
+        const val WIDGET_HEIGHT = SLOT_HEIGHT - PADDING
+        const val LABEL_Y_OFFSET = 4
+        const val WIDGET_Y_OFFSET = 0
+    }
+
+    val clonedConfig = Cobblemon.config.clone()
+    val defaultConfig = CobblemonConfig()
+
+    private lateinit var layout: HeaderAndFooterLayout
+    private lateinit var searchEdit: EditBox
+    private lateinit var variableList: CobblemonConfigVariableList
+    private lateinit var doneButton: Button
+
+    private var searchString: String = ""
+
+    override fun init() {
+        super.init()
+
+        if (::layout.isInitialized) layout.visitWidgets { removeWidget(it) }
+        layout = HeaderAndFooterLayout(this, HEADER_HEIGHT, FOOTER_HEIGHT)
+
+        if (::variableList.isInitialized) removeWidget(variableList)
+        variableList = CobblemonConfigVariableList(this)
+        variableList.filterConfigurations(searchString)
+        addRenderableWidget(variableList)
+
+        searchEdit = EditBox(
+            Minecraft.getInstance().font,
+            width / 2 - HALF_SLOT_WIDTH / 2,
+            variableList.y,
+            HALF_SLOT_WIDTH,
+            SLOT_HEIGHT,
+            lang("config.ui.search_configurations"),
+        ).also {
+            it.height = WIDGET_HEIGHT
+            it.setMaxLength(250)
+
+            it.value = searchString
+            it.setResponder { text ->
+                variableList.filterConfigurations(text)
+                searchString = text
+            }
+        }
+
+        val linearLayout = layout.addToHeader(LinearLayout.vertical())
+        linearLayout.addChild(StringWidget(lang("config.ui.search_configurations"), this.font))
+        linearLayout.addChild(searchEdit)
+        layout.addToHeader(linearLayout)
+
+        doneButton = Button.builder(CommonComponents.GUI_DONE) { doneButtonClick() }
+            .pos(width / 2 - HALF_SLOT_WIDTH / 2, variableList.y + variableList.height + PADDING)
+            .width(HALF_SLOT_WIDTH).build()
+        layout.addToFooter(doneButton)
+
+        layout.visitWidgets { widget ->
+            addRenderableWidget(widget)
+        }
+        arrangeLayoutElements()
+    }
+
+    private fun arrangeLayoutElements() {
+        layout.arrangeElements()
+        variableList.updateSize(this.width, this.layout)
+    }
+
+    private fun doneButtonClick() {
+        Cobblemon.saveConfig(clonedConfig)
+        Cobblemon.reloadConfig()
+        onClose()
+    }
+
+    override fun onClose() {
+        minecraft?.setScreen(previousScreen)
+    }
+}

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

@@ -0,0 +1,190 @@
+/*
+ * 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.config
+
+import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.api.text.yellow
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigScreen.Companion.HEIGHT
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigScreen.Companion.LABEL_Y_OFFSET
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigScreen.Companion.PADDING
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigScreen.Companion.SLOT_HEIGHT
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigScreen.Companion.SLOT_WIDTH
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigVariableList.CobblemonConfigVariableListEntry
+import com.cobblemon.mod.common.client.gui.config.variable.*
+import com.cobblemon.mod.common.client.render.drawScaledText
+import com.cobblemon.mod.common.config.Category
+import com.cobblemon.mod.common.config.CobblemonConfig
+import com.cobblemon.mod.common.config.CobblemonConfigField
+import com.cobblemon.mod.common.util.asTranslated
+import net.minecraft.SharedConstants
+import net.minecraft.client.Minecraft
+import net.minecraft.client.gui.GuiGraphics
+import net.minecraft.client.gui.components.ContainerObjectSelectionList
+import net.minecraft.client.gui.components.Tooltip
+import net.minecraft.client.gui.components.events.GuiEventListener
+import net.minecraft.client.gui.narration.NarratableEntry
+import kotlin.math.min
+import kotlin.reflect.KClass
+import kotlin.reflect.KMutableProperty1
+import kotlin.reflect.full.memberProperties
+import kotlin.reflect.jvm.javaField
+
+class CobblemonConfigVariableList(
+    val parent: CobblemonConfigScreen,
+) : ContainerObjectSelectionList<CobblemonConfigVariableListEntry>(
+    Minecraft.getInstance(),
+    Minecraft.getInstance().window.guiScaledWidth,
+    HEIGHT,
+    0,
+    SLOT_HEIGHT
+) {
+
+    val entries = mutableListOf<CobblemonConfigCategory>()
+
+    init {
+        this.x = 0
+        this.y = minecraft.window.guiScaledHeight / 2 - HEIGHT / 2
+
+        setRenderHeader(false, 0)
+        addEntries()
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    private fun addEntries() {
+        parent.clonedConfig::class.memberProperties.map { property ->
+            if (!property.javaField!!.isAnnotationPresent(CobblemonConfigField::class.java)) {
+                return@map null
+            }
+
+            val entry: CobblemonConfigVariable? =
+                when (val classifier = property.returnType.classifier) {
+                    String::class -> CobblemonConfigStringVariable(this, property as KMutableProperty1<out CobblemonConfig, String>)
+                    Int::class -> CobblemonConfigIntVariable(this, property as KMutableProperty1<out CobblemonConfig, Int>)
+                    Float::class -> CobblemonConfigFloatVariable(this, property as KMutableProperty1<out CobblemonConfig, Float>)
+                    Double::class -> CobblemonConfigDoubleVariable(this, property as KMutableProperty1<out CobblemonConfig, Double>)
+                    Boolean::class -> CobblemonConfigBooleanVariable(this, property as KMutableProperty1<out CobblemonConfig, Boolean>)
+                    is KClass<*> -> if (classifier.java.isEnum) {
+                        CobblemonConfigEnumVariable(this, property as KMutableProperty1<out CobblemonConfig, Enum<*>>)
+                    } else null
+                    else -> null
+                }
+
+            if (entry == null) {
+                if (SharedConstants.IS_RUNNING_IN_IDE) {
+                    Cobblemon.LOGGER.warn("Widget for variable type: ${property.returnType.classifier} not registered: ${property.name}")
+                }
+
+                return@map null
+            }
+
+            return@map entry
+        }
+        .filterNotNull()
+        .groupBy { it.cobblemonConfigFieldAnnotation.category }
+        .toSortedMap(compareBy { it.ordinal })
+        .forEach { category, variables ->
+            val categoryEntry = CobblemonConfigCategory(this, category, variables)
+            entries.add(categoryEntry)
+        }
+
+        entries.forEach { entry -> entry.add() }
+    }
+
+    override fun renderWidget(guiGraphics: GuiGraphics, mouseX: Int, mouseY: Int, partialTick: Float) {
+        super.renderWidget(guiGraphics, mouseX, mouseY, partialTick)
+
+        val hoveredVariableTooltip = this.hovered?.tooltip
+        if (isMouseInsideScrollList(mouseX, mouseY) && hoveredVariableTooltip != null) {
+            guiGraphics.renderTooltip(minecraft.font, hoveredVariableTooltip.toCharSequence(minecraft), mouseX, mouseY)
+        }
+    }
+
+    fun isMouseInsideScrollList(mouseX: Int, mouseY: Int): Boolean {
+        val bottomX = parent.width / 2 - SLOT_WIDTH / 2
+        val upperX = parent.width / 2 + SLOT_WIDTH / 2
+
+        return mouseX >= bottomX && mouseX <= upperX && mouseY >= y && mouseY <= bottom
+    }
+
+    override fun getRowWidth(): Int = width
+    override fun getScrollbarPosition(): Int = width / 2 - SLOT_WIDTH / 2 + SLOT_WIDTH + PADDING
+
+    fun filterConfigurations(text: String) {
+        for (entry in entries) {
+            entry.remove()
+        }
+
+        for (entry in entries) {
+            if (text.isBlank() || entry.filter(text)) {
+                entry.add(text)
+            }
+        }
+
+        scrollAmount = min(maxScroll.toDouble(), scrollAmount)
+    }
+
+    abstract class CobblemonConfigVariableListEntry(
+        val parent: CobblemonConfigVariableList,
+    ) : Entry<CobblemonConfigVariableListEntry>() {
+        val children = mutableListOf<GuiEventListener>()
+        var tooltip: Tooltip? = null
+
+        fun getX(left: Int) = parent.width / 2 - SLOT_WIDTH / 2
+        fun getY(top: Int) = top
+
+        abstract fun filter(text: String): Boolean
+
+        override fun children(): MutableList<out GuiEventListener> = children
+        override fun narratables(): MutableList<out NarratableEntry> = children.filterIsInstance<NarratableEntry>().toMutableList()
+    }
+
+    class CobblemonConfigCategory(
+        parent: CobblemonConfigVariableList,
+        val category: Category,
+        val configVariables: List<CobblemonConfigVariable>
+    ) : CobblemonConfigVariableListEntry(parent) {
+        override fun render(
+            context: GuiGraphics,
+            index: Int,
+            top: Int,
+            left: Int,
+            width: Int,
+            height: Int,
+            mouseX: Int,
+            mouseY: Int,
+            hovering: Boolean,
+            partialTick: Float
+        ) {
+            drawScaledText(
+                context = context,
+                text = "cobblemon.config.ui.category.${category.lang}".asTranslated().yellow(),
+                x = parent.width / 2,
+                y = getY(top) + LABEL_Y_OFFSET,
+                shadow = true,
+                centered = true,
+            )
+        }
+
+        fun add(filter: String? = null) {
+            parent.addEntry(this)
+            configVariables.forEach { variable ->
+                if (filter == null || variable.filter(filter)) {
+                    parent.addEntry(variable)
+                }
+            }
+        }
+
+        fun remove() {
+            parent.removeEntry(this)
+            configVariables.forEach { variable -> parent.removeEntry(variable) }
+        }
+
+        override fun filter(text: String): Boolean = configVariables.any { it.filter(text) }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/config/variable/CobblemonConfigButtonVariable.kt

@@ -0,0 +1,126 @@
+/*
+ * 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.config.variable
+
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigScreen.Companion.PADDING
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigScreen.Companion.WIDGET_HEIGHT
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigScreen.Companion.WIDGET_WIDTH
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigScreen.Companion.WIDGET_Y_OFFSET
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigVariableList
+
+import com.cobblemon.mod.common.config.CobblemonConfig
+import com.cobblemon.mod.common.util.lang
+import net.minecraft.client.gui.GuiGraphics
+import net.minecraft.client.gui.components.Button
+import net.minecraft.client.gui.components.Tooltip
+import net.minecraft.network.chat.CommonComponents
+import net.minecraft.network.chat.Component
+import kotlin.reflect.KClass
+import kotlin.reflect.KMutableProperty1
+
+abstract class CobblemonConfigButtonVariable(
+    parent: CobblemonConfigVariableList,
+    config: KMutableProperty1<out CobblemonConfig, *>,
+) : CobblemonConfigVariable(parent, config) {
+    val button: Button =
+        Button.builder(labelLang) { onButtonClick() }
+            .size(WIDGET_WIDTH, WIDGET_HEIGHT)
+            .build()
+
+    init {
+        children.addFirst(button)
+    }
+
+    abstract fun onButtonClick()
+
+    override fun updateConfigValueDisplay() {
+        button.message = Component.literal(getConfigValueAsString())
+    }
+
+    override fun render(
+        context: GuiGraphics,
+        index: Int,
+        top: Int,
+        left: Int,
+        width: Int,
+        height: Int,
+        mouseX: Int,
+        mouseY: Int,
+        hovering: Boolean,
+        partialTick: Float
+    ) {
+        super.render(context, index, top, left, width, height, mouseX, mouseY, hovering, partialTick)
+
+        button.x = resetButton.x - button.width - PADDING
+        button.y = getY(top) + WIDGET_Y_OFFSET
+        button.render(context, mouseX, mouseY, partialTick)
+    }
+}
+
+class CobblemonConfigBooleanVariable(
+    parent: CobblemonConfigVariableList,
+    config: KMutableProperty1<out CobblemonConfig, Boolean>,
+) : CobblemonConfigButtonVariable(parent, config) {
+
+    init {
+        updateConfigValueDisplay()
+    }
+
+    override fun getConfigValueAsString(): String = (if (isSelected()) CommonComponents.GUI_YES else CommonComponents.GUI_NO).string
+    override fun onButtonClick() = setConfigValue(!isSelected())
+
+    private fun isSelected() = (config.getter.call(parent.parent.clonedConfig) as Boolean?) ?: false
+}
+
+class CobblemonConfigEnumVariable(
+    parent: CobblemonConfigVariableList,
+    config: KMutableProperty1<out CobblemonConfig, Enum<*>>,
+) : CobblemonConfigButtonVariable(parent, config) {
+
+    private var enumIndex = 0
+
+    @Suppress("UNCHECKED_CAST")
+    private val enumValues: Array<Enum<*>> = config.returnType.classifier
+        .let { it as? KClass<Enum<*>> }
+        ?.java?.enumConstants ?: emptyArray()
+
+    init {
+        val currentEnumValue = getCurrentEnumValue()
+        enumValues.firstOrNull { it.name == currentEnumValue?.name }?.let {
+            enumIndex = it.ordinal
+        }
+        updateConfigValueDisplay()
+    }
+
+    override fun getConfigValueAsString(): String {
+        return getCurrentEnumValue()?.name?.let {
+            lang("$labelEntry.${it.lowercase()}").string
+        } ?: ""
+    }
+
+    private fun getConfigValueTooltipString(): String {
+        return getCurrentEnumValue()?.name?.let {
+            lang("$labelEntry.${it.lowercase()}.tooltip").string
+        } ?: ""
+    }
+
+    override fun onButtonClick() {
+        enumIndex = (enumIndex + 1) % enumValues.size
+        val newEnumValue = enumValues[enumIndex]
+
+        setConfigValue(newEnumValue)
+    }
+
+    override fun updateConfigValueDisplay() {
+        super.updateConfigValueDisplay()
+        tooltip = Tooltip.create(Component.literal(getConfigValueTooltipString()))
+    }
+
+    private fun getCurrentEnumValue(): Enum<*>? = (config.getter.call(parent.parent.clonedConfig) as Enum<*>?)
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/config/variable/CobblemonConfigEditBoxVariable.kt

@@ -0,0 +1,155 @@
+/*
+ * 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.config.variable
+
+import com.cobblemon.mod.common.api.text.add
+import com.cobblemon.mod.common.api.text.red
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigScreen.Companion.PADDING
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigScreen.Companion.SLOT_HEIGHT
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigScreen.Companion.WIDGET_HEIGHT
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigScreen.Companion.WIDGET_WIDTH
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigScreen.Companion.WIDGET_Y_OFFSET
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigVariableList
+import com.cobblemon.mod.common.config.CobblemonConfig
+import com.cobblemon.mod.common.config.constraint.IntConstraint
+import com.cobblemon.mod.common.util.lang
+import net.minecraft.ChatFormatting
+import net.minecraft.client.Minecraft
+import net.minecraft.client.gui.GuiGraphics
+import net.minecraft.client.gui.components.EditBox
+import net.minecraft.client.gui.components.EditBox.DEFAULT_TEXT_COLOR
+import net.minecraft.client.gui.components.Tooltip
+import net.minecraft.network.chat.Component
+import kotlin.reflect.KMutableProperty1
+import kotlin.reflect.jvm.javaField
+
+abstract class CobblemonConfigEditBoxVariable(
+    parent: CobblemonConfigVariableList,
+    config: KMutableProperty1<out CobblemonConfig, *>,
+) : CobblemonConfigVariable(parent, config) {
+    val editBox = EditBox(
+        Minecraft.getInstance().font,
+        parent.x,
+        parent.y,
+        WIDGET_WIDTH,
+        SLOT_HEIGHT,
+        labelLang,
+    ).also {
+        it.height = WIDGET_HEIGHT
+        it.setMaxLength(250)
+
+        it.value = getConfigValueAsString()
+    }
+
+    init {
+        children.addFirst(editBox)
+    }
+
+    override fun updateConfigValueDisplay() {
+        editBox.value = getConfigValueAsString()
+    }
+
+    override fun render(
+        context: GuiGraphics,
+        index: Int,
+        top: Int,
+        left: Int,
+        width: Int,
+        height: Int,
+        mouseX: Int,
+        mouseY: Int,
+        hovering: Boolean,
+        partialTick: Float
+    ) {
+        super.render(context, index, top, left, width, height, mouseX, mouseY, hovering, partialTick)
+
+        editBox.x = resetButton.x - editBox.width - PADDING
+        editBox.y = getY(top) + WIDGET_Y_OFFSET
+        editBox.render(context, mouseX, mouseY, partialTick)
+    }
+}
+
+class CobblemonConfigStringVariable(
+    parent: CobblemonConfigVariableList,
+    config: KMutableProperty1<out CobblemonConfig, String>,
+) : CobblemonConfigEditBoxVariable(parent, config) {
+    override fun getConfigValueAsString(): String = (config.getter.call(parent.parent.clonedConfig) as String?) ?: ""
+
+    init {
+        editBox.setResponder { value ->
+            setConfigValue(value, false)
+        }
+    }
+}
+
+class CobblemonConfigIntVariable(
+    parent: CobblemonConfigVariableList,
+    config: KMutableProperty1<out CobblemonConfig, Int>,
+) : CobblemonConfigEditBoxVariable(parent, config) {
+    private val intConstraintAnnotation: IntConstraint? =
+        config.javaField!!.annotations.firstOrNull{ it is IntConstraint } as IntConstraint?
+
+    override fun getConfigValueAsString(): String = (config.getter.call(parent.parent.clonedConfig) as Int?).toString()
+
+    init {
+        editBox.setFilter { value -> value.toIntOrNull() != null || value.isBlank() }
+        editBox.setResponder { value ->
+            if (value.isBlank()) {
+                return@setResponder
+            }
+
+            val intValue = value.toInt()
+            setConfigValue(intValue, false)
+
+            if (intConstraintAnnotation != null) {
+                val isBetweenIntConstraint = intValue >= intConstraintAnnotation.min && intValue <= intConstraintAnnotation.max
+                if (isBetweenIntConstraint) {
+                    tooltip = originalTooltip
+                    editBox.setTextColor(DEFAULT_TEXT_COLOR)
+                } else {
+                    val errorLang = lang("config.ui.error.int_constraint", intConstraintAnnotation.min, intConstraintAnnotation.max).red()
+                    tooltip = Tooltip.create(tooltipLang.plainCopy().add(Component.literal("\n")).add(errorLang))
+                    ChatFormatting.RED.color?.let { editBox.setTextColor(it) }
+                }
+            }
+        }
+    }
+}
+
+class CobblemonConfigFloatVariable(
+    parent: CobblemonConfigVariableList,
+    config: KMutableProperty1<out CobblemonConfig, Float>,
+) : CobblemonConfigEditBoxVariable(parent, config) {
+    override fun getConfigValueAsString(): String = (config.getter.call(parent.parent.clonedConfig) as Float?).toString()
+
+    init {
+        editBox.setFilter { value -> value.toFloatOrNull() != null || value.isBlank() }
+        editBox.setResponder { value ->
+            if (value.toFloatOrNull() != null) {
+                setConfigValue(value.toFloat(), false)
+            }
+        }
+    }
+}
+
+class CobblemonConfigDoubleVariable(
+    parent: CobblemonConfigVariableList,
+    config: KMutableProperty1<out CobblemonConfig, Double>,
+) : CobblemonConfigEditBoxVariable(parent, config) {
+    override fun getConfigValueAsString(): String = (config.getter.call(parent.parent.clonedConfig) as Double?).toString()
+
+    init {
+        editBox.setFilter { value -> value.toDoubleOrNull() != null || value.isBlank() }
+        editBox.setResponder { value ->
+            if (value.toDoubleOrNull() != null) {
+                setConfigValue(value.toDouble(), false)
+            }
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/config/variable/CobblemonConfigVariable.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.client.gui.config.variable
+
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigScreen.Companion.LABEL_Y_OFFSET
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigScreen.Companion.RESET_SLOT_WIDTH
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigScreen.Companion.SLOT_WIDTH
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigScreen.Companion.WIDGET_HEIGHT
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigScreen.Companion.WIDGET_Y_OFFSET
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigVariableList
+import com.cobblemon.mod.common.client.gui.config.CobblemonConfigVariableList.CobblemonConfigVariableListEntry
+import com.cobblemon.mod.common.client.render.drawScaledText
+import com.cobblemon.mod.common.config.CobblemonConfig
+import com.cobblemon.mod.common.config.CobblemonConfigField
+import com.cobblemon.mod.common.util.lang
+import net.minecraft.client.gui.GuiGraphics
+import net.minecraft.client.gui.components.Button
+import net.minecraft.client.gui.components.Tooltip
+import net.minecraft.network.chat.MutableComponent
+import java.text.Normalizer
+import kotlin.reflect.KMutableProperty1
+import kotlin.reflect.jvm.javaField
+
+abstract class CobblemonConfigVariable(
+    parent: CobblemonConfigVariableList,
+    val config: KMutableProperty1<out CobblemonConfig, *>,
+) : CobblemonConfigVariableListEntry(parent) {
+    val cobblemonConfigFieldAnnotation: CobblemonConfigField =
+        config.javaField!!.annotations.firstOrNull{ it is CobblemonConfigField } as CobblemonConfigField
+
+    val labelEntry = "config.ui.${cobblemonConfigFieldAnnotation.lang}"
+    val tooltipEntry = "$labelEntry.tooltip"
+    val labelLang: MutableComponent = lang(labelEntry)
+    val tooltipLang: MutableComponent = lang(tooltipEntry)
+    val originalTooltip: Tooltip? = if (!tooltipLang.string.endsWith(tooltipEntry)) Tooltip.create(tooltipLang) else null
+
+    val resetButton: Button =
+        Button.builder(lang("config.ui.reset")) {
+            val defaultValue = config.getter.call(parent.parent.defaultConfig)
+            setConfigValue(defaultValue)
+        }
+        .size(RESET_SLOT_WIDTH, WIDGET_HEIGHT)
+        .build()
+
+    init {
+        tooltip = originalTooltip
+        children.add(resetButton)
+        updateResetButton()
+    }
+
+    abstract fun getConfigValueAsString(): String
+    abstract fun updateConfigValueDisplay()
+
+    fun setConfigValue(value: Any?, updateConfigValueDisplay: Boolean = true) {
+        config.setter.call(parent.parent.clonedConfig, value)
+
+        if (updateConfigValueDisplay) {
+            updateConfigValueDisplay()
+        }
+
+        updateResetButton()
+    }
+
+    private fun updateResetButton() {
+        resetButton.active = config.getter.call(parent.parent.clonedConfig) != config.getter.call(parent.parent.defaultConfig)
+    }
+
+    override fun filter(text: String): Boolean {
+        val normalizedLabel = Normalizer.normalize(labelLang.string, Normalizer.Form.NFD).replace("\\p{M}+".toRegex(), "")
+        return normalizedLabel.contains(text, ignoreCase = true)
+    }
+
+    override fun render(
+        context: GuiGraphics,
+        index: Int,
+        top: Int,
+        left: Int,
+        width: Int,
+        height: Int,
+        mouseX: Int,
+        mouseY: Int,
+        hovering: Boolean,
+        partialTick: Float
+    ) {
+        val x = getX(left)
+        val y = getY(top)
+
+        drawScaledText(
+            context = context,
+            text = labelLang,
+            x = getX(left),
+            y = getY(top) + LABEL_Y_OFFSET,
+            shadow = true
+        )
+
+        resetButton.x = x + SLOT_WIDTH - RESET_SLOT_WIDTH
+        resetButton.y = y + WIDGET_Y_OFFSET
+        resetButton.render(context, mouseX, mouseY, partialTick)
+    }
+}

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

@@ -15,8 +15,6 @@ import com.cobblemon.mod.common.client.entity.NPCClientDelegate
 import com.cobblemon.mod.common.client.entity.PokemonClientDelegate
 import com.cobblemon.mod.common.client.render.models.blockbench.FloatingState
 import com.cobblemon.mod.common.client.render.models.blockbench.PosableState
-import com.cobblemon.mod.common.client.render.models.blockbench.repository.NPCModelRepository
-import com.cobblemon.mod.common.client.render.models.blockbench.repository.PokemonModelRepository
 import com.cobblemon.mod.common.entity.PosableEntity
 import com.cobblemon.mod.common.entity.npc.NPCEntity
 import java.util.UUID
@@ -82,7 +80,6 @@ class ReferenceRenderableFace(val entity: PosableEntity, override val isLeftSide
             state.currentAspects = state.currentEntity.pokemon.aspects
             drawPosablePortrait(
                 identifier = state.currentEntity.pokemon.species.resourceIdentifier,
-                repository = PokemonModelRepository,
                 contextScale = state.currentEntity.pokemon.form.baseScale,
                 matrixStack = GuiGraphics.pose(),
                 state = state,
@@ -96,7 +93,6 @@ class ReferenceRenderableFace(val entity: PosableEntity, override val isLeftSide
             val limbSwingAmount = entity.walkAnimation.speed(partialTicks)
             drawPosablePortrait(
                 identifier = state.npcEntity.npc.resourceIdentifier,
-                repository = NPCModelRepository,
                 matrixStack = GuiGraphics.pose(),
                 state = state,
                 reversed = !isLeftSide,
@@ -131,7 +127,6 @@ class ArtificialRenderableFace(
                 contextScale = species.getForm(aspects).baseScale,
                 state = state,
                 reversed = !isLeftSide,
-                repository = PokemonModelRepository,
                 partialTicks = partialTicks
             )
         } else if (modelType == "npc") {
@@ -140,7 +135,6 @@ class ArtificialRenderableFace(
                 matrixStack = GuiGraphics.pose(),
                 state = state,
                 reversed = !isLeftSide,
-                repository = NPCModelRepository,
                 partialTicks = partialTicks
             )
         }

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

@@ -21,18 +21,18 @@ 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, canRide: Boolean): InteractWheelGUI {
     val mountShoulder = InteractWheelOption(
         iconResource = cobblemonResource("textures/gui/interact/icon_shoulder.png"),
         tooltipText = "cobblemon.ui.interact.mount.shoulder",
         onPress = {
             if (canMountShoulder) {
-                InteractPokemonPacket(pokemonID, true).sendToServer()
+                InteractPokemonPacket(pokemonID, true, false).sendToServer()
                 closeGUI()
             }
         }
@@ -41,15 +41,32 @@ fun createPokemonInteractGui(pokemonID: UUID, canMountShoulder: Boolean): Intera
         iconResource = cobblemonResource("textures/gui/interact/icon_held_item.png"),
         tooltipText = "cobblemon.ui.interact.give.item",
         onPress = {
-            InteractPokemonPacket(pokemonID, false).sendToServer()
+            InteractPokemonPacket(pokemonID, false, false).sendToServer()
             closeGUI()
         }
     )
+
+    val ride = InteractWheelOption(
+        iconResource = cobblemonResource("textures/gui/interact/icon_held_item.png"),
+        tooltipText = "cobblemon.ui.interact.ride",
+        onPress = {
+            if (canRide) {
+                InteractPokemonPacket(pokemonID, false, true).sendToServer()
+                closeGUI()
+            }
+        }
+    )
+
     val options: Multimap<Orientation, InteractWheelOption> = ArrayListMultimap.create()
     options.put(Orientation.TOP_RIGHT, giveItem)
+    if(canRide) {
+        options.put(Orientation.BOTTOM_LEFT, ride)
+    }
+
     if (canMountShoulder) {
         options.put(Orientation.TOP_LEFT, mountShoulder)
     }
+
     CobblemonEvents.POKEMON_INTERACTION_GUI_CREATION.post(PokemonInteractionGUICreationEvent(pokemonID, canMountShoulder, options))
     return InteractWheelGUI(options, Component.translatable("cobblemon.ui.interact.pokemon"))
 }

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/npc/widgets/NPCRenderWidget.kt

@@ -11,9 +11,7 @@ package com.cobblemon.mod.common.client.gui.npc.widgets
 import com.cobblemon.mod.common.api.gui.drawProfile
 import com.cobblemon.mod.common.client.gui.CobblemonRenderable
 import com.cobblemon.mod.common.client.render.models.blockbench.FloatingState
-import com.cobblemon.mod.common.client.render.models.blockbench.repository.NPCModelRepository
 import net.minecraft.client.gui.GuiGraphics
-import net.minecraft.client.gui.components.Renderable
 import net.minecraft.client.gui.components.events.GuiEventListener
 import net.minecraft.resources.ResourceLocation
 
@@ -47,7 +45,6 @@ class NPCRenderWidget(
         context.pose().translate(x + (WIDTH / 2F), y + HEIGHT + (HEIGHT / 4F), -500F)
 
         drawProfile(
-            repository = NPCModelRepository,
             resourceIdentifier = identifier,
             matrixStack = context.pose(),
             partialTicks = delta,

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

@@ -0,0 +1,81 @@
+/*
+ * 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.pc
+
+import com.cobblemon.mod.common.api.text.bold
+import com.cobblemon.mod.common.api.text.font
+import com.cobblemon.mod.common.api.text.text
+import com.cobblemon.mod.common.client.CobblemonResources
+import com.cobblemon.mod.common.client.render.drawScaledText
+import com.cobblemon.mod.common.client.storage.ClientBox
+import com.cobblemon.mod.common.net.messages.server.storage.pc.RequestRenamePCBoxPacket
+import net.minecraft.client.Minecraft
+import net.minecraft.client.gui.GuiGraphics
+import net.minecraft.client.gui.components.EditBox
+import net.minecraft.network.chat.Component
+import net.minecraft.network.chat.MutableComponent
+
+class BoxNameWidget(
+    private val pX: Int,
+    pY: Int,
+    text: Component = "BoxNameWidget".text(),
+    private val pcGui: PCGUI,
+    private val storageWidget: StorageWidget,
+): EditBox(Minecraft.getInstance().font, pX, pY, 0, HEIGHT, text) {
+
+    companion object {
+        const val HEIGHT = 14
+    }
+
+    init {
+        setMaxLength(21)
+        update()
+        setResponder { update() }
+    }
+
+    override fun renderWidget(context: GuiGraphics, mouseX: Int, mouseY: Int, delta: Float) {
+        if (cursorPosition != value.length) moveCursorToEnd(false)
+
+        drawScaledText(
+            context = context,
+            text = text(),
+            x = x,
+            y = y
+        )
+    }
+
+    override fun setFocused(focused: Boolean) {
+        super.setFocused(focused)
+        update()
+        if (!focused) {
+            RequestRenamePCBoxPacket(pcGui.pc.uuid, storageWidget.box, value).sendToServer()
+            pcGui.pc.boxes[storageWidget.box].name = if (value.isBlank()) null else Component.literal(value).bold()
+            value = ""
+        }
+    }
+
+    private fun text(): MutableComponent {
+        return (if (isFocused) {
+            "${value}_".text()
+        } else if (value.isEmpty()) {
+            getBox().name?: Component.translatable("cobblemon.ui.pc.box.title", storageWidget.box + 1)
+        } else {
+            value.text()
+        }).bold().font(CobblemonResources.DEFAULT_LARGE)
+    }
+
+    fun getBox(): ClientBox {
+        return pcGui.pc.boxes[storageWidget.box]
+    }
+
+    fun update() {
+        width = Minecraft.getInstance().font.width(text())
+        x = pX - width / 2
+    }
+}