Updated Changelog

Fix Adorn compatibility

See merge request cable-mc/cobblemon!2112

CHANGELOG.md

@@ -2,24 +2,70 @@
 ## [1.7.2 (MONTH Xth, YEAR)](#1-7-2)
 
 ### Additions
+- Added riding statistics: `Distance by Pokémon on Land`, `Distance by Pokémon in Air` and `Distance by Pokémon in Liquid`.
+- Added the Partner Mark, which party Pokémon have a very small chance to earn as the player walks, provided they have enough friendship.
+- Added trades for Saccharine Saplings, Hearty Grains, Chipped Pot, and Masterpiece Teacup to the Wandering Trader.
+- Added brewing recipe for Throat Spray.
+- Added new effects
+  - Mental Restoration: Reduces "Time Since Last Rest" statistic, which controls Insomnia, by half a minute per second per effect level
+  - Negative Effect Cleanse: Removes all negative effects
+  - Effect Cleanse: Removes all effects
+- Added more seasonings for sinister tea
+  - Mental Herb - Mental Restoration I for 10 seconds
+  - White Herb - Negative Effect Cleanse
+  - Milk - Effect Cleanse
+  - Moomoo Milk - Effect Cleanse
+- Added `label` as an alternate key to the `tag` property.
+- Added Saccharine wood furniture for Adorn.
 
 ### Changes
+- Ride sounds have been separated into stereo for passengers and mono for other players. Riding will now sound more spacious.
+- Added a new config option, `Enable In-Flight Dismounting` (default: off), which lets you dismount while riding a Pokémon in the air.
+- Battle AI now uses a smarter threshold for switching, reducing unnecessary switches.
+- AI will always use the most damaging move when at low HP and when it is not switching, improving endgame decision-making.
+- Added support for optional message variants in battle activate instructions for more context-specific battle text.
+  - Example: `this.add('-activate', pokemon, 'ability: example', '[msg]message1');` will parse to lang key `cobblemon.battle.activate.example.message1`
 
 ### Fixes
+- Fixed an issue in the OmniPathNodeMaker/Navigation that prevented Combees from pathing into and out of Saccharine leaves.
 - Fixed orientation not getting reset after crashing while flying and getting back on the Pokémon.
 - Fixed Furfrou not being trimmable on NeoForge.
+- Fixed shiny Pokémon not respecting the silent flag on spawn.
 - Fixed honey from Saccharine Leaves being harvestable at less than the max age.
 - Items given from interacting with Saccharine Leaves are placed in the active hotbar slot if possible.
 - Fix all Pokémon being saved to chunks and never despawning.
+- Fixed possible error on world generation when Combees are placed in naturally generated bee nests.
 - Fixed PokeSnacks crashing if there was no available spawn.
 - Fixed Pokémon spawn influences not being specific to regional forms
 - Fixed crashing when viewing another player in spectator mode
+- Fixed missing apricorn textures for Adorn blocks
+- Fixed crashing when riding due to malformed json file, instead resetting it
+- Fixed mochi items consuming two items at a time
+- Fix item interaction sometimes not working properly when playing on servers.
+- Fixed Soothe Bell not being properly tagged as a held item.
+- Fixed Mint Leaves not being usable for filling the Resurrection Machine.
+- Added Saccharine Boats and Saccharine Boat with Chests to relevant boat tags.
+- Fixed the `run_script` Molang function to not fail if the environment's context is null.
+- Fixed the movesets of certain Pokémon being incorrectly sanitized upon reload.
+- Fixed the ordering of Aprijuice's riding stat boosts to always have the same order.
+- Fixed the Molang functions `date_local_time`, `date_of`, `date_is_after` to use the correct date format.
+- Fixed the bottom half of pasture blocks having an incorrect hit-box when facing north or south.
+
+- Fixed Galarian Mr. Mime incorrectly being rideable.
+- Fixed gimmicks not being usable in double / triple battles
+- Fixed gimmick buttons showing when already used in the same turn in double / triple battles
+- Fixed Apricorn block model rotation for counters/sinks/cupboards/drawers to match that of most recent version of Adorn.
+- Fixed Scraggy & Scrafty being able to spawn on non-natural blocks in badlands
 
 ### Developer
+- Changed the `owner` parameter in the `OwnerQueryRequirement` interface from `ServerPlayer` to `Player`. This method is now also called on the client to verify whether a Pokémon interaction succeeded, so make sure to update your implementations to handle both server and client contexts.
 
 ### Molang & Datapacks
+- Ride sounds can now be set as exclusive to passengers
+- Ride sounds no longer play when submerged unless specified with a new setting
+- Exception handling has been added to `run_molang`, resolving some crashes caused by malformed MoLang expressions.
 
 ### Particles
 
 ### Localization
-- Updated translations for:
+- Updated translations for:

common/build.gradle.kts

@@ -54,8 +54,6 @@ dependencies {
     // Flywheel has no common dep so just pick one and don't use any platform specific code in common
     // modCompileOnly(libs.flywheelFabric)
 
-    modCompileOnly(files("temp/vivecraft-1.21.1-1.3.4.jar")) // TODO: Switch this to a proper dependency when Vivecraft gets a maven repo
-
     // Showdown
     modCompileOnly(libs.graal)
 

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

@@ -11,7 +11,9 @@ package com.cobblemon.mod.common.mixin;
 
 import com.cobblemon.mod.common.CobblemonMemories;
 import com.cobblemon.mod.common.api.ai.config.task.PathToBeeHiveTaskConfig;
+import com.cobblemon.mod.common.api.pokemon.PokemonProperties;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import com.cobblemon.mod.common.world.feature.SaccharineTreeFeature;
 import net.minecraft.core.BlockPos;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.tags.BlockTags;
@@ -42,7 +44,21 @@ public abstract class BeeOccupantMixin {
         if (cir.getReturnValue() == null) {
             final BeehiveBlockEntity.Occupant occupant = (BeehiveBlockEntity.Occupant) (Object) this;
             CompoundTag compoundTag = occupant.entityData().copyTag();
-            Entity entity = EntityType.loadEntityRecursive(compoundTag, level, (entityx) -> entityx);
+            String id = compoundTag.getString("id");
+            Entity entity = null;
+            if (id.equals(SaccharineTreeFeature.Companion.getPOKEMON_PLACEHOLD_ID())) {
+                // Special case for Pokemon stuffed into a beenest upon world gen.
+                // For technical reasons we cannot create them as full entities during world gen.
+                // So we look for this special id tag and complete the entity when it attempts to exit a hive.
+                if (compoundTag.contains("pokemonProperties")) {
+                    String properties = compoundTag.getString("pokemonProperties");
+                    PokemonProperties pokemon = PokemonProperties.Companion.parse(properties);
+                    entity = pokemon.createEntity(level);
+                }
+            } else {
+                entity = EntityType.loadEntityRecursive(compoundTag, level, (entityx) -> entityx);
+            }
+
             if (entity instanceof PokemonEntity pokemonEntity) {
                 var state = level.getBlockState(pos);
                 var newPos = Vec3.ZERO;

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

@@ -11,11 +11,15 @@ package com.cobblemon.mod.common.mixin;
 import com.cobblemon.mod.common.Cobblemon;
 import com.cobblemon.mod.common.OrientationControllable;
 import com.cobblemon.mod.common.PlayerSpawnerAccessor;
+import com.cobblemon.mod.common.api.riding.RidingStyle;
 import com.cobblemon.mod.common.api.spawning.spawner.PlayerSpawner;
 import com.cobblemon.mod.common.api.spawning.spawner.PlayerSpawnerFactory;
+import com.cobblemon.mod.common.api.stats.CobblemonStats;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
 import com.cobblemon.mod.common.world.gamerules.CobblemonGameRules;
 import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import com.llamalad7.mixinextras.sugar.Local;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.server.level.ServerPlayer;
@@ -89,4 +93,32 @@ public abstract class ServerPlayerMixin implements PlayerSpawnerAccessor {
     private boolean cobblemon$cancelSavingPokemonMounts(boolean original, @Local(ordinal=0) Entity entity) {
         return original && !(entity instanceof PokemonEntity);
     }
+
+    @WrapOperation(method = "checkRidingStatistics", at = @At(value = "INVOKE", target = "Lnet/minecraft/server/level/ServerPlayer;getVehicle()Lnet/minecraft/world/entity/Entity;"))
+    public Entity cobblemon$checkRidingStatistics(ServerPlayer player, Operation<Entity> original, @Local int distance) {
+        var entity = original.call(player);
+        if (!(entity instanceof PokemonEntity pokemonEntity)) {
+            return entity;
+        }
+
+        var ridingController = pokemonEntity.getRidingController();
+        if (ridingController == null) return entity;
+
+        var activeContext = ridingController.getContext();
+        if (activeContext == null) return entity;
+
+        var ridingStyle = activeContext.getStyle();
+        CobblemonStats.CobblemonStat stat = switch (ridingStyle) {
+            case RidingStyle.LAND -> CobblemonStats.RIDING_LAND;
+            case RidingStyle.AIR -> CobblemonStats.RIDING_AIR;
+            case RidingStyle.LIQUID -> CobblemonStats.RIDING_LIQUID;
+            default -> null;
+        };
+
+        if (stat != null) {
+            player.awardStat(CobblemonStats.getStat(stat), distance);
+        }
+
+        return entity;
+    }
 }

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

@@ -77,7 +77,6 @@ import com.cobblemon.mod.common.config.constraint.IntConstraint
 import com.cobblemon.mod.common.config.starter.StarterConfig
 import com.cobblemon.mod.common.data.CobblemonDataProvider
 import com.cobblemon.mod.common.events.*
-import com.cobblemon.mod.common.integration.vivecraft.CobblemonVR
 import com.cobblemon.mod.common.net.messages.client.settings.ServerSettingsPacket
 import com.cobblemon.mod.common.permission.LaxPermissionValidator
 import com.cobblemon.mod.common.platform.events.PlatformEvents
@@ -92,7 +91,7 @@ import com.cobblemon.mod.common.pokemon.feature.SlowpokeTailRegrowthSpeciesFeatu
 import com.cobblemon.mod.common.pokemon.feature.TagSeasonResolver
 import com.cobblemon.mod.common.pokemon.helditem.CobblemonHeldItemManager
 import com.cobblemon.mod.common.pokemon.properties.*
-import com.cobblemon.mod.common.pokemon.properties.tags.PokemonFlagProperty
+import com.cobblemon.mod.common.pokemon.properties.LabelProperty
 import com.cobblemon.mod.common.pokemon.stat.CobblemonStatProvider
 import com.cobblemon.mod.common.starter.CobblemonStarterHandler
 import com.cobblemon.mod.common.util.*
@@ -131,12 +130,10 @@ object Cobblemon {
     const val MODID = CobblemonBuildDetails.MOD_ID
     const val VERSION = CobblemonBuildDetails.VERSION
     const val CONFIG_PATH = "config/$MODID/main.json"
-
     @JvmField
     val LOGGER: Logger = LogManager.getLogger()
 
     lateinit var implementation: CobblemonImplementation
-
     @Deprecated("This field is now a config value", ReplaceWith("Cobblemon.config.captureCalculator"))
     var captureCalculator: CaptureCalculator
         get() = this.config.captureCalculator
@@ -166,49 +163,21 @@ object Cobblemon {
     val serverPlayerStructs = mutableMapOf<UUID, ObjectValue<Player>>()
 
     val statistics: CobblemonStats = CobblemonStats
-    var cobblemonVR: CobblemonVR? = null
 
     @JvmStatic
     val builtinPacks = listOf<CobblemonPack>(
-        CobblemonPack(
-            id = "adorncompatibility",
-            name = "Adorn Compatibility",
-            packType = PackType.CLIENT_RESOURCES,
-            activationBehaviour = ResourcePackActivationBehaviour.ALWAYS_ENABLED,
-            neededMods = setOf("adorn")
-        ),
-        CobblemonPack(
-            id = "gyaradosjump",
-            name = "Gyarados Jump Patterns",
-            packType = PackType.CLIENT_RESOURCES,
-            activationBehaviour = ResourcePackActivationBehaviour.DEFAULT_ENABLED
-        ),
-        CobblemonPack(
-            id = "regionbiasforms",
-            name = "Region Bias Forms",
-            packType = PackType.CLIENT_RESOURCES,
-            activationBehaviour = ResourcePackActivationBehaviour.DEFAULT_ENABLED
-        ),
-        CobblemonPack(
-            id = "uniqueshinyforms",
-            name = "Shinies for Magikarp Jump",
-            packType = PackType.CLIENT_RESOURCES,
-            activationBehaviour = ResourcePackActivationBehaviour.NORMAL
-        ),
+        CobblemonPack(id = "adorncompatibility", name = "Adorn Compatibility", packType = PackType.CLIENT_RESOURCES, activationBehaviour = ResourcePackActivationBehaviour.ALWAYS_ENABLED, neededMods = setOf("adorn")),
+        CobblemonPack(id = "gyaradosjump", name = "Gyarados Jump Patterns", packType = PackType.CLIENT_RESOURCES, activationBehaviour = ResourcePackActivationBehaviour.DEFAULT_ENABLED),
+        CobblemonPack(id = "regionbiasforms", name = "Region Bias Forms", packType = PackType.CLIENT_RESOURCES, activationBehaviour = ResourcePackActivationBehaviour.DEFAULT_ENABLED),
+        CobblemonPack(id = "uniqueshinyforms", name = "Shinies for Magikarp Jump", packType = PackType.CLIENT_RESOURCES, activationBehaviour = ResourcePackActivationBehaviour.NORMAL),
 
-        CobblemonPack(
-            id = "repurposedstructurescobblemon",
-            name = "Repurposed Structures Cobblemon",
-            packType = PackType.SERVER_DATA,
-            activationBehaviour = ResourcePackActivationBehaviour.DEFAULT_ENABLED,
-            neededMods = setOf("repurposed_structures")
-        ),
+        CobblemonPack(id = "repurposedstructurescobblemon", name = "Repurposed Structures Cobblemon", packType = PackType.SERVER_DATA, activationBehaviour = ResourcePackActivationBehaviour.DEFAULT_ENABLED, neededMods = setOf("repurposed_structures")),
     )
 
     fun preInitialize(implementation: CobblemonImplementation) {
         this.implementation = implementation
 
-        this.LOGGER.info("Launching Cobblemon ${CobblemonBuildDetails.VERSION}${if (CobblemonBuildDetails.SNAPSHOT) "-SNAPSHOT" else ""} ")
+        this.LOGGER.info("Launching Cobblemon ${CobblemonBuildDetails.VERSION}${if(CobblemonBuildDetails.SNAPSHOT) "-SNAPSHOT" else ""} ")
         if (CobblemonBuildDetails.SNAPSHOT) {
             this.LOGGER.info("  - Git Commit: ${smallCommitHash()} (https://gitlab.com/cable-mc/cobblemon/-/commit/${CobblemonBuildDetails.GIT_COMMIT})")
             this.LOGGER.info("  - Branch: ${CobblemonBuildDetails.BRANCH}")
@@ -232,6 +201,7 @@ object Cobblemon {
         implementation.registerEntityDataSerializers()
         implementation.registerCriteria()
         implementation.registerEntitySubPredicates()
+        implementation.registerMobEffects()
         DispenserBehaviorRegistry.registerDispenserBehaviors()
 
         DropEntry.register("command", CommandDropEntry::class.java)
@@ -272,10 +242,7 @@ object Cobblemon {
         }
 
         PlatformEvents.RIGHT_CLICK_ENTITY.subscribe { event ->
-            if (event.player.getItemInHand(event.hand).item is NameTagItem && event.entity.type.`is`(
-                    CobblemonEntityTypeTags.CANNOT_HAVE_NAME_TAG
-                )
-            ) {
+            if (event.player.getItemInHand(event.hand).item is NameTagItem && event.entity.type.`is`(CobblemonEntityTypeTags.CANNOT_HAVE_NAME_TAG)) {
                 event.cancel()
             }
         }
@@ -286,10 +253,7 @@ object Cobblemon {
                 pokemon.lockedEvolutions
                     .filterIsInstance<BlockClickEvolution>()
                     .forEach { evolution ->
-                        evolution.attemptEvolution(
-                            pokemon,
-                            BlockClickEvolution.BlockInteractionContext(block, player.level())
-                        )
+                        evolution.attemptEvolution(pokemon, BlockClickEvolution.BlockInteractionContext(block, player.level()))
                     }
             }
         }
@@ -349,14 +313,9 @@ object Cobblemon {
             SlowpokeTailRegrowthSpeciesFeatureProvider
         )
 
-        if (implementation.isModInstalled("vivecraft")) {  // VR integration
-            cobblemonVR = CobblemonVR()
-            cobblemonVR?.init()
-        }
-
         CustomPokemonProperty.register(UncatchableProperty)
         CustomPokemonProperty.register(BattleCloneProperty)
-        CustomPokemonProperty.register(PokemonFlagProperty)
+        CustomPokemonProperty.register(LabelProperty)
         CustomPokemonProperty.register(HiddenAbilityPropertyType)
         CustomPokemonProperty.register(AspectPropertyType)
         CustomPokemonProperty.register(UnaspectPropertyType)
@@ -373,7 +332,7 @@ object Cobblemon {
         }
 
         PlatformEvents.SERVER_TICK_POST.subscribe {
-            ServerTaskTracker.update(1 / 20F)
+            ServerTaskTracker.update(1/20F)
             ServerRealTimeTaskTracker.update()
         }
         PlatformEvents.SERVER_TICK_PRE.subscribe {
@@ -417,22 +376,10 @@ object Cobblemon {
                             .applyConnectionString(ConnectionString(config.mongoDBConnectionString))
                             .build()
                         mongoClient = MongoClients.create(mongoClientSettings)
-                        val generalMongoFactory = CachedPlayerDataStoreFactory(
-                            PlayerDataMongoBackend(
-                                mongoClient,
-                                config.mongoDBDatabaseName,
-                                "PlayerDataCollection"
-                            )
-                        )
+                        val generalMongoFactory = CachedPlayerDataStoreFactory(PlayerDataMongoBackend(mongoClient, config.mongoDBDatabaseName, "PlayerDataCollection"))
                         generalMongoFactory.setup(server)
 
-                        val pokedexMongoFactory = CachedPlayerDataStoreFactory(
-                            DexDataMongoBackend(
-                                mongoClient,
-                                config.mongoDBDatabaseName,
-                                "PokeDexCollection"
-                            )
-                        )
+                        val pokedexMongoFactory = CachedPlayerDataStoreFactory(DexDataMongoBackend(mongoClient, config.mongoDBDatabaseName, "PokeDexCollection"))
                         pokedexMongoFactory.setup(server)
 
                         playerDataManager.setFactory(generalMongoFactory, PlayerInstancedDataStoreTypes.GENERAL)
@@ -554,7 +501,6 @@ object Cobblemon {
                                 field.set(config, field.get(defaultConfig))
                             }
                         }
-
                         is IntConstraint -> {
                             var value = field.get(config)
                             if (value is Int) {
@@ -607,76 +553,20 @@ object Cobblemon {
     }
 
     private fun registerArgumentTypes() {
-        this.implementation.registerCommandArgument(
-            cobblemonResource("pokemon"),
-            SpeciesArgumentType::class,
-            SingletonArgumentInfo.contextFree(SpeciesArgumentType::species)
-        )
-        this.implementation.registerCommandArgument(
-            cobblemonResource("pokemon_properties"),
-            PokemonPropertiesArgumentType::class,
-            SingletonArgumentInfo.contextFree(PokemonPropertiesArgumentType::properties)
-        )
-        this.implementation.registerCommandArgument(
-            cobblemonResource("spawn_bucket"),
-            SpawnBucketArgumentType::class,
-            SingletonArgumentInfo.contextFree(SpawnBucketArgumentType::spawnBucket)
-        )
-        this.implementation.registerCommandArgument(
-            cobblemonResource("move"),
-            MoveArgumentType::class,
-            SingletonArgumentInfo.contextFree(MoveArgumentType::move)
-        )
-        this.implementation.registerCommandArgument(
-            cobblemonResource("party_slot"),
-            PartySlotArgumentType::class,
-            SingletonArgumentInfo.contextFree(PartySlotArgumentType::partySlot)
-        )
-        this.implementation.registerCommandArgument(
-            cobblemonResource("pokemon_store"),
-            PokemonStoreArgumentType::class,
-            SingletonArgumentInfo.contextFree(PokemonStoreArgumentType::pokemonStore)
-        )
-        this.implementation.registerCommandArgument(
-            cobblemonResource("dialogue"),
-            DialogueArgumentType::class,
-            SingletonArgumentInfo.contextFree(DialogueArgumentType::dialogue)
-        )
-        this.implementation.registerCommandArgument(
-            cobblemonResource("form"),
-            FormArgumentType::class,
-            SingletonArgumentInfo.contextFree(FormArgumentType::form)
-        )
-        this.implementation.registerCommandArgument(
-            cobblemonResource("dex"),
-            DexArgumentType::class,
-            SingletonArgumentInfo.contextFree(DexArgumentType::dex)
-        )
-        this.implementation.registerCommandArgument(
-            cobblemonResource("npc_class"),
-            NPCClassArgumentType::class,
-            SingletonArgumentInfo.contextFree(NPCClassArgumentType::npcClass)
-        )
-        this.implementation.registerCommandArgument(
-            cobblemonResource("wallpaper"),
-            UnlockablePCBoxWallpaperArgumentType::class,
-            SingletonArgumentInfo.contextFree(UnlockablePCBoxWallpaperArgumentType::wallpaper)
-        )
-        this.implementation.registerCommandArgument(
-            cobblemonResource("mark"),
-            MarkArgumentType::class,
-            SingletonArgumentInfo.contextFree(MarkArgumentType::mark)
-        )
-        this.implementation.registerCommandArgument(
-            cobblemonResource("transform_type"),
-            TransformTypeArgumentType::class,
-            SingletonArgumentInfo.contextFree(TransformTypeArgumentType::transformType)
-        )
-        this.implementation.registerCommandArgument(
-            cobblemonResource("model_part"),
-            ModelPartArgumentType::class,
-            SingletonArgumentInfo.contextFree(ModelPartArgumentType::modelPart)
-        )
+        this.implementation.registerCommandArgument(cobblemonResource("pokemon"), SpeciesArgumentType::class, SingletonArgumentInfo.contextFree(SpeciesArgumentType::species))
+        this.implementation.registerCommandArgument(cobblemonResource("pokemon_properties"), PokemonPropertiesArgumentType::class, SingletonArgumentInfo.contextFree(PokemonPropertiesArgumentType::properties))
+        this.implementation.registerCommandArgument(cobblemonResource("spawn_bucket"), SpawnBucketArgumentType::class, SingletonArgumentInfo.contextFree(SpawnBucketArgumentType::spawnBucket))
+        this.implementation.registerCommandArgument(cobblemonResource("move"), MoveArgumentType::class, SingletonArgumentInfo.contextFree(MoveArgumentType::move))
+        this.implementation.registerCommandArgument(cobblemonResource("party_slot"), PartySlotArgumentType::class, SingletonArgumentInfo.contextFree(PartySlotArgumentType::partySlot))
+        this.implementation.registerCommandArgument(cobblemonResource("pokemon_store"), PokemonStoreArgumentType::class, SingletonArgumentInfo.contextFree(PokemonStoreArgumentType::pokemonStore))
+        this.implementation.registerCommandArgument(cobblemonResource("dialogue"), DialogueArgumentType::class, SingletonArgumentInfo.contextFree(DialogueArgumentType::dialogue))
+        this.implementation.registerCommandArgument(cobblemonResource("form"), FormArgumentType::class, SingletonArgumentInfo.contextFree(FormArgumentType::form))
+        this.implementation.registerCommandArgument(cobblemonResource("dex"), DexArgumentType::class, SingletonArgumentInfo.contextFree (DexArgumentType::dex))
+        this.implementation.registerCommandArgument(cobblemonResource("npc_class"), NPCClassArgumentType::class, SingletonArgumentInfo.contextFree(NPCClassArgumentType::npcClass))
+        this.implementation.registerCommandArgument(cobblemonResource("wallpaper"), UnlockablePCBoxWallpaperArgumentType::class, SingletonArgumentInfo.contextFree(UnlockablePCBoxWallpaperArgumentType::wallpaper))
+        this.implementation.registerCommandArgument(cobblemonResource("mark"), MarkArgumentType::class, SingletonArgumentInfo.contextFree(MarkArgumentType::mark))
+        this.implementation.registerCommandArgument(cobblemonResource("transform_type"), TransformTypeArgumentType::class, SingletonArgumentInfo.contextFree(TransformTypeArgumentType::transformType))
+        this.implementation.registerCommandArgument(cobblemonResource("model_part"), ModelPartArgumentType::class, SingletonArgumentInfo.contextFree(ModelPartArgumentType::modelPart))
     }
 
 }

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

@@ -117,6 +117,11 @@ interface CobblemonImplementation {
 
     fun registerEntitySubPredicates()
 
+    /**
+     * TODO
+     */
+    fun registerMobEffects()
+
 
     /**
      * Add a feature to the current platform implementation.

common/src/main/kotlin/com/cobblemon/mod/common/CobblemonMobEffects.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
+
+import com.cobblemon.mod.common.api.cooking.effects.CleanseAllEffect
+import com.cobblemon.mod.common.api.cooking.effects.CleanseNegativeEffect
+import com.cobblemon.mod.common.api.cooking.effects.MentalRestorationEffect
+import com.cobblemon.mod.common.platform.PlatformRegistry
+import net.minecraft.core.Registry
+import net.minecraft.core.registries.BuiltInRegistries
+import net.minecraft.core.registries.Registries
+import net.minecraft.resources.ResourceKey
+import net.minecraft.world.effect.MobEffect
+
+object CobblemonMobEffects : PlatformRegistry<Registry<MobEffect>, ResourceKey<Registry<MobEffect>>, MobEffect>() {
+    override val registry: Registry<MobEffect> = BuiltInRegistries.MOB_EFFECT
+    override val resourceKey: ResourceKey<Registry<MobEffect>> = Registries.MOB_EFFECT
+
+    @JvmField
+    val CLEANSE_NEGATIVE = create("cleanse_negative", CleanseNegativeEffect())
+
+    @JvmField
+    val MENTAL_RESTORATION = create("mental_restoration", MentalRestorationEffect())
+
+    @JvmField
+    val CLEANSE_ALL = create("cleanse_all", CleanseAllEffect())
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/cooking/effects/CleanseAllEffect.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.cooking.effects
+
+import net.minecraft.world.effect.MobEffect
+import net.minecraft.world.effect.MobEffectCategory
+import net.minecraft.world.entity.Entity
+import net.minecraft.world.entity.LivingEntity
+
+class CleanseAllEffect : MobEffect(MobEffectCategory.BENEFICIAL, 0xFFFFFF) {
+    override fun isInstantenous() = true
+    override fun applyInstantenousEffect(source: Entity?, indirect: Entity?, target: LivingEntity, amplifier: Int, proximity: Double) {
+        target.removeAllEffects()
+    }
+    override fun shouldApplyEffectTickThisTick(duration: Int, amplifier: Int) = false
+}

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

@@ -0,0 +1,27 @@
+/*
+ * 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.cooking.effects
+
+import net.minecraft.world.effect.MobEffect
+import net.minecraft.world.effect.MobEffectCategory
+import net.minecraft.world.entity.Entity
+import net.minecraft.world.entity.LivingEntity
+
+class CleanseNegativeEffect : MobEffect(MobEffectCategory.BENEFICIAL, 0xFFFFFF) {
+    override fun isInstantenous() = true
+    override fun applyInstantenousEffect(source: Entity?, indirect: Entity?, target: LivingEntity, amplifier: Int, proximity: Double) {
+        val snapshot = target.activeEffects.toList()
+        for (ei in snapshot) {
+            if (ei.effect.value().category == MobEffectCategory.HARMFUL) {
+                target.removeEffect(ei.effect)
+            }
+        }
+    }
+    override fun shouldApplyEffectTickThisTick(duration: Int, amplifier: Int) = false
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/cooking/effects/MentalRestorationEffect.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.cooking.effects
+
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.stats.Stats
+import net.minecraft.world.effect.MobEffect
+import net.minecraft.world.effect.MobEffectCategory
+import net.minecraft.world.entity.LivingEntity
+
+class MentalRestorationEffect : MobEffect(MobEffectCategory.BENEFICIAL, 0xAA66FF) {
+    override fun applyEffectTick(entity: LivingEntity, amplifier: Int): Boolean {
+        if (entity is ServerPlayer) {
+            val stats = entity.stats
+            val statType = Stats.CUSTOM.get(Stats.TIME_SINCE_REST)
+            val current = stats.getValue(statType)
+            val reduction = 31 * (amplifier + 1)// reduce by half a minute every second per level (30 ticks removed per tick + 1 to account for the tick passing)
+            val newValue = Math.max(current - reduction, 0)
+            stats.setValue(entity, statType, newValue)
+        }
+        return true
+    }
+
+    override fun shouldApplyEffectTickThisTick(duration: Int, amplifier: Int): Boolean {
+        return true
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/interaction/PokemonInteractions.kt

@@ -12,10 +12,10 @@ import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.api.data.JsonDataRegistry
 import com.cobblemon.mod.common.api.molang.ExpressionLike
 import com.cobblemon.mod.common.api.pokemon.PokemonProperties
-import com.cobblemon.mod.common.api.pokemon.requirement.OwnerQueryRequirement
 import com.cobblemon.mod.common.api.pokemon.requirement.Requirement
 import com.cobblemon.mod.common.api.reactive.SimpleObservable
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.net.messages.client.data.PokemonInteractionsSyncPacket
 import com.cobblemon.mod.common.pokemon.adapters.CobblemonRequirementAdapter
 import com.cobblemon.mod.common.pokemon.evolution.adapters.LegacyItemConditionWrapperAdapter
 import com.cobblemon.mod.common.pokemon.requirements.PokemonPropertiesRequirement
@@ -51,7 +51,12 @@ object PokemonInteractions : JsonDataRegistry<PokemonInteractionSet> {
     val speciesInteractions = mutableListOf<PokemonInteractionSet>()
     val generalInteractions = mutableListOf<PokemonInteractionSet>()
 
-    override fun sync(player: ServerPlayer) {}
+    override fun sync(player: ServerPlayer) {
+        PokemonInteractionsSyncPacket(
+            speciesInteractions,
+            generalInteractions,
+        ).sendToPlayer(player)
+    }
 
     override fun reload(data: Map<ResourceLocation, PokemonInteractionSet>) {
         speciesInteractions.clear()

common/src/main/kotlin/com/cobblemon/mod/common/api/interaction/PokemonInteration.kt

@@ -15,11 +15,10 @@ import com.cobblemon.mod.common.api.molang.MoLangFunctions.setup
 import com.cobblemon.mod.common.api.pokemon.requirement.Requirement
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.net.messages.client.sound.UnvalidatedPlaySoundS2CPacket
-import com.cobblemon.mod.common.util.asExpressionLike
-import com.cobblemon.mod.common.util.giveOrDropItemStack
-import com.cobblemon.mod.common.util.withPlayerValue
-import com.cobblemon.mod.common.util.withQueryValue
+import com.cobblemon.mod.common.pokemon.adapters.CobblemonRequirementAdapter
+import com.cobblemon.mod.common.util.*
 import net.minecraft.core.registries.Registries
+import net.minecraft.network.FriendlyByteBuf
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.sounds.SoundSource
@@ -28,30 +27,83 @@ import net.minecraft.world.entity.EquipmentSlot
 import net.minecraft.world.entity.item.ItemEntity
 import net.minecraft.world.item.ItemStack
 
-/**
- * A
- */
 data class PokemonInteractionSet(
     val requirements: List<Requirement> = listOf(),
-    val interactions: List<PokemonInteraction> = listOf()
-)
+    val interactions: List<PokemonInteraction> = listOf(),
+) {
+    fun encode(buffer: FriendlyByteBuf) {
+        buffer.writeCollection(requirements) { it, requirement ->
+            CobblemonRequirementAdapter.encode(requirement, it)
+        }
+        buffer.writeCollection(interactions) { it, interaction ->
+            interaction.encode(it)
+        }
+    }
+
+    companion object {
+        fun decode(buffer: FriendlyByteBuf): PokemonInteractionSet {
+            val requirements = buffer.readList { it ->
+                CobblemonRequirementAdapter.decode(it)
+            }
+            val interactions = buffer.readList { it ->
+                PokemonInteraction.decode(it)
+            }
+
+            return PokemonInteractionSet(
+                requirements,
+                interactions,
+            )
+        }
+    }
+}
+
 data class PokemonInteraction(
     val grouping: ResourceLocation,
     val requirements: List<Requirement> = listOf(),
     val effects: List<InteractionEffect> = listOf(),
     val cooldown: ExpressionLike = "0".asExpressionLike()
-)
+) {
+    fun encode(buffer: FriendlyByteBuf) {
+        buffer.writeResourceLocation(grouping)
+        buffer.writeCollection(requirements) { it, requirement ->
+            CobblemonRequirementAdapter.encode(requirement, it)
+        }
+        buffer.writeExpressionLike(cooldown)
+    }
+
+    companion object {
+        fun decode(buffer: FriendlyByteBuf): PokemonInteraction {
+            val grouping = buffer.readResourceLocation()
+            val requirements = buffer.readList { it ->
+                CobblemonRequirementAdapter.decode(it)
+            }
+
+            // No need to sync these for now
+            val effects = emptyList<InteractionEffect>()
+            val cooldown = buffer.readExpressionLike()
+
+            return PokemonInteraction(
+                grouping,
+                requirements,
+                effects,
+                cooldown,
+            )
+        }
+    }
+}
 
 interface InteractionEffect {
     fun applyEffect(pokemon: PokemonEntity, player: ServerPlayer)
 }
 
-class DropItemEffect(val item: ResourceLocation, val amount: IntRange?): InteractionEffect {
+class DropItemEffect(val item: ResourceLocation, val amount: IntRange?) : InteractionEffect {
     override fun applyEffect(
         pokemon: PokemonEntity,
         player: ServerPlayer
     ) {
-        val item = player.registryAccess().registryOrThrow(Registries.ITEM).get(item) ?: throw IllegalArgumentException("Cannot load item with id: $item")
+        val item = player.registryAccess().registryOrThrow(Registries.ITEM).get(item) ?: throw IllegalArgumentException(
+            "Cannot load item with id: $item"
+        )
         val stack = ItemStack(item)
         stack.count = amount?.randomOrNull() ?: 1
         if (stack.isEmpty)
@@ -68,12 +120,14 @@ class DropItemEffect(val item: ResourceLocation, val amount: IntRange?): Interac
     }
 }
 
-class GiveItemEffect(val item: ResourceLocation, val amount: IntRange?): InteractionEffect {
+class GiveItemEffect(val item: ResourceLocation, val amount: IntRange?) : InteractionEffect {
     override fun applyEffect(
         pokemon: PokemonEntity,
         player: ServerPlayer
     ) {
-        val item = player.registryAccess().registryOrThrow(Registries.ITEM).get(item) ?: throw IllegalArgumentException("Cannot load item with id: $item")
+        val item = player.registryAccess().registryOrThrow(Registries.ITEM).get(item) ?: throw IllegalArgumentException(
+            "Cannot load item with id: $item"
+        )
         val stack = ItemStack(item)
         stack.count = amount?.randomOrNull() ?: 1
         if (stack.isEmpty)
@@ -86,14 +140,29 @@ class GiveItemEffect(val item: ResourceLocation, val amount: IntRange?): Interac
     }
 }
 
-class PlaySoundEffect(val sound: ResourceLocation, val soundSource: SoundSource?, val playAround: Boolean = true, val distance: Double = 64.0, val volume: Float = 1.0F, val pitch: Float = 1.0F): InteractionEffect {
+class PlaySoundEffect(
+    val sound: ResourceLocation,
+    val soundSource: SoundSource?,
+    val playAround: Boolean = true,
+    val distance: Double = 64.0,
+    val volume: Float = 1.0F,
+    val pitch: Float = 1.0F
+) : InteractionEffect {
     override fun applyEffect(
         pokemon: PokemonEntity,
         player: ServerPlayer
     ) {
-        val packet = UnvalidatedPlaySoundS2CPacket(sound, soundSource ?: SoundSource.NEUTRAL, pokemon.x, pokemon.y, pokemon.z, volume, pitch)
+        val packet = UnvalidatedPlaySoundS2CPacket(
+            sound,
+            soundSource ?: SoundSource.NEUTRAL,
+            pokemon.x,
+            pokemon.y,
+            pokemon.z,
+            volume,
+            pitch
+        )
         if (playAround) {
-            packet.sendToPlayersAround( pokemon.x, pokemon.y, pokemon.z, distance, pokemon.level().dimension())
+            packet.sendToPlayersAround(pokemon.x, pokemon.y, pokemon.z, distance, pokemon.level().dimension())
         } else {
             packet.sendToPlayer(player)
         }
@@ -104,7 +173,7 @@ class PlaySoundEffect(val sound: ResourceLocation, val soundSource: SoundSource?
     }
 }
 
-class ShrinkItemEffect(val amount: Int = 1): InteractionEffect {
+class ShrinkItemEffect(val amount: Int = 1) : InteractionEffect {
     override fun applyEffect(
         pokemon: PokemonEntity,
         player: ServerPlayer
@@ -120,7 +189,7 @@ class ShrinkItemEffect(val amount: Int = 1): InteractionEffect {
     }
 }
 
-class ScriptEffect(val script: ExpressionLike): InteractionEffect {
+class ScriptEffect(val script: ExpressionLike) : InteractionEffect {
     override fun applyEffect(
         pokemon: PokemonEntity,
         player: ServerPlayer

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

@@ -311,7 +311,7 @@ object MoLangFunctions {
             runtime.environment.variable = params.environment.variable
             val args = params.params.subList(1, params.params.size)
             runtime.environment.context = ContextStruct(
-                params.environment.context.map + args.mapIndexed { index, value -> "arg_${index + 1}" to value }.toMap()
+                (params.environment.context?.map ?: emptyMap()) + args.mapIndexed { index, value -> "arg_${index + 1}" to value }.toMap()
             )
             val script = params.getString(0).asIdentifierDefaultingNamespace()
             // store the args in the
@@ -324,13 +324,24 @@ object MoLangFunctions {
             runtime.environment.context = params.environment.context
             val expression = params.getString(0).asExpressionLike()
             val delayInSeconds = params.getDoubleOrNull(1)?.toFloat() ?: 0.0f
+
+            fun evaluate(): MoValue {
+                return try {
+                    runtime.resolve(expression)
+                } catch (ex: Exception) {
+                    Cobblemon.LOGGER.warn("Failed to evaluate MoLang expression${if (delayInSeconds > 0.0f) " (delayed)" else ""}: $expression", ex)
+                    DoubleValue.ZERO
+                }
+            }
+
             if (delayInSeconds > 0.0f) {
                 val tracker = if (Cobblemon.implementation.environment() == Environment.SERVER) ServerTaskTracker else ClientTaskTracker
                 tracker.after(delayInSeconds) {
-                    runtime.resolve(expression)
+                    evaluate()
                 }
+                DoubleValue.ONE
             } else {
-                runtime.resolve(expression)
+                evaluate()
             }
         },
         "system_time_millis" to java.util.function.Function { _ ->
@@ -340,19 +351,19 @@ object MoLangFunctions {
         "date_local_time" to java.util.function.Function { _ ->
             val time = System.currentTimeMillis()
             val date = java.util.Date(time)
-            val formatted = java.text.SimpleDateFormat("DD/MM/YYYY").format(date)
+            val formatted = java.text.SimpleDateFormat("dd/MM/yyyy").format(date)
             StringValue(formatted)
         },
         "date_of" to java.util.function.Function { params ->
             val time = params.getDouble(0).toLong()
             val date = java.util.Date(time)
-            val formatted = java.text.SimpleDateFormat("DD/MM/YYYY").format(date)
+            val formatted = java.text.SimpleDateFormat("dd/MM/yyyy").format(date)
             StringValue(formatted)
         },
         "date_is_after" to java.util.function.Function { params ->
             val dateA = params.getString(0)
             val dateB = params.getString(1)
-            val format = java.text.SimpleDateFormat("DD/MM/YYYY")
+            val format = java.text.SimpleDateFormat("dd/MM/yyyy")
             val a = format.parse(dateA)
             val b = format.parse(dateB)
             DoubleValue(a.after(b))
@@ -779,6 +790,20 @@ object MoLangFunctions {
                     battleStartResult.ifSuccessful { returnValue = it.struct }
                     return@put returnValue
                 }
+                map.put("get_custom_stat") { params ->
+                    val statName = params.getString(0)
+
+                    val resourceLocation = ResourceLocation.tryParse(statName) ?: return@put DoubleValue.ZERO
+                    val statResourceLocation = BuiltInRegistries.CUSTOM_STAT.get(resourceLocation) ?: return@put DoubleValue.ZERO
+
+                    val exists = net.minecraft.stats.Stats.CUSTOM.contains(statResourceLocation)
+                    if (!exists) return@put DoubleValue.ZERO
+
+                    val stat = net.minecraft.stats.Stats.CUSTOM.get(statResourceLocation)
+                    val value = player.stats.getValue(stat)
+
+                    DoubleValue(value)
+                }
             }
             map
         }
@@ -1739,22 +1764,35 @@ object MoLangFunctions {
                 pokemon.removeCosmeticItem()
             }
             map.put("add_marks") { params ->
+                var appliedMark = false
                 for (param in params.params) {
                     val identifier = param.asString().asIdentifierDefaultingNamespace()
                     val mark = Marks.getByIdentifier(identifier)
-                    if (mark != null) pokemon.exchangeMark(mark, true)
+                    if (mark != null) {
+                        pokemon.exchangeMark(mark, true)
+                        appliedMark = true
+                    }
                 }
+
+                DoubleValue(appliedMark)
             }
             map.put("add_marks_with_chance") { params ->
+                var appliedMark = false
                 for (param in params.params) {
                     val identifier = param.asString().asIdentifierDefaultingNamespace()
                     val mark = Marks.getByIdentifier(identifier)
+
                     mark?.let {
                         val probability = it.chance.coerceIn(0F, 1F) * 100
                         val randomValue = Random.nextDouble(0.0, 100.0)
-                        if (randomValue < probability) pokemon.exchangeMark(it, true)
+                        if (randomValue < probability) {
+                            pokemon.exchangeMark(it, true)
+                            appliedMark = true
+                        }
                     }
                 }
+
+                DoubleValue(appliedMark)
             }
             map.put("add_potential_marks") { params ->
                 for (param in params.params) {

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

@@ -80,7 +80,9 @@ open class ChoiceSpeciesFeatureProvider(
 
     internal constructor(): this(emptyList())
 
-    override fun get(pokemon: Pokemon) = pokemon.getFeature<StringSpeciesFeature>(keys.first())
+    override fun get(pokemon: Pokemon): StringSpeciesFeature? {
+        return pokemon.features.filterIsInstance<StringSpeciesFeature>().find { it.name in keys }
+    }
 
     override fun invoke(pokemon: Pokemon): StringSpeciesFeature? {
         val existing = get(pokemon)
@@ -101,15 +103,15 @@ open class ChoiceSpeciesFeatureProvider(
     }
 
     override fun invoke(nbt: CompoundTag): StringSpeciesFeature? {
-        return if (nbt.contains(keys.first())) {
-            StringSpeciesFeature(keys.first(), "").also { it.loadFromNBT(nbt) }
-        } else null
+        val key = keys.find { nbt.contains(it) }
+        if (key == null) return null
+        return StringSpeciesFeature(key, "").also { it.loadFromNBT(nbt) }
     }
 
     override fun invoke(json: JsonObject): StringSpeciesFeature? {
-        return if (json.has(keys.first())) {
-            StringSpeciesFeature(keys.first(), "").also { it.loadFromJSON(json) }
-        } else null
+        val key = keys.find { json.has(it) }
+        if (key == null) return null
+        return StringSpeciesFeature(key, "").also { it.loadFromJSON(json) }
     }
 
     override fun fromString(value: String?): StringSpeciesFeature? {
@@ -131,7 +133,7 @@ open class ChoiceSpeciesFeatureProvider(
 
     override fun provide(properties: PokemonProperties): Set<String> {
         return if (isAspect) {
-            val feature = properties.customProperties.filterIsInstance<StringSpeciesFeature>().find { it.name == keys.first() }
+            val feature = properties.customProperties.filterIsInstance<StringSpeciesFeature>().find { it.name in keys }
             if (feature != null) {
                 setOf(getAspect(feature))
             } else {

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

@@ -132,7 +132,9 @@ class FlagSpeciesFeatureProvider : SynchronizedSpeciesFeatureProvider<FlagSpecie
 
     constructor(vararg keys: String) : this(keys.toList())
 
-    override fun get(pokemon: Pokemon) = pokemon.getFeature<FlagSpeciesFeature>(keys.first())
+    override fun get(pokemon: Pokemon): FlagSpeciesFeature? {
+        return pokemon.features.filterIsInstance<FlagSpeciesFeature>().find { it.name in keys }
+    }
 
     override fun invoke(pokemon: Pokemon): FlagSpeciesFeature? {
         return get(pokemon)
@@ -144,15 +146,15 @@ class FlagSpeciesFeatureProvider : SynchronizedSpeciesFeatureProvider<FlagSpecie
     }
 
     override fun invoke(nbt: CompoundTag): FlagSpeciesFeature? {
-        return if (nbt.contains(keys.first())) {
-            FlagSpeciesFeature(keys.first(), false).also { it.loadFromNBT(nbt) }
-        } else null
+        val key = keys.find { nbt.contains(it) }
+        if (key == null) return null
+        return FlagSpeciesFeature(key, false).also { it.loadFromNBT(nbt) }
     }
 
     override fun invoke(json: JsonObject): FlagSpeciesFeature? {
-        return if (json.has(keys.first())) {
-            FlagSpeciesFeature(keys.first(), false).also { it.loadFromJSON(json) }
-        } else null
+        val key = keys.find { json.has(it) }
+        if (key == null) return null
+        return FlagSpeciesFeature(key, false).also { it.loadFromJSON(json) }
     }
 
     override fun fromString(value: String?): FlagSpeciesFeature? {
@@ -170,16 +172,26 @@ class FlagSpeciesFeatureProvider : SynchronizedSpeciesFeatureProvider<FlagSpecie
     }
 
     override fun provide(pokemon: Pokemon): Set<String> {
-        return if (isAspect && pokemon.getFeature<FlagSpeciesFeature>(keys.first())?.enabled == true) {
-            setOf(keys.first())
+        return if (isAspect) {
+            val feature = pokemon.features.filterIsInstance<FlagSpeciesFeature>().find { it.name in keys }
+            if (feature != null && feature.enabled) {
+                setOf(keys.first())
+            } else {
+                emptySet()
+            }
         } else {
             emptySet()
         }
     }
 
     override fun provide(properties: PokemonProperties): Set<String> {
-        return if (isAspect && properties.customProperties.filterIsInstance<FlagSpeciesFeature>().find { it.name == keys.first() }?.enabled == true) {
-            setOf(keys.first())
+        return if (isAspect) {
+            val feature = properties.customProperties.filterIsInstance<FlagSpeciesFeature>().find { it.name in keys }
+            if (feature != null && feature.enabled) {
+                setOf(keys.first())
+            } else {
+                emptySet()
+            }
         } else {
             emptySet()
         }

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

@@ -142,19 +142,15 @@ class IntSpeciesFeatureProvider : SynchronizedSpeciesFeatureProvider<IntSpeciesF
     }
 
     override fun invoke(nbt: CompoundTag): IntSpeciesFeature? {
-        return if (nbt.contains(keys.first())) {
-            IntSpeciesFeature(keys.first(), nbt.getInt(keys.first()))
-        } else {
-            null
-        }
+        val key = keys.find { nbt.contains(it) }
+        if (key == null) return null
+        return IntSpeciesFeature(keys.first(), nbt.getInt(key));
     }
 
     override fun invoke(json: JsonObject): IntSpeciesFeature? {
-        return if (json.has(keys.first())) {
-            IntSpeciesFeature(keys.first(), json.get(keys.first()).asInt)
-        } else {
-            null
-        }
+        val key = keys.find { json.has(it) }
+        if (key == null) return null
+        return IntSpeciesFeature(keys.first(), json.get(key).asInt)
     }
 
     override fun get(pokemon: Pokemon) = pokemon.features.filterIsInstance<IntSpeciesFeature>().find { it.name in keys }

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

@@ -12,6 +12,7 @@ import com.cobblemon.mod.common.entity.npc.NPCEntity
 import com.cobblemon.mod.common.pokemon.Pokemon
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.player.Player
 
 /**
  * A [Requirement] that expects a [LivingEntity] to be attached to the [Pokemon].
@@ -26,7 +27,7 @@ interface OwnerQueryRequirement : Requirement {
     override fun check(pokemon: Pokemon): Boolean {
         val owner = pokemon.getOwnerEntity() ?: return false
         return when (owner) {
-            is ServerPlayer -> {
+            is Player -> {
                 this.checkPlayer(pokemon, owner)
             }
             is NPCEntity -> {
@@ -37,13 +38,13 @@ interface OwnerQueryRequirement : Requirement {
     }
 
     /**
-     * Checks if the given [Pokemon] & [ServerPlayer] satisfies the requirement.
+     * Checks if the given [Pokemon] & [Player] satisfies the requirement.
      *
      * @param pokemon The [Pokemon] being queried.
-     * @param owner The [ServerPlayer] that owns this [Pokemon].
+     * @param owner The [Player] that owns this [Pokemon].
      * @return If the requirement was satisfied.
      */
-    fun checkPlayer(pokemon: Pokemon, owner: ServerPlayer): Boolean
+    fun checkPlayer(pokemon: Pokemon, owner: Player): Boolean
 
     /**
      * Checks if the given [Pokemon] & [NPCEntity] satisfies the requirement.

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

@@ -12,6 +12,7 @@ package com.cobblemon.mod.common.api.riding.sound
 import com.cobblemon.mod.common.api.riding.behaviour.types.composite.CompositeBehaviour
 import com.cobblemon.mod.common.api.riding.behaviour.types.composite.CompositeState
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.util.getIsSubmerged
 import com.cobblemon.mod.common.util.resolveDouble
 import net.minecraft.client.Minecraft
 import net.minecraft.client.resources.sounds.AbstractTickableSoundInstance
@@ -65,6 +66,21 @@ class RideLoopSound(val ride: PokemonEntity, val soundSettings: RideSoundSetting
             return
         }
 
+        // Mute the sound if it's not meant to play for the passenger
+        if (this.isPassenger && !this.soundSettings.playForPassengers) {
+            this.volume = 0.0f
+            return
+        }
+
+        // Mute sounds when submerged unless they support underwater sounds, underwater sounds don't play above water
+        if (this.ride.getIsSubmerged() && !this.soundSettings.submerged) {
+            this.volume = 0.0f
+            return
+        } else if (!this.ride.getIsSubmerged() && this.soundSettings.submerged) {
+            this.volume = 0.0f
+            return
+        }
+
         // Perform data driven pitch and volume calculation
         this.volume = ((soundSettings.volumeExpr.let { ride.runtime.resolveDouble(it) })).toFloat()
         this.volume *= this.fade

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

@@ -27,7 +27,9 @@ data class RideSoundSettings(
     val soundLocation: ResourceLocation,
     @SerializedName("volumeExpr") private val _volumeExpr: Expression? = "1.0".asExpression(),
     @SerializedName("pitchExpr") private val _pitchExpr: Expression? = "1.0".asExpression(),
+    val playForPassengers: Boolean = true,
     val playForNonPassengers: Boolean = false,
+    val submerged: Boolean = false,
     val muffleEnabled: Boolean = false,
     @SerializedName("attenuationModel") private val _attenuationModel: RideAttenuationModel? = RideAttenuationModel.NONE
 ): Encodable {
@@ -46,7 +48,9 @@ data class RideSoundSettings(
         buffer.writeResourceLocation(soundLocation)
         buffer.writeExpression(volumeExpr)
         buffer.writeExpression(pitchExpr)
+        buffer.writeBoolean(playForPassengers)
         buffer.writeBoolean(playForNonPassengers)
+        buffer.writeBoolean(submerged)
         buffer.writeBoolean(muffleEnabled)
         buffer.writeEnum(attenuationModel)
     }
@@ -57,7 +61,9 @@ data class RideSoundSettings(
             val soundLocation = buffer.readResourceLocation()
             val volumeExpr = buffer.readExpression()
             val pitchExpr = buffer.readExpression()
+            val playForPassengers = buffer.readBoolean()
             val playForNonPassengers = buffer.readBoolean()
+            val submerged = buffer.readBoolean()
             val muffleEnabled = buffer.readBoolean()
             val attenuationModel = buffer.readEnum(RideAttenuationModel::class.java)
 
@@ -65,7 +71,9 @@ data class RideSoundSettings(
                 soundLocation,
                 volumeExpr,
                 pitchExpr,
+                playForPassengers,
                 playForNonPassengers,
+                submerged,
                 muffleEnabled,
                 attenuationModel
             )

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

@@ -8,30 +8,58 @@
 
 package com.cobblemon.mod.common.api.stats
 
+import com.cobblemon.mod.common.Cobblemon
+import net.minecraft.core.registries.BuiltInRegistries
 import net.minecraft.resources.ResourceLocation
+import net.minecraft.stats.StatFormatter
 
 object CobblemonStats {
-    val stats = mutableMapOf<String,  ResourceLocation>()
+    val stats = mutableMapOf<String, CobblemonStat>()
 
-    var CAPTURED: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "captured") //makeCustomStat("captured", StatFormatter.DEFAULT)
-    val SHINIES_CAPTURED: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "shinies_captured") //makeCustomStat("shinies_captured", StatFormatter.DEFAULT)
-    val RELEASED: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "released") //makeCustomStat("released", StatFormatter.DEFAULT)
-    val EVOLVED: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "evolved") //makeCustomStat("evolved", StatFormatter.DEFAULT)
-    val LEVEL_UP: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "level_up") //makeCustomStat("level_up", StatFormatter.DEFAULT)
-    val BATTLES_WON: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "battles_won") //makeCustomStat("battles_won", StatFormatter.DEFAULT)
-    val BATTLES_LOST: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "battles_lost") //makeCustomStat("battles_lost", StatFormatter.DEFAULT)
-    val BATTLES_FLED: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "battles_fled") //makeCustomStat("battles_fled", StatFormatter.DEFAULT)
-    val BATTLES_TOTAL: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "battles_total") //makeCustomStat("battles_total", StatFormatter.DEFAULT)
-    val DEX_ENTRIES: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "dex_entries") //makeCustomStat("dex_entries", StatFormatter.DEFAULT)
-    val EGGS_COLLECTED: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "eggs_collected") //makeCustomStat("eggs_collected", StatFormatter.DEFAULT)
-    val EGGS_HATCHED: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "eggs_hatched") //makeCustomStat("eggs_hatched", StatFormatter.DEFAULT)
-    val TRADED: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "traded") //makeCustomStat("traded", StatFormatter.DEFAULT)
-    val FOSSILS_REVIVED: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "fossils_revived") //makeCustomStat("fossils_revived", StatFormatter.DEFAULT)
-    val TIMES_RIDDEN: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "times_ridden")
-    val ROD_CASTS: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "rod_casts")
-    val REEL_INS: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "reel_ins")
-    val POKEMON_INTERACTED_WITH: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "pokemon_interacted_with") //makeCustomStat("pokemon_interacted_with", StatFormatter.DEFAULT)
-    //TODO block, stats (interact, gimmi), riding (styles?)
+    @JvmField
+    var CAPTURED: CobblemonStat = CobblemonStat("captured")
+    @JvmField
+    val SHINIES_CAPTURED: CobblemonStat = CobblemonStat("shinies_captured")
+    @JvmField
+    val RELEASED: CobblemonStat = CobblemonStat("released")
+    @JvmField
+    val EVOLVED: CobblemonStat = CobblemonStat("evolved")
+    @JvmField
+    val LEVEL_UP: CobblemonStat = CobblemonStat("level_up")
+    @JvmField
+    val BATTLES_WON: CobblemonStat = CobblemonStat("battles_won")
+    @JvmField
+    val BATTLES_LOST: CobblemonStat = CobblemonStat("battles_lost")
+    @JvmField
+    val BATTLES_FLED: CobblemonStat = CobblemonStat("battles_fled")
+    @JvmField
+    val BATTLES_TOTAL: CobblemonStat = CobblemonStat("battles_total")
+    @JvmField
+    val DEX_ENTRIES: CobblemonStat = CobblemonStat("dex_entries")
+    @JvmField
+    val EGGS_COLLECTED: CobblemonStat = CobblemonStat("eggs_collected")
+    @JvmField
+    val EGGS_HATCHED: CobblemonStat = CobblemonStat("eggs_hatched")
+    @JvmField
+    val TRADED: CobblemonStat = CobblemonStat("traded")
+    @JvmField
+    val FOSSILS_REVIVED: CobblemonStat = CobblemonStat("fossils_revived")
+    @JvmField
+    val TIMES_RIDDEN: CobblemonStat = CobblemonStat("times_ridden")
+    @JvmField
+    val ROD_CASTS: CobblemonStat = CobblemonStat("rod_casts")
+    @JvmField
+    val REEL_INS: CobblemonStat = CobblemonStat("reel_ins")
+    @JvmField
+    val POKEMON_INTERACTED_WITH: CobblemonStat = CobblemonStat("pokemon_interacted_with")
+    @JvmField
+    val RIDING_LAND: CobblemonStat = CobblemonStat("riding_land", StatFormatter.DISTANCE)
+    @JvmField
+    val RIDING_AIR: CobblemonStat = CobblemonStat("riding_air", StatFormatter.DISTANCE)
+    @JvmField
+    val RIDING_LIQUID: CobblemonStat = CobblemonStat("riding_liquid", StatFormatter.DISTANCE)
+
+    //TODO block, stats (interact, gimmi)
 
     fun registerStats() {
         stats["captured"] = CAPTURED
@@ -52,5 +80,22 @@ object CobblemonStats {
         stats["rod_casts"] = ROD_CASTS
         stats["reel_ins"] = REEL_INS
         stats["pokemon_interacted_with"] = POKEMON_INTERACTED_WITH
+        stats["riding_land"] = RIDING_LAND
+        stats["riding_air"] = RIDING_AIR
+        stats["riding_liquid"] = RIDING_LIQUID
+    }
+
+    @JvmStatic
+    fun getStat(cobblemonStat: CobblemonStat) : ResourceLocation {
+        val resourceLocation = cobblemonStat.resourceLocation
+        val stat = BuiltInRegistries.CUSTOM_STAT.get(resourceLocation)
+        if (stat == null) {
+            Cobblemon.LOGGER.error("Could not find stat with id {}", resourceLocation)
+        }
+        return stat ?: throw NullPointerException("Could not find stat with id $resourceLocation")
+    }
+
+    data class CobblemonStat(val path: String, val formatter: StatFormatter = StatFormatter.DEFAULT) {
+        val resourceLocation: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", path);
     }
 }

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

@@ -105,12 +105,18 @@ data class BattleFormat(
     }
 
     fun toFormatJSON(): String {
+        /*
+          Bag clause does not exist in showdown as a rule because showdown simply has no concept of a 'bag'.
+          If we try sending it, the battle will error. So this simply omits that from ever getting sent.
+          If we ever find a case where we are doing this for more than just bag clause, we should make a proper abstraction.
+         */
+        val rulesToSendToShowdown = ruleSet.filter { it != BattleRules.BAG_CLAUSE }
         return """
             {
                 "mod": "$mod",
                 "gameType": "${battleType.name}",
                 "gen": $gen,
-                "ruleset": [${ruleSet.joinToString { "\"$it\"" }}],
+                "ruleset": [${rulesToSendToShowdown.joinToString { "\"$it\"" }}],
                 "effectType": "Format"
             }
         """.trimIndent().replace("\n", "")

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

@@ -12,6 +12,7 @@ object BattleRules {
     const val OBTAINABLE = "Obtainable"
     const val PAST = "+Past"
     const val UNOBTAINABLE = "+Unobtainable"
+    const val BAG_CLAUSE = "Bag Clause"
     const val TEAM_PREVIEW = "Team Preview"
     const val ENDLESS_BATTLE_CLAUSE = "Endless Battle Clause"
     const val CANCEL_MOD = "Cancel Mod"

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

@@ -289,6 +289,8 @@ class ShowdownMoveset {
     var canDynamax = false
     var maxMoves: List<InBattleGimmickMove?>? = null
     var canTerastallize: String? = null
+    /** This stores a list of gimmicks that have already been used this turn by a previous Pokemon, but the full turn has not been processed (ie. double battles). */
+    val pendingGimmickUsedThisTurn = mutableListOf<Gimmick>()
 
     fun saveToBuffer(buffer: RegistryFriendlyByteBuf) {
         buffer.writeSizedInt(IntSize.U_BYTE, moves.size)

common/src/main/kotlin/com/cobblemon/mod/common/battles/ai/StrongBattleAI.kt

@@ -31,6 +31,7 @@ import kotlin.collections.associateWith
 import kotlin.collections.partition
 import kotlin.math.absoluteValue
 
+
 /**
  * AI that tries to choose the best move for the given situations. Based off of the Pokemon Trainer Tournament Simulator Github
  * https://github.com/cRz-Shadows/Pokemon_Trainer_Tournament_Simulator/blob/main/pokemon-showdown/sim/examples/Simulation-test-1.ts#L330
@@ -271,6 +272,11 @@ class StrongBattleAI(skill: Int) : BattleAI {
         }
         activeTrackerPokemon.firstTurn = false
 
+        // If HP is below 30% and not switching out, always use the most damaging move
+        if (activeTrackerPokemon.currentHpPercent < 0.3 && !shouldSwitchOut(aiSide, battle, activeBattlePokemon, moveset)) {
+            findAndUseMostDamagingMove(activeBattlePokemon, activeTrackerPokemon, opponents, availableMoves, moveset, battle, aiSide)?.let { return it }
+        }
+
         // Decision-making based on move availability and switch-out condition
         if (!shouldSwitchOut(aiSide, battle, activeBattlePokemon, moveset)) {
             val nRemainingMons = activeTracker.alliedSide.actors.sumOf { actor -> actor.party.filter { it.currentHpPercent > 0 }.size }
@@ -521,6 +527,19 @@ class StrongBattleAI(skill: Int) : BattleAI {
 
         val opponentActiveTracker = activeTracker.opponentSide.activePokemon
         val opponentSpeedEstimations = opponentActiveTracker.map { statEstimationActive(it, Stats.SPEED) }
+
+
+        // Only switch if a switch-in is significantly better than the current Pokémon
+        val currentScore = estimateMatchup(activeBattlePokemon, side, battle)
+        val bestSwitchScore = availableSwitches.maxOfOrNull { estimateMatchup(activeBattlePokemon, side, battle, it) } ?: currentScore
+        val improvementThreshold = currentScore.absoluteValue * 0.25 + 2
+        if (bestSwitchScore <= currentScore + improvementThreshold) {
+            return false
+        }
+
+        if(bestSwitchScore < 1) {
+            return false
+        }
         // todo add some way to keep track of the player's boosting to see if it needs to switch out to something that can stop it
 
         // if slower speed stat than the opposing pokemon and HP is less than 20% don't switch out
@@ -548,6 +567,8 @@ class StrongBattleAI(skill: Int) : BattleAI {
         if (availableSwitches.isEmpty() || availableSwitches.none { estimateMatchup(activeBattlePokemon, side, battle, it) > 0 })
             return false
 
+        
+
         // ...and a 'good' reason to switch out
         if (opponentActiveTracker.any { it.boosts.getOrDefault(Stats.ACCURACY, 0) <= accuracySwitchThreshold } ||
             opponentActiveTracker.any { it.boosts.getOrDefault(Stats.DEFENCE, 0) <= -3 } ||

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

@@ -114,7 +114,14 @@ class ActivateInstruction(val instructionSet: InstructionSet, val message: Battl
                 }
                 "maxguard", "protect" -> battleLang("activate.protect", pokemonName)
                 "shadowforce", "hyperspacefury", "hyperspacehole" -> battleLang("activate.phantomforce", pokemonName)
-                else -> battleLang("activate.${effect.id}", pokemonName, sourceName, extraEffect)
+                else -> {
+                    val msgVariant = message.optionalArgument("msg")
+                    if (msgVariant != null) {
+                        battleLang("activate.${effect.id}.$msgVariant", pokemonName, sourceName, extraEffect)
+                    } else {
+                        battleLang("activate.${effect.id}", pokemonName, sourceName, extraEffect)
+                    }
+                }
             }
             battle.broadcastChatMessage(lang)
             //We check holds here so the chat msg + particle effect happen more concurrently, instead of sequentially

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

@@ -21,6 +21,7 @@ import com.cobblemon.mod.common.util.isInBattle
 import com.cobblemon.mod.common.util.playSoundServer
 import com.cobblemon.mod.common.util.toVec3d
 import com.cobblemon.mod.common.util.voxelShape
+import com.cobblemon.mod.common.util.rotateShape
 import com.mojang.serialization.MapCodec
 import net.minecraft.core.BlockPos
 import net.minecraft.core.Direction
@@ -71,10 +72,10 @@ class PastureBlock(settings: Properties): BaseEntityBlock(settings), SimpleWater
         private val WEST_AABB_TOP = buildCollider(top = true, Direction.WEST)
         private val EAST_AABB_TOP = buildCollider(top = true, Direction.EAST)
 
-        private val SOUTH_AABB_BOTTOM = buildCollider(top = false, Direction.SOUTH)
-        private val NORTH_AABB_BOTTOM = buildCollider(top = false, Direction.NORTH)
-        private val WEST_AABB_BOTTOM = buildCollider(top = false, Direction.WEST)
         private val EAST_AABB_BOTTOM = buildCollider(top = false, Direction.EAST)
+        private val SOUTH_AABB_BOTTOM = rotateShape(Direction.EAST, Direction.SOUTH, EAST_AABB_BOTTOM)
+        private val NORTH_AABB_BOTTOM = rotateShape(Direction.EAST, Direction.NORTH, EAST_AABB_BOTTOM)
+        private val WEST_AABB_BOTTOM = rotateShape(Direction.EAST, Direction.WEST, EAST_AABB_BOTTOM)
 
         private fun buildCollider(top: Boolean, direction: Direction): VoxelShape {
             if (top) {

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

@@ -8,9 +8,7 @@
 
 package com.cobblemon.mod.common.client
 
-import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.Cobblemon.LOGGER
-import com.cobblemon.mod.common.Cobblemon.cobblemonVR
 import com.cobblemon.mod.common.CobblemonBlockEntities
 import com.cobblemon.mod.common.CobblemonBlocks
 import com.cobblemon.mod.common.CobblemonClientImplementation
@@ -29,7 +27,6 @@ import com.cobblemon.mod.common.client.gui.PartyOverlayDataControl
 import com.cobblemon.mod.common.client.gui.RideControlsOverlay
 import com.cobblemon.mod.common.client.gui.battle.BattleOverlay
 import com.cobblemon.mod.common.client.gui.cookingpot.CookingPotScreen
-import com.cobblemon.mod.common.client.integration.vivecraft.CobblemonVRClient
 import com.cobblemon.mod.common.client.particle.BedrockParticleOptionsRepository
 import com.cobblemon.mod.common.client.render.ClientPlayerIcon
 import com.cobblemon.mod.common.client.render.DeferredRenderer
@@ -75,7 +72,6 @@ import com.cobblemon.mod.common.client.tooltips.TooltipManager
 import com.cobblemon.mod.common.client.trade.ClientTrade
 import com.cobblemon.mod.common.entity.boat.CobblemonBoatType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.integration.vivecraft.CobblemonVR
 import com.cobblemon.mod.common.platform.events.PlatformEvents
 import com.cobblemon.mod.common.pokedex.scanner.PokedexUsageContext
 import com.cobblemon.mod.common.util.isLookingAt
@@ -156,10 +152,6 @@ object CobblemonClient {
         this.registerTooltipManagers()
         this.registerMenuScreens()
 
-        if (Cobblemon.implementation.isModInstalled("vivecraft")) {  // VR integration
-            CobblemonVRClient.init()
-        }
-
         LOGGER.info("Registering custom BuiltinItemRenderers")
         CobblemonBuiltinItemRendererRegistry.register(CobblemonItems.POKEMON_MODEL, PokemonItemRenderer())
 
@@ -195,9 +187,7 @@ object CobblemonClient {
 
                 nearbyPokemon?.forEach { entity ->
                     if (entity is PokemonEntity && !entity.isSilent && !entity.passengers.contains(player)) {
-                        if (player.isLookingAt(entity) && !player.isSpectator && entity.pokemon.shiny) entity.delegate.spawnShinyParticle(
-                            player
-                        )
+                        if (player.isLookingAt(entity) && !player.isSpectator && entity.pokemon.shiny) entity.delegate.spawnShinyParticle(player)
                         entity.delegate.spawnAspectParticle()
                     }
                 }
@@ -379,10 +369,7 @@ object CobblemonClient {
         this.implementation.registerBlockEntityRenderer(CobblemonBlockEntities.DISPLAY_CASE, ::DisplayCaseRenderer)
         this.implementation.registerBlockEntityRenderer(CobblemonBlockEntities.LECTERN, ::LecternBlockEntityRenderer)
         this.implementation.registerBlockEntityRenderer(CobblemonBlockEntities.CAMPFIRE, ::CampfireBlockEntityRenderer)
-        this.implementation.registerBlockEntityRenderer(
-            CobblemonBlockEntities.POKE_SNACK,
-            ::PokeSnackBlockEntityRenderer
-        )
+        this.implementation.registerBlockEntityRenderer(CobblemonBlockEntities.POKE_SNACK, ::PokeSnackBlockEntityRenderer)
     }
 
     private fun registerEntityRenderers() {
@@ -411,11 +398,7 @@ object CobblemonClient {
 
     private fun registerItemColors() {
         implementation.registerItemColors(AprijuiceItemColorProvider, *CobblemonItems.aprijuices.toTypedArray())
-        implementation.registerItemColors(
-            PokeSnackItemColorProvider,
-            CobblemonItems.POKE_SNACK,
-            CobblemonItems.POKE_CAKE
-        )
+        implementation.registerItemColors(PokeSnackItemColorProvider, CobblemonItems.POKE_SNACK, CobblemonItems.POKE_CAKE)
         implementation.registerItemColors(PokeBaitItemColorProvider, CobblemonItems.POKE_BAIT)
         implementation.registerItemColors(PonigiriItemColorProvider, CobblemonItems.PONIGIRI)
         implementation.registerItemColors(SinisterTeaItemColorProvider, CobblemonItems.SINISTER_TEA)

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

@@ -11,10 +11,11 @@ package com.cobblemon.mod.common.client.battle
 import com.cobblemon.mod.common.CobblemonNetwork
 import com.cobblemon.mod.common.api.battles.model.actor.ActorType
 import com.cobblemon.mod.common.api.pokedex.PokedexEntryProgress
-import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
 import com.cobblemon.mod.common.battles.BattleFormat
 import com.cobblemon.mod.common.battles.ForcePassActionResponse
+import com.cobblemon.mod.common.battles.MoveActionResponse
 import com.cobblemon.mod.common.battles.PassActionResponse
+import com.cobblemon.mod.common.battles.ShowdownMoveset
 import com.cobblemon.mod.common.client.CobblemonClient
 import com.cobblemon.mod.common.net.messages.server.battle.BattleSelectActionsPacket
 import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
@@ -61,8 +62,15 @@ class ClientBattle(
         if (index != -1) {
            while(index < pendingActionRequests.size) {
                val request = pendingActionRequests[index]
-               if (request.response != PassActionResponse && request.response !is ForcePassActionResponse)
+               if (request.response != PassActionResponse && request.response !is ForcePassActionResponse) {
+                   val response = request.response
+                   // If we're cancelling a turn that used a gimmick, we re-enable the ability for that gimmick to be used.
+                   if (response is MoveActionResponse && response.gimmickID != null) {
+                       val gimmick = ShowdownMoveset.Gimmick.entries.find { it.id == response.gimmickID }
+                       pendingActionRequests.forEach { it.moveSet?.pendingGimmickUsedThisTurn?.remove(gimmick) }
+                   }
                    request.response = null
+               }
                index++
            }
         }

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

@@ -68,7 +68,7 @@ class BattleMoveSelection(
     var moveTiles = baseTiles
 
     val backButton = BattleBackButton(x - 11F, Minecraft.getInstance().window.guiScaledHeight - 22F)
-    val gimmickButtons = moveSet.getGimmicks().mapIndexed { index, gimmick ->
+    val gimmickButtons = moveSet.getGimmicks().filter { it !in moveSet.pendingGimmickUsedThisTurn }.mapIndexed { index, gimmick ->
         val initOff = BattleBackButton.WIDTH * 0.65F
         val xOff = initOff + BattleGimmickButton.SPACING * index
         BattleGimmickButton.create(gimmick, this, backButton.x + xOff, backButton.y)

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

@@ -17,6 +17,7 @@ import com.cobblemon.mod.common.api.text.text
 import com.cobblemon.mod.common.battles.InBattleGimmickMove
 import com.cobblemon.mod.common.battles.InBattleMove
 import com.cobblemon.mod.common.battles.MoveActionResponse
+import com.cobblemon.mod.common.battles.ShowdownMoveset
 import com.cobblemon.mod.common.client.CobblemonClient
 import com.cobblemon.mod.common.client.CobblemonResources
 import com.cobblemon.mod.common.client.battle.ActiveClientBattlePokemon
@@ -127,7 +128,7 @@ class BattleTargetSelection(
         private val isMultiTarget = multiTargetList?.firstOrNull { it.getPNX() == target.getPNX() } != null
         private val isCurrentPokemon = request.activePokemon.battlePokemon?.uuid == target.battlePokemon!!.uuid
 
-        open val response: MoveActionResponse get() = MoveActionResponse(targetSelection.move.id, responseTarget)
+        open val response: MoveActionResponse get() = MoveActionResponse(targetSelection.move.id, responseTarget, gimmickID)
         val state = FloatingState()
 
         open val selectable: Boolean get() = isMultiTarget || (responseTarget != null)
@@ -311,6 +312,13 @@ class BattleTargetSelection(
         fun onClick() {
             if (!selectable) return
             targetSelection.playDownSound(Minecraft.getInstance().soundManager)
+            // If a gimmick is used, remove the ability to use it on any pending action requests ahead of it
+            if (response.gimmickID != null) {
+                val gimmick = ShowdownMoveset.Gimmick.entries.first { it.id == response.gimmickID }
+                CobblemonClient.battle?.pendingActionRequests?.forEach {
+                    it.moveSet?.pendingGimmickUsedThisTurn?.add(gimmick)
+                }
+            }
             targetSelection.battleGUI.selectAction(targetSelection.request, response)
         }
     }

common/src/main/kotlin/com/cobblemon/mod/common/client/integration/vivecraft/CobblemonVRClient.kt

@@ -1,26 +0,0 @@
-package com.cobblemon.mod.common.client.integration.vivecraft
-
-import com.cobblemon.mod.common.client.integration.vivecraft.party.PartyOnArm
-import com.cobblemon.mod.common.client.integration.vivecraft.proximity.ProximityManager
-import com.cobblemon.mod.common.client.integration.vivecraft.proximity.ProximityRegistration
-import com.cobblemon.mod.common.client.integration.vivecraft.listener.proximity.PokeRodBaitListener
-import org.vivecraft.api.data.VRBodyPart
-
-class CobblemonVRClient {
-
-    companion object {
-        fun init() {
-            PartyOnArm.init()
-            ProximityManager.init()
-            ProximityManager.register(
-                ProximityRegistration(
-                    bodyA = VRBodyPart.MAIN_HAND,
-                    bodyB = VRBodyPart.OFF_HAND,
-                    distanceThreshold = 0.25f,
-                    angleThreshold = 120f,
-                    listener = PokeRodBaitListener("Main-OffHand")
-                )
-            )
-        }
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/integration/vivecraft/listener/proximity/PokeRodBaitListener.kt

@@ -1,40 +0,0 @@
-package com.cobblemon.mod.common.client.integration.vivecraft.listener.proximity
-
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.CobblemonNetwork
-import com.cobblemon.mod.common.api.tags.CobblemonItemTags
-import com.cobblemon.mod.common.client.integration.vivecraft.proximity.ProximityListener
-import com.cobblemon.mod.common.client.integration.vivecraft.proximity.ProximityRegistration
-import com.cobblemon.mod.common.net.messages.server.pokerod.ApplyBaitPacket
-import net.minecraft.client.Minecraft
-import net.minecraft.world.InteractionHand
-import net.minecraft.world.item.ItemStack
-import org.vivecraft.api.data.VRBodyPart
-import org.vivecraft.api.data.VRPose
-
-class PokeRodBaitListener(private val name: String) : ProximityListener {
-    //TODO: Also add that if 1 is Rod the other needs to be seasoning
-    override fun isActive(registration: ProximityRegistration): Boolean {
-        val player = Minecraft.getInstance().player ?: return false
-        val handA: InteractionHand = VRBodyPart.toInteractionHand(registration.bodyA) ?: return false
-        val itemStackA: ItemStack = player.getItemInHand(handA)
-
-        val handB: InteractionHand = VRBodyPart.toInteractionHand(registration.bodyB) ?: return false
-        val itemStackB: ItemStack = player.getItemInHand(handB)
-
-        return itemStackA.`is`(CobblemonItemTags.POKE_RODS) || itemStackB.`is`(CobblemonItemTags.POKE_RODS)
-    }
-
-    override fun onEnter(bodyA: VRBodyPart, bodyB: VRBodyPart, pose: VRPose) {
-        Cobblemon.LOGGER.info("[$name] Enter: $bodyA <-> $bodyB")
-    }
-
-    override fun onExit(bodyA: VRBodyPart, bodyB: VRBodyPart, pose: VRPose) {
-        Cobblemon.LOGGER.info("[$name] Exit: $bodyA <-> $bodyB")
-    }
-
-    override fun onTick(bodyA: VRBodyPart, bodyB: VRBodyPart, pose: VRPose) {
-        Cobblemon.LOGGER.info("[$name] Proximity: $bodyA <-> $bodyB")
-        CobblemonNetwork.sendToServer(ApplyBaitPacket())
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/integration/vivecraft/listener/swing/DirectionalSwingListener.kt

@@ -1,237 +0,0 @@
-package com.cobblemon.mod.common.client.integration.vivecraft.listener.swing
-
-import com.cobblemon.mod.common.Cobblemon
-import net.minecraft.client.Minecraft
-import net.minecraft.world.InteractionHand
-import net.minecraft.world.entity.player.Player
-import net.minecraft.world.item.ItemStack
-import net.minecraft.world.phys.Vec3
-import org.vivecraft.api.client.VRClientAPI
-import org.vivecraft.api.client.tracker.swing.SwingContext
-import org.vivecraft.api.client.tracker.swing.SwingListener
-import org.vivecraft.api.data.VRBodyPart
-import kotlin.math.abs
-
-/**
- * Listener that classifies directional swings (up, down, forward, backward, left, right)
- * using Vivecraft VR pose history and invokes handler methods for each direction.
- *
- * @param forwardDotThreshold Dot product threshold used to classify forward/back/left/right directions.
- * @param historyTicks Number of ticks used to compute velocity from historical poses.
- */
-abstract class DirectionalSwingListener(
-    private val forwardDotThreshold: Double = 0.3,
-    private val historyTicks: Int = 10
-) : SwingListener {
-
-    protected val minecraft: Minecraft = Minecraft.getInstance()
-    protected val clientData: VRClientAPI = VRClientAPI.instance()
-
-    /**
-     * Compute the net movement vector for the specified body part over the given number of ticks.
-     * Returns null if historical pose data is unavailable, insufficient, or movement is negligible.
-     *
-     * @param bodyPart The VR body part to compute movement for.
-     * @param ticks The number of ticks of history to consider.
-     * @return The movement vector or null if unavailable/insignificant.
-     */
-    private fun changeForVelocity(bodyPart: VRBodyPart, ticks: Int = historyTicks): Vec3? {
-        val history = clientData.historicalVRPoses ?: return null
-        if (history.ticksOfHistory() < ticks) return null
-
-        val delta = history.netMovement(bodyPart, ticks)
-        delta?.lengthSqr()?.let { if (it < 1e-6) return null }
-
-        return delta
-    }
-
-    /**
-     * Called when an upward swing is detected.
-     *
-     * @param useHand The hand used for the swing.
-     * @param handVel The velocity vector of the hand during the swing.
-     * @param player The player performing the swing.
-     * @return True if the upward action was handled, false otherwise.
-     */
-    protected open fun onUpwardSwing(
-        useHand: InteractionHand,
-        player: Player
-    ): Boolean {
-        Cobblemon.LOGGER.info(
-            "Ignoring swing: upward movement. player={}, hand={}",
-            player, useHand
-        )
-        return true
-    }
-
-    /**
-     * Called when a downward swing is detected.
-     *
-     * @param useHand The hand used for the swing.
-     * @param handVel The velocity vector of the hand during the swing.
-     * @param player The player performing the swing.
-     * @return True if the downward action was handled, false otherwise.
-     */
-    protected open fun onDownwardSwing(
-        useHand: InteractionHand,
-        handVel: Vec3,
-        player: Player
-    ): Boolean {
-        Cobblemon.LOGGER.info(
-            "Ignoring swing: downward movement. handVel={}, player={}, hand={}",
-            handVel, player, useHand
-        )
-        return true
-    }
-
-    /**
-     * Called when a forward swing is detected.
-     *
-     * @param useHand The hand used for the swing.
-     * @param handVel The velocity vector of the hand during the swing.
-     * @param player The player performing the swing.
-     * @return True if the forward action was handled, false otherwise.
-     */
-    protected open fun onForwardSwing(
-        useHand: InteractionHand,
-        handVel: Vec3,
-        player: Player
-    ): Boolean {
-        return true
-    }
-
-    /**
-     * Called when a backward swing is detected.
-     *
-     * @param useHand The hand used for the swing.
-     * @param handVel The velocity vector of the hand during the swing.
-     * @param player The player performing the swing.
-     * @return True if the backward action was handled, false otherwise.
-     */
-    protected open fun onBackwardSwing(
-        useHand: InteractionHand,
-        handVel: Vec3,
-        player: Player
-    ): Boolean {
-        Cobblemon.LOGGER.info(
-            "Ignoring swing: backward movement. handVel={}, player={}, hand={}",
-            handVel, player, useHand
-        )
-        return true
-    }
-
-    /**
-     * Called when a leftward swing is detected.
-     *
-     * @param useHand The hand used for the swing.
-     * @param handVel The velocity vector of the hand during the swing.
-     * @param player The player performing the swing.
-     * @return True if the leftward action was handled, false otherwise.
-     */
-    protected open fun onLeftSwing(
-        useHand: InteractionHand,
-        handVel: Vec3,
-        player: Player
-    ): Boolean {
-        Cobblemon.LOGGER.info(
-            "Ignoring swing: leftward movement. handVel={}, player={}, hand={}",
-            handVel, player, useHand
-        )
-        return true
-    }
-
-    /**
-     * Called when a rightward swing is detected.
-     *
-     * @param useHand The hand used for the swing.
-     * @param handVel The velocity vector of the hand during the swing.
-     * @param player The player performing the swing.
-     * @return True if the rightward action was handled, false otherwise.
-     */
-    protected open fun onRightSwing(
-        useHand: InteractionHand,
-        handVel: Vec3,
-        player: Player
-    ): Boolean {
-        Cobblemon.LOGGER.info(
-            "Ignoring swing: rightward movement. handVel={}, player={}, hand={}",
-            handVel, player, useHand
-        )
-        return true
-    }
-
-
-    /**
-     * Checks if the given item stack is valid for processing by this swing listener.
-     * Subclasses must implement this to specify which items they handle.
-     * @param itemStack The item stack to validate.
-     * @return True if the item stack is valid, false otherwise.
-     */
-    protected abstract fun isValidItem(itemStack: ItemStack): Boolean
-
-    /**
-     * Called when a swing ends. Validates the held item, computes hand velocity from historical poses,
-     * handles vertical swings first (upward/downward) and then classifies horizontal direction:
-     * forward/backward by dot with player look direction; left/right by projecting onto a right vector
-     * computed from world up and forward. Ambiguous swings are ignored.
-     *
-     * @param context Vivecraft swing context containing body part information.
-     */
-    override fun onSwingEnd(context: SwingContext?) {
-        val player = minecraft.player ?: return
-        val ctx = context ?: return
-        val useHand: InteractionHand = VRBodyPart.toInteractionHand(ctx.bodyPart) ?: return
-        val itemStack: ItemStack = player.getItemInHand(useHand)
-
-        if (!isValidItem(itemStack)) return
-
-        val handVel = changeForVelocity(ctx.bodyPart) ?: run {
-            Cobblemon.LOGGER.info(
-                "Ignoring swing: insufficient historical pose data for velocity. bodyPart={}, player={}",
-                ctx.bodyPart, player
-            )
-            return
-        }
-
-        val vertical = handVel.y
-        if (vertical > 0.0) {
-            if (onUpwardSwing(useHand, player)) return
-        } else if (vertical < 0.0) {
-            if (onDownwardSwing(useHand, handVel, player)) return
-        }
-
-        val forward = player.lookAngle.normalize()
-        val handDir = handVel.normalize()
-        val forwardDot = handDir.dot(forward)
-
-        val worldUp = Vec3(0.0, 1.0, 0.0)
-        val right = forward.cross(worldUp).let {
-            if (it.lengthSqr() < 1e-6) Vec3(1.0, 0.0, 0.0) else it.normalize()
-        }
-        val rightDot = handDir.dot(right)
-
-        if (forwardDot > forwardDotThreshold) {
-            if (onForwardSwing(useHand, handVel, player)) return
-            return
-        }
-
-        if (forwardDot < -forwardDotThreshold) {
-            if (onBackwardSwing(useHand, handVel, player)) return
-            return
-        }
-
-        if (abs(rightDot) > forwardDotThreshold) {
-            if (rightDot > 0.0) {
-                if (onRightSwing(useHand, handVel, player)) return
-            } else {
-                if (onLeftSwing(useHand, handVel, player)) return
-            }
-            return
-        }
-
-        Cobblemon.LOGGER.info(
-            "Ignoring swing: ambiguous direction. forwardDot={}, rightDot={}, handVel={}, player={}",
-            forwardDot, rightDot, handVel, player
-        )
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/integration/vivecraft/listener/swing/PokeBallSwingListener.kt

@@ -1,29 +0,0 @@
-package com.cobblemon.mod.common.client.integration.vivecraft.listener.swing
-
-import com.cobblemon.mod.common.CobblemonNetwork
-import com.cobblemon.mod.common.api.tags.CobblemonItemTags
-import com.cobblemon.mod.common.net.messages.server.pokeball.SendOutPokeBallPacket
-import net.minecraft.world.InteractionHand
-import net.minecraft.world.entity.player.Player
-import net.minecraft.world.item.ItemStack
-import net.minecraft.world.phys.Vec3
-
-class PokeBallSwingListener : DirectionalSwingListener() {
-
-    override fun isValidItem(itemStack: ItemStack): Boolean =
-        itemStack.`is`(CobblemonItemTags.POKE_BALLS)
-
-    override fun onForwardSwing(
-        useHand: InteractionHand,
-        handVel: Vec3,
-        player: Player
-    ): Boolean {
-        CobblemonNetwork.sendToServer(SendOutPokeBallPacket())
-        return true
-    }
-
-    override fun onDownwardSwing(useHand: InteractionHand, handVel: Vec3, player: Player): Boolean {
-        CobblemonNetwork.sendToServer(SendOutPokeBallPacket())
-        return super.onDownwardSwing(useHand, handVel, player)
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/integration/vivecraft/listener/swing/PokeRodSwingListener.kt

@@ -1,31 +0,0 @@
-package com.cobblemon.mod.common.client.integration.vivecraft.listener.swing
-
-import com.cobblemon.mod.common.CobblemonNetwork
-import com.cobblemon.mod.common.api.tags.CobblemonItemTags
-import com.cobblemon.mod.common.net.messages.server.pokerod.CastPokeRodPacket
-import com.cobblemon.mod.common.net.messages.server.pokerod.ReelPokeRodPacket
-import net.minecraft.world.InteractionHand
-import net.minecraft.world.entity.player.Player
-import net.minecraft.world.item.ItemStack
-import net.minecraft.world.phys.Vec3
-
-class PokeRodSwingListener : DirectionalSwingListener() {
-
-    override fun isValidItem(itemStack: ItemStack): Boolean =
-        itemStack.`is`(CobblemonItemTags.POKE_RODS)
-
-    override fun onUpwardSwing(useHand: InteractionHand, player: Player): Boolean {
-        CobblemonNetwork.sendToServer(ReelPokeRodPacket(useHand == InteractionHand.MAIN_HAND))
-        return super.onUpwardSwing(useHand, player)
-    }
-
-    override fun onForwardSwing(useHand: InteractionHand, handVel: Vec3, player: Player): Boolean {
-        CobblemonNetwork.sendToServer(CastPokeRodPacket(useHand == InteractionHand.MAIN_HAND))
-        return super.onForwardSwing(useHand, handVel, player)
-    }
-
-    override fun onDownwardSwing(useHand: InteractionHand, handVel: Vec3, player: Player): Boolean {
-        CobblemonNetwork.sendToServer(CastPokeRodPacket(useHand == InteractionHand.MAIN_HAND))
-        return super.onDownwardSwing(useHand, handVel, player)
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/integration/vivecraft/party/PartyOnArm.kt

@@ -1,188 +0,0 @@
-package com.cobblemon.mod.common.client.integration.vivecraft.party
-
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.client.CobblemonClient
-import com.cobblemon.mod.common.entity.pokeball.EmptyPokeBallEntity
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.platform.events.ClientTickEvent
-import com.cobblemon.mod.common.platform.events.PlatformEvents
-import com.cobblemon.mod.common.platform.events.RenderEvent
-import com.cobblemon.mod.common.pokemon.Pokemon
-import com.mojang.math.Axis
-import net.minecraft.client.Minecraft
-import net.minecraft.client.gui.GuiGraphics
-import net.minecraft.client.player.LocalPlayer
-import net.minecraft.client.renderer.LightTexture
-import net.minecraft.resources.ResourceLocation
-import net.minecraft.world.InteractionHand
-import net.minecraft.world.entity.Entity
-import net.minecraft.world.phys.Vec3
-import org.joml.Vector3f
-import org.vivecraft.api.VRAPI
-import org.vivecraft.api.client.InteractModule
-import org.vivecraft.api.client.VRClientAPI
-import org.vivecraft.api.data.VRBodyPartData
-import java.util.function.Consumer
-
-class PartyOnArm : InteractModule {
-
-    val fakePartyEntities: Array<Entity?> = arrayOfNulls(6)
-    var selectedIndex = -1
-
-    private fun onTick(tickEvent: ClientTickEvent.Post) {
-        val client = tickEvent.client
-        client.player ?: return
-        val playerData = VRClientAPI.instance().postTickWorldPose ?: return
-        val offHandData = playerData.offHand
-
-        // Keep up-to-date fakePartyEntities, which is done so we always have a Pokemon or PokeBall entity available to
-        // render and keep it ticking so we have proper animations.
-        val party = CobblemonClient.storage.party
-
-        // Handle the selected index, placing either a Pokemon or null
-        if (selectedIndex > -1) {
-            val actual = party.get(selectedIndex)
-            if (actual == null) {
-                fakePartyEntities[selectedIndex] = null
-            } else if (fakePartyEntities[selectedIndex] is PokemonEntity) {
-                fakePartyEntities[selectedIndex]!!.tick()
-            } else {
-                fakePartyEntities[selectedIndex] = PokemonEntity(client.level!!, actual)
-            }
-        }
-        // Handle the other indices, placing a pokeball or null
-        for (i in 0..5) {
-            if (i != selectedIndex) {
-                val actual = party.get(i)
-                if (actual == null) {
-                    fakePartyEntities[i] = null
-                } else if (fakePartyEntities[i] !is EmptyPokeBallEntity) {
-                    val pokeBall = EmptyPokeBallEntity(actual.caughtBall, client.level!!)
-                    pokeBall.captureState = EmptyPokeBallEntity.CaptureState.FALL
-                    fakePartyEntities[i] = pokeBall
-                } else {
-                    fakePartyEntities[i]!!.tick()
-                }
-            }
-        }
-
-        // Check primary hand for overlap with any of the Pokemon
-        val centerPos = getCenterPos(offHandData)
-        selectedIndex = -1
-        for (i in 0..5) {
-            if (party.get(i) != null) {
-                val pokemonPos = getPokemonPos(centerPos, playerData.offHand, i)
-                if (playerData.mainHand.pos.distanceToSqr(pokemonPos) < DIST_SELECT_SQR) {
-                    selectedIndex = i
-                    break
-                }
-            }
-        }
-    }
-
-    private fun onRender(renderEvent: RenderEvent) {
-        if (renderEvent.stage != RenderEvent.Stage.AFTER_ENTITIES) return
-        val mc = Minecraft.getInstance()
-        val bufferSource = mc.renderBuffers().bufferSource()
-        val guiGraphics = GuiGraphics(mc, mc.renderBuffers().bufferSource())
-        val cameraPos = renderEvent.camera.getPosition()
-        val poseStack = guiGraphics.pose()
-        val partialTick = renderEvent.tickCounter.getGameTimeDeltaPartialTick(true)
-        val offHandData = VRClientAPI.instance().getWorldRenderPose()?.offHand ?: return
-
-        val centerPos = getCenterPos(offHandData)
-
-
-        for (i in 0..5) {
-            val pokemon = fakePartyEntities[i]
-            if (pokemon != null) {
-                poseStack.pushPose()
-                val pokemonPos = getPokemonPos(centerPos, offHandData, i)
-                val renderPos = Vec3(
-                    -cameraPos.x + pokemonPos.x,
-                    -cameraPos.y + pokemonPos.y,
-                    -cameraPos.z + pokemonPos.z,
-                )
-                poseStack.translate(renderPos.x, renderPos.y, renderPos.z)
-                poseStack.scale(0.05f, 0.05f, 0.05f)
-                poseStack.mulPose(Axis.YN.rotation(offHandData.yaw.toFloat()))
-                poseStack.mulPose(Axis.XN.rotation(offHandData.pitch.toFloat()))
-                poseStack.mulPose(Axis.ZP.rotation(offHandData.roll.toFloat() + Math.PI.toFloat()))
-                mc.entityRenderDispatcher.getRenderer(pokemon).render(pokemon, 0f, partialTick, poseStack, bufferSource,
-                    LightTexture.FULL_BRIGHT)
-                poseStack.popPose()
-            }
-        }
-    }
-
-    private fun getCenterPos(pose: VRBodyPartData): Vec3 {
-        return pose.pos.subtract(pose.dir.scale(0.125))
-    }
-
-    private fun getPokemonPos(centerPos: Vec3, controllerData: VRBodyPartData, index: Int): Vec3 {
-        var pos = centerPos
-        // Move to bottom of hand
-        var downVecF = Vector3f(0f, -0.0625f, 0f)
-        downVecF.rotate(Axis.ZP.rotation(controllerData.roll.toFloat()))
-        downVecF.rotate(Axis.XN.rotation(controllerData.pitch.toFloat()))
-        downVecF.rotate(Axis.YN.rotation(controllerData.yaw.toFloat()))
-        pos = pos.add(Vec3(downVecF.x.toDouble(), downVecF.y.toDouble(), downVecF.z.toDouble()))
-        // Move right or left based on index
-        val rightF = Vector3f(0f, 0f, 1f) // Default forward vector of Minecraft
-        rightF.rotate(Axis.YN.rotation(Math.PI.toFloat() / 2f))
-        rightF.rotate(Axis.ZP.rotation(controllerData.roll.toFloat()))
-        rightF.rotate(Axis.XN.rotation(controllerData.pitch.toFloat()))
-        rightF.rotate(Axis.YN.rotation(controllerData.yaw.toFloat()))
-        val right = Vec3(rightF.x.toDouble(), rightF.y.toDouble(), rightF.z.toDouble())
-        if (index > 2) {
-            pos = pos.add(right.scale(-0.0625))
-        } else {
-            pos = pos.add(right.scale(0.0625))
-        }
-        // Offset by -hand direction if on left, 0 if center, or +hand direction if right
-        return pos.add(controllerData.dir.scale(DIST_BETWEEN_HORIZONTAL * (index % 3 - 1)))
-    }
-
-    override fun getId(): ResourceLocation {
-        return INTERACT_ID
-    }
-
-    override fun isActive(
-        player: LocalPlayer,
-        hand: InteractionHand,
-        handPosition: Vec3
-    ): Boolean {
-        return hand == InteractionHand.MAIN_HAND && selectedIndex > -1
-    }
-
-    override fun onPress(
-        player: LocalPlayer,
-        hand: InteractionHand
-    ): Boolean {
-        // UUID lookup is done at press time since the Pokemon may have switched since initially hovered over, such
-        // as via commands.
-        val uuid = CobblemonClient.storage.party.get(selectedIndex)?.uuid ?: return false
-        CobblemonClient.storage.switchToPokemon(uuid)
-        return true
-    }
-
-    companion object {
-        const val DIST_BETWEEN_HORIZONTAL: Double = 0.125
-        const val DIST_BETWEEN_VERTICAL: Float = 0.05f
-        const val DIST_SELECT_SQR: Double = 0.1 * 0.1
-
-        val INTERACT_ID = ResourceLocation(Cobblemon.MODID, "party_on_arm_interact_module")
-
-        private val INSTANCE = PartyOnArm()
-
-        fun init() {
-            PlatformEvents.RENDER.subscribe(Consumer { renderEvent: RenderEvent? -> INSTANCE.onRender(renderEvent!!) })
-            PlatformEvents.CLIENT_TICK_POST.subscribe(Consumer { tickEvent: ClientTickEvent.Post? ->
-                INSTANCE.onTick(
-                    tickEvent!!
-                )
-            })
-            VRAPI.instance().register(INSTANCE)
-        }
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/integration/vivecraft/proximity/ProximityListener.kt

@@ -1,12 +0,0 @@
-package com.cobblemon.mod.common.client.integration.vivecraft.proximity
-
-import org.vivecraft.api.data.VRBodyPart
-import org.vivecraft.api.data.VRPose
-
-// TODO: Make an PR to Vivecraft that adds this feature directly to Vivecraft
-interface ProximityListener {
-    fun isActive(registration: ProximityRegistration): Boolean = true
-    fun onEnter(bodyA: VRBodyPart, bodyB: VRBodyPart, pose: VRPose)
-    fun onExit(bodyA: VRBodyPart, bodyB: VRBodyPart, pose: VRPose)
-    fun onTick(bodyA: VRBodyPart, bodyB: VRBodyPart, pose: VRPose)
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/integration/vivecraft/proximity/ProximityManager.kt

@@ -1,79 +0,0 @@
-package com.cobblemon.mod.common.client.integration.vivecraft.proximity
-
-import com.cobblemon.mod.common.platform.events.ClientTickEvent
-import com.cobblemon.mod.common.platform.events.PlatformEvents
-import org.vivecraft.api.client.VRClientAPI
-import kotlin.math.acos
-
-// TODO: Make an PR to Vivecraft that adds this feature directly to Vivecraft
-class ProximityManager {
-    private val registrations = mutableListOf<ProximityRegistration>()
-    private val previousInProximity = mutableMapOf<ProximityRegistration, Boolean>()
-    private val api: VRClientAPI = VRClientAPI.instance()
-
-    fun register(registration: ProximityRegistration) {
-        registrations += registration
-        previousInProximity.putIfAbsent(registration, false)
-    }
-
-    fun unregister(registration: ProximityRegistration) {
-        registrations -= registration
-        previousInProximity.remove(registration)
-    }
-
-    fun clear() {
-        registrations.clear()
-        previousInProximity.clear()
-    }
-
-    fun isActive(registration: ProximityRegistration): Boolean {
-        return registration.listener.isActive(registration)
-    }
-
-    fun onTick(tickEvent: ClientTickEvent.Post) {
-        val vrPose = api.getPostTickWorldPose() ?: return
-
-        for (reg in registrations) {
-            if (!isActive(reg)) continue
-            val poseA = vrPose.getBodyPartData(reg.bodyA) ?: continue
-            val poseB = vrPose.getBodyPartData(reg.bodyB) ?: continue
-
-            val distance = poseA.pos.distanceTo(poseB.pos)
-
-            val dot = poseA.dir.dot(poseB.dir).coerceIn(-1.0, 1.0)
-            val angleDeg = Math.toDegrees(acos(dot)).toFloat()
-            val angleOk = angleDeg <= reg.angleThreshold
-
-            val nowInProximity = distance <= reg.distanceThreshold && angleOk
-            val wasInProximity = previousInProximity[reg] ?: false
-
-            if (!wasInProximity && nowInProximity) {
-                reg.listener.onEnter(reg.bodyA, reg.bodyB, vrPose)
-            } else if (wasInProximity && !nowInProximity) {
-                reg.listener.onExit(reg.bodyA, reg.bodyB, vrPose)
-            }
-
-            if (nowInProximity) {
-                reg.listener.onTick(reg.bodyA, reg.bodyB, vrPose)
-            }
-
-            previousInProximity[reg] = nowInProximity
-        }
-    }
-
-    companion object {
-        private val INSTANCE = ProximityManager()
-
-        fun init() {
-            PlatformEvents.CLIENT_TICK_POST.subscribe { tickEvent: ClientTickEvent.Post? ->
-                INSTANCE.onTick(
-                    tickEvent!!
-                )
-            }
-        }
-
-        fun register(registration: ProximityRegistration) = INSTANCE.register(registration)
-        fun unregister(registration: ProximityRegistration) = INSTANCE.unregister(registration)
-        fun clearAll() = INSTANCE.clear()
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/integration/vivecraft/proximity/ProximityRegistration.kt

@@ -1,12 +0,0 @@
-package com.cobblemon.mod.common.client.integration.vivecraft.proximity
-
-import org.vivecraft.api.data.VRBodyPart
-
-// TODO: Make an PR to Vivecraft that adds this feature directly to Vivecraft
-data class ProximityRegistration(
-    val bodyA: VRBodyPart,
-    val bodyB: VRBodyPart,
-    val distanceThreshold: Float,
-    val angleThreshold: Float = 180f,
-    val listener: ProximityListener
-)

common/src/main/kotlin/com/cobblemon/mod/common/client/keybind/keybinds/PartySendBinding.kt

@@ -143,18 +143,18 @@ object PartySendBinding : CobblemonBlockingKeyBinding(
     }
 
     private fun canAttemptDismount(player: LocalPlayer, selectedPartyPokemon: Pokemon?): Boolean {
-        if (player.vehicle !is PokemonEntity) return false
-        val vehicle = player.vehicle as PokemonEntity
-        if (player != vehicle.controllingPassenger) {
-            return true
-        }
+        val vehicle = player.vehicle as? PokemonEntity ?: return false
+
+        if (player != vehicle.controllingPassenger) return true
+
         val isAirRide = vehicle.ridingController?.context?.style == RidingStyle.AIR
         val hasLandRide = vehicle.rideProp.behaviours?.get(RidingStyle.LAND) != null
-        return if (isAirRide && hasLandRide) {
-            false
-        } else {
-            vehicle.pokemon.uuid == selectedPartyPokemon?.uuid
+
+        if (!Cobblemon.config.enableInFlightDismounting && isAirRide && hasLandRide) {
+            return false
         }
+
+        return vehicle.pokemon.uuid == selectedPartyPokemon?.uuid
     }
 
     private fun isRidingPokemon(player: LocalPlayer, ignoreControlling: Boolean = false): Boolean {

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

@@ -0,0 +1,27 @@
+/*
+ * 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.net.data
+
+import com.cobblemon.mod.common.api.interaction.PokemonInteractions
+import com.cobblemon.mod.common.api.net.ClientNetworkPacketHandler
+import com.cobblemon.mod.common.net.messages.client.data.PokemonInteractionsSyncPacket
+import net.minecraft.client.Minecraft
+
+object PokemonInteractionsSyncHandler : ClientNetworkPacketHandler<PokemonInteractionsSyncPacket> {
+
+    override fun handle(
+        packet: PokemonInteractionsSyncPacket,
+        client: Minecraft,
+    ) {
+        PokemonInteractions.speciesInteractions.clear()
+        PokemonInteractions.speciesInteractions.addAll(packet.speciesInteractions)
+        PokemonInteractions.generalInteractions.clear()
+        PokemonInteractions.generalInteractions.addAll(packet.generalInteractions)
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/persisted/ClientPersistedData.kt

@@ -8,6 +8,8 @@
 
 package com.cobblemon.mod.common.client.persisted
 
+import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.Cobblemon.LOGGER
 import com.cobblemon.mod.common.config.CobblemonConfig
 import java.io.BufferedReader
 import java.io.BufferedWriter
@@ -31,7 +33,14 @@ object ClientPersistedData {
     fun readSnapshotsData() : SnapshotAcknowledgementData? {
         if (snapshotsPath.exists()) {
             BufferedReader(InputStreamReader(FileInputStream(snapshotsPath.toFile()))).use { reader ->
-                return gson.fromJson(reader, SnapshotAcknowledgementData::class.java)
+                try {
+                    return gson.fromJson(reader, SnapshotAcknowledgementData::class.java)
+                } catch (exception: Exception) {
+                    LOGGER.error("Failed to load snapshots.json... Resetting File")
+                    val data = SnapshotAcknowledgementData(Cobblemon.VERSION, false)
+                    writeSnapshotsData(data)
+                    return data
+                }
             }
         }
 
@@ -46,16 +55,23 @@ object ClientPersistedData {
     fun readRidingPerspectivesData() : RidingPerspectiveData? {
         if (ridingPerspectivesPath.exists()) {
             BufferedReader(InputStreamReader(FileInputStream(ridingPerspectivesPath.toFile()))).use { reader ->
-                return gson.fromJson(reader, RidingPerspectiveData::class.java)
+                try {
+                    return gson.fromJson(reader, RidingPerspectiveData::class.java)
+                } catch (exception: Exception) {
+                    LOGGER.error("Failed to load riding_perspectives.json... Resetting File")
+                    val data = RidingPerspectiveData()
+                    saveRidingPerspectivesData(data)
+                    return data
+                }
             }
         }
 
         return null
     }
 
-    fun saveRidingPerspectivesData() {
+    fun saveRidingPerspectivesData(data: RidingPerspectiveData) {
         ridingPerspectivesPath.toFile().parentFile.mkdirs()
-        BufferedWriter(FileWriter(ridingPerspectivesPath.toFile())).use { writer -> gson.toJson(ridingPerspectives, writer) }
+        BufferedWriter(FileWriter(ridingPerspectivesPath.toFile())).use { writer -> gson.toJson(data, writer) }
     }
 
     data class SnapshotAcknowledgementData(val version: String, val dontShowAgain: Boolean)
@@ -64,7 +80,7 @@ object ClientPersistedData {
     ) {
         fun updatePerspective(key: ResourceLocation, cameraType: CameraType) {
             perspectives[key] = cameraType
-            saveRidingPerspectivesData()
+            saveRidingPerspectivesData(this)
         }
     }
 }

common/src/main/kotlin/com/cobblemon/mod/common/client/tooltips/SeasoningTooltipHelper.kt

@@ -206,7 +206,7 @@ fun generateAdditionalRideBoostsTooltip(stack: ItemStack): MutableList<Component
     val resultLines = mutableListOf<Component>()
     resultLines.add(rideBoostSeasoningHeader)
 
-    for ((stat, value) in boosts) {
+    for ((stat, value) in boosts.toSortedMap()) {
         val statName = stat.displayName.also { it.style = it.style.withColor(stat.flavour.colour) }
         val valueText = if (value < 0) {
             Component.literal("$value").red()

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

@@ -329,6 +329,9 @@ class CobblemonConfig {
     @CobblemonConfigField(Category.Riding, lang = "remember_riding_camera", CLIENT)
     var rememberRidingCamera = false
 
+    @CobblemonConfigField(Category.Riding, lang = "enable_in_flight_dismounting", CLIENT)
+    var enableInFlightDismounting = false
+
     @CobblemonConfigField(Category.Debug, lang = "enable_debug_keys", CLIENT)
     var enableDebugKeys = false
 

common/src/main/kotlin/com/cobblemon/mod/common/entity/ai/OmniPathNavigation.kt

@@ -269,9 +269,6 @@ class OmniPathNavigation(val world: Level, val entity: Mob) : GroundPathNavigati
             // If we can fly and we're airborne, return the current Y position
             return vec.y
         }
-        if (world.getBlockState(blockPos).block == CobblemonBlocks.SACCHARINE_LEAVES && pather.canPathThroughSaccLeaves()) {
-            return vec.y + 0.5
-        }
         return if ((canFloat()) && blockGetter.getFluidState(blockPos).`is`(FluidTags.WATER)) vec.y + 0.5 else super.getGroundY(vec)
     }
 

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

@@ -1208,14 +1208,13 @@ open class PokemonEntity(
             }
         }
 
-        if (hand == InteractionHand.MAIN_HAND && player is ServerPlayer) {
-            if (player.isShiftKeyDown) {
+        if (hand == InteractionHand.MAIN_HAND) {
+            if (player.isShiftKeyDown && player is ServerPlayer) {
                 showInteractionWheel(player, itemStack)
                 return InteractionResult.sidedSuccess(level().isClientSide)
             }
-            else if (pokemon.getOwnerPlayer() == player) {
-                // TODO #105
-                if (this.attemptItemInteraction(player, player.getItemInHand(hand))) return InteractionResult.SUCCESS
+            else if (this.ownerUUID == player.uuid && this.attemptItemInteraction(player, player.getItemInHand(hand))) {
+                return InteractionResult.sidedSuccess(level().isClientSide)
             }
         }
 
@@ -1391,18 +1390,24 @@ open class PokemonEntity(
             return bagItemLike.handleInteraction(player, battlePokemon, stack)
         }
 
-        if (player !is ServerPlayer || this.isBusy) {
+        if (this.isBusy) {
             return false
         }
 
         val interaction = PokemonInteractions.findInteraction(this)
-
         if (interaction != null && !pokemon.isOnInteractionCooldown(interaction.grouping)) {
-            interaction.effects.forEach { it.applyEffect(this, player) }
-            pokemon.interactionCooldowns.put(interaction.grouping, runtime.resolveInt(interaction.cooldown))
+            if (player is ServerPlayer) {
+                interaction.effects.forEach { it.applyEffect(this, player) }
+                pokemon.interactionCooldowns.put(interaction.grouping, runtime.resolveInt(interaction.cooldown))
+            }
+
             return true
         }
 
+        if (player !is ServerPlayer) {
+            return false
+        }
+
         // Evolution item logic
         if (pokemon.getOwnerPlayer() == player) {
             val context = ItemInteractionEvolution.ItemInteractionContext(stack, player.level())

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

@@ -30,21 +30,13 @@ import com.cobblemon.mod.common.api.events.battles.BattleStartedEvent
 import com.cobblemon.mod.common.api.events.battles.BattleVictoryEvent
 import com.cobblemon.mod.common.api.events.fishing.PokerodCastEvent
 import com.cobblemon.mod.common.api.events.fishing.PokerodReelEvent
-import com.cobblemon.mod.common.api.events.pokemon.CollectEggEvent
-import com.cobblemon.mod.common.api.events.pokemon.FossilRevivedEvent
-import com.cobblemon.mod.common.api.events.pokemon.HatchEggEvent
-import com.cobblemon.mod.common.api.events.pokemon.LevelUpEvent
-import com.cobblemon.mod.common.api.events.pokemon.PokemonCapturedEvent
-import com.cobblemon.mod.common.api.events.pokemon.PokemonGainedEvent
-import com.cobblemon.mod.common.api.events.pokemon.RidePokemonEvent
-import com.cobblemon.mod.common.api.events.pokemon.TradeEvent
+import com.cobblemon.mod.common.api.events.pokemon.*
 import com.cobblemon.mod.common.api.events.pokemon.evolution.EvolutionCompleteEvent
 import com.cobblemon.mod.common.api.events.storage.ReleasePokemonEvent
+import com.cobblemon.mod.common.api.stats.CobblemonStats.getStat
 import com.cobblemon.mod.common.util.getPlayer
-import net.minecraft.core.registries.BuiltInRegistries
-import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerPlayer
-import java.util.UUID
+import java.util.*
 
 object StatHandler : EventHandler {
     override fun registerListeners() {
@@ -100,13 +92,13 @@ object StatHandler : EventHandler {
 
     fun onBattleStart(event : BattleStartedEvent) {
         event.battle.players.forEach { player ->
-            player.awardStat(this.getStat(getStat(Cobblemon.statistics.BATTLES_TOTAL)))
+            player.awardStat(getStat(Cobblemon.statistics.BATTLES_TOTAL))
         }
     }
 
     fun onDexEntryGain(event : PokemonGainedEvent) {
         val player = event.pokemon.getOwnerPlayer()
-        player?.awardStat(getStat(getStat(Cobblemon.statistics.DEX_ENTRIES)))
+        player?.awardStat(getStat(Cobblemon.statistics.DEX_ENTRIES))
     }
 
     fun onCollectEgg(event : CollectEggEvent) {
@@ -139,12 +131,4 @@ object StatHandler : EventHandler {
     fun onReelIn(event : PokerodReelEvent) {
         event.player.awardStat(getStat(Cobblemon.statistics.REEL_INS))
     }
-
-    fun getStat(resourceLocation: ResourceLocation) : ResourceLocation {
-        val stat = BuiltInRegistries.CUSTOM_STAT.get(resourceLocation)
-        if (stat == null) {
-            Cobblemon.LOGGER.error("Could not find stat with id {}", resourceLocation)
-        }
-        return stat ?: throw NullPointerException("Could not find stat with id $resourceLocation")
-    }
 }

common/src/main/kotlin/com/cobblemon/mod/common/integration/AdornCompatibility.kt

@@ -14,7 +14,7 @@ import juuxel.adorn.block.variant.CompatBlockVariantSet
 
 class AdornCompatibility : CompatBlockVariantSet() {
     override fun getWoodVariants(): List<BlockVariant?>? {
-        return this.createVariants({ BlockVariant.Wood(it) }, "apricorn")
+        return this.createVariants({ BlockVariant.Wood(it) }, "apricorn", "saccharine")
     }
 
     override fun getModId(): String? {

common/src/main/kotlin/com/cobblemon/mod/common/integration/vivecraft/CobblemonVR.kt

@@ -1,16 +0,0 @@
-package com.cobblemon.mod.common.integration.vivecraft
-
-import com.cobblemon.mod.common.client.integration.vivecraft.listener.swing.PokeBallSwingListener
-import com.cobblemon.mod.common.client.integration.vivecraft.listener.swing.PokeRodSwingListener
-import org.vivecraft.api.VRAPI
-
-class CobblemonVR {
-
-    fun init() {
-        VRAPI.instance()
-            .register(PokeBallSwingListener())
-
-        VRAPI.instance()
-            .register(PokeRodSwingListener())
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/item/PokeBallItem.kt

@@ -23,7 +23,7 @@ import net.minecraft.world.level.Level
 import kotlin.math.cos
 
 class PokeBallItem(
-    val pokeBall: PokeBall
+        val pokeBall: PokeBall
 ) : CobblemonItem(Properties().apply {
     when (pokeBall.name) {
         // Master balls are a netherite product and should be fire immune
@@ -43,7 +43,7 @@ class PokeBallItem(
         return InteractionResultHolder.sidedSuccess(itemStack, world.isClientSide)
     }
 
-    fun throwPokeBall(world: Level, player: ServerPlayer) {
+    private fun throwPokeBall(world: Level, player: ServerPlayer) {
         val pokeBallEntity = EmptyPokeBallEntity(pokeBall, player.level(), player).apply {
             val overhandFactor: Float = if (player.xRot < 0) {
                 5f * cos(player.xRot.toRadians())
@@ -57,5 +57,4 @@ class PokeBallItem(
         }
         world.addFreshEntity(pokeBallEntity)
     }
-
 }

common/src/main/kotlin/com/cobblemon/mod/common/item/battle/BagItemConvertible.kt

@@ -13,6 +13,7 @@ import com.cobblemon.mod.common.advancement.criterion.PokemonInteractContext
 import com.cobblemon.mod.common.api.text.red
 import com.cobblemon.mod.common.battles.BagItemActionResponse
 import com.cobblemon.mod.common.battles.BagItems
+import com.cobblemon.mod.common.battles.BattleRules
 import com.cobblemon.mod.common.battles.pokemon.BattlePokemon
 import com.cobblemon.mod.common.util.battleLang
 import net.minecraft.core.registries.BuiltInRegistries
@@ -41,7 +42,7 @@ interface BagItemLike {
     fun handleInteraction(player: ServerPlayer, battlePokemon: BattlePokemon, stack: ItemStack): Boolean {
         val battle = battlePokemon.actor.battle
         val bagItem = getBagItem(stack) ?: return false
-        if (!battlePokemon.actor.canFitForcedAction()) {
+        if (!battlePokemon.actor.canFitForcedAction() || battle.format.ruleSet.contains(BattleRules.BAG_CLAUSE)) {
             player.sendSystemMessage(battleLang("bagitem.cannot").red())
             return false
         }

common/src/main/kotlin/com/cobblemon/mod/common/item/interactive/MochiItem.kt

@@ -25,9 +25,7 @@ class MochiItem(stat: Stats): EVIncreaseItem(stat, 4) {
         }
 
         pokemon.feedPokemon(1)
-
-        stack.consume(1, player)
-
+        
         return super.applyToPokemon(player, stack, pokemon)
     }
 }

common/src/main/kotlin/com/cobblemon/mod/common/item/interactive/PokerodItem.kt

@@ -75,8 +75,7 @@ class PokerodItem(val pokeRodId: ResourceLocation, settings: Properties) : Fishi
 
                 if (baitCount > 1) {
                     baitStack.count = baitCount - 1
-                    stack.set(
-                        CobblemonItemComponents.BAIT, RodBaitComponent(baitStack)
+                    stack.set(CobblemonItemComponents.BAIT, RodBaitComponent(baitStack)
                     )
                 }
             }
@@ -150,163 +149,90 @@ class PokerodItem(val pokeRodId: ResourceLocation, settings: Properties) : Fishi
     }
 
     override fun use(world: Level, user: Player, hand: InteractionHand): InteractionResultHolder<ItemStack> {
+
         val itemStack = user.getItemInHand(hand)
         val offHandItem = user.getItemInHand(InteractionHand.OFF_HAND)
 
-        attemptApplyOffhandBait(world, user, itemStack, offHandItem)?.let { return it }
+        // Check if offhand item is valid bait and the rod is not in use, if so then apply bait from offhand
+        if (!world.isClientSide && user.fishing == null && SpawnBaitEffects.isFishingBait(offHandItem)) {
+            CobblemonEvents.BAIT_SET_PRE.postThen(BaitSetEvent(itemStack, offHandItem), { event ->
+                return InteractionResultHolder.fail(itemStack)
+            }, {
+                playAttachSound(user)
 
-        if (user.fishing != null) {
-            attemptReel(world, user, hand, itemStack)?.let { return it }
-        } else {
-            attemptCast(world, user, hand, itemStack)?.let { return it }
+                // if there is bait on the rod already then drop it on the ground before applying offhand bait
+                val baitStack = getBaitStackOnRod(itemStack)
+
+                if (baitStack != ItemStack.EMPTY && offHandItem.item != baitStack.item) {
+                    user.drop(baitStack, true) // Drop the full stack
+
+                    // apply single bait item from offhand
+                    val singleBait = offHandItem.copy()
+                    singleBait.count = 1
+                    setBait(itemStack, singleBait)
+                    offHandItem.shrink(1)
+                }
+            })
         }
 
-        return InteractionResultHolder.sidedSuccess(itemStack, world.isClientSide)
-    }
-
-    fun applyBait(
-        rodStack: ItemStack,
-        baitSource: ItemStack,
-        player: Player?
-    ): Boolean {
-        if (baitSource.isEmpty || !SpawnBaitEffects.isFishingBait(baitSource)) return false
-
-        val existingBait = getBaitStackOnRod(rodStack)
-        if (!existingBait.isEmpty && existingBait.item == baitSource.item) return false
-
-        var applied = false
-
-        CobblemonEvents.BAIT_SET_PRE.postThen(
-            BaitSetEvent(rodStack, baitSource),
-            { return false },
-            {
-                if (!existingBait.isEmpty && player != null) {
-                    player.drop(existingBait, true)
-                }
-
-                val singleBait = baitSource.copy()
-                singleBait.count = 1
-                setBait(rodStack, singleBait)
-
-                baitSource.shrink(1)
-                applied = true
+        var i: Int
+        if (user.fishing != null) { // if the bobber is out yet
+            if (!world.isClientSide) {
+                CobblemonEvents.POKEROD_REEL.postThen(
+                    PokerodReelEvent(user, itemStack),
+                    { event -> return InteractionResultHolder.fail(itemStack) },
+                    { event ->
+                        i = user.fishing!!.retrieve(itemStack)
+                        itemStack.hurtAndBreak(i, user, hand.toEquipmentSlot())
+                        world.playSoundServer(
+                            Vec3(user.x,
+                                user.y,
+                                user.z),
+                            CobblemonSounds.FISHING_ROD_REEL_IN,
+                            SoundSource.PLAYERS,
+                            1.0f,
+                            1.0f / (world.getRandom().nextFloat() * 0.4f + 0.8f)
+                        )
+                    }
+                )
             }
-        )
 
-        return applied
-    }
 
-    fun attemptApplyOffhandBait(
-        world: Level,
-        user: Player,
-        rodStack: ItemStack,
-        offHandItem: ItemStack
-    ): InteractionResultHolder<ItemStack>? {
-        if (world.isClientSide) return null
-        if (user.fishing != null) return null
+            world.playSound(null as Player?, user.x, user.y, user.z, CobblemonSounds.FISHING_ROD_REEL_IN, SoundSource.PLAYERS, 1.0f, 1.0f)
+            user.gameEvent(GameEvent.ITEM_INTERACT_FINISH)
+        } else { // if the bobber is not out yet
 
-        val applied = applyBait(
-            rodStack = rodStack,
-            baitSource = offHandItem,
-            player = user
-        )
+            if (!world.isClientSide) {
+                val lureLevel = world.enchantmentRegistry.getHolder(Enchantments.LURE).map { EnchantmentHelper.getItemEnchantmentLevel(it, itemStack) }.orElse(0)
+                val luckLevel = world.enchantmentRegistry.getHolder(Enchantments.LUCK_OF_THE_SEA).map { EnchantmentHelper.getItemEnchantmentLevel(it, itemStack) }.orElse(0)
 
-        if (applied) {
-            playAttachSound(user)
-            return InteractionResultHolder.sidedSuccess(rodStack, false)
+                val bobberEntity = PokeRodFishingBobberEntity(
+                    user,
+                    pokeRodId,
+                    getBaitStackOnRod(itemStack),
+                    world,
+                    luckLevel,
+                    lureLevel,
+                    itemStack
+                )
+                CobblemonEvents.POKEROD_CAST_PRE.postThen(
+                    PokerodCastEvent.Pre(itemStack, bobberEntity, getBaitStackOnRod(itemStack)),
+                    { event -> return InteractionResultHolder.fail(itemStack) },
+                    { event ->
+                        world.addFreshEntity(bobberEntity)
+                        var baitId = getBaitStackOnRod(itemStack).takeUnless { it.isEmpty }?.itemHolder?.unwrapKey()?.orElse(null)?.location() ?: cobblemonResource("empty_bait")
+                        CobblemonCriteria.CAST_POKE_ROD.trigger(user as ServerPlayer, CastPokeRodContext(baitId))
+
+                        CobblemonEvents.POKEROD_CAST_POST.post(
+                            PokerodCastEvent.Post(itemStack, bobberEntity, getBaitStackOnRod(itemStack))
+                        )
+                    }
+                )
+            }
+
+            user.awardStat(Stats.ITEM_USED.get(this))
+            user.gameEvent(GameEvent.ITEM_INTERACT_START)
         }
-
-        return null
-    }
-
-
-    fun attemptReel(
-        world: Level,
-        user: Player,
-        hand: InteractionHand,
-        itemStack: ItemStack
-    ): InteractionResultHolder<ItemStack>? {
-        if (user.fishing == null) return null
-
-        if (!world.isClientSide) {
-            CobblemonEvents.POKEROD_REEL.postThen(
-                PokerodReelEvent(user, itemStack),
-                { event -> return InteractionResultHolder.fail(itemStack) },
-                { event ->
-                    val i = user.fishing!!.retrieve(itemStack)
-                    itemStack.hurtAndBreak(i, user, hand.toEquipmentSlot())
-                    world.playSoundServer(
-                        Vec3(user.x, user.y, user.z),
-                        CobblemonSounds.FISHING_ROD_REEL_IN,
-                        SoundSource.PLAYERS,
-                        1.0f,
-                        1.0f / (world.getRandom().nextFloat() * 0.4f + 0.8f)
-                    )
-                }
-            )
-        }
-
-        world.playSound(
-            null as Player?,
-            user.x,
-            user.y,
-            user.z,
-            CobblemonSounds.FISHING_ROD_REEL_IN,
-            SoundSource.PLAYERS,
-            1.0f,
-            1.0f
-        )
-        user.gameEvent(GameEvent.ITEM_INTERACT_FINISH)
-
-        return InteractionResultHolder.sidedSuccess(itemStack, world.isClientSide)
-    }
-
-    fun attemptCast(
-        world: Level,
-        user: Player,
-        hand: InteractionHand,
-        itemStack: ItemStack
-    ): InteractionResultHolder<ItemStack>? {
-        if (user.fishing != null) return null
-
-        if (!world.isClientSide) {
-            val lureLevel = world.enchantmentRegistry.getHolder(Enchantments.LURE)
-                .map { EnchantmentHelper.getItemEnchantmentLevel(it, itemStack) }
-                .orElse(0)
-            val luckLevel = world.enchantmentRegistry.getHolder(Enchantments.LUCK_OF_THE_SEA)
-                .map { EnchantmentHelper.getItemEnchantmentLevel(it, itemStack) }
-                .orElse(0)
-
-            val bobberEntity = PokeRodFishingBobberEntity(
-                user,
-                pokeRodId,
-                getBaitStackOnRod(itemStack),
-                world,
-                luckLevel,
-                lureLevel,
-                itemStack
-            )
-
-            CobblemonEvents.POKEROD_CAST_PRE.postThen(
-                PokerodCastEvent.Pre(itemStack, bobberEntity, getBaitStackOnRod(itemStack)),
-                { event -> return InteractionResultHolder.fail(itemStack) },
-                { event ->
-                    world.addFreshEntity(bobberEntity)
-                    val baitId = getBaitStackOnRod(itemStack).takeUnless { it.isEmpty }
-                        ?.itemHolder?.unwrapKey()?.orElse(null)?.location()
-                        ?: cobblemonResource("empty_bait")
-                    CobblemonCriteria.CAST_POKE_ROD.trigger(user as ServerPlayer, CastPokeRodContext(baitId))
-
-                    CobblemonEvents.POKEROD_CAST_POST.post(
-                        PokerodCastEvent.Post(itemStack, bobberEntity, getBaitStackOnRod(itemStack))
-                    )
-                }
-            )
-        }
-
-        user.awardStat(Stats.ITEM_USED.get(this))
-        user.gameEvent(GameEvent.ITEM_INTERACT_START)
-
         return InteractionResultHolder.sidedSuccess(itemStack, world.isClientSide)
     }
 

common/src/main/kotlin/com/cobblemon/mod/common/item/interactive/SinisterTeaItem.kt

@@ -35,9 +35,16 @@ class SinisterTeaItem : Item(
             val effectsComponent = stack.get(CobblemonItemComponents.MOB_EFFECTS)
 
             if (effectsComponent != null) {
-                for (effect in effectsComponent.mobEffects) {
-                    val effectCopy = MobEffectInstance(effect)
-                    user.addEffect(effectCopy)
+                for (raw in effectsComponent.mobEffects) {
+                    val inst = MobEffectInstance(raw)
+                    val holder = inst.effect
+                    val effect = holder.value()
+
+                    if (effect.isInstantenous) {
+                        effect.applyInstantenousEffect(user as? Player, null, user, inst.amplifier, 1.0)
+                    } else {
+                        user.addEffect(inst)
+                    }
                 }
             }
         }

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

@@ -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.net.messages.client.data
+
+import com.cobblemon.mod.common.api.interaction.PokemonInteractionSet
+import com.cobblemon.mod.common.api.net.NetworkPacket
+import com.cobblemon.mod.common.util.cobblemonResource
+import net.minecraft.network.RegistryFriendlyByteBuf
+
+class PokemonInteractionsSyncPacket(
+    val speciesInteractions: List<PokemonInteractionSet>,
+    val generalInteractions: List<PokemonInteractionSet>,
+) : NetworkPacket<PokemonInteractionsSyncPacket> {
+    override val id = ID
+
+    override fun encode(buffer: RegistryFriendlyByteBuf) {
+        buffer.writeCollection(speciesInteractions) { it, speciesInteraction ->
+            speciesInteraction.encode(it)
+        }
+        buffer.writeCollection(generalInteractions) { it, generalInteraction ->
+            generalInteraction.encode(it)
+        }
+    }
+
+    companion object {
+        val ID = cobblemonResource("pokemon_interactions_sync")
+
+        fun decode(buffer: RegistryFriendlyByteBuf): PokemonInteractionsSyncPacket {
+            val speciesInteractions = buffer.readList { it ->
+                PokemonInteractionSet.decode(it)
+            }
+            val generalInteractions = buffer.readList { it ->
+                PokemonInteractionSet.decode(it)
+            }
+
+            return PokemonInteractionsSyncPacket(
+                speciesInteractions,
+                generalInteractions,
+            )
+        }
+    }
+}

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

@@ -21,7 +21,9 @@ class PokemonStateUpdatePacket(pokemon: () -> Pokemon?, value: PokemonState): Si
         value.writeToBuffer(buffer)
     }
 
-    override fun set(pokemon: Pokemon, value: PokemonState) { pokemon.state = value }
+    override fun set(pokemon: Pokemon, value: PokemonState) {
+        pokemon.state = value
+    }
 
     companion object {
         val ID = cobblemonResource("state_update")

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

@@ -13,30 +13,24 @@ import com.cobblemon.mod.common.api.mark.Marks
 import com.cobblemon.mod.common.api.pokeball.PokeBalls
 import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
 import com.cobblemon.mod.common.api.riding.stats.RidingStat
+import com.cobblemon.mod.common.client.CobblemonClient
 import com.cobblemon.mod.common.entity.PlatformType
 import com.cobblemon.mod.common.entity.PoseType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.pokemon.Gender
-import com.cobblemon.mod.common.util.cobblemonResource
-import com.cobblemon.mod.common.util.readEnumConstant
-import com.cobblemon.mod.common.util.readIdentifier
-import com.cobblemon.mod.common.util.readString
-import com.cobblemon.mod.common.util.readText
-import com.cobblemon.mod.common.util.writeEnumConstant
-import com.cobblemon.mod.common.util.writeIdentifier
-import com.cobblemon.mod.common.util.writeString
-import com.cobblemon.mod.common.util.writeText
-import java.util.UUID
+import com.cobblemon.mod.common.util.*
 import net.minecraft.client.multiplayer.ClientLevel
 import net.minecraft.network.RegistryFriendlyByteBuf
 import net.minecraft.network.chat.MutableComponent
 import net.minecraft.network.protocol.game.ClientboundAddEntityPacket
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.world.entity.Entity
+import java.util.*
 
 class SpawnPokemonPacket(
     var ownerId: UUID?,
     var pokemonUUID: UUID,
+    var storageUUID: UUID?,
     var scaleModifier: Float,
     var speciesId: ResourceLocation,
     var gender: Gender,
@@ -61,6 +55,7 @@ class SpawnPokemonPacket(
     var tickSpawned: Int,
     var rideBoosts: Map<RidingStat, Float>,
     var rideStamina: Float,
+    var silent: Boolean,
     vanillaSpawnPacket: ClientboundAddEntityPacket,
 ) : SpawnExtraDataEntityPacket<SpawnPokemonPacket, PokemonEntity>(vanillaSpawnPacket) {
 
@@ -69,6 +64,7 @@ class SpawnPokemonPacket(
     constructor(entity: PokemonEntity, vanillaSpawnPacket: ClientboundAddEntityPacket) : this(
         entity.ownerUUID,
         entity.pokemon.uuid,
+        entity.pokemon.storeCoordinates.get()?.store?.uuid,
         entity.pokemon.scaleModifier,
         entity.exposedSpecies.resourceIdentifier,
         entity.pokemon.gender,
@@ -93,12 +89,14 @@ class SpawnPokemonPacket(
         entity.tickCount,
         entity.entityData.get(PokemonEntity.RIDE_BOOSTS),
         entity.entityData.get(PokemonEntity.RIDE_STAMINA),
+        entity.isSilent,
         vanillaSpawnPacket
     )
 
     override fun encodeEntityData(buffer: RegistryFriendlyByteBuf) {
         buffer.writeNullable(ownerId) { _, v -> buffer.writeUUID(v) }
         buffer.writeUUID(this.pokemonUUID)
+        buffer.writeNullable(this.storageUUID) { pb, value -> pb.writeUUID(value) }
         buffer.writeFloat(this.scaleModifier)
         buffer.writeIdentifier(this.speciesId)
         buffer.writeEnumConstant(this.gender)
@@ -127,10 +125,21 @@ class SpawnPokemonPacket(
             { _, value -> buffer.writeFloat(value) }
         )
         buffer.writeFloat(rideStamina)
+        buffer.writeBoolean(silent)
     }
 
     override fun applyData(entity: PokemonEntity, level: ClientLevel) {
         entity.ownerUUID = ownerId
+
+        // Reuse the stored Pokémon instance to avoid creating a duplicate,
+        // preventing client/entity desync issues.
+        this@SpawnPokemonPacket.storageUUID?.let {
+            val storedPokemon = CobblemonClient.storage.locatePokemon(it, this@SpawnPokemonPacket.pokemonUUID)
+            if (storedPokemon != null) {
+                entity.pokemon = storedPokemon
+            }
+        }
+
         entity.pokemon.apply {
             uuid = this@SpawnPokemonPacket.pokemonUUID
             scaleModifier = this@SpawnPokemonPacket.scaleModifier
@@ -162,6 +171,7 @@ class SpawnPokemonPacket(
         entity.entityData.set(PokemonEntity.RIDE_BOOSTS, rideBoosts)
         entity.entityData.set(PokemonEntity.RIDE_STAMINA, rideStamina)
         entity.entityData.set(PokemonEntity.SCALE_MODIFIER, scaleModifier)
+        entity.isSilent = silent
 
         entity.ejectPassengers()
         passengers.forEach {
@@ -179,6 +189,7 @@ class SpawnPokemonPacket(
         fun decode(buffer: RegistryFriendlyByteBuf): SpawnPokemonPacket {
             val ownerId = buffer.readNullable { buffer.readUUID() }
             val pokemonUUID = buffer.readUUID()
+            val storageUUID = buffer.readNullable { buffer.readUUID() }
             val scaleModifier = buffer.readFloat()
             val speciesId = buffer.readIdentifier()
             val gender = buffer.readEnumConstant(Gender::class.java)
@@ -206,11 +217,13 @@ class SpawnPokemonPacket(
                 { buffer.readFloat() }
             )
             val rideStamina = buffer.readFloat()
+            val silent = buffer.readBoolean()
             val vanillaPacket = decodeVanillaPacket(buffer)
 
             return SpawnPokemonPacket(
                 ownerId,
                 pokemonUUID,
+                storageUUID,
                 scaleModifier,
                 speciesId,
                 gender,
@@ -235,6 +248,7 @@ class SpawnPokemonPacket(
                 tickSpawned,
                 rideBoosts,
                 rideStamina,
+                silent,
                 vanillaPacket
             )
         }

common/src/main/kotlin/com/cobblemon/mod/common/net/messages/server/pokeball/SendOutPokeBallPacket.kt

@@ -1,16 +0,0 @@
-package com.cobblemon.mod.common.net.messages.server.pokeball
-
-import com.cobblemon.mod.common.api.net.NetworkPacket
-import com.cobblemon.mod.common.util.cobblemonResource
-import net.minecraft.network.RegistryFriendlyByteBuf
-
-class SendOutPokeBallPacket() : NetworkPacket<SendOutPokeBallPacket> {
-    override val id = ID
-    override fun encode(buffer: RegistryFriendlyByteBuf) {
-    }
-
-    companion object {
-        val ID = cobblemonResource("send_out_pokeball")
-        fun decode(buffer: RegistryFriendlyByteBuf) = SendOutPokeBallPacket()
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/net/messages/server/pokerod/ApplyBaitPacket.kt

@@ -1,16 +0,0 @@
-package com.cobblemon.mod.common.net.messages.server.pokerod
-
-import com.cobblemon.mod.common.api.net.NetworkPacket
-import com.cobblemon.mod.common.util.cobblemonResource
-import net.minecraft.network.RegistryFriendlyByteBuf
-
-class ApplyBaitPacket() : NetworkPacket<ApplyBaitPacket> {
-    override val id = ID
-    override fun encode(buffer: RegistryFriendlyByteBuf) {
-    }
-
-    companion object {
-        val ID = cobblemonResource("apply_bait")
-        fun decode(buffer: RegistryFriendlyByteBuf) = ApplyBaitPacket()
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/net/messages/server/pokerod/CastPokeRodPacket.kt

@@ -1,17 +0,0 @@
-package com.cobblemon.mod.common.net.messages.server.pokerod
-
-import com.cobblemon.mod.common.api.net.NetworkPacket
-import com.cobblemon.mod.common.util.cobblemonResource
-import net.minecraft.network.RegistryFriendlyByteBuf
-
-class CastPokeRodPacket(val mainHand: Boolean) : NetworkPacket<CastPokeRodPacket> {
-    override val id = ID
-    override fun encode(buffer: RegistryFriendlyByteBuf) {
-        buffer.writeBoolean(mainHand)
-    }
-
-    companion object {
-        val ID = cobblemonResource("cast_pokerod")
-        fun decode(buffer: RegistryFriendlyByteBuf) = CastPokeRodPacket(buffer.readBoolean())
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/net/messages/server/pokerod/ReelPokeRodPacket.kt

@@ -1,17 +0,0 @@
-package com.cobblemon.mod.common.net.messages.server.pokerod
-
-import com.cobblemon.mod.common.api.net.NetworkPacket
-import com.cobblemon.mod.common.util.cobblemonResource
-import net.minecraft.network.RegistryFriendlyByteBuf
-
-class ReelPokeRodPacket(val mainHand: Boolean) : NetworkPacket<ReelPokeRodPacket> {
-    override val id = ID
-    override fun encode(buffer: RegistryFriendlyByteBuf) {
-        buffer.writeBoolean(mainHand)
-    }
-
-    companion object {
-        val ID = cobblemonResource("reel_pokerod")
-        fun decode(buffer: RegistryFriendlyByteBuf) = ReelPokeRodPacket(buffer.readBoolean())
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/net/serverhandling/pokeball/SendOutPokeBallHandler.kt

@@ -1,29 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.net.serverhandling.pokeball
-
-import com.cobblemon.mod.common.api.net.ServerNetworkPacketHandler
-import com.cobblemon.mod.common.item.PokeBallItem
-import com.cobblemon.mod.common.net.messages.server.pokeball.SendOutPokeBallPacket
-import com.cobblemon.mod.common.util.isServerSide
-import net.minecraft.server.MinecraftServer
-import net.minecraft.server.level.ServerPlayer
-
-object SendOutPokeBallHandler : ServerNetworkPacketHandler<SendOutPokeBallPacket> {
-
-    override fun handle(packet: SendOutPokeBallPacket, server: MinecraftServer, player: ServerPlayer) {
-        (player.mainHandItem.item as? PokeBallItem)?.let { pokeball ->
-            if (player.level().isServerSide()) {
-                pokeball.throwPokeBall(player.level(), player)
-            }
-            // TODO: player.mainHandItem.consume(1, player)
-        }
-
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/net/serverhandling/pokerod/ApplyBaitHandler.kt

@@ -1,41 +0,0 @@
-package com.cobblemon.mod.common.net.serverhandling.pokerod
-
-import com.cobblemon.mod.common.api.net.ServerNetworkPacketHandler
-import com.cobblemon.mod.common.item.interactive.PokerodItem
-import com.cobblemon.mod.common.net.messages.server.pokerod.ApplyBaitPacket
-import com.cobblemon.mod.common.util.isServerSide
-import net.minecraft.server.MinecraftServer
-import net.minecraft.server.level.ServerPlayer
-import net.minecraft.world.InteractionHand
-
-object ApplyBaitHandler : ServerNetworkPacketHandler<ApplyBaitPacket> {
-
-    override fun handle(packet: ApplyBaitPacket, server: MinecraftServer, player: ServerPlayer) {
-
-        val mainHandItem = player.getItemInHand(InteractionHand.MAIN_HAND)
-        val offHandItem = player.getItemInHand(InteractionHand.OFF_HAND)
-
-        println("[ApplyBaitHandler] Main hand: ${mainHandItem.item}")
-        println("[ApplyBaitHandler] Off hand:  ${offHandItem.item}")
-
-        (mainHandItem.item as? PokerodItem)?.let { pokerod ->
-            if (player.level().isServerSide()) {
-                pokerod.applyBait(
-                    mainHandItem,
-                    offHandItem,
-                    player
-                )
-            }
-        }
-
-        (offHandItem.item as? PokerodItem)?.let { pokerod ->
-            if (player.level().isServerSide()) {
-                pokerod.applyBait(
-                    offHandItem,
-                    mainHandItem,
-                    player
-                )
-            }
-        }
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/net/serverhandling/pokerod/CastPokeRodHandler.kt

@@ -1,35 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.net.serverhandling.pokerod
-
-import com.cobblemon.mod.common.api.net.ServerNetworkPacketHandler
-import com.cobblemon.mod.common.item.PokeBallItem
-import com.cobblemon.mod.common.item.interactive.PokerodItem
-import com.cobblemon.mod.common.net.messages.server.pokeball.SendOutPokeBallPacket
-import com.cobblemon.mod.common.net.messages.server.pokerod.CastPokeRodPacket
-import com.cobblemon.mod.common.util.isServerSide
-import net.minecraft.server.MinecraftServer
-import net.minecraft.server.level.ServerPlayer
-import net.minecraft.world.InteractionHand
-
-object CastPokeRodHandler : ServerNetworkPacketHandler<CastPokeRodPacket> {
-
-    override fun handle(packet: CastPokeRodPacket, server: MinecraftServer, player: ServerPlayer) {
-        val hand = if (packet.mainHand) InteractionHand.MAIN_HAND else InteractionHand.OFF_HAND
-        (player.getItemInHand(hand).item as? PokerodItem)?.let { pokerod ->
-            if (player.level().isServerSide()) pokerod.attemptCast(
-                player.level(),
-                player,
-                hand,
-                player.getItemInHand(hand)
-            )
-        }
-
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/net/serverhandling/pokerod/ReelPokeRodHandler.kt

@@ -1,36 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.net.serverhandling.pokerod
-
-import com.cobblemon.mod.common.api.net.ServerNetworkPacketHandler
-import com.cobblemon.mod.common.item.PokeBallItem
-import com.cobblemon.mod.common.item.interactive.PokerodItem
-import com.cobblemon.mod.common.net.messages.server.pokeball.SendOutPokeBallPacket
-import com.cobblemon.mod.common.net.messages.server.pokerod.CastPokeRodPacket
-import com.cobblemon.mod.common.net.messages.server.pokerod.ReelPokeRodPacket
-import com.cobblemon.mod.common.util.isServerSide
-import net.minecraft.server.MinecraftServer
-import net.minecraft.server.level.ServerPlayer
-import net.minecraft.world.InteractionHand
-
-object ReelPokeRodHandler : ServerNetworkPacketHandler<ReelPokeRodPacket> {
-
-    override fun handle(packet: ReelPokeRodPacket, server: MinecraftServer, player: ServerPlayer) {
-        val hand = if (packet.mainHand) InteractionHand.MAIN_HAND else InteractionHand.OFF_HAND
-        (player.getItemInHand(hand).item as? PokerodItem)?.let { pokerod ->
-            if (player.level().isServerSide()) pokerod.attemptReel(
-                player.level(),
-                player,
-                hand,
-                player.getItemInHand(hand)
-            )
-        }
-
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/net/serverhandling/riding/DismountPokemonPacketHandler.kt

@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.net.serverhandling.riding
 
 import com.cobblemon.mod.common.api.net.ServerNetworkPacketHandler
+import com.cobblemon.mod.common.api.riding.RidingStyle
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.net.messages.server.riding.DismountPokemonPacket
 import net.minecraft.server.MinecraftServer
@@ -25,12 +26,16 @@ object DismountPokemonPacketHandler : ServerNetworkPacketHandler<DismountPokemon
 
         val pokemon = player.vehicle as PokemonEntity
         if (!canPlayerStopRidingPokemon(pokemon, player)) return
+
+        val isRidingInAir = pokemon.ridingController?.context?.style == RidingStyle.AIR
+
         if (pokemon.controllingPassenger == player) {
             pokemon.passengers.forEach { it.stopRiding() }
-        }
-        else {
+        } else {
             player.stopRiding()
         }
+
+        if (isRidingInAir) pokemon.setFlying(true)
     }
 
     private fun canPlayerStopRidingPokemon(pokemon: PokemonEntity, player: ServerPlayer): Boolean {

common/src/main/kotlin/com/cobblemon/mod/common/platform/events/RenderEvent.kt

@@ -32,7 +32,6 @@ data class RenderEvent(
 
     /** Represents when a layer is rendered by [LevelRenderer.renderLevel]. Ordinal corresponds with its render order. */
     enum class Stage {
-        AFTER_ENTITIES,
         TRANSLUCENT
     }
 }

common/src/main/kotlin/com/cobblemon/mod/common/pokemon/Pokemon.kt

@@ -199,6 +199,9 @@ open class Pokemon : ShowdownIdentifiable {
 
     var form = species.standardForm
         set(value) {
+            // If nothing actually changed, avoid running heavy logic (e.g. updateMovesOnFormChange when the form hasn't really "changed")
+            if (field == value) return
+
             // Species updates already update HP but just a form change may require it
             // Moved to before the field was set else it won't actually do the hp calc proper <3
             val quotient = clamp(currentHealth / maxHealth.toFloat(), 0F, 1F)
@@ -1437,6 +1440,11 @@ open class Pokemon : ShowdownIdentifiable {
     }
 
     fun getOwnerEntity(): LivingEntity? {
+        if (isClient) {
+            val ownerUUID = entity?.ownerUUID ?: return null
+            return entity?.level()?.getPlayerByUUID(ownerUUID)
+        }
+
         return storeCoordinates.get()?.let {
             if (isPlayerOwned()) {
                 server()?.playerList?.getPlayer(it.store.uuid)
@@ -2139,16 +2147,26 @@ open class Pokemon : ShowdownIdentifiable {
      */
     open fun self(): Pokemon = this
 
+
+    /**
+     * Function that sanitizes specific form-related moves when the form of this Pokémon changes.
+     * We only want to sanitize `form_change` moves here so that intended illegalities from the user are preserved.
+     *
+     * E.g, Removing Overheat from Rotom when it is no longer Rotom-Heat and the target form is not compatible with Overheat.
+     */
     private fun updateMovesOnFormChange(newForm: FormData) {
-        if (this.isClient) {
-            return
-        }
+        if (this.isClient) return
+
+        val oldFormChangeMoves = this.form.moves.formChangeMoves.toSet()
+
+        // Only remove moves that were provided by the old form's form-change moves AND are not learnable by the new form
         for (i in 0 until MoveSet.MOVE_COUNT) {
             val move = this.moveSet[i]
-            if (move != null && !LearnsetQuery.ANY.canLearn(move.template, newForm.moves)) {
+            if (move != null && move.template in oldFormChangeMoves) {
                 this.moveSet.setMove(i, null)
             }
         }
+
         val benchedIterator = this.benchedMoves.iterator()
         while (benchedIterator.hasNext()) {
             val benchedMove = benchedIterator.next()
@@ -2156,11 +2174,18 @@ open class Pokemon : ShowdownIdentifiable {
                 benchedIterator.remove()
             }
         }
-        // Add form change moves
+
+        // Add new form's form-change moves
         newForm.moves.formChangeMoves.forEach { move ->
-            // Under the hood these check if the moves already exist
-            this.benchedMoves.add(BenchedMove(move, 0))
+            if (this.moveSet.filterNotNull().none { it.template == move }) {
+                if (this.moveSet.hasSpace()) {
+                    this.moveSet.add(move.create())
+                } else {
+                    this.benchedMoves.add(BenchedMove(move, 0))
+                }
+            }
         }
+
         // If moveset is empty try to find one valid move to fill it
         if (this.moveSet.filterNotNull().isEmpty()) {
             val benchedMove = this.benchedMoves.firstOrNull()

common/src/main/kotlin/com/cobblemon/mod/common/pokemon/adapters/CobbledRequirementAdapter.kt

@@ -8,13 +8,22 @@
 
 package com.cobblemon.mod.common.pokemon.adapters
 
+import com.cobblemon.mod.common.api.interaction.InteractionEffect
+import com.cobblemon.mod.common.api.molang.ExpressionLike
+import com.cobblemon.mod.common.api.pokemon.PokemonProperties
 import com.cobblemon.mod.common.api.pokemon.adapters.RequirementAdapter
 import com.cobblemon.mod.common.api.pokemon.requirement.Requirement
+import com.cobblemon.mod.common.pokemon.evolution.adapters.LegacyItemConditionWrapperAdapter
 import com.cobblemon.mod.common.pokemon.requirements.*
+import com.cobblemon.mod.common.util.adapters.*
+import com.cobblemon.mod.common.util.readString
+import com.cobblemon.mod.common.util.writeString
 import com.google.common.collect.HashBiMap
-import com.google.gson.JsonDeserializationContext
-import com.google.gson.JsonElement
-import com.google.gson.JsonSerializationContext
+import com.google.gson.*
+import net.minecraft.advancements.critereon.ItemPredicate
+import net.minecraft.network.FriendlyByteBuf
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.util.LowerCaseEnumTypeAdapterFactory
 import java.lang.reflect.Type
 import kotlin.reflect.KClass
 
@@ -60,21 +69,60 @@ object CobblemonRequirementAdapter : RequirementAdapter {
         this.registerType(OwnerHoldsItemRequirement.ADAPTER_VARIANT, OwnerHoldsItemRequirement::class)
     }
 
+    val gson: Gson by lazy {
+        GsonBuilder()
+            .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
+            .registerTypeAdapter(PokemonProperties::class.java, pokemonPropertiesShortAdapter)
+            .registerTypeAdapter(ItemPredicate::class.java, LegacyItemConditionWrapperAdapter)
+            .registerTypeAdapter(Requirement::class.java, CobblemonRequirementAdapter)
+            .registerTypeAdapter(InteractionEffect::class.java, InteractionEffectAdapter)
+            .registerTypeAdapter(ExpressionLike::class.java, ExpressionLikeAdapter)
+            .registerTypeAdapter(IntRange::class.java, IntRangeAdapter)
+            .registerTypeAdapterFactory(LowerCaseEnumTypeAdapterFactory())
+            .setPrettyPrinting()
+            .create()
+    }
+
     override fun <T : Requirement> registerType(id: String, type: KClass<T>) {
         this.types[id.lowercase()] = type
     }
 
     override fun deserialize(json: JsonElement, typeOfT: Type, context: JsonDeserializationContext): Requirement {
         val variant = json.asJsonObject.get(VARIANT).asString.lowercase()
-        val type = this.types[variant] ?: throw IllegalArgumentException("Cannot resolve evolution requirement type for variant $variant")
+        val type = getRequirementType(variant)
         return context.deserialize(json, type.java)
     }
 
-    override fun serialize(src: Requirement, typeOfSrc: Type, context: JsonSerializationContext): JsonElement {
-        val json = context.serialize(src, src::class.java).asJsonObject
-        val variant = this.types.inverse()[src::class] ?: throw IllegalArgumentException("Cannot resolve evolution requirement for type ${src::class.qualifiedName}")
+    override fun serialize(requirement: Requirement, typeOfSrc: Type, context: JsonSerializationContext): JsonElement {
+        val json = context.serialize(requirement, requirement::class.java).asJsonObject
+        val variant = getVariant(requirement)
         json.addProperty(VARIANT, variant)
         return json
     }
 
+    fun encode(requirement: Requirement, buffer: FriendlyByteBuf) {
+        buffer.writeString(gson.toJson(requirement, Requirement::class.java))
+    }
+
+    fun decode(buffer: FriendlyByteBuf): Requirement {
+        return gson.fromJson(buffer.readString(), Requirement::class.java)
+    }
+
+    private fun getVariant(requirement: Requirement): String {
+        val variant = this.types.inverse()[requirement::class]
+        if (variant == null) {
+            throw IllegalArgumentException("Cannot resolve evolution requirement for type ${requirement::class.qualifiedName}")
+        }
+
+        return variant
+    }
+
+    private fun getRequirementType(variant: String): KClass<out Requirement> {
+        val requirementType = this.types[variant]
+        if (requirementType == null) {
+            throw IllegalArgumentException("Cannot resolve evolution requirement type for variant $variant")
+        }
+
+        return requirementType
+    }
 }

common/src/main/kotlin/com/cobblemon/mod/common/pokemon/ai/OmniPathNodeMaker.kt

@@ -562,8 +562,8 @@ class OmniPathNodeMaker : NodeEvaluator() {
 ////            PathType.WALKABLE
 ////        } else if (blockState.canPathfindThrough(world, pos, NavigationType.AIR) && !blockStateBelow.isSideSolid(world, below, Direction.UP, SideShapeType.FULL)) {
 ////            PathType.OPEN
-//        } else if (blockState.`is`(BlockTags.LEAVES) && blockState.block == CobblemonBlocks.SACCHARINE_LEAVES && canPathThroughLeaves()) {
-//            return PathType.OPEN
+        if (canPathThroughLeaves() && blockState.block == CobblemonBlocks.SACCHARINE_LEAVES)
+            return PathType.OPEN
 //        } else PathType.BLOCKED
 
         // This is the 1.6.1 logic but with some optimizations
@@ -633,9 +633,6 @@ class OmniPathNodeMaker : NodeEvaluator() {
             pfContext, x, y, z, sizeX, sizeY, sizeZ, canOpenDoors, canPassDoors, set, PathType.BLOCKED, BlockPos(x, y, z), returnedEarlyPathType
         )
 
-        if (PathType.LEAVES in set) {
-            return PathType.OPEN
-        }
 
         if (PathType.FENCE in set) {
             return PathType.FENCE
@@ -755,7 +752,7 @@ class OmniPathNodeMaker : NodeEvaluator() {
         } else if (type == PathType.RAIL && block !is BaseRailBlock && pfContext.getCachedBlockState(pos.below()).block !is BaseRailBlock) {
             PathType.UNPASSABLE_RAIL
         } else if (type == PathType.LEAVES) {
-            if (blockState.block === CobblemonBlocks.SACCHARINE_LEAVES && canPathThroughLeaves()) {
+            if (canPathThroughLeaves() && blockState.block === CobblemonBlocks.SACCHARINE_LEAVES) {
                 PathType.OPEN
             } else {
                 PathType.BLOCKED

common/src/main/kotlin/com/cobblemon/mod/common/pokemon/properties/LabelProperty.kt

@@ -6,19 +6,15 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-package com.cobblemon.mod.common.pokemon.properties.tags
+package com.cobblemon.mod.common.pokemon.properties
 
 import com.cobblemon.mod.common.api.properties.CustomPokemonPropertyType
-import com.cobblemon.mod.common.pokemon.properties.StringProperty
 
-object PokemonFlagProperty : CustomPokemonPropertyType<StringProperty> {
-
-    private const val KEY = "tag"
-
-    override val keys = setOf(KEY)
+object LabelProperty : CustomPokemonPropertyType<StringProperty> {
+    override val keys = setOf("label", "tag")
     override val needsKey = true
 
-    override fun fromString(value: String?) = if (value == null) null else StringProperty(KEY, value, { _, _ -> }, { pokemon, underlyingValue -> pokemon.hasLabels(underlyingValue) })
+    override fun fromString(value: String?) = if (value == null) null else StringProperty(keys.first(), value, { _, _ -> }, { pokemon, underlyingValue -> pokemon.hasLabels(underlyingValue) })
 
     override fun examples() = emptySet<String>()
 }

common/src/main/kotlin/com/cobblemon/mod/common/pokemon/requirements/AdvancementRequirement.kt

@@ -11,9 +11,9 @@ package com.cobblemon.mod.common.pokemon.requirements
 import com.cobblemon.mod.common.api.pokemon.requirement.OwnerQueryRequirement
 import com.cobblemon.mod.common.entity.npc.NPCEntity
 import com.cobblemon.mod.common.pokemon.Pokemon
-import net.minecraft.server.level.ServerPlayer
 import net.minecraft.resources.ResourceLocation
-import kotlin.collections.iterator
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.world.entity.player.Player
 
 /**
  * An [com.cobblemon.mod.common.api.pokemon.requirement.Requirement] that checks if the player has a certain [net.minecraft.advancements.Advancement]
@@ -26,13 +26,16 @@ class AdvancementRequirement(val requiredAdvancement: ResourceLocation) : OwnerQ
 
     override fun checkPlayer(
         pokemon: Pokemon,
-        owner: ServerPlayer
+        owner: Player
     ): Boolean {
-        for (entry in owner.advancements.progress) {
+        val serverPlayer = owner as? ServerPlayer ?: return false
+
+        for (entry in serverPlayer.advancements.progress) {
             if (entry.key.id == requiredAdvancement && entry.value.isDone) {
                 return true
             }
         }
+
         return false
     }
 

common/src/main/kotlin/com/cobblemon/mod/common/pokemon/requirements/OwnerHoldsItemRequirement.kt

@@ -12,11 +12,9 @@ import com.cobblemon.mod.common.api.pokemon.requirement.OwnerQueryRequirement
 import com.cobblemon.mod.common.entity.npc.NPCEntity
 import com.cobblemon.mod.common.pokemon.Pokemon
 import net.minecraft.advancements.critereon.ItemPredicate
-import net.minecraft.server.level.ServerPlayer
-import net.minecraft.resources.ResourceLocation
 import net.minecraft.world.InteractionHand
 import net.minecraft.world.entity.LivingEntity
-import kotlin.collections.iterator
+import net.minecraft.world.entity.player.Player
 
 /**
  * An [OwnerQueryRequirement] that checks if the player/npc is holding a certain [ItemPredicate]
@@ -30,7 +28,7 @@ class OwnerHoldsItemRequirement(val itemCondition: ItemPredicate)
 
     override fun checkPlayer(
         pokemon: Pokemon,
-        owner: ServerPlayer
+        owner: Player
     ): Boolean {
         return checkItem(owner)
     }

common/src/main/kotlin/com/cobblemon/mod/common/util/Vec3Extensions.kt

@@ -11,7 +11,6 @@ package com.cobblemon.mod.common.util
 import net.minecraft.core.BlockPos
 import net.minecraft.world.phys.Vec3
 import org.joml.Vector3f
-import kotlin.math.sqrt
 
 /**
  * For conversion from Vec3dto BlockPos, loses accuracy
@@ -23,17 +22,9 @@ fun Vec3.toBlockPos(): BlockPos {
 fun Vec3.toVec3f(): Vector3f = Vector3f(x.toFloat(), y.toFloat(), z.toFloat())
 fun Vector3f.toVec3d(): Vec3 =
     Vec3(x.toDouble(), y.toDouble(), z.toDouble())
-
 fun Vector3f.set(vec3d: Vec3): Vector3f {
     x = vec3d.x.toFloat()
     y = vec3d.y.toFloat()
     z = vec3d.z.toFloat()
     return this
-}
-
-fun Vector3f.distance(other: Vector3f): Float {
-    val dx = other.x - x
-    val dy = other.y - y
-    val dz = other.z - z
-    return sqrt(dx * dx + dy * dy + dz * dz)
 }

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

@@ -8,22 +8,22 @@
 
 package com.cobblemon.mod.common.util.adapters
 
-import com.google.gson.JsonDeserializationContext
-import com.google.gson.JsonDeserializer
-import com.google.gson.JsonElement
-import com.google.gson.JsonSerializationContext
-import com.google.gson.JsonSerializer
+import com.google.gson.*
 import com.mojang.serialization.Codec
-import com.mojang.serialization.JsonOps
 import java.lang.reflect.Type
 
 class CodecBackedAdapter<T>(val codec: Codec<T>) : JsonDeserializer<T>, JsonSerializer<T> {
+
     override fun deserialize(
         jElement: JsonElement,
         typeOfT: Type,
         context: JsonDeserializationContext
     ): T {
-        return JsonOps.INSTANCE.withDecoder(codec).apply(jElement).result().get().first as T
+        val ops = RegistryOpsProvider.getOpsWithDefaultFallback()
+        val result = ops.withDecoder(codec).apply(jElement)
+        return result.result().orElseThrow {
+            IllegalStateException("Failed to deserialize $jElement: ${result.error().orElse(null)}")
+        }.first
     }
 
     override fun serialize(
@@ -31,6 +31,10 @@ class CodecBackedAdapter<T>(val codec: Codec<T>) : JsonDeserializer<T>, JsonSeri
         typeOfSrc: Type?,
         context: JsonSerializationContext?
     ): JsonElement {
-        return JsonOps.INSTANCE.withEncoder(codec).apply(src).result().get()
+        val ops = RegistryOpsProvider.getOpsWithDefaultFallback()
+        val result = ops.withEncoder(codec).apply(src)
+        return result.result().orElseThrow {
+            IllegalStateException("Failed to serialize $src: ${result.error().orElse(null)}")
+        }
     }
 }

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

@@ -0,0 +1,41 @@
+/*
+ * 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.util.adapters
+
+import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.Environment
+import com.cobblemon.mod.common.util.server
+import com.google.gson.JsonElement
+import com.mojang.serialization.DynamicOps
+import com.mojang.serialization.JsonOps
+import net.minecraft.client.Minecraft
+import net.minecraft.resources.RegistryOps
+
+/**
+ * Utility for obtaining RegistryOps with the correct client/server registry access.
+ * Used when manually encoding/decoding registry-backed values (e.g., items, predicates).
+ */
+object RegistryOpsProvider {
+    fun getOpsWithDefaultFallback(): DynamicOps<JsonElement> {
+        if (Cobblemon.implementation.environment() == Environment.CLIENT) {
+            val minecraft = Minecraft.getInstance()
+            if (minecraft != null && minecraft.level != null)
+                return RegistryOps.create(JsonOps.INSTANCE, minecraft.level!!.registryAccess())
+        }
+
+
+        if (Cobblemon.implementation.environment() == Environment.SERVER) {
+            val server = server()
+            if (server != null)
+                return RegistryOps.create(JsonOps.INSTANCE, server.registryAccess())
+        }
+
+        return JsonOps.INSTANCE
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/world/feature/SaccharineTreeFeature.kt

@@ -10,13 +10,14 @@ package com.cobblemon.mod.common.world.feature
 
 import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.CobblemonBlocks
-import com.cobblemon.mod.common.api.pokemon.PokemonProperties
 import com.cobblemon.mod.common.api.tags.CobblemonBiomeTags
 import net.minecraft.core.BlockPos
 import net.minecraft.core.Direction
 import net.minecraft.core.Direction.UP
+import net.minecraft.nbt.CompoundTag
 import net.minecraft.tags.BlockTags
 import net.minecraft.util.RandomSource
+import net.minecraft.world.item.component.CustomData
 import net.minecraft.world.level.WorldGenLevel
 import net.minecraft.world.level.block.Block.UPDATE_ALL
 import net.minecraft.world.level.block.Block.UPDATE_CLIENTS
@@ -227,12 +228,20 @@ class SaccharineTreeFeature : Feature<BlockStateConfiguration>(BlockStateConfigu
                     val i: Int = 2 + randomSource.nextInt(2)
                     for (j in 0..<i) {
                         if (isCombee > 0) {
-                            beehiveBlockEntity!!.storeBee(BeehiveBlockEntity.Occupant.create(randomSource.nextInt(599)))
+                            beehiveBlockEntity?.storeBee(BeehiveBlockEntity.Occupant.create(randomSource.nextInt(599)))
                         } else {
+                            // We want to create a Pokemon entity here and turn it into a compound tag to store in the hive.
+                            // But creating a Pokemon entity during world generation can cause issues.
+                            // So instead we create custom compound tag that is a placeholder for an incomplete Pokemon.
+                            // This is caught and handled by BeeOccupantMixin.java, which turns it into a complete entity.
                             val properties = "${POKEMON_ARGS} lvl=${LEVEL_RANGE.random()}"
-                            val pokemon = PokemonProperties.parse(properties)
-                            val entity = pokemon.createEntity(worldGenLevel.level)
-                            beehiveBlockEntity!!.addOccupant(entity)
+                            val compoundTag = CompoundTag()
+                            compoundTag.putString("id", POKEMON_PLACEHOLD_ID)
+                            compoundTag.putString("pokemonProperties", properties)
+                            val occupant = BeehiveBlockEntity.Occupant(
+                                CustomData.of(compoundTag), randomSource.nextInt(599), 600
+                            )
+                            beehiveBlockEntity?.storeBee(occupant)
                         }
                     }
                 })
@@ -351,5 +360,6 @@ class SaccharineTreeFeature : Feature<BlockStateConfiguration>(BlockStateConfigu
     companion object {
         val POKEMON_ARGS = "combee"
         val LEVEL_RANGE = 5..15
+        val POKEMON_PLACEHOLD_ID = "cobblemon_pokemon_entity_placeholder"
     }
 }

common/src/main/resources/assets/cobblemon/lang/en_us.json

@@ -820,6 +820,14 @@
   "cobblemon.cooking.cooking_quality.medium": "Medium",
   "cobblemon.cooking.cooking_quality.high": "High",
 
+  "effect.cobblemon.cleanse_all": "Effect Cleanse",
+  "effect.cobblemon.cleanse_negative": "Negative Effect Cleanse",
+  "effect.cobblemon.mental_restoration": "Mental Restoration",
+
+  "effect.cobblemon.cleanse_all": "Effect Cleanse",
+  "effect.cobblemon.cleanse_negative": "Negative Effect Cleanse",
+  "effect.cobblemon.mental_restoration": "Mental Restoration",
+
   "cobblemon.fossil.armor": "Armor",
   "cobblemon.fossil.bird": "Bird",
   "cobblemon.fossil.claw": "Claw",
@@ -2621,6 +2629,8 @@
   "cobblemon.config.ui.infinite_ride_stamina.tooltip": "Whether rideable Pokémon have infinite stamina.",
   "cobblemon.config.ui.remember_riding_camera": "Remember Riding Camera",
   "cobblemon.config.ui.remember_riding_camera.tooltip": "Whether the camera mode will automatically switch to the last used camera mode when mounting a rideable Pokémon.",
+  "cobblemon.config.ui.enable_in_flight_dismounting": "Enable In-Flight Dismounting",
+  "cobblemon.config.ui.enable_in_flight_dismounting.tooltip": "Allows players to dismount while riding a Pokémon in the air. When disabled, dismounting is only possible while on the ground.",
 
   "cobblemon.config.ui.allow_starter_on_join": "Allow Starter on Join",
   "cobblemon.config.ui.prompt_starter_once_only": "Prompt Starter Once Only",
@@ -3515,6 +3525,7 @@
   "tag.item.cobblemon.plants": "Plants",
   "tag.item.cobblemon.seeds": "Seeds",
   "tag.item.cobblemon.boats": "Boats",
+  "tag.item.cobblemon.chest_boats": "Chest Boats",
   "tag.item.cobblemon.hanging_signs": "Hanging Signs",
   "tag.item.cobblemon.signs": "Signs",
   "tag.item.cobblemon.dawn_stone_ores": "Dawn Stone Ores",
@@ -9445,5 +9456,8 @@
   "stat.cobblemon.traded": "Pokémon Traded",
   "stat.cobblemon.times_ridden": "Pokémon Ridden",
   "stat.cobblemon.rod_casts": "PokéRod Casts",
-  "stat.cobblemon.reel_ins": "PokéRod Catches"
+  "stat.cobblemon.reel_ins": "PokéRod Catches",
+  "stat.cobblemon.riding_land": "Distance by Pokémon on Land",
+  "stat.cobblemon.riding_air": "Distance by Pokémon in Air",
+  "stat.cobblemon.riding_liquid": "Distance by Pokémon in Liquid"
 }

common/src/main/resources/assets/cobblemon/models/item/pokemon_model.json

@@ -1,4 +1,7 @@
 {
   "parent": "minecraft:builtin/entity",
-  "gui_light": "side"
+  "gui_light": "side",
+  "textures": {
+    "particle": "cobblemon:item/poke_balls/cherish_ball"
+  }
 }

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

@@ -1517,76 +1517,139 @@
       { "name": "cobblemon:animation/wings/steel_wing_flap_medium_8", "volume": 0.25 }
     ]
   },
-  "ride.loop.wind": {
+  "ride.loop.wind.mono": {
     "sounds": [
       {
-        "name": "cobblemon:ride/loop/wind_loop",
+        "name": "cobblemon:ride/loop/wind_loop_mono",
         "stream": true,
         "attenuation_distance": 48.0,
         "volume": 0.15
       }
     ]
   },
-  "ride.loop.leather": {
+  "ride.loop.wind.stereo": {
     "sounds": [
       {
-        "name": "cobblemon:ride/loop/leather_flight_loop",
+        "name": "cobblemon:ride/loop/wind_loop_stereo",
+        "stream": true,
+        "volume": 0.04
+      }
+    ]
+  },
+  "ride.loop.leather.mono": {
+    "sounds": [
+      {
+        "name": "cobblemon:ride/loop/leather_flight_loop_mono",
         "stream": true,
         "attenuation_distance": 48.0,
         "volume": 0.25
       }
     ]
   },
-  "ride.loop.plumage": {
+  "ride.loop.leather.stereo": {
     "sounds": [
       {
-        "name": "cobblemon:ride/loop/plumage_flight_loop",
+        "name": "cobblemon:ride/loop/leather_flight_loop_stereo",
+        "stream": true,
+        "volume": 0.05
+      }
+    ]
+  },
+  "ride.loop.plumage.mono": {
+    "sounds": [
+      {
+        "name": "cobblemon:ride/loop/plumage_flight_loop_mono",
         "stream": true,
         "attenuation_distance": 48.0,
         "volume": 0.25
       }
     ]
   },
-  "ride.loop.saucer": {
+  "ride.loop.plumage.stereo": {
     "sounds": [
       {
-        "name": "cobblemon:ride/loop/saucer_flight_loop",
+        "name": "cobblemon:ride/loop/plumage_flight_loop_stereo",
+        "stream": true,
+        "volume": 0.05
+      }
+    ]
+  },
+  "ride.loop.saucer.mono": {
+    "sounds": [
+      {
+        "name": "cobblemon:ride/loop/saucer_flight_loop_mono",
         "stream": true,
         "attenuation_distance": 48.0,
         "volume": 0.25
       }
     ]
   },
-  "ride.loop.rocket": {
+  "ride.loop.saucer.stereo": {
     "sounds": [
       {
-        "name": "cobblemon:ride/loop/rocket_flight_loop",
+        "name": "cobblemon:ride/loop/saucer_flight_loop_stereo",
+        "stream": true,
+        "volume": 0.1
+      }
+    ]
+  },
+  "ride.loop.rocket.mono": {
+    "sounds": [
+      {
+        "name": "cobblemon:ride/loop/rocket_flight_loop_mono",
         "stream": true,
         "attenuation_distance": 48.0,
         "volume": 0.4
       }
     ]
   },
-  "ride.loop.water_surface": {
+  "ride.loop.rocket.stereo": {
     "sounds": [
       {
-        "name": "cobblemon:ride/loop/water_surface_loop",
+        "name": "cobblemon:ride/loop/rocket_flight_loop_stereo",
+        "stream": true,
+        "volume": 0.3
+      }
+    ]
+  },
+  "ride.loop.water_surface.mono": {
+    "sounds": [
+      {
+        "name": "cobblemon:ride/loop/water_surface_loop_mono",
         "stream": true,
         "attenuation_distance": 32.0,
         "volume": 0.4
       }
     ]
   },
-  "ride.loop.underwater": {
+  "ride.loop.water_surface.stereo": {
     "sounds": [
       {
-        "name": "cobblemon:ride/loop/underwater_loop",
+        "name": "cobblemon:ride/loop/water_surface_loop_stereo",
+        "stream": true,
+        "volume": 0.13
+      }
+    ]
+  },
+  "ride.loop.underwater.mono": {
+    "sounds": [
+      {
+        "name": "cobblemon:ride/loop/underwater_loop_mono",
         "stream": true,
         "attenuation_distance": 16.0,
         "volume": 0.4
       }
     ]
   },
+  "ride.loop.underwater.stereo": {
+    "sounds": [
+      {
+        "name": "cobblemon:ride/loop/underwater_loop_stereo",
+        "stream": true,
+        "volume": 0.2
+      }
+    ]
+  },
   "pokemon.bulbasaur.ambient": {
     "sounds": [ "cobblemon:pokemon/bulbasaur/bulbasaur_ambient" ]
   },