Added scraper for trainer data sheet

Added more molang expressions to a bunch of composed pool properties, fixed some bugs
Added egg move selector
2026-10-28 13:06:25 -04:00 · 2026-01-19 16:24:55 +10:00 · 2025-12-15 14:22:59 +10:00 · 2025-12-15 12:07:06 +10:00 · 2025-12-14 20:33:34 +10:00 · 2025-12-14 20:27:30 +10:00
165 changed files with 1843 additions and 4949 deletions
@@ -0,0 +1,16 @@
+### Additions
+
+### Changes
+- Wild Pokémon now reliably have at least one offensive move, if they can have offensive moves at that level.
+
+### Fixes
+
+### Developer
+
+### Molang & Datapacks
+- Added `moveset_builders` datapack folder for different styles of movesets.
+- Added `party_pools` datapack folder for defining groups of Pokémon for the purposes of complex NPC party definitions.
+- Added `party_compositions` datapack folder for arranging parties on NPCs that rely on party pools.
+- Added `composed_pool` NPC party provider type which combines a party pool with a party composition to create more complex NPC parties.
+
+### Particles
@@ -2,51 +2,19 @@
 ## [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.

 ### 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.

 ### 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 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.

 ### 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

 ### Particles

@@ -11,15 +11,11 @@ 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;
@@ -93,32 +89,4 @@ 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;
-    }
 }
@@ -33,7 +33,7 @@ public class AbstractClientPlayerMixin {
            cir.setReturnValue(usageContext.getFovMultiplier());
        } else {
            // Only modify fov through riding if the pokedex is not open
-            AbstractClientPlayer player = (AbstractClientPlayer) (Object) this;
+            LocalPlayer player = (LocalPlayer) (Object) this;
            // Only modify fov for the driver and not the passengers
            if (player != null && player.isPassenger() && player.getVehicle() instanceof PokemonEntity && player.getVehicle().getControllingPassenger() == player) {
                PokemonEntity ride = (PokemonEntity) player.getVehicle();
@@ -42,8 +42,8 @@ import com.cobblemon.mod.common.api.scheduling.ServerRealTimeTaskTracker
 import com.cobblemon.mod.common.api.scheduling.ServerTaskTracker
 import com.cobblemon.mod.common.api.spawning.BestSpawner
 import com.cobblemon.mod.common.api.spawning.CobblemonSpawningZoneGenerator
-import com.cobblemon.mod.common.api.spawning.SpawningZoneGenerator
 import com.cobblemon.mod.common.api.spawning.position.AreaSpawnablePositionResolver
+import com.cobblemon.mod.common.api.spawning.SpawningZoneGenerator
 import com.cobblemon.mod.common.api.starter.StarterHandler
 import com.cobblemon.mod.common.api.stats.CobblemonStats
 import com.cobblemon.mod.common.api.storage.PokemonStoreManager
@@ -76,7 +76,12 @@ import com.cobblemon.mod.common.config.LastChangedVersion
 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.events.AdvancementHandler
+import com.cobblemon.mod.common.events.EntityCallbackHandler
+import com.cobblemon.mod.common.events.CallbackHandler
+import com.cobblemon.mod.common.events.PokedexHandler
+import com.cobblemon.mod.common.events.ServerTickHandler
+import com.cobblemon.mod.common.events.StatHandler
 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
@@ -91,7 +96,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.LabelProperty
+import com.cobblemon.mod.common.pokemon.properties.tags.PokemonFlagProperty
 import com.cobblemon.mod.common.pokemon.stat.CobblemonStatProvider
 import com.cobblemon.mod.common.starter.CobblemonStarterHandler
 import com.cobblemon.mod.common.util.*
@@ -201,7 +206,6 @@ object Cobblemon {
        implementation.registerEntityDataSerializers()
        implementation.registerCriteria()
        implementation.registerEntitySubPredicates()
-        implementation.registerMobEffects()
        DispenserBehaviorRegistry.registerDispenserBehaviors()

        DropEntry.register("command", CommandDropEntry::class.java)
@@ -315,7 +319,7 @@ object Cobblemon {

        CustomPokemonProperty.register(UncatchableProperty)
        CustomPokemonProperty.register(BattleCloneProperty)
-        CustomPokemonProperty.register(LabelProperty)
+        CustomPokemonProperty.register(PokemonFlagProperty)
        CustomPokemonProperty.register(HiddenAbilityPropertyType)
        CustomPokemonProperty.register(AspectPropertyType)
        CustomPokemonProperty.register(UnaspectPropertyType)
@@ -117,11 +117,6 @@ interface CobblemonImplementation {

    fun registerEntitySubPredicates()

-    /**
-     * TODO
-     */
-    fun registerMobEffects()
-

    /**
     * Add a feature to the current platform implementation.
@@ -1,33 +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
-
-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())
-}
@@ -0,0 +1,55 @@
+/*
+ * 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.data.JsonDataRegistry
+import com.cobblemon.mod.common.api.moves.MoveSelector
+import com.cobblemon.mod.common.api.moves.MovesetBuilder
+import com.cobblemon.mod.common.api.reactive.SimpleObservable
+import com.cobblemon.mod.common.util.adapters.IdentifierAdapter
+import com.cobblemon.mod.common.util.adapters.MovesetBuilderAdapter
+import com.cobblemon.mod.common.util.adapters.StringToObjectAdapter
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+import com.google.gson.reflect.TypeToken
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.server.packs.PackType
+
+object CobblemonMovesetBuilders : JsonDataRegistry<MovesetBuilder> {
+    override val gson: Gson = GsonBuilder()
+        .setPrettyPrinting()
+        .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
+        .registerTypeAdapter(MovesetBuilder::class.java, MovesetBuilderAdapter)
+        .registerTypeAdapter(MoveSelector::class.java, StringToObjectAdapter(MoveSelector.selectors))
+        .create()
+
+    override val typeToken = TypeToken.get(MovesetBuilder::class.java)
+    override val resourcePath = "moveset_builders"
+    override val id: ResourceLocation = cobblemonResource("moveset_builders")
+    override val type = PackType.SERVER_DATA
+    override val observable = SimpleObservable<CobblemonMovesetBuilders>()
+
+    val movesetBuilders = mutableMapOf<ResourceLocation, MovesetBuilder>()
+
+    fun getOrThrow(id: ResourceLocation): MovesetBuilder {
+        return movesetBuilders[id]
+            ?: throw IllegalArgumentException("Unknown MovesetBuilder id: $id")
+    }
+
+    override fun sync(player: ServerPlayer) { /* These don't sync. But what if they did? Nah probably shouldn't sync. */ }
+
+    override fun reload(data: Map<ResourceLocation, MovesetBuilder>) {
+        movesetBuilders.clear()
+        data.forEach { (id, value) -> value.id = id }
+        movesetBuilders.putAll(data)
+        observable.emit(this)
+    }
+}
@@ -21,12 +21,15 @@ import com.cobblemon.mod.common.client.net.callback.partymove.OpenPartyMoveCallb
 import com.cobblemon.mod.common.client.net.cooking.ToggleCookingPotLidHandler
 import com.cobblemon.mod.common.client.net.data.CobblemonMechanicsSyncHandler
 import com.cobblemon.mod.common.client.net.data.DataRegistrySyncPacketHandler
-import com.cobblemon.mod.common.client.net.data.PokemonInteractionsSyncHandler
 import com.cobblemon.mod.common.client.net.data.RideSettingsSyncHandler
 import com.cobblemon.mod.common.client.net.debug.OpenRidingStatsDebugGUIHandler
 import com.cobblemon.mod.common.client.net.dialogue.DialogueClosedHandler
 import com.cobblemon.mod.common.client.net.dialogue.DialogueOpenedHandler
-import com.cobblemon.mod.common.client.net.effect.*
+import com.cobblemon.mod.common.client.net.effect.PokeSnackBlockParticlesHandler
+import com.cobblemon.mod.common.client.net.effect.RunPosableMoLangHandler
+import com.cobblemon.mod.common.client.net.effect.SaccharineLogBlockParticlesHandler
+import com.cobblemon.mod.common.client.net.effect.SpawnSnowstormEntityParticleHandler
+import com.cobblemon.mod.common.client.net.effect.SpawnSnowstormParticleHandler
 import com.cobblemon.mod.common.client.net.gui.ExpGainedDataPacketHandler
 import com.cobblemon.mod.common.client.net.gui.InteractPokemonUIPacketHandler
 import com.cobblemon.mod.common.client.net.gui.PokedexUIPacketHandler
@@ -34,7 +37,11 @@ import com.cobblemon.mod.common.client.net.gui.SummaryUIPacketHandler
 import com.cobblemon.mod.common.client.net.npc.CloseNPCEditorHandler
 import com.cobblemon.mod.common.client.net.npc.OpenNPCEditorHandler
 import com.cobblemon.mod.common.client.net.orientation.ClientboundUpdateOrientationHandler
-import com.cobblemon.mod.common.client.net.pasture.*
+import com.cobblemon.mod.common.client.net.pasture.ClosePastureHandler
+import com.cobblemon.mod.common.client.net.pasture.OpenPastureHandler
+import com.cobblemon.mod.common.client.net.pasture.PokemonPasturedHandler
+import com.cobblemon.mod.common.client.net.pasture.PokemonUnpasturedHandler
+import com.cobblemon.mod.common.client.net.pasture.UpdatePastureConflictFlagHandler
 import com.cobblemon.mod.common.client.net.pokedex.ServerConfirmedRegisterHandler
 import com.cobblemon.mod.common.client.net.pokemon.update.ClientboundUpdateRidingStateHandler
 import com.cobblemon.mod.common.client.net.pokemon.update.PokemonUpdatePacketHandler
@@ -52,7 +59,14 @@ import com.cobblemon.mod.common.client.net.storage.party.SetPartyPokemonHandler
 import com.cobblemon.mod.common.client.net.storage.party.SetPartyReferenceHandler
 import com.cobblemon.mod.common.client.net.storage.pc.*
 import com.cobblemon.mod.common.client.net.toast.ToastPacketHandler
-import com.cobblemon.mod.common.client.net.trade.*
+import com.cobblemon.mod.common.client.net.trade.TradeAcceptanceChangedHandler
+import com.cobblemon.mod.common.client.net.trade.TradeCancelledHandler
+import com.cobblemon.mod.common.client.net.trade.TradeCompletedHandler
+import com.cobblemon.mod.common.client.net.trade.TradeOfferExpiredHandler
+import com.cobblemon.mod.common.client.net.trade.TradeOfferNotificationHandler
+import com.cobblemon.mod.common.client.net.trade.TradeProcessStartedHandler
+import com.cobblemon.mod.common.client.net.trade.TradeStartedHandler
+import com.cobblemon.mod.common.client.net.trade.TradeUpdatedHandler
 import com.cobblemon.mod.common.net.PacketRegisterInfo
 import com.cobblemon.mod.common.net.messages.client.CalculateSeatPositionsPacket
 import com.cobblemon.mod.common.net.messages.client.OpenBehaviourEditorPacket
@@ -69,12 +83,20 @@ import com.cobblemon.mod.common.net.messages.client.data.*
 import com.cobblemon.mod.common.net.messages.client.debug.RequestOpenRidingStatsDebugGUIPacket
 import com.cobblemon.mod.common.net.messages.client.dialogue.DialogueClosedPacket
 import com.cobblemon.mod.common.net.messages.client.dialogue.DialogueOpenedPacket
-import com.cobblemon.mod.common.net.messages.client.effect.*
+import com.cobblemon.mod.common.net.messages.client.effect.PokeSnackBlockParticlesPacket
+import com.cobblemon.mod.common.net.messages.client.effect.RunPosableMoLangPacket
+import com.cobblemon.mod.common.net.messages.client.effect.SaccharineLogBlockParticlesPacket
+import com.cobblemon.mod.common.net.messages.client.effect.SpawnSnowstormEntityParticlePacket
+import com.cobblemon.mod.common.net.messages.client.effect.SpawnSnowstormParticlePacket
 import com.cobblemon.mod.common.net.messages.client.npc.CloseNPCEditorPacket
 import com.cobblemon.mod.common.net.messages.client.npc.OpenNPCEditorPacket
 import com.cobblemon.mod.common.net.messages.client.orientation.ClientboundUpdateDriverInputPacket
 import com.cobblemon.mod.common.net.messages.client.orientation.ClientboundUpdateOrientationPacket
-import com.cobblemon.mod.common.net.messages.client.pasture.*
+import com.cobblemon.mod.common.net.messages.client.pasture.ClosePasturePacket
+import com.cobblemon.mod.common.net.messages.client.pasture.OpenPasturePacket
+import com.cobblemon.mod.common.net.messages.client.pasture.PokemonPasturedPacket
+import com.cobblemon.mod.common.net.messages.client.pasture.PokemonUnpasturedPacket
+import com.cobblemon.mod.common.net.messages.client.pasture.UpdatePastureConflictFlagPacket
 import com.cobblemon.mod.common.net.messages.client.pokedex.ServerConfirmedRegisterPacket
 import com.cobblemon.mod.common.net.messages.client.pokemon.update.*
 import com.cobblemon.mod.common.net.messages.client.pokemon.update.evolution.AddEvolutionPacket
@@ -94,19 +116,43 @@ import com.cobblemon.mod.common.net.messages.client.storage.party.InitializePart
 import com.cobblemon.mod.common.net.messages.client.storage.party.MoveClientPartyPokemonPacket
 import com.cobblemon.mod.common.net.messages.client.storage.party.SetPartyPokemonPacket
 import com.cobblemon.mod.common.net.messages.client.storage.party.SetPartyReferencePacket
-import com.cobblemon.mod.common.net.messages.client.storage.pc.*
+import com.cobblemon.mod.common.net.messages.client.storage.pc.ClosePCPacket
+import com.cobblemon.mod.common.net.messages.client.storage.pc.InitializePCPacket
+import com.cobblemon.mod.common.net.messages.client.storage.pc.MoveClientPCPokemonPacket
+import com.cobblemon.mod.common.net.messages.client.storage.pc.OpenPCPacket
+import com.cobblemon.mod.common.net.messages.client.storage.pc.RenamePCBoxPacket
+import com.cobblemon.mod.common.net.messages.client.storage.pc.SetPCBoxPacket
+import com.cobblemon.mod.common.net.messages.client.storage.pc.SetPCPokemonPacket
 import com.cobblemon.mod.common.net.messages.client.storage.pc.wallpaper.ChangePCBoxWallpaperPacket
 import com.cobblemon.mod.common.net.messages.client.storage.pc.wallpaper.RequestPCBoxWallpapersPacket
 import com.cobblemon.mod.common.net.messages.client.storage.pc.wallpaper.SetPCBoxWallpapersPacket
 import com.cobblemon.mod.common.net.messages.client.storage.pc.wallpaper.UnlockPCBoxWallpaperPacket
 import com.cobblemon.mod.common.net.messages.client.toast.ToastPacket
-import com.cobblemon.mod.common.net.messages.client.trade.*
+import com.cobblemon.mod.common.net.messages.client.trade.TradeAcceptanceChangedPacket
+import com.cobblemon.mod.common.net.messages.client.trade.TradeCancelledPacket
+import com.cobblemon.mod.common.net.messages.client.trade.TradeCompletedPacket
+import com.cobblemon.mod.common.net.messages.client.trade.TradeOfferExpiredPacket
+import com.cobblemon.mod.common.net.messages.client.trade.TradeOfferNotificationPacket
+import com.cobblemon.mod.common.net.messages.client.trade.TradeProcessStartedPacket
+import com.cobblemon.mod.common.net.messages.client.trade.TradeStartedPacket
+import com.cobblemon.mod.common.net.messages.client.trade.TradeUpdatedPacket
 import com.cobblemon.mod.common.net.messages.client.ui.ExpGainedDataPacket
 import com.cobblemon.mod.common.net.messages.client.ui.InteractPokemonUIPacket
 import com.cobblemon.mod.common.net.messages.client.ui.PokedexUIPacket
 import com.cobblemon.mod.common.net.messages.client.ui.SummaryUIPacket
-import com.cobblemon.mod.common.net.messages.server.*
-import com.cobblemon.mod.common.net.messages.server.battle.*
+import com.cobblemon.mod.common.net.messages.server.BattleChallengePacket
+import com.cobblemon.mod.common.net.messages.server.BattleChallengeResponsePacket
+import com.cobblemon.mod.common.net.messages.server.BenchMovePacket
+import com.cobblemon.mod.common.net.messages.server.RequestMoveSwapPacket
+import com.cobblemon.mod.common.net.messages.server.RequestPlayerInteractionsPacket
+import com.cobblemon.mod.common.net.messages.server.SelectStarterPacket
+import com.cobblemon.mod.common.net.messages.server.SendOutPokemonPacket
+import com.cobblemon.mod.common.net.messages.server.battle.BattleSelectActionsPacket
+import com.cobblemon.mod.common.net.messages.server.battle.BattleTeamLeavePacket
+import com.cobblemon.mod.common.net.messages.server.battle.BattleTeamRequestPacket
+import com.cobblemon.mod.common.net.messages.server.battle.BattleTeamResponsePacket
+import com.cobblemon.mod.common.net.messages.server.battle.RemoveSpectatorPacket
+import com.cobblemon.mod.common.net.messages.server.battle.SpectateBattlePacket
 import com.cobblemon.mod.common.net.messages.server.behaviour.DamageOnCollisionPacket
 import com.cobblemon.mod.common.net.messages.server.behaviour.SetEntityBehaviourPacket
 import com.cobblemon.mod.common.net.messages.server.block.AdjustBlockEntityViewerCountPacket
@@ -131,7 +177,11 @@ import com.cobblemon.mod.common.net.messages.server.pasture.UnpasturePokemonPack
 import com.cobblemon.mod.common.net.messages.server.pokedex.scanner.FinishScanningPacket
 import com.cobblemon.mod.common.net.messages.server.pokedex.scanner.StartScanningPacket
 import com.cobblemon.mod.common.net.messages.server.pokemon.interact.InteractPokemonPacket
-import com.cobblemon.mod.common.net.messages.server.pokemon.update.*
+import com.cobblemon.mod.common.net.messages.server.pokemon.update.ServerboundUpdateRidingStatePacket
+import com.cobblemon.mod.common.net.messages.server.pokemon.update.SetActiveMarkPacket
+import com.cobblemon.mod.common.net.messages.server.pokemon.update.SetItemHiddenPacket
+import com.cobblemon.mod.common.net.messages.server.pokemon.update.SetMarkingsPacket
+import com.cobblemon.mod.common.net.messages.server.pokemon.update.SetNicknamePacket
 import com.cobblemon.mod.common.net.messages.server.pokemon.update.evolution.AcceptEvolutionPacket
 import com.cobblemon.mod.common.net.messages.server.riding.DismountPokemonPacket
 import com.cobblemon.mod.common.net.messages.server.riding.ServerboundUpdateDriverInputPacket
@@ -142,11 +192,21 @@ import com.cobblemon.mod.common.net.messages.server.storage.party.MovePartyPokem
 import com.cobblemon.mod.common.net.messages.server.storage.party.ReleasePartyPokemonPacket
 import com.cobblemon.mod.common.net.messages.server.storage.party.SwapPartyPokemonPacket
 import com.cobblemon.mod.common.net.messages.server.storage.pc.*
-import com.cobblemon.mod.common.net.messages.server.trade.*
+import com.cobblemon.mod.common.net.messages.server.trade.AcceptTradeRequestPacket
+import com.cobblemon.mod.common.net.messages.server.trade.CancelTradePacket
+import com.cobblemon.mod.common.net.messages.server.trade.ChangeTradeAcceptancePacket
+import com.cobblemon.mod.common.net.messages.server.trade.OfferTradePacket
+import com.cobblemon.mod.common.net.messages.server.trade.PerformTradePacket
+import com.cobblemon.mod.common.net.messages.server.trade.UpdateTradeOfferPacket
 import com.cobblemon.mod.common.net.serverhandling.ChallengeHandler
 import com.cobblemon.mod.common.net.serverhandling.ChallengeResponseHandler
 import com.cobblemon.mod.common.net.serverhandling.RequestInteractionsHandler
-import com.cobblemon.mod.common.net.serverhandling.battle.*
+import com.cobblemon.mod.common.net.serverhandling.battle.BattleSelectActionsHandler
+import com.cobblemon.mod.common.net.serverhandling.battle.RemoveSpectatorHandler
+import com.cobblemon.mod.common.net.serverhandling.battle.SpectateBattleHandler
+import com.cobblemon.mod.common.net.serverhandling.battle.TeamLeaveHandler
+import com.cobblemon.mod.common.net.serverhandling.battle.TeamRequestHandler
+import com.cobblemon.mod.common.net.serverhandling.battle.TeamRequestResponseHandler
 import com.cobblemon.mod.common.net.serverhandling.behaviour.DamageOnCollisionPacketHandler
 import com.cobblemon.mod.common.net.serverhandling.behaviour.SetEntityBehaviourHandler
 import com.cobblemon.mod.common.net.serverhandling.block.AdjustBlockEntityViewerCountHandler
@@ -172,7 +232,11 @@ import com.cobblemon.mod.common.net.serverhandling.pasture.UnpasturePokemonHandl
 import com.cobblemon.mod.common.net.serverhandling.pokedex.scanner.FinishScanningHandler
 import com.cobblemon.mod.common.net.serverhandling.pokedex.scanner.StartScanningHandler
 import com.cobblemon.mod.common.net.serverhandling.pokemon.interact.InteractPokemonHandler
-import com.cobblemon.mod.common.net.serverhandling.pokemon.update.*
+import com.cobblemon.mod.common.net.serverhandling.pokemon.update.ServerboundUpdateRidingStateHandler
+import com.cobblemon.mod.common.net.serverhandling.pokemon.update.SetActiveMarkHandler
+import com.cobblemon.mod.common.net.serverhandling.pokemon.update.SetItemHiddenHandler
+import com.cobblemon.mod.common.net.serverhandling.pokemon.update.SetMarkingsHandler
+import com.cobblemon.mod.common.net.serverhandling.pokemon.update.SetNicknameHandler
 import com.cobblemon.mod.common.net.serverhandling.riding.DismountPokemonPacketHandler
 import com.cobblemon.mod.common.net.serverhandling.riding.DriverInputPacketHandler
 import com.cobblemon.mod.common.net.serverhandling.riding.ServerboundUpdateRiderRotationHandler
@@ -186,7 +250,12 @@ import com.cobblemon.mod.common.net.serverhandling.storage.party.MovePartyPokemo
 import com.cobblemon.mod.common.net.serverhandling.storage.party.ReleasePCPokemonHandler
 import com.cobblemon.mod.common.net.serverhandling.storage.party.SwapPartyPokemonHandler
 import com.cobblemon.mod.common.net.serverhandling.storage.pc.*
-import com.cobblemon.mod.common.net.serverhandling.trade.*
+import com.cobblemon.mod.common.net.serverhandling.trade.AcceptTradeRequestHandler
+import com.cobblemon.mod.common.net.serverhandling.trade.CancelTradeHandler
+import com.cobblemon.mod.common.net.serverhandling.trade.ChangeTradeAcceptanceHandler
+import com.cobblemon.mod.common.net.serverhandling.trade.OfferTradeHandler
+import com.cobblemon.mod.common.net.serverhandling.trade.PerformTradeHandler
+import com.cobblemon.mod.common.net.serverhandling.trade.UpdateTradeOfferHandler
 import com.cobblemon.mod.common.util.server
 import net.minecraft.server.level.ServerPlayer

@@ -332,7 +401,6 @@ object CobblemonNetwork {
        // Data registries
        list.add(PacketRegisterInfo(AbilityRegistrySyncPacket.ID, AbilityRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
        list.add(PacketRegisterInfo(CobblemonMechanicsSyncPacket.ID, CobblemonMechanicsSyncPacket::decode, CobblemonMechanicsSyncHandler))
-        list.add(PacketRegisterInfo(PokemonInteractionsSyncPacket.ID, PokemonInteractionsSyncPacket::decode, PokemonInteractionsSyncHandler))
        list.add(PacketRegisterInfo(MovesRegistrySyncPacket.ID, MovesRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
        list.add(PacketRegisterInfo(BerryRegistrySyncPacket.ID, BerryRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
        list.add(PacketRegisterInfo(SpeciesRegistrySyncPacket.ID, SpeciesRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
@@ -0,0 +1,47 @@
+/*
+ * 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.data.JsonDataRegistry
+import com.cobblemon.mod.common.api.npc.PartyComposition
+import com.cobblemon.mod.common.api.reactive.SimpleObservable
+import com.cobblemon.mod.common.util.adapters.IdentifierAdapter
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+import com.google.gson.reflect.TypeToken
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.server.packs.PackType
+
+object CobblemonPartyCompositions : JsonDataRegistry<PartyComposition> {
+    override val id: ResourceLocation = cobblemonResource("party_compositions")
+    override val type = PackType.SERVER_DATA
+    override val typeToken: TypeToken<PartyComposition> = TypeToken.get(PartyComposition::class.java)
+    override val resourcePath: String = "party_compositions"
+    override val observable = SimpleObservable<CobblemonPartyCompositions>()
+    override val gson: Gson = GsonBuilder()
+        .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
+        .setPrettyPrinting()
+        .create()
+
+    val partyCompositions = mutableMapOf<ResourceLocation, PartyComposition>()
+
+    override fun sync(player: ServerPlayer) {
+        // probably worth syncing which exist, yeah. the deeper details probably not. I'll get to this eventually.
+    }
+
+    override fun reload(data: Map<ResourceLocation, PartyComposition>) {
+        data.entries.forEach { it.value.id = it.key }
+        partyCompositions.clear()
+        partyCompositions.putAll(data)
+        observable.emit(this)
+        Cobblemon.LOGGER.info("Loaded ${data.size} party compositions.")
+    }
+}
@@ -0,0 +1,60 @@
+/*
+ * 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.data.JsonDataRegistry
+import com.cobblemon.mod.common.api.molang.ExpressionLike
+import com.cobblemon.mod.common.api.moves.MovesetBuilder
+import com.cobblemon.mod.common.api.npc.PartyPool
+import com.cobblemon.mod.common.api.pokemon.PokemonProperties
+import com.cobblemon.mod.common.api.reactive.SimpleObservable
+import com.cobblemon.mod.common.util.ScriptableIntRange
+import com.cobblemon.mod.common.util.adapters.ExpressionLikeAdapter
+import com.cobblemon.mod.common.util.adapters.IdentifierAdapter
+import com.cobblemon.mod.common.util.adapters.IntRangeAdapter
+import com.cobblemon.mod.common.util.adapters.MovesetBuilderReferenceAdapter
+import com.cobblemon.mod.common.util.adapters.PokemonPropertiesAdapter
+import com.cobblemon.mod.common.util.adapters.ScriptableIntRangeAdapter
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+import com.google.gson.reflect.TypeToken
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.server.packs.PackType
+
+object CobblemonPartyPools : JsonDataRegistry<PartyPool> {
+    override val id: ResourceLocation = cobblemonResource("party_pools")
+    override val type = PackType.SERVER_DATA
+    override val typeToken: TypeToken<PartyPool> = TypeToken.get(PartyPool::class.java)
+    override val resourcePath: String = "party_pools"
+    override val observable = SimpleObservable<CobblemonPartyPools>()
+    override val gson: Gson = GsonBuilder()
+        .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
+        .registerTypeAdapter(PokemonProperties::class.java, PokemonPropertiesAdapter(saveLong = false))
+        .registerTypeAdapter(IntRange::class.java, IntRangeAdapter)
+        .registerTypeAdapter(ScriptableIntRange::class.java, ScriptableIntRangeAdapter)
+        .registerTypeAdapter(MovesetBuilder::class.java, MovesetBuilderReferenceAdapter)
+        .registerTypeAdapter(ExpressionLike::class.java, ExpressionLikeAdapter)
+        .setPrettyPrinting()
+        .create()
+
+    val partyPools = mutableMapOf<ResourceLocation, PartyPool>()
+
+    override fun sync(player: ServerPlayer) {
+        // probably worth syncing. Knowing the details might help exploit the server? lot of effort for little though.
+    }
+
+    override fun reload(data: Map<ResourceLocation, PartyPool>) {
+        data.entries.forEach { it.value.id = it.key }
+        partyPools.clear()
+        partyPools.putAll(data)
+        observable.emit(this)
+    }
+}
@@ -1,22 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.api.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
-}
@@ -1,27 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.api.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
-}
@@ -1,33 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.api.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
-    }
-}
@@ -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,12 +51,7 @@ object PokemonInteractions : JsonDataRegistry<PokemonInteractionSet> {
    val speciesInteractions = mutableListOf<PokemonInteractionSet>()
    val generalInteractions = mutableListOf<PokemonInteractionSet>()

-    override fun sync(player: ServerPlayer) {
-        PokemonInteractionsSyncPacket(
-            speciesInteractions,
-            generalInteractions,
-        ).sendToPlayer(player)
-    }
+    override fun sync(player: ServerPlayer) {}

    override fun reload(data: Map<ResourceLocation, PokemonInteractionSet>) {
        speciesInteractions.clear()
@@ -15,10 +15,11 @@ 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.pokemon.adapters.CobblemonRequirementAdapter
-import com.cobblemon.mod.common.util.*
+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 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
@@ -27,83 +28,30 @@ 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(),
-) {
-    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,
-            )
-        }
-    }
-}
-
+    val interactions: List<PokemonInteraction> = listOf()
+)
 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)
@@ -120,14 +68,12 @@ class DropItemEffect(val item: ResourceLocation, val amount: IntRange?) : Intera
    }
 }

-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)
@@ -140,29 +86,14 @@ class GiveItemEffect(val item: ResourceLocation, val amount: IntRange?) : Intera
    }
 }

-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)
        }
@@ -173,7 +104,7 @@ class PlaySoundEffect(
    }
 }

-class ShrinkItemEffect(val amount: Int = 1) : InteractionEffect {
+class ShrinkItemEffect(val amount: Int = 1): InteractionEffect {
    override fun applyEffect(
        pokemon: PokemonEntity,
        player: ServerPlayer
@@ -189,7 +120,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
@@ -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 ?: emptyMap()) + args.mapIndexed { index, value -> "arg_${index + 1}" to value }.toMap()
+                params.environment.context.map + args.mapIndexed { index, value -> "arg_${index + 1}" to value }.toMap()
            )
            val script = params.getString(0).asIdentifierDefaultingNamespace()
            // store the args in the
@@ -779,20 +779,6 @@ 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
        }
@@ -1753,35 +1739,22 @@ 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)
-                        appliedMark = true
-                    }
+                    if (mark != null) pokemon.exchangeMark(mark, 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)
-                            appliedMark = true
-                        }
+                        if (randomValue < probability) pokemon.exchangeMark(it, true)
                    }
                }
-
-                DoubleValue(appliedMark)
            }
            map.put("add_potential_marks") { params ->
                for (param in params.params) {
@@ -1851,8 +1824,7 @@ object MoLangFunctions {
                return@put DoubleValue(if (pokemon.addRideBoost(stat, value)) 1.0 else 0.0)
            }
            map.put("initialize_moveset") { params ->
-                val preferLatest = params.getBooleanOrNull(0) ?: true
-                pokemon.initializeMoveset(preferLatest)
+                pokemon.initializeMovesetFromDefault()
                return@put DoubleValue.ONE
            }
            map.put("validate_moveset") { params ->
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.moves
+
+import com.cobblemon.mod.common.pokemon.FormData
+import com.cobblemon.mod.common.util.cobblemonResource
+import net.minecraft.resources.ResourceLocation
+
+/**
+ * This is all you need tbh. A moveset builder that picks moves from up to 4 slots of move selectors.
+ *
+ * @author Hiroku
+ * @since December 5th, 2025
+ */
+class DefaultMovesetBuilder : MovesetBuilder {
+    companion object {
+        val TYPE = cobblemonResource("default")
+    }
+
+    override val type: ResourceLocation = TYPE
+    override var id: ResourceLocation = cobblemonResource("temp") // replaced on load.
+
+    val slot1: List<MoveSelector> = listOf()
+    val slot2: List<MoveSelector> = listOf()
+    val slot3: List<MoveSelector> = listOf()
+    val slot4: List<MoveSelector> = listOf()
+
+    override fun build(form: FormData, level: Int): MoveSet {
+        val chosenMoves = mutableSetOf<MoveTemplate>()
+        tryAddMoveFromSlot(form, level, slot1, chosenMoves)
+        tryAddMoveFromSlot(form, level, slot2, chosenMoves)
+        tryAddMoveFromSlot(form, level, slot3, chosenMoves)
+        tryAddMoveFromSlot(form, level, slot4, chosenMoves)
+        if (chosenMoves.isEmpty()) {
+            chosenMoves.add(Moves.getExceptional())
+        }
+        val moveset = MoveSet()
+        chosenMoves.map(MoveTemplate::create).forEach(moveset::add)
+        return moveset
+    }
+
+    fun tryAddMoveFromSlot(form: FormData, level: Int, selectors: List<MoveSelector>, chosenMoves: MutableSet<MoveTemplate>) {
+        for (selector in selectors) {
+            val move = selector(form, form.moves, level, chosenMoves)
+            if (move != null) {
+                chosenMoves.add(move)
+                return
+            }
+        }
+    }
+}
@@ -0,0 +1,148 @@
+/*
+ * 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.moves
+
+import com.cobblemon.mod.common.api.moves.categories.DamageCategories
+import com.cobblemon.mod.common.api.pokemon.moves.Learnset
+import com.cobblemon.mod.common.api.pokemon.stats.Stats
+import com.cobblemon.mod.common.pokemon.FormData
+import com.cobblemon.mod.common.util.weightedSelection
+
+/**
+ * A function that selects a move from a given [Learnset] for a particular [FormData] at a certain level,
+ * taking into account any moves that have already been chosen for the moveset.
+ *
+ * @author Hiroku
+ * @since December 5th, 2025
+ */
+fun interface MoveSelector {
+    operator fun invoke(form: FormData, learnset: Learnset, level: Int, chosenMoves: Set<MoveTemplate>): MoveTemplate?
+
+    companion object {
+        val NONE = MoveSelector { _, _, _, _ -> null }
+        val LAST_LEVELUP = MoveSelector { form, learnset, level, chosenMoves ->
+            val levels = learnset.levelUpMoves.keys.filter { it <= level }.sortedDescending()
+            levels.forEach {
+                val moves = (learnset.levelUpMoves[it] ?: return@forEach) - chosenMoves
+                if (moves.isNotEmpty()) {
+                    return@MoveSelector moves.weightedSelection { it.getSelectionWeight(form) }
+                }
+            }
+            return@MoveSelector null
+        }
+        val LAST_OFFENSIVE = MoveSelector { form, learnset, level, chosenMoves ->
+            val levels = learnset.levelUpMoves.keys.filter { it <= level }.sortedDescending()
+            levels.forEach {
+                val moves = (learnset.levelUpMoves[it]?.filter { it.damageCategory != DamageCategories.STATUS } ?: return@forEach) - chosenMoves
+                if (moves.isNotEmpty()) {
+                    return@MoveSelector moves.weightedSelection { it.getSelectionWeight(form) }
+                }
+            }
+            return@MoveSelector null
+        }
+        val LAST_SUITABLE_OFFENSIVE = MoveSelector { form, learnset, level, chosenMoves ->
+            val levels = learnset.levelUpMoves.keys.filter { it <= level }.sortedDescending()
+            val suitableCategories = if (form.baseStats[Stats.ATTACK]!! > form.baseStats[Stats.SPECIAL_ATTACK]!!) {
+                setOf(DamageCategories.PHYSICAL)
+            } else if (form.baseStats[Stats.SPECIAL_ATTACK]!! > form.baseStats[Stats.ATTACK]!!) {
+                setOf(DamageCategories.SPECIAL)
+            } else {
+                setOf(DamageCategories.PHYSICAL, DamageCategories.SPECIAL)
+            }
+            levels.forEach {
+                val moves = (learnset.levelUpMoves[it]?.filter { it.damageCategory in suitableCategories } ?: return@forEach) - chosenMoves
+                if (moves.isNotEmpty()) {
+                    return@MoveSelector moves.weightedSelection { it.getSelectionWeight(form) }
+                }
+            }
+            return@MoveSelector null
+        }
+        val LAST_STATUS = MoveSelector { form, learnset, level, chosenMoves ->
+            val levels = learnset.levelUpMoves.keys.filter { it <= level }.sortedDescending()
+            levels.forEach {
+                val moves = (learnset.levelUpMoves[it]?.filter { it.damageCategory == DamageCategories.STATUS } ?: return@forEach) - chosenMoves
+                if (moves.isNotEmpty()) {
+                    return@MoveSelector moves.weightedSelection { it.getSelectionWeight(form) }
+                }
+            }
+            return@MoveSelector null
+        }
+        val STAB = MoveSelector { form, learnset, level, chosenMoves ->
+            val moves = learnset.getLevelUpMovesUpTo(level) - chosenMoves
+            val stabMoves = moves.filter { it.elementalType in form.types && it.damageCategory != DamageCategories.STATUS }
+            return@MoveSelector stabMoves.weightedSelection { it.getSelectionWeight(form) }
+        }
+        val STAB_PHYSICAL = MoveSelector { form, learnset, level, chosenMoves ->
+            val moves = learnset.getLevelUpMovesUpTo(level) - chosenMoves
+            val stabMoves = moves.filter { it.elementalType in form.types && it.damageCategory == DamageCategories.PHYSICAL }
+            return@MoveSelector stabMoves.weightedSelection { it.getSelectionWeight(form) }
+        }
+        val STAB_SPECIAL = MoveSelector { form, learnset, level, chosenMoves ->
+            val moves = learnset.getLevelUpMovesUpTo(level) - chosenMoves
+            val stabMoves = moves.filter { it.elementalType in form.types && it.damageCategory == DamageCategories.SPECIAL }
+            return@MoveSelector stabMoves.weightedSelection { it.getSelectionWeight(form) }
+        }
+        val PHYSICAL = MoveSelector { form, learnset, level, chosenMoves ->
+            val moves = learnset.getLevelUpMovesUpTo(level) - chosenMoves
+            val physicalMoves = moves.filter { it.damageCategory == DamageCategories.PHYSICAL }
+            return@MoveSelector physicalMoves.weightedSelection { it.getSelectionWeight(form) }
+        }
+        val SPECIAL = MoveSelector { form, learnset, level, chosenMoves ->
+            val moves = learnset.getLevelUpMovesUpTo(level) - chosenMoves
+            val specialMoves = moves.filter { it.damageCategory == DamageCategories.SPECIAL }
+            return@MoveSelector specialMoves.weightedSelection { it.getSelectionWeight(form) }
+        }
+        val OFFENSIVE = MoveSelector { form, learnset, level, chosenMoves ->
+            val moves = learnset.getLevelUpMovesUpTo(level) - chosenMoves
+            val offensiveMoves = moves.filter { it.damageCategory != DamageCategories.STATUS }
+            return@MoveSelector offensiveMoves.weightedSelection { it.getSelectionWeight(form) }
+        }
+        val RANDOM_LEVELUP = MoveSelector { form, learnset, level, chosenMoves ->
+            val moves = learnset.getLevelUpMovesUpTo(level) - chosenMoves
+            return@MoveSelector moves.weightedSelection { it.getSelectionWeight(form) }
+        }
+        val STATUS = MoveSelector { form, learnset, level, chosenMoves ->
+            val moves = learnset.getLevelUpMovesUpTo(level) - chosenMoves
+            val statusMoves = moves.filter { it.damageCategory == DamageCategories.STATUS }
+            return@MoveSelector statusMoves.weightedSelection { it.getSelectionWeight(form) }
+        }
+        val TM = MoveSelector { form, learnset, level, chosenMoves ->
+            val moves = learnset.tmMoves - chosenMoves - learnset.getLevelUpMovesUpTo(level)
+            return@MoveSelector moves.weightedSelection { it.getSelectionWeight(form) }
+        }
+        val STAB_TM = MoveSelector { form, learnset, level, chosenMoves ->
+            val moves = learnset.tmMoves - chosenMoves - learnset.getLevelUpMovesUpTo(level)
+            val stabMoves = moves.filter { it.elementalType in form.types }
+            return@MoveSelector stabMoves.weightedSelection { it.getSelectionWeight(form) }
+        }
+        val EGG = MoveSelector { form, learnset, level, chosenMoves ->
+            val moves = learnset.eggMoves - chosenMoves - learnset.getLevelUpMovesUpTo(level)
+            return@MoveSelector moves.weightedSelection { it.getSelectionWeight(form) }
+        }
+
+        val selectors = mutableMapOf(
+            "none" to NONE,
+            "last_levelup" to LAST_LEVELUP,
+            "last_offensive" to LAST_OFFENSIVE,
+            "last_suitable_offensive" to LAST_SUITABLE_OFFENSIVE,
+            "last_status" to LAST_STATUS,
+            "levelup" to RANDOM_LEVELUP,
+            "stab" to STAB,
+            "stab_physical" to STAB_PHYSICAL,
+            "stab_special" to STAB_SPECIAL,
+            "physical" to PHYSICAL,
+            "special" to SPECIAL,
+            "offensive" to OFFENSIVE,
+            "status" to STATUS,
+            "tm" to TM,
+            "stab_tm" to STAB_TM,
+            "egg" to EGG
+        )
+    }
+}
@@ -12,12 +12,12 @@ import com.bedrockk.molang.runtime.struct.MoStruct
 import com.bedrockk.molang.runtime.struct.QueryStruct
 import com.bedrockk.molang.runtime.value.DoubleValue
 import com.bedrockk.molang.runtime.value.StringValue
-import com.cobblemon.mod.common.api.moves.animations.ActionEffectTimeline
 import com.cobblemon.mod.common.api.moves.categories.DamageCategories
 import com.cobblemon.mod.common.api.moves.categories.DamageCategory
 import com.cobblemon.mod.common.api.types.ElementalType
 import com.cobblemon.mod.common.api.types.ElementalTypes
 import com.cobblemon.mod.common.battles.MoveTarget
+import com.cobblemon.mod.common.pokemon.FormData
 import com.cobblemon.mod.common.util.codec.CodecUtils
 import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.util.lang
@@ -53,7 +53,8 @@ open class MoveTemplate(
    val pp: Int,
    val priority: Int,
    val critRatio: Double,
-    val effectChances: Array<Double>
+    val effectChances: Array<Double>,
+    val weight: Float
 ) {
    val struct: MoStruct by lazy {
        QueryStruct(hashMapOf())
@@ -66,9 +67,9 @@ open class MoveTemplate(
            .addFunction("pp") { DoubleValue(pp) }
            .addFunction("priority") { DoubleValue(priority) }
            .addFunction("crit_ratio") { DoubleValue(critRatio) }
+            .addFunction("weight") { DoubleValue(weight.toDouble()) }
    }

-
    val displayName: MutableComponent
        get() = lang("move.$name")
    val description: MutableComponent
@@ -86,7 +87,8 @@ open class MoveTemplate(
        pp = 5,
        priority = 0,
        critRatio = 0.0,
-        effectChances = emptyArray()
+        effectChances = emptyArray(),
+        weight = 0F,
    )

    companion object {
@@ -157,4 +159,12 @@ open class MoveTemplate(
        }
        return this.elementalType
    }
+
+    fun getSelectionWeight(form: FormData): Float {
+        return if (this in form.signatureMoves) {
+            weight * MovesetBuilder.signatureMoveWeightMultiplier
+        } else {
+            weight
+        }
+    }
 }
@@ -10,15 +10,15 @@ package com.cobblemon.mod.common.api.moves

 import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.api.data.DataRegistry
-import com.cobblemon.mod.common.api.moves.animations.ActionEffects
 import com.cobblemon.mod.common.api.moves.categories.DamageCategories
 import com.cobblemon.mod.common.api.reactive.SimpleObservable
 import com.cobblemon.mod.common.api.types.ElementalTypes
 import com.cobblemon.mod.common.battles.MoveTarget
 import com.cobblemon.mod.common.battles.runner.ShowdownService
 import com.cobblemon.mod.common.net.messages.client.data.MovesRegistrySyncPacket
-import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
 import com.cobblemon.mod.common.util.cobblemonResource
+import com.cobblemon.mod.common.util.fromJson
+import com.google.gson.GsonBuilder
 import com.google.gson.JsonArray
 import com.google.gson.JsonObject
 import net.minecraft.resources.ResourceLocation
@@ -46,6 +46,14 @@ object Moves : DataRegistry {
        this.idMapping.clear()
        this.moveScripts.clear()

+        val weights = mutableMapOf<String, Number>()
+        manager.getResourceStack(cobblemonResource("move_weights.json")).forEach {
+            it.open().use {
+                val map = GsonBuilder().create().fromJson<Map<String, Number>>(it.reader())
+                weights.putAll(map)
+            }
+        }
+
        ShowdownService.service.resetRegistryData("move")
        manager.listResources("moves") { it.path.endsWith(".js") }.forEach { (identifier, resource) ->
            resource.open().use { stream ->
@@ -75,6 +83,7 @@ object Moves : DataRegistry {
                val priority = jsMove.get("priority").asInt
                val critRatio = jsMove.get("critRatio")?.asDouble ?: 1.0
                val effectChances = arrayListOf<Double>()
+                val weight = weights[id]?.toFloat() ?: 50F
                val secondariesMember = jsMove.get("secondaries")
                val secondaryMember = jsMove.get("secondary")
                if (secondariesMember != null && secondariesMember is JsonArray) {
@@ -92,7 +101,20 @@ object Moves : DataRegistry {
                        effectChances += secondaryMember.get("chance").asDouble
                    }
                }
-                val move = MoveTemplate(id, num, elementalType, damageCategory, power, target, accuracy, pp, priority, critRatio, effectChances.toTypedArray())
+                val move = MoveTemplate(
+                    name = id,
+                    num = num,
+                    elementalType = elementalType,
+                    damageCategory = damageCategory,
+                    power = power,
+                    target = target,
+                    accuracy = accuracy,
+                    pp = pp,
+                    priority = priority,
+                    critRatio = critRatio,
+                    effectChances = effectChances.toTypedArray(),
+                    weight = weight
+                )
                this.register(move)
            } catch (e: Exception) {
                Cobblemon.LOGGER.error("Caught exception trying to resolve the move '{}'", id, e)
@@ -113,7 +135,7 @@ object Moves : DataRegistry {
    @JvmStatic
    fun getByNameOrDummy(name: String) = allMoves[name.lowercase()] ?: MoveTemplate.dummy(name.lowercase())
    @JvmStatic
-    fun getExceptional() = getByName("tackle") ?: allMoves.values.random()
+    fun getExceptional() = getByName("tackle") ?: allMoves.values.first()
    @JvmStatic
    fun count() = allMoves.size
    @JvmStatic
@@ -129,5 +151,4 @@ object Moves : DataRegistry {
        this.allMoves[move.name] = move
        this.idMapping[move.num] = move
    }
-
 }
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.moves
+
+import com.cobblemon.mod.common.pokemon.FormData
+import com.cobblemon.mod.common.util.cobblemonResource
+import net.minecraft.resources.ResourceLocation
+
+/**
+ * Builders a moveset for a particular [FormData] and level. Probably only really need [DefaultMovesetBuilder] though.
+ *
+ * @author Hiroku
+ * @since December 5th, 2025
+ */
+interface MovesetBuilder {
+    /** The ID of this builder. It's autofilled from the registry loader. */
+    var id: ResourceLocation
+    /** The subtype designation for this moveset builder. Generally unused once read from JSON. */
+    val type: ResourceLocation
+
+    /** Builds a brand new moveset for the [form] and [level]. */
+    fun build(form: FormData, level: Int): MoveSet
+
+    companion object {
+        /** Weight multiplier for moves that are in the form's signatureMoves list. Makes them way more likely to be chosen. */
+        var signatureMoveWeightMultiplier = 5F
+        /** Subtypes of MovesetBuilder. I personally doubt you'll need any other subtypes, but hey. */
+        val movesetBuilderTypes = mutableMapOf<ResourceLocation, Class<out MovesetBuilder>>(
+            cobblemonResource("default") to DefaultMovesetBuilder::class.java
+        )
+    }
+}
@@ -8,12 +8,14 @@

 package com.cobblemon.mod.common.api.npc

+import com.cobblemon.mod.common.api.npc.partyproviders.ComposedPoolPartyProvider
 import com.cobblemon.mod.common.api.npc.partyproviders.PoolPartyProvider
 import com.cobblemon.mod.common.api.npc.partyproviders.ScriptPartyProvider
 import com.cobblemon.mod.common.api.npc.partyproviders.SimplePartyProvider
 import com.cobblemon.mod.common.api.storage.party.NPCPartyStore
 import com.cobblemon.mod.common.entity.npc.NPCEntity
 import com.google.gson.JsonElement
+import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerPlayer

 /**
@@ -25,14 +27,15 @@ import net.minecraft.server.level.ServerPlayer
 */
 interface NPCPartyProvider {
    companion object {
-        val types = mutableMapOf<String, (String) -> NPCPartyProvider>(
-            SimplePartyProvider.TYPE to { SimplePartyProvider() },
-            PoolPartyProvider.TYPE to { PoolPartyProvider() },
-            ScriptPartyProvider.TYPE to { ScriptPartyProvider() }
+        val types = mutableMapOf(
+            SimplePartyProvider.TYPE to ::SimplePartyProvider,
+            PoolPartyProvider.TYPE to ::PoolPartyProvider,
+            ScriptPartyProvider.TYPE to ::ScriptPartyProvider,
+            ComposedPoolPartyProvider.TYPE to ::ComposedPoolPartyProvider
        )
    }

-    val type: String
+    val type: ResourceLocation
    val isStatic: Boolean
    fun provide(npc: NPCEntity, level: Int, players: List<ServerPlayer> = emptyList()): NPCPartyStore
    // Why did I opt for manual JSON loading??? I must have had a reason but I can't remember. Maybe for S2C? Use a codec doofus
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.npc
+
+import com.bedrockk.molang.runtime.MoLangRuntime
+import com.cobblemon.mod.common.pokemon.Pokemon
+import com.cobblemon.mod.common.util.cobblemonResource
+import kotlin.random.Random
+
+/**
+ * A kind of definition for how to compose a party of Pokémon given a [PartyPool].
+ *
+ * @author Hiroku
+ * @since December 7th, 2025
+ */
+class PartyComposition {
+    var id = cobblemonResource("dummy_composition")
+//    val displayName = "cobblemon.party_composition.$id" // dunno if i will use this yet
+    val scrambleOrder: Boolean = false
+    val slot1 = listOf<String>()
+    val slot2 = listOf<String>()
+    val slot3 = listOf<String>()
+    val slot4 = listOf<String>()
+    val slot5 = listOf<String>()
+    val slot6 = listOf<String>()
+
+    fun compose(pool: PartyPool, level: Int, aspects: Set<String>, desiredPokemonCount: Int, runtime: MoLangRuntime, random: Random = Random.Default): List<Pokemon> {
+        val chosenEntries = mutableListOf<PartyPool.PoolEntry>()
+        val availableEntries = pool.entries.filter { level in it.npcLevels.resolve(runtime) && (it.npcAspects.isEmpty() || it.npcAspects.all(aspects::contains)) }
+
+        for (labelSet in listOf(slot1, slot2, slot3, slot4, slot5, slot6)) {
+            pool.tryChoosingEntry(labelSet, runtime, random, availableEntries, chosenEntries)
+            if (chosenEntries.size >= desiredPokemonCount) {
+                break
+            }
+        }
+
+        val finalEntries = if (scrambleOrder) {
+            chosenEntries.shuffled(random)
+        } else {
+            chosenEntries
+        }
+
+        val pokemon = finalEntries.map { entry ->
+            val levelVariation = entry.levelVariation.resolve(runtime)
+            val lvlVariation = if (levelVariation.first == levelVariation.last) {
+                levelVariation.first
+            } else {
+                levelVariation.random(random)
+            }
+
+            val finalLevel = level + lvlVariation
+            val properties = entry.pokemon.copy()
+            properties.level = properties.level ?: finalLevel
+            val pokemon = properties.create()
+            entry.movesetBuilders.randomOrNull()?.let(pokemon::initializeMovesetFrom)
+            pokemon
+        }
+
+        return pokemon
+    }
+}
@@ -0,0 +1,77 @@
+/*
+ * 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.npc
+
+import com.bedrockk.molang.runtime.MoLangRuntime
+import com.cobblemon.mod.common.api.molang.ExpressionLike
+import com.cobblemon.mod.common.api.moves.MovesetBuilder
+import com.cobblemon.mod.common.api.pokemon.PokemonProperties
+import com.cobblemon.mod.common.util.ScriptableIntRange
+import com.cobblemon.mod.common.util.asExpressionLike
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.cobblemon.mod.common.util.toProperties
+import com.cobblemon.mod.common.util.weightedSelection
+import kotlin.random.Random
+
+/**
+ * A pool of Pokémon to choose from, typically for generating a party for an NPC. The entries
+ * of the pool work on a weight and label system which is used as part of a [PartyComposition].
+ *
+ * @author Hiroku
+ * @since December 7th, 2025
+ */
+class PartyPool {
+    var id = cobblemonResource("dummy")
+    val displayName = "cobblemon.party_pool.$id"
+    val entries = mutableListOf<PoolEntry>()
+
+    class PoolEntry {
+        val pokemon: PokemonProperties = "pikachu".toProperties()
+        val labels: List<String> = emptyList()
+        val npcAspects: List<String> = emptyList()
+        val required: List<String> = emptyList()
+        val incompatible: List<String> = emptyList()
+        val maxSelectableTimes: ExpressionLike = "6".asExpressionLike()
+        val levelVariation: ScriptableIntRange = ScriptableIntRange(0, 0)
+        val npcLevels: ScriptableIntRange = ScriptableIntRange(1, 100)
+        val movesetBuilders: List<MovesetBuilder> = emptyList()
+        val weight: ExpressionLike = "50".asExpressionLike()
+    }
+
+    /**
+     * Goes through each of the labels in order, trying to find a valid choice. Once it finds one, it skips the later
+     * labels and adds the value to [chosenEntries] and returns. If none of the labels could find a valid entry, nothing is added.
+     */
+    fun tryChoosingEntry(
+        labels: List<String>,
+        runtime: MoLangRuntime,
+        random: Random,
+        availableEntries: List<PoolEntry>,
+        chosenEntries: MutableList<PoolEntry>,
+    ) {
+        for (label in labels) {
+            val entries = availableEntries
+                .filter { label in it.labels || label.lowercase() == "any" }
+                .filter { entry ->
+                    // Check required labels
+                    entry.required.all { it in labels } &&
+                            // Check excluded labels
+                            entry.incompatible.none { it in labels } &&
+                            // Check max selectable times
+                            chosenEntries.count { it == entry } < entry.maxSelectableTimes.resolveFloat(runtime)
+                }
+
+            if (entries.isNotEmpty()) {
+                val selectedEntry = entries.weightedSelection(random) { it.weight.resolveFloat(runtime) } ?: return
+                chosenEntries.add(selectedEntry)
+                return
+            }
+        }
+    }
+}
@@ -0,0 +1,94 @@
+/*
+ * 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.npc.partyproviders
+
+import com.bedrockk.molang.Expression
+import com.bedrockk.molang.runtime.MoLangRuntime
+import com.bedrockk.molang.runtime.value.DoubleValue
+import com.cobblemon.mod.common.CobblemonPartyCompositions
+import com.cobblemon.mod.common.CobblemonPartyPools
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.setup
+import com.cobblemon.mod.common.api.npc.NPCPartyProvider
+import com.cobblemon.mod.common.api.npc.PartyComposition
+import com.cobblemon.mod.common.api.npc.PartyPool
+import com.cobblemon.mod.common.api.storage.party.NPCPartyStore
+import com.cobblemon.mod.common.entity.npc.NPCEntity
+import com.cobblemon.mod.common.util.asArrayValue
+import com.cobblemon.mod.common.util.asExpression
+import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.cobblemon.mod.common.util.resolveInt
+import com.cobblemon.mod.common.util.withQueryValue
+import com.google.gson.JsonElement
+import com.google.gson.JsonObject
+import kotlin.random.Random
+import kotlin.ranges.random
+import net.minecraft.server.level.ServerPlayer
+
+/**
+ * An [NPCPartyProvider] which uses a [PartyComposition] and [PartyPool] to generate a party.
+ *
+ * There are controls for minimum and maximum Pokémon count, as well as whether to use a fixed random seed for the NPC.
+ *
+ * @author Hiroku
+ * @since December 8th, 2025
+ */
+class ComposedPoolPartyProvider : NPCPartyProvider {
+    companion object {
+        val TYPE = cobblemonResource("composed_pool")
+    }
+
+    override val type = TYPE
+    override var isStatic: Boolean = true
+    var useFixedRandom: Boolean = false
+    var minPokemon: Expression = "1".asExpression()
+    var maxPokemon: Expression = "6".asExpression()
+    lateinit var pool: PartyPool
+    lateinit var composition: PartyComposition
+
+    override fun loadFromJSON(json: JsonElement) {
+        json as JsonObject
+        isStatic = json.getAsJsonPrimitive("isStatic")?.asBoolean ?: true
+        useFixedRandom = json.getAsJsonPrimitive("useFixedRandom")?.asBoolean ?: false
+        pool = CobblemonPartyPools.partyPools[json.get("pool").asString.asIdentifierDefaultingNamespace()]
+            ?: throw IllegalArgumentException("Unknown PartyPool id: ${json.get("pool").asString}")
+        composition = CobblemonPartyCompositions.partyCompositions[json.get("composition").asString.asIdentifierDefaultingNamespace()]
+            ?: throw IllegalArgumentException("Unknown PartyComposition id: ${json.get("composition").asString}")
+        minPokemon = json.getAsJsonPrimitive("minPokemon").asString?.asExpression() ?: "1".asExpression()
+        maxPokemon = json.getAsJsonPrimitive("maxPokemon").asString?.asExpression() ?: "6".asExpression()
+    }
+
+    override fun provide(npc: NPCEntity, level: Int, players: List<ServerPlayer>): NPCPartyStore {
+        val runtime = MoLangRuntime().setup().withQueryValue("npc", npc.struct)
+        val random = if (useFixedRandom) Random(npc.uuid.hashCode()) else Random.Default
+        runtime.withQueryValue("level", DoubleValue(level))
+        runtime.withQueryValue("players", players.asArrayValue { it.asMoLangValue() })
+        if (players.size == 1) {
+            // This is for the convenience, most cases will be pvn one player
+            runtime.withQueryValue("player", players.first().asMoLangValue())
+        }
+        val minPokemon = runtime.resolveInt(this.minPokemon)
+        val maxPokemon = runtime.resolveInt(this.maxPokemon)
+        val desiredPokemonCount = (minPokemon..maxPokemon).random(random)
+
+        val pokemonList = composition.compose(
+            pool = pool,
+            level = level,
+            aspects = npc.aspects,
+            desiredPokemonCount = desiredPokemonCount,
+            runtime = runtime,
+            random = random
+        )
+
+        val partyStore = NPCPartyStore(npc)
+        pokemonList.forEach(partyStore::add)
+        return partyStore
+    }
+}
@@ -48,7 +48,7 @@ import kotlin.random.Random
 */
 class PoolPartyProvider : NPCPartyProvider {
    companion object {
-        const val TYPE = "pool"
+        val TYPE = cobblemonResource("pool")
    }

    @Transient
@@ -150,10 +150,10 @@ class PoolPartyProvider : NPCPartyProvider {
            val instance = selected.pokemon.copy().also { it.level = it.level ?: dictatedLevel ?: randomLevel }.create()
            party.add(instance)
        }
-        if (party.none()) {
-            LOGGER.error("${npc} has no Pokemon on Party")
-        }

+        if (party.none()) {
+            LOGGER.error("$npc had no Pokémon produced by their party provider")
+        }
    }

    override fun provide(npc: NPCEntity, level: Int, players: List<ServerPlayer>): NPCPartyStore {
@@ -28,7 +28,7 @@ import net.minecraft.server.level.ServerPlayer

 class ScriptPartyProvider : NPCPartyProvider {
    companion object {
-        const val TYPE = "script"
+        val TYPE = cobblemonResource("script")
    }

    override val type = TYPE
@@ -16,6 +16,7 @@ import com.cobblemon.mod.common.api.pokemon.PokemonProperties
 import com.cobblemon.mod.common.api.storage.party.NPCPartyStore
 import com.cobblemon.mod.common.entity.npc.NPCEntity
 import com.cobblemon.mod.common.util.asArrayValue
+import com.cobblemon.mod.common.util.cobblemonResource
 import com.cobblemon.mod.common.util.getBooleanOrNull
 import com.cobblemon.mod.common.util.toProperties
 import com.google.gson.JsonElement
@@ -29,7 +30,7 @@ import net.minecraft.server.level.ServerPlayer
 */
 class SimplePartyProvider : NPCPartyProvider {
    companion object {
-        const val TYPE = "simple"
+        val TYPE = cobblemonResource("simple")
    }

    @Transient
@@ -10,6 +10,7 @@ package com.cobblemon.mod.common.api.pokemon

 import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.Cobblemon.config
+import com.cobblemon.mod.common.CobblemonMovesetBuilders
 import com.cobblemon.mod.common.api.abilities.Abilities
 import com.cobblemon.mod.common.api.abilities.Ability
 import com.cobblemon.mod.common.api.events.CobblemonEvents
@@ -148,6 +149,13 @@ open class PokemonProperties {
            props.originalTrainerType = OriginalTrainerType.entries.toList().parsePropertyOfCollection(keyPairs, listOf("originaltrainertype", "ottype"), labelsOptional = true) { it.name.lowercase() }
            props.originalTrainer = parsePlayerProperty(keyPairs, listOf("originaltrainer", "ot"))
            props.moves = parseString(keyPairs, listOf("moves"))?.split(",")
+            props.movesetBuilders = parseString(keyPairs, listOf("moveset_builders", "movesetbuilders", "moveset_builder", "movesetbuilder"))?.split(",")?.mapNotNull {
+                try {
+                    it.asIdentifierDefaultingNamespace()
+                } catch (_: ResourceLocationException) {
+                    null
+                }
+            }
            props.heldItem = parseString(keyPairs, listOf("helditem", "held_item"))
            props.minPerfectIVs = parseIntProperty(keyPairs, listOf("min_perfect_ivs"))?.coerceIn(0, Stats.PERMANENT.size)
            props.scaleModifier = parseFloatProperty(keyPairs, listOf("scale_modifier"))
@@ -356,6 +364,7 @@ open class PokemonProperties {
    var originalTrainerType: OriginalTrainerType? = null
    var originalTrainer: String? = null // Original Trainer by Username or UUID
    var moves: List<String>? = null
+    var movesetBuilders: List<ResourceLocation>? = null
    var heldItem: String? = null
    var cosmeticItem: String? = null
    var scaleModifier: Float? = null
@@ -462,7 +471,7 @@ open class PokemonProperties {
        }
        moves?.let { moves ->
            if (pokemon.moveSet.getMoves().isEmpty()) {
-                pokemon.initializeMoveset(preferLatest = true)
+                pokemon.initializeMovesetFromDefault()
            }
            val moveTemplates = moves.mapNotNull(Moves::getByName).shuffled()
            val replaceableIndices = (0..3).filterNot { pokemon.moveSet[it]?.template?.let(moveTemplates::contains) == true }.shuffled()
@@ -475,6 +484,13 @@ open class PokemonProperties {
                pokemon.moveSet.update()
            }
        }
+        movesetBuilders?.let { movesetBuilders ->
+            val builders = movesetBuilders.mapNotNull { CobblemonMovesetBuilders.movesetBuilders[it] }
+            if (builders.isNotEmpty()) {
+                val movesetBuilder = builders.random()
+                pokemon.initializeMovesetFrom(movesetBuilder)
+            }
+        }
        heldItem?.let { itemKey ->
            val server = server() ?: return@let
            val parser = ItemParser(server.registryAccess())
@@ -678,6 +694,7 @@ open class PokemonProperties {
        originalTrainerType?.let { nbt.putInt(DataKeys.POKEMON_ORIGINAL_TRAINER_TYPE, it.ordinal) }
        originalTrainer?.let { nbt.putString(DataKeys.POKEMON_ORIGINAL_TRAINER, it) }
        moves?.let { nbt.putString(DataKeys.POKEMON_PROPERTIES_MOVES, it.joinToString(separator = ",")) }
+        movesetBuilders?.let { nbt.putString(DataKeys.POKEMON_PROPERTIES_MOVESET_BUILDERS, it.joinToString(separator = ",") { source -> source.toString() }) }
        heldItem?.let {nbt.putString(DataKeys.POKEMON_PROPERTIES_HELDITEM, it)}
        scaleModifier?.let { nbt.putFloat(DataKeys.POKEMON_SCALE_MODIFIER, it) }
        val custom = ListTag()
@@ -712,6 +729,7 @@ open class PokemonProperties {
        originalTrainerType = if (tag.contains(DataKeys.POKEMON_ORIGINAL_TRAINER_TYPE)) OriginalTrainerType.valueOf(tag.getString(DataKeys.POKEMON_ORIGINAL_TRAINER_TYPE)) else null
        originalTrainer = if (tag.contains(DataKeys.POKEMON_ORIGINAL_TRAINER)) tag.getString(DataKeys.POKEMON_ORIGINAL_TRAINER) else null
        moves = if (tag.contains(DataKeys.POKEMON_PROPERTIES_MOVES)) tag.getString(DataKeys.POKEMON_PROPERTIES_MOVES).split(",") else null
+        movesetBuilders = if (tag.contains(DataKeys.POKEMON_PROPERTIES_MOVESET_BUILDERS)) tag.getString(DataKeys.POKEMON_PROPERTIES_MOVESET_BUILDERS).split(",").map { it.asIdentifierDefaultingNamespace() } else null
        heldItem = if (tag.contains(DataKeys.POKEMON_PROPERTIES_HELDITEM)) tag.getString(DataKeys.POKEMON_PROPERTIES_HELDITEM) else null
        scaleModifier = if (tag.contains(DataKeys.POKEMON_SCALE_MODIFIER)) tag.getFloat(DataKeys.POKEMON_SCALE_MODIFIER) else null
        val custom = tag.getList(DataKeys.POKEMON_PROPERTIES_CUSTOM, Tag.TAG_STRING.toInt())
@@ -747,6 +765,7 @@ open class PokemonProperties {
        originalTrainerType?.let { json.addProperty(DataKeys.POKEMON_ORIGINAL_TRAINER_TYPE, it.name) }
        originalTrainer?.let { json.addProperty(DataKeys.POKEMON_ORIGINAL_TRAINER, it) }
        moves?.let { json.addProperty(DataKeys.POKEMON_PROPERTIES_MOVES, it.joinToString(separator = ",")) }
+        movesetBuilders?.let { json.addProperty(DataKeys.POKEMON_PROPERTIES_MOVESET_BUILDERS, it.joinToString(separator = ",") { source -> source.toString() }) }
        heldItem?.let {json.addProperty(DataKeys.POKEMON_PROPERTIES_HELDITEM, it)}
        scaleModifier?.let { json.addProperty(DataKeys.POKEMON_SCALE_MODIFIER, it) }
        val custom = JsonArray()
@@ -781,6 +800,7 @@ open class PokemonProperties {
        originalTrainerType = json.get(DataKeys.POKEMON_ORIGINAL_TRAINER_TYPE)?.asString?.let { OriginalTrainerType.valueOf(it) }
        originalTrainer = json.get(DataKeys.POKEMON_ORIGINAL_TRAINER)?.asString
        moves = json.get(DataKeys.POKEMON_PROPERTIES_MOVES)?.asString?.split(",")
+        movesetBuilders = json.get(DataKeys.POKEMON_PROPERTIES_MOVESET_BUILDERS)?.asString?.split(",")?.map { it.asIdentifierDefaultingNamespace() }
        heldItem = json.get(DataKeys.POKEMON_PROPERTIES_HELDITEM)?.asString
        scaleModifier = json.get(DataKeys.POKEMON_SCALE_MODIFIER)?.asFloat
        val custom = json.get(DataKeys.POKEMON_PROPERTIES_CUSTOM)?.asJsonArray
@@ -820,6 +840,7 @@ open class PokemonProperties {
        originalTrainer?.let { pieces.add("originaltrainer=$it") }
        customProperties.forEach { pieces.add(it.asString()) }
        moves?.let { pieces.add("moves=${it.joinToString(separator = ",")}") }
+        movesetBuilders?.let { pieces.add("movesetbuilders=${it.joinToString(separator = ",") { source -> source.toString() }}") }
        heldItem?.let {pieces.add("helditem=$it")}
        scaleModifier?.let { pieces.add("scale_modifier=$it") }
        return pieces.joinToString(separator)
@@ -23,6 +23,7 @@ import com.cobblemon.mod.common.api.drop.ItemDropMethod
 import com.cobblemon.mod.common.api.entity.EntityDimensionsAdapter
 import com.cobblemon.mod.common.api.molang.ExpressionLike
 import com.cobblemon.mod.common.api.moves.MoveTemplate
+import com.cobblemon.mod.common.api.moves.MovesetBuilder
 import com.cobblemon.mod.common.api.moves.adapters.MoveTemplateAdapter
 import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
 import com.cobblemon.mod.common.api.pokemon.PokemonSpecies.getByIdentifier
@@ -131,6 +132,7 @@ object PokemonSpecies : JsonDataRegistry<Species> {
        .registerTypeAdapter(RidingBehaviourSettings::class.java, RidingBehaviourSettingsAdapter)
        .registerTypeAdapter(RideSoundSettingsList::class.java, RideSoundSettingsListAdapter)
        .registerTypeAdapter(ObtainableItemCondition::class.java, ObtainableItemConditionAdapter)
+        .registerTypeAdapter(MovesetBuilder::class.java, MovesetBuilderReferenceAdapter)
        .disableHtmlEscaping()
        .enableComplexMapKeySerialization()
        .create()
@@ -80,9 +80,7 @@ open class ChoiceSpeciesFeatureProvider(

    internal constructor(): this(emptyList())

-    override fun get(pokemon: Pokemon): StringSpeciesFeature? {
-        return pokemon.features.filterIsInstance<StringSpeciesFeature>().find { it.name in keys }
-    }
+    override fun get(pokemon: Pokemon) = pokemon.getFeature<StringSpeciesFeature>(keys.first())

    override fun invoke(pokemon: Pokemon): StringSpeciesFeature? {
        val existing = get(pokemon)
@@ -103,15 +101,15 @@ open class ChoiceSpeciesFeatureProvider(
    }

    override fun invoke(nbt: CompoundTag): StringSpeciesFeature? {
-        val key = keys.find { nbt.contains(it) }
-        if (key == null) return null
-        return StringSpeciesFeature(key, "").also { it.loadFromNBT(nbt) }
+        return if (nbt.contains(keys.first())) {
+            StringSpeciesFeature(keys.first(), "").also { it.loadFromNBT(nbt) }
+        } else null
    }

    override fun invoke(json: JsonObject): StringSpeciesFeature? {
-        val key = keys.find { json.has(it) }
-        if (key == null) return null
-        return StringSpeciesFeature(key, "").also { it.loadFromJSON(json) }
+        return if (json.has(keys.first())) {
+            StringSpeciesFeature(keys.first(), "").also { it.loadFromJSON(json) }
+        } else null
    }

    override fun fromString(value: String?): StringSpeciesFeature? {
@@ -133,7 +131,7 @@ open class ChoiceSpeciesFeatureProvider(

    override fun provide(properties: PokemonProperties): Set<String> {
        return if (isAspect) {
-            val feature = properties.customProperties.filterIsInstance<StringSpeciesFeature>().find { it.name in keys }
+            val feature = properties.customProperties.filterIsInstance<StringSpeciesFeature>().find { it.name == keys.first() }
            if (feature != null) {
                setOf(getAspect(feature))
            } else {
@@ -132,9 +132,7 @@ class FlagSpeciesFeatureProvider : SynchronizedSpeciesFeatureProvider<FlagSpecie

    constructor(vararg keys: String) : this(keys.toList())

-    override fun get(pokemon: Pokemon): FlagSpeciesFeature? {
-        return pokemon.features.filterIsInstance<FlagSpeciesFeature>().find { it.name in keys }
-    }
+    override fun get(pokemon: Pokemon) = pokemon.getFeature<FlagSpeciesFeature>(keys.first())

    override fun invoke(pokemon: Pokemon): FlagSpeciesFeature? {
        return get(pokemon)
@@ -146,15 +144,15 @@ class FlagSpeciesFeatureProvider : SynchronizedSpeciesFeatureProvider<FlagSpecie
    }

    override fun invoke(nbt: CompoundTag): FlagSpeciesFeature? {
-        val key = keys.find { nbt.contains(it) }
-        if (key == null) return null
-        return FlagSpeciesFeature(key, false).also { it.loadFromNBT(nbt) }
+        return if (nbt.contains(keys.first())) {
+            FlagSpeciesFeature(keys.first(), false).also { it.loadFromNBT(nbt) }
+        } else null
    }

    override fun invoke(json: JsonObject): FlagSpeciesFeature? {
-        val key = keys.find { json.has(it) }
-        if (key == null) return null
-        return FlagSpeciesFeature(key, false).also { it.loadFromJSON(json) }
+        return if (json.has(keys.first())) {
+            FlagSpeciesFeature(keys.first(), false).also { it.loadFromJSON(json) }
+        } else null
    }

    override fun fromString(value: String?): FlagSpeciesFeature? {
@@ -172,26 +170,16 @@ class FlagSpeciesFeatureProvider : SynchronizedSpeciesFeatureProvider<FlagSpecie
    }

    override fun provide(pokemon: Pokemon): Set<String> {
-        return if (isAspect) {
-            val feature = pokemon.features.filterIsInstance<FlagSpeciesFeature>().find { it.name in keys }
-            if (feature != null && feature.enabled) {
-                setOf(keys.first())
-            } else {
-                emptySet()
-            }
+        return if (isAspect && pokemon.getFeature<FlagSpeciesFeature>(keys.first())?.enabled == true) {
+            setOf(keys.first())
        } else {
            emptySet()
        }
    }

    override fun provide(properties: PokemonProperties): Set<String> {
-        return if (isAspect) {
-            val feature = properties.customProperties.filterIsInstance<FlagSpeciesFeature>().find { it.name in keys }
-            if (feature != null && feature.enabled) {
-                setOf(keys.first())
-            } else {
-                emptySet()
-            }
+        return if (isAspect && properties.customProperties.filterIsInstance<FlagSpeciesFeature>().find { it.name == keys.first() }?.enabled == true) {
+            setOf(keys.first())
        } else {
            emptySet()
        }
@@ -142,15 +142,19 @@ class IntSpeciesFeatureProvider : SynchronizedSpeciesFeatureProvider<IntSpeciesF
    }

    override fun invoke(nbt: CompoundTag): IntSpeciesFeature? {
-        val key = keys.find { nbt.contains(it) }
-        if (key == null) return null
-        return IntSpeciesFeature(keys.first(), nbt.getInt(key));
+        return if (nbt.contains(keys.first())) {
+            IntSpeciesFeature(keys.first(), nbt.getInt(keys.first()))
+        } else {
+            null
+        }
    }

    override fun invoke(json: JsonObject): IntSpeciesFeature? {
-        val key = keys.find { json.has(it) }
-        if (key == null) return null
-        return IntSpeciesFeature(keys.first(), json.get(key).asInt)
+        return if (json.has(keys.first())) {
+            IntSpeciesFeature(keys.first(), json.get(keys.first()).asInt)
+        } else {
+            null
+        }
    }

    override fun get(pokemon: Pokemon) = pokemon.features.filterIsInstance<IntSpeciesFeature>().find { it.name in keys }
@@ -12,7 +12,6 @@ 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].
@@ -27,7 +26,7 @@ interface OwnerQueryRequirement : Requirement {
    override fun check(pokemon: Pokemon): Boolean {
        val owner = pokemon.getOwnerEntity() ?: return false
        return when (owner) {
-            is Player -> {
+            is ServerPlayer -> {
                this.checkPlayer(pokemon, owner)
            }
            is NPCEntity -> {
@@ -38,13 +37,13 @@ interface OwnerQueryRequirement : Requirement {
    }

    /**
-     * Checks if the given [Pokemon] & [Player] satisfies the requirement.
+     * Checks if the given [Pokemon] & [ServerPlayer] satisfies the requirement.
     *
     * @param pokemon The [Pokemon] being queried.
-     * @param owner The [Player] that owns this [Pokemon].
+     * @param owner The [ServerPlayer] that owns this [Pokemon].
     * @return If the requirement was satisfied.
     */
-    fun checkPlayer(pokemon: Pokemon, owner: Player): Boolean
+    fun checkPlayer(pokemon: Pokemon, owner: ServerPlayer): Boolean

    /**
     * Checks if the given [Pokemon] & [NPCEntity] satisfies the requirement.
@@ -12,7 +12,6 @@ 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
@@ -66,21 +65,6 @@ 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
@@ -27,9 +27,7 @@ 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 {
@@ -48,9 +46,7 @@ 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)
    }
@@ -61,9 +57,7 @@ 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)

@@ -71,9 +65,7 @@ data class RideSoundSettings(
                soundLocation,
                volumeExpr,
                pitchExpr,
-                playForPassengers,
                playForNonPassengers,
-                submerged,
                muffleEnabled,
                attenuationModel
            )
@@ -44,7 +44,11 @@ abstract class SpawnAction<R>(

        spawnablePosition.applyInfluences { it.affectAction(this) }
        val result = run()
-        future.complete(result)
+        if (result != null) {
+            future.complete(result)
+        } else {
+            future.completeExceptionally(Exception("Nothing was spawned."))
+        }

        return result
    }
@@ -61,9 +61,7 @@ open class SpawnBaitInfluence(val effects: List<SpawnBait.Effect>, val onUsed: (
                val baitEVStat = effects.firstOrNull { it.type == Effects.EV }?.subcategory?.path?.let { Stats.getStat(it) }

                if (detailSpecies != null && baitEVStat != null) {
-                    val detailAspects = detail.pokemon.aspects
-                    val formData = detailSpecies.getForm(detailAspects)
-                    val evYieldValue = formData.evYield[baitEVStat]?.toFloat() ?: 0f
+                    val evYieldValue = detailSpecies.evYield[baitEVStat]?.toFloat() ?: 0f
                    return when {
                        evYieldValue > 0 -> {
                            markUsed()
@@ -85,9 +83,7 @@ open class SpawnBaitInfluence(val effects: List<SpawnBait.Effect>, val onUsed: (
                val baitTypingEffect = baitEffect?.subcategory?.path?.let { ElementalTypes.get(it) }

                if (detailSpecies != null && baitTypingEffect != null) {
-                    val detailAspects = detail.pokemon.aspects
-                    val formData = detailSpecies.getForm(detailAspects)
-                    val isMatchingType = formData.types.contains(baitTypingEffect)
+                    val isMatchingType = detailSpecies.types.contains(baitTypingEffect)
                    return when {
                        isMatchingType -> {
                            markUsed()
@@ -104,9 +100,6 @@ open class SpawnBaitInfluence(val effects: List<SpawnBait.Effect>, val onUsed: (
                val detailSpecies = detail.pokemon.species?.let { PokemonSpecies.getByName(it) }

                if (detailSpecies != null) {
-                    val detailAspects = detail.pokemon.aspects
-                    val formData = detailSpecies.getForm(detailAspects)
-
                    // Collect all the egg group effects
                    val eggGroupEffects = effects.filter { it.type == Effects.EGG_GROUP }

@@ -118,7 +111,7 @@ open class SpawnBaitInfluence(val effects: List<SpawnBait.Effect>, val onUsed: (
                            LOGGER.warn("Unknown egg group identifier: $effectEggGroupKey")
                            return@firstOrNull false
                        }
-                        formData.eggGroups.contains(eggGroup)
+                        detailSpecies.eggGroups.contains(eggGroup)
                    }

                    if (matchingEffect != null) {
@@ -8,58 +8,30 @@

 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, CobblemonStat>()
+    val stats = mutableMapOf<String,  ResourceLocation>()

-    @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)
+    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?)

    fun registerStats() {
        stats["captured"] = CAPTURED
@@ -80,22 +52,5 @@ 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);
    }
 }
@@ -1,671 +0,0 @@
-package com.cobblemon.mod.common.battles.ai
-
-import com.cobblemon.mod.common.api.battles.interpreter.BattleContext
-import com.cobblemon.mod.common.api.battles.model.PokemonBattle
-import com.cobblemon.mod.common.api.battles.model.ai.BattleAI
-import com.cobblemon.mod.common.api.battles.model.actor.BattleActor
-import com.cobblemon.mod.common.api.moves.Moves
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.battles.*
-import com.cobblemon.mod.common.battles.ai.competitive.*
-import com.cobblemon.mod.common.battles.pokemon.BattlePokemon
-import com.cobblemon.mod.common.net.messages.client.battle.BattleHealthChangePacket
-import kotlin.random.Random
-
-class CompetitiveBattleAI(private val skill: Int) : BattleAI {
-
-    companion object {
-        private const val DEBUG_TOP_MOVES = 4
-    }
-
-    private val skillLevel = skill.coerceIn(0, 5)
-
-    private val aiDebugEnabled = isAiDebugEnabled()
-
-    private val battleTracker = EnhancedActiveTracker()
-    private val opponentPredictor = OpponentPredictor()
-    private val strategyAnalyzer = StrategyAnalyzer()
-    private lateinit var damageCalculator: DamageCalculator
-    private lateinit var moveEvaluator: MoveEvaluator
-    private lateinit var switchDecisionMaker: SwitchDecisionMaker
-    private lateinit var doublesDecisionMaker: DoublesDecisionMaker
-
-    private var currentBattle: PokemonBattle? = null
-    private var currentGamePlan: GamePlan? = null
-    private var battleState: BattleState? = null
-    private var lastMoveEvaluation: MoveEvaluator.MoveEvaluation? = null
-
-    private var isDoublesMode: Boolean = false
-    private var currentSlot: Int = 0
-    private var currentTurn: Int = -1
-    private val turnDecisions: MutableMap<Int, DoublesDecisionMaker.MoveTargetPair> = mutableMapOf()
-    private var firstSlotDecided: Boolean = false
-
-    override fun choose(
-        activeBattlePokemon: ActiveBattlePokemon,
-        battle: PokemonBattle,
-        aiSide: BattleSide,
-        moveset: ShowdownMoveset?,
-        forceSwitch: Boolean
-    ): ShowdownActionResponse {
-        try {
-            initializeComponents(battle)
-            updateBattleState(activeBattlePokemon, battle)
-
-            if (currentGamePlan == null) {
-                val npcTeam = battle.side2.actors.first().pokemonList.map { it.effectedPokemon }
-                currentGamePlan = strategyAnalyzer.analyzeTeamComposition(npcTeam)
-            }
-
-            if (battle.turn != currentTurn) {
-                currentTurn = battle.turn
-                turnDecisions.clear()
-                firstSlotDecided = false
-            }
-
-            if (forceSwitch || activeBattlePokemon.isGone()) {
-                return handleForcedSwitch(activeBattlePokemon, battle)
-            }
-
-            if (!passesSkillCheck()) {
-                debugLog("Skill check failed; selecting random move.")
-                return makeRandomMove(moveset, activeBattlePokemon)
-            }
-
-            updateOpponentModel(battle)
-
-            if (isDoublesMode) {
-                return chooseForDoubles(activeBattlePokemon, battle, moveset)
-            }
-
-            if (shouldAttemptSwitch() && shouldSwitch(activeBattlePokemon, battle)) {
-                val switchTarget = findBestSwitch(activeBattlePokemon, battle)
-                if (switchTarget != null) {
-                    switchTarget.willBeSwitchedIn = true
-                    logSwitchDecision("voluntary_switch", battle, listOf(switchTarget), switchTarget)
-                    return SwitchActionResponse(switchTarget.uuid)
-                }
-            }
-
-            val bestMove = chooseBestMove(moveset, activeBattlePokemon, battle)
-            logMoveDecision("move_select", bestMove, activeBattlePokemon)
-            return executeMove(bestMove, activeBattlePokemon)
-
-        } catch (e: Exception) {
-            e.printStackTrace()
-            return PassActionResponse
-        }
-    }
-
-    private fun chooseForDoubles(
-        activeBattlePokemon: ActiveBattlePokemon,
-        battle: PokemonBattle,
-        moveset: ShowdownMoveset?
-    ): ShowdownActionResponse {
-        val state = battleState ?: return PassActionResponse
-        val plan = currentGamePlan ?: return PassActionResponse
-        val myPokemon = battleTracker.p2Active.getActiveAt(currentSlot) ?: return PassActionResponse
-        val partnerSlot = 1 - currentSlot
-        val partner = battleTracker.p2Active.getActiveAt(partnerSlot)
-        val opponents = battleTracker.p1Active.getAllActive()
-
-        val decision = doublesDecisionMaker.findBestMoveAndTarget(
-            moveset,
-            activeBattlePokemon,
-            myPokemon,
-            opponents,
-            partner,
-            state,
-            plan
-        )
-
-        if (decision == null) {
-            debugLog("Doubles: no evaluated option; selecting random move.")
-            return makeRandomMove(moveset, activeBattlePokemon)
-        }
-
-        turnDecisions[currentSlot] = decision
-        firstSlotDecided = true
-
-        debugLog(
-            "Doubles: chose move=${decision.move.id} target=${decision.targetPNX ?: "auto"} " +
-                "score=${"%.2f".format(decision.evaluation.totalScore)} " +
-                "expectedDamage=${"%.1f".format(decision.evaluation.expectedDamage)} " +
-                "strategic=${"%.1f".format(decision.evaluation.strategicValue)} " +
-                "risk=${"%.2f".format(decision.evaluation.riskFactor)}"
-        )
-        return executeDoublesMove(decision, activeBattlePokemon)
-    }
-
-    private fun executeDoublesMove(
-        decision: DoublesDecisionMaker.MoveTargetPair,
-        activeBattlePokemon: ActiveBattlePokemon
-    ): ShowdownActionResponse {
-        return if (decision.targetPNX != null) {
-            MoveActionResponse(decision.move.id, decision.targetPNX)
-        } else {
-            MoveActionResponse(decision.move.id)
-        }
-    }
-
-    private fun initializeComponents(battle: PokemonBattle) {
-        if (currentBattle != battle) {
-            currentBattle = battle
-            isDoublesMode = battle.format.battleType.pokemonPerSide > 1
-            damageCalculator = DamageCalculator(battle)
-            moveEvaluator = MoveEvaluator(damageCalculator, opponentPredictor, isDoublesMode)
-            switchDecisionMaker = SwitchDecisionMaker(damageCalculator, opponentPredictor, strategyAnalyzer)
-            doublesDecisionMaker = DoublesDecisionMaker(moveEvaluator, damageCalculator)
-        }
-    }
-
-    private fun updateBattleState(activeBattlePokemon: ActiveBattlePokemon, battle: PokemonBattle) {
-        val request = activeBattlePokemon.actor.request ?: return
-
-        // Determine current slot from PNX (e.g., "p2a" = slot 0, "p2b" = slot 1)
-        val pnx = activeBattlePokemon.getPNX()
-        currentSlot = if (pnx.length >= 3) pnx[2] - 'a' else 0
-
-        if (isDoublesMode) {
-            battle.side1.activePokemon.forEachIndexed { index, active ->
-                active.battlePokemon?.let { pokemon ->
-                    battleTracker.updatePokemonSlot(battleTracker.p1Active, index, pokemon)
-                }
-            }
-
-            battle.side2.activePokemon.forEachIndexed { index, active ->
-                active.battlePokemon?.let { pokemon ->
-                    battleTracker.updatePokemonSlot(battleTracker.p2Active, index, pokemon)
-                }
-            }
-
-            battleTracker.p1Active.activePokemon =
-                battleTracker.p1Active.getActiveAt(currentSlot) ?: battleTracker.p1Active.activePokemon
-            battleTracker.p2Active.activePokemon =
-                battleTracker.p2Active.getActiveAt(currentSlot) ?: battleTracker.p2Active.activePokemon
-        } else {
-            battle.side1.activePokemon.firstOrNull()?.battlePokemon?.let { playerPokemon ->
-                battleTracker.updatePokemon(battleTracker.p1Active.activePokemon, playerPokemon)
-                battleTracker.updateParty(battleTracker.p1Active, battleTracker.p1Active.activePokemon)
-            }
-
-            activeBattlePokemon.battlePokemon?.let { aiPokemon ->
-                battleTracker.updatePokemon(battleTracker.p2Active.activePokemon, aiPokemon)
-                battleTracker.updateParty(battleTracker.p2Active, battleTracker.p2Active.activePokemon)
-            }
-        }
-
-        updateRevealedMoves(battle)
-        battleState = createBattleState(battle, activeBattlePokemon)
-    }
-
-    private fun createBattleState(battle: PokemonBattle, activeBattlePokemon: ActiveBattlePokemon): BattleState? {
-        val p1Actor = battle.side1.actors.firstOrNull() ?: return null
-        val p2Actor = battle.side2.actors.firstOrNull() ?: return null
-
-        val playerActiveTracker = if (isDoublesMode) {
-            battleTracker.p1Active.getActiveAt(currentSlot) ?: battleTracker.p1Active.activePokemon
-        } else {
-            battleTracker.p1Active.activePokemon
-        }
-        val npcActiveTracker = if (isDoublesMode) {
-            battleTracker.p2Active.getActiveAt(currentSlot) ?: battleTracker.p2Active.activePokemon
-        } else {
-            battleTracker.p2Active.activePokemon
-        }
-
-        val playerActive = playerActiveTracker.pokemon ?: return null
-        val npcActive = npcActiveTracker.pokemon ?: return null
-        val playerActiveSlots = battleTracker.p1Active.getAllActive()
-            .mapNotNull { it.pokemon }
-            .ifEmpty { listOf(playerActive) }
-
-        val npcActiveSlots = battleTracker.p2Active.getAllActive()
-            .mapNotNull { it.pokemon }
-            .ifEmpty { listOf(npcActive) }
-
-        val partnerSlot = if (isDoublesMode) {
-            val mySlot = currentSlot
-            1 - mySlot
-        } else {
-            null
-        }
-
-        return BattleState(
-            turn = battle.turn,
-            playerTeam = p1Actor.pokemonList.map { it.effectedPokemon },
-            npcTeam = p2Actor.pokemonList.map { it.effectedPokemon },
-            playerActive = playerActive,
-            npcActive = npcActive,
-            weather = getWeather(battle),
-            terrain = getTerrain(battle),
-            playerHazards = getHazards(battle.side1),
-            npcHazards = getHazards(battle.side2),
-            playerBoosts = battleTracker.p1Active.activePokemon.boosts,
-            npcBoosts = battleTracker.p2Active.activePokemon.boosts,
-            battleContext = battle.contextManager,
-            isDoubles = isDoublesMode,
-            playerActiveSlots = playerActiveSlots,
-            npcActiveSlots = npcActiveSlots,
-            mySlotIndex = currentSlot,
-            partnerSlotIndex = partnerSlot
-        )
-    }
-
-    private fun handleForcedSwitch(activeBattlePokemon: ActiveBattlePokemon, battle: PokemonBattle): ShowdownActionResponse {
-        val availableSwitches = getAvailableSwitches(activeBattlePokemon)
-
-        if (availableSwitches.isEmpty()) {
-            return ForfeitActionResponse()
-        }
-
-        val state = battleState
-        val plan = currentGamePlan
-
-        val bestSwitch = if (state != null && plan != null) {
-            switchDecisionMaker.findBestSwitch(
-                availableSwitches,
-                battleTracker.p1Active.activePokemon,
-                state,
-                plan
-            )
-        } else {
-            null
-        }
-
-        val switchTarget = bestSwitch ?: availableSwitches.first()
-        switchTarget.willBeSwitchedIn = true
-        logSwitchDecision("forced_switch", battle, availableSwitches, switchTarget)
-        return SwitchActionResponse(switchTarget.uuid)
-    }
-
-    private fun shouldSwitch(activeBattlePokemon: ActiveBattlePokemon, battle: PokemonBattle): Boolean {
-        val availableSwitches = getAvailableSwitches(activeBattlePokemon)
-        if (availableSwitches.isEmpty()) return false
-
-        val state = battleState ?: return false
-        val plan = currentGamePlan ?: return false
-
-        return switchDecisionMaker.shouldVoluntarilySwitch(
-            battleTracker.p2Active.activePokemon,
-            battleTracker.p1Active.activePokemon,
-            state,
-            plan,
-            availableSwitches
-        )
-    }
-
-    private fun findBestSwitch(activeBattlePokemon: ActiveBattlePokemon, battle: PokemonBattle): BattlePokemon? {
-        val availableSwitches = getAvailableSwitches(activeBattlePokemon)
-
-        val state = battleState ?: return null
-        val plan = currentGamePlan ?: return null
-
-        return switchDecisionMaker.findBestSwitch(
-            availableSwitches,
-            battleTracker.p1Active.activePokemon,
-            state,
-            plan
-        )
-    }
-
-    private fun chooseBestMove(
-        moveset: ShowdownMoveset?,
-        activeBattlePokemon: ActiveBattlePokemon,
-        battle: PokemonBattle
-    ): InBattleMove? {
-        if (moveset == null) return null
-
-        val usableMoves = moveset.moves.filter { it.canBeUsed() }
-        if (usableMoves.isEmpty()) return null
-
-        val state = battleState ?: return null
-        val plan = currentGamePlan ?: return null
-
-        val evaluations = usableMoves.map { move ->
-            moveEvaluator.evaluateMove(
-                move,
-                battleTracker.p2Active.activePokemon,
-                battleTracker.p1Active.activePokemon,
-                state,
-                plan
-            )
-        }
-
-        val bestEvaluation = evaluations.maxByOrNull { it.totalScore }
-        logMoveRanking(evaluations)
-        lastMoveEvaluation = bestEvaluation
-        return bestEvaluation?.move
-    }
-
-    private fun executeMove(move: InBattleMove?, activeBattlePokemon: ActiveBattlePokemon): ShowdownActionResponse {
-        if (move == null) {
-            return makeRandomMove(null, activeBattlePokemon)
-        }
-
-        val target = if (move.mustBeUsed()) {
-            null
-        } else {
-            move.target.targetList(activeBattlePokemon)
-        }
-
-        return if (target == null) {
-            MoveActionResponse(move.id)
-        } else {
-            val chosenTarget = target.filter { !it.isAllied(activeBattlePokemon) }.randomOrNull()
-                ?: target.random()
-            MoveActionResponse(move.id, (chosenTarget as ActiveBattlePokemon).getPNX())
-        }
-    }
-
-    private fun makeRandomMove(moveset: ShowdownMoveset?, activeBattlePokemon: ActiveBattlePokemon): ShowdownActionResponse {
-        if (moveset == null) return PassActionResponse
-
-        val usableMoves = moveset.moves.filter { it.canBeUsed() }
-        val move = usableMoves.randomOrNull() ?: return PassActionResponse
-
-        val target = if (move.mustBeUsed()) null else move.target.targetList(activeBattlePokemon)
-
-        return if (target == null) {
-            MoveActionResponse(move.id)
-        } else {
-            val chosenTarget = target.filter { !it.isAllied(activeBattlePokemon) }.randomOrNull()
-                ?: target.random()
-            MoveActionResponse(move.id, (chosenTarget as ActiveBattlePokemon).getPNX())
-        }
-    }
-
-    private fun updateOpponentModel(battle: PokemonBattle) {
-        val situation = categorizeSituation(battleState ?: return)
-
-        val opponentActives = if (isDoublesMode) {
-            battleTracker.p1Active.getAllActive()
-        } else {
-            listOf(battleTracker.p1Active.activePokemon)
-        }
-
-        for (opponentActive in opponentActives) {
-            for (move in opponentActive.revealedMoves) {
-                opponentPredictor.updateMoveHistory(
-                    opponentActive.species ?: "unknown",
-                    move,
-                    situation.name.lowercase()
-                )
-            }
-        }
-    }
-
-    override fun onHealthChange(packet: BattleHealthChangePacket) {
-        try {
-            val battle = currentBattle ?: return
-            val pnx = packet.pnx
-
-            val activePokemon = battle.activePokemon.find { it.getPNX() == pnx } ?: return
-            val newHealth = packet.newHealth.toInt()
-            val isPlayerPokemon = activePokemon.actor == battle.side1.actors.firstOrNull()
-            val teamTracker = if (isPlayerPokemon) {
-                battleTracker.p1Active
-            } else {
-                battleTracker.p2Active
-            }
-            val tracker = battleTracker.getTrackedPokemonByPNX(pnx, teamTracker) ?: teamTracker.activePokemon
-
-            val oldHealth = tracker.currentHp
-            val hpChange = newHealth - oldHealth
-
-            tracker.previousHp = oldHealth
-            tracker.currentHp = newHealth
-            tracker.lastHpChange = hpChange
-            tracker.currentHpPercent = if (tracker.maxHp > 0) newHealth.toDouble() / tracker.maxHp else 0.0
-
-            updateMomentum(hpChange, isPlayerPokemon)
-
-            detectCriticalThresholds(tracker, oldHealth, newHealth, isPlayerPokemon)
-
-        } catch (e: Exception) {
-        }
-    }
-
-
-    private fun updateMomentum(hpChange: Int, isPlayerPokemon: Boolean) {
-        val momentumChange = when {
-            hpChange > 0 -> -5.0  // Opponent healing shifts momentum toward them
-            hpChange < 0 -> kotlin.math.abs(hpChange) / 10.0  // Damage shifts momentum
-            else -> 0.0
-        }
-
-        if (isPlayerPokemon) {
-            // Player took damage = AI momentum increases
-            battleTracker.p2Active.momentum += momentumChange
-            battleTracker.p1Active.momentum -= momentumChange
-        } else {
-            // AI took damage = Player momentum increases
-            battleTracker.p2Active.momentum -= momentumChange
-            battleTracker.p1Active.momentum += momentumChange
-        }
-
-        // Clamp momentum to -100 to 100
-        battleTracker.p1Active.momentum = battleTracker.p1Active.momentum.coerceIn(-100.0, 100.0)
-        battleTracker.p2Active.momentum = battleTracker.p2Active.momentum.coerceIn(-100.0, 100.0)
-    }
-
-    private fun detectCriticalThresholds(
-        tracker: TrackedPokemon,
-        oldHealth: Int,
-        newHealth: Int,
-        isPlayerPokemon: Boolean
-    ) {
-        if (newHealth <= 0 && oldHealth > 0) {
-            if (isPlayerPokemon) {
-                battleTracker.p2Active.momentum += 20.0
-            } else {
-                battleTracker.p1Active.momentum += 20.0
-            }
-        }
-    }
-
-    private fun categorizeSituation(battleState: BattleState): BattleSituation {
-        val myHP = battleState.npcActive.currentHealth.toDouble() / battleState.npcActive.maxHealth
-        val oppHP = battleState.playerActive.currentHealth.toDouble() / battleState.playerActive.maxHealth
-
-        return when {
-            myHP < 0.25 -> BattleSituation.DESPERATE
-            oppHP < 0.25 -> BattleSituation.WINNING
-            myHP > 0.8 && oppHP > 0.8 -> BattleSituation.EARLY_GAME
-            battleState.npcTeam.count { it.currentHealth > 0 } <= 2 -> BattleSituation.ENDGAME
-            battleState.playerBoosts.values.any { it >= 2 } -> BattleSituation.OPPONENT_SETUP
-            battleState.npcBoosts.values.any { it >= 2 } -> BattleSituation.MY_SETUP
-            battleState.weather != null -> BattleSituation.WEATHER_CONTROL
-            else -> BattleSituation.NEUTRAL
-        }
-    }
-
-    private fun getAvailableSwitches(activeBattlePokemon: ActiveBattlePokemon): List<BattlePokemon> {
-        val currentUuid = activeBattlePokemon.battlePokemon?.uuid
-
-        return activeBattlePokemon.actor.pokemonList.filter {
-            it.health > 0 &&
-            it.uuid != currentUuid &&
-            try { it.canBeSentOut() } catch (e: Exception) { true }
-        }
-    }
-
-    private fun passesSkillCheck(): Boolean {
-        if (skillLevel == 5) return true
-        if (skillLevel == 0) return false
-
-        val baseChance = skillLevel * 20
-        val turnBonus = if ((battleState?.turn ?: 0) > 10) 10 else 0
-
-        return Random.nextInt(100) < (baseChance + turnBonus)
-    }
-
-    private fun shouldAttemptSwitch(): Boolean {
-        return when (skillLevel) {
-            in 0..2 -> false
-            3 -> Random.nextDouble() < 0.25
-            4 -> Random.nextDouble() < 0.70
-            5 -> true
-            else -> false
-        }
-    }
-
-    private fun getWeather(battle: PokemonBattle): String? {
-        return try {
-            battle.contextManager.get(BattleContext.Type.WEATHER)
-                ?.firstOrNull()?.id
-        } catch (e: Exception) {
-            null
-        }
-    }
-
-    private fun getTerrain(battle: PokemonBattle): String? {
-        return try {
-            battle.contextManager.get(BattleContext.Type.TERRAIN)
-                ?.firstOrNull()?.id
-        } catch (e: Exception) {
-            null
-        }
-    }
-
-    private fun getHazards(side: BattleSide): List<String> {
-        return try {
-            side.contextManager.get(BattleContext.Type.HAZARD)
-                ?.map { it.id } ?: emptyList()
-        } catch (e: Exception) {
-            emptyList()
-        }
-    }
-
-    private fun updateRevealedMoves(battle: PokemonBattle) {
-        updateTeamRevealedMoves(battle, battleTracker.p1Active)
-        updateTeamRevealedMoves(battle, battleTracker.p2Active)
-    }
-
-    private fun updateTeamRevealedMoves(battle: PokemonBattle, team: TeamTracker) {
-        val active = team.getAllActive().ifEmpty { listOf(team.activePokemon) }
-        for (tracked in active) {
-            val pokemon = tracked.pokemon ?: continue
-            val majorMessage = battle.majorBattleActions[pokemon.uuid]
-            val minorMessage = battle.minorBattleActions[pokemon.uuid]
-            val candidates = listOfNotNull(majorMessage, minorMessage)
-            for (message in candidates) {
-                val id = message.id.lowercase()
-                if (id != "move" && id != "-singlemove" && id != "singlemove") continue
-                val moveId = message.effectAt(1)?.id?.lowercase() ?: continue
-                tracked.revealedMoves.add(moveId)
-            }
-        }
-    }
-
-    private fun logMoveDecision(
-        reason: String,
-        move: InBattleMove?,
-        activeBattlePokemon: ActiveBattlePokemon
-    ) {
-        if (!aiDebugEnabled || move == null) return
-        val eval = lastMoveEvaluation
-        val self = activeBattlePokemon.battlePokemon?.effectedPokemon?.species?.name ?: "unknown"
-        val opp = battleTracker.p1Active.activePokemon.species ?: "unknown"
-        val plan = currentGamePlan?.winCondition?.name ?: "unknown"
-        if (eval == null) {
-            debugLog("Decision=$reason self=$self opp=$opp move=${move.id} plan=$plan")
-            return
-        }
-        debugLog(
-            "Decision=$reason self=$self opp=$opp move=${move.id} plan=$plan " +
-                "score=${"%.2f".format(eval.totalScore)} " +
-                "expectedDamage=${"%.1f".format(eval.expectedDamage)} " +
-                "strategic=${"%.1f".format(eval.strategicValue)} " +
-                "risk=${"%.2f".format(eval.riskFactor)}"
-        )
-    }
-
-    private fun logMoveRanking(evaluations: List<MoveEvaluator.MoveEvaluation>) {
-        if (!aiDebugEnabled || evaluations.isEmpty()) return
-        val plan = currentGamePlan?.winCondition?.name ?: "unknown"
-        val situation = battleState?.let { categorizeSituation(it).name } ?: "unknown"
-        val top = evaluations.sortedByDescending { it.totalScore }.take(DEBUG_TOP_MOVES)
-        val state = battleState
-        val planData = currentGamePlan
-        val attacker = battleTracker.p2Active.activePokemon
-        val defender = battleTracker.p1Active.activePokemon
-        val details = top.joinToString(", ") { eval ->
-            val debug = if (state != null && planData != null) {
-                moveEvaluator.buildDebugDetails(eval.move, attacker, defender, state, planData)
-            } else {
-                null
-            }
-            val flags = if (debug != null) {
-                listOf(
-                    "stab=${debug.hasStab}",
-                    "eff=${"%.2f".format(debug.effectiveness)}",
-                    "acc=${"%.2f".format(debug.accuracy)}",
-                    "prio=${debug.priority}",
-                    "status=${debug.isStatusMove}",
-                    "setup=${debug.isSetup}",
-                    "hazardSet=${debug.setsHazards}",
-                    "hazardClear=${debug.removesHazards}",
-                    "weather=${debug.setsWeather}",
-                    "recovery=${debug.isRecovery}",
-                    "pivot=${debug.isPivot}",
-                    "risky=${debug.isRisky}"
-                ).joinToString(" ")
-            } else {
-                "n/a"
-            }
-            "${eval.move.id}:" +
-                "score=${"%.2f".format(eval.totalScore)} " +
-                "raw=${"%.1f".format(eval.rawDamage)} " +
-                "dmg=${"%.1f".format(eval.expectedDamage)} " +
-                "strat=${"%.1f".format(eval.strategicValue)} " +
-                "align=${"%.1f".format(eval.gamePlanAlignment)} " +
-                "turn=${"%.1f".format(eval.turnAdvantage)} " +
-                "risk=${"%.2f".format(eval.riskFactor)} " +
-                flags
-        }
-        debugLog("MoveRank plan=$plan situation=$situation top=[$details]")
-    }
-
-    private fun logSwitchDecision(
-        reason: String,
-        battle: PokemonBattle,
-        availableSwitches: List<BattlePokemon>,
-        chosen: BattlePokemon?
-    ) {
-        if (!aiDebugEnabled) return
-        val state = battleState
-        val plan = currentGamePlan
-        val opponent = battleTracker.p1Active.activePokemon
-        val ranked = if (state != null && plan != null) {
-            availableSwitches.map { candidate ->
-                val score = switchDecisionMaker.evaluateSwitchOption(
-                    candidate.effectedPokemon,
-                    opponent,
-                    state,
-                    plan
-                )
-                candidate to score
-            }.sortedByDescending { it.second }
-                .take(3)
-                .joinToString(", ") { (candidate, score) ->
-                    "${candidate.effectedPokemon.species.name}:${"%.1f".format(score)}"
-                }
-        } else {
-            "n/a"
-        }
-
-        val chosenName = chosen?.effectedPokemon?.species?.name ?: "none"
-        debugLog("Decision=$reason chosen=$chosenName options=[$ranked]")
-    }
-
-    private fun debugLog(message: String) {
-        if (aiDebugEnabled) {
-            Cobblemon.LOGGER.info("[CompetitiveBattleAI] $message")
-        }
-    }
-
-    private fun isAiDebugEnabled(): Boolean {
-        return true
-    }
-}
@@ -1,20 +0,0 @@
-package com.cobblemon.mod.common.battles.ai.competitive
-
-object AiBattleUtils {
-    fun normalizeWeatherId(weather: String?): String? {
-        val id = weather?.lowercase() ?: return null
-        return when (id) {
-            "sun", "sunny", "sunnyday", "harshsunlight" -> "sunnyday"
-            "rain", "raindance", "heavyrain" -> "raindance"
-            "sand", "sandstorm" -> "sandstorm"
-            "hail" -> "hail"
-            "snow", "snowscape" -> "snow"
-            else -> id
-        }
-    }
-
-    fun hasStab(moveTypeName: String, pokemonTypes: List<String>): Boolean {
-        val moveType = moveTypeName.lowercase()
-        return pokemonTypes.any { it.lowercase() == moveType }
-    }
-}
@@ -1,236 +0,0 @@
-package com.cobblemon.mod.common.battles.ai.competitive
-
-import com.cobblemon.mod.common.api.moves.Move
-import com.cobblemon.mod.common.api.pokemon.stats.Stat
-import com.cobblemon.mod.common.api.pokemon.stats.Stats
-import com.cobblemon.mod.common.battles.interpreter.ContextManager
-import com.cobblemon.mod.common.battles.pokemon.BattlePokemon
-import com.cobblemon.mod.common.pokemon.Pokemon
-
-data class BattleState(
-    val turn: Int,
-    val playerTeam: List<Pokemon>,
-    val npcTeam: List<Pokemon>,
-    val playerActive: Pokemon,
-    val npcActive: Pokemon,
-    val weather: String?,
-    val terrain: String?,
-    val playerHazards: List<String>,
-    val npcHazards: List<String>,
-    val playerBoosts: Map<Stat, Int>,
-    val npcBoosts: Map<Stat, Int>,
-    val battleContext: ContextManager,
-    val gamePhase: GamePhase = determineGamePhase(turn, npcTeam, playerTeam),
-    val isDoubles: Boolean = false,
-    val playerActiveSlots: List<Pokemon> = listOf(playerActive),
-    val npcActiveSlots: List<Pokemon> = listOf(npcActive),
-    val mySlotIndex: Int = 0,
-    val partnerSlotIndex: Int? = null
-) {
-    companion object {
-        private fun determineGamePhase(turn: Int, npcTeam: List<Pokemon>, playerTeam: List<Pokemon>): GamePhase {
-            val npcAlive = npcTeam.count { it.currentHealth > 0 }
-            val playerAlive = playerTeam.count { it.currentHealth > 0 }
-
-            return when {
-                turn <= 3 -> GamePhase.EARLY_GAME
-                npcAlive <= 2 || playerAlive <= 2 -> GamePhase.ENDGAME
-                turn >= 15 -> GamePhase.LATE_GAME
-                else -> GamePhase.MID_GAME
-            }
-        }
-    }
-}
-
-enum class GamePhase {
-    EARLY_GAME,
-    MID_GAME,
-    LATE_GAME,
-    ENDGAME
-}
-
-data class TrackedPokemon(
-    var pokemon: Pokemon? = null,
-    var originalPokemon: Pokemon? = null,
-    var species: String? = null,
-
-    var currentHp: Int = 0,
-    var currentHpPercent: Double = 0.0,
-    var maxHp: Int = 0,
-    var previousHp: Int = 0,
-    var lastHpChange: Int = 0,
-
-    var boosts: Map<Stat, Int> = mapOf(),
-    var atkBoost: Int = 0,
-    var defBoost: Int = 0,
-    var spaBoost: Int = 0,
-    var spdBoost: Int = 0,
-    var speBoost: Int = 0,
-
-    var currentAbility: String? = null,
-    var currentTypes: MutableList<String>? = null,
-
-    var stats: Map<Stat, Int> = mapOf(),
-    var moves: List<Move> = listOf(),
-    var revealedMoves: MutableSet<String> = mutableSetOf(),
-
-    var cachedAttack: Double = 0.0,
-    var cachedDefense: Double = 0.0,
-    var cachedSpAttack: Double = 0.0,
-    var cachedSpDefense: Double = 0.0,
-    var cachedSpeed: Double = 0.0,
-
-    var sideConditions: Map<String, Any> = mapOf(),
-    var firstTurn: Int = 0,
-    var protectCount: Int = 0,
-    var lastMoveDamage: Int = 0,
-    var statusTurns: Int = 0,
-    var switchInTurn: Int = 0,
-
-    var predictedRole: PokemonRole = PokemonRole.UNKNOWN,
-    var threatLevel: Int = 0
-)
-
-
-enum class PokemonRole {
-    UNKNOWN,
-    SWEEPER, 
-    SETUP_SWEEPER, 
-    WALLBREAKER, 
-    REVENGE_KILLER, 
-    TANK, 
-    SUPPORT, 
-    PIVOT, 
-    BALANCED 
-}
-
-data class TeamTracker(
-    var party: MutableList<TrackedPokemon> = mutableListOf(),
-    var uuid: String? = null,
-    var activePokemon: TrackedPokemon = TrackedPokemon(),
-    var activeSlots: MutableList<TrackedPokemon> = mutableListOf(),
-    var nRemainingMons: Int = 0,
-    var hazardDamage: Int = 0,
-    var teamSynergy: Double = 0.0,
-    var momentum: Double = 0.0
-) {
-    fun getActiveAt(slotIndex: Int): TrackedPokemon? = activeSlots.getOrNull(slotIndex)
-
-    fun getAllActive(): List<TrackedPokemon> = activeSlots.filter { it.currentHp > 0 }
-
-    fun syncLegacyActivePokemon() {
-        if (activeSlots.isNotEmpty()) {
-            activePokemon = activeSlots[0]
-        }
-    }
-}
-
-class EnhancedActiveTracker {
-    var p1Active: TeamTracker = TeamTracker()
-    var p2Active: TeamTracker = TeamTracker()
-
-    private var lastStateUpdateTurn: Int = -1
-
-    fun updatePokemonSlot(team: TeamTracker, slotIndex: Int, battlePokemon: BattlePokemon) {
-        while (team.activeSlots.size <= slotIndex) {
-            team.activeSlots.add(TrackedPokemon())
-        }
-
-        updatePokemon(team.activeSlots[slotIndex], battlePokemon)
-        team.syncLegacyActivePokemon()
-    }
-
-    fun getTrackedPokemonByPNX(pnx: String, team: TeamTracker): TrackedPokemon? {
-        if (pnx.length < 3) return null
-        val slotIndex = pnx[2] - 'a'
-        return team.getActiveAt(slotIndex)
-    }
-
-    fun updatePokemon(tracker: TrackedPokemon, battlePokemon: BattlePokemon) {
-        val pokemon = battlePokemon.effectedPokemon
-
-        tracker.pokemon = pokemon
-        tracker.originalPokemon = battlePokemon.originalPokemon
-        tracker.species = pokemon.species.name
-        tracker.currentHp = pokemon.currentHealth
-        tracker.maxHp = pokemon.maxHealth
-        tracker.currentHpPercent = pokemon.currentHealth.toDouble() / pokemon.maxHealth
-        tracker.currentTypes = pokemon.types.map { it.name.lowercase() }.toMutableList()
-        tracker.currentAbility = pokemon.ability.name
-        tracker.moves = pokemon.moveSet.getMoves()
-
-        tracker.boosts = battlePokemon.statChanges
-        tracker.atkBoost = battlePokemon.statChanges[Stats.ATTACK] ?: 0
-        tracker.defBoost = battlePokemon.statChanges[Stats.DEFENCE] ?: 0
-        tracker.spaBoost = battlePokemon.statChanges[Stats.SPECIAL_ATTACK] ?: 0
-        tracker.spdBoost = battlePokemon.statChanges[Stats.SPECIAL_DEFENCE] ?: 0
-        tracker.speBoost = battlePokemon.statChanges[Stats.SPEED] ?: 0
-
-        cacheStats(tracker)
-    }
-
-    private fun cacheStats(tracker: TrackedPokemon) {
-        val pokemon = tracker.pokemon ?: return
-
-        tracker.cachedAttack = calculateStat(pokemon, Stats.ATTACK)
-        tracker.cachedDefense = calculateStat(pokemon, Stats.DEFENCE)
-        tracker.cachedSpAttack = calculateStat(pokemon, Stats.SPECIAL_ATTACK)
-        tracker.cachedSpDefense = calculateStat(pokemon, Stats.SPECIAL_DEFENCE)
-        tracker.cachedSpeed = calculateStat(pokemon, Stats.SPEED)
-    }
-
-    private fun calculateStat(pokemon: Pokemon, stat: Stat): Double {
-        val base = pokemon.species.baseStats[stat] ?: 0
-        val iv = pokemon.ivs[stat] ?: 31
-        val ev = pokemon.evs[stat] ?: 0
-        val level = pokemon.level
-
-        return ((2.0 * base + iv + ev / 4.0) * level / 100.0 + 5.0)
-    }
-
-    fun updateParty(team: TeamTracker, pokemon: TrackedPokemon) {
-        val existingIndex = team.party.indexOfFirst { it.pokemon?.uuid == pokemon.pokemon?.uuid }
-        if (existingIndex == -1) {
-            team.party.add(pokemon)
-        } else {
-            team.party[existingIndex] = pokemon
-        }
-    }
-}
-
-data class FearThreat(
-    val pokemon: Pokemon,
-    val hasEndeavor: Boolean,
-    val hasPriorityMove: Boolean,
-    val hasFocusItem: Boolean,
-    val threatLevel: Int
-)
-
-enum class BattleSituation {
-    DESPERATE,
-    WINNING,
-    EARLY_GAME,
-    ENDGAME,
-    OPPONENT_SETUP,
-    MY_SETUP,
-    NEUTRAL,
-    HAZARD_ADVANTAGE,
-    WEATHER_CONTROL
-}
-
-data class MatchupEvaluation(
-    val offensiveAdvantage: Double,
-    val defensiveAdvantage: Double,
-    val speedAdvantage: Double,
-    val overallScore: Double,
-    val recommendation: MatchupRecommendation
-)
-
-enum class MatchupRecommendation {
-    STAY_IN_AND_ATTACK,
-    STAY_IN_AND_SETUP,
-    STAY_IN_AND_STATUS,
-    CONSIDER_SWITCHING,
-    SWITCH_OUT,
-    PIVOT_OUT
-}
@@ -1,483 +0,0 @@
-package com.cobblemon.mod.common.battles.ai.competitive
-
-import com.cobblemon.mod.common.CobblemonItems
-import com.cobblemon.mod.common.api.battles.model.PokemonBattle
-import com.cobblemon.mod.common.api.moves.MoveTemplate
-import com.cobblemon.mod.common.api.moves.Moves
-import com.cobblemon.mod.common.api.moves.categories.DamageCategories
-import com.cobblemon.mod.common.api.pokemon.stats.Stat
-import com.cobblemon.mod.common.api.pokemon.stats.Stats
-import com.cobblemon.mod.common.api.types.ElementalType
-import com.cobblemon.mod.common.api.types.ElementalTypes
-import com.cobblemon.mod.common.battles.InBattleMove
-import com.cobblemon.mod.common.pokemon.Pokemon
-import net.minecraft.core.registries.BuiltInRegistries
-import java.util.*
-import kotlin.math.max
-
-class DamageCalculator(
-    private val battle: PokemonBattle?,
-    private val consumedItems: MutableMap<UUID, MutableList<String>> = mutableMapOf()
-) {
-
-    fun calculateDamage(
-        move: InBattleMove,
-        attacker: TrackedPokemon,
-        defender: TrackedPokemon,
-        weather: String? = null,
-        criticalHit: Boolean = false,
-        isSpreadMove: Boolean = false,
-        targetCount: Int = 1
-    ): Double {
-        val moveData = Moves.getByName(move.id) ?: return 0.0
-        var power = moveData.power.toDouble()
-
-        if (power <= 0) return 0.0
-
-        if (isSpreadMove && targetCount > 1) {
-            power *= 0.75
-        }
-
-        val immunityMultiplier = checkAllImmunities(moveData, attacker, defender)
-        if (immunityMultiplier == 0.0) return 0.0
-
-        val level = attacker.pokemon?.level ?: 50
-        val attackStat = getAttackStat(moveData, attacker)
-        val defenseStat = getDefenseStat(moveData, defender)
-
-        var damage = ((2.0 * level / 5.0 + 2.0) * power * (attackStat / defenseStat)) / 50.0 + 2.0
-
-        damage *= calculateCriticalMultiplier(criticalHit)
-        damage *= calculateSTABMultiplier(attacker, moveData)
-        damage *= TypeEffectiveness.calculateTypeEffectiveness(moveData.elementalType, defender.currentTypes ?: listOf())
-        damage *= calculateWeatherMultiplier(moveData, AiBattleUtils.normalizeWeatherId(weather))
-        damage *= calculateAbilityMultiplier(attacker, defender, moveData)
-        damage *= calculateItemMultiplier(attacker, defender, moveData)
-        damage *= calculateBurnMultiplier(attacker, moveData)
-        damage *= calculateScreenMultiplier(attacker, defender, moveData)
-        damage *= calculateRandomFactor()
-        damage = calculateMultiHitDamage(moveData, damage)
-
-        val finalDamage = max(1.0, damage)
-
-        if (finalDamage > 0) {
-            trackConsumedItems(defender, moveData)
-        }
-
-        return finalDamage
-    }
-
-    private fun getAttackStat(moveData: MoveTemplate, attacker: TrackedPokemon): Double {
-        val pokemon = attacker.pokemon ?: return 100.0
-
-        val baseStat = if (moveData.damageCategory == DamageCategories.PHYSICAL) {
-            getEffectiveStat(pokemon, Stats.ATTACK)
-        } else {
-            getEffectiveStat(pokemon, Stats.SPECIAL_ATTACK)
-        }
-
-        val boost = if (moveData.damageCategory == DamageCategories.PHYSICAL) {
-            attacker.atkBoost
-        } else {
-            attacker.spaBoost
-        }
-
-        return applyStatBoosts(baseStat, boost)
-    }
-
-    private fun getDefenseStat(moveData: MoveTemplate, defender: TrackedPokemon): Double {
-        val pokemon = defender.pokemon ?: return 100.0 
-
-        val baseStat = if (moveData.damageCategory == DamageCategories.PHYSICAL) {
-            getEffectiveStat(pokemon, Stats.DEFENCE)
-        } else {
-            getEffectiveStat(pokemon, Stats.SPECIAL_DEFENCE)
-        }
-
-        val boost = if (moveData.damageCategory == DamageCategories.PHYSICAL) {
-            defender.defBoost
-        } else {
-            defender.spdBoost
-        }
-
-        return applyStatBoosts(baseStat, boost)
-    }
-
-     
-    private fun applyStatBoosts(baseStat: Double, boost: Int): Double {
-        val clampedBoost = boost.coerceIn(-6, 6)
-        return if (clampedBoost >= 0) {
-            baseStat * (2.0 + clampedBoost) / 2.0
-        } else {
-            baseStat * 2.0 / (2.0 - clampedBoost)
-        }
-    }
-
-     
-    private fun getEffectiveStat(pokemon: Pokemon, stat: Stat): Double {
-        val base = pokemon.species.baseStats[stat] ?: 0
-        val iv = pokemon.ivs[stat] ?: 31
-        val ev = pokemon.evs[stat] ?: 0
-        val level = pokemon.level
-
-        return if (stat == Stats.HP) {
-            ((2.0 * base + iv + ev / 4.0) * level / 100.0 + level + 10.0)
-        } else {
-            ((2.0 * base + iv + ev / 4.0) * level / 100.0 + 5.0)
-        }
-    }
-
-    private fun checkAllImmunities(
-        moveData: MoveTemplate,
-        attacker: TrackedPokemon,
-        defender: TrackedPokemon
-    ): Double {
-        if (checkTypeImmunity(moveData, defender)) return 0.0
-        if (checkAbilityImmunity(moveData, attacker, defender)) return 0.0
-        if (checkItemImmunity(moveData, defender)) return 0.0
-        if (checkMoveSpecificImmunity(moveData, defender)) return 0.0
-        return 1.0
-    }
-
-    private fun checkTypeImmunity(moveData: MoveTemplate, defender: TrackedPokemon): Boolean {
-        val defenderTypes = (defender.currentTypes ?: defender.pokemon?.types?.map { it.name } ?: listOf())
-            .map { it.lowercase() }
-
-        return when (moveData.elementalType) {
-            ElementalTypes.GROUND -> "flying" in defenderTypes
-            ElementalTypes.ELECTRIC -> "ground" in defenderTypes
-            ElementalTypes.NORMAL, ElementalTypes.FIGHTING -> "ghost" in defenderTypes
-            ElementalTypes.PSYCHIC -> "dark" in defenderTypes
-            ElementalTypes.POISON -> "steel" in defenderTypes
-            ElementalTypes.DRAGON -> "fairy" in defenderTypes
-            ElementalTypes.GHOST -> "normal" in defenderTypes
-            else -> false
-        }
-    }
-
-    private fun checkAbilityImmunity(
-        moveData: MoveTemplate,
-        attacker: TrackedPokemon,
-        defender: TrackedPokemon
-    ): Boolean {
-        val defenderAbility = defender.currentAbility?.lowercase()
-            ?: defender.pokemon?.ability?.name?.lowercase()
-            ?: return false
-
-        val attackerAbility = attacker.currentAbility?.lowercase()
-            ?: attacker.pokemon?.ability?.name?.lowercase()
-        if (attackerAbility in listOf("moldbreaker", "turboblaze", "teravolt")) {
-            if (defenderAbility != "wonderguard") return false
-        }
-
-        return when (defenderAbility) {
-            "levitate" -> moveData.elementalType == ElementalTypes.GROUND
-            "voltabsorb", "lightningrod", "motordrive" -> moveData.elementalType == ElementalTypes.ELECTRIC
-            "flashfire", "wellbakedbody" -> moveData.elementalType == ElementalTypes.FIRE
-            "waterabsorb", "stormdrain", "dryskin" -> moveData.elementalType == ElementalTypes.WATER
-            "sapsipper" -> moveData.elementalType == ElementalTypes.GRASS
-            "eartheater" -> moveData.elementalType == ElementalTypes.GROUND
-            "soundproof" -> isSoundMove(moveData)
-            "bulletproof" -> isBallOrBombMove(moveData)
-            "queenlymajesty", "dazzling" -> moveData.priority > 0
-            "wonderguard" -> {
-                val effectiveness = TypeEffectiveness.calculateTypeEffectiveness(
-                    moveData.elementalType,
-                    defender.currentTypes ?: listOf()
-                )
-                effectiveness <= 1.0
-            }
-            "goodasgold" -> moveData.power.toInt() == 0 
-            else -> false
-        }
-    }
-
-    private fun checkItemImmunity(moveData: MoveTemplate, defender: TrackedPokemon): Boolean {
-        val defenderItem = defender.pokemon?.heldItem()?.item?.let {
-            BuiltInRegistries.ITEM.getKey(it).toString()
-        } ?: return false
-
-        return when (defenderItem) {
-            "cobblemon:air_balloon" -> {
-                val notConsumed = consumedItems[defender.pokemon?.uuid]?.contains("airballoon") != true
-                notConsumed && moveData.elementalType == ElementalTypes.GROUND
-            }
-            "cobblemon:safety_goggles" -> isPowderMove(moveData) || isWeatherDamageMove(moveData)
-            else -> false
-        }
-    }
-
-    private fun checkMoveSpecificImmunity(moveData: MoveTemplate, defender: TrackedPokemon): Boolean {
-        val defenderTypes = (defender.currentTypes ?: defender.pokemon?.types?.map { it.name } ?: listOf())
-            .map { it.lowercase() }
-        val defenderAbility = defender.currentAbility?.lowercase()
-            ?: defender.pokemon?.ability?.name?.lowercase()
-
-        return when (moveData.name.lowercase()) {
-            "thunderwave" -> {
-                "electric" in defenderTypes || "ground" in defenderTypes ||
-                defenderAbility in listOf("limber", "volt absorb", "lightningrod", "motordrive")
-            }
-            "willowisp" -> {
-                "fire" in defenderTypes ||
-                defenderAbility in listOf("waterveil", "waterbubble", "flashfire")
-            }
-            "toxic", "poisonpowder", "poisongas" -> {
-                "poison" in defenderTypes || "steel" in defenderTypes ||
-                defenderAbility in listOf("immunity", "poisonheal", "pastelveil")
-            }
-            "sleeppowder", "spore", "hypnosis", "sing" -> {
-                defenderAbility in listOf("insomnia", "vitalspirit", "comatose", "sweetveil")
-            }
-            else -> false
-        }
-    }
-
-    private fun calculateCriticalMultiplier(criticalHit: Boolean): Double {
-        return if (criticalHit) 1.5 else 1.0
-    }
-
-    private fun calculateSTABMultiplier(attacker: TrackedPokemon, moveData: MoveTemplate): Double {
-        val pokemonTypes = attacker.currentTypes ?: attacker.pokemon?.types?.map { it.name } ?: return 1.0
-        return if (AiBattleUtils.hasStab(moveData.elementalType.name, pokemonTypes)) {
-            if (attacker.currentAbility?.lowercase() == "adaptability") 2.0 else 1.5
-        } else 1.0
-    }
-
-    private fun calculateWeatherMultiplier(moveData: MoveTemplate, weather: String?): Double {
-        return when (weather) {
-            "sunnyday" -> when {
-                moveData.elementalType == ElementalTypes.FIRE -> 1.5
-                moveData.elementalType == ElementalTypes.WATER && moveData.name != "hydrosteam" -> 0.5
-                moveData.name == "hydrosteam" -> 1.5 
-                else -> 1.0
-            }
-            "raindance" -> when {
-                moveData.elementalType == ElementalTypes.WATER -> 1.5
-                moveData.elementalType == ElementalTypes.FIRE -> 0.5
-                else -> 1.0
-            }
-            "sandstorm", "hail", "snow" -> if (moveData.name == "weatherball") 2.0 else 1.0
-            else -> 1.0
-        }
-    }
-
-    private fun calculateAbilityMultiplier(
-        attacker: TrackedPokemon,
-        defender: TrackedPokemon,
-        moveData: MoveTemplate
-    ): Double {
-        var multiplier = 1.0
-
-        when (attacker.currentAbility?.lowercase()) {
-            "hugepower", "purepower" -> {
-                if (moveData.damageCategory == DamageCategories.PHYSICAL) multiplier *= 2.0
-            }
-            "guts" -> {
-                if (attacker.pokemon?.status != null && moveData.damageCategory == DamageCategories.PHYSICAL) {
-                    multiplier *= 1.5
-                }
-            }
-            "overgrow" -> {
-                if (moveData.elementalType == ElementalTypes.GRASS && attacker.currentHpPercent <= 0.33) {
-                    multiplier *= 1.5
-                }
-            }
-            "blaze" -> {
-                if (moveData.elementalType == ElementalTypes.FIRE && attacker.currentHpPercent <= 0.33) {
-                    multiplier *= 1.5
-                }
-            }
-            "torrent" -> {
-                if (moveData.elementalType == ElementalTypes.WATER && attacker.currentHpPercent <= 0.33) {
-                    multiplier *= 1.5
-                }
-            }
-            "swarm" -> {
-                if (moveData.elementalType == ElementalTypes.BUG && attacker.currentHpPercent <= 0.33) {
-                    multiplier *= 1.5
-                }
-            }
-        }
-
-        when (defender.currentAbility?.lowercase()) {
-            "thickfat" -> {
-                if (moveData.elementalType == ElementalTypes.FIRE || moveData.elementalType == ElementalTypes.ICE) {
-                    multiplier *= 0.5
-                }
-            }
-            "filter", "solidrock" -> {
-                val effectiveness = TypeEffectiveness.calculateTypeEffectiveness(
-                    moveData.elementalType,
-                    defender.currentTypes ?: listOf()
-                )
-                if (effectiveness > 1.0) multiplier *= 0.75
-            }
-        }
-
-        return multiplier
-    }
-
-    private fun calculateItemMultiplier(
-        attacker: TrackedPokemon,
-        defender: TrackedPokemon,
-        moveData: MoveTemplate
-    ): Double {
-        var multiplier = 1.0
-
-        val attackerItem = attacker.pokemon?.heldItem()?.item?.let {
-            BuiltInRegistries.ITEM.getKey(it).toString()
-        }
-
-        when (attackerItem) {
-            "cobblemon:choice_band" -> {
-                if (moveData.damageCategory == DamageCategories.PHYSICAL) multiplier *= 1.5
-            }
-            "cobblemon:choice_specs" -> {
-                if (moveData.damageCategory == DamageCategories.SPECIAL) multiplier *= 1.5
-            }
-            "cobblemon:life_orb" -> multiplier *= 1.3
-        }
-
-        return multiplier
-    }
-
-    private fun calculateBurnMultiplier(attacker: TrackedPokemon, moveData: MoveTemplate): Double {
-        return if (attacker.pokemon?.status?.status?.showdownName == "burn" &&
-            moveData.damageCategory == DamageCategories.PHYSICAL &&
-            attacker.currentAbility != "guts") {
-            0.5
-        } else {
-            1.0
-        }
-    }
-
-    private fun calculateScreenMultiplier(
-        attacker: TrackedPokemon,
-        defender: TrackedPokemon,
-        moveData: MoveTemplate
-    ): Double {
-        val attackerAbility = attacker.currentAbility?.lowercase() ?: attacker.pokemon?.ability?.name?.lowercase()
-        if (attackerAbility == "infiltrator") {
-            return 1.0
-        }
-
-        val sideConditions = defender.sideConditions.keys.map { it.lowercase() }
-
-        val hasReflect = "reflect" in sideConditions
-        val hasLightScreen = "lightscreen" in sideConditions || "light screen" in sideConditions
-        val hasAuroraVeil = "auroraveil" in sideConditions || "aurora veil" in sideConditions
-
-        val multiplier = when (moveData.damageCategory) {
-            DamageCategories.PHYSICAL -> {
-                when {
-                    hasAuroraVeil -> 0.5
-                    hasReflect -> 0.5
-                    else -> 1.0
-                }
-            }
-            DamageCategories.SPECIAL -> {
-                when {
-                    hasAuroraVeil -> 0.5
-                    hasLightScreen -> 0.5
-                    else -> 1.0
-                }
-            }
-            else -> 1.0
-        }
-
-        return multiplier
-    }
-
-    private fun calculateRandomFactor(): Double = 0.925
-
-    private fun calculateMultiHitDamage(moveData: MoveTemplate, baseDamage: Double): Double {
-        val moveName = moveData.name.lowercase()
-
-        return when {
-            moveName == "populationbomb" -> {
-                val accuracy = moveData.accuracy / 100.0
-                var expectedDamage = 0.0
-                var probability = 1.0
-
-                for (hit in 1..10) {
-                    expectedDamage += baseDamage * probability
-                    probability *= accuracy
-                }
-                expectedDamage
-            }
-
-            moveName in listOf("triplekick", "tripleaxel") -> {
-                val accuracy = moveData.accuracy / 100.0
-                baseDamage * 1.0 +
-                    baseDamage * 2.0 * accuracy +
-                    baseDamage * 3.0 * accuracy * accuracy
-            }
-
-            moveName in MoveData.multiHitMoves.keys -> {
-                val hitRange = MoveData.multiHitMoves[moveName]!!
-                val minHits = hitRange.keys.minOrNull() ?: 1
-                val maxHits = hitRange.values.maxOrNull() ?: 1
-
-                when {
-                    minHits == 2 && maxHits == 5 -> baseDamage * 3.0
-                    minHits == 2 && maxHits == 2 -> baseDamage * 2.0
-                    minHits == 3 && maxHits == 3 -> baseDamage * 3.0
-                    else -> baseDamage * ((minHits + maxHits) / 2.0)
-                }
-            }
-
-            else -> baseDamage
-        }
-    }
-
-    private fun isSoundMove(moveData: MoveTemplate): Boolean {
-        return moveData.name.lowercase() in listOf(
-            "boomburst", "bugbuzz", "chatter", "clangoroussoul", "disarmingvoice",
-            "echoedvoice", "grasswhistle", "growl", "hypervoice", "metalsound",
-            "nobleroar", "overdrive", "perishsong", "relicsong", "roar", "round",
-            "screech", "sing", "snore", "sparklingaria", "supersonic", "uproar"
-        )
-    }
-
-    private fun isBallOrBombMove(moveData: MoveTemplate): Boolean {
-        return moveData.name.lowercase() in listOf(
-            "acidspray", "aurasphere", "barrage", "bulletseed", "eggbomb",
-            "electroball", "energyball", "focusblast", "gyroball", "iceball",
-            "magnetbomb", "mistball", "mudbomb", "octazooka", "pollenpuff",
-            "rockblast", "searingshot", "seedbomb", "shadowball", "sludgebomb",
-            "weatherball", "zapcannon"
-        )
-    }
-
-    private fun isPowderMove(moveData: MoveTemplate): Boolean {
-        return moveData.name.lowercase() in listOf(
-            "sleeppowder", "stunspore", "poisonpowder", "cottonspore",
-            "ragepowder", "spore"
-        )
-    }
-
-    private fun isWeatherDamageMove(moveData: MoveTemplate): Boolean {
-        return moveData.name.lowercase() in listOf("sandstorm", "hail")
-    }
-
-    private fun trackConsumedItems(defender: TrackedPokemon, moveData: MoveTemplate) {
-        val pokemon = defender.pokemon ?: return
-        val defenderItem = pokemon.heldItem()?.item?.let {
-            BuiltInRegistries.ITEM.getKey(it).toString()
-        } ?: return
-
-        if (defenderItem == "cobblemon:air_balloon") {
-            val alreadyConsumed = consumedItems[pokemon.uuid]?.contains("airballoon") == true
-            if (!alreadyConsumed) {
-                addConsumedItem(pokemon.uuid, "airballoon")
-            }
-        }
-    }
-
-    private fun addConsumedItem(pokemonUuid: UUID, item: String) {
-        val items = consumedItems.getOrPut(pokemonUuid) { mutableListOf() }
-        items.add(item)
-    }
-
-}
@@ -1,135 +0,0 @@
-package com.cobblemon.mod.common.battles.ai.competitive
-
-import com.cobblemon.mod.common.api.moves.Moves
-import com.cobblemon.mod.common.api.pokemon.stats.Stats
-import com.cobblemon.mod.common.battles.ActiveBattlePokemon
-import com.cobblemon.mod.common.battles.InBattleMove
-import com.cobblemon.mod.common.battles.ShowdownMoveset
-import com.cobblemon.mod.common.battles.pokemon.BattlePokemon
-
-class DoublesDecisionMaker(
-    private val moveEvaluator: MoveEvaluator,
-    private val damageCalculator: DamageCalculator
-) {
-
-    data class MoveTargetPair(
-        val move: InBattleMove,
-        val targetPNX: String?,
-        val evaluation: MoveEvaluator.MoveEvaluation
-    )
-
-    fun findBestMoveAndTarget(
-        moveset: ShowdownMoveset?,
-        activeBattlePokemon: ActiveBattlePokemon,
-        myPokemon: TrackedPokemon,
-        opponents: List<TrackedPokemon>,
-        partner: TrackedPokemon?,
-        battleState: BattleState,
-        gamePlan: GamePlan
-    ): MoveTargetPair? {
-        if (moveset == null) return null
-
-        val usableMoves = moveset.moves.filter { it.canBeUsed() }
-        if (usableMoves.isEmpty()) return null
-
-        val allOptions = mutableListOf<MoveTargetPair>()
-
-        for (move in usableMoves) {
-            val moveData = Moves.getByName(move.id) ?: continue
-            val targetList = move.target.targetList(activeBattlePokemon)
-
-            if (targetList == null) {
-                val evaluation = moveEvaluator.evaluateMoveForDoubles(
-                    move, myPokemon, opponents.firstOrNull() ?: TrackedPokemon(),
-                    opponents, partner, battleState, gamePlan
-                )
-                allOptions.add(MoveTargetPair(move, null, evaluation))
-            } else {
-                val opponentTargets = targetList.filterIsInstance<ActiveBattlePokemon>()
-                    .filter { !it.isAllied(activeBattlePokemon) }
-
-                for (target in opponentTargets) {
-                    val targetPokemon = opponents.find {
-                        it.pokemon?.uuid == target.battlePokemon?.uuid
-                    } ?: continue
-
-                    val evaluation = moveEvaluator.evaluateMoveForDoubles(
-                        move, myPokemon, targetPokemon,
-                        opponents, partner, battleState, gamePlan
-                    )
-
-                    allOptions.add(MoveTargetPair(move, target.getPNX(), evaluation))
-                }
-            }
-        }
-
-        return allOptions.maxByOrNull { it.evaluation.totalScore }
-    }
-
-    fun scoreTarget(
-        target: TrackedPokemon,
-        myPokemon: TrackedPokemon,
-        allOpponents: List<TrackedPokemon>,
-        battleState: BattleState
-    ): Double {
-        var score = 0.0
-
-        score += target.threatLevel * 20.0
-
-        val mySpeed = myPokemon.cachedSpeed
-        val targetSpeed = target.cachedSpeed
-        if (targetSpeed > mySpeed && target.currentHpPercent < 0.5) {
-            score += 100.0
-        }
-
-        if (target.boosts.values.any { it >= 2 }) {
-            score += 120.0
-        }
-
-        if (target.cachedAttack > 100 || target.cachedSpAttack > 100) {
-            score += 40.0
-        }
-
-        if (target.currentHpPercent < 0.3) {
-            score += 80.0
-        }
-
-        return score
-    }
-
-    fun selectBestTarget(
-        move: InBattleMove,
-        activeBattlePokemon: ActiveBattlePokemon,
-        myPokemon: TrackedPokemon,
-        opponents: List<TrackedPokemon>,
-        battleState: BattleState
-    ): String? {
-        val targetList = move.target.targetList(activeBattlePokemon) ?: return null
-
-        val opponentTargets = targetList.filterIsInstance<ActiveBattlePokemon>()
-            .filter { !it.isAllied(activeBattlePokemon) }
-
-        if (opponentTargets.isEmpty()) return null
-
-        val targetScores = opponentTargets.mapNotNull { target ->
-            val targetPokemon = opponents.find {
-                it.pokemon?.uuid == target.battlePokemon?.uuid
-            }
-
-            if (targetPokemon != null) {
-                val damage = damageCalculator.calculateDamage(
-                    move, myPokemon, targetPokemon, battleState.weather
-                )
-
-                val targetScore = scoreTarget(targetPokemon, myPokemon, opponents, battleState)
-                val totalScore = damage + targetScore
-
-                target to totalScore
-            } else {
-                null
-            }
-        }
-
-        return targetScores.maxByOrNull { it.second }?.first?.getPNX()
-    }
-}
@@ -1,178 +0,0 @@
-package com.cobblemon.mod.common.battles.ai.competitive
-
-import com.cobblemon.mod.common.api.moves.MoveTemplate
-import com.cobblemon.mod.common.api.moves.Moves
-import com.cobblemon.mod.common.api.pokemon.stats.Stat
-import com.cobblemon.mod.common.api.pokemon.stats.Stats
-import com.cobblemon.mod.common.api.pokemon.status.Statuses
-
- 
-object MoveData {
-    val multiHitMoves: Map<String, Map<Int, Int>> = mapOf(
-        "armthrust" to mapOf(2 to 5),
-        "barrage" to mapOf(2 to 5),
-        "bonerush" to mapOf(2 to 5),
-        "bulletseed" to mapOf(2 to 5),
-        "cometpunch" to mapOf(2 to 5),
-        "doubleslap" to mapOf(2 to 5),
-        "furyattack" to mapOf(2 to 5),
-        "furyswipes" to mapOf(2 to 5),
-        "iciclespear" to mapOf(2 to 5),
-        "pinmissile" to mapOf(2 to 5),
-        "rockblast" to mapOf(2 to 5),
-        "scaleshot" to mapOf(2 to 5),
-        "spikecannon" to mapOf(2 to 5),
-        "tailslap" to mapOf(2 to 5),
-        "watershuriken" to mapOf(2 to 5),
-        "bonemerang" to mapOf(2 to 2),
-        "doublehit" to mapOf(2 to 2),
-        "doubleironbash" to mapOf(2 to 2),
-        "doublekick" to mapOf(2 to 2),
-        "dragondarts" to mapOf(2 to 2),
-        "dualchop" to mapOf(2 to 2),
-        "dualwingbeat" to mapOf(2 to 2),
-        "geargrind" to mapOf(2 to 2),
-        "twinbeam" to mapOf(2 to 2),
-        "twineedle" to mapOf(2 to 2),
-        "surgingstrikes" to mapOf(3 to 3),
-        "tripledive" to mapOf(3 to 3),
-        "tripleaxel" to mapOf(1 to 3), 
-        "triplekick" to mapOf(1 to 3),
-        "populationbomb" to mapOf(1 to 10)
-    )
-     
-    val statusMoves: Map<MoveTemplate?, String> = mapOf(
-        Moves.getByName("willowisp") to Statuses.BURN.showdownName,
-        Moves.getByName("scald") to Statuses.BURN.showdownName,
-        Moves.getByName("scorchingsands") to Statuses.BURN.showdownName,
-        Moves.getByName("flamethrower") to Statuses.BURN.showdownName,
-        Moves.getByName("sacredfire") to Statuses.BURN.showdownName,
-        Moves.getByName("glare") to Statuses.PARALYSIS.showdownName,
-        Moves.getByName("nuzzle") to Statuses.PARALYSIS.showdownName,
-        Moves.getByName("stunspore") to Statuses.PARALYSIS.showdownName,
-        Moves.getByName("thunderwave") to Statuses.PARALYSIS.showdownName,
-        Moves.getByName("bodyslam") to Statuses.PARALYSIS.showdownName,
-        Moves.getByName("discharge") to Statuses.PARALYSIS.showdownName,
-        Moves.getByName("spark") to Statuses.PARALYSIS.showdownName,
-        Moves.getByName("darkvoid") to Statuses.SLEEP.showdownName,
-        Moves.getByName("hypnosis") to Statuses.SLEEP.showdownName,
-        Moves.getByName("lovelykiss") to Statuses.SLEEP.showdownName,
-        Moves.getByName("relicsong") to Statuses.SLEEP.showdownName,
-        Moves.getByName("sing") to Statuses.SLEEP.showdownName,
-        Moves.getByName("sleeppowder") to Statuses.SLEEP.showdownName,
-        Moves.getByName("spore") to Statuses.SLEEP.showdownName,
-        Moves.getByName("yawn") to Statuses.SLEEP.showdownName,
-        Moves.getByName("chatter") to "confusion",
-        Moves.getByName("confuseray") to "confusion",
-        Moves.getByName("dynamicpunch") to "confusion",
-        Moves.getByName("flatter") to "confusion",
-        Moves.getByName("supersonic") to "confusion",
-        Moves.getByName("swagger") to "confusion",
-        Moves.getByName("sweetkiss") to "confusion",
-        Moves.getByName("teeterdance") to "confusion",
-        Moves.getByName("poisongas") to Statuses.POISON.showdownName,
-        Moves.getByName("poisonpowder") to Statuses.POISON.showdownName,
-        Moves.getByName("poisonjab") to Statuses.POISON.showdownName,
-        Moves.getByName("sludgebomb") to Statuses.POISON.showdownName,
-        Moves.getByName("crosspoison") to Statuses.POISON.showdownName,
-        Moves.getByName("toxic") to Statuses.POISON_BADLY.showdownName,
-        Moves.getByName("toxicthread") to Statuses.POISON.showdownName,
-        Moves.getByName("curse") to "cursed",
-        Moves.getByName("leechseed") to "leech"
-    )
-
-    val boostFromMoves: Map<String, Map<Stat, Int>> = mapOf(
-        "bellydrum" to mapOf(Stats.ATTACK to 6), 
-        "swordsdance" to mapOf(Stats.ATTACK to 2),
-        "honeclaws" to mapOf(Stats.ATTACK to 1, Stats.ACCURACY to 1),
-        "bulkup" to mapOf(Stats.ATTACK to 1, Stats.DEFENCE to 1),
-        "curse" to mapOf(Stats.ATTACK to 1, Stats.DEFENCE to 1, Stats.SPEED to -1), 
-        "howl" to mapOf(Stats.ATTACK to 1),
-        "meditate" to mapOf(Stats.ATTACK to 1),
-        "sharpen" to mapOf(Stats.ATTACK to 1),
-        "workup" to mapOf(Stats.ATTACK to 1, Stats.SPECIAL_ATTACK to 1),
-        "acidarmor" to mapOf(Stats.DEFENCE to 2),
-        "barrier" to mapOf(Stats.DEFENCE to 2),
-        "cottonguard" to mapOf(Stats.DEFENCE to 3),
-        "defensecurl" to mapOf(Stats.DEFENCE to 1),
-        "irondefense" to mapOf(Stats.DEFENCE to 2),
-        "stockpile" to mapOf(Stats.DEFENCE to 1, Stats.SPECIAL_DEFENCE to 1),
-        "stuffcheeks" to mapOf(Stats.DEFENCE to 2),
-        "shelter" to mapOf(Stats.DEFENCE to 2, Stats.EVASION to 1),
-        "withdraw" to mapOf(Stats.DEFENCE to 1),
-        "harden" to mapOf(Stats.DEFENCE to 1),
-        "nastyplot" to mapOf(Stats.SPECIAL_ATTACK to 2),
-        "calmmind" to mapOf(Stats.SPECIAL_ATTACK to 1, Stats.SPECIAL_DEFENCE to 1),
-        "quiverdance" to mapOf(Stats.SPECIAL_ATTACK to 1, Stats.SPECIAL_DEFENCE to 1, Stats.SPEED to 1),
-        "tailglow" to mapOf(Stats.SPECIAL_ATTACK to 3),
-        "takeheart" to mapOf(Stats.SPECIAL_ATTACK to 1, Stats.SPECIAL_DEFENCE to 1),
-        "geomancy" to mapOf(Stats.SPECIAL_ATTACK to 2, Stats.SPECIAL_DEFENCE to 2, Stats.SPEED to 2), 
-        "growth" to mapOf(Stats.SPECIAL_ATTACK to 1),
-        "amnesia" to mapOf(Stats.SPECIAL_DEFENCE to 2),
-        "agility" to mapOf(Stats.SPEED to 2),
-        "autotomize" to mapOf(Stats.SPEED to 2),
-        "rockpolish" to mapOf(Stats.SPEED to 2),
-        "dragondance" to mapOf(Stats.ATTACK to 1, Stats.SPEED to 1),
-        "shiftgear" to mapOf(Stats.ATTACK to 1, Stats.SPEED to 2),
-        "clangoroussoul" to mapOf(Stats.ATTACK to 1, Stats.DEFENCE to 1, Stats.SPECIAL_ATTACK to 1, Stats.SPECIAL_DEFENCE to 1, Stats.SPEED to 1),
-        "extremeevoboost" to mapOf(Stats.ATTACK to 2, Stats.DEFENCE to 2, Stats.SPECIAL_ATTACK to 2, Stats.SPECIAL_DEFENCE to 2, Stats.SPEED to 2),
-        "clangoroussoulblaze" to mapOf(Stats.ATTACK to 1, Stats.DEFENCE to 1, Stats.SPECIAL_ATTACK to 1, Stats.SPECIAL_DEFENCE to 1, Stats.SPEED to 1),
-        "filletaway" to mapOf(Stats.ATTACK to 2, Stats.SPECIAL_ATTACK to 2, Stats.SPEED to 2), 
-        "noretreat" to mapOf(Stats.ATTACK to 1, Stats.DEFENCE to 1, Stats.SPECIAL_ATTACK to 1, Stats.SPECIAL_DEFENCE to 1, Stats.SPEED to 1),
-        "shellsmash" to mapOf(Stats.ATTACK to 2, Stats.DEFENCE to -1, Stats.SPECIAL_ATTACK to 2, Stats.SPECIAL_DEFENCE to -1, Stats.SPEED to 2),
-        "tidyup" to mapOf(Stats.ATTACK to 1, Stats.SPEED to 1),
-        "victorydance" to mapOf(Stats.ATTACK to 1, Stats.DEFENCE to 1, Stats.SPEED to 1),
-        "coil" to mapOf(Stats.ATTACK to 1, Stats.DEFENCE to 1, Stats.ACCURACY to 1),
-        "minimize" to mapOf(Stats.EVASION to 2),
-        "doubleteam" to mapOf(Stats.EVASION to 1)
-    )
-
-    val weatherMoves: Map<String, String> = mapOf(
-        "raindance" to "rain",
-        "sunnyday" to "sun",
-        "sandstorm" to "sand",
-        "hail" to "hail",
-        "snowscape" to "snow"
-    )
-
-    val weatherDependentMoves: Map<String, String> = mapOf(
-        "thunder" to "rain", 
-        "hurricane" to "rain", 
-        "blizzard" to "hail", 
-        "solarbeam" to "sun", 
-        "hydrosteam" to "sun", 
-        "weatherball" to "any" 
-    )
-
-    val weatherAbilities: Map<String, String> = mapOf(
-        "swiftswim" to "rain", 
-        "raindish" to "rain", 
-        "dryskin" to "rain",
-        "chlorophyll" to "sun", 
-        "leafguard" to "sun", 
-        "flowergift" to "sun", 
-        "solarpower" to "sun",
-        "sandrush" to "sand", 
-        "sandveil" to "sand", 
-        "sandforce" to "sand",
-        "icebody" to "hail", 
-        "snowcloak" to "hail" 
-    )
-
-    val entryHazards = listOf("spikes", "stealthrock", "stickyweb", "toxicspikes")
-    val antiHazardsMoves = listOf("rapidspin", "defog", "tidyup")
-    val antiBoostMoves = listOf("clearsmog", "haze", "roar", "whirlwind")
-    val pivotMoves = listOf("uturn", "flipturn", "partingshot", "batonpass", "voltswitch", "teleport")
-    val setupMoves = setOf("tailwind", "trickroom", "auroraveil", "lightscreen", "reflect")
-    val selfRecoveryMoves = listOf("healorder", "milkdrink", "recover", "rest", "roost", "slackoff", "softboiled")
-    val priorityMoves = listOf(
-        "quickattack", "extremespeed", "bulletpunch", "machpunch",
-        "aquajet", "shadowsneak", "accelerock", "iceshard",
-        "suckerpunch", "firstimpression", "fakeout"
-    )
-
-    val recoilMoves = listOf(
-        "doubleedge", "bravebird", "closecombat", "superpower",
-        "overheat", "dracometeor", "leafstorm", "flareblitz"
-    )
-}
@@ -1,737 +0,0 @@
-package com.cobblemon.mod.common.battles.ai.competitive
-
-import com.cobblemon.mod.common.api.moves.Moves
-import com.cobblemon.mod.common.api.pokemon.stats.Stats
-import com.cobblemon.mod.common.battles.InBattleMove
-import com.cobblemon.mod.common.battles.MoveTarget
-import com.cobblemon.mod.common.pokemon.Pokemon
-import kotlin.math.abs
-import kotlin.math.max
-
-
-class MoveEvaluator(
-    private val damageCalculator: DamageCalculator,
-    private val opponentPredictor: OpponentPredictor,
-    private val isDoublesMode: Boolean = false
-) {
-
-
-    data class MoveEvaluation(
-        val move: InBattleMove,
-        val rawDamage: Double,
-        val expectedDamage: Double,
-        val strategicValue: Double,
-        val riskFactor: Double,
-        val priority: Int,
-        val turnAdvantage: Double,
-        val gamePlanAlignment: Double
-    ) {
-
-        val totalScore: Double = (expectedDamage + strategicValue + gamePlanAlignment + turnAdvantage) / riskFactor
-    }
-
-    data class MoveDebugDetails(
-        val moveId: String,
-        val moveType: String,
-        val accuracy: Double,
-        val rawDamage: Double,
-        val expectedDamage: Double,
-        val effectiveness: Double,
-        val hasStab: Boolean,
-        val priority: Int,
-        val isStatusMove: Boolean,
-        val setsWeather: Boolean,
-        val setsHazards: Boolean,
-        val removesHazards: Boolean,
-        val isRecovery: Boolean,
-        val isPivot: Boolean,
-        val isSetup: Boolean,
-        val isRisky: Boolean
-    )
-
-    fun buildDebugDetails(
-        move: InBattleMove,
-        attacker: TrackedPokemon,
-        defender: TrackedPokemon,
-        battleState: BattleState,
-        gamePlan: GamePlan
-    ): MoveDebugDetails? {
-        val moveData = Moves.getByName(move.id) ?: return null
-        val rawDamage = damageCalculator.calculateDamage(move, attacker, defender, battleState.weather)
-        val accuracy = getEffectiveAccuracy(move, attacker, defender, battleState.weather)
-        val expectedDamage = rawDamage * accuracy
-        val effectiveness = TypeEffectiveness.calculateTypeEffectiveness(
-            moveData.elementalType,
-            defender.currentTypes ?: listOf()
-        )
-        val attackerTypes = attacker.currentTypes ?: attacker.pokemon?.types?.map { it.name } ?: listOf()
-        val hasStab = AiBattleUtils.hasStab(moveData.elementalType.name, attackerTypes)
-        val moveId = move.id.lowercase()
-        val isStatusMove = MoveData.statusMoves.keys.any { it?.name?.lowercase() == moveId }
-        val setsWeather = moveId in MoveData.weatherMoves.keys
-        val setsHazards = moveId in MoveData.entryHazards
-        val removesHazards = moveId in MoveData.antiHazardsMoves
-        val isRecovery = moveId in MoveData.selfRecoveryMoves
-        val isPivot = moveId in MoveData.pivotMoves
-        val isSetup = moveId in MoveData.boostFromMoves.keys
-        val isRisky = moveId in gamePlan.riskyMoves
-
-        return MoveDebugDetails(
-            moveId = move.id,
-            moveType = moveData.elementalType.name,
-            accuracy = accuracy,
-            rawDamage = rawDamage,
-            expectedDamage = expectedDamage,
-            effectiveness = effectiveness,
-            hasStab = hasStab,
-            priority = moveData.priority,
-            isStatusMove = isStatusMove,
-            setsWeather = setsWeather,
-            setsHazards = setsHazards,
-            removesHazards = removesHazards,
-            isRecovery = isRecovery,
-            isPivot = isPivot,
-            isSetup = isSetup,
-            isRisky = isRisky
-        )
-    }
-
-
-    fun evaluateMove(
-        move: InBattleMove,
-        attacker: TrackedPokemon,
-        defender: TrackedPokemon,
-        battleState: BattleState,
-        gamePlan: GamePlan
-    ): MoveEvaluation {
-        val moveData = Moves.getByName(move.id)
-            ?: return MoveEvaluation(move, 0.0, 0.0, 0.0, 1.0, 0, 0.0, 0.0)
-
-
-        val rawDamage = damageCalculator.calculateDamage(move, attacker, defender, battleState.weather)
-        val accuracy = getEffectiveAccuracy(move, attacker, defender, battleState.weather)
-        val expectedDamage = rawDamage * accuracy
-
-
-        val strategicValue = calculateStrategicValue(move, attacker, defender, battleState, gamePlan)
-        val riskFactor = calculateRiskFactor(move, attacker, defender, battleState, gamePlan)
-        val turnAdvantage = calculateTurnAdvantage(move, attacker, defender, battleState)
-        val gamePlanAlignment = calculateGamePlanAlignment(move, attacker, defender, battleState, gamePlan)
-
-        return MoveEvaluation(
-            move = move,
-            rawDamage = rawDamage,
-            expectedDamage = expectedDamage,
-            strategicValue = strategicValue,
-            riskFactor = riskFactor,
-            priority = moveData.priority,
-            turnAdvantage = turnAdvantage,
-            gamePlanAlignment = gamePlanAlignment
-        )
-    }
-
-
-    private fun getEffectiveAccuracy(
-        move: InBattleMove,
-        attacker: TrackedPokemon,
-        defender: TrackedPokemon,
-        weather: String?
-    ): Double {
-        val moveData = Moves.getByName(move.id) ?: return 0.0
-        var accuracy = if (moveData.accuracy <= 0) 1.0 else moveData.accuracy / 100.0
-        val normalizedWeather = AiBattleUtils.normalizeWeatherId(weather)
-
-
-        when (normalizedWeather) {
-            "raindance" -> {
-                if (move.id.lowercase() in listOf("thunder", "hurricane")) accuracy = 1.0
-            }
-
-            "hail", "snow" -> {
-                if (move.id.lowercase() == "blizzard") accuracy = 1.0
-            }
-
-            "sunnyday" -> {
-                if (move.id.lowercase() in listOf("thunder", "hurricane")) accuracy *= 0.5
-            }
-        }
-
-
-        when (attacker.currentAbility?.lowercase()) {
-            "compoundeyes" -> accuracy *= 1.3
-            "noguard" -> accuracy = 1.0
-        }
-
-        when (defender.currentAbility?.lowercase()) {
-            "noguard" -> accuracy = 1.0
-            "sandveil" -> if (normalizedWeather == "sandstorm") accuracy *= 0.8
-            "snowcloak" -> if (normalizedWeather in listOf("hail", "snow")) accuracy *= 0.8
-        }
-
-
-        val accuracyBoost = attacker.boosts.getOrDefault(Stats.ACCURACY, 0)
-        val evasionBoost = defender.boosts.getOrDefault(Stats.EVASION, 0)
-        val netBoost = accuracyBoost - evasionBoost
-
-        if (netBoost != 0) {
-            accuracy *= if (netBoost > 0) {
-                (3.0 + netBoost) / 3.0
-            } else {
-                3.0 / (3.0 - netBoost)
-            }
-        }
-
-        return accuracy.coerceIn(0.0, 1.0)
-    }
-
-
-    private fun calculateStrategicValue(
-        move: InBattleMove,
-        attacker: TrackedPokemon,
-        defender: TrackedPokemon,
-        battleState: BattleState,
-        gamePlan: GamePlan
-    ): Double {
-        var value = 0.0
-
-
-        if (move.id.lowercase() in MoveData.weatherMoves.keys) {
-            value += evaluateWeatherSetting(move, gamePlan, battleState)
-        }
-
-
-        if (move.id.lowercase() in MoveData.boostFromMoves.keys) {
-            value += evaluateSetupMove(move, attacker, defender, battleState, gamePlan)
-        }
-
-
-        val moveId = move.id.lowercase()
-        val isStatusMove = MoveData.statusMoves.keys.any { it?.name?.lowercase() == moveId }
-        if (isStatusMove) {
-            value += evaluateStatusMove(move, attacker, defender, battleState, gamePlan)
-        }
-
-
-        if (move.id.lowercase() in MoveData.entryHazards) {
-            value += evaluateHazardSetting(battleState, gamePlan)
-        }
-
-
-        if (move.id.lowercase() in MoveData.antiHazardsMoves) {
-            value += evaluateHazardRemoval(battleState, gamePlan)
-        }
-
-
-        val moveData = Moves.getByName(move.id)
-        if (moveData != null && moveData.priority > 0) {
-            value += evaluatePriorityMove(move, attacker, defender, battleState)
-        }
-
-
-        if (move.id.lowercase() in MoveData.selfRecoveryMoves) {
-            value += evaluateRecoveryMove(attacker, battleState, gamePlan)
-        }
-
-
-        if (move.id.lowercase() in MoveData.pivotMoves) {
-            value += evaluatePivotMove(move, attacker, defender, battleState)
-        }
-
-
-        if (battleState.gamePhase == GamePhase.ENDGAME) {
-            value += evaluateEndgameMove(move, battleState)
-        }
-
-        return value
-    }
-
-
-    private fun calculateGamePlanAlignment(
-        move: InBattleMove,
-        attacker: TrackedPokemon,
-        defender: TrackedPokemon,
-        battleState: BattleState,
-        gamePlan: GamePlan
-    ): Double {
-        val moveData = Moves.getByName(move.id) ?: return 0.0
-        var alignment = 0.0
-        val normalizedWeather = AiBattleUtils.normalizeWeatherId(battleState.weather)
-
-
-        if (move.id.lowercase() in gamePlan.riskyMoves) {
-            alignment -= 100.0
-        }
-
-
-        alignment += when (gamePlan.winCondition) {
-            WinCondition.RAIN_OFFENSE -> {
-                var score = 0.0
-                if (move.id.lowercase() == "raindance") score += 200.0
-                if (normalizedWeather == "raindance") {
-                    if (moveData.elementalType.name.lowercase() == "water") score += 50.0
-                    if (move.id.lowercase() in listOf("thunder", "hurricane")) score += 100.0
-                }
-                score
-            }
-
-            WinCondition.SUN_OFFENSE -> {
-                var score = 0.0
-                if (move.id.lowercase() == "sunnyday") score += 200.0
-                if (normalizedWeather == "sunnyday") {
-                    if (moveData.elementalType.name.lowercase() == "fire") score += 50.0
-                    if (move.id.lowercase() == "solarbeam") score += 100.0
-                }
-                score
-            }
-
-            WinCondition.SETUP_SWEEP -> {
-                var score = 0.0
-                if (move.id.lowercase() in MoveData.boostFromMoves.keys &&
-                    attacker.species in gamePlan.keyPokemon
-                ) {
-                    score += 150.0
-                }
-                if (attacker.boosts.values.any { it >= 2 } && moveData.power > 80) {
-                    score += 100.0
-                }
-                score
-            }
-
-            WinCondition.AGGRESSIVE_SWEEP -> {
-                var score = 0.0
-                if (moveData.power >= 90) score += 60.0
-                if (moveData.priority > 0 && defender.currentHpPercent < 0.5) score += 80.0
-                score
-            }
-
-            WinCondition.DEFENSIVE_STALL -> {
-                var score = 0.0
-                if (MoveData.statusMoves.keys.any { it?.name?.lowercase() == move.id.lowercase() }) score += 70.0
-                if (move.id.lowercase() in MoveData.selfRecoveryMoves) score += 60.0
-                if (moveData.power > 80) score -= 30.0
-                score
-            }
-
-            WinCondition.HAZARD_CONTROL -> {
-                var score = 0.0
-                if (move.id.lowercase() == "stealthrock" && "stealthrock" !in battleState.playerHazards) {
-                    score += 250.0
-                }
-                if (move.id.lowercase() in MoveData.entryHazards) score += 100.0
-                score
-            }
-
-            WinCondition.REVENGE_KILLING -> {
-                var score = 0.0
-                if (moveData.priority > 0) score += 120.0
-                if (defender.currentHp > 50 && moveData.power >= 40 && moveData.power <= 80) score += 40.0
-                score
-            }
-
-            else -> 0.0
-        }
-
-
-        if (moveData.power > 0) {
-            alignment += moveData.power * gamePlan.aggressionLevel * 0.3
-        } else {
-            alignment += (1.0 - gamePlan.aggressionLevel) * 30.0
-        }
-
-        return alignment
-    }
-
-
-    private fun calculateRiskFactor(
-        move: InBattleMove,
-        attacker: TrackedPokemon,
-        defender: TrackedPokemon,
-        battleState: BattleState,
-        gamePlan: GamePlan
-    ): Double {
-        val moveData = Moves.getByName(move.id) ?: return 1.0
-        var risk = 1.0
-
-
-        val accuracy = getEffectiveAccuracy(move, attacker, defender, battleState.weather)
-        risk += (1.0 - accuracy) * 0.5
-
-
-        if (move.id.lowercase() in MoveData.recoilMoves) {
-            risk += if (attacker.currentHpPercent < 0.5) 0.5 else 0.2
-        }
-
-
-        if (move.id.lowercase() in listOf("explosion", "selfdestruct", "memento", "healingwish")) {
-
-            if (attacker.species in gamePlan.keyPokemon) {
-                risk += 2.0
-            } else if (attacker.currentHpPercent < 0.3) {
-                risk += 0.2
-            } else {
-                risk += 0.8
-            }
-        }
-
-
-        if (move.pp <= 1) {
-            risk += 0.3
-        }
-
-
-        val mySpeed = attacker.pokemon?.let { getEffectiveStat(it, Stats.SPEED) } ?: 0.0
-        val oppSpeed = defender.pokemon?.let { getEffectiveStat(it, Stats.SPEED) } ?: 0.0
-        if (abs(mySpeed - oppSpeed) < 5) {
-            risk += 0.1
-        }
-
-
-        val teamAdvantage = calculateTeamAdvantage(battleState)
-        if (teamAdvantage > 0) {
-
-            risk *= 0.8
-        } else if (teamAdvantage < -1) {
-
-            risk *= 1.2
-        }
-
-        return max(0.1, risk)
-    }
-
-
-    private fun calculateTurnAdvantage(
-        move: InBattleMove,
-        attacker: TrackedPokemon,
-        defender: TrackedPokemon,
-        battleState: BattleState
-    ): Double {
-        val moveData = Moves.getByName(move.id) ?: return 0.0
-        var advantage = 0.0
-        val mySpeed = attacker.pokemon?.let { getEffectiveStat(it, Stats.SPEED) } ?: 0.0
-        val oppSpeed = defender.pokemon?.let { getEffectiveStat(it, Stats.SPEED) } ?: 0.0
-        if (mySpeed > oppSpeed) advantage += 15.0
-        if (moveData.priority > 0) advantage += moveData.priority * 25.0
-        if (battleState.gamePhase == GamePhase.ENDGAME && moveData.power > 90) {
-            advantage += 20.0
-        }
-        return advantage
-    }
-
-
-    private fun evaluateWeatherSetting(move: InBattleMove, gamePlan: GamePlan, battleState: BattleState): Double {
-        val moveName = move.id.lowercase()
-        val weatherType = MoveData.weatherMoves[moveName] ?: return 0.0
-
-        return when (gamePlan.winCondition) {
-            WinCondition.RAIN_OFFENSE -> if (weatherType == "rain") 300.0 else 0.0
-            WinCondition.SUN_OFFENSE -> if (weatherType == "sun") 300.0 else 0.0
-            WinCondition.SAND_OFFENSE -> if (weatherType == "sand") 300.0 else 0.0
-            WinCondition.WEATHER_CONTROL -> 150.0
-            else -> 30.0
-        }
-    }
-
-    private fun evaluateSetupMove(
-        move: InBattleMove,
-        attacker: TrackedPokemon,
-        defender: TrackedPokemon,
-        battleState: BattleState,
-        gamePlan: GamePlan
-    ): Double {
-        val boosts = MoveData.boostFromMoves[move.id.lowercase()] ?: return 0.0
-        var value = 0.0
-        val totalBoosts = boosts.values.sum()
-        value += totalBoosts * 40.0 * gamePlan.setupPriority
-        val relevantBoosts = boosts.keys.mapNotNull { stat -> attacker.boosts[stat] }
-        if (relevantBoosts.any { it >= 3 }) value *= 0.2
-        val predictedMoves = opponentPredictor.predictMoveHeuristically(defender, attacker)
-        val dangerLevel = predictedMoves.count { (moveName, _) ->
-            (Moves.getByName(moveName)?.power ?: 0.0) > 80
-        }
-        if (dangerLevel > 0 && attacker.currentHpPercent < 0.7) {
-            value *= 0.4
-        }
-
-        return value
-    }
-
-    private fun evaluateStatusMove(
-        move: InBattleMove,
-        attacker: TrackedPokemon,
-        defender: TrackedPokemon,
-        battleState: BattleState,
-        gamePlan: GamePlan
-    ): Double {
-
-        if (defender.pokemon?.status != null) return 0.0
-
-        return when (move.id.lowercase()) {
-            "thunderwave", "stunspore", "glare" -> {
-
-                if (defender.predictedRole == PokemonRole.SWEEPER) 90.0 else 50.0
-            }
-
-            "willowisp" -> {
-
-                if (defender.predictedRole in listOf(PokemonRole.WALLBREAKER, PokemonRole.SWEEPER)) {
-                    80.0
-                } else 40.0
-            }
-
-            "toxic" -> {
-
-                if (gamePlan.winCondition == WinCondition.DEFENSIVE_STALL) 100.0 else 60.0
-            }
-
-            "spore", "sleeppowder" -> 120.0
-            else -> 30.0
-        }
-    }
-
-    private fun evaluateHazardSetting(battleState: BattleState, gamePlan: GamePlan): Double {
-        val remainingOpponents = battleState.playerTeam.count { it.currentHealth > 0 }
-        if (remainingOpponents < 2) return 15.0
-
-        var value = remainingOpponents * 20.0
-        if (gamePlan.winCondition == WinCondition.HAZARD_CONTROL) value *= 1.8
-
-        return value
-    }
-
-    private fun evaluateHazardRemoval(battleState: BattleState, gamePlan: GamePlan): Double {
-        val myHazards = battleState.npcHazards.size
-        if (myHazards == 0) return 5.0
-
-        var value = myHazards * 40.0
-        val remainingTeam = battleState.npcTeam.count { it.currentHealth > 0 }
-        if (remainingTeam >= 3) value *= 1.3
-
-        return value
-    }
-
-    private fun evaluatePriorityMove(
-        move: InBattleMove,
-        attacker: TrackedPokemon,
-        defender: TrackedPokemon,
-        battleState: BattleState
-    ): Double {
-        val moveData = Moves.getByName(move.id) ?: return 0.0
-        var value = moveData.priority * 20.0
-
-
-        if (defender.currentHpPercent < 0.5) {
-            val damage = damageCalculator.calculateDamage(move, attacker, defender, battleState.weather)
-            if (damage >= defender.currentHp) value += 150.0
-        }
-
-
-        val mySpeed = attacker.pokemon?.let { getEffectiveStat(it, Stats.SPEED) } ?: 0.0
-        val oppSpeed = defender.pokemon?.let { getEffectiveStat(it, Stats.SPEED) } ?: 0.0
-        if (abs(mySpeed - oppSpeed) < 10) value += 50.0
-
-        return value
-    }
-
-    private fun evaluateRecoveryMove(
-        attacker: TrackedPokemon,
-        battleState: BattleState,
-        gamePlan: GamePlan
-    ): Double {
-        if (attacker.currentHpPercent > 0.8) return 5.0
-
-        var value = (1.0 - attacker.currentHpPercent) * 140.0
-
-
-        if (gamePlan.winCondition == WinCondition.DEFENSIVE_STALL) value *= 1.5
-
-        return value
-    }
-
-    private fun evaluatePivotMove(
-        move: InBattleMove,
-        attacker: TrackedPokemon,
-        defender: TrackedPokemon,
-        battleState: BattleState
-    ): Double {
-        var value = 40.0
-
-
-        val damage = damageCalculator.calculateDamage(move, attacker, defender, battleState.weather)
-        value += damage * 0.3
-
-        return value
-    }
-
-    private fun evaluateEndgameMove(move: InBattleMove, battleState: BattleState): Double {
-        val moveData = Moves.getByName(move.id) ?: return 0.0
-        var bonus = 0.0
-
-
-        if (moveData.power > 0 && moveData.accuracy >= 90) {
-            bonus += 35.0
-        }
-
-
-        if (moveData.accuracy < 80) {
-            bonus -= 30.0
-        }
-
-
-        if (moveData.priority > 0) {
-            bonus += 50.0
-        }
-
-        return bonus
-    }
-
-    private fun calculateTeamAdvantage(battleState: BattleState): Int {
-        val npcAlive = battleState.npcTeam.count { it.currentHealth > 0 }
-        val playerAlive = battleState.playerTeam.count { it.currentHealth > 0 }
-        return npcAlive - playerAlive
-    }
-
-    private fun getEffectiveStat(pokemon: Pokemon, stat: Stats): Double {
-        val base = pokemon.species.baseStats[stat] ?: 0
-        val iv = pokemon.ivs[stat] ?: 31
-        val ev = pokemon.evs[stat] ?: 0
-        val level = pokemon.level
-
-        return if (stat == Stats.HP) {
-            ((2.0 * base + iv + ev / 4.0) * level / 100.0 + level + 10.0)
-        } else {
-            ((2.0 * base + iv + ev / 4.0) * level / 100.0 + 5.0)
-        }
-    }
-
-    fun evaluateMoveForDoubles(
-        move: InBattleMove,
-        attacker: TrackedPokemon,
-        primaryTarget: TrackedPokemon,
-        allOpponents: List<TrackedPokemon>,
-        partner: TrackedPokemon?,
-        battleState: BattleState,
-        gamePlan: GamePlan
-    ): MoveEvaluation {
-        val moveData = Moves.getByName(move.id)
-            ?: return MoveEvaluation(move, 0.0, 0.0, 0.0, 1.0, 0, 0.0, 0.0)
-
-        if (isSpreadMove(moveData.target)) {
-            return evaluateSpreadMove(move, attacker, allOpponents, partner, battleState, gamePlan)
-        }
-
-        val baseEvaluation = evaluateMove(move, attacker, primaryTarget, battleState, gamePlan)
-
-        var targetingBonus = 0.0
-        if (primaryTarget.threatLevel > 5) {
-            targetingBonus += 20.0
-        }
-
-        return MoveEvaluation(
-            move = baseEvaluation.move,
-            rawDamage = baseEvaluation.rawDamage,
-            expectedDamage = baseEvaluation.expectedDamage,
-            strategicValue = baseEvaluation.strategicValue + targetingBonus,
-            riskFactor = baseEvaluation.riskFactor,
-            priority = baseEvaluation.priority,
-            turnAdvantage = baseEvaluation.turnAdvantage,
-            gamePlanAlignment = baseEvaluation.gamePlanAlignment
-        )
-    }
-
-    private fun evaluateSpreadMove(
-        move: InBattleMove,
-        attacker: TrackedPokemon,
-        allOpponents: List<TrackedPokemon>,
-        partner: TrackedPokemon?,
-        battleState: BattleState,
-        gamePlan: GamePlan
-    ): MoveEvaluation {
-        val moveData = Moves.getByName(move.id)
-            ?: return MoveEvaluation(move, 0.0, 0.0, 0.0, 1.0, 0, 0.0, 0.0)
-
-        var totalDamage = 0.0
-        var totalStrategicValue = 0.0
-        val activeOpponents = allOpponents.filter { it.currentHp > 0 }
-        val targetCount = activeOpponents.size + (if (hitsPartner(moveData.target) && partner != null) 1 else 0)
-
-
-        for (opponent in activeOpponents) {
-            val damage = damageCalculator.calculateDamage(
-                move, attacker, opponent, battleState.weather,
-                isSpreadMove = true,
-                targetCount = targetCount
-            )
-            totalDamage += damage
-
-
-            if (damage >= opponent.currentHp) {
-                totalStrategicValue += 150.0
-            }
-        }
-
-        val multiTargetBonus = activeOpponents.size * 40.0
-        totalStrategicValue += multiTargetBonus
-
-        var partnerPenalty = 0.0
-        if (hitsPartner(moveData.target) && partner != null && partner.currentHp > 0) {
-            val partnerDamage = damageCalculator.calculateDamage(
-                move, attacker, partner, battleState.weather,
-                isSpreadMove = true,
-                targetCount = targetCount
-            )
-
-            partnerPenalty = when {
-                partnerDamage >= partner.currentHp -> -999999.0
-                partner.species in gamePlan.keyPokemon -> -partnerDamage * 5.0
-                partner.currentHpPercent < 0.3 -> -partnerDamage * 4.0
-                else -> -partnerDamage * 2.0
-            }
-
-            totalStrategicValue += partnerPenalty
-        }
-
-        val accuracy =
-            getEffectiveAccuracy(move, attacker, activeOpponents.firstOrNull() ?: TrackedPokemon(), battleState.weather)
-        val expectedDamage = totalDamage * accuracy
-
-        val riskFactor = if (partnerPenalty < -1000) {
-            999.0
-        } else if (partnerPenalty < 0) {
-            max(1.5, 1.0 + abs(partnerPenalty) / 100.0)
-        } else {
-            1.0
-        }
-
-        val gamePlanAlignment = if (activeOpponents.isNotEmpty()) {
-            calculateGamePlanAlignment(move, attacker, activeOpponents.first(), battleState, gamePlan)
-        } else {
-            0.0
-        }
-
-        return MoveEvaluation(
-            move = move,
-            rawDamage = totalDamage,
-            expectedDamage = expectedDamage,
-            strategicValue = totalStrategicValue,
-            riskFactor = riskFactor,
-            priority = moveData.priority,
-            turnAdvantage = 0.0,
-            gamePlanAlignment = gamePlanAlignment
-        )
-    }
-
-
-    private fun isSpreadMove(target: MoveTarget): Boolean {
-        return target in listOf(
-            MoveTarget.allAdjacent,
-            MoveTarget.allAdjacentFoes,
-            MoveTarget.all
-        )
-    }
-
-
-    private fun hitsPartner(target: MoveTarget): Boolean {
-        return target == MoveTarget.allAdjacent
-    }
-
-}
@@ -1,157 +0,0 @@
-package com.cobblemon.mod.common.battles.ai.competitive
-
-import com.cobblemon.mod.common.api.moves.Moves
-import com.cobblemon.mod.common.pokemon.Pokemon
-import kotlin.math.min
-
- 
-class OpponentPredictor {
-    private val moveHistory = mutableMapOf<String, MutableList<String>>()
-    private val switchHistory = mutableMapOf<String, MutableList<String>>()
-    private val situationResponses = mutableMapOf<String, MutableMap<String, Int>>()
-    private val aggressionLevel = mutableMapOf<String, Double>()
-    private val setupTendency = mutableMapOf<String, Double>()
-    private val switchFrequency = mutableMapOf<String, Double>()
-
-     
-    fun updateMoveHistory(pokemon: String, move: String, situation: String) {
-        moveHistory.getOrPut(pokemon) { mutableListOf() }.add(move)
-        situationResponses.getOrPut(situation) { mutableMapOf() }.merge(move, 1, Int::plus)
-        val moveData = Moves.getByName(move)
-        if (moveData != null) {
-            val currentAggression = aggressionLevel[pokemon] ?: 0.5
-            val newAggression = if (moveData.power > 0) {
- 
-                currentAggression * 0.9 + 0.8 * 0.1
-            } else {
- 
-                currentAggression * 0.9 + 0.2 * 0.1
-            }
-            aggressionLevel[pokemon] = newAggression
-            if (move in MoveData.boostFromMoves.keys) {
-                val currentSetup = setupTendency[pokemon] ?: 0.3
-                setupTendency[pokemon] = min(1.0, currentSetup + 0.15)
-            }
-        }
-    }
-
-    fun updateSwitchPattern(fromPokemon: String, toPokemon: String, reason: String) {
-        switchHistory.getOrPut(fromPokemon) { mutableListOf() }.add(toPokemon)
-        situationResponses.getOrPut("switch_$reason") { mutableMapOf() }.merge(toPokemon, 1, Int::plus)
-        val totalActions = (moveHistory[fromPokemon]?.size ?: 0) + (switchHistory[fromPokemon]?.size ?: 0)
-        if (totalActions > 0) {
-            switchFrequency[fromPokemon] = (switchHistory[fromPokemon]?.size ?: 0).toDouble() / totalActions
-        }
-    }
-
-    fun predictNextMove(pokemon: String, situation: String): Map<String, Double> {
-        val responses = situationResponses[situation] ?: return emptyMap()
-        val total = responses.values.sum().toDouble()
-
-        return if (total > 0) {
-            responses.mapValues { it.value / total }
-        } else {
-            emptyMap()
-        }
-    }
-
-    fun getSwitchProbability(pokemon: String, situation: String): Double {
-        val switches = switchHistory[pokemon]?.size ?: 0
-        val totalActions = (moveHistory[pokemon]?.size ?: 0) + switches
-
- 
-        if (totalActions < 5) return 0.2 
-
-        return min(0.8, switches.toDouble() / totalActions + 0.1)
-    }
-
-     
-    private fun getAggressionLevel(pokemon: String): Double = aggressionLevel[pokemon] ?: 0.5
-    private fun getSetupTendency(pokemon: String): Double = setupTendency[pokemon] ?: 0.3
-    private fun getSwitchFrequency(pokemon: String): Double = switchFrequency[pokemon] ?: 0.2
-
-    fun predictMoveHeuristically(
-        opponent: TrackedPokemon,
-        myPokemon: TrackedPokemon
-    ): Map<String, Double> {
-        val predictions = mutableMapOf<String, Double>()
-        val aggression = getAggressionLevel(opponent.species ?: "unknown")
-        for (moveName in opponent.revealedMoves) {
-            val moveData = Moves.getByName(moveName) ?: continue
-            var probability = 0.25
-
-            probability *= if (moveData.power > 0) {
-                aggression + 0.3
-            } else {
-                (1.0 - aggression) + 0.3
-            }
-
-            val myTypes = myPokemon.currentTypes ?: listOf()
-            val effectiveness = TypeEffectiveness.calculateTypeEffectiveness(moveData.elementalType, myTypes)
-            probability *= (0.5 + effectiveness)
-
-            predictions[moveName] = probability
-        }
-
-        val total = predictions.values.sum()
-        return if (total > 0) {
-            predictions.mapValues { it.value / total }
-        } else {
-            emptyMap()
-        }
-    }
-
-    fun predictSwitchTarget(
-        fromPokemon: String,
-        myActivePokemon: TrackedPokemon
-    ): Map<String, Double> {
-        val pastSwitches = switchHistory[fromPokemon] ?: return emptyMap()
-
- 
-        val switchCounts = mutableMapOf<String, Int>()
-        for (target in pastSwitches) {
-            switchCounts.merge(target, 1, Int::plus)
-        }
-
-        val total = switchCounts.values.sum().toDouble()
-        return if (total > 0) {
-            switchCounts.mapValues { it.value / total }
-        } else {
-            emptyMap()
-        }
-    }
-
-     
-    fun categorizePlaystyle(pokemon: String): OpponentPlaystyle {
-        val aggression = getAggressionLevel(pokemon)
-        val setupTend = getSetupTendency(pokemon)
-        val switchFreq = getSwitchFrequency(pokemon)
-
-        return when {
-            setupTend > 0.5 -> OpponentPlaystyle.SETUP_ORIENTED
-            aggression > 0.7 && switchFreq < 0.3 -> OpponentPlaystyle.HYPER_OFFENSIVE
-            switchFreq > 0.5 -> OpponentPlaystyle.MOMENTUM_BASED
-            aggression < 0.4 -> OpponentPlaystyle.DEFENSIVE_STALL
-            else -> OpponentPlaystyle.BALANCED
-        }
-    }
-
-     
-    fun reset() {
-        moveHistory.clear()
-        switchHistory.clear()
-        situationResponses.clear()
-        aggressionLevel.clear()
-        setupTendency.clear()
-        switchFrequency.clear()
-    }
-}
-
- 
-enum class OpponentPlaystyle {
-    HYPER_OFFENSIVE, 
-    SETUP_ORIENTED, 
-    MOMENTUM_BASED, 
-    DEFENSIVE_STALL, 
-    BALANCED 
-}
@@ -1,340 +0,0 @@
-package com.cobblemon.mod.common.battles.ai.competitive
-
-import com.cobblemon.mod.common.api.pokemon.stats.Stats
-import com.cobblemon.mod.common.pokemon.Pokemon
-import kotlin.math.max
-
-
-class StrategyAnalyzer {
-    fun analyzeTeamComposition(team: List<Pokemon>): GamePlan {
-        val roles = team.map { identifyPokemonRole(it) }
-        val sweepers = roles.count { it == PokemonRole.SWEEPER }
-        val setupSweepers = roles.count { it == PokemonRole.SETUP_SWEEPER }
-        val wallbreakers = roles.count { it == PokemonRole.WALLBREAKER }
-        val supports = roles.count { it in listOf(PokemonRole.SUPPORT, PokemonRole.TANK) }
-        val revengeKillers = roles.count { it == PokemonRole.REVENGE_KILLER }
-        val weatherStrategy = identifyWeatherStrategy(team)
-        if (weatherStrategy != null) {
-            return createWeatherGamePlan(weatherStrategy, team)
-        }
-        val hazardStrategy = identifyHazardStrategy(team)
-        if (hazardStrategy != null) {
-            return createHazardGamePlan(team)
-        }
-        val winCondition = when {
-            setupSweepers >= 2 && supports >= 2 -> WinCondition.SETUP_SWEEP
-            sweepers + wallbreakers >= 4 -> WinCondition.AGGRESSIVE_SWEEP
-            supports >= 3 -> WinCondition.DEFENSIVE_STALL
-            revengeKillers >= 2 -> WinCondition.REVENGE_KILLING
-            else -> WinCondition.BALANCED
-        }
-        return createGamePlan(winCondition, team, roles)
-    }
-
-
-    private fun identifyWeatherStrategy(team: List<Pokemon>): WinCondition? {
-        val rainSetters = team.count { hasWeatherSettingMove(it, "rain") || hasWeatherSettingAbility(it, "rain") }
-        val rainAbusers = team.count { hasWeatherAbility(it, "rain") || hasWeatherMoves(it, "rain") }
-        val sunSetters = team.count { hasWeatherSettingMove(it, "sun") || hasWeatherSettingAbility(it, "sun") }
-        val sunAbusers = team.count { hasWeatherAbility(it, "sun") || hasWeatherMoves(it, "sun") }
-        val sandSetters = team.count { hasWeatherSettingMove(it, "sand") || hasWeatherSettingAbility(it, "sand") }
-        val sandAbusers = team.count { hasWeatherAbility(it, "sand") }
-        return when {
-            rainSetters >= 1 && rainAbusers >= 2 -> WinCondition.RAIN_OFFENSE
-            sunSetters >= 1 && sunAbusers >= 2 -> WinCondition.SUN_OFFENSE
-            sandSetters >= 1 && sandAbusers >= 2 -> WinCondition.SAND_OFFENSE
-            rainSetters >= 1 || sunSetters >= 1 || sandSetters >= 1 -> WinCondition.WEATHER_CONTROL
-            else -> null
-        }
-    }
-
-    private fun identifyHazardStrategy(team: List<Pokemon>): Boolean {
-        val hazardSetters = team.count { pokemon ->
-            pokemon.moveSet.getMoves().any { it.name.lowercase() in MoveData.entryHazards }
-        }
-        val hazardRemovers = team.count { pokemon ->
-            pokemon.moveSet.getMoves().any { it.name.lowercase() in MoveData.antiHazardsMoves }
-        }
-        return hazardSetters >= 2 && hazardRemovers >= 1
-    }
-    private fun createWeatherGamePlan(winCondition: WinCondition, team: List<Pokemon>): GamePlan {
-        val weatherType = when (winCondition) {
-            WinCondition.RAIN_OFFENSE -> "rain"
-            WinCondition.SUN_OFFENSE -> "sun"
-            WinCondition.SAND_OFFENSE -> "sand"
-            else -> "any"
-        }
-        val setters =
-            team.filter { hasWeatherSettingMove(it, weatherType) || hasWeatherSettingAbility(it, weatherType) }
-        val abusers = team.filter { hasWeatherAbility(it, weatherType) || hasWeatherMoves(it, weatherType) }
-        val keyPokemon = (setters + abusers).distinct().map { it.species.name }
-        val priorities = when (winCondition) {
-            WinCondition.RAIN_OFFENSE -> listOf(
-                "set_rain_immediately",
-                "preserve_rain_setter",
-                "sweep_with_rain_abusers",
-                "use_perfect_accuracy_moves",
-                "prevent_weather_changes"
-            )
-            WinCondition.SUN_OFFENSE -> listOf(
-                "set_sun_immediately",
-                "preserve_sun_setter",
-                "sweep_with_chlorophyll",
-                "use_solar_beam",
-                "prevent_weather_changes"
-            )
-            WinCondition.SAND_OFFENSE -> listOf(
-                "set_sandstorm",
-                "abuse_sand_rush",
-                "chip_damage_from_sand",
-                "prevent_weather_changes"
-            )
-            else -> listOf("maintain_weather", "use_weather_abusers")
-        }
-
-        val riskyMoves = listOf(
-            "explosion",
-            "selfdestruct",
-            "memento"
-        )
-
-        return GamePlan(
-            winCondition = winCondition,
-            keyPokemon = keyPokemon,
-            priorities = priorities,
-            riskyMoves = riskyMoves,
-            aggressionLevel = 0.8,
-            setupPriority = 0.9
-        )
-    }
-
-
-    private fun createHazardGamePlan(team: List<Pokemon>): GamePlan {
-        val hazardSetters = team.filter { pokemon ->
-            pokemon.moveSet.getMoves().any { it.name.lowercase() in MoveData.entryHazards }
-        }.map { it.species.name }
-
-        return GamePlan(
-            winCondition = WinCondition.HAZARD_CONTROL,
-            keyPokemon = hazardSetters,
-            priorities = listOf(
-                "set_stealth_rock_early",
-                "stack_hazards_if_safe",
-                "remove_opponent_hazards",
-                "force_switches",
-                "preserve_hazard_setters"
-            ),
-            riskyMoves = listOf("explosion"),
-            aggressionLevel = 0.6,
-            setupPriority = 0.7
-        )
-    }
-
-
-    private fun createGamePlan(winCondition: WinCondition, team: List<Pokemon>, roles: List<PokemonRole>): GamePlan {
-        val keyPokemon = identifyKeyPokemon(winCondition, team, roles)
-
-        val priorities = when (winCondition) {
-            WinCondition.SETUP_SWEEP -> listOf(
-                "create_setup_opportunity",
-                "execute_setup_moves",
-                "sweep_after_setup",
-                "preserve_setup_sweeper",
-                "remove_priority_threats"
-            )
-
-            WinCondition.AGGRESSIVE_SWEEP -> listOf(
-                "maintain_offensive_pressure",
-                "use_coverage_moves",
-                "preserve_sweepers",
-                "use_priority_to_finish",
-                "momentum_over_setup"
-            )
-
-            WinCondition.DEFENSIVE_STALL -> listOf(
-                "spread_status_conditions",
-                "use_recovery_moves",
-                "set_up_hazards",
-                "stall_out_threats",
-                "remove_opponent_hazards"
-            )
-
-            WinCondition.REVENGE_KILLING -> listOf(
-                "preserve_revenge_killer",
-                "use_priority_strategically",
-                "chip_into_priority_range",
-                "scout_with_protect",
-                "maintain_momentum"
-            )
-
-            WinCondition.HAZARD_CONTROL -> listOf(
-                "set_stealth_rock_early",
-                "stack_hazards_safely",
-                "remove_opponent_hazards",
-                "force_switches"
-            )
-
-            else -> listOf(
-                "maintain_balance",
-                "adapt_to_opponent",
-                "resource_management",
-                "take_calculated_risks"
-            )
-        }
-
-        val riskyMoves = when (winCondition) {
-            WinCondition.SETUP_SWEEP -> listOf("explosion", "memento", "healingwish", "lunardance")
-            WinCondition.REVENGE_KILLING -> listOf("doubleedge", "bravebird", "flareblitz")
-            WinCondition.DEFENSIVE_STALL -> MoveData.recoilMoves
-            else -> listOf("explosion", "memento")
-        }
-
-        val aggressionLevel = when (winCondition) {
-            WinCondition.AGGRESSIVE_SWEEP -> 0.9
-            WinCondition.SETUP_SWEEP -> 0.7
-            WinCondition.REVENGE_KILLING -> 0.75
-            WinCondition.DEFENSIVE_STALL -> 0.3
-            else -> 0.6
-        }
-
-        val setupPriority = when (winCondition) {
-            WinCondition.SETUP_SWEEP -> 0.95
-            WinCondition.DEFENSIVE_STALL -> 0.6
-            else -> 0.5
-        }
-
-        return GamePlan(
-            winCondition = winCondition,
-            keyPokemon = keyPokemon,
-            priorities = priorities,
-            riskyMoves = riskyMoves,
-            aggressionLevel = aggressionLevel,
-            setupPriority = setupPriority
-        )
-    }
-
-
-    private fun identifyKeyPokemon(
-        winCondition: WinCondition,
-        team: List<Pokemon>,
-        roles: List<PokemonRole>
-    ): List<String> {
-        return when (winCondition) {
-            WinCondition.SETUP_SWEEP -> {
-                team.filterIndexed { index, _ -> roles[index] == PokemonRole.SETUP_SWEEPER }
-                    .map { it.species.name }
-            }
-
-            WinCondition.AGGRESSIVE_SWEEP -> {
-                team.filterIndexed { index, _ -> roles[index] in listOf(PokemonRole.SWEEPER, PokemonRole.WALLBREAKER) }
-                    .map { it.species.name }
-            }
-
-            WinCondition.REVENGE_KILLING -> {
-                team.filterIndexed { index, _ -> roles[index] == PokemonRole.REVENGE_KILLER }
-                    .map { it.species.name }
-            }
-
-            WinCondition.DEFENSIVE_STALL -> {
-                team.filterIndexed { index, _ -> roles[index] in listOf(PokemonRole.TANK, PokemonRole.SUPPORT) }
-                    .map { it.species.name }
-            }
-
-            else -> team.take(2).map { it.species.name }
-        }
-    }
-
-
-    fun identifyPokemonRole(pokemon: Pokemon): PokemonRole {
-        val attack = pokemon.species.baseStats[Stats.ATTACK] ?: 0
-        val spAttack = pokemon.species.baseStats[Stats.SPECIAL_ATTACK] ?: 0
-        val defense = pokemon.species.baseStats[Stats.DEFENCE] ?: 0
-        val spDefense = pokemon.species.baseStats[Stats.SPECIAL_DEFENCE] ?: 0
-        val speed = pokemon.species.baseStats[Stats.SPEED] ?: 0
-        val hp = pokemon.species.baseStats[Stats.HP] ?: 0
-
-        val maxAttack = max(attack, spAttack)
-        val avgDefense = (defense + spDefense) / 2.0
-        val bulk = hp + avgDefense
-
-        val hasSetupMoves = pokemon.moveSet.getMoves().any { it.name.lowercase() in MoveData.boostFromMoves.keys }
-        val hasPriorityMoves = pokemon.moveSet.getMoves().any { it.name.lowercase() in MoveData.priorityMoves }
-        val hasPivotMoves = pokemon.moveSet.getMoves().any { it.name.lowercase() in MoveData.pivotMoves }
-        val hasRecoveryMoves = pokemon.moveSet.getMoves().any { it.name.lowercase() in MoveData.selfRecoveryMoves }
-
-        return when {
-            hasPivotMoves -> PokemonRole.PIVOT
-            hasSetupMoves && speed >= 90 && maxAttack >= 90 -> PokemonRole.SETUP_SWEEPER
-            speed >= 110 && hasPriorityMoves -> PokemonRole.REVENGE_KILLER
-            speed >= 100 && maxAttack >= 100 -> PokemonRole.SWEEPER
-            maxAttack >= 120 -> PokemonRole.WALLBREAKER
-            bulk >= 180 && maxAttack < 80 -> PokemonRole.TANK
-            hasRecoveryMoves || hasSetupMoves -> PokemonRole.SUPPORT
-            else -> PokemonRole.BALANCED
-        }
-    }
-
-
-    private fun hasWeatherSettingMove(pokemon: Pokemon, weather: String): Boolean {
-        val moves = pokemon.moveSet.getMoves().map { it.name.lowercase() }
-        return when (weather) {
-            "rain" -> "raindance" in moves
-            "sun" -> "sunnyday" in moves
-            "sand" -> "sandstorm" in moves
-            else -> moves.any { it in MoveData.weatherMoves.keys }
-        }
-    }
-
-    private fun hasWeatherSettingAbility(pokemon: Pokemon, weather: String): Boolean {
-        val ability = pokemon.ability.name.lowercase()
-        return when (weather) {
-            "rain" -> ability == "drizzle"
-            "sun" -> ability == "drought"
-            "sand" -> ability == "sandstream"
-            else -> false
-        }
-    }
-
-    private fun hasWeatherAbility(pokemon: Pokemon, weather: String): Boolean {
-        val ability = pokemon.ability.name.lowercase()
-        return when (weather) {
-            "rain" -> ability in listOf("swiftswim", "raindish", "dryskin")
-            "sun" -> ability in listOf("chlorophyll", "leafguard", "flowergift", "solarpower")
-            "sand" -> ability in listOf("sandrush", "sandveil", "sandforce")
-            else -> MoveData.weatherAbilities[ability] == weather
-        }
-    }
-
-    private fun hasWeatherMoves(pokemon: Pokemon, weather: String): Boolean {
-        val moves = pokemon.moveSet.getMoves().map { it.name.lowercase() }
-        return when (weather) {
-            "rain" -> moves.any { it in listOf("thunder", "hurricane") }
-            "sun" -> moves.any { it in listOf("solarbeam", "hydrosteam") }
-            else -> false
-        }
-    }
-}
-
-
-enum class WinCondition {
-    AGGRESSIVE_SWEEP,
-    SETUP_SWEEP,
-    DEFENSIVE_STALL,
-    HAZARD_CONTROL,
-    REVENGE_KILLING,
-    BALANCED,
-    RAIN_OFFENSE,
-    SUN_OFFENSE,
-    SAND_OFFENSE,
-    WEATHER_CONTROL
-}
-
-
-data class GamePlan(
-    val winCondition: WinCondition,
-    val keyPokemon: List<String>,
-    val priorities: List<String>,
-    val riskyMoves: List<String>,
-    val aggressionLevel: Double = 0.6,
-    val setupPriority: Double = 0.5
-)
@@ -1,324 +0,0 @@
-package com.cobblemon.mod.common.battles.ai.competitive
-
-import com.cobblemon.mod.common.api.pokemon.stats.Stats
-import com.cobblemon.mod.common.battles.pokemon.BattlePokemon
-import com.cobblemon.mod.common.pokemon.Pokemon
-import kotlin.math.max
-
-
-class SwitchDecisionMaker(
-    private val damageCalculator: DamageCalculator,
-    private val opponentPredictor: OpponentPredictor,
-    private val strategyAnalyzer: StrategyAnalyzer
-) {
-
-
-    fun shouldVoluntarilySwitch(
-        myPokemon: TrackedPokemon,
-        opponentPokemon: TrackedPokemon,
-        battleState: BattleState,
-        gamePlan: GamePlan,
-        availableSwitches: List<BattlePokemon>
-    ): Boolean {
-        if (availableSwitches.isEmpty()) return false
-
-
-        val currentMatchup = evaluateMatchup(myPokemon, opponentPokemon, battleState)
-
-
-        val bestSwitchScore = availableSwitches.maxOfOrNull { switchOption ->
-            evaluateSwitchOption(
-                switchOption.effectedPokemon,
-                opponentPokemon,
-                battleState,
-                gamePlan
-            )
-        } ?: 0.0
-
-
-        val switchThreshold = 40.0
-        if (bestSwitchScore > currentMatchup.overallScore + switchThreshold) {
-            return true
-        }
-
-
-        val shouldSwitch = checkSwitchConditions(
-            myPokemon,
-            opponentPokemon,
-            battleState,
-            gamePlan,
-            currentMatchup
-        )
-
-        return shouldSwitch
-    }
-
-
-    fun findBestSwitch(
-        availableSwitches: List<BattlePokemon>,
-        opponentPokemon: TrackedPokemon,
-        battleState: BattleState,
-        gamePlan: GamePlan
-    ): BattlePokemon? {
-        if (availableSwitches.isEmpty()) return null
-
-        return availableSwitches.maxByOrNull { switchOption ->
-            evaluateSwitchOption(
-                switchOption.effectedPokemon,
-                opponentPokemon,
-                battleState,
-                gamePlan
-            )
-        }
-    }
-
-
-    fun evaluateSwitchOption(
-        candidate: Pokemon,
-        opponent: TrackedPokemon,
-        battleState: BattleState,
-        gamePlan: GamePlan
-    ): Double {
-        var score = 0.0
-
-
-        val candidateTracker = createTrackerPokemon(candidate)
-
-
-        val matchup = evaluateMatchup(candidateTracker, opponent, battleState)
-        score += matchup.overallScore
-
-
-        val hpFactor = candidateTracker.currentHpPercent
-        if (hpFactor < 0.5) {
-            score -= (1.0 - hpFactor) * 40.0
-        }
-
-
-        if (gamePlan.keyPokemon.contains(candidate.species.name)) {
-            score += 20.0
-        }
-
-
-        val mySpeed = getEffectiveStat(candidate, Stats.SPEED)
-        val oppSpeed = opponent.pokemon?.let { getEffectiveStat(it, Stats.SPEED) } ?: 0.0
-        if (mySpeed > oppSpeed) score += 25.0
-
-
-        val hazardDamage = calculateEntryHazardDamage(candidate, battleState.npcHazards)
-        score -= hazardDamage * 0.5
-
-
-        val role = strategyAnalyzer.identifyPokemonRole(candidate)
-        score += evaluateRoleSynergy(role, gamePlan, battleState)
-
-        return score
-    }
-
-
-    private fun evaluateMatchup(
-        myPokemon: TrackedPokemon,
-        opponent: TrackedPokemon,
-        battleState: BattleState
-    ): MatchupEvaluation {
-
-        val ourBestEffectiveness = calculateBestMoveEffectiveness(myPokemon, opponent)
-        val offensiveAdvantage = (ourBestEffectiveness - 1.0) * 40.0
-
-
-        val theirBestEffectiveness = calculateBestMoveEffectiveness(opponent, myPokemon)
-        val defensiveAdvantage = -(theirBestEffectiveness - 1.0) * 35.0
-
-
-        val mySpeed = myPokemon.pokemon?.let { getEffectiveStat(it, Stats.SPEED) } ?: 0.0
-        val oppSpeed = opponent.pokemon?.let { getEffectiveStat(it, Stats.SPEED) } ?: 0.0
-        val speedAdvantage = if (mySpeed > oppSpeed) 20.0 else -15.0
-
-
-        val overallScore = offensiveAdvantage + defensiveAdvantage + speedAdvantage
-
-
-        val recommendation = when {
-            overallScore > 60 && myPokemon.currentHpPercent > 0.7 -> MatchupRecommendation.STAY_IN_AND_SETUP
-            overallScore > 30 -> MatchupRecommendation.STAY_IN_AND_ATTACK
-            overallScore > 0 -> MatchupRecommendation.CONSIDER_SWITCHING
-            overallScore > -30 -> MatchupRecommendation.PIVOT_OUT
-            else -> MatchupRecommendation.SWITCH_OUT
-        }
-
-        return MatchupEvaluation(
-            offensiveAdvantage = offensiveAdvantage,
-            defensiveAdvantage = defensiveAdvantage,
-            speedAdvantage = speedAdvantage,
-            overallScore = overallScore,
-            recommendation = recommendation
-        )
-    }
-
-
-    private fun checkSwitchConditions(
-        myPokemon: TrackedPokemon,
-        opponent: TrackedPokemon,
-        battleState: BattleState,
-        gamePlan: GamePlan,
-        matchup: MatchupEvaluation
-    ): Boolean {
-
-        val theirBestEffectiveness = calculateBestMoveEffectiveness(opponent, myPokemon)
-        if (theirBestEffectiveness >= 2.0 && myPokemon.currentHpPercent > 0.3) {
-            return true
-        }
-
-
-        if (myPokemon.currentHpPercent < 0.3 && matchup.overallScore < 30) {
-            return true
-        }
-
-
-        if (opponent.boosts.values.any { it >= 2 } && matchup.overallScore < 20) {
-            return true
-        }
-
-
-        if (myPokemon.species in gamePlan.keyPokemon &&
-            myPokemon.currentHpPercent < 0.5 &&
-            theirBestEffectiveness > 1.0
-        ) {
-            return true
-        }
-
-        return false
-    }
-
-
-    private fun calculateBestMoveEffectiveness(
-        attacker: TrackedPokemon,
-        defender: TrackedPokemon
-    ): Double {
-        val moves = attacker.pokemon?.moveSet?.getMoves() ?: return 1.0
-        return moves.maxOfOrNull { move ->
-            TypeEffectiveness.calculateTypeEffectiveness(
-                move.type,
-                defender.currentTypes ?: listOf()
-            )
-        } ?: 1.0
-    }
-
-
-    private fun calculateEntryHazardDamage(pokemon: Pokemon, hazards: List<String>): Double {
-        var damage = 0.0
-        val maxHP = getEffectiveStat(pokemon, Stats.HP)
-
-        for (hazard in hazards) {
-            when (hazard.lowercase()) {
-                "stealthrock" -> {
-
-                    val rockEffectiveness = pokemon.types.fold(1.0) { acc, type ->
-                        acc * TypeEffectiveness.getDamageMultiplier(
-                            com.cobblemon.mod.common.api.types.ElementalTypes.ROCK,
-                            type
-                        )
-                    }
-                    damage += maxHP * rockEffectiveness * 0.125
-                }
-
-                "spikes" -> damage += maxHP * 0.125
-                "toxicspikes" -> {
-
-                    if (!pokemon.types.any { it.name.lowercase() in listOf("poison", "steel") }) {
-                        damage += maxHP * 0.15
-                    }
-                }
-
-                "stickyweb" -> damage += 10.0
-            }
-        }
-
-        return damage
-    }
-
-
-    private fun evaluateRoleSynergy(
-        role: PokemonRole,
-        gamePlan: GamePlan,
-        battleState: BattleState
-    ): Double {
-        return when (gamePlan.winCondition) {
-            WinCondition.SETUP_SWEEP -> {
-                when (role) {
-                    PokemonRole.SETUP_SWEEPER -> 50.0
-                    PokemonRole.SUPPORT -> if (battleState.gamePhase == GamePhase.EARLY_GAME) 30.0 else 10.0
-                    else -> 0.0
-                }
-            }
-
-            WinCondition.AGGRESSIVE_SWEEP -> {
-                when (role) {
-                    PokemonRole.SWEEPER, PokemonRole.WALLBREAKER -> 40.0
-                    PokemonRole.REVENGE_KILLER -> 30.0
-                    else -> 0.0
-                }
-            }
-
-            WinCondition.DEFENSIVE_STALL -> {
-                when (role) {
-                    PokemonRole.TANK, PokemonRole.SUPPORT -> 45.0
-                    else -> -10.0
-                }
-            }
-
-            WinCondition.REVENGE_KILLING -> {
-                when (role) {
-                    PokemonRole.REVENGE_KILLER -> 60.0
-                    PokemonRole.PIVOT -> 25.0
-                    else -> 0.0
-                }
-            }
-
-            WinCondition.RAIN_OFFENSE, WinCondition.SUN_OFFENSE, WinCondition.SAND_OFFENSE -> {
-
-                when (role) {
-                    PokemonRole.SWEEPER -> 35.0
-                    else -> 0.0
-                }
-            }
-
-            else -> 0.0
-        }
-    }
-
-
-    private fun createTrackerPokemon(pokemon: Pokemon): TrackedPokemon {
-        val tracker = TrackedPokemon(
-            pokemon = pokemon,
-            originalPokemon = pokemon,
-            species = pokemon.species.name,
-            currentHp = pokemon.currentHealth,
-            maxHp = pokemon.maxHealth,
-            currentHpPercent = pokemon.currentHealth.toDouble() / pokemon.maxHealth,
-            currentTypes = pokemon.types.map { it.name.lowercase() }.toMutableList(),
-            currentAbility = pokemon.ability.name,
-            moves = pokemon.moveSet.getMoves(),
-            predictedRole = strategyAnalyzer.identifyPokemonRole(pokemon),
-            cachedAttack = getEffectiveStat(pokemon, Stats.ATTACK),
-            cachedDefense = getEffectiveStat(pokemon, Stats.DEFENCE),
-            cachedSpAttack = getEffectiveStat(pokemon, Stats.SPECIAL_ATTACK),
-            cachedSpDefense = getEffectiveStat(pokemon, Stats.SPECIAL_DEFENCE),
-            cachedSpeed = getEffectiveStat(pokemon, Stats.SPEED)
-        )
-        return tracker
-    }
-
-    private fun getEffectiveStat(pokemon: Pokemon, stat: Stats): Double {
-        val base = pokemon.species.baseStats[stat] ?: 0
-        val iv = pokemon.ivs[stat] ?: 31
-        val ev = pokemon.evs[stat] ?: 0
-        val level = pokemon.level
-
-        return if (stat == Stats.HP) {
-            ((2.0 * base + iv + ev / 4.0) * level / 100.0 + level + 10.0)
-        } else {
-            ((2.0 * base + iv + ev / 4.0) * level / 100.0 + 5.0)
-        }
-    }
-}
@@ -1,403 +0,0 @@
-package com.cobblemon.mod.common.battles.ai.competitive
-
-import com.cobblemon.mod.common.api.types.ElementalType
-import com.cobblemon.mod.common.api.types.ElementalTypes
-
-
-object TypeEffectiveness {
-
-
-    val typeEffectivenessMap: Map<ElementalType, Map<ElementalType, Double>> = mapOf(
-        ElementalTypes.NORMAL to mapOf(
-            ElementalTypes.NORMAL to 1.0,
-            ElementalTypes.FIRE to 1.0,
-            ElementalTypes.WATER to 1.0,
-            ElementalTypes.ELECTRIC to 1.0,
-            ElementalTypes.GRASS to 1.0,
-            ElementalTypes.ICE to 1.0,
-            ElementalTypes.FIGHTING to 1.0,
-            ElementalTypes.POISON to 1.0,
-            ElementalTypes.GROUND to 1.0,
-            ElementalTypes.FLYING to 1.0,
-            ElementalTypes.PSYCHIC to 1.0,
-            ElementalTypes.BUG to 1.0,
-            ElementalTypes.ROCK to 0.5,
-            ElementalTypes.GHOST to 0.0,
-            ElementalTypes.DRAGON to 1.0,
-            ElementalTypes.DARK to 1.0,
-            ElementalTypes.STEEL to 0.5,
-            ElementalTypes.FAIRY to 1.0
-        ),
-        ElementalTypes.FIRE to mapOf(
-            ElementalTypes.NORMAL to 1.0,
-            ElementalTypes.FIRE to 0.5,
-            ElementalTypes.WATER to 0.5,
-            ElementalTypes.ELECTRIC to 1.0,
-            ElementalTypes.GRASS to 2.0,
-            ElementalTypes.ICE to 2.0,
-            ElementalTypes.FIGHTING to 1.0,
-            ElementalTypes.POISON to 1.0,
-            ElementalTypes.GROUND to 1.0,
-            ElementalTypes.FLYING to 1.0,
-            ElementalTypes.PSYCHIC to 1.0,
-            ElementalTypes.BUG to 2.0,
-            ElementalTypes.ROCK to 0.5,
-            ElementalTypes.GHOST to 1.0,
-            ElementalTypes.DRAGON to 0.5,
-            ElementalTypes.DARK to 1.0,
-            ElementalTypes.STEEL to 2.0,
-            ElementalTypes.FAIRY to 1.0
-        ),
-        ElementalTypes.WATER to mapOf(
-            ElementalTypes.NORMAL to 1.0,
-            ElementalTypes.FIRE to 2.0,
-            ElementalTypes.WATER to 0.5,
-            ElementalTypes.ELECTRIC to 1.0,
-            ElementalTypes.GRASS to 0.5,
-            ElementalTypes.ICE to 1.0,
-            ElementalTypes.FIGHTING to 1.0,
-            ElementalTypes.POISON to 1.0,
-            ElementalTypes.GROUND to 2.0,
-            ElementalTypes.FLYING to 1.0,
-            ElementalTypes.PSYCHIC to 1.0,
-            ElementalTypes.BUG to 1.0,
-            ElementalTypes.ROCK to 2.0,
-            ElementalTypes.GHOST to 1.0,
-            ElementalTypes.DRAGON to 0.5,
-            ElementalTypes.DARK to 1.0,
-            ElementalTypes.STEEL to 1.0,
-            ElementalTypes.FAIRY to 1.0
-        ),
-        ElementalTypes.ELECTRIC to mapOf(
-            ElementalTypes.NORMAL to 1.0,
-            ElementalTypes.FIRE to 1.0,
-            ElementalTypes.WATER to 2.0,
-            ElementalTypes.ELECTRIC to 0.5,
-            ElementalTypes.GRASS to 0.5,
-            ElementalTypes.ICE to 1.0,
-            ElementalTypes.FIGHTING to 1.0,
-            ElementalTypes.POISON to 1.0,
-            ElementalTypes.GROUND to 0.0,
-            ElementalTypes.FLYING to 2.0,
-            ElementalTypes.PSYCHIC to 1.0,
-            ElementalTypes.BUG to 1.0,
-            ElementalTypes.ROCK to 1.0,
-            ElementalTypes.GHOST to 1.0,
-            ElementalTypes.DRAGON to 0.5,
-            ElementalTypes.DARK to 1.0,
-            ElementalTypes.STEEL to 1.0,
-            ElementalTypes.FAIRY to 1.0
-        ),
-        ElementalTypes.GRASS to mapOf(
-            ElementalTypes.NORMAL to 1.0,
-            ElementalTypes.FIRE to 0.5,
-            ElementalTypes.WATER to 2.0,
-            ElementalTypes.ELECTRIC to 1.0,
-            ElementalTypes.GRASS to 0.5,
-            ElementalTypes.ICE to 1.0,
-            ElementalTypes.FIGHTING to 1.0,
-            ElementalTypes.POISON to 0.5,
-            ElementalTypes.GROUND to 2.0,
-            ElementalTypes.FLYING to 0.5,
-            ElementalTypes.PSYCHIC to 1.0,
-            ElementalTypes.BUG to 0.5,
-            ElementalTypes.ROCK to 2.0,
-            ElementalTypes.GHOST to 1.0,
-            ElementalTypes.DRAGON to 0.5,
-            ElementalTypes.DARK to 1.0,
-            ElementalTypes.STEEL to 0.5,
-            ElementalTypes.FAIRY to 1.0
-        ),
-        ElementalTypes.ICE to mapOf(
-            ElementalTypes.NORMAL to 1.0,
-            ElementalTypes.FIRE to 0.5,
-            ElementalTypes.WATER to 0.5,
-            ElementalTypes.ELECTRIC to 1.0,
-            ElementalTypes.GRASS to 2.0,
-            ElementalTypes.ICE to 0.5,
-            ElementalTypes.FIGHTING to 1.0,
-            ElementalTypes.POISON to 1.0,
-            ElementalTypes.GROUND to 2.0,
-            ElementalTypes.FLYING to 2.0,
-            ElementalTypes.PSYCHIC to 1.0,
-            ElementalTypes.BUG to 1.0,
-            ElementalTypes.ROCK to 1.0,
-            ElementalTypes.GHOST to 1.0,
-            ElementalTypes.DRAGON to 2.0,
-            ElementalTypes.DARK to 1.0,
-            ElementalTypes.STEEL to 0.5,
-            ElementalTypes.FAIRY to 1.0
-        ),
-        ElementalTypes.FIGHTING to mapOf(
-            ElementalTypes.NORMAL to 2.0,
-            ElementalTypes.FIRE to 1.0,
-            ElementalTypes.WATER to 1.0,
-            ElementalTypes.ELECTRIC to 1.0,
-            ElementalTypes.GRASS to 1.0,
-            ElementalTypes.ICE to 2.0,
-            ElementalTypes.FIGHTING to 1.0,
-            ElementalTypes.POISON to 0.5,
-            ElementalTypes.GROUND to 1.0,
-            ElementalTypes.FLYING to 0.5,
-            ElementalTypes.PSYCHIC to 0.5,
-            ElementalTypes.BUG to 0.5,
-            ElementalTypes.ROCK to 2.0,
-            ElementalTypes.GHOST to 0.0,
-            ElementalTypes.DRAGON to 1.0,
-            ElementalTypes.DARK to 2.0,
-            ElementalTypes.STEEL to 2.0,
-            ElementalTypes.FAIRY to 0.5
-        ),
-        ElementalTypes.POISON to mapOf(
-            ElementalTypes.NORMAL to 1.0,
-            ElementalTypes.FIRE to 1.0,
-            ElementalTypes.WATER to 1.0,
-            ElementalTypes.ELECTRIC to 1.0,
-            ElementalTypes.GRASS to 2.0,
-            ElementalTypes.ICE to 1.0,
-            ElementalTypes.FIGHTING to 1.0,
-            ElementalTypes.POISON to 0.5,
-            ElementalTypes.GROUND to 0.5,
-            ElementalTypes.FLYING to 1.0,
-            ElementalTypes.PSYCHIC to 1.0,
-            ElementalTypes.BUG to 1.0,
-            ElementalTypes.ROCK to 0.5,
-            ElementalTypes.GHOST to 0.5,
-            ElementalTypes.DRAGON to 1.0,
-            ElementalTypes.DARK to 1.0,
-            ElementalTypes.STEEL to 0.0,
-            ElementalTypes.FAIRY to 2.0
-        ),
-        ElementalTypes.GROUND to mapOf(
-            ElementalTypes.NORMAL to 1.0,
-            ElementalTypes.FIRE to 2.0,
-            ElementalTypes.WATER to 1.0,
-            ElementalTypes.ELECTRIC to 2.0,
-            ElementalTypes.GRASS to 0.5,
-            ElementalTypes.ICE to 1.0,
-            ElementalTypes.FIGHTING to 1.0,
-            ElementalTypes.POISON to 2.0,
-            ElementalTypes.GROUND to 1.0,
-            ElementalTypes.FLYING to 0.0,
-            ElementalTypes.PSYCHIC to 1.0,
-            ElementalTypes.BUG to 0.5,
-            ElementalTypes.ROCK to 2.0,
-            ElementalTypes.GHOST to 1.0,
-            ElementalTypes.DRAGON to 1.0,
-            ElementalTypes.DARK to 1.0,
-            ElementalTypes.STEEL to 2.0,
-            ElementalTypes.FAIRY to 1.0
-        ),
-        ElementalTypes.FLYING to mapOf(
-            ElementalTypes.NORMAL to 1.0,
-            ElementalTypes.FIRE to 1.0,
-            ElementalTypes.WATER to 1.0,
-            ElementalTypes.ELECTRIC to 0.5,
-            ElementalTypes.GRASS to 2.0,
-            ElementalTypes.ICE to 1.0,
-            ElementalTypes.FIGHTING to 2.0,
-            ElementalTypes.POISON to 1.0,
-            ElementalTypes.GROUND to 1.0,
-            ElementalTypes.FLYING to 1.0,
-            ElementalTypes.PSYCHIC to 1.0,
-            ElementalTypes.BUG to 2.0,
-            ElementalTypes.ROCK to 0.5,
-            ElementalTypes.GHOST to 1.0,
-            ElementalTypes.DRAGON to 1.0,
-            ElementalTypes.DARK to 1.0,
-            ElementalTypes.STEEL to 0.5,
-            ElementalTypes.FAIRY to 1.0
-        ),
-        ElementalTypes.PSYCHIC to mapOf(
-            ElementalTypes.NORMAL to 1.0,
-            ElementalTypes.FIRE to 1.0,
-            ElementalTypes.WATER to 1.0,
-            ElementalTypes.ELECTRIC to 1.0,
-            ElementalTypes.GRASS to 1.0,
-            ElementalTypes.ICE to 1.0,
-            ElementalTypes.FIGHTING to 2.0,
-            ElementalTypes.POISON to 2.0,
-            ElementalTypes.GROUND to 1.0,
-            ElementalTypes.FLYING to 1.0,
-            ElementalTypes.PSYCHIC to 0.5,
-            ElementalTypes.BUG to 1.0,
-            ElementalTypes.ROCK to 1.0,
-            ElementalTypes.GHOST to 1.0,
-            ElementalTypes.DRAGON to 1.0,
-            ElementalTypes.DARK to 0.0,
-            ElementalTypes.STEEL to 0.5,
-            ElementalTypes.FAIRY to 1.0
-        ),
-        ElementalTypes.BUG to mapOf(
-            ElementalTypes.NORMAL to 1.0,
-            ElementalTypes.FIRE to 0.5,
-            ElementalTypes.WATER to 1.0,
-            ElementalTypes.ELECTRIC to 1.0,
-            ElementalTypes.GRASS to 2.0,
-            ElementalTypes.ICE to 1.0,
-            ElementalTypes.FIGHTING to 0.5,
-            ElementalTypes.POISON to 0.5,
-            ElementalTypes.GROUND to 1.0,
-            ElementalTypes.FLYING to 0.5,
-            ElementalTypes.PSYCHIC to 2.0,
-            ElementalTypes.BUG to 1.0,
-            ElementalTypes.ROCK to 1.0,
-            ElementalTypes.GHOST to 0.5,
-            ElementalTypes.DRAGON to 1.0,
-            ElementalTypes.DARK to 2.0,
-            ElementalTypes.STEEL to 0.5,
-            ElementalTypes.FAIRY to 0.5
-        ),
-        ElementalTypes.ROCK to mapOf(
-            ElementalTypes.NORMAL to 1.0,
-            ElementalTypes.FIRE to 2.0,
-            ElementalTypes.WATER to 1.0,
-            ElementalTypes.ELECTRIC to 1.0,
-            ElementalTypes.GRASS to 1.0,
-            ElementalTypes.ICE to 2.0,
-            ElementalTypes.FIGHTING to 0.5,
-            ElementalTypes.POISON to 1.0,
-            ElementalTypes.GROUND to 0.5,
-            ElementalTypes.FLYING to 2.0,
-            ElementalTypes.PSYCHIC to 1.0,
-            ElementalTypes.BUG to 2.0,
-            ElementalTypes.ROCK to 1.0,
-            ElementalTypes.GHOST to 1.0,
-            ElementalTypes.DRAGON to 1.0,
-            ElementalTypes.DARK to 1.0,
-            ElementalTypes.STEEL to 0.5,
-            ElementalTypes.FAIRY to 1.0
-        ),
-        ElementalTypes.GHOST to mapOf(
-            ElementalTypes.NORMAL to 0.0,
-            ElementalTypes.FIRE to 1.0,
-            ElementalTypes.WATER to 1.0,
-            ElementalTypes.ELECTRIC to 1.0,
-            ElementalTypes.GRASS to 1.0,
-            ElementalTypes.ICE to 1.0,
-            ElementalTypes.FIGHTING to 1.0,
-            ElementalTypes.POISON to 1.0,
-            ElementalTypes.GROUND to 1.0,
-            ElementalTypes.FLYING to 1.0,
-            ElementalTypes.PSYCHIC to 2.0,
-            ElementalTypes.BUG to 1.0,
-            ElementalTypes.ROCK to 1.0,
-            ElementalTypes.GHOST to 2.0,
-            ElementalTypes.DRAGON to 1.0,
-            ElementalTypes.DARK to 0.5,
-            ElementalTypes.STEEL to 1.0,
-            ElementalTypes.FAIRY to 1.0
-        ),
-        ElementalTypes.DRAGON to mapOf(
-            ElementalTypes.NORMAL to 1.0,
-            ElementalTypes.FIRE to 1.0,
-            ElementalTypes.WATER to 1.0,
-            ElementalTypes.ELECTRIC to 1.0,
-            ElementalTypes.GRASS to 1.0,
-            ElementalTypes.ICE to 1.0,
-            ElementalTypes.FIGHTING to 1.0,
-            ElementalTypes.POISON to 1.0,
-            ElementalTypes.GROUND to 1.0,
-            ElementalTypes.FLYING to 1.0,
-            ElementalTypes.PSYCHIC to 1.0,
-            ElementalTypes.BUG to 1.0,
-            ElementalTypes.ROCK to 1.0,
-            ElementalTypes.GHOST to 1.0,
-            ElementalTypes.DRAGON to 2.0,
-            ElementalTypes.DARK to 1.0,
-            ElementalTypes.STEEL to 0.5,
-            ElementalTypes.FAIRY to 0.0
-        ),
-        ElementalTypes.DARK to mapOf(
-            ElementalTypes.NORMAL to 1.0,
-            ElementalTypes.FIRE to 1.0,
-            ElementalTypes.WATER to 1.0,
-            ElementalTypes.ELECTRIC to 1.0,
-            ElementalTypes.GRASS to 1.0,
-            ElementalTypes.ICE to 1.0,
-            ElementalTypes.FIGHTING to 0.5,
-            ElementalTypes.POISON to 1.0,
-            ElementalTypes.GROUND to 1.0,
-            ElementalTypes.FLYING to 1.0,
-            ElementalTypes.PSYCHIC to 2.0,
-            ElementalTypes.BUG to 1.0,
-            ElementalTypes.ROCK to 1.0,
-            ElementalTypes.GHOST to 2.0,
-            ElementalTypes.DRAGON to 1.0,
-            ElementalTypes.DARK to 0.5,
-            ElementalTypes.STEEL to 1.0,
-            ElementalTypes.FAIRY to 0.5
-        ),
-        ElementalTypes.STEEL to mapOf(
-            ElementalTypes.NORMAL to 1.0,
-            ElementalTypes.FIRE to 0.5,
-            ElementalTypes.WATER to 0.5,
-            ElementalTypes.ELECTRIC to 0.5,
-            ElementalTypes.GRASS to 1.0,
-            ElementalTypes.ICE to 2.0,
-            ElementalTypes.FIGHTING to 1.0,
-            ElementalTypes.POISON to 1.0,
-            ElementalTypes.GROUND to 1.0,
-            ElementalTypes.FLYING to 1.0,
-            ElementalTypes.PSYCHIC to 1.0,
-            ElementalTypes.BUG to 1.0,
-            ElementalTypes.ROCK to 2.0,
-            ElementalTypes.GHOST to 1.0,
-            ElementalTypes.DRAGON to 1.0,
-            ElementalTypes.DARK to 1.0,
-            ElementalTypes.STEEL to 0.5,
-            ElementalTypes.FAIRY to 2.0
-        ),
-        ElementalTypes.FAIRY to mapOf(
-            ElementalTypes.NORMAL to 1.0,
-            ElementalTypes.FIRE to 0.5,
-            ElementalTypes.WATER to 1.0,
-            ElementalTypes.ELECTRIC to 1.0,
-            ElementalTypes.GRASS to 1.0,
-            ElementalTypes.ICE to 1.0,
-            ElementalTypes.FIGHTING to 2.0,
-            ElementalTypes.POISON to 0.5,
-            ElementalTypes.GROUND to 1.0,
-            ElementalTypes.FLYING to 1.0,
-            ElementalTypes.PSYCHIC to 1.0,
-            ElementalTypes.BUG to 1.0,
-            ElementalTypes.ROCK to 1.0,
-            ElementalTypes.GHOST to 1.0,
-            ElementalTypes.DRAGON to 2.0,
-            ElementalTypes.DARK to 2.0,
-            ElementalTypes.STEEL to 0.5,
-            ElementalTypes.FAIRY to 1.0
-        )
-    )
-
-
-    fun getDamageMultiplier(attackerType: ElementalType, defenderType: ElementalType): Double {
-        return typeEffectivenessMap[attackerType]?.get(defenderType) ?: 1.0
-    }
-
-
-    fun calculateTypeEffectiveness(moveType: ElementalType, defenderTypes: List<String>): Double {
-        var multiplier = 1.0
-        for (typeString in defenderTypes) {
-            val defenderType = ElementalTypes.get(typeString.lowercase())
-            if (defenderType != null) {
-                multiplier *= getDamageMultiplier(moveType, defenderType)
-            }
-        }
-        return multiplier
-    }
-
-
-    fun getEffectivenessCategory(effectiveness: Double): EffectivenessCategory {
-        return when {
-            effectiveness == 0.0 -> EffectivenessCategory.IMMUNE
-            effectiveness < 1.0 -> EffectivenessCategory.NOT_VERY_EFFECTIVE
-            effectiveness == 1.0 -> EffectivenessCategory.NEUTRAL
-            else -> EffectivenessCategory.SUPER_EFFECTIVE
-        }
-    }
-
-    enum class EffectivenessCategory {
-        IMMUNE, NOT_VERY_EFFECTIVE, NEUTRAL, SUPER_EFFECTIVE
-    }
-}
@@ -31,6 +31,7 @@ class WeatherInstruction(val message: BattleMessage): InterpreterInstruction {
        val weather = message.effectAt(0)?.id ?: return
        val source = message.battlePokemonFromOptional(battle)
        source?.let { ShowdownInterpreter.broadcastOptionalAbility(battle, message.effect(), source) }
+
        battle.dispatchWaiting(1.5F) {
            val lang = when {
                message.hasOptionalArgument("upkeep") -> battleLang("weather.$weather.upkeep")
@@ -138,7 +138,8 @@ abstract class BattleGimmickButton(gimmick: ShowdownMoveset.Gimmick, val x: Floa
                pp = gimmickTemplate?.pp ?: moveTemplate.pp,
                priority = gimmickTemplate?.priority ?: moveTemplate.priority,
                critRatio = gimmickTemplate?.critRatio ?: moveTemplate.critRatio,
-                effectChances = gimmickTemplate?.effectChances ?: moveTemplate.effectChances
+                effectChances = gimmickTemplate?.effectChances ?: moveTemplate.effectChances,
+                weight = gimmickTemplate?.weight ?: moveTemplate.weight
            )
        }
    }
@@ -143,18 +143,18 @@ object PartySendBinding : CobblemonBlockingKeyBinding(
    }

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

    private fun isRidingPokemon(player: LocalPlayer, ignoreControlling: Boolean = false): Boolean {
@@ -1,27 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.client.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)
-    }
-}
@@ -8,8 +8,6 @@

 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
@@ -33,14 +31,7 @@ object ClientPersistedData {
    fun readSnapshotsData() : SnapshotAcknowledgementData? {
        if (snapshotsPath.exists()) {
            BufferedReader(InputStreamReader(FileInputStream(snapshotsPath.toFile()))).use { reader ->
-                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
-                }
+                return gson.fromJson(reader, SnapshotAcknowledgementData::class.java)
            }
        }

@@ -55,23 +46,16 @@ object ClientPersistedData {
    fun readRidingPerspectivesData() : RidingPerspectiveData? {
        if (ridingPerspectivesPath.exists()) {
            BufferedReader(InputStreamReader(FileInputStream(ridingPerspectivesPath.toFile()))).use { reader ->
-                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 gson.fromJson(reader, RidingPerspectiveData::class.java)
            }
        }

        return null
    }

-    fun saveRidingPerspectivesData(data: RidingPerspectiveData) {
+    fun saveRidingPerspectivesData() {
        ridingPerspectivesPath.toFile().parentFile.mkdirs()
-        BufferedWriter(FileWriter(ridingPerspectivesPath.toFile())).use { writer -> gson.toJson(data, writer) }
+        BufferedWriter(FileWriter(ridingPerspectivesPath.toFile())).use { writer -> gson.toJson(ridingPerspectives, writer) }
    }

    data class SnapshotAcknowledgementData(val version: String, val dontShowAgain: Boolean)
@@ -80,7 +64,7 @@ object ClientPersistedData {
    ) {
        fun updatePerspective(key: ResourceLocation, cameraType: CameraType) {
            perspectives[key] = cameraType
-            saveRidingPerspectivesData(this)
+            saveRidingPerspectivesData()
        }
    }
 }
@@ -329,9 +329,6 @@ 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

@@ -14,6 +14,9 @@ import com.cobblemon.mod.common.CobblemonBehaviours
 import com.cobblemon.mod.common.CobblemonCallbacks
 import com.cobblemon.mod.common.CobblemonCosmeticItems
 import com.cobblemon.mod.common.CobblemonMechanics
+import com.cobblemon.mod.common.CobblemonMovesetBuilders
+import com.cobblemon.mod.common.CobblemonPartyCompositions
+import com.cobblemon.mod.common.CobblemonPartyPools
 import com.cobblemon.mod.common.CobblemonRideSettings
 import com.cobblemon.mod.common.CobblemonUnlockableWallpapers
 import com.cobblemon.mod.common.api.abilities.Abilities
@@ -78,12 +81,15 @@ object CobblemonDataProvider : DataProvider {
        this.register(SpeciesFeatureAssignments, reloadable = false)
        this.register(ActionEffects, reloadable = true)
        this.register(Moves, reloadable = false)
+        this.register(CobblemonMovesetBuilders, reloadable = false)
        this.register(Abilities, reloadable = false)
        this.register(CobblemonBehaviours, reloadable = false)
        this.register(PokemonSpecies, reloadable = false)
        this.register(SpeciesAdditions, reloadable = false)
        this.register(PokeBalls, reloadable = false)
        this.register(PropertiesCompletionProvider, reloadable = false)
+        this.register(CobblemonPartyPools, reloadable = false)
+        this.register(CobblemonPartyCompositions, reloadable = false)
        this.register(SpawnDetailPresets, reloadable = true)
        this.register(CobblemonSpawnRules, reloadable = true)
        this.register(CobblemonMechanics, reloadable = true)
@@ -269,6 +269,9 @@ 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)
    }

@@ -802,14 +802,13 @@ class PokeRodFishingBobberEntity(type: EntityType<out PokeRodFishingBobberEntity

        spawnAction.complete()
        val result = spawnAction.future
-        val resultingSpawn = result.get()
-
-        if (resultingSpawn == null) {
+        if (result.isCompletedExceptionally) {
            noBite(player)
            return false
        }

        var spawnedPokemon: PokemonEntity? = null
+        val resultingSpawn = result.get()

        if (resultingSpawn is EntitySpawnResult) {
            for (entity in resultingSpawn.entities) {
@@ -14,7 +14,6 @@ import com.cobblemon.mod.common.api.battles.model.actor.BattleActor
 import com.cobblemon.mod.common.api.battles.model.actor.EntityBackedBattleActor
 import com.cobblemon.mod.common.api.net.NetworkPacket
 import com.cobblemon.mod.common.api.storage.party.PartyStore
-import com.cobblemon.mod.common.battles.ai.CompetitiveBattleAI
 import com.cobblemon.mod.common.battles.ai.StrongBattleAI
 import com.cobblemon.mod.common.battles.pokemon.BattlePokemon
 import com.cobblemon.mod.common.net.messages.client.battle.BattleEndPacket
@@ -31,7 +30,7 @@ class NPCBattleActor(
 ) : AIBattleActor(
    gameId = npc.uuid,
    pokemonList = pokemonList.let { if (npc.npc.randomizePartyOrder) it.shuffled() else it },
-    battleAI = CompetitiveBattleAI(skill)
+    battleAI = StrongBattleAI(skill)
 ), EntityBackedBattleActor<NPCEntity> {
    override val entity = npc
    override val type = ActorType.NPC
@@ -191,7 +191,7 @@ class EmptyPokeBallEntity : ThrowableItemProjectile, PosableEntity, WaterDragMod
                }
            }
        } else {
-            setNoGravity(false)
+            isNoGravity = false
            deltaMovement = Vec3.ZERO
        }
    }
@@ -1208,13 +1208,14 @@ open class PokemonEntity(
            }
        }

-        if (hand == InteractionHand.MAIN_HAND) {
-            if (player.isShiftKeyDown && player is ServerPlayer) {
+        if (hand == InteractionHand.MAIN_HAND && player is ServerPlayer) {
+            if (player.isShiftKeyDown) {
                showInteractionWheel(player, itemStack)
                return InteractionResult.sidedSuccess(level().isClientSide)
            }
-            else if (this.ownerUUID == player.uuid && this.attemptItemInteraction(player, player.getItemInHand(hand))) {
-                return InteractionResult.sidedSuccess(level().isClientSide)
+            else if (pokemon.getOwnerPlayer() == player) {
+                // TODO #105
+                if (this.attemptItemInteraction(player, player.getItemInHand(hand))) return InteractionResult.SUCCESS
            }
        }

@@ -1281,7 +1282,7 @@ open class PokemonEntity(
    }

    override fun shouldBeSaved(): Boolean {
-        if (ownerUUID == null && !pokemon.isNPCOwned() && (Cobblemon.config.savePokemonToWorld || isPersistenceRequired)) {
+        if (ownerUUID == null && !pokemon.isNPCOwned() && (Cobblemon.config.savePokemonToWorld || isPersistenceRequired || this.pokemon.canDropHeldItem)) {
            CobblemonEvents.POKEMON_ENTITY_SAVE_TO_WORLD.postThen(PokemonEntitySaveToWorldEvent(this)) {
                return true
            }
@@ -1390,24 +1391,18 @@ open class PokemonEntity(
            return bagItemLike.handleInteraction(player, battlePokemon, stack)
        }

-        if (this.isBusy) {
+        if (player !is ServerPlayer || this.isBusy) {
            return false
        }

        val interaction = PokemonInteractions.findInteraction(this)
+
        if (interaction != null && !pokemon.isOnInteractionCooldown(interaction.grouping)) {
-            if (player is ServerPlayer) {
-                interaction.effects.forEach { it.applyEffect(this, player) }
-                pokemon.interactionCooldowns.put(interaction.grouping, runtime.resolveInt(interaction.cooldown))
-            }
-
+            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())
@@ -30,13 +30,21 @@ 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.*
+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.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.*
+import java.util.UUID

 object StatHandler : EventHandler {
    override fun registerListeners() {
@@ -92,13 +100,13 @@ object StatHandler : EventHandler {

    fun onBattleStart(event : BattleStartedEvent) {
        event.battle.players.forEach { player ->
-            player.awardStat(getStat(Cobblemon.statistics.BATTLES_TOTAL))
+            player.awardStat(this.getStat(getStat(Cobblemon.statistics.BATTLES_TOTAL)))
        }
    }

    fun onDexEntryGain(event : PokemonGainedEvent) {
        val player = event.pokemon.getOwnerPlayer()
-        player?.awardStat(getStat(Cobblemon.statistics.DEX_ENTRIES))
+        player?.awardStat(getStat(getStat(Cobblemon.statistics.DEX_ENTRIES)))
    }

    fun onCollectEgg(event : CollectEggEvent) {
@@ -131,4 +139,12 @@ 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")
+    }
 }
@@ -25,7 +25,9 @@ class MochiItem(stat: Stats): EVIncreaseItem(stat, 4) {
        }

        pokemon.feedPokemon(1)
-        
+
+        stack.consume(1, player)
+
        return super.applyToPokemon(player, stack, pokemon)
    }
 }
@@ -35,16 +35,9 @@ class SinisterTeaItem : Item(
            val effectsComponent = stack.get(CobblemonItemComponents.MOB_EFFECTS)

            if (effectsComponent != null) {
-                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)
-                    }
+                for (effect in effectsComponent.mobEffects) {
+                    val effectCopy = MobEffectInstance(effect)
+                    user.addEffect(effectCopy)
                }
            }
        }
@@ -13,7 +13,11 @@ import com.cobblemon.mod.common.api.moves.Moves
 import com.cobblemon.mod.common.api.moves.categories.DamageCategories
 import com.cobblemon.mod.common.api.types.ElementalTypes
 import com.cobblemon.mod.common.battles.MoveTarget
-import com.cobblemon.mod.common.util.*
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.cobblemon.mod.common.util.readEnumConstant
+import com.cobblemon.mod.common.util.readString
+import com.cobblemon.mod.common.util.writeEnumConstant
+import com.cobblemon.mod.common.util.writeString
 import net.minecraft.network.RegistryFriendlyByteBuf

 class MovesRegistrySyncPacket(moves: List<MoveTemplate>) : DataRegistrySyncPacket<MoveTemplate, MovesRegistrySyncPacket>(moves) {
@@ -33,6 +37,7 @@ class MovesRegistrySyncPacket(moves: List<MoveTemplate>) : DataRegistrySyncPacke
        buffer.writeDouble(entry.critRatio)
        buffer.writeInt(entry.effectChances.size)
        entry.effectChances.forEach { chance -> buffer.writeDouble(chance) }
+        buffer.writeFloat(entry.weight)
    }

    override fun decodeEntry(buffer: RegistryFriendlyByteBuf): MoveTemplate {
@@ -50,7 +55,21 @@ class MovesRegistrySyncPacket(moves: List<MoveTemplate>) : DataRegistrySyncPacke
        repeat(buffer.readInt()) {
            effectChances += buffer.readDouble()
        }
-        return MoveTemplate(name, num, type, damageCategory, power, target, accuracy, pp, priority, critRatio, effectChances.toTypedArray())
+        val weight = buffer.readFloat()
+        return MoveTemplate(
+            name = name,
+            num = num,
+            elementalType = type,
+            damageCategory = damageCategory,
+            power = power,
+            target = target,
+            accuracy = accuracy,
+            pp = pp,
+            priority = priority,
+            critRatio = critRatio,
+            effectChances = effectChances.toTypedArray(),
+            weight = weight
+        )
    }

    override fun synchronizeDecoded(entries: Collection<MoveTemplate>) {
@@ -1,48 +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.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,
-            )
-        }
-    }
-}
@@ -21,9 +21,7 @@ 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")
@@ -13,24 +13,30 @@ 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.*
+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 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,
@@ -55,7 +61,6 @@ class SpawnPokemonPacket(
    var tickSpawned: Int,
    var rideBoosts: Map<RidingStat, Float>,
    var rideStamina: Float,
-    var silent: Boolean,
    vanillaSpawnPacket: ClientboundAddEntityPacket,
 ) : SpawnExtraDataEntityPacket<SpawnPokemonPacket, PokemonEntity>(vanillaSpawnPacket) {

@@ -64,7 +69,6 @@ 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,
@@ -89,14 +93,12 @@ 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)
@@ -125,21 +127,10 @@ 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
@@ -171,7 +162,6 @@ 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 {
@@ -189,7 +179,6 @@ 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)
@@ -217,13 +206,11 @@ class SpawnPokemonPacket(
                { buffer.readFloat() }
            )
            val rideStamina = buffer.readFloat()
-            val silent = buffer.readBoolean()
            val vanillaPacket = decodeVanillaPacket(buffer)

            return SpawnPokemonPacket(
                ownerId,
                pokemonUUID,
-                storageUUID,
                scaleModifier,
                speciesId,
                gender,
@@ -248,7 +235,6 @@ class SpawnPokemonPacket(
                tickSpawned,
                rideBoosts,
                rideStamina,
-                silent,
                vanillaPacket
            )
        }
@@ -9,7 +9,6 @@
 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
@@ -26,16 +25,12 @@ 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 {
@@ -104,6 +104,10 @@ class FormData(
    private var _baseAI: MutableList<BehaviourConfig>? = null,
    @SerializedName("ai")
    private var _ai: MutableList<BehaviourConfig>? = null,
+    @SerializedName("signatureMoves")
+    private var _signatureMoves: MutableList<MoveTemplate>? = null,
+    @SerializedName("defaultWildMovesetBuilder")
+    private val _defaultWildMovesetBuilder: ResourceLocation? = null,
    val requiredMove: String? = null,
    val requiredItem: String? = null,
    /** For forms that can accept different items (e.g. Arceus-Grass: Meadow Plate or Grassium-Z). */
@@ -235,6 +239,10 @@ class FormData(
        get() = _baseAI ?: species.baseAI
    val ai: List<BehaviourConfig>
        get() = _ai ?: species.ai
+    val signatureMoves: List<MoveTemplate>
+        get() = _signatureMoves ?: species.signatureMoves
+    val defaultWildMovesetBuilder: ResourceLocation
+        get() = _defaultWildMovesetBuilder ?: species.defaultWildMovesetBuilder

    fun eyeHeight(entity: PokemonEntity): Float {
        return this.resolveEyeHeight(entity) ?: return this.species.eyeHeight(entity)
@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.pokemon

 import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.CobblemonMovesetBuilders
 import com.cobblemon.mod.common.CobblemonNetwork.sendPacket
 import com.cobblemon.mod.common.CobblemonNetwork.sendPacketToPlayers
 import com.cobblemon.mod.common.CobblemonSounds
@@ -34,6 +35,7 @@ import com.cobblemon.mod.common.api.moves.Move
 import com.cobblemon.mod.common.api.moves.MoveSet
 import com.cobblemon.mod.common.api.moves.MoveTemplate
 import com.cobblemon.mod.common.api.moves.Moves
+import com.cobblemon.mod.common.api.moves.MovesetBuilder
 import com.cobblemon.mod.common.api.pokeball.PokeBalls
 import com.cobblemon.mod.common.api.pokemon.Natures
 import com.cobblemon.mod.common.api.pokemon.PokemonProperties
@@ -591,6 +593,9 @@ open class Pokemon : ShowdownIdentifiable {
            onChange(MarkingsUpdatePacket({ this }, value))
        }

+    // Last flower fed to a Mooshtank
+    var lastFlowerFed: ItemStack = ItemStack.EMPTY
+
    fun asRenderablePokemon() = RenderablePokemon(species, aspects, if (heldItemVisible) heldItem else ItemStack.EMPTY)

    /**
@@ -673,7 +678,7 @@ open class Pokemon : ShowdownIdentifiable {
     * Whether this Pokémon's held item can be dropped by its AI.
     */
    internal var canDropHeldItem: Boolean = false
-        get() = field || heldItem.isEmpty
+        get() = field && !heldItem.isEmpty

    val riding: RidingProperties
        get() = this.form.riding
@@ -1437,11 +1442,6 @@ 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)
@@ -1561,10 +1561,8 @@ open class Pokemon : ShowdownIdentifiable {
        originalTrainer = fakeTrainerName
    }

-    fun refreshOriginalTrainer()
-    {
-        when (originalTrainerType)
-        {
+    fun refreshOriginalTrainer() {
+        when (originalTrainerType) {
            OriginalTrainerType.PLAYER -> {
                UUID.fromString(originalTrainer)?.let { uuid ->
                    server()?.profileCache?.get(uuid)?.orElse(null)?.name?.let {
@@ -1581,8 +1579,7 @@ open class Pokemon : ShowdownIdentifiable {
        }
    }

-    fun removeOriginalTrainer()
-    {
+    fun removeOriginalTrainer() {
        originalTrainer = null
        originalTrainerType = OriginalTrainerType.NONE
        originalTrainerName = null
@@ -1624,14 +1621,11 @@ open class Pokemon : ShowdownIdentifiable {
        species = species
        checkGender()
        if (moveSet.getMoves().isEmpty()) {
-            initializeMoveset()
+            initializeMovesetFromDefault()
        }
        return this
    }

-    // Last flower fed to a Mooshtank
-    var lastFlowerFed: ItemStack = ItemStack.EMPTY
-
    fun checkGender() {
        var reassess = false
        if (form.maleRatio !in 0F..1F && gender != Gender.GENDERLESS) {
@@ -1807,6 +1801,20 @@ open class Pokemon : ShowdownIdentifiable {
        moveSet.update()
    }

+    fun initializeMovesetFromDefault() {
+        initializeMovesetFrom(movesetBuilder = CobblemonMovesetBuilders.getOrThrow(form.defaultWildMovesetBuilder))
+    }
+
+    fun initializeMovesetFrom(movesetBuilder: MovesetBuilder) {
+        val newMoveset = movesetBuilder.build(form = form, level = level)
+        moveSet.copyFrom(newMoveset)
+    }
+
+    @Deprecated(
+        message = "Will be removed within potentially 1 title update",
+        replaceWith = ReplaceWith("initializeMovesetFromDefault"),
+        level = DeprecationLevel.ERROR
+    )
    fun initializeMoveset(preferLatest: Boolean = true) {
        val possibleMoves = form.moves.getLevelUpMovesUpTo(level).toMutableList()
        moveSet.doWithoutEmitting {
@@ -22,6 +22,7 @@ import com.cobblemon.mod.common.api.drop.DropTable
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.addSpeciesFunctions
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.addStandardFunctions
 import com.cobblemon.mod.common.api.molang.ObjectValue
+import com.cobblemon.mod.common.api.moves.MoveTemplate
 import com.cobblemon.mod.common.api.pokemon.PokemonProperties
 import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
 import com.cobblemon.mod.common.api.pokemon.effect.ShoulderEffect
@@ -42,6 +43,7 @@ import com.cobblemon.mod.common.net.IntSize
 import com.cobblemon.mod.common.pokemon.abilities.HiddenAbility
 import com.cobblemon.mod.common.pokemon.ai.PokemonBehaviour
 import com.cobblemon.mod.common.pokemon.lighthing.LightingData
+import com.cobblemon.mod.common.util.cobblemonResource
 import com.cobblemon.mod.common.util.readEntityDimensions
 import com.cobblemon.mod.common.util.readEnumConstant
 import com.cobblemon.mod.common.util.readIdentifier
@@ -111,6 +113,8 @@ class Species : ClientDataSynchronizer<Species>, ShowdownIdentifiable {
    var implemented = false
    var baseAI: MutableList<BehaviourConfig>? = null
    var ai = mutableListOf<BehaviourConfig>()
+    var signatureMoves = mutableListOf<MoveTemplate>()
+    var defaultWildMovesetBuilder = cobblemonResource("wild")

    /**
     * The height in decimeters
@@ -8,22 +8,13 @@

 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.*
-import net.minecraft.advancements.critereon.ItemPredicate
-import net.minecraft.network.FriendlyByteBuf
-import net.minecraft.resources.ResourceLocation
-import net.minecraft.util.LowerCaseEnumTypeAdapterFactory
+import com.google.gson.JsonDeserializationContext
+import com.google.gson.JsonElement
+import com.google.gson.JsonSerializationContext
 import java.lang.reflect.Type
 import kotlin.reflect.KClass

@@ -69,60 +60,21 @@ 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 = getRequirementType(variant)
+        val type = this.types[variant] ?: throw IllegalArgumentException("Cannot resolve evolution requirement type for variant $variant")
        return context.deserialize(json, type.java)
    }

-    override fun serialize(requirement: Requirement, typeOfSrc: Type, context: JsonSerializationContext): JsonElement {
-        val json = context.serialize(requirement, requirement::class.java).asJsonObject
-        val variant = getVariant(requirement)
+    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}")
        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
-    }
 }
@@ -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
-        if (canPathThroughLeaves() && blockState.block == CobblemonBlocks.SACCHARINE_LEAVES)
-            return PathType.OPEN
+//        } else if (blockState.`is`(BlockTags.LEAVES) && blockState.block == CobblemonBlocks.SACCHARINE_LEAVES && canPathThroughLeaves()) {
+//            return PathType.OPEN
 //        } else PathType.BLOCKED

        // This is the 1.6.1 logic but with some optimizations
@@ -633,6 +633,9 @@ 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
@@ -752,7 +755,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 (canPathThroughLeaves() && blockState.block === CobblemonBlocks.SACCHARINE_LEAVES) {
+            if (blockState.block === CobblemonBlocks.SACCHARINE_LEAVES && canPathThroughLeaves()) {
                PathType.OPEN
            } else {
                PathType.BLOCKED
@@ -6,15 +6,19 @@
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */

-package com.cobblemon.mod.common.pokemon.properties
+package com.cobblemon.mod.common.pokemon.properties.tags

 import com.cobblemon.mod.common.api.properties.CustomPokemonPropertyType
+import com.cobblemon.mod.common.pokemon.properties.StringProperty

-object LabelProperty : CustomPokemonPropertyType<StringProperty> {
-    override val keys = setOf("label", "tag")
+object PokemonFlagProperty : CustomPokemonPropertyType<StringProperty> {
+
+    private const val KEY = "tag"
+
+    override val keys = setOf(KEY)
    override val needsKey = true

-    override fun fromString(value: String?) = if (value == null) null else StringProperty(keys.first(), value, { _, _ -> }, { pokemon, underlyingValue -> pokemon.hasLabels(underlyingValue) })
+    override fun fromString(value: String?) = if (value == null) null else StringProperty(KEY, value, { _, _ -> }, { pokemon, underlyingValue -> pokemon.hasLabels(underlyingValue) })

    override fun examples() = emptySet<String>()
 }
@@ -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.resources.ResourceLocation
 import net.minecraft.server.level.ServerPlayer
-import net.minecraft.world.entity.player.Player
+import net.minecraft.resources.ResourceLocation
+import kotlin.collections.iterator

 /**
 * An [com.cobblemon.mod.common.api.pokemon.requirement.Requirement] that checks if the player has a certain [net.minecraft.advancements.Advancement]
@@ -26,16 +26,13 @@ class AdvancementRequirement(val requiredAdvancement: ResourceLocation) : OwnerQ

    override fun checkPlayer(
        pokemon: Pokemon,
-        owner: Player
+        owner: ServerPlayer
    ): Boolean {
-        val serverPlayer = owner as? ServerPlayer ?: return false
-
-        for (entry in serverPlayer.advancements.progress) {
+        for (entry in owner.advancements.progress) {
            if (entry.key.id == requiredAdvancement && entry.value.isDone) {
                return true
            }
        }
-
        return false
    }

@@ -12,9 +12,11 @@ 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 net.minecraft.world.entity.player.Player
+import kotlin.collections.iterator

 /**
 * An [OwnerQueryRequirement] that checks if the player/npc is holding a certain [ItemPredicate]
@@ -28,7 +30,7 @@ class OwnerHoldsItemRequirement(val itemCondition: ItemPredicate)

    override fun checkPlayer(
        pokemon: Pokemon,
-        owner: Player
+        owner: ServerPlayer
    ): Boolean {
        return checkItem(owner)
    }
@@ -87,6 +87,7 @@ object DataKeys {

    const val POKEMON_PROPERTIES_MOVES = "Moves"
    const val POKEMON_PROPERTIES_HELDITEM = "HeldItem"
+    const val POKEMON_PROPERTIES_MOVESET_BUILDERS = "MovesetBuilders"

    // Entity effects
    const val ENTITY_EFFECTS = "EntityEffects"
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.util
+
+import com.bedrockk.molang.runtime.MoLangRuntime
+import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.api.molang.ExpressionLike
+
+/**
+ * An IntRange where the minimum and maximum values are defined by MoLang expressions. When deserializing from
+ * JSON the [com.cobblemon.mod.common.util.adapters.ScriptableIntRangeAdapter] will figure out if it's a single
+ * value in which case it's not using any scripting stuff. Otherwise, if it's an object with "min" and "max" properties
+ * it will respect them as expressions.
+ *
+ * @author Hiroku
+ * @since December 15th, 2025
+ */
+class ScriptableIntRange(
+    val min: ExpressionLike = "0".asExpressionLike(),
+    val max: ExpressionLike = "0".asExpressionLike()
+) {
+    constructor(min: Int, max: Int): this(
+        min = min.toString().asExpressionLike(),
+        max = max.toString().asExpressionLike()
+    )
+
+    fun resolve(runtime: MoLangRuntime): IntRange {
+        val minimum = min.resolveInt(runtime)
+        val maximum = max.resolveInt(runtime)
+        if (minimum > maximum) {
+            Cobblemon.LOGGER.error("ScriptableIntRange(${min.getString()}, ${max.getString()}) resolved a minimum ($minimum) greater than maximum ($maximum). Returning empty range.")
+            return IntRange.EMPTY
+        }
+        return minimum..maximum
+    }
+}
@@ -8,22 +8,22 @@

 package com.cobblemon.mod.common.util.adapters

-import com.google.gson.*
+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.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 {
-        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
+        return JsonOps.INSTANCE.withDecoder(codec).apply(jElement).result().get().first as T
    }

    override fun serialize(
@@ -31,10 +31,6 @@ class CodecBackedAdapter<T>(val codec: Codec<T>) : JsonDeserializer<T>, JsonSeri
        typeOfSrc: Type?,
        context: JsonSerializationContext?
    ): JsonElement {
-        val ops = RegistryOpsProvider.getOpsWithDefaultFallback()
-        val result = ops.withEncoder(codec).apply(src)
-        return result.result().orElseThrow {
-            IllegalStateException("Failed to serialize $src: ${result.error().orElse(null)}")
-        }
+        return JsonOps.INSTANCE.withEncoder(codec).apply(src).result().get()
    }
 }
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.util.adapters
+
+import com.cobblemon.mod.common.api.moves.MovesetBuilder
+import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
+import com.google.gson.JsonDeserializationContext
+import com.google.gson.JsonDeserializer
+import com.google.gson.JsonElement
+import java.lang.reflect.Type
+
+object MovesetBuilderAdapter : JsonDeserializer<MovesetBuilder> {
+    override fun deserialize(json: JsonElement, typeOfT: Type, context: JsonDeserializationContext): MovesetBuilder {
+        val jsonObject = json.asJsonObject
+        val type = jsonObject.get("type")?.asString ?: "cobblemon:default"
+        val clazz = MovesetBuilder.movesetBuilderTypes[type.asIdentifierDefaultingNamespace()]
+            ?: throw IllegalArgumentException("Unknown MovesetBuilder type: $type")
+        return context.deserialize(json, clazz)
+    }
+}
@@ -0,0 +1,23 @@
+/*
+ * 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.CobblemonMovesetBuilders
+import com.cobblemon.mod.common.api.moves.MovesetBuilder
+import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
+import com.google.gson.JsonDeserializationContext
+import com.google.gson.JsonDeserializer
+import com.google.gson.JsonElement
+import java.lang.reflect.Type
+
+object MovesetBuilderReferenceAdapter : JsonDeserializer<MovesetBuilder> {
+    override fun deserialize(json: JsonElement, typeOfT: Type, context: JsonDeserializationContext): MovesetBuilder {
+        return CobblemonMovesetBuilders.getOrThrow(json.asString.asIdentifierDefaultingNamespace())
+    }
+}
@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.util.adapters

 import com.cobblemon.mod.common.api.npc.NPCPartyProvider
+import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
 import com.google.gson.JsonDeserializationContext
 import com.google.gson.JsonDeserializer
 import com.google.gson.JsonElement
@@ -16,8 +17,8 @@ import java.lang.reflect.Type

 object NPCPartyProviderAdapter : JsonDeserializer<NPCPartyProvider> {
    override fun deserialize(json: JsonElement, type: Type, ctx: JsonDeserializationContext): NPCPartyProvider {
-        val typeName = if (json.isJsonPrimitive) json.asString else json.asJsonObject.get("type").asString
-        return NPCPartyProvider.types[typeName]?.invoke(typeName)?.also { it.loadFromJSON(json) }
+        val typeName = (if (json.isJsonPrimitive) json.asString else json.asJsonObject.get("type").asString).asIdentifierDefaultingNamespace()
+        return NPCPartyProvider.types[typeName]?.invoke()?.also { it.loadFromJSON(json) }
            ?: throw IllegalStateException("Unable to find party provider by type: $typeName")
    }
 }
@@ -1,41 +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.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
-    }
-}
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.util.adapters
+
+import com.cobblemon.mod.common.util.ScriptableIntRange
+import com.cobblemon.mod.common.util.asExpressionLike
+import com.google.gson.JsonDeserializationContext
+import com.google.gson.JsonDeserializer
+import com.google.gson.JsonElement
+import com.google.gson.JsonPrimitive
+import java.lang.reflect.Type
+
+/**
+ * Parses a [ScriptableIntRange] by two paths. One is if it's a primitive in which
+ * case they're just doing a normal [IntRange] and it will parse it using the same
+ * method as IntRange normally gets and then returns a ScriptableIntRange of literals.
+ *
+ * The other path is if they provide an object with "min" and "max" in which case
+ * each property is deserialized as an [ExpressionLike].
+ *
+ * @author Hiroku
+ * @since December 15th, 2025
+ */
+object ScriptableIntRangeAdapter : JsonDeserializer<ScriptableIntRange> {
+    override fun deserialize(
+        json: JsonElement,
+        typeOfT: Type,
+        context: JsonDeserializationContext
+    ): ScriptableIntRange {
+        if (json is JsonPrimitive) {
+            IntRangeAdapter.deserialize(json, typeOfT, context).let {
+                return ScriptableIntRange(
+                    it.first.toString().asExpressionLike(),
+                    it.last.toString().asExpressionLike()
+                )
+            }
+        } else {
+            val obj = json.asJsonObject
+            val min = obj.get("min").asString
+            val max = obj.get("max").asString
+            return ScriptableIntRange(
+                min.toString().asExpressionLike(),
+                max.toString().asExpressionLike()
+            )
+        }
+    }
+}
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.util.adapters
+
+import com.google.gson.JsonDeserializationContext
+import com.google.gson.JsonDeserializer
+import com.google.gson.JsonElement
+import java.lang.reflect.Type
+
+/**
+ * A simple adapter that maps string values to objects based on a provided mapping.
+ *
+ * I could swear I already made something like this before.
+ *
+ * @author Hiroku
+ * @since December 5th, 2025
+ */
+class StringToObjectAdapter<T>(
+    val mapping: MutableMap<String, T>
+) : JsonDeserializer<T> {
+    override fun deserialize(json: JsonElement, typeOfT: Type, context: JsonDeserializationContext): T = mapping[json.asString]
+        ?: throw IllegalArgumentException("Unknown mapping for string: ${json.asString}")
+}
@@ -820,14 +820,6 @@
  "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",
@@ -2629,8 +2621,6 @@
  "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",
@@ -3525,7 +3515,6 @@
  "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",
@@ -9456,8 +9445,5 @@
  "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.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"
+  "stat.cobblemon.reel_ins": "PokéRod Catches"
 }
@@ -1,7 +1,4 @@
 {
  "parent": "minecraft:builtin/entity",
-  "gui_light": "side",
-  "textures": {
-    "particle": "cobblemon:item/poke_balls/cherish_ball"
-  }
+  "gui_light": "side"
 }
@@ -1517,139 +1517,76 @@
      { "name": "cobblemon:animation/wings/steel_wing_flap_medium_8", "volume": 0.25 }
    ]
  },
-  "ride.loop.wind.mono": {
+  "ride.loop.wind": {
    "sounds": [
      {
-        "name": "cobblemon:ride/loop/wind_loop_mono",
+        "name": "cobblemon:ride/loop/wind_loop",
        "stream": true,
        "attenuation_distance": 48.0,
        "volume": 0.15
      }
    ]
  },
-  "ride.loop.wind.stereo": {
+  "ride.loop.leather": {
    "sounds": [
      {
-        "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",
+        "name": "cobblemon:ride/loop/leather_flight_loop",
        "stream": true,
        "attenuation_distance": 48.0,
        "volume": 0.25
      }
    ]
  },
-  "ride.loop.leather.stereo": {
+  "ride.loop.plumage": {
    "sounds": [
      {
-        "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",
+        "name": "cobblemon:ride/loop/plumage_flight_loop",
        "stream": true,
        "attenuation_distance": 48.0,
        "volume": 0.25
      }
    ]
  },
-  "ride.loop.plumage.stereo": {
+  "ride.loop.saucer": {
    "sounds": [
      {
-        "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",
+        "name": "cobblemon:ride/loop/saucer_flight_loop",
        "stream": true,
        "attenuation_distance": 48.0,
        "volume": 0.25
      }
    ]
  },
-  "ride.loop.saucer.stereo": {
+  "ride.loop.rocket": {
    "sounds": [
      {
-        "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",
+        "name": "cobblemon:ride/loop/rocket_flight_loop",
        "stream": true,
        "attenuation_distance": 48.0,
        "volume": 0.4
      }
    ]
  },
-  "ride.loop.rocket.stereo": {
+  "ride.loop.water_surface": {
    "sounds": [
      {
-        "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",
+        "name": "cobblemon:ride/loop/water_surface_loop",
        "stream": true,
        "attenuation_distance": 32.0,
        "volume": 0.4
      }
    ]
  },
-  "ride.loop.water_surface.stereo": {
+  "ride.loop.underwater": {
    "sounds": [
      {
-        "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",
+        "name": "cobblemon:ride/loop/underwater_loop",
        "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" ]
  },
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Paul	0fa8484876	Added scraper for trainer data sheet	2026-01-19 16:24:55 +10:00
Paul	aafdb7688a	Added more molang expressions to a bunch of composed pool properties, fixed some bugs	2025-12-15 14:22:59 +10:00
Paul	73b53f9702	Added `egg` move selector	2025-12-15 12:07:06 +10:00
Paul	33317a57c7	more doco changes [skip-ci]	2025-12-14 20:33:34 +10:00
Paul	72d8f26cdb	Change silly default example weight to the actual default weight	2025-12-14 20:27:30 +10:00
Paul	aea1afe145	Rearrange doco	2025-12-14 20:26:21 +10:00
Paul	0fec45b7ea	Added npcAspects condition for party pool entries	2025-12-14 20:24:52 +10:00
Paul	af98b823aa	Documentation	2025-12-14 20:13:04 +10:00
Paul	07d9da2ca9	Added last_suitable_offensive move selector, added alpha moveset builder	2025-12-14 17:29:47 +10:00
Paul	c2c86b2ef1	Stack all the cobblemon:move_weights.json from any datapacks onto one big map, like tags	2025-12-14 17:05:58 +10:00
Paul	22733e7117	Added more advanced moveset and party construction for NPCs	2025-12-08 19:31:48 +10:00