Changelog [skip-ci]

Snapnoshot
Merge branch 'implement_pokemon' into 'main'
2026-10-25 08:36:24 -04:00 · 2025-01-26 09:34:42 +10:00 · 2025-01-26 08:53:26 +10:00 · 2025-01-25 22:32:19 +00:00 · 2025-01-25 16:27:21 -06:00 · 2025-01-25 16:26:48 -06:00
3523 changed files with 279523 additions and 155559 deletions
@@ -1,5 +1,207 @@
 # Changelog
-## [1.6.0 - The Record Catch Update (Month Xth, 2024)](#1-6-0)
+## [1.6.1 (January 26th, 2025)](#1-6-1)
+
+### Additions
+- Added crossover paintings from Close Combat: Premonition, Altar, Slumber, and Nomad.
+- Added Galarica Nuts, used for crafting Galarica Cuffs and Wreaths. Dropped from certain Pokémon. Take a wild guess which.
+- Added compatibility with Repurposed Structures. (Thank you, TelepathicGrunt!)
+- Added an evolution method for Karrablast to evolve into Escavalier in singleplayer.
+- Pokédexes can now be placed in Chiseled Bookshelves.
+- Added optional box argument to the /pc command.
+- Pokédex and Dialogue screens now close when the inventory keybind is pressed.
+- Added config setting `maxPokedexScanningDetectionRange` to control from what distance the player can scan Pokémon using the Pokédex.
+- Added config setting `hideUnimplementedPokemonInThePokedex` which hides unimplemented Pokémon from the Pokédex when set to true. 
+- Added debug renderer for posable entity locators.
+
+### Pokémon Added
+
+#### Gen 5
+- Ducklett
+- Swanna
+- Shelmet
+- Accelgor
+- Karrablast
+- Escavalier
+- Rufflet
+- Braviary
+- Foongus
+- Amoonguss
+
+#### Gen 6
+- Binacle
+- Barbaracle
+
+#### Gen 7
+- Dewpider
+- Araquanid
+- Alolan Geodude
+- Alolan Graveler
+- Alolan Golem
+
+#### Gen 8
+- Galarian Slowpoke
+- Galarian Slowbro
+- Galarian Slowking
+
+#### Gen 9
+- Paldean Tauros
+
+### Added cries to the following Pokémon
+- All Nidorans
+- Shellder, Cloyster
+- Pinsir
+- Tyrogue, Hitmontop
+- Spinda
+
+### Animation updates for the following Pokémon
+- Primeape
+- Munchlax
+- Snorlax
+- Poliwrath
+- Goldeen
+- Seaking
+- Dondozo
+- Wobbuffet
+- Charcadet
+- Armarouge
+- Ceruledge
+- Geodude
+- Graveler
+- Golem
+- Sandile
+- Krokorok
+- Krookodile
+
+### Model updates for the following Pokémon
+- Slowpoke
+- Slowbro
+- Slowking
+- Eiscue
+- Tauros
+- Goldeen
+- Seaking
+- Charcadet
+- Armarouge
+- Ceruledge
+- Pinsir
+- Geodude
+- Graveler
+- Golem
+
+### Cry updates for the following Pokémon
+- Sceptile
+
+### Changes
+- Completely re-synced Pokémon move and stat data based on later games. Learnsets have changed considerably to maximise available moves.
+- Pokémon will now be dynamically revealed to the Pokédex as they're seen in battle instead of revealing entire parties at the end of battle.
+- Unseen wild Pokémon will update their name from '???' to their real name as soon as a battle starts to match how the battle UI shows the actual species name.
+- Pokémon under the illusion effect will reveal their disguise to the Pokédex first and then the base Pokémon once the disguise is broken.
+- Berries will now drop from berry trees if broken at age 0 so you aren't punished for mistaken planting.
+- Increased Fortune drops on Mint Seeds.
+- Updated Slowpoke's shiny texture.
+- Updated drops for many Pokémon.
+- Adjusted the evolution sound to match the timing of the particle effect.
+- Made berry trees shear-able by dispenser blocks. I'm sure nobody will make unholy contraptions with this.
+- Edited some recipes to utilize tags instead of direct item IDs, for better mod compatibility.
+- Added more support for a variety of Fabric/NeoForge conventional tags.
+- Reformatted some tags to be more consistent.
+
+### Fixes
+- Fixed Pokédex sometimes crashing when switching forms.
+- Fixed Pokédex interface not transitioning out when closed.
+- Fixed texture dimensions for the player and Pokémon interact interface.
+- Fixed crash related to Tom's Simple Storage mod and the Fossil Machine.
+- Fixed not being able to retrieve a fossil from the Fossil Machine with an empty hand.
+- Fixed Pokémon being collidable (collidible? collissionable? kaleidoscopable?) while being captured by a Poké Ball.
+- Fixed `full_party`, `own_zangoose_seviper`, `use_revive` and `use_candy` Advancement triggers.
+- Fixed `healing_machine` Advancement by using the correct 1.21 trigger.
+- Fix Display Cases not dropping items if destroyed through explosions.
+- Fixed an issue where the first Pokémon in the pastured Pokémon list clipped into the interface.
+- Fixed all Pokémon facing South on spawn.
+- Fixed bait being consumed even when not reeling in any Pokémon.
+- Fixed Miltank milk magically disappearing out of your bucket.
+- Fixed Pokémon nicknames migrating from 1.5.2 not being displayed properly.
+- Fixed capitalization in one of our config options. It was a very important fix. Very important. Old configs are fine.
+- Fixed Poké Rods not working if Lure or Luck of the Sea enchantments get removed by other mods.
+- Fixed crashes related to Pokémon when they are ready to evolve while holding an enchanted item. Very specific.
+- Fixed a crash that sometimes occurred when evolving Nincada.
+- Fixed Cobblemon plants not being compostable on NeoForge.
+- Fixed hide UI (F1 key) not hiding the party overlay.
+- Fixed NPC MoLang command `player_lose_command` not working.
+- Fixed misaligned tooltips with edit boxes in the NPC editor screen.
+- Fixed Pokémon riding two boats when attempting to deploy a platform on water.
+- Fixed the summary screen showing there's experience to reach the next level when they are at the level cap.
+- Fixed Pokémon forgetting moves when evolving on specific cases.
+- Fixed Adorn compatibility, including improvements when using JEI/REI (Apricorn items now show up under the collapsed entries rather than standalone).
+- Fixed error message appearing on battle log when using Solar Beam with Sunny Day.
+- Fixed Pokémon Model offsets for larger species.
+- Fixed `/pokedex grant all` command not giving male/female/shininess completion for some Pokémon.
+- Fixed `/pokedex grant only` and `/pokedex remove only` not respecting the form parameter passed.
+- Fixed variant forms appearing incorrectly in the Pokédex when the normal form had not been unlocked.
+- Fixed Pokémon occasionally being shot into the sky during battle. No Pokémon were harmed by this bug, probably.
+- Fixed NPC editing GUI not updating aspects until a game restart.
+- Fixed some users being unable to open their PC if a Pokémon in it had a lot of PP raises beyond normal bounds. How did you get those, anyway? Tell me or the Bellossom gets it.
+- Fixed some color variants (Dubwool, Conkeldurr and Undyed wooloo) being missing in the Pokédex.
+- Fixed invalid species or held items causing Players to not be able to load into their world anymore (commonly happening after removing addons/mods).
+- Fixed Wooloo variants not being automatically registered in the owner's Pokédex when dyed.
+- Fixed Vivichoke Dip and Leek & Potato Stew not returning a bowl upon consumption.
+- Fixed Fossil Restoration Tank not accepting Hay Bales as organic material.
+- Fixed Potion items applying double their intended healing value.
+- Fixed Fast Ball capture bonuses applying to all Pokémon, making it the Best Ball instead of the Mediocre Edge-Case Ball. 
+- Fixed "learned new move" messages appearing for already-known moves on Pokémon evolutions.
+- Fixed Pokémon Item Models breaking shadows nearby when being placed in Display Cases or Item Frames.
+- Fixed berries not giving bonus yields when planted in their preferred biomes. I'm sure we've fixed that 5 times now.
+- Fixed the NeoForge version not supporting "SodiumDynamicLights".
+- Fixed players disconnecting from servers if they made changes to certain config options.
+- Fixed players with shouldered Pokémon not being able to rejoin their 1.5.2 worlds using 1.6.
+- Fixed `PokemonProperties` utilizing `ability=<some ability>` being treated as a forced ability even when it is a legal ability for the Pokémon.
+- Fixed type formatting in Pokédex scanner mode when dual types require two lines.
+- Fixed trading sometimes crashing the game or server. 
+- Fixed Wild shiny sounds not respecting the `shinyNoticeParticlesDistance` config setting.
+- Fixed Pokémon being able to evolve mid-battle.
+- Fixed NPC held items being able to be stolen by players. Don't be a thief!
+- Fixed evolutions that require a held item consuming it as soon as meeting requirements when it should only be consumed upon evolution.
+- Fixed Pokémon showing only the default form when selecting them as a target in battle.
+- Fixed a possible error coming out of reeling fishing rods in specific situations.
+- Fixed incorrect weights being used when Poké Fishing with Luck of the Sea.
+- Parametric particle motion now works.
+- Event-spawned particles now work.
+- Particles can now have independent coordinate spaces.
+
+### Developer
+- Updated the Pokédex data updated events to always include a `Pokemon` instance, and optionally a `DisguiseData` instance.
+- Updated fields in `SpawnNPCPacket` and `SpawnPokemonPacket` to be visible and mutable.
+- Updated `UnvalidatedPlaySoundS2CPacket` to be public instead of internal and made its fields mutable.
+- Added `hideNameTag` field and `HideNPCNameTag` nbt tag to `NPCEntity` to allow hiding the name tag of the NPC.
+- Added the player to `PokerodReelEvent` so you know who is doing the reeling.
+
+### MoLang & Datapacks  
+- Added flows for:
+  - `forme_change`: Triggered when a Pokémon changes form in battle.
+  - `mega_evolution`: Triggered when a Pokémon mega evolves in battle. (Note: Third-party mods are required for this feature currently)
+  - `zpower_used`: Triggered when a Pokémon uses a Z-Power move in battle. (Note: Third-party mods are required for this feature currently)
+  - `terastallization`: Triggered when a Pokémon terastallizes in battle. (Note: Third-party mods are required for this feature currently)
+  - `battle_fainted`: Triggered when a Pokémon faints in battle.
+  - `battle_fled`: Triggered when a player flees from battle.
+  - `battle_started_pre`: Triggered when a battle starts. Cancelable!
+  - `battle_started_post`: Triggered when a battle starts.
+  - `apricorn_harvested`: Triggered when an Apricorn is harvested.
+  - `thrown_pokeball_hit`: Triggered when a thrown Pokéball hits a Pokémon.
+  - `level_up`: Triggered when a Pokémon levels up.
+  - `pokemon_fainted`: Triggered when a Pokémon faints.
+  - `pokemon_gained`: Triggered when a player gains a Pokémon.
+- Added MoLang functions:
+  - For Pokémon:
+    - `pokemon.apply(PokemonProperties)`: Applies the given properties to the Pokémon.
+    - `pokemon.owner`: Returns the owner of the Pokémon or 0.0 if there is no owner or they are not online.
+  - For all entities:
+    - `entity.is_standing_on_blocks(depth, blocks...)`: Returns whether the specified entity is standing on a specific block or set of blocks. Example usage: `q.is_standing_on_blocks(2, minecraft:sand)`
+- Added NPC field:
+  - `hideNameTag`: Hides the name tag of the NPC.
+  - Added `baseScale` property to NPCs.
+- Added MoLang particle queries for getting distance to targeted entities.
+
+## [1.6.0 - The Record Catch Update (December 25th, 2024)](#1-6-0)
 #### "Now that there's a fishing mechanic, the mod is actually good!"

 ### Additions
@@ -124,9 +326,6 @@
 #### Gen 9
 - Wattrel
 - Kilowattrel
- Wiglett
- Wugtrio
- Flamigo
 - Veluza
 - Farigiraf
 - Klawf
@@ -1903,5 +2102,4 @@ Thank you so much to all of our community translators that bring the mod to the
 - Added species, ability, and move translations for `ko_ko`, `jp_jp`, `fr_fr`, `es_es`, `it_it`, and `zh_cn`.

 ## [1.0.0 (November 12th, 2022)](#1-0-0)
- Initial release.
-
+- Initial release.
@@ -9,6 +9,20 @@
 package com.cobblemon.mod.common.mixin;

 import com.cobblemon.mod.common.client.CobblemonClient;
+import com.cobblemon.mod.common.client.render.MatrixWrapper;
+import com.cobblemon.mod.common.client.render.models.blockbench.PosableModel;
+import com.cobblemon.mod.common.client.render.models.blockbench.PosableState;
+import com.cobblemon.mod.common.entity.PosableEntity;
+import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.blaze3d.vertex.VertexConsumer;
+import net.minecraft.client.renderer.LevelRenderer;
+import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.phys.AABB;
+import net.minecraft.world.phys.Vec3;
+import org.joml.Vector3f;
+import org.spongepowered.asm.mixin.Debug;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
@@ -34,4 +48,39 @@ public class EntityRenderDispatcherMixin {
    public void resourceManagerReloadHook(ResourceManager resourceManager, CallbackInfo ci) {
        CobblemonClient.INSTANCE.onAddLayer(this.playerRenderers);
    }
+
+    @Inject(
+        method = "renderHitbox(Lcom/mojang/blaze3d/vertex/PoseStack;Lcom/mojang/blaze3d/vertex/VertexConsumer;Lnet/minecraft/world/entity/Entity;FFFF)V",
+        at = @At(value = "TAIL")
+    )
+    private static void renderLocators(
+        PoseStack poseStack,
+        VertexConsumer buffer,
+        Entity entity,
+        float red,
+        float green,
+        float blue,
+        float alpha,
+        CallbackInfo ci
+    ) {
+        if (entity instanceof PosableEntity posableEntity) {
+            if (posableEntity.getDelegate() instanceof PosableState state) {
+                state.getLocatorStates().forEach((locator, matrix) -> {
+                    poseStack.pushPose();
+                    Vec3 pos = matrix.getOrigin().subtract(entity.position());
+                    LevelRenderer.renderLineBox(
+                        poseStack,
+                        buffer,
+                        AABB.ofSize(pos, 0.25, 0.25, 0.25),
+                        0F,
+                        1F,
+                        0F,
+                        1F
+                    );
+                    poseStack.popPose();
+                });
+
+            }
+        }
+    }
 }
@@ -14,6 +14,7 @@ import com.cobblemon.mod.common.api.events.CobblemonEvents;
 import com.cobblemon.mod.common.api.events.item.LeftoversCreatedEvent;
 import com.cobblemon.mod.common.api.pokemon.PokemonSpecies;
 import com.cobblemon.mod.common.api.storage.party.PartyStore;
+import com.cobblemon.mod.common.api.storage.party.PlayerPartyStore;
 import com.cobblemon.mod.common.api.tags.CobblemonItemTags;
 import com.cobblemon.mod.common.pokedex.scanner.PokedexEntityData;
 import com.cobblemon.mod.common.pokedex.scanner.ScannableEntity;
@@ -178,10 +179,10 @@ public abstract class PlayerMixin extends LivingEntity implements ScannableEntit

    @Override @Nullable
    public PokedexEntityData resolvePokemonScan() {
-        if(CompoundTagUtilities.isShoulderPokemon(this.getShoulderEntityRight())){
+        if (CompoundTagUtilities.isShoulderPokemon(this.getShoulderEntityRight())){
            return getDataFromShoulderPokemon(this.getShoulderEntityRight());
        }
-        if(CompoundTagUtilities.isShoulderPokemon(this.getShoulderEntityLeft())){
+        if (CompoundTagUtilities.isShoulderPokemon(this.getShoulderEntityLeft())){
            return getDataFromShoulderPokemon(this.getShoulderEntityLeft());
        }
        return null;
@@ -190,30 +191,34 @@ public abstract class PlayerMixin extends LivingEntity implements ScannableEntit
    @Nullable @Unique
    private PokedexEntityData getDataFromShoulderPokemon(CompoundTag shoulderTag) {
        CompoundTag pokemonTag = shoulderTag.getCompound(DataKeys.POKEMON);
-        if(pokemonTag.isEmpty()) return null;
+        if (pokemonTag.isEmpty()) return null;
        Species species = PokemonSpecies.INSTANCE.getByIdentifier(ResourceLocation.parse(pokemonTag.getString(DataKeys.POKEMON_SPECIES_IDENTIFIER)));
-        if(species == null) return null;
+        if (species == null) return null;
        String formId = pokemonTag.getString(DataKeys.POKEMON_FORM_ID);
        FormData form = species.getStandardForm();
        List<FormData> formList = species.getForms().stream().filter(it -> it.formOnlyShowdownId().equals(formId)).toList();
-        if(!formList.isEmpty()) form = formList.getFirst();
-        if(form == null) return null;
+        if (!formList.isEmpty()) form = formList.getFirst();
+        if (form == null) return null;
        String genderString = pokemonTag.getString(DataKeys.POKEMON_GENDER);
-        if(genderString.isEmpty()) return null;
+        if (genderString.isEmpty()) return null;
        Gender gender = Gender.valueOf(genderString);
        boolean shiny = pokemonTag.getBoolean(DataKeys.POKEMON_SHINY);
        int level = pokemonTag.getInt(DataKeys.POKEMON_LEVEL);
        Set<String> aspects = shoulderTag.getList(DataKeys.SHOULDER_ASPECTS, Tag.TAG_STRING).stream().map(Tag::getAsString).collect(Collectors.toSet());

-        return new PokedexEntityData(
-                species,
-                form,
-                gender,
-                aspects,
-                shiny,
-                level,
-                this.getUUID()
-        );
+        Pokemon pokemon = new Pokemon();
+        if (level().isClientSide) {
+            pokemon.setSpecies(species);
+            pokemon.setForm(form);
+            pokemon.setGender(gender);
+            pokemon.setShiny(shiny);
+            pokemon.setLevel(level);
+            pokemon.setForcedAspects(aspects);
+        } else {
+            PlayerPartyStore party = Cobblemon.INSTANCE.getStorage().getParty(this.getUUID(), this.registryAccess());
+            pokemon = party.get(shoulderTag.getUUID(DataKeys.SHOULDER_UUID));
+        }
+        return new PokedexEntityData(pokemon, null);
    }

    @Override
@@ -14,6 +14,7 @@ import com.cobblemon.mod.common.api.SeasonResolver
 import com.cobblemon.mod.common.api.data.DataProvider
 import com.cobblemon.mod.common.api.drop.CommandDropEntry
 import com.cobblemon.mod.common.api.drop.DropEntry
+import com.cobblemon.mod.common.api.drop.EvolutionItemDropEntry
 import com.cobblemon.mod.common.api.drop.ItemDropEntry
 import com.cobblemon.mod.common.api.events.CobblemonEvents
 import com.cobblemon.mod.common.api.events.CobblemonEvents.DATA_SYNCHRONIZED
@@ -68,6 +69,7 @@ import com.cobblemon.mod.common.battles.BattleSide
 import com.cobblemon.mod.common.battles.ShowdownThread
 import com.cobblemon.mod.common.battles.actor.PokemonBattleActor
 import com.cobblemon.mod.common.battles.pokemon.BattlePokemon
+import com.cobblemon.mod.common.client.CobblemonPack
 import com.cobblemon.mod.common.command.argument.*
 import com.cobblemon.mod.common.config.CobblemonConfig
 import com.cobblemon.mod.common.config.LastChangedVersion
@@ -123,6 +125,7 @@ import kotlin.reflect.jvm.javaField
 import net.minecraft.client.Minecraft
 import net.minecraft.commands.synchronization.SingletonArgumentInfo
 import net.minecraft.resources.ResourceKey
+import net.minecraft.server.packs.PackType
 import net.minecraft.world.item.NameTagItem
 import net.minecraft.world.level.Level
 import net.minecraft.world.level.storage.LevelResource
@@ -162,6 +165,16 @@ object Cobblemon {
    var statProvider: StatProvider = CobblemonStatProvider
    var seasonResolver: SeasonResolver = TagSeasonResolver

+    @JvmStatic
+    val builtinPacks = listOf<CobblemonPack>(
+        CobblemonPack(id = "adorncompatibility", name = "Adorn Compatibility", packType = PackType.CLIENT_RESOURCES, activationBehaviour = ResourcePackActivationBehaviour.ALWAYS_ENABLED, neededMods = setOf("adorn")),
+        CobblemonPack(id = "gyaradosjump", name = "Gyarados Jump Patterns", packType = PackType.CLIENT_RESOURCES, activationBehaviour = ResourcePackActivationBehaviour.DEFAULT_ENABLED),
+        CobblemonPack(id = "regionbiasforms", name = "Region Bias Forms", packType = PackType.CLIENT_RESOURCES, activationBehaviour = ResourcePackActivationBehaviour.DEFAULT_ENABLED),
+        CobblemonPack(id = "uniqueshinyforms", name = "Shinies for Magikarp Jump", packType = PackType.CLIENT_RESOURCES, activationBehaviour = ResourcePackActivationBehaviour.NORMAL),
+
+        CobblemonPack(id = "repurposedstructurescobblemon", name = "Repurposed Structures Cobblemon", packType = PackType.SERVER_DATA, activationBehaviour = ResourcePackActivationBehaviour.DEFAULT_ENABLED, neededMods = setOf("repurposed_structures")),
+    )
+
    fun preInitialize(implementation: CobblemonImplementation) {
        this.implementation = implementation

@@ -188,6 +201,7 @@ object Cobblemon {

        DropEntry.register("command", CommandDropEntry::class.java)
        DropEntry.register("item", ItemDropEntry::class.java, isDefault = true)
+        DropEntry.register("evolution", EvolutionItemDropEntry::class.java)

        ExperienceGroups.registerDefaults()
        CaptureCalculators.registerDefaults()
@@ -206,7 +220,7 @@ object Cobblemon {
            storage.onPlayerDataSync(it)
            playerDataManager.syncAllToPlayer(it)
            starterHandler.handleJoin(it)
-            ServerSettingsPacket(this.config.preventCompletePartyDeposit, this.config.displayEntityLevelLabel, this.config.displayEntityNameLabel).sendToPlayer(it)
+            ServerSettingsPacket(this.config.preventCompletePartyDeposit, this.config.displayEntityLevelLabel, this.config.displayEntityNameLabel, this.config.maxPokemonLevel, this.config.maxPokemonFriendship, this.config.maxDynamaxLevel).sendToPlayer(it)
        }
        PlatformEvents.SERVER_PLAYER_LOGOUT.subscribe {
            PCLinkManager.removeLink(it.player.uuid)
@@ -244,6 +258,8 @@ object Cobblemon {
        // Lowest priority because this applies after luxury ball bonus as of gen 4
        CobblemonEvents.FRIENDSHIP_UPDATED.subscribe(Priority.LOWEST) { event ->
            var increment = (event.newFriendship - event.pokemon.friendship).toFloat()
+            if (increment <= 0) //these affects are only meant to affect positive gains
+                return@subscribe
            // Our Luxury ball spec is diff from official, but we will still assume these stack
            if (event.pokemon.heldItemNoCopy().`is`(CobblemonItemTags.IS_FRIENDSHIP_BOOSTER)) {
                increment += increment * 0.5F
@@ -317,6 +317,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField val RAZOR_FANG = noSettingsItem("razor_fang")
    @JvmField val AUSPICIOUS_ARMOR = heldItem("auspicious_armor")
    @JvmField val MALICIOUS_ARMOR = heldItem("malicious_armor")
+    @JvmField val SHELL_HELMET = heldItem("shell_helmet")

    private val berries = mutableMapOf<ResourceLocation, BerryItem>()
    // Plants
@@ -392,6 +393,9 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It

    @JvmField val BERRY_JUICE = this.create("berry_juice", BerryJuiceItem())

+    @JvmField
+    val GALARICA_NUTS = create("galarica_nuts", GalaricaNutItem())
+
    // Medicine
    @JvmField
    val RARE_CANDY = candyItem("rare_candy") { _, pokemon -> pokemon.getExperienceToNextLevel() }
@@ -442,6 +446,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
            .saturationModifier(1.2F)
            .effect(MobEffectInstance(MobEffects.ABSORPTION, 900, 0), 1F)
            .alwaysEdible()
+            .usingConvertsTo(Items.BOWL)
            .build())) {
        override fun finishUsingItem(stack: ItemStack, world: Level, user: LivingEntity): ItemStack {
            user.removeAllEffects()
@@ -477,7 +482,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val HEAL_POWDER = create("heal_powder", HealPowderItem())
    @JvmField
-    val LEEK_AND_POTATO_STEW = create("leek_and_potato_stew", Item(Item.Properties().food(FoodProperties.Builder().nutrition(8).saturationModifier(0.6f).build()).stacksTo(1)))
+    val LEEK_AND_POTATO_STEW = create("leek_and_potato_stew", Item(Item.Properties().food(FoodProperties.Builder().nutrition(8).saturationModifier(0.6f).usingConvertsTo(Items.BOWL).build()).stacksTo(1)))
    @JvmField
    val REVIVE = create("revive", ReviveItem(max = false))
    @JvmField
@@ -33,12 +33,13 @@ class PartyCheckCriterion(
    override fun matches(player: ServerPlayer, context: PlayerPartyStore): Boolean {
        val matches = mutableListOf<ResourceLocation>()
        party.forEach {
-            if (it == "any".asIdentifierDefaultingNamespace()) {
+            if (it == "any".asIdentifierDefaultingNamespace("minecraft") || it == "any".asIdentifierDefaultingNamespace()) {
                matches.add(it)
            }
        }
        val partyCount = context.count()
        if (matches.containsAll(party) && party.size == partyCount && matches.size == partyCount) return true
+        matches.clear()
        context.iterator().forEach {
            if (party.contains(it.species.resourceIdentifier)) {
                matches.add(it.species.resourceIdentifier)
@@ -47,55 +48,3 @@ class PartyCheckCriterion(
        return matches.containsAll(party) && matches.size == party.size
    }
 }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-/*class PartyCheckCriterion(id: Identifier, entity: LootContextPredicate) : SimpleCriterionCondition<PartyCheckContext>(id, entity){
-    val party = mutableListOf<Identifier>()
-    override fun toJson(json: JsonObject) {
-        json.add("party", JsonArray(party.size).also {
-            party.forEach { pokemon -> it.add(pokemon.toString()) }
-        })
-    }
-
-    override fun fromJson(json: JsonObject) {
-        party.clear()
-        json.getAsJsonArray("party").forEach { element ->
-            party.add(element.asString.asIdentifierDefaultingNamespace())
-        }
-    }
-
-    override fun matches(player: ServerPlayer, context: PartyCheckContext): Boolean {
-        val playerParty = player.party()
-        val matches = mutableListOf<Identifier>()
-        party.forEach {
-            if (it == "any".asIdentifierDefaultingNamespace()) {
-                matches.add(it)
-            }
-        }
-        val partyCount = playerParty.count()
-        if (matches.containsAll(party) && party.size == partyCount && matches.size == partyCount) return true
-        playerParty.iterator().forEach {
-            if (party.contains(it.species.resourceIdentifier)) {
-                matches.add(it.species.resourceIdentifier)
-            }
-        }
-        return matches.containsAll(party) && matches.size == partyCount
-    }
-}
-
-open class PartyCheckContext(val party : PlayerPartyStore)*/
@@ -8,6 +8,7 @@

 package com.cobblemon.mod.common.api.drop

+import com.cobblemon.mod.common.pokemon.Pokemon
 import net.minecraft.server.level.ServerLevel
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.world.entity.LivingEntity
@@ -40,17 +41,23 @@ interface DropEntry {
     * to be dropped.
     */
    val percentage: Float
+
    /**
     * The drop's quantity when doing selection from the [DropTable]. See the drop table documentation for more on how
     * this works.
     */
    val quantity: Int
+
    /**
     * The maximum number of times the item can be selected drop the [DropTable]. In most cases this will just be 1,
     * meaning that the item, once picked, cannot be picked again. A larger value will allow the same [DropEntry] from
     * appearing multiple times in a drop action.
     */
    val maxSelectableTimes: Int
+
+    /** Whether this is considered a possible drop at the moment or not */
+    fun canDrop(pokemon: Pokemon?): Boolean = true
+
    /** The logic to use to actually drop the thing. */
    fun drop(entity: LivingEntity?, world: ServerLevel, pos: Vec3, player: ServerPlayer?)
 }
@@ -11,11 +11,13 @@ package com.cobblemon.mod.common.api.drop
 import com.cobblemon.mod.common.api.events.CobblemonEvents.LOOT_DROPPED
 import com.cobblemon.mod.common.api.events.drops.LootDroppedEvent
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.pokemon.Pokemon
 import kotlin.random.Random
 import net.minecraft.network.RegistryFriendlyByteBuf
 import net.minecraft.server.level.ServerLevel
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.item.ItemStack
 import net.minecraft.world.phys.Vec3

 /**
@@ -45,9 +47,11 @@ class DropTable {
     * Gets a drop list from this table as a list of [DropEntry]. You can specify the range of drop quantity totals
     * that will be possible, or if you leave it blank it will use [DropTable.amount].
     */
-    fun getDrops(amount: IntRange = this.amount): List<DropEntry> {
+    fun getDrops(amount: IntRange = this.amount, pokemon: Pokemon? = null): List<DropEntry> {
        val chosenAmount = amount.random()
-        val possibleDrops = entries.filter { it.quantity <= chosenAmount }.toMutableList()
+        val possibleDrops = entries.filter {
+            it.quantity <= chosenAmount && it.canDrop(pokemon)
+        }.toMutableList()

        if (possibleDrops.isEmpty()) {
            return emptyList()
@@ -87,11 +91,10 @@ class DropTable {
        world: ServerLevel,
        pos: Vec3,
        player: ServerPlayer?,
-        amount: IntRange = this.amount
+        amount: IntRange = this.amount,
+        pokemon: Pokemon? = null,
    ) {
-        val drops = getDrops(amount).toMutableList()
-        val heldItem = (entity as PokemonEntity).pokemon.heldItemNoCopy()
-        if (!heldItem.isEmpty) entity.spawnAtLocation(heldItem.item)
+        val drops = getDrops(amount, pokemon).toMutableList()
        LOOT_DROPPED.postThen(
            event = LootDroppedEvent(this, player, entity, drops),
            ifSucceeded = { it.drops.forEach { it.drop(entity, world, pos, player) } }
@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.drop
+
+import com.cobblemon.mod.common.api.pokemon.evolution.requirement.EvolutionRequirement
+import com.cobblemon.mod.common.pokemon.Pokemon
+
+class EvolutionItemDropEntry : ItemDropEntry() {
+    val requirements: MutableSet<EvolutionRequirement> = mutableSetOf()
+
+    override fun canDrop(pokemon: Pokemon?): Boolean = pokemon != null && requirements.all { it.check(pokemon) }
+}
@@ -13,6 +13,7 @@ import com.cobblemon.mod.common.api.events.battles.BattleFledEvent
 import com.cobblemon.mod.common.api.events.battles.BattleStartedPostEvent
 import com.cobblemon.mod.common.api.events.battles.BattleStartedPreEvent
 import com.cobblemon.mod.common.api.events.battles.BattleVictoryEvent
+import com.cobblemon.mod.common.api.events.battles.instruction.FormeChangeEvent
 import com.cobblemon.mod.common.api.events.battles.instruction.MegaEvolutionEvent
 import com.cobblemon.mod.common.api.events.battles.instruction.TerastallizationEvent
 import com.cobblemon.mod.common.api.events.battles.instruction.ZMoveUsedEvent
@@ -105,6 +106,8 @@ object CobblemonEvents {
    val TERASTALLIZATION = EventObservable<TerastallizationEvent>()
    @JvmField
    val ZPOWER_USED = EventObservable<ZMoveUsedEvent>()
+    @JvmField
+    val FORME_CHANGE = EventObservable<FormeChangeEvent>()

    @JvmField
    val POKEMON_SENT_PRE = CancelableObservable<PokemonSentPreEvent>()
@@ -193,6 +196,8 @@ object CobblemonEvents {
    @JvmField
    val POKEMON_SEEN = EventObservable<PokemonSeenEvent>()
    @JvmField
+    val POKEMON_ASPECTS_CHANGED = EventObservable<PokemonAspectsChangedEvent>()
+    @JvmField
    val POKEDEX_DATA_CHANGED_PRE = CancelableObservable<PokedexDataChangedEvent.Pre>()
    @JvmField
    val POKEDEX_DATA_CHANGED_POST = EventObservable<PokedexDataChangedEvent.Post>()
@@ -8,9 +8,16 @@

 package com.cobblemon.mod.common.api.events.battles

+import com.bedrockk.molang.runtime.struct.QueryStruct
+import com.bedrockk.molang.runtime.value.DoubleValue
+import com.bedrockk.molang.runtime.value.MoValue
+import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.battles.interpreter.BattleContext
 import com.cobblemon.mod.common.api.battles.model.PokemonBattle
+import com.cobblemon.mod.common.api.battles.model.actor.ActorType
 import com.cobblemon.mod.common.battles.pokemon.BattlePokemon
+import com.cobblemon.mod.common.util.asArrayValue
+import java.util.function.Function

 /**
 * Event fired when a [BattlePokemon] faints. Exposes the [BattlePokemon] that fainted and the [BattleContext]
@@ -23,4 +30,20 @@ data class BattleFaintedEvent(
    override val battle: PokemonBattle,
    val killed: BattlePokemon,
    val context: BattleContext
-) : BattleEvent
+) : BattleEvent {
+    val structContext = mutableMapOf<String, MoValue>(
+        "battle" to battle.struct,
+        "players" to battle.actors.filter { it.type == ActorType.PLAYER }.asArrayValue { it.struct },
+        "npcs" to battle.actors.filter { it.type == ActorType.NPC }.asArrayValue { it.struct },
+        "wild_pokemon" to battle.actors.filter { it.type == ActorType.WILD }.asArrayValue { it.struct },
+        "pokemon" to killed.struct,
+        "context" to QueryStruct(
+            hashMapOf(
+                "type" to Function { StringValue(context.type.name) },
+                "origin" to Function { context.origin?.struct ?: DoubleValue(0.0) },
+                "id" to Function { StringValue(context.id) },
+                "turn_created" to Function { DoubleValue(context.turn.toDouble()) },
+            )
+        )
+    )
+}
@@ -8,8 +8,12 @@

 package com.cobblemon.mod.common.api.events.battles

+import com.bedrockk.molang.runtime.value.MoValue
+import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.battles.model.PokemonBattle
+import com.cobblemon.mod.common.api.battles.model.actor.ActorType
 import com.cobblemon.mod.common.battles.actor.PlayerBattleActor
+import com.cobblemon.mod.common.util.asArrayValue

 /**
 * Event fired when a [PokemonBattle] is fled by a [PlayerBattleActor].
@@ -20,4 +24,11 @@ import com.cobblemon.mod.common.battles.actor.PlayerBattleActor
 data class BattleFledEvent (
    override val battle: PokemonBattle,
    val player: PlayerBattleActor
-) : BattleEvent
+) : BattleEvent {
+    val context = mutableMapOf<String, MoValue>(
+        "battle" to battle.struct,
+        "players" to battle.actors.filter { it.type == ActorType.PLAYER }.asArrayValue { it.struct },
+        "npcs" to battle.actors.filter { it.type == ActorType.NPC }.asArrayValue { it.struct },
+        "wild_pokemon" to battle.actors.filter { it.type == ActorType.WILD }.asArrayValue { it.struct }
+    )
+}
@@ -9,7 +9,9 @@
 package com.cobblemon.mod.common.api.events.battles

 import com.cobblemon.mod.common.api.battles.model.PokemonBattle
+import com.cobblemon.mod.common.api.battles.model.actor.ActorType
 import com.cobblemon.mod.common.api.events.Cancelable
+import com.cobblemon.mod.common.util.asArrayValue
 import net.minecraft.network.chat.MutableComponent

 /**
@@ -21,7 +23,14 @@ import net.minecraft.network.chat.MutableComponent
 * @author Segfault Guy
 * @since March 26th 2023
 */
-data class BattleStartedPreEvent (override val battle: PokemonBattle, var reason: MutableComponent? = null) : BattleEvent, Cancelable()
+data class BattleStartedPreEvent (override val battle: PokemonBattle, var reason: MutableComponent? = null) : BattleEvent, Cancelable() {
+    val context = mutableMapOf(
+        "battle" to battle.struct,
+        "players" to battle.actors.filter { it.type == ActorType.PLAYER }.asArrayValue { it.struct },
+        "npcs" to battle.actors.filter { it.type == ActorType.NPC }.asArrayValue { it.struct },
+        "wild_pokemon" to battle.actors.filter { it.type == ActorType.WILD }.asArrayValue { it.struct }
+    )
+}

 /**
 * Event fired after a [PokemonBattle] starts.
@@ -29,4 +38,11 @@ data class BattleStartedPreEvent (override val battle: PokemonBattle, var reason
 * @author Segfault Guy
 * @since March 26th 2023
 */
-data class BattleStartedPostEvent (override val battle: PokemonBattle) : BattleEvent
+data class BattleStartedPostEvent (override val battle: PokemonBattle) : BattleEvent {
+    val context = mutableMapOf(
+        "battle" to battle.struct,
+        "players" to battle.actors.filter { it.type == ActorType.PLAYER }.asArrayValue { it.struct },
+        "npcs" to battle.actors.filter { it.type == ActorType.NPC }.asArrayValue { it.struct },
+        "wild_pokemon" to battle.actors.filter { it.type == ActorType.WILD }.asArrayValue { it.struct }
+    )
+}
@@ -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.events.battles.instruction
+
+import com.bedrockk.molang.runtime.value.MoValue
+import com.bedrockk.molang.runtime.value.StringValue
+import com.cobblemon.mod.common.api.battles.model.PokemonBattle
+import com.cobblemon.mod.common.api.battles.model.actor.ActorType
+import com.cobblemon.mod.common.api.events.battles.BattleEvent
+import com.cobblemon.mod.common.battles.dispatch.InterpreterInstruction
+import com.cobblemon.mod.common.battles.pokemon.BattlePokemon
+import com.cobblemon.mod.common.util.asArrayValue
+
+/**
+ * Event that is fired when a Pokemon changes Forme in battle.
+ * @param battle The battle where the change occurred.
+ * @param pokemon The Pokemon that changed Forme.
+ */
+data class FormeChangeEvent(
+    override val battle: PokemonBattle,
+    val pokemon: BattlePokemon,
+    val formeName: String
+) : BattleEvent {
+    val context = mutableMapOf(
+        "battle" to battle.struct,
+        "players" to battle.actors.filter { it.type == ActorType.PLAYER }.asArrayValue { it.struct },
+        "npcs" to battle.actors.filter { it.type == ActorType.NPC }.asArrayValue { it.struct },
+        "wild_pokemon" to battle.actors.filter { it.type == ActorType.WILD }.asArrayValue { it.struct },
+        "pokemon" to pokemon.struct,
+        "forme" to StringValue(formeName)
+    )
+}
@@ -8,13 +8,25 @@

 package com.cobblemon.mod.common.api.events.battles.instruction

+import com.bedrockk.molang.runtime.value.MoValue
+import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.battles.model.PokemonBattle
+import com.cobblemon.mod.common.api.battles.model.actor.ActorType
 import com.cobblemon.mod.common.battles.dispatch.InterpreterInstruction
 import com.cobblemon.mod.common.battles.pokemon.BattlePokemon
+import com.cobblemon.mod.common.util.asArrayValue

 /**
 * Event that is fired when a Pokemon Mega Evolves.
 * @param battle The Pokemon Battle.
 * @param pokemon The Pokemon that Mega Evolves.
 */
-data class MegaEvolutionEvent(val battle: PokemonBattle, val pokemon: BattlePokemon)
+data class MegaEvolutionEvent(val battle: PokemonBattle, val pokemon: BattlePokemon) {
+    val context = mutableMapOf<String, MoValue>(
+        "battle" to battle.struct,
+        "players" to battle.actors.filter { it.type == ActorType.PLAYER }.asArrayValue { it.struct },
+        "npcs" to battle.actors.filter { it.type == ActorType.NPC }.asArrayValue { it.struct },
+        "wild_pokemon" to battle.actors.filter { it.type == ActorType.WILD }.asArrayValue { it.struct },
+        "pokemon" to pokemon.struct
+    )
+}
@@ -8,9 +8,13 @@

 package com.cobblemon.mod.common.api.events.battles.instruction

+import com.bedrockk.molang.runtime.value.MoValue
+import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.battles.model.PokemonBattle
+import com.cobblemon.mod.common.api.battles.model.actor.ActorType
 import com.cobblemon.mod.common.api.types.tera.TeraType
 import com.cobblemon.mod.common.battles.pokemon.BattlePokemon
+import com.cobblemon.mod.common.util.asArrayValue

 /**
 * Event that is fired when a Pokemon Terastallizes.
@@ -22,4 +26,13 @@ data class TerastallizationEvent(
    val battle: PokemonBattle,
    val pokemon: BattlePokemon,
    val teraType: TeraType
-    )
+    ) {
+    val context = mutableMapOf<String, MoValue>(
+        "battle" to battle.struct,
+        "players" to battle.actors.filter { it.type == ActorType.PLAYER }.asArrayValue { it.struct },
+        "npcs" to battle.actors.filter { it.type == ActorType.NPC }.asArrayValue { it.struct },
+        "wild_pokemon" to battle.actors.filter { it.type == ActorType.WILD }.asArrayValue { it.struct },
+        "pokemon" to pokemon.struct,
+        "tera_type" to StringValue(teraType.id.toString())
+    )
+}
@@ -8,12 +8,24 @@

 package com.cobblemon.mod.common.api.events.battles.instruction

+import com.bedrockk.molang.runtime.value.MoValue
+import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.battles.model.PokemonBattle
+import com.cobblemon.mod.common.api.battles.model.actor.ActorType
 import com.cobblemon.mod.common.battles.pokemon.BattlePokemon
+import com.cobblemon.mod.common.util.asArrayValue

 /**
 * Event that is fired when a Pokemon uses a Z-Move.
 * @param battle The Pokemon Battle.
 * @param pokemon The Pokemon that uses the Z-Move.
 */
-data class ZMoveUsedEvent(val battle: PokemonBattle, val pokemon: BattlePokemon)
+data class ZMoveUsedEvent(val battle: PokemonBattle, val pokemon: BattlePokemon) {
+    val context = mutableMapOf<String, MoValue>(
+        "battle" to battle.struct,
+        "players" to battle.actors.filter { it.type == ActorType.PLAYER }.asArrayValue { it.struct },
+        "npcs" to battle.actors.filter { it.type == ActorType.NPC }.asArrayValue { it.struct },
+        "wild_pokemon" to battle.actors.filter { it.type == ActorType.WILD }.asArrayValue { it.struct },
+        "pokemon" to pokemon.struct
+    )
+}
@@ -8,8 +8,13 @@

 package com.cobblemon.mod.common.api.events.farming

+import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.apricorn.Apricorn
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
+import com.cobblemon.mod.common.util.toArrayStruct
+import com.cobblemon.mod.common.util.worldRegistry
 import net.minecraft.core.BlockPos
+import net.minecraft.core.registries.Registries
 import net.minecraft.server.level.ServerLevel
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.world.level.block.state.BlockState
@@ -26,4 +31,11 @@ class ApricornHarvestEvent(
    fun getBlock(): BlockState {
        return world.getBlockState(pos)
    }
+
+    val context = mutableMapOf(
+        "player" to player.asMoLangValue(),
+        "apricorn" to StringValue(apricorn.name),
+        "world" to world.worldRegistry.wrapAsHolder(world).asMoLangValue(Registries.DIMENSION),
+        "pos" to pos.toArrayStruct()
+    )
 }
@@ -9,10 +9,11 @@
 package com.cobblemon.mod.common.api.events.fishing

 import com.cobblemon.mod.common.api.events.Cancelable
+import net.minecraft.world.entity.player.Player
 import net.minecraft.world.item.ItemStack

 /**
 * Event that is fired when a fishing rod is reeled.
 * @param rod The ItemStack of the rod that is being reeled.
 */
-class PokerodReelEvent(val rod: ItemStack) : Cancelable()
+class PokerodReelEvent(val player: Player, val rod: ItemStack) : Cancelable()
@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.api.events.pokeball

 import com.cobblemon.mod.common.api.events.Cancelable
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.entity.pokeball.EmptyPokeBallEntity
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity

@@ -18,4 +19,9 @@ import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 class ThrownPokeballHitEvent(
    val pokeBall : EmptyPokeBallEntity,
    val pokemon : PokemonEntity
-) : Cancelable()
+) : Cancelable() {
+    val context = mutableMapOf(
+        "pokeball" to pokeBall.struct,
+        "pokemon" to pokemon.asMoLangValue()
+    )
+}
@@ -8,14 +8,28 @@

 package com.cobblemon.mod.common.api.events.pokedex.scanning

+import com.bedrockk.molang.runtime.value.DoubleValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.pokedex.scanner.PokedexEntityData
 import com.cobblemon.mod.common.pokedex.scanner.ScannableEntity
 import net.minecraft.server.level.ServerPlayer
+import net.minecraft.world.entity.LivingEntity

 data class PokemonScannedEvent(val player: ServerPlayer, val scannedPokemonEntityData: PokedexEntityData, val scannedEntity: ScannableEntity) {
-    val pokedexEntityData: PokedexEntityData
-        get() = scannedPokemonEntityData
-
    val isOwned: Boolean
-        get() = scannedPokemonEntityData.ownerUUID == player.uuid
+        get() = scannedPokemonEntityData.pokemon.getOwnerUUID() == player.uuid
+
+    val context = mutableMapOf(
+        "player" to player.asMoLangValue(),
+        "pokemon" to scannedPokemonEntityData.pokemon.struct,
+        "disguise" to (scannedPokemonEntityData.disguise?.struct ?: DoubleValue.ZERO),
+        "entity" to {
+            when (scannedEntity) {
+                is LivingEntity -> scannedEntity.asMostSpecificMoLangValue()
+                else -> DoubleValue.ZERO
+            }
+        },
+    )
 }
@@ -8,6 +8,7 @@

 package com.cobblemon.mod.common.api.events.pokemon

+import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.pokemon.Pokemon

 /**
@@ -18,5 +19,11 @@ import com.cobblemon.mod.common.pokemon.Pokemon
 */
 data class FriendshipUpdatedEvent(
    val pokemon: Pokemon,
-    var newFriendship: Int
-)
+    val newFriendshipInitial: Int
+)
+{
+    var newFriendship: Int = newFriendshipInitial
+        set(value) {
+            field = value.coerceIn(0, Cobblemon.config.maxPokemonFriendship)
+        }
+}
@@ -8,6 +8,7 @@

 package com.cobblemon.mod.common.api.events.pokemon

+import com.bedrockk.molang.runtime.value.DoubleValue
 import com.cobblemon.mod.common.pokemon.Pokemon

 /**
@@ -16,4 +17,10 @@ import com.cobblemon.mod.common.pokemon.Pokemon
 * @author Hiroku
 * @since August 5th, 2022
 */
-class LevelUpEvent(val pokemon: Pokemon, val oldLevel: Int, var newLevel: Int)
+class LevelUpEvent(val pokemon: Pokemon, val oldLevel: Int, var newLevel: Int) {
+    val context = mutableMapOf(
+        "pokemon" to pokemon.struct,
+        "old_level" to DoubleValue(oldLevel.toDouble()),
+        "new_level" to DoubleValue(newLevel.toDouble())
+    )
+}
@@ -17,16 +17,14 @@ import com.cobblemon.mod.common.api.pokedex.AbstractPokedexManager
 import com.cobblemon.mod.common.api.pokedex.FormDexRecord
 import com.cobblemon.mod.common.api.pokedex.PokedexEntryProgress
 import com.cobblemon.mod.common.pokedex.scanner.PokedexEntityData
-import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.util.getPlayer
-import com.mojang.datafixers.util.Either
 import java.util.UUID

 /**
 * Event that fires when a Pokémon's information is gained or updated in the Pokédex.
 */
 sealed interface PokedexDataChangedEvent {
-    val dataSource: Either<PokedexEntityData, Pokemon>
+    val dataSource: PokedexEntityData
    val knowledge: PokedexEntryProgress
    val playerUUID: UUID
    val record: FormDexRecord
@@ -37,22 +35,22 @@ sealed interface PokedexDataChangedEvent {
    fun getContext(): MutableMap<String, MoValue> {
        return mutableMapOf(
            "player" to (playerUUID.getPlayer()?.asMoLangValue() ?: DoubleValue.ZERO),
-            "pokemon" to dataSource.map({ DoubleValue.ZERO }, { it.struct }),
-            "data" to dataSource.map({ it.struct }, { DoubleValue.ZERO }),
+            "pokemon" to dataSource.pokemon.struct,
+            "disguise" to (dataSource.disguise?.struct ?: DoubleValue.ZERO),
            "knowledge" to StringValue(knowledge.name.lowercase()),
            "pokedex" to pokedexManager.struct
        )
    }

    class Pre(
-        override val dataSource: Either<PokedexEntityData, Pokemon>,
+        override val dataSource: PokedexEntityData,
        override val knowledge: PokedexEntryProgress,
        override val playerUUID: UUID,
        override val record: FormDexRecord
    ) : PokedexDataChangedEvent, Cancelable()

    class Post(
-        override val dataSource: Either<PokedexEntityData, Pokemon>,
+        override val dataSource: PokedexEntityData,
        override val knowledge: PokedexEntryProgress,
        override val playerUUID: UUID,
        override val record: FormDexRecord
@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.events.pokemon
+
+import com.cobblemon.mod.common.pokemon.Pokemon
+import java.util.*
+
+data class PokemonAspectsChangedEvent(
+    val ownerId: UUID?,
+    val pokemon: Pokemon,
+)
@@ -8,6 +8,7 @@

 package com.cobblemon.mod.common.api.events.pokemon

+import com.bedrockk.molang.runtime.value.DoubleValue
 import com.cobblemon.mod.common.pokemon.Pokemon

 /**
@@ -16,4 +17,9 @@ import com.cobblemon.mod.common.pokemon.Pokemon
 data class PokemonFaintedEvent(
    val pokemon: Pokemon,
    var faintedTimer: Int
-)
+) {
+    val context = mutableMapOf(
+        "pokemon" to pokemon.struct,
+        "fainted_timer" to DoubleValue(faintedTimer)
+    )
+}
@@ -8,10 +8,16 @@

 package com.cobblemon.mod.common.api.events.pokemon

+import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.pokemon.Pokemon
 import java.util.UUID

 data class PokemonGainedEvent(
    val playerId: UUID,
    val pokemon: Pokemon
-)
+) {
+    val context = mutableMapOf(
+        "player_id" to StringValue(playerId.toString()),
+        "pokemon" to pokemon.struct
+    )
+}
@@ -96,11 +96,12 @@ interface PokemonSelectingItem {
            player.sendSystemMessage(battleLang("bagitem.invalid").red())
        } else {
            battlePokemon.actor.forceChoose(BagItemActionResponse(bagItem, battlePokemon))
+            val stackName = BuiltInRegistries.ITEM.getKey(stack.item)
            if (!player.isCreative) {
                stack.shrink(1)
                battlePokemon.actor.itemsUsed.add(bagItem)
            }
-            CobblemonCriteria.POKEMON_INTERACT.trigger(player, PokemonInteractContext(battlePokemon.effectedPokemon.species.resourceIdentifier, BuiltInRegistries.ITEM.getKey(stack.item)))
+            CobblemonCriteria.POKEMON_INTERACT.trigger(player, PokemonInteractContext(battlePokemon.effectedPokemon.species.resourceIdentifier, stackName))
        }
    }

@@ -148,4 +149,4 @@ interface PokemonSelectingItem {

        return InteractionResultHolder.success(stack)
    }
-}
+}
@@ -514,6 +514,17 @@ object MoLangFunctions {
                    .map { it.asMostSpecificMoLangValue() }
                    .asArrayValue()
            }
+            map.put("is_standing_on_blocks") { params ->
+                val depth = params.getDouble(0).toInt()
+                val blocks: MutableSet<Block> = mutableSetOf()
+                for (blockIndex in 1..<params.params.size) {
+                    val blockString = params.getString(blockIndex)
+                    val block = BuiltInRegistries.BLOCK.get(blockString.asIdentifierDefaultingNamespace("minecraft"))
+                    blocks.add(block)
+                }
+
+                return@put if (entity.isStandingOn(blocks, depth)) DoubleValue.ONE else DoubleValue.ZERO
+            }
            if (entity is PosableEntity) {
                map.put("play_animation") { params ->
                    val animation = params.getString(0)
@@ -603,7 +614,8 @@ object MoLangFunctions {
                    val context = ActionEffectContext(
                        actionEffect = actionEffect,
                        providers = mutableListOf(NPCProvider(npc)),
-                        runtime = runtime
+                        runtime = runtime,
+                        level = npc.level()
                    )
                    npc.actionEffect = context
                    npc.brain.setMemory(CobblemonMemories.ACTIVE_ACTION_EFFECT, context)
@@ -706,6 +718,11 @@ object MoLangFunctions {
            map.put("form") { StringValue(pokemon.form.name) }
            map.put("weight") { DoubleValue(pokemon.species.weight.toDouble()) }
            map.put("matches") { params -> DoubleValue(params.getString(0).toProperties().matches(pokemon)) }
+            map.put("apply") { params ->
+                params.getString(0).toProperties().apply(pokemon)
+                DoubleValue.ONE
+            }
+            map.put("owner") { pokemon.getOwnerPlayer()?.asMoLangValue() ?: DoubleValue.ZERO }
            map
        }
    )
@@ -54,7 +54,15 @@ class BenchedMoves : Iterable<BenchedMove> {
        }
    }

-    fun add(benchedMove: BenchedMove) = doThenEmit { benchedMoves.add(benchedMove) }
+    fun add(benchedMove: BenchedMove): Boolean {
+        if (any { it.moveTemplate == benchedMove.moveTemplate }) {
+            return false
+        }
+
+        doThenEmit { benchedMoves.add(benchedMove) }
+        return true
+    }
+
    fun addAll(benchedMoves: Iterable<BenchedMove>) = doThenEmit { this.benchedMoves.addAll(benchedMoves) }
    fun clear() = doThenEmit { benchedMoves.clear() }
    fun remove(benchedMove: BenchedMove) = doThenEmit { benchedMoves.remove(benchedMove) }
@@ -8,6 +8,12 @@

 package com.cobblemon.mod.common.api.moves

+import com.bedrockk.molang.runtime.MoParams
+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.molang.MoLangFunctions.addFunctions
+import com.cobblemon.mod.common.api.molang.ObjectValue
 import com.cobblemon.mod.common.api.moves.categories.DamageCategory
 import com.cobblemon.mod.common.api.reactive.SimpleObservable
 import com.cobblemon.mod.common.api.types.ElementalType
@@ -25,6 +31,7 @@ import com.mojang.serialization.codecs.RecordCodecBuilder
 import kotlin.math.ceil
 import kotlin.properties.Delegates
 import net.minecraft.network.chat.MutableComponent
+import java.util.function.Function

 /**
 * Representing a Move based on some template and with current PP and the number of raised PP stages.
@@ -90,6 +97,21 @@ open class Move(
    val maxPp: Int
        get() = template.pp + raisedPpStages * template.pp / 5

+    val struct: QueryStruct = ObjectValue(this).also {
+        it.addFunctions(
+            hashMapOf(
+                "name" to Function { StringValue(name) },
+                "display_name" to Function { StringValue(displayName.string) },
+                "description" to Function { StringValue(description.string) },
+                "type" to Function { StringValue(type.name) },
+                "damage_category" to Function { StringValue(damageCategory.name) },
+                "power" to Function { DoubleValue(power) },
+                "accuracy" to Function { DoubleValue(accuracy) },
+                "max_pp" to Function { DoubleValue(maxPp.toDouble()) }
+            )
+        )
+    }
+
    /** Raises the max PP and rescales the current PP value. Returns false if it was already maxed out. */
    fun raiseMaxPP(amount: Int): Boolean {
        val oldPp = maxPp
@@ -8,6 +8,8 @@

 package com.cobblemon.mod.common.api.moves

+import com.bedrockk.molang.runtime.struct.QueryStruct
+import com.bedrockk.molang.runtime.value.DoubleValue
 import com.cobblemon.mod.common.api.reactive.SimpleObservable
 import com.cobblemon.mod.common.net.IntSize
 import com.cobblemon.mod.common.util.DataKeys
@@ -27,6 +29,22 @@ class MoveSet : Iterable<Move> {

    private val moves = arrayOfNulls<Move>(MOVE_COUNT)

+    fun toStruct(): QueryStruct {
+        val struct = QueryStruct(hashMapOf())
+        struct.addFunction("move") { params ->
+            val index = params.getInt(0) as? Int ?: return@addFunction null
+            return@addFunction get(index)?.struct
+        }
+        struct.addFunction("has_move") { params ->
+            val moveID = params.getString(0) ?: return@addFunction null
+            return@addFunction if(moves.any { it?.template?.name == moveID }) DoubleValue(1.0) else DoubleValue(0.0)
+        }
+        struct.addFunction("get_move") { params ->
+            val moveID = params.getString(0) ?: return@addFunction null
+            return@addFunction moves.firstOrNull { it?.template?.name == moveID }?.struct
+        }
+        return struct
+    }

    override fun iterator() = moves.filterNotNull().iterator()

@@ -116,18 +134,21 @@ class MoveSet : Iterable<Move> {
        return json
    }

-    fun add(move: Move) {
+    fun add(move: Move): Boolean {
        if (any { it.template == move.template }) {
-            return
+            return false
        }
+
        for (i in 0 until MOVE_COUNT) {
            if (moves[i] == null) {
                moves[i] = move
                move.observable.subscribe { this.update() }
                update()
-                return
+                return true
            }
        }
+
+        return false
    }

    fun update() {
@@ -15,6 +15,7 @@ import com.cobblemon.mod.common.entity.npc.NPCEntity
 import com.cobblemon.mod.common.util.asExpressionLike
 import com.cobblemon.mod.common.util.resolveBoolean
 import net.minecraft.world.entity.Entity
+import net.minecraft.world.level.Level
 import java.util.concurrent.CompletableFuture

 /**
@@ -69,7 +70,8 @@ class ActionEffectContext(
    val runtime: MoLangRuntime,
    var canBeInterrupted: Boolean = false,
    var interrupted: Boolean = false,
-    var currentKeyframes: MutableList<ActionEffectKeyframe> = mutableListOf()
+    var currentKeyframes: MutableList<ActionEffectKeyframe> = mutableListOf(),
+    var level: Level? = null
 ) {
    inline fun <reified T> findOneProvider() = providers.filterIsInstance<T>().firstOrNull()
 }
@@ -24,6 +24,7 @@ import net.minecraft.server.level.ServerLevel

 /**
 * Spawns particles on the entity based on the given particle effect and locator.
+ * Optionally, you can specify target that ends up setting the destination pos on the spawned ParticleStorm
 *
 * @author Hiroku
 * @since January 21st, 2024
@@ -32,14 +33,25 @@ class EntityParticlesActionEffectKeyframe : ConditionalActionEffectKeyframe(), E
    override val entityCondition = "q.entity.is_user".asExpressionLike()
    var effect: String? = null
    var locators: List<String> = listOf("target")
+    var targetLocators: Set<String>? = null

    val delay: ExpressionLike = "0".asExpressionLike()
    val visibilityRange = 200

    override fun playWhenTrue(context: ActionEffectContext): CompletableFuture<Unit> {
-        val entities = context.providers
+        val allEntities = context.providers
            .filterIsInstance<EntityProvider>()
-            .flatMap { prov -> prov.entities.filter { test(context, it, isUser = prov is UsersProvider) } }
+            .flatMap { prov -> prov.entities }
+
+        val userEntities = context.providers
+            .filterIsInstance<UsersProvider>()
+            .flatMap { prov -> prov.entities }
+
+        val targetEntities = context.providers
+            .filterIsInstance<TargetsProvider>()
+            .flatMap { prov -> prov.entities}
+
+        val sourceEntities = allEntities.filter { test(context, it, it in userEntities) }

        val effectIdentifier = try {
            effect?.asExpressionLike()?.resolveString(context.runtime)?.takeIf { it != "0" } ?: effect
@@ -47,10 +59,24 @@ class EntityParticlesActionEffectKeyframe : ConditionalActionEffectKeyframe(), E
            effect
        }?.asIdentifierDefaultingNamespace() ?: return skip()

-        entities.filter { it is PosableEntity }.forEach { entity ->
-            val packet = SpawnSnowstormEntityParticlePacket(effectIdentifier, entity.id, (locators).toList())
-            val players = (entity.level() as ServerLevel).getPlayers { it.distanceTo(entity) <= visibilityRange }
-            packet.sendToPlayers(players)
+        //Things could be a little weird here since TECHNICALLY it might be possible for a battle to be happening across dimensions
+        val calcedLevel = (context.level as? ServerLevel) ?: allEntities.first().level() as ServerLevel
+        val players = calcedLevel.getPlayers { player ->
+            allEntities.any { player.distanceTo(it) <= visibilityRange }
+        }
+
+
+        sourceEntities.filter { it is PosableEntity }.forEach { entity ->
+            if (targetLocators == null) {
+                val packet = SpawnSnowstormEntityParticlePacket(effectIdentifier, entity.id, locators)
+                packet.sendToPlayers(players)
+            }
+            else {
+                targetEntities.forEach { targetEntity ->
+                    val packet = SpawnSnowstormEntityParticlePacket(effectIdentifier, entity.id, locators, targetEntity.id, targetLocators!!.toList())
+                    packet.sendToPlayers(players)
+                }
+            }
        }

        return delayedFuture(seconds = delay.resolveFloat(context.runtime))
@@ -38,8 +38,9 @@ class NPCClass {
    var resourceIdentifier: ResourceLocation = cobblemonResource("dummy")
    var names: MutableList<Component> = mutableListOf()
    var aspects: MutableSet<String> = mutableSetOf() // These only make sense when applied via presets
+    var baseScale: Float = 1F
    var hitbox = EntityDimensions.scalable(0.6F, 1.8F).withEyeHeight(1.62F)
-    var modelScale: Float = 0.94F
+    var modelScale: Float = 0.9375F
    var battleConfiguration = NPCBattleConfiguration()
    var interaction: NPCInteractConfiguration? = null
    var canDespawn = true
@@ -56,12 +57,14 @@ class NPCClass {
    var isInvulnerable = false
    var isLeashable = true
    var allowProjectileHits = true
+    var hideNameTag = false

    // If you're adding stuff here, add it to NPCPreset and NPCClassAdapter too

    fun encode(buffer: RegistryFriendlyByteBuf) {
        buffer.writeString(resourceIdentifier.toString())
        buffer.writeCollection(names) { _, v -> buffer.writeText(v) }
+        buffer.writeFloat(baseScale)
        buffer.writeFloat(hitbox.width)
        buffer.writeFloat(hitbox.height)
        buffer.writeBoolean(hitbox.fixed)
@@ -95,11 +98,13 @@ class NPCClass {
        buffer.writeBoolean(isInvulnerable)
        buffer.writeBoolean(isLeashable)
        buffer.writeBoolean(allowProjectileHits)
+        buffer.writeBoolean(hideNameTag)
    }

    fun decode(buffer: RegistryFriendlyByteBuf) {
        resourceIdentifier = ResourceLocation.parse(buffer.readString().toString())
        names = buffer.readList { buffer.readText().copy() }.toMutableList()
+        baseScale = buffer.readFloat()
        val length = buffer.readFloat()
        val width = buffer.readFloat()
        val fixed = buffer.readBoolean()
@@ -145,5 +150,6 @@ class NPCClass {
        isInvulnerable = buffer.readBoolean()
        isLeashable = buffer.readBoolean()
        allowProjectileHits = buffer.readBoolean()
+        hideNameTag = buffer.readBoolean()
    }
 }
@@ -26,6 +26,7 @@ class NPCPreset {
    var canDespawn: Boolean? = null
    var interaction: NPCInteractConfiguration? = null
    var names: MutableSet<Component>? = null
+    var baseScale: Float? = null
    var hitbox: EntityDimensions? = null
    var ai: List<BrainConfig>? = null
    var skill: Int? = null
@@ -36,6 +37,7 @@ class NPCPreset {
    var isInvulnerable: Boolean? = null
    var isLeashable: Boolean? = null
    var allowProjectileHits: Boolean? = null
+    var hideNameTag: Boolean? = null

    fun applyTo(npcClass: NPCClass) {
        resourceIdentifier?.let { npcClass.resourceIdentifier = it }
@@ -51,6 +53,7 @@ class NPCPreset {
 //        aiScripts?.let { npcClass.aiScripts.addAll(it) }
        interaction?.let { npcClass.interaction = it }
        names?.let { npcClass.names.addAll(it) }
+        baseScale?.let { npcClass.baseScale = it }
        hitbox?.let { npcClass.hitbox = it }
        skill?.let { npcClass.skill = it }
        autoHealParty?.let { npcClass.autoHealParty = it }
@@ -61,5 +64,6 @@ class NPCPreset {
        isInvulnerable?.let { npcClass.isInvulnerable = it }
        isLeashable?.let { npcClass.isLeashable = it }
        allowProjectileHits?.let { npcClass.allowProjectileHits = it }
+        hideNameTag?.let { npcClass.hideNameTag = it }
    }
 }
@@ -78,6 +78,7 @@ any number of presets and the properties of those presets will be merged into th
      "skill": 5,
      "autoHealParty": true,
      "randomizePartyOrder": true,
+      "hideNameTag": false,
      "party": {
        "type": "simple",
        "pokemon": [
@@ -411,4 +412,7 @@ Pokémon in the party.

 ### ai
 The AI property is an array of brain configurations. This is used to configure the behaviours of the NPC. See
-the documentation for brain configurations at [AI Configuration](../ai/config/README.md).
+the documentation for brain configurations at [AI Configuration](../ai/config/README.md).
+
+### hideNameTag
+Whether the NPC's nametag should be hidden or not. Defaults to false.
@@ -202,6 +202,8 @@ object PokeBalls : JsonDataRegistry<PokeBall> {
        // Luxury ball effect, low priority as it must be triggered before soothe bell as of gen 4
        CobblemonEvents.FRIENDSHIP_UPDATED.subscribe(priority = Priority.LOW) { event ->
            var increment = (event.newFriendship - event.pokemon.friendship).toFloat()
+            if (increment <= 0) //these affects are only meant to affect positive gains
+                return@subscribe
            if (increment <= 1F) {
                event.pokemon.caughtBall.effects.filterIsInstance<FriendshipEarningBoostEffect>()
                    .forEach { increment *= it.multiplier }
@@ -42,7 +42,10 @@ class BaseStatModifier(

    override fun behavior(thrower: LivingEntity, pokemon: Pokemon): CatchRateModifier.Behavior = CatchRateModifier.Behavior.MULTIPLY

-    override fun isValid(thrower: LivingEntity, pokemon: Pokemon): Boolean = pokemon.form.baseStats[this.stat] != null
+    override fun isValid(thrower: LivingEntity, pokemon: Pokemon): Boolean {
+        val valStat = pokemon.form.baseStats[this.stat] ?: return false
+        return comparator(valStat)
+    }

    override fun modifyCatchRate(currentCatchRate: Float, thrower: LivingEntity, pokemon: Pokemon): Float = this.behavior(thrower, pokemon).mutator(currentCatchRate, this.value(thrower, pokemon))

@@ -32,6 +32,18 @@ abstract class AbstractPokedexManager {
        markDirty()
    }

+    fun deleteFormRecord(speciesId: ResourceLocation, formName: String) {
+        val speciesRecord = speciesRecords[speciesId] ?: return
+        speciesRecord.deleteFormRecord(formName)
+
+        if (speciesRecord.isFormRecordsEmpty) {
+            deleteSpeciesRecord(speciesId)
+            return
+        }
+
+        markDirty()
+    }
+
    fun getSpeciesRecord(speciesId: ResourceLocation): SpeciesDexRecord? {
        return speciesRecords[speciesId]
    }
@@ -84,15 +96,21 @@ abstract class AbstractPokedexManager {
    }

    fun getNewInformation(pokedexEntityData: PokedexEntityData): PokedexLearnedInformation {
-        val speciesRecord = getSpeciesRecord(pokedexEntityData.species.resourceIdentifier)
+        val speciesRecord = getSpeciesRecord(pokedexEntityData.getApparentSpecies().resourceIdentifier)
        if (speciesRecord == null || speciesRecord.getKnowledge() == PokedexEntryProgress.NONE) {
            return PokedexLearnedInformation.SPECIES
        }
-        val formRecord = speciesRecord.getFormRecord(pokedexEntityData.form.name)
+        val formRecord = speciesRecord.getFormRecord(pokedexEntityData.getApparentForm().name)
        if (formRecord == null || formRecord.knowledge == PokedexEntryProgress.NONE) {
            return PokedexLearnedInformation.FORM
        }
-        if (pokedexEntityData.aspects.any{ !speciesRecord.hasAspect(it) } || pokedexEntityData.gender !in formRecord.getGenders() || !formRecord.hasSeenShinyState(pokedexEntityData.shiny)) {
+
+        // Can't update aspects on a disguise
+        if (pokedexEntityData.disguise != null) {
+            return PokedexLearnedInformation.NONE
+        }
+
+        if (pokedexEntityData.pokemon.aspects.any { !speciesRecord.hasAspect(it) } || pokedexEntityData.pokemon.gender !in formRecord.getGenders() || !formRecord.hasSeenShinyState(pokedexEntityData.pokemon.shiny)) {
            return PokedexLearnedInformation.VARIATION
        }
        return PokedexLearnedInformation.NONE
@@ -13,6 +13,7 @@ import com.bedrockk.molang.runtime.struct.VariableStruct
 import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.events.CobblemonEvents
 import com.cobblemon.mod.common.api.events.pokemon.PokedexDataChangedEvent
+import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
 import com.cobblemon.mod.common.pokedex.scanner.PokedexEntityData
 import com.cobblemon.mod.common.pokemon.Gender
 import com.cobblemon.mod.common.pokemon.Pokemon
@@ -88,21 +89,15 @@ class FormDexRecord {
        it.knowledge = knowledge
    }

-    fun encountered(pokemon: Pokemon) {
-        if (wouldBeDifferent(pokemon, PokedexEntryProgress.ENCOUNTERED)) {
-            addInformation(pokemon, PokedexEntryProgress.ENCOUNTERED)
-        }
-    }
-
    fun encountered(pokedexEntityData: PokedexEntityData) {
        if (wouldBeDifferent(pokedexEntityData, PokedexEntryProgress.ENCOUNTERED)) {
            addInformation(pokedexEntityData, PokedexEntryProgress.ENCOUNTERED)
        }
    }

-    fun caught(pokemon: Pokemon) {
-        if (wouldBeDifferent(pokemon, PokedexEntryProgress.CAUGHT)) {
-            addInformation(pokemon, PokedexEntryProgress.CAUGHT)
+    fun caught(pokedexEntityData: PokedexEntityData) {
+        if (wouldBeDifferent(pokedexEntityData, PokedexEntryProgress.CAUGHT)) {
+            addInformation(pokedexEntityData, PokedexEntryProgress.CAUGHT)
        }
    }

@@ -112,8 +107,11 @@ class FormDexRecord {

    //Used when granting all entries in dex, should figure out better way
    fun addAllShinyStatesAndGenders() {
-        genders.addAll(listOf(Gender.MALE, Gender.FEMALE))
+        val form = PokemonSpecies.getByIdentifier(speciesDexRecord.id)?.getFormByName(formName)
+        genders.addAll(form?.possibleGenders ?: listOf(Gender.MALE, Gender.FEMALE))
+
        seenShinyStates.addAll(listOf("shiny", "normal"))
+        speciesDexRecord.onFormRecordUpdated(this)
    }

    fun setKnowledgeProgress(newKnowledge: PokedexEntryProgress) {
@@ -121,47 +119,18 @@ class FormDexRecord {
        speciesDexRecord.onFormRecordUpdated(this)
    }

-    private fun addInformation(pokemon: Pokemon, knowledge: PokedexEntryProgress) {
-        (speciesDexRecord.pokedexManager as? PokedexManager)?.let { pokedexManager ->
-            CobblemonEvents.POKEDEX_DATA_CHANGED_PRE.postThen(
-                PokedexDataChangedEvent.Pre(
-                        Either.right(pokemon),
-                        knowledge,
-                        pokedexManager.uuid,
-                        this
-                ),
-                ifSucceeded = {
-                    genders.add(pokemon.gender)
-                    seenShinyStates.add(if (pokemon.shiny) "shiny" else "normal")
-                    if (knowledge.ordinal > this.knowledge.ordinal) {
-                        this.knowledge = knowledge
-                    }
-                    speciesDexRecord.addInformation(pokemon, knowledge)
-                    speciesDexRecord.onFormRecordUpdated(this)
-                    CobblemonEvents.POKEDEX_DATA_CHANGED_POST.post(
-                        PokedexDataChangedEvent.Post(
-                                Either.right(pokemon),
-                                knowledge,
-                                pokedexManager.uuid,
-                                this
-                        )
-                    )
-                })
-        }
-    }
-
    private fun addInformation(pokedexEntityData: PokedexEntityData, knowledge: PokedexEntryProgress) {
        (speciesDexRecord.pokedexManager as? PokedexManager)?.let { pokedexManager ->
            CobblemonEvents.POKEDEX_DATA_CHANGED_PRE.postThen(
                PokedexDataChangedEvent.Pre(
-                        Either.left(pokedexEntityData),
-                        knowledge,
-                        pokedexManager.uuid,
-                        this
+                    pokedexEntityData,
+                    knowledge,
+                    pokedexManager.uuid,
+                    this
                ),
                ifSucceeded = {
-                    genders.add(pokedexEntityData.gender)
-                    seenShinyStates.add(if (pokedexEntityData.shiny) "shiny" else "normal")
+                    genders.add(pokedexEntityData.pokemon.gender)
+                    seenShinyStates.add(if (pokedexEntityData.pokemon.shiny) "shiny" else "normal")
                    if (knowledge.ordinal > this.knowledge.ordinal) {
                        this.knowledge = knowledge
                    }
@@ -169,10 +138,10 @@ class FormDexRecord {
                    speciesDexRecord.onFormRecordUpdated(this)
                    CobblemonEvents.POKEDEX_DATA_CHANGED_POST.post(
                        PokedexDataChangedEvent.Post(
-                                Either.left(pokedexEntityData),
-                                knowledge,
-                                pokedexManager.uuid,
-                                this
+                            pokedexEntityData,
+                            knowledge,
+                            pokedexManager.uuid,
+                            this
                        )
                    )
                }
@@ -180,19 +149,10 @@ class FormDexRecord {
        }
    }

-    /** Returns whether the given [Pokemon] and [knowledge] would add new information to the Pokédex.*/
-    fun wouldBeDifferent(pokemon: Pokemon, knowledge: PokedexEntryProgress): Boolean {
-        return pokemon.gender !in genders
-                || (pokemon.shiny && "shiny" !in seenShinyStates)
-                || (!pokemon.shiny && "normal" !in seenShinyStates)
-                || knowledge.ordinal > this.knowledge.ordinal
-                || speciesDexRecord.wouldBeDifferent(pokemon)
-    }
-
    fun wouldBeDifferent(pokedexEntityData: PokedexEntityData, knowledge: PokedexEntryProgress): Boolean {
-        return pokedexEntityData.gender !in genders
-                || (pokedexEntityData.shiny && "shiny" !in seenShinyStates)
-                || (!pokedexEntityData.shiny && "normal" !in seenShinyStates)
+        return pokedexEntityData.pokemon.gender !in genders
+                || (pokedexEntityData.pokemon.shiny && "shiny" !in seenShinyStates)
+                || (!pokedexEntityData.pokemon.shiny && "normal" !in seenShinyStates)
                || knowledge.ordinal > this.knowledge.ordinal
                || speciesDexRecord.wouldBeDifferent(pokedexEntityData)
    }
@@ -30,19 +30,19 @@ class PokedexManager(
    fun encounter(pokemon: Pokemon) {
        val speciesId = pokemon.species.resourceIdentifier
        val formName = pokemon.form.name
-        getOrCreateSpeciesRecord(speciesId).getOrCreateFormRecord(formName).encountered(pokemon)
+        getOrCreateSpeciesRecord(speciesId).getOrCreateFormRecord(formName).encountered(PokedexEntityData(pokemon = pokemon, disguise = null))
    }

    fun encounter(pokedexEntityData: PokedexEntityData) {
-        val speciesId = pokedexEntityData.species.resourceIdentifier
-        val formName = pokedexEntityData.form.name
+        val speciesId = pokedexEntityData.getApparentSpecies().resourceIdentifier
+        val formName = pokedexEntityData.getApparentForm().name
        getOrCreateSpeciesRecord(speciesId).getOrCreateFormRecord(formName).encountered(pokedexEntityData)
    }

    fun catch(pokemon: Pokemon) {
        val speciesId = pokemon.species.resourceIdentifier
        val formName = pokemon.form.name
-        getOrCreateSpeciesRecord(speciesId).getOrCreateFormRecord(formName).caught(pokemon)
+        getOrCreateSpeciesRecord(speciesId).getOrCreateFormRecord(formName).caught(PokedexEntityData(pokemon = pokemon, disguise = null))
    }

    override fun markDirty() {
@@ -50,6 +50,8 @@ class SpeciesDexRecord {
    lateinit var id: ResourceLocation
    private val aspects: MutableSet<String> = mutableSetOf()
    private val formRecords: MutableMap<String, FormDexRecord> = mutableMapOf()
+    val isFormRecordsEmpty: Boolean
+        get() = formRecords.isEmpty()

    fun describe(): String {
        return "SpeciesDexRecord(aspects=$aspects, formRecords=$formRecords)"
@@ -95,7 +97,7 @@ class SpeciesDexRecord {
    }

    fun addInformation(pokedexEntityData: PokedexEntityData, knowledge: PokedexEntryProgress) {
-        aspects.addAll(pokedexEntityData.aspects)
+        aspects.addAll(pokedexEntityData.pokemon.aspects)
    }

    fun addAspects(addedAspects: Set<String>) {
@@ -105,7 +107,7 @@ class SpeciesDexRecord {
    /** Returns true if the given Pokémon contains new information. Internal because it's only to be called from [FormDexRecord.wouldBeDifferent]. */
    internal fun wouldBeDifferent(pokemon: Pokemon) = pokemon.aspects.any { it !in aspects }

-    internal fun wouldBeDifferent(pokedexEntityData: PokedexEntityData) = pokedexEntityData.aspects.any { it !in aspects }
+    internal fun wouldBeDifferent(pokedexEntityData: PokedexEntityData) = pokedexEntityData.pokemon.aspects.any { it !in aspects }

    fun getOrCreateFormRecord(formName: String): FormDexRecord {
        return formRecords.getOrPut(formName.lowercase()) {
@@ -32,9 +32,10 @@ class SearchFilter(val pokedexManager: AbstractPokedexManager, val searchString:
        if (searchString == "") return true

        val species = PokemonSpecies.getByIdentifier(entry.speciesId) ?: return false
-        if (pokedexManager.getHighestKnowledgeFor(entry) == PokedexEntryProgress.NONE) return false
+        val highestKnowledgeForEntry = pokedexManager.getHighestKnowledgeFor(entry)
+        if (highestKnowledgeForEntry == PokedexEntryProgress.NONE) return false

-        when(searchByType) {
+        when (searchByType) {
            SearchByType.ABILITIES -> {
                if (pokedexManager.getHighestKnowledgeFor(entry) !== PokedexEntryProgress.CAUGHT) return false
                val abilityList = mutableListOf<String>()
@@ -468,6 +468,10 @@ open class PokemonProperties {
        return this.commonMatches(pokemonEntity.pokemon) && this.customProperties.none { !it.matches(pokemonEntity) }
    }

+    fun matches(properties: PokemonProperties): Boolean {
+        return properties.asString() == this.asString()
+    }
+
    private fun commonMatches(pokemon: Pokemon): Boolean {
        level?.takeIf { it != pokemon.level }?.let { return false }
        shiny?.takeIf { it != pokemon.shiny }?.let { return false }
@@ -805,7 +809,7 @@ open class PokemonProperties {
    private fun createAbility(id: String, form: FormData): Ability? {
        val ability = Abilities.get(id) ?: return null
        val potentialAbility = form.abilities.firstOrNull { potential -> potential.template == ability } ?: return ability.create(true)
-        return potentialAbility.template.create(false)
+        return potentialAbility.template.create(false, potentialAbility.priority)
    }

 }
@@ -13,6 +13,7 @@ import com.cobblemon.mod.common.CobblemonItems
 import com.cobblemon.mod.common.CobblemonSounds
 import com.cobblemon.mod.common.advancement.CobblemonCriteria
 import com.cobblemon.mod.common.advancement.criterion.EvolvePokemonContext
+import com.cobblemon.mod.common.api.drop.DropTable
 import com.cobblemon.mod.common.api.events.CobblemonEvents
 import com.cobblemon.mod.common.api.events.pokemon.PokemonGainedEvent
 import com.cobblemon.mod.common.api.events.pokemon.evolution.EvolutionCompleteEvent
@@ -32,9 +33,8 @@ import com.cobblemon.mod.common.pokemon.evolution.variants.LevelUpEvolution
 import com.cobblemon.mod.common.pokemon.evolution.variants.TradeEvolution
 import com.cobblemon.mod.common.util.lang
 import com.cobblemon.mod.common.util.party
-import net.minecraft.client.Minecraft
-import net.minecraft.core.registries.BuiltInRegistries
-import net.minecraft.network.protocol.game.ClientboundSoundPacket
+import com.cobblemon.mod.common.world.gamerules.CobblemonGameRules
+import net.minecraft.server.level.ServerLevel
 import net.minecraft.sounds.SoundSource
 import net.minecraft.world.entity.Entity
 import net.minecraft.world.item.ItemStack
@@ -80,6 +80,11 @@ interface Evolution : EvolutionLike {
     */
    val learnableMoves: MutableSet<MoveTemplate>

+    /**
+     * The items that will drop once the evolution finishes.
+     */
+    val drops: DropTable
+
    /**
     * Checks if the given [Pokemon] passes all the conditions and is ready to evolve.
     *
@@ -100,9 +105,6 @@ interface Evolution : EvolutionLike {
     * @param pokemon The [Pokemon] being evolved.
     */
    fun evolve(pokemon: Pokemon): Boolean {
-        if (this.consumeHeldItem) {
-            pokemon.swapHeldItem(ItemStack.EMPTY)
-        }
        if (this.optional) {
            // All the networking is handled under the hood, see EvolutionController.
            return pokemon.evolutionProxy.server().add(this)
@@ -130,7 +132,7 @@ interface Evolution : EvolutionLike {
        owner.party().getFirstAvailablePosition() ?: return false

        // Add shed Pokemon to player's party
-        val shedPokemon = pokemon.clone()
+        val shedPokemon = pokemon.clone(registryAccess = owner.registryAccess())
        shedPokemon.removeHeldItem()
        innerShedder.apply(shedPokemon)
        shedPokemon.caughtBall = ((pokeballStack?.item ?: CobblemonItems.POKE_BALL) as PokeBallItem).pokeBall
@@ -190,19 +192,49 @@ interface Evolution : EvolutionLike {
    }

    fun evolutionMethod(pokemon: Pokemon) {
+        // This ensures the Pokémon doesn't lose moves during evolution
+        // (e.g., Oshawott evolving at level 17 knowing Razor Shell, while Dewott only learns it at level 18).
+        val previousSpeciesLearnableMoves = pokemon.relearnableMoves
+
        this.result.apply(pokemon)
-        this.learnableMoves.forEach { move ->
-            if (pokemon.moveSet.hasSpace()) {
-                pokemon.moveSet.add(move.create())
-            } else {
-                pokemon.benchedMoves.add(BenchedMove(move, 0))
+
+        val movesToLearn = previousSpeciesLearnableMoves + this.learnableMoves
+        movesToLearn.forEach { move ->
+            val couldAddMove =
+                if (pokemon.moveSet.hasSpace()) {
+                    pokemon.moveSet.add(move.create())
+                } else {
+                    pokemon.benchedMoves.add(BenchedMove(move, 0))
+                }
+
+            val previousSpeciesKnewMove = previousSpeciesLearnableMoves.any { move.name == it.name }
+
+            if (couldAddMove && !previousSpeciesKnewMove) {
+                pokemon.getOwnerPlayer()?.sendSystemMessage(lang("experience.learned_move", pokemon.getDisplayName(), move.displayName))
            }
-            pokemon.getOwnerPlayer()?.sendSystemMessage(lang("experience.learned_move", pokemon.getDisplayName(), move.displayName))
        }
+
        // we want to instantly tick for example you might only evolve your Bulbasaur at level 34 so Venusaur should be immediately available
        pokemon.evolutions.filterIsInstance<PassiveEvolution>().forEach { evolution -> evolution.attemptEvolution(pokemon) }
        pokemon.lockedEvolutions.filterIsInstance<PassiveEvolution>().forEach { evolution -> evolution.attemptEvolution(pokemon) }
+
        this.shed(pokemon)
+
+        if (this.consumeHeldItem) {
+            pokemon.swapHeldItem(ItemStack.EMPTY)
+        }
+
+        val ownerPlayer = pokemon.getOwnerPlayer()
+        if (ownerPlayer != null && ownerPlayer.level().gameRules.getBoolean(CobblemonGameRules.DO_POKEMON_LOOT)) {
+            drops.drop(
+                pokemon.entity,
+                ownerPlayer.level() as ServerLevel,
+                pokemon.entity?.position() ?: ownerPlayer.position(),
+                ownerPlayer,
+                pokemon = pokemon
+            )
+        }
+
        CobblemonEvents.EVOLUTION_COMPLETE.post(EvolutionCompleteEvent(pokemon, this))
        CobblemonEvents.POKEMON_GAINED.post(PokemonGainedEvent(pokemon.getOwnerUUID()!!, pokemon))
    }
@@ -210,4 +242,4 @@ interface Evolution : EvolutionLike {
    fun applyTo(pokemon: Pokemon) {
        result.apply(pokemon)
    }
-}
+}
@@ -21,6 +21,12 @@ object CobblemonPokemonLabels {
     */
    const val LEGENDARY = "legendary"

+    /**
+     * Represents a Pokémon who is typically banned or has restricted usage in competitive sanctions.
+     * For example usage see this [VGC](https://www.pokemon.com/us/pokemon-news/trainers-can-once-again-use-a-restricted-pokemon-in-ranked-battles-series-10-starting-august-1-2021) page.
+     */
+    const val RESTRICTED = "restricted"
+
    /**
     * Represents a mythical Pokémon.
     * In Cobblemon terms they do not exist since we do not share the concept of timed event only Pokémon but the official ones are still tagged.
@@ -28,14 +34,21 @@ object CobblemonPokemonLabels {
    const val MYTHICAL = "mythical"

    /**
-     * Represents Pokémon that originate from Ultra Space.
+     * Represents Pokémon that receive a boosted catch rate from the Beast Ball. (Due to Beast Boost)
+     * Does not include [thematically related](https://bulbapedia.bulbagarden.net/wiki/Ultra_Beast#Related_Pok%C3%A9mon) beasts.
     */
    const val ULTRA_BEAST = "ultra_beast"

    /**
-     * Represents the pseudo legendary Pokémon.
+     * Represents a Pokémon whose family could be derived from resurrecting a fossil.
     */
-    const val PSEUDO_LEGENDARY = "pseudo_legendary"
+    const val FOSSIL = "fossil"
+
+    /**
+     * Represents the "pseudo-legendary" Pokémon. (Slow-rate three-stage lines with a base stat total of 600)
+     * Term reference on this [Pokémon Center](https://www.pokemoncenter.com/search/powerhouse) page.
+     */
+    const val POWERHOUSE = "powerhouse"

    /**
     * Represents a baby Pokémon, this is not just a first stage Pokémon species, it is also unable to breed.
@@ -52,52 +65,55 @@ object CobblemonPokemonLabels {
    /**
     * See [REGIONAL], this has no official regionals but it consists of the "base" form that comes from the region.
     */
-    const val REGIONAL_OF_KANTO = "kanto_regional"
+    const val KANTONIAN_FORM = "kantonian_form"
+
+    /**
+     * See [REGIONAL], this has no official regionals but it consists of the "base" form that comes from the region.
+     * Source for adjectival form: [Bulbapedia](https://bulbapedia.bulbagarden.net/wiki/Johto#Trivia)
+     */
+    const val JOHTONIAN_FORM = "johtonian_form"
+
+    /**
+     * See [REGIONAL], this has no official regionals but it consists of the "base" form that comes from the region.
+     * Source for adjectival form:[Bulbapedia](https://bulbapedia.bulbagarden.net/wiki/Hoenn#Trivia)
+     */
+    const val HOENNIAN_FORM = "hoennian_form"
+
+    /**
+     * See [REGIONAL], this has no official regionals but it consists of the "base" form that comes from the region.
+     * Source for adjectival form:[Bulbapedia](https://bulbapedia.bulbagarden.net/wiki/Sinnoh#Trivia)
+     */
+    const val SINNOHAN_FORM = "sinnohan_form"

    /**
     * See [REGIONAL], this has no official regionals but it consists of the "base" form that comes from the region.
     */
-    const val REGIONAL_OF_JOHTO = "johto_regional"
+    const val UNOVAN_FORM = "unovan_form"

    /**
     * See [REGIONAL], this has no official regionals but it consists of the "base" form that comes from the region.
     */
-    const val REGIONAL_OF_HOENN = "hoenn_regional"
-
-    /**
-     * See [REGIONAL], this has no official regionals but it consists of the "base" form that comes from the region.
-     */
-    const val REGIONAL_OF_SINNOH = "sinnoh_regional"
-
-    /**
-     * See [REGIONAL], this has no official regionals but it consists of the "base" form that comes from the region.
-     */
-    const val REGIONAL_OF_UNOVA = "unova_regional"
-
-    /**
-     * See [REGIONAL], this has no official regionals but it consists of the "base" form that comes from the region.
-     */
-    const val REGIONAL_OF_KALOS = "kalos_regional"
+    const val KALOSIAN_FORM = "kalosian_form"

    /**
     * See [REGIONAL] and this [Bulbapedia](https://bulbapedia.bulbagarden.net/wiki/Regional_form#Alolan_Form) page.
     */
-    const val REGIONAL_OF_ALOLA = "alola_regional"
+    const val ALOLAN_FORM = "alolan_form"

    /**
     * See [REGIONAL] and this [Bulbapedia](https://bulbapedia.bulbagarden.net/wiki/Regional_form#Galarian_Form) page.
     */
-    const val REGIONAL_OF_GALAR = "galar_regional"
+    const val GALARIAN_FORM = "galarian_form"

    /**
     * See [REGIONAL] and this [Bulbapedia](https://bulbapedia.bulbagarden.net/wiki/Regional_form#Hisuian_Form) page.
     */
-    const val REGIONAL_OF_HISUI = "hisui_regional"
+    const val HISUIAN_FORM = "hisuian_form"

    /**
     * See [REGIONAL] and this [Bulbapedia](https://bulbapedia.bulbagarden.net/wiki/Regional_form#Paldean_Form) page.
     */
-    const val REGIONAL_OF_PALDEA = "paldea_regional"
+    const val PALDEAN_FORM = "paldean_form"

    /**
     * Represents a mega evolution.
@@ -124,7 +140,7 @@ object CobblemonPokemonLabels {
    const val TOTEM = "totem"

    /**
-     * Represents a Paradox species.
+     * Represents Pokémon that trigger the Booster Energy item (due to Protosynthesis/Quark Drive)
     * For more information see the [Bulbapedia](https://bulbapedia.bulbagarden.net/wiki/Paradox_Pok%C3%A9mon) page.
     */
    const val PARADOX = "paradox"
@@ -171,12 +187,24 @@ object CobblemonPokemonLabels {
     */
    const val GENERATION_7 = "gen7"

+    /**
+     * The "official" designation for Pokémon from Gen 7 (Unknown) and not the Alola region
+     * This may also include forms of Pokémon that had been previously introduced
+     */
+    const val GENERATION_7B = "gen7b"
+
    /**
     * Pokémon from the national Pokédex of 810 to 905
     * This may also include forms of Pokémon that had been previously introduced
     */
    const val GENERATION_8 = "gen8"

+    /**
+     * The "official" designation for Pokémon from Gen 8 (Hisui) and not the Galar region
+     * This may also include forms of Pokémon that had been previously introduced
+     */
+    const val GENERATION_8A = "gen8a"
+
    /**
     * Pokémon from the national Pokédex from 906 to 1008
     * This may also include forms of Pokémon that had been previously introduced
@@ -53,7 +53,7 @@ enum class Stats(override val identifier: ResourceLocation, override val display
        fun getStat(statKey: String) = when(statKey.lowercase()) {
            "hp" -> HP
            "atk", "attack" -> ATTACK // Hyper Cutter states the full stat name "Attack"
-            "def", "defense" -> DEFENCE // Big Pecks states the full stat name "Defense"
+            "def", "defense", "defence" -> DEFENCE // Big Pecks states the full stat name "Defense"
            "spa" -> SPECIAL_ATTACK
            "spd" -> SPECIAL_DEFENCE
            "spe", "speed" -> SPEED
@@ -31,6 +31,7 @@ class BedrockParticleEmitter(
    var rate: ParticleEmitterRate = InstantParticleEmitterRate(),
    var shape: ParticleEmitterShape = SphereParticleEmitterShape(),
    var lifetime: ParticleEmitterLifetime = OnceEmitterLifetime(NumberExpression(1.0)),
+    var space: EmitterSpace = EmitterSpace(),
    var eventTimeline: EventTriggerTimeline = EventTriggerTimeline(mutableMapOf()),
    var creationEvents: MutableList<SimpleEventTrigger> = mutableListOf(),
    var expirationEvents: MutableList<SimpleEventTrigger> = mutableListOf(),
@@ -45,18 +46,20 @@ class BedrockParticleEmitter(
                ParticleEmitterRate.codec.fieldOf("rate").forGetter { it.rate },
                ParticleEmitterShape.codec.fieldOf("shape").forGetter { it.shape },
                ParticleEmitterLifetime.codec.fieldOf("lifetime").forGetter { it.lifetime },
+                EmitterSpace.CODEC.fieldOf("space").forGetter { it.space },
                EventTriggerTimeline.CODEC.fieldOf("eventTimeline").forGetter { it.eventTimeline },
                SimpleEventTrigger.CODEC.listOf().fieldOf("creationEvents").forGetter { it.creationEvents },
                SimpleEventTrigger.CODEC.listOf().fieldOf("expirationEvents").forGetter { it.expirationEvents },
                EventTriggerTimeline.CODEC.fieldOf("travelDistanceEvents").forGetter { it.travelDistanceEvents },
                LoopingTravelDistanceEventTrigger.CODEC.listOf().fieldOf("loopingTravelDistanceEvents").forGetter { it.loopingTravelDistanceEvents }
-            ).apply(instance) { startExpressions, updateExpressions, rate, shape, lifetime, eventTimeline, creationEvents, expirationEvents, travelDistanceEvents, loopingTravelDistanceEvents ->
+            ).apply(instance) { startExpressions, updateExpressions, rate, shape, lifetime, space, eventTimeline, creationEvents, expirationEvents, travelDistanceEvents, loopingTravelDistanceEvents ->
                BedrockParticleEmitter(
                    startExpressions = startExpressions,
                    updateExpressions = updateExpressions,
                    shape = shape,
                    rate = rate,
                    lifetime = lifetime,
+                    space = space,
                    eventTimeline = eventTimeline,
                    creationEvents = creationEvents,
                    expirationEvents = expirationEvents,
@@ -0,0 +1,61 @@
+/*
+ * 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.snowstorm
+
+import com.cobblemon.mod.common.api.data.ArbitrarilyMappedSerializableCompanion
+import com.cobblemon.mod.common.client.render.MatrixWrapper
+import com.cobblemon.mod.common.util.codec.CodecUtils
+import com.cobblemon.mod.common.util.codec.optionalFieldOfWithDefault
+import com.mojang.serialization.Codec
+import com.mojang.serialization.codecs.RecordCodecBuilder
+import org.joml.AxisAngle4f
+import org.joml.Matrix4f
+import org.joml.Vector3f
+
+class EmitterSpace(
+    var scaling: ScalingMode = ScalingMode.WORLD
+) {
+    companion object {
+        val CODEC: Codec<EmitterSpace> = RecordCodecBuilder.create { instance ->
+            instance.group(
+                Codec.STRING.optionalFieldOfWithDefault("scaling", "world").forGetter { it.scaling.toString() }
+            ).apply(instance) { scaling ->
+                EmitterSpace(
+                    ScalingMode.valueOf(scaling.uppercase())
+                )
+            }
+        }
+    }
+
+    fun initializeEmitterMatrix(rootMatrix: MatrixWrapper, locatorMatrix: MatrixWrapper): MatrixWrapper {
+        val rootRotation = rootMatrix.matrix.getRotation(AxisAngle4f())
+        val scale = Vector3f()
+
+        if (scaling == ScalingMode.ENTITY) {
+            locatorMatrix.matrix.getScale(scale)
+        }
+        else {
+            rootMatrix.matrix.getScale(scale)
+            //Incase they are multiplying some axis by -1 to rotate
+            scale.x = Math.signum(scale.x)
+            scale.y = Math.signum(scale.y)
+            scale.z = Math.signum(scale.z)
+        }
+
+        val particleScale = Vector3f(scale.x, scale.y, scale.z)
+        //Presumably we will want to make the initial rotation configurable instead of always using root
+        val particleRawMatrix = Matrix4f().scale(particleScale).rotate(rootRotation)
+        return MatrixWrapper().updateMatrix(particleRawMatrix).updatePosition(locatorMatrix.getOrigin())
+    }
+
+    enum class ScalingMode {
+        WORLD,
+        ENTITY
+    }
+}
@@ -26,6 +26,7 @@ import net.minecraft.resources.ResourceLocation
 import net.minecraft.sounds.SoundEvent
 import net.minecraft.sounds.SoundSource
 import net.minecraft.world.phys.Vec3
+import org.joml.Matrix4f

 /**
 * An event that can be referenced from various particle event triggers. The events are not necessarily particles,
@@ -77,9 +78,11 @@ class ParticleEvent(
    fun run(storm: ParticleStorm, particle: SnowstormParticle?) {
        particleEffect?.let { effect ->
            val bedrockParticleOptions = BedrockParticleOptionsRepository.getEffect(effect.effect) ?: return@let
-            val rootMatrix = when (effect.type) {
-                EventParticleOptions.EventParticleType.EMITTER-> MatrixWrapper().updatePosition(storm.matrixWrapper.position).updateMatrix(storm.matrixWrapper.matrix)
-                EventParticleOptions.EventParticleType.EMITTER_BOUND -> storm.matrixWrapper
+            val particleMatrix = when (effect.type) {
+                //It may seem incorrect to clone for both of these, but the locator matrix determines whether the
+                //emitter follows the locator. We don't want the child emitter to affect the parent emitter so we make a copy
+                EventParticleOptions.EventParticleType.EMITTER,
+                EventParticleOptions.EventParticleType.EMITTER_BOUND -> storm.emitterSpaceMatrix.clone()
                EventParticleOptions.EventParticleType.PARTICLE,
                EventParticleOptions.EventParticleType.PARTICLE_WITH_VELOCITY -> (particle?.let {
                    Vec3(
@@ -87,7 +90,19 @@ class ParticleEvent(
                        it.getY(),
                        it.getZ()
                    )
-                } ?: Vec3(storm.getX(), storm.getY(), storm.getZ())).let { MatrixWrapper().updatePosition(it) }
+                } ?: Vec3(storm.getX(), storm.getY(), storm.getZ())).let {
+                    val matrixWrapper = MatrixWrapper()
+                    matrixWrapper.updatePosition(it)
+                    //We only want the orientation of the original matrix, not position/translation
+                    matrixWrapper.updateMatrix(Matrix4f(storm.emitterSpaceMatrix.matrix).setTranslation(0F, 0F, 0F))
+                }
+            }
+
+            val locatorMatrix = when (effect.type) {
+                EventParticleOptions.EventParticleType.EMITTER -> particleMatrix
+                EventParticleOptions.EventParticleType.EMITTER_BOUND -> storm.locatorSpaceMatrix
+                EventParticleOptions.EventParticleType.PARTICLE,
+                EventParticleOptions.EventParticleType.PARTICLE_WITH_VELOCITY -> particleMatrix
            }

            val sourceVelocity = when (effect.type) {
@@ -105,17 +120,24 @@ class ParticleEvent(

            val newStorm = ParticleStorm(
                effect = bedrockParticleOptions,
-                matrixWrapper = rootMatrix,
+                emitterSpaceMatrix = particleMatrix,
+                locatorSpaceMatrix = locatorMatrix,
                world = storm.world,
                sourceVelocity = sourceVelocity,
                sourceAlive = storm.sourceAlive,
                sourceVisible = storm.sourceVisible,
                onDespawn = {},
-                runtime = MoLangRuntime().setup().also { it.environment.query = storm.runtime.environment.query },
+                targetPos = storm.targetPos,
+                runtime = MoLangRuntime().setup(),
                entity = storm.entity
            )
-
-            effect.expression?.resolve(newStorm.runtime)
+            //The reason this doesn't use the newStorms runtime is that the parent storm can add queries AFTER
+            //the child storm spawns in. Say a parent storm has a creation event. The child spawns before the parent
+            //When the parent tries to add its queries, it overwrites the child's
+            val tempRuntime = MoLangRuntime().setup().also {
+                it.environment.query = storm.runtime.environment.query
+            }
+            effect.expression?.resolve(tempRuntime)

            newStorm.spawn()
        }
@@ -77,16 +77,17 @@ class ParametricParticleMotion(

    override fun getInitialVelocity(runtime: MoLangRuntime, storm: ParticleStorm, particlePos: Vec3, emitterPos: Vec3) = Vec3.ZERO
    override fun getVelocity(runtime: MoLangRuntime, particle: SnowstormParticle, velocity: Vec3): Vec3 {
-        val stormPosition = Vec3(
-            particle.storm.getX(),
-            particle.storm.getY(),
-            particle.storm.getZ()
+        val particlePositionWS = Vec3(
+            particle.getX(),
+            particle.getY(),
+            particle.getZ()
        )
-        val offset = runtime.resolveVec3d(this.offset)
-        val particlePosition =
-            Vec3(particle.getX(), particle.getY(), particle.getZ())
-        val desiredPosition = stormPosition.add(offset)
-        return desiredPosition.subtract(particlePosition)
+        val matrix = particle.matrixWrapper
+
+        val targetPosPS = runtime.resolveVec3d(offset)
+        val targetPosWS = matrix.transformPosition(targetPosPS)
+
+        return targetPosWS.subtract(particlePositionWS)
    }

    override fun getParticleDirection(runtime: MoLangRuntime, storm: ParticleStorm, velocity: Vec3, minSpeed: Float) = runtime.resolveVec3d(direction).normalize()
@@ -277,7 +278,7 @@ class CustomMotionDirection(
            runtime.resolveDouble(direction.second),
            runtime.resolveDouble(direction.third)
        )
-        return storm.matrixWrapper.matrix.transformDirection(v)
+        return storm.emitterSpaceMatrix.matrix.transformDirection(v)
    }

    override fun <T> encode(ops: DynamicOps<T>) = CODEC.encodeStart(ops, this)
@@ -11,6 +11,7 @@ package com.cobblemon.mod.common.api.spawning.condition
 import com.cobblemon.mod.common.api.conditional.RegistryLikeCondition
 import com.cobblemon.mod.common.api.spawning.context.FishingSpawningContext
 import com.cobblemon.mod.common.util.itemRegistry
+import net.minecraft.resources.ResourceLocation
 import net.minecraft.world.item.Item
 import net.minecraft.world.item.enchantment.EnchantmentHelper
 import net.minecraft.world.item.enchantment.Enchantments
@@ -27,6 +28,10 @@ class FishingSpawningCondition: SpawningCondition<FishingSpawningContext>() {

    var rod: RegistryLikeCondition<Item>? = null
    var neededNearbyBlocks: MutableList<RegistryLikeCondition<Block>>? = null
+    var minLureLevel: Int? = null
+    var maxLureLevel: Int? = null
+    var bait: ResourceLocation? = null
+    var rodType: ResourceLocation? = null

    override fun fits(ctx: FishingSpawningContext): Boolean {
        if (!super.fits(ctx)) {
@@ -59,10 +59,6 @@ abstract class SpawningCondition<T : SpawningContext> {
    var isThundering: Boolean? = null
    var timeRange: TimeRange? = null
    var structures: MutableList<Either<ResourceLocation, TagKey<Structure>>>? = null
-    var minLureLevel: Int? = null
-    var maxLureLevel: Int? = null
-    var bait: ResourceLocation? = null
-    var rodType: ResourceLocation? = null
    var isSlimeChunk: Boolean? = null

    @Transient
@@ -10,15 +10,12 @@ package com.cobblemon.mod.common.api.spawning.fishing

 import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.Cobblemon.LOGGER
-import com.cobblemon.mod.common.api.Priority
-import com.cobblemon.mod.common.api.abilities.Abilities
 import com.cobblemon.mod.common.api.events.CobblemonEvents
 import com.cobblemon.mod.common.api.events.fishing.BobberSpawnPokemonEvent
 import com.cobblemon.mod.common.api.fishing.FishingBait
 import com.cobblemon.mod.common.api.pokemon.Natures
 import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
 import com.cobblemon.mod.common.api.pokemon.egg.EggGroup
-import com.cobblemon.mod.common.api.pokemon.stats.Stat
 import com.cobblemon.mod.common.api.pokemon.stats.Stats
 import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.SpawnCause
@@ -27,7 +24,6 @@ import com.cobblemon.mod.common.api.spawning.detail.PokemonSpawnDetail
 import com.cobblemon.mod.common.api.spawning.detail.SpawnDetail
 import com.cobblemon.mod.common.api.spawning.spawner.Spawner
 import com.cobblemon.mod.common.api.types.ElementalTypes
-import com.cobblemon.mod.common.api.types.tera.TeraTypes
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.item.interactive.PokerodItem
 import com.cobblemon.mod.common.pokemon.Gender
@@ -129,8 +125,8 @@ class FishingSpawnCause(
        }

        fun alterFriendshipAttempt(pokemonEntity: PokemonEntity, effect: FishingBait.Effect) {
-            if (pokemonEntity.pokemon.friendship + effect.value > 255)
-                pokemonEntity.pokemon.setFriendship(255)
+            if (pokemonEntity.pokemon.friendship + effect.value > Cobblemon.config.maxPokemonFriendship)
+                pokemonEntity.pokemon.setFriendship(Cobblemon.config.maxPokemonFriendship)
            else
                pokemonEntity.pokemon.setFriendship(pokemonEntity.pokemon.friendship + effect.value.toInt())
        }
@@ -8,12 +8,14 @@

 package com.cobblemon.mod.common.api.storage

+import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.CobblemonNetwork.sendPacket
 import com.cobblemon.mod.common.api.net.NetworkPacket
 import com.cobblemon.mod.common.api.reactive.Observable
 import com.cobblemon.mod.common.api.storage.factory.FileBackedPokemonStoreFactory
 import com.cobblemon.mod.common.api.storage.factory.PokemonStoreFactory
 import com.cobblemon.mod.common.pokemon.Pokemon
+import com.cobblemon.mod.common.util.DataKeys
 import com.google.gson.JsonObject
 import java.util.UUID
 import net.minecraft.core.RegistryAccess
@@ -147,10 +149,14 @@ abstract class PokemonStore<T : StorePosition> : Iterable<Pokemon> {

    operator fun get(uuid: UUID) = find { it.uuid == uuid }

-    open fun handleInvalidSpeciesNBT(nbt: CompoundTag) {}
+    open fun handleInvalidSpeciesNBT(nbt: CompoundTag) {
+        Cobblemon.LOGGER.error("Failed to read unknown species: ${nbt.getString(DataKeys.POKEMON_SPECIES_IDENTIFIER)}")
+    }
    abstract fun saveToNBT(nbt: CompoundTag, registryAccess: RegistryAccess): CompoundTag
    abstract fun loadFromNBT(nbt: CompoundTag, registryAccess: RegistryAccess): PokemonStore<T>
-    open fun handleInvalidSpeciesJSON(json: JsonObject) {}
+    open fun handleInvalidSpeciesJSON(json: JsonObject) {
+        Cobblemon.LOGGER.error("Failed to read unknown species: ${json.get(DataKeys.POKEMON_SPECIES_IDENTIFIER).asString}")
+    }
    abstract fun saveToJSON(json: JsonObject, registryAccess: RegistryAccess): JsonObject
    abstract fun loadFromJSON(json: JsonObject, registryAccess: RegistryAccess): PokemonStore<T>
    abstract fun savePositionToNBT(position: T, nbt: CompoundTag)
@@ -27,15 +27,15 @@ import net.minecraft.world.entity.player.Player
 * @since February 21, 2024
 */

-class PlayerInstancedDataStoreManager {
+open class PlayerInstancedDataStoreManager {
    val factories = mutableMapOf<PlayerInstancedDataStoreType, PlayerInstancedDataFactory<*>>()
    val saveTasks = mutableMapOf<PlayerInstancedDataStoreType, ScheduledTask>()
-    fun setFactory(factory: PlayerInstancedDataFactory<*>, dataType: PlayerInstancedDataStoreType) {
+    open fun setFactory(factory: PlayerInstancedDataFactory<*>, dataType: PlayerInstancedDataStoreType) {
        factories[dataType] = factory
    }


-    fun setup(server: MinecraftServer) {
+    open fun setup(server: MinecraftServer) {
        factories.values.forEach {
            it.setup(server)
        }
@@ -57,62 +57,62 @@ class PlayerInstancedDataStoreManager {
            .build()
    }

-    fun get(playerId: UUID, dataType: PlayerInstancedDataStoreType): InstancedPlayerData {
+    open fun get(playerId: UUID, dataType: PlayerInstancedDataStoreType): InstancedPlayerData {
        if (!factories.contains(dataType)) {
            throw UnsupportedOperationException("No factory registered for $dataType")
        }
        return factories[dataType]!!.getForPlayer(playerId)
    }

-    fun get(player: Player, dataType: PlayerInstancedDataStoreType): InstancedPlayerData {
+    open fun get(player: Player, dataType: PlayerInstancedDataStoreType): InstancedPlayerData {
        return get(player.uuid, dataType)
    }

-    fun saveAllOfOneType(dataType: PlayerInstancedDataStoreType) {
+    open fun saveAllOfOneType(dataType: PlayerInstancedDataStoreType) {
        if (!factories.contains(dataType)) {
            throw UnsupportedOperationException("No factory registered for $dataType")
        }
        return factories[dataType]!!.saveAll()
    }

-    fun saveSingle(playerData: InstancedPlayerData, dataType: PlayerInstancedDataStoreType) {
+    open fun saveSingle(playerData: InstancedPlayerData, dataType: PlayerInstancedDataStoreType) {
        if (!factories.contains(dataType)) {
            throw UnsupportedOperationException("No factory registered for $dataType")
        }
        return factories[dataType]!!.saveSingle(playerData.uuid)
    }

-    fun onPlayerDisconnect(player: ServerPlayer) {
+    open fun onPlayerDisconnect(player: ServerPlayer) {
        factories.values.forEach {
            it.onPlayerDisconnect(player)
        }
    }

-    fun syncAllToPlayer(player: ServerPlayer) {
+    open fun syncAllToPlayer(player: ServerPlayer) {
        factories.values.forEach {
            it.sendToPlayer(player)
        }
    }

-    fun saveAllStores() {
+    open fun saveAllStores() {
        factories.values.forEach {
            it.saveAll()
        }
    }

-    fun getGenericData(player: ServerPlayer): GeneralPlayerData {
+    open fun getGenericData(player: ServerPlayer): GeneralPlayerData {
        return getGenericData(player.uuid)
    }

-    fun getGenericData(playerId: UUID): GeneralPlayerData {
+    open fun getGenericData(playerId: UUID): GeneralPlayerData {
        return get(playerId, PlayerInstancedDataStoreTypes.GENERAL) as GeneralPlayerData
    }

-    fun getPokedexData(player: ServerPlayer): PokedexManager {
+    open fun getPokedexData(player: ServerPlayer): PokedexManager {
        return getPokedexData(player.uuid)
    }

-    fun getPokedexData(playerId: UUID): PokedexManager {
+    open fun getPokedexData(playerId: UUID): PokedexManager {
        return get(playerId, PlayerInstancedDataStoreTypes.POKEDEX) as PokedexManager
    }
 }
@@ -39,7 +39,7 @@ abstract class JsonBackedPlayerDataStoreBackend<T : InstancedPlayerData>(
    override fun load(uuid: UUID): T {
        val playerFile = filePath(uuid)
        playerFile.parentFile.mkdirs()
-        return if (playerFile.exists()) {
+        return if (playerFile.exists() && playerFile.length() > 0L) {
            gson.fromJson(BufferedReader(FileReader(playerFile)), classToken).also {
                // Resolves old data that's missing new properties
                val newProps = it::class.memberProperties.filterIsInstance<KMutableProperty<*>>().filter { member -> member.getter.call(it) == null }
@@ -37,11 +37,11 @@ abstract class NbtBackedPlayerData<T : InstancedPlayerData>(
    override fun load(uuid: UUID): T {
        val playerFile = filePath(uuid)
        playerFile.parentFile.mkdirs()
-        return if (playerFile.exists()) {
+        return if (playerFile.exists() && playerFile.length() > 0L) {
            val input = NbtIo.read(playerFile.toPath())
            val decodeResult = NbtOps.INSTANCE.withDecoder(codec).apply(input)
            decodeResult.getPartialOrThrow {
-                Cobblemon.LOGGER.error("Error decoding pokedex for player uuid ${uuid}")
+                Cobblemon.LOGGER.error("Error decoding $subfolder for player uuid $uuid")
                Cobblemon.LOGGER.error(it)
                throw UnsupportedOperationException()
            }.first
@@ -23,30 +23,72 @@ object CobblemonBlockTags {

    @JvmField val ALL_HANGING_SIGNS = createTag("all_hanging_signs")
    @JvmField val ALL_SIGNS = createTag("all_signs")
+    @JvmField val ANCIENT_CITY_BLOCKS = createTag("ancient_city_blocks")
    @JvmField val APRICORN_LEAVES = createTag("apricorn_leaves")
    @JvmField val APRICORN_LOGS = createTag("apricorn_logs")
    @JvmField val APRICORN_SAPLINGS = createTag("apricorn_saplings")
    @JvmField val APRICORNS = createTag("apricorns")
-    @JvmField val BERRY_WILD_SOIL = createTag("berry_wild_soil")
-    @JvmField val BERRY_SOIL = createTag("berry_soil")
+    @JvmField val BERRIES = createTag("berries")
    @JvmField val BERRY_REPLACEABLE = createTag("berry_replaceable")
+    @JvmField val BERRY_SOIL = createTag("berry_soil")
+    @JvmField val BERRY_WILD_SOIL = createTag("berry_wild_soil")
+    @JvmField val BLACK_TUMBLESTONE_BRICKS = createTag("black_tumblestone_bricks")
+    @JvmField val BLACK_TUMBLESTONES = createTag("black_tumblestones")
+    @JvmField val BLUE_FLOWERS = createTag("blue_flowers")
    @JvmField val CEILING_HANGING_SIGNS = createTag("ceiling_hanging_signs")
    @JvmField val CROPS = createTag("crops")
+    @JvmField val DAWN_STONE_ORES = createTag("dawn_stone_ores")
+    @JvmField val DESERT_PYRAMID_BLOCKS = createTag("desert_pyramid_blocks")
    @JvmField val DRIPSTONE_GROWABLE = createTag("dripstone_growable")
    @JvmField val DRIPSTONE_REPLACEABLES = createTag("dripstone_replaceables")
+    @JvmField val DUSK_STONE_ORES = createTag("dusk_stone_ores")
+    @JvmField val END_CITY_BLOCKS = createTag("end_city_blocks")
+    @JvmField val EVOLUTION_STONE_BLOCKS = createTag("evolution_stone_blocks")
+    @JvmField val FIRE_STONE_ORES = createTag("fire_stone_ores")
    @JvmField val FLOWERS = createTag("flowers")
+    @JvmField val FOSSIL_MACHINE_PARTS = createTag("fossil_machine_parts")
+    @JvmField val GEMSTONES = createTag("gemstones")
+    @JvmField val GILDED_CHESTS = createTag("gilded_chests")
+    @JvmField val GLAZED_TERRACOTTA_BLOCKS = createTag("glazed_terracotta_blocks")
+    @JvmField val ICE_STONE_ORES = createTag("ice_stone_ores")
+    @JvmField val JUNGLE_PYRAMID_BLOCKS = createTag("jungle_pyramid_blocks")
+    @JvmField val LEAF_STONE_ORES = createTag("leaf_stone_ores")
+    @JvmField val MACHINES = createTag("machines")
+    @JvmField val MANSION_BLOCKS = createTag("mansion_blocks")
    @JvmField val MEDICINAL_LEEK_PLANTABLE = createTag("medicinal_leek_plantable")
    @JvmField val MINTS = createTag("mints")
-    @JvmField val ROOTS_SPREADABLE = createTag("roots_spreadable")
-    @JvmField val SIGNS = createTag("signs")
-    @JvmField val SMALL_FLOWERS = createTag("small_flowers")
-    @JvmField val SEES_SKY = createTag("sees_sky")
-    @JvmField val SNOW_BLOCK = createTag("snow_block")
+    @JvmField val MOON_STONE_ORES = createTag("moon_stone_ores")
+    @JvmField val NATURAL = createTag("natural")
+    @JvmField val NETHER_STRUCTURE_BLOCKS = createTag("nether_structure_blocks")
+    @JvmField val PINK_FLOWERS = createTag("pink_flowers")
+    @JvmField val RED_FLOWERS = createTag("red_flowers")
+    @JvmField val RED_TUMBLESTONE_BRICKS = createTag("red_tumblestone_bricks")
+    @JvmField val RED_TUMBLESTONES = createTag("red_tumblestones")
+    @JvmField val REDSTONE_BLOCKS = createTag("redstone_blocks")
    @JvmField val ROOTS = createTag("roots")
+    @JvmField val ROOTS_SPREADABLE = createTag("roots_spreadable")
+    @JvmField val RUINED_PORTAL_BLOCKS = createTag("ruined_portal_blocks")
+    @JvmField val SEES_SKY = createTag("sees_sky")
+    @JvmField val SHINY_STONE_ORES = createTag("shiny_stone_ores")
+    @JvmField val SIGNS = createTag("signs")
+    @JvmField val SKY_TUMBLESTONE_BRICKS = createTag("sky_tumblestone_bricks")
+    @JvmField val SKY_TUMBLESTONES = createTag("sky_tumblestones")
+    @JvmField val SMALL_FLOWERS = createTag("small_flowers")
+    @JvmField val SNOW_BLOCK = createTag("snow_block")
    @JvmField val STANDING_SIGNS = createTag("standing_signs")
+    @JvmField val SUN_STONE_ORES = createTag("sun_stone_ores")
+    @JvmField val THUNDER_STONE_ORES = createTag("thunder_stone_ores")
+    @JvmField val TRAIL_RUINS_BLOCKS = createTag("trail_ruins_blocks")
+    @JvmField val TRASH = createTag("trash")
+    @JvmField val TREES = createTag("trees")
+    @JvmField val TUMBLESTONE_BRICKS = createTag("tumblestone_bricks")
+    @JvmField val TUMBLESTONES = createTag("tumblestones")
    @JvmField val TUMBLESTONE_HEAT_SOURCE = createTag("tumblestone_heat_source")
    @JvmField val WALL_HANGING_SIGNS = createTag("wall_hanging_signs")
    @JvmField val WALL_SIGNS = createTag("wall_signs")
+    @JvmField val WATER_STONE_ORES = createTag("water_stone_ores")
+    @JvmField val WHITE_FLOWERS = createTag("white_flowers")
+    @JvmField val YELLOW_FLOWERS = createTag("yellow_flowers")

    private fun createTag(name: String) = TagKey.create(Registries.BLOCK, cobblemonResource(name))

@@ -21,137 +21,108 @@ import net.minecraft.tags.TagKey
 */
@Suppress("unused", "HasPlatformType")
 object CobblemonItemTags {
-    @JvmField
-    val ANCIENT_POKE_BALLS = create("ancient_poke_balls")
-    @JvmField
-    val APRICORN_LOGS = create("apricorn_logs")
-    @JvmField
-    val APRICORN_SPROUTS = create("apricorn_sprouts")
-    @JvmField
-    val APRICORNS = create("apricorns")
-    @JvmField
-    val POKEDEX = create("pokedex")
-    /**
-     * This tag is only used for a Torterra aspect based easter egg evolution at the moment.
-     * It simply includes the 'minecraft:azalea' and 'minecraft:flowering_azalea' items by default.
-     */
-    @JvmField
-    val AZALEA_TREE = create("azalea_tree")
-    @JvmField
-    val BERRIES = create("berries")
-    @JvmField
-    val BOATS = create("boats")
-    @JvmField
-    val COBBLEMON_SEEDS = create("cobblemon_seeds")
-    /**
-     * This tag is used for Fossil Machine natural materials
-     */
-    @JvmField
-    val COOKED_MEAT = create("cooked_meat")
-    @JvmField
-    val DAWN_STONE_ORES = create("dawn_stone_ores")
-    @JvmField
-    val DUSK_STONE_ORES = create("dusk_stone_ores")
-    @JvmField
-    val EVOLUTION_ITEMS = create("evolution_items")
-    @JvmField
-    val EVOLUTION_STONES = create("evolution_stones")
-    @JvmField
-    val EXPERIENCE_CANDIES = create("experience_candies")
-    @JvmField
-    val FIRE_STONE_ORES = create("fire_stone_ores")
-    @JvmField
-    val FOSSILS = create("fossils")
-    @JvmField
-    val HANGING_SIGNS = create("hanging_signs")
-    @JvmField
-    val HERBS = create("herbs")
-    @JvmField
-    val ICE_STONE_ORES = create("ice_stone_ores")
-    @JvmField
-    val LEAF_STONE_ORES = create("leaf_stone_ores")
-    @JvmField
-    val MINT_LEAF = create("mint_leaf")
-    @JvmField
-    val MINT_SEEDS = create("mint_seeds")
-    @JvmField
-    val MINTS = create("mints")
-    @JvmField
-    val MOON_STONE_ORES = create("moon_stone_ores")
-    @JvmField
-    val MUTATED_BERRIES = create("mutated_berries")
-    @JvmField
-    val PLANTS = create("plants")
-    @JvmField
-    val POKE_BALLS = create("poke_balls")
-    @JvmField
-    val PROTEIN_INGREDIENTS = create("protein_ingredients")
+    @JvmField val ABILITY_CHANGERS = create("ability_changers")
+    @JvmField val ANCIENT_POKE_BALLS = create("ancient_poke_balls")
+    @JvmField val APPLES = create("apples")
+    @JvmField val APRICORN_LOGS = create("apricorn_logs")
+    @JvmField val APRICORN_POKE_BALLS = create("apricorn_poke_balls")
+    @JvmField val APRICORN_SPROUTS = create("apricorn_sprouts")
+    @JvmField val APRICORNS = create("apricorns")
+    /** This tag is only used for a Torterra aspect based easter egg evolution at the moment.
+     * It simply includes the 'minecraft:azalea' and 'minecraft:flowering_azalea' items by default. */
+    @JvmField val AZALEA_TREE = create("azalea_tree")
+    @JvmField val BATTLE_ITEMS = create("battle_items")
+    @JvmField val BERRIES = create("berries")
+    @JvmField val BLACK_TUMBLESTONE_BRICKS = create("black_tumblestone_bricks")
+    @JvmField val BLACK_TUMBLESTONES = create("black_tumblestones")
+    @JvmField val BOATS = create("boats")
+    /** This tag is used for Fossil Machine natural materials */
+    @JvmField val COOKED_MEAT = create("cooked_meat")
+    @JvmField val DAWN_STONE_ORES = create("dawn_stone_ores")
+    @JvmField val POTTERY_SHERDS = create("decorated_pot_sherds")
+    @JvmField val DEEP_SEAS = create("deep_seas")
+    @JvmField val DUSK_STONE_ORES = create("dusk_stone_ores")
+    @JvmField val ETHERS = create("ethers")
+    @JvmField val EVOLUTION_ITEMS = create("evolution_items")
+    @JvmField val EVOLUTION_STONE_BLOCKS = create("evolution_stone_blocks")
+    @JvmField val EVOLUTION_STONES = create("evolution_stones")
+    @JvmField val EXPERIENCE_CANDIES = create("experience_candies")
+    @JvmField val FEATHERS = create("feathers")
+    @JvmField val FIRE_STONE_ORES = create("fire_stone_ores")
+    @JvmField val FOSSIL_MACHINE_PARTS = create("fossil_machine_parts")
+    @JvmField val FOSSILS = create("fossils")
+    @JvmField val GILDED_CHESTS = create("gilded_chests")
+    @JvmField val HANGING_SIGNS = create("hanging_signs")
+    @JvmField val HERBS = create("herbs")
+    @JvmField val ICE_STONE_ORES = create("ice_stone_ores")
+    @JvmField val LEAF_STONE_ORES = create("leaf_stone_ores")
+    @JvmField val MACHINES = create("machines")
+    @JvmField val MINT_LEAF = create("mint_leaf")
+    @JvmField val MINT_SEEDS = create("mint_seeds")
+    @JvmField val MINTS = create("mints")
+    @JvmField val MOON_STONE_ORES = create("moon_stone_ores")
+    @JvmField val MUTATED_BERRIES = create("mutated_berries")
+    @JvmField val PLANTS = create("plants")
+    @JvmField val POKE_BALLS = create("poke_balls")
+    @JvmField val POKE_RODS = create("poke_rods")
+    @JvmField val POKEDEX = create("pokedex")
+    @JvmField val POKEDEX_SCREEN = create("pokedex_screen")
+    @JvmField val POTIONS = create("potions")
+    @JvmField val PROTEIN_INGREDIENTS = create("protein_ingredients")
    /** See [COOKED_MEAT] */
-    @JvmField
-    val RAW_MEAT = create("raw_meat")
-    @JvmField
-    val SEEDS = create("seeds")
-    @JvmField
-    val SHINY_STONE_ORES = create("shiny_stone_ores")
-    @JvmField
-    val SIGNS = create("signs")
-    @JvmField
-    val SUN_STONE_ORES = create("sun_stone_ores")
-    @JvmField
-    val THUNDER_STONE_ORES = create("thunder_stone_ores")
-    @JvmField
-    val TUMBLESTONES = create("tumblestones")
-    @JvmField
-    val WATER_STONE_ORES = create("water_stone_ores")
-    @JvmField
-    val ZINC_INGREDIENTS = create("zinc_ingredients")
+    @JvmField val RAW_MEAT = create("raw_meat")
+    @JvmField val RED_TUMBLESTONE_BRICKS = create("red_tumblestone_bricks")
+    @JvmField val RED_TUMBLESTONES = create("red_tumblestones")
+    @JvmField val REMEDIES = create("remedies")
+    @JvmField val RESTORES = create("restores")
+    @JvmField val REVIVES = create("revives")
+    @JvmField val SEEDS = create("seeds")
+    @JvmField val SHINY_STONE_ORES = create("shiny_stone_ores")
+    @JvmField val SIGNS = create("signs")
+    @JvmField val SKY_TUMBLESTONE_BRICKS = create("sky_tumblestone_bricks")
+    @JvmField val SKY_TUMBLESTONES = create("sky_tumblestones")
+    @JvmField val SUN_STONE_ORES = create("sun_stone_ores")
+    @JvmField val SWEETS = create("sweets")
+    @JvmField val TEACUPS = create("teacups")
+    @JvmField val TEAPOTS = create("teapots")
+    @JvmField val THUNDER_STONE_ORES = create("thunder_stone_ores")
+    @JvmField val TIER_1_POKE_BALL_MATERIALS = create("tier_1_poke_ball_materials")
+    @JvmField val TIER_1_POKE_BALLS = create("tier_1_poke_balls")
+    @JvmField val TIER_2_POKE_BALL_MATERIALS = create("tier_2_poke_ball_materials")
+    @JvmField val TIER_2_POKE_BALLS = create("tier_2_poke_balls")
+    @JvmField val TIER_3_POKE_BALL_MATERIALS = create("tier_3_poke_ball_materials")
+    @JvmField val TIER_3_POKE_BALLS = create("tier_3_poke_balls")
+    @JvmField val TIER_4_POKE_BALL_MATERIALS = create("tier_4_poke_ball_materials")
+    @JvmField val TIER_4_POKE_BALLS = create("tier_4_poke_balls")
+    @JvmField val TIER_5_POKE_BALLS = create("tier_5_poke_balls")
+    @JvmField val TUMBLESTONE_BRICKS = create("tumblestone_bricks")
+    @JvmField val TUMBLESTONES = create("tumblestones")
+    @JvmField val TYPE_GEMS = create("type_gems")
+    @JvmField val VITAMINS = create("vitamins")
+    @JvmField val WATER_STONE_ORES = create("water_stone_ores")
+    @JvmField val ZINC_INGREDIENTS = create("zinc_ingredients")

    // Held Item Tags
-    @JvmField
-    val ANY_HELD_ITEM = create("held/is_held_item")
-    @JvmField
-    val EXPERIENCE_SHARE = create("held/experience_share")
-    @JvmField
-    val LUCKY_EGG = create("held/lucky_egg")
-    @JvmField
-    val DESTINY_KNOT = create("held/destiny_knot")
-    @JvmField
-    val EVERSTONE = create("held/everstone")
-    @JvmField
-    val POWER_ANKLET = create("held/power_anklet")
-    @JvmField
-    val POWER_BAND = create("held/power_band")
-    @JvmField
-    val POWER_BELT = create("held/power_belt")
-    @JvmField
-    val POWER_BRACER = create("held/power_bracer")
-    @JvmField
-    val POWER_LENS = create("held/power_lens")
-    @JvmField
-    val POWER_WEIGHT = create("held/power_weight")
-    @JvmField
-    val CONSUMED_IN_NPC_BATTLE = create("held/consumed_in_npc_battle")
-    @JvmField
-    val CONSUMED_IN_PVP_BATTLE = create("held/consumed_in_pvp_battle")
-    @JvmField
-    val CONSUMED_IN_WILD_BATTLE = create("held/consumed_in_wild_battle")
-    @JvmField
-    val TERRAIN_SEEDS = create("held/terrain_seeds")
+    @JvmField val CONSUMED_IN_NPC_BATTLE = create("held/consumed_in_npc_battle")
+    @JvmField val CONSUMED_IN_PVP_BATTLE = create("held/consumed_in_pvp_battle")
+    @JvmField val CONSUMED_IN_WILD_BATTLE = create("held/consumed_in_wild_battle")
+    @JvmField val DESTINY_KNOT = create("held/destiny_knot")
+    @JvmField val EVERSTONE = create("held/everstone")
+    @JvmField val EXPERIENCE_SHARE = create("held/experience_share")
+    @JvmField val IS_FRIENDSHIP_BOOSTER = create("is_friendship_booster")
+    @JvmField val ANY_HELD_ITEM = create("held/is_held_item")
+    /** Tag that flags items as being able to "create" [CobblemonItems.LEFTOVERS]. */
+    @JvmField val LEAVES_LEFTOVERS = create("held/leaves_leftovers")
+    @JvmField val LUCKY_EGG = create("held/lucky_egg")
+    @JvmField val POWER_ANKLET = create("held/power_anklet")
+    @JvmField val POWER_BAND = create("held/power_band")
+    @JvmField val POWER_BELT = create("held/power_belt")
+    @JvmField val POWER_BRACER = create("held/power_bracer")
+    @JvmField val POWER_LENS = create("held/power_lens")
+    @JvmField val POWER_WEIGHT = create("held/power_weight")
+    @JvmField val TERRAIN_SEEDS = create("held/terrain_seeds")

-    /**
-     * Tag that flags items as being able to "create" [CobblemonItems.LEFTOVERS].
-     */
-    @JvmField
-    val LEAVES_LEFTOVERS = create("held/leaves_leftovers")

-    @JvmField
-    val POTTERY_SHERDS = create("decorated_pot_sherds")
-
-    @JvmField
-    val ABILITY_CHANGERS = create("ability_changers")
-
-    @JvmField
-    val IS_FRIENDSHIP_BOOSTER = create("is_friendship_booster")

    private fun create(path: String) = TagKey.create(Registries.ITEM, cobblemonResource(path))

@@ -27,7 +27,7 @@ import net.minecraft.world.phys.Vec3
 import java.util.*

 /**
- * Responsible for managing [BattleChallenge]s and initiating PVP [PokemonBattle]s.
+ * Responsible for managing [BattleChallenge]s and initiating PVP [com.cobblemon.mod.common.api.battles.model.PokemonBattle]s.
 *
 * @author Segfault Guy, JazzMcNade
 * @since October 28th, 2024
@@ -122,7 +122,7 @@ object ChallengeManager : RequestManager<ChallengeManager.BattleChallenge>() {
        }
    }

-    override fun isValidInteraction(player: ServerPlayer, target: ServerPlayer) = player.canInteractWith(target, Cobblemon.config.BattlePvPMaxDistance)
+    override fun isValidInteraction(player: ServerPlayer, target: ServerPlayer) = player.canInteractWith(target, Cobblemon.config.battlePvPMaxDistance)

    override fun canAccept(request: BattleChallenge): Boolean {
        if (request is MultiBattleChallenge) {
@@ -132,7 +132,7 @@ object ChallengeManager : RequestManager<ChallengeManager.BattleChallenge>() {
            if (existingReceiverTeam == null || existingSenderTeam == null) {
                request.notifySender(true, "error.missing_team")
                request.notifyReceiver(true, "error.missing_team")
-                return false;
+                return false
            }

            val players = existingReceiverTeam.teamPlayers + existingSenderTeam.teamPlayers
@@ -54,7 +54,7 @@ object ShowdownInterpreter {
        }

        listOf(
-            "player", "teamsize", "gametype", "gen", "tier", "rated", "clearpoke", "poke", "teampreview", "start", "rule", "t:", "", "capture"
+            "player", "teamsize", "gametype", "gen", "tier", "rated", "clearpoke", "poke", "teampreview", "start", "rule", "t:", "", "capture", "-anim"
        ).forEach { updateInstructionParser[it] = { _, _, _, _ -> IgnoredInstruction() } }

        updateInstructionParser["-ability"]              = { _, instructionSet, message, _ -> AbilityInstruction(instructionSet, message) }
@@ -63,7 +63,8 @@ class ActivateInstruction(val instructionSet: InstructionSet, val message: Battl
            val context = ActionEffectContext(
                actionEffect = actionEffect,
                runtime = runtime,
-                providers = providers
+                providers = providers,
+                level = battle.players.firstOrNull()?.level()
            )
            this.future = actionEffect.run(context)
            holds = context.holds // Reference so future things can check on this action effect's holds
@@ -56,7 +56,8 @@ class BoostInstruction(battle: PokemonBattle, val message: BattleMessage, val is
            val context = ActionEffectContext(
                actionEffect = actionEffect,
                runtime = runtime,
-                providers = providers
+                providers = providers,
+                level = battle.players.firstOrNull()?.level()
            )
            this.future = actionEffect.run(context)
            holds = context.holds // Reference so future things can check on this action effect's holds
@@ -52,7 +52,8 @@ class CantInstruction(val message: BattleMessage): ActionEffectInstruction {
            val context = ActionEffectContext(
                actionEffect = actionEffect,
                runtime = runtime,
-                providers = providers
+                providers = providers,
+                level = battle.players.firstOrNull()?.level()
            )
            this.future = actionEffect.run(context)
            holds = context.holds // Reference so future things can check on this action effect's holds
@@ -114,7 +114,8 @@ class DamageInstruction(
            val context = ActionEffectContext(
                actionEffect = actionEffect,
                runtime = runtime,
-                providers = providers
+                providers = providers,
+                level = battle.players.firstOrNull()?.level()
            )
            this.future = actionEffect.run(context)
            holds = context.holds // Reference so future things can check on this action effect's holds
@@ -10,6 +10,8 @@ package com.cobblemon.mod.common.battles.interpreter.instructions

 import com.cobblemon.mod.common.api.battles.interpreter.BattleMessage
 import com.cobblemon.mod.common.api.battles.model.PokemonBattle
+import com.cobblemon.mod.common.api.events.CobblemonEvents
+import com.cobblemon.mod.common.api.events.battles.instruction.FormeChangeEvent
 import com.cobblemon.mod.common.battles.ShowdownInterpreter
 import com.cobblemon.mod.common.battles.dispatch.InterpreterInstruction
 import com.cobblemon.mod.common.util.battleLang
@@ -35,6 +37,7 @@ class FormeChangeInstruction(val message: BattleMessage): InterpreterInstruction
        battle.dispatchWaiting {
            battle.minorBattleActions[battlePokemon.uuid] = message

+            CobblemonEvents.FORME_CHANGE.post(FormeChangeEvent(battle, battlePokemon, formName))
            val pokemonName = battlePokemon.getName()
            val lang = when(formName) {
                "busted", "hero", "complete" -> return@dispatchWaiting
@@ -102,7 +102,8 @@ class MoveInstruction(
            val context = ActionEffectContext(
                actionEffect = actionEffect,
                runtime = runtime,
-                providers = providers
+                providers = providers,
+                level = battle.players.firstOrNull()?.level()
            )

            val subsequentInstructions = instructionSet.findInstructionsCausedBy(this)
@@ -13,6 +13,8 @@ import com.cobblemon.mod.common.api.battles.interpreter.BattleMessage
 import com.cobblemon.mod.common.api.battles.model.PokemonBattle
 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.events.CobblemonEvents
+import com.cobblemon.mod.common.api.events.pokemon.PokemonSeenEvent
 import com.cobblemon.mod.common.api.scheduling.afterOnServer
 import com.cobblemon.mod.common.battles.ActiveBattlePokemon
 import com.cobblemon.mod.common.battles.ShowdownInterpreter
@@ -213,7 +215,12 @@ class SwitchInstruction(val instructionSet: InstructionSet, val battleActor: Bat
                battleLang("switch.other.nickname", actor.getName(), nickname, publicPokemon.species.translatedName)
            } ?: battleLang("switch.other", actor.getName(), publicPokemon.getDisplayName())
            actor.sendMessage(battleLang("switch.self", publicPokemon.getDisplayName()))
-            battle.actors.filter { it != actor }.forEach { it.sendMessage(publicLang) }
+            battle.actors.filter { it != actor }.forEach {
+                it.sendMessage(publicLang)
+            }
+            battle.playerUUIDs.forEach { uuid ->
+                CobblemonEvents.POKEMON_SEEN.post(PokemonSeenEvent(uuid, publicPokemon))
+            }
        }
    }

@@ -13,7 +13,6 @@ import com.cobblemon.mod.common.api.battles.model.PokemonBattle
 import com.cobblemon.mod.common.api.battles.model.actor.ActorType
 import com.cobblemon.mod.common.api.events.CobblemonEvents
 import com.cobblemon.mod.common.api.events.battles.BattleVictoryEvent
-import com.cobblemon.mod.common.api.events.pokemon.PokemonSeenEvent
 import com.cobblemon.mod.common.api.text.gold
 import com.cobblemon.mod.common.api.text.plus
 import com.cobblemon.mod.common.api.text.red
@@ -70,11 +69,6 @@ class WinInstruction(val message: BattleMessage): InterpreterInstruction {
        }
        battle.dispatchGo {
            battle.end()
-            battle.actors.flatMap { it.pokemonList }.map { it.originalPokemon }.forEach { pokemon ->
-                battle.playerUUIDs.forEach { playerUuid ->
-                    CobblemonEvents.POKEMON_SEEN.post(PokemonSeenEvent(playerUuid, pokemon))
-                }
-            }
            CobblemonEvents.BATTLE_VICTORY.post(BattleVictoryEvent(battle, winners, losers, wasCaught))
            ShowdownInterpreter.lastCauser.remove(battle.battleId)
        }
@@ -8,7 +8,11 @@

 package com.cobblemon.mod.common.battles.pokemon

+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.battles.model.actor.BattleActor
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asStruct
 import com.cobblemon.mod.common.api.moves.MoveSet
 import com.cobblemon.mod.common.api.pokemon.helditem.HeldItemManager
 import com.cobblemon.mod.common.api.pokemon.helditem.HeldItemProvider
@@ -24,8 +28,10 @@ import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.pokemon.properties.BattleCloneProperty
 import com.cobblemon.mod.common.pokemon.properties.UncatchableProperty
 import com.cobblemon.mod.common.util.battleLang
+import com.cobblemon.mod.common.util.server
 import java.util.UUID
 import net.minecraft.network.chat.MutableComponent
+import java.util.function.Function

 open class BattlePokemon(
    val originalPokemon: Pokemon,
@@ -33,9 +39,11 @@ open class BattlePokemon(
    val postBattleEntityOperation: (PokemonEntity) -> Unit = {}
 ) {
    lateinit var actor: BattleActor
+
    companion object {
        fun safeCopyOf(pokemon: Pokemon): BattlePokemon {
-            val effectedPokemon = pokemon.clone()
+            //TOOD figure out a closer registry access (might have to break some method signatures for this (1.7?)
+            val effectedPokemon = pokemon.clone(registryAccess = server()?.registryAccess() ?: throw IllegalStateException("No registry access available"))
            BattleCloneProperty.isBattleClone().apply(effectedPokemon)
            UncatchableProperty.uncatchable().apply(effectedPokemon)
            return BattlePokemon(
@@ -54,6 +62,22 @@ open class BattlePokemon(
        )
    }

+    val struct = QueryStruct(
+        hashMapOf(
+            "pokemon" to Function { effectedPokemon.asStruct() },
+            "original_pokemon" to Function {
+                originalPokemon.asStruct()
+            },
+            "actor" to Function { actor.struct },
+            "battle" to Function { actor.battle.struct },
+            "uuid" to Function { StringValue(uuid.toString()) },
+            "health" to Function { DoubleValue(health.toDouble()) },
+            "max_health" to Function { DoubleValue(maxHealth.toDouble()) },
+            "ivs" to Function { effectedPokemon.ivs.struct },
+            "nature" to Function { StringValue(effectedPokemon.nature.name.toString()) },
+            "moveset" to Function { effectedPokemon.moveSet.toStruct() }
+        ))
+
    val uuid: UUID
        get() = effectedPokemon.uuid
    val health: Int
@@ -82,7 +106,7 @@ open class BattlePokemon(
     * The [HeldItemManager] backing this [BattlePokemon].
     */
    val heldItemManager: HeldItemManager by lazy { HeldItemProvider.provide(this) }
-    
+
    val contextManager = ContextManager()

    open fun getName(): MutableComponent {
@@ -100,11 +124,11 @@ open class BattlePokemon(

    fun isSentOut() = actor.battle.activePokemon.any { it.battlePokemon == this }
    fun canBeSentOut() =
-            if (actor.request?.side?.pokemon?.any{ it.reviving } == true) {
-                !isSentOut() && !willBeSwitchedIn && health <= 0
-            } else {
-                !isSentOut() && !willBeSwitchedIn && health > 0
-            }
+        if (actor.request?.side?.pokemon?.any { it.reviving } == true) {
+            !isSentOut() && !willBeSwitchedIn && health <= 0
+        } else {
+            !isSentOut() && !willBeSwitchedIn && health > 0
+        }

    fun getIllusion(): BattlePokemon? = this.actor.activePokemon.find { it.battlePokemon == this }?.illusion
 }
@@ -26,6 +26,7 @@ import net.minecraft.core.BlockPos
 import net.minecraft.core.Direction
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerLevel
+import net.minecraft.sounds.SoundEvents
 import net.minecraft.sounds.SoundSource
 import net.minecraft.util.RandomSource
 import net.minecraft.world.InteractionHand
@@ -54,7 +55,7 @@ import net.minecraft.world.phys.shapes.CollisionContext
 import net.minecraft.world.phys.shapes.Shapes
 import net.minecraft.world.phys.shapes.VoxelShape

-class BerryBlock(private val berryIdentifier: ResourceLocation, settings: Properties) : BaseEntityBlock(settings), BonemealableBlock, Mulchable {
+class BerryBlock(private val berryIdentifier: ResourceLocation, settings: Properties) : BaseEntityBlock(settings), BonemealableBlock, Mulchable, ShearableBlock {

    private val lookupDirections = setOf(Direction.NORTH, Direction.EAST, Direction.WEST, Direction.SOUTH)

@@ -186,12 +187,11 @@ class BerryBlock(private val berryIdentifier: ResourceLocation, settings: Proper
        if (player.getItemInHand(InteractionHand.MAIN_HAND).`is`(Items.BONE_MEAL) && !this.isMaxAge(state)) {
            return InteractionResult.PASS
        } else if (this.isMaxAge(state)) {
-            val blockEntity = world.getBlockEntity(pos) as? BerryBlockEntity ?: return InteractionResult.PASS
-            blockEntity.harvest(world, state, pos, player).forEach { drop ->
-                Block.popResource(world, pos, drop)
+            return if (harvestBerry(world, state, pos, player)) {
+                InteractionResult.sidedSuccess(world.isClientSide)
+            } else {
+                InteractionResult.PASS
            }
-            world.playSound(null, pos, CobblemonSounds.BERRY_HARVEST, SoundSource.BLOCKS, 0.4F, 1F)
-            return InteractionResult.sidedSuccess(world.isClientSide)
        }
        return super.useWithoutItem(state, world, pos, player, blockHitResult)
    }
@@ -334,4 +334,24 @@ class BerryBlock(private val berryIdentifier: ResourceLocation, settings: Proper
            }
        }
    }
+
+    override fun attemptShear(world: Level, state: BlockState, pos: BlockPos, successCallback: () -> Unit): Boolean {
+        return if (this.isMaxAge(state)) {
+            harvestBerry(world, state, pos)
+        } else {
+            false
+        }
+    }
+
+    private fun harvestBerry(world: Level, state: BlockState, pos: BlockPos, player: Player? = null): Boolean {
+        val blockEntity = world.getBlockEntity(pos) as? BerryBlockEntity ?: return false
+        blockEntity.harvest(world, state, pos, player).forEach { drop ->
+            Block.popResource(world, pos, drop)
+        }
+
+        val sound = if (player != null) CobblemonSounds.BERRY_HARVEST else SoundEvents.SHEEP_SHEAR
+        world.playSound(null, pos, sound, SoundSource.BLOCKS, 1F, 1F)
+
+        return true
+    }
 }
@@ -94,12 +94,18 @@ class DisplayCaseBlock(settings: Properties) : BaseEntityBlock(settings) {
        return result
    }

-    override fun playerWillDestroy(world: Level, pos: BlockPos, state: BlockState, player: Player): BlockState {
+    override fun onRemove(
+        state: BlockState,
+        world: Level,
+        pos: BlockPos,
+        newState: BlockState,
+        moved: Boolean
+    ) {
        val entity = world.getBlockEntity(pos) as DisplayCaseBlockEntity
-        if (!entity.getStack().isEmpty && !player.isCreative) {
-            Containers.dropContents(world, pos, entity.inv)
+        if (!entity.getStack().isEmpty) {
+            Containers.dropContentsOnDestroy(state, newState, world, pos)
        }
-        return super.playerWillDestroy(world, pos, state, player)
+        super.onRemove(state, world, pos, newState, moved)
    }

    override fun getRenderShape(state: BlockState) = RenderShape.MODEL
@@ -225,7 +225,7 @@ class BerryBlockEntity(pos: BlockPos, state: BlockState) : BlockEntity(Cobblemon
     * @param player The [Player] harvesting the tree.
     * @return The resulting [ItemStack]s to be dropped.
     */
-    fun harvest(world: Level, state: BlockState, pos: BlockPos, player: Player): Collection<ItemStack> {
+    fun harvest(world: Level, state: BlockState, pos: BlockPos, player: Player?): Collection<ItemStack> {
        val drops = arrayListOf<ItemStack>()
        val unique = this.growthPoints.groupingBy { it }.eachCount()
        unique.forEach { (identifier, amount) ->
@@ -248,6 +248,10 @@ class BerryBlockEntity(pos: BlockPos, state: BlockState) : BlockEntity(Cobblemon
        return drops
    }

+    fun harvest(world: Level, state: BlockState, pos: BlockPos): Collection<ItemStack>{
+        return harvest(world, state, pos, null);
+    }
+
    override fun loadAdditional(nbt: CompoundTag, registryLookup: HolderLookup.Provider) {
        this.berryIdentifier = ResourceLocation.parse(nbt.getString(BERRY).takeIf { it.isNotBlank() } ?: "cobblemon:pecha")
        this.wasLoading = true
@@ -330,7 +334,7 @@ class BerryBlockEntity(pos: BlockPos, state: BlockState) : BlockEntity(Cobblemon
        this.setChanged()
    }

-    private fun refresh(world: Level, pos: BlockPos, state: BlockState, player: Player) {
+    private fun refresh(world: Level, pos: BlockPos, state: BlockState, player: Player?) {
        val newState = state.setValue(BerryBlock.AGE, 3)
        world.setBlock(pos, newState, UPDATE_CLIENTS)
        world.gameEvent(player, GameEvent.BLOCK_CHANGE, pos)
@@ -118,7 +118,7 @@ class RestorationTankBlockEntity(
        }

        override fun getSlotsForFace(side: Direction): IntArray {
-            return if (side == Direction.DOWN) intArrayOf(0, 1, 2, 3, 4, 5, 6, 7) else intArrayOf(-1)
+            return if (side == Direction.DOWN) intArrayOf(0, 1, 2, 3, 4, 5, 6, 7) else intArrayOf()
        }

        override fun canPlaceItemThroughFace(slot: Int, stack: ItemStack, direction: Direction?): Boolean {
@@ -155,7 +155,7 @@ class FossilMultiblockStructure (

        // Reclaim the last fossil from the machine if their hand is empty
        if (player.getItemInHand(InteractionHand.MAIN_HAND).isEmpty) {
-            if(!this.isRunning() && this.hasCreatedPokemon) {
+            if(!this.isRunning() && !this.hasCreatedPokemon) {
                if (fossilInventory.isEmpty()) {
                    return InteractionResult.CONSUME
                }
@@ -14,7 +14,6 @@ import com.cobblemon.mod.common.CobblemonBlocks
 import com.cobblemon.mod.common.CobblemonClientImplementation
 import com.cobblemon.mod.common.CobblemonEntities
 import com.cobblemon.mod.common.CobblemonItems
-import com.cobblemon.mod.common.ResourcePackActivationBehaviour
 import com.cobblemon.mod.common.api.berry.Berries
 import com.cobblemon.mod.common.api.scheduling.ClientTaskTracker
 import com.cobblemon.mod.common.api.storage.player.client.ClientGeneralPlayerData
@@ -104,14 +103,6 @@ object CobblemonClient {
        GenericBedrockEntityModelRepository
    )

-    @JvmStatic
-    val builtinResourcePacks = listOf<CobblemonResourcePack>(
-        CobblemonResourcePack(id = "adorncompatibility", name = "Adorn Compatibility", activationBehaviour = ResourcePackActivationBehaviour.DEFAULT_ENABLED, neededMods = setOf("adorn")),
-        CobblemonResourcePack(id = "gyaradosjump", name = "Gyarados Jump Patterns", activationBehaviour = ResourcePackActivationBehaviour.DEFAULT_ENABLED),
-        CobblemonResourcePack(id = "regionbiasforms", name = "Region Bias Forms", activationBehaviour = ResourcePackActivationBehaviour.DEFAULT_ENABLED),
-        CobblemonResourcePack(id = "uniqueshinyforms", name = "Shinies for Magikarp Jump", activationBehaviour = ResourcePackActivationBehaviour.NORMAL),
-    )
-
    val overlay: PartyOverlay by lazy { PartyOverlay() }
    val battleOverlay: BattleOverlay by lazy { BattleOverlay() }
    val pokedexUsageContext: PokedexUsageContext by lazy { PokedexUsageContext() }
@@ -10,10 +10,12 @@ package com.cobblemon.mod.common.client

 import com.cobblemon.mod.common.ResourcePackActivationBehaviour
 import net.minecraft.network.chat.Component
+import net.minecraft.server.packs.PackType

-class CobblemonResourcePack(
+class CobblemonPack(
    val id: String,
    val name: String,
+    val packType: PackType,
    val activationBehaviour: ResourcePackActivationBehaviour,
    val neededMods: Set<String> = setOf()
 ) {
@@ -14,6 +14,7 @@ import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.CobblemonSounds
 import com.cobblemon.mod.common.api.entity.PokemonSideDelegate
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.addEntityFunctions
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.addFunctions
 import com.cobblemon.mod.common.api.pokeball.PokeBalls
 import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
@@ -43,8 +44,6 @@ import net.minecraft.world.InteractionHand
 import net.minecraft.world.entity.Entity
 import net.minecraft.world.entity.player.Player
 import net.minecraft.world.phys.Vec3
-import java.util.UUID
-import java.util.concurrent.ConcurrentHashMap

 class PokemonClientDelegate : PosableState(), PokemonSideDelegate {
    companion object {
@@ -193,15 +192,18 @@ class PokemonClientDelegate : PosableState(), PokemonSideDelegate {
                                        val ballType =
                                            currentEntity.pokemon.caughtBall.name.path.toLowerCase().replace("_", "")
                                        val mode = if (currentEntity.isBattling) "battle" else "casual"
+                                        //TODO: A lot of this is probably able to be simplified by just using a single particle with events
+                                        //Do it in the particle file, not code.
                                        val sendflash =
                                            BedrockParticleOptionsRepository.getEffect(cobblemonResource("${ballType}/${mode}/sendflash"))
                                        sendflash?.let { effect ->
                                            val wrapper = MatrixWrapper()
                                            val matrix = PoseStack()
-                                            matrix.translate(newPos.x, newPos.y, newPos.z)
+                                            //This could potentially cause strange issues if the matrix has a translation component here.
                                            wrapper.updateMatrix(matrix.last().pose())
+                                            wrapper.updatePosition(Vec3(newPos.x, newPos.y, newPos.z))
                                            val world = Minecraft.getInstance().level ?: return@let
-                                            ParticleStorm(effect, wrapper, world).spawn()
+                                            ParticleStorm(effect, wrapper, wrapper, world).spawn()
                                            val ballsparks =
                                                BedrockParticleOptionsRepository.getEffect(cobblemonResource("${ballType}/${mode}/ballsparks"))
                                            val ballsendsparkle =
@@ -212,6 +214,7 @@ class PokemonClientDelegate : PosableState(), PokemonSideDelegate {
                                                    ParticleStorm(
                                                        effect,
                                                        wrapper,
+                                                        wrapper,
                                                        world
                                                    ).spawn()
                                                }
@@ -219,6 +222,7 @@ class PokemonClientDelegate : PosableState(), PokemonSideDelegate {
                                                    ParticleStorm(
                                                        effect,
                                                        wrapper,
+                                                        wrapper,
                                                        world
                                                    ).spawn()
                                                }
@@ -229,6 +233,7 @@ class PokemonClientDelegate : PosableState(), PokemonSideDelegate {
                                                        ParticleStorm(
                                                            effect,
                                                            wrapper,
+                                                            wrapper,
                                                            world
                                                        ).spawn()
                                                    }
@@ -367,24 +372,24 @@ class PokemonClientDelegate : PosableState(), PokemonSideDelegate {

    override fun tick(entity: PokemonEntity) {
        incrementAge(entity)
-        if(currentEntity.ownerUUID == null && currentEntity.pokemon.shiny && secondsSinceLastShinyParticle > SHINY_PARTICLE_COOLDOWN && !currentEntity.isBattling) {
-            //wild shiny not looked at
-            playShinyEffect("cobblemon:shiny_sparkle_ambient_wild")
-            lastShinyParticle = System.currentTimeMillis()
-        }
-        getClientShinyPokemon()
+        playWildShinySounds()
    }

-    fun getClientShinyPokemon() {
+    fun playWildShinySounds() {
        val player = Minecraft.getInstance().player ?: return
        val isWithinRange = player.position().distanceTo(currentEntity.position()) <= Cobblemon.config.shinyNoticeParticlesDistance

-        if (currentEntity.pokemon.shiny && currentEntity.ownerUUID == null && !player.isSpectator ) {
-            if (isWithinRange && !shined) {
-                playShinyEffect("cobblemon:wild_shiny_ring")
-                shined = true
-                lastShinyParticle = System.currentTimeMillis()
-            } else if (!isWithinRange) {
+        if (currentEntity.pokemon.shiny && currentEntity.ownerUUID == null) {
+            if (isWithinRange) {
+                if (secondsSinceLastShinyParticle > SHINY_PARTICLE_COOLDOWN && !currentEntity.isBattling) {
+                    playShinyEffect("cobblemon:shiny_sparkle_ambient_wild")
+                    lastShinyParticle = System.currentTimeMillis()
+                }
+                if (!shined && !player.isSpectator) {
+                    playShinyEffect("cobblemon:wild_shiny_ring")
+                    shined = true
+                }
+            } else {
                shined = false
            }
        }
@@ -92,7 +92,7 @@ class PartyOverlay : Gui(Minecraft.getInstance()) {
            if (!screenExemptions.contains(minecraft.screen?.javaClass as Class<out Screen>))
                return
        }
-        if (minecraft.debugOverlay.showDebugScreen()) {
+        if (minecraft.options.hideGui || minecraft.debugOverlay.showDebugScreen()) {
            return
        }
        // Hiding if toggled via Keybind
@@ -191,6 +191,8 @@ class BattleTargetSelection(
                matrices.pushPose()
                matrices.translate(x + TARGET_WIDTH - (25 / 2.0) - 2, y + 5.0, 0.0)
                matrices.scale(2.5F, 2.5F, 1F)
+                // Grab aspects for right variant
+                state.currentAspects = battlePokemon.state.currentAspects
                drawProfilePokemon(
                    species = battlePokemon.species.resourceIdentifier,
                    matrixStack = matrices,
@@ -28,13 +28,10 @@ import com.cobblemon.mod.common.entity.PosableEntity
 import com.cobblemon.mod.common.net.messages.client.dialogue.dto.DialogueDTO
 import com.cobblemon.mod.common.net.messages.client.dialogue.dto.DialogueInputDTO
 import com.cobblemon.mod.common.net.messages.server.dialogue.EscapeDialoguePacket
-import com.cobblemon.mod.common.util.asExpressionLike
-import com.cobblemon.mod.common.util.asExpressions
-import com.cobblemon.mod.common.util.asTranslated
-import com.cobblemon.mod.common.util.cobblemonResource
-import com.cobblemon.mod.common.util.resolve
+import com.cobblemon.mod.common.util.*
 import net.minecraft.client.Minecraft
 import net.minecraft.client.gui.GuiGraphics
+import net.minecraft.client.gui.components.EditBox
 import net.minecraft.client.gui.screens.Screen

 class DialogueScreen(var dialogueDTO: DialogueDTO) : Screen("gui.dialogue".asTranslated()), CobblemonRenderable {
@@ -230,4 +227,13 @@ class DialogueScreen(var dialogueDTO: DialogueDTO) : Screen("gui.dialogue".asTra
    override fun onClose() {
        EscapeDialoguePacket().sendToServer()
    }
+
+    override fun keyPressed(keyCode: Int, scanCode: Int, modifiers: Int): Boolean {
+        if (isInventoryKeyPressed(minecraft, keyCode, scanCode) && focused !is EditBox) {
+            onClose()
+            return true
+        }
+
+        return super.keyPressed(keyCode, scanCode, modifiers)
+    }
 }
@@ -113,13 +113,17 @@ class InteractWheelButton(
    override fun playDownSound(soundManager: SoundManager) {}

    private fun isHovered(mouseX: Float, mouseY: Float): Boolean {
-        val xMin = x.toFloat()
-        val xMax = xMin + BUTTON_SIZE
-        val yMin = y.toFloat()
-        val yMax = yMin + BUTTON_SIZE
+        val xMin = x.toFloat() + 1
+        val xMax = xMin + BUTTON_SIZE - 2
+        val yMin = y.toFloat() + 1
+        val yMax = yMin + BUTTON_SIZE - 2
        return canHover(mouseX.toDouble(), mouseY.toDouble()) && mouseX in xMin..xMax && mouseY in yMin..yMax
    }

+    override fun mouseClicked(mouseX: Double, mouseY: Double, button: Int): Boolean {
+        return if (isHovered(mouseX.toFloat(), mouseY.toFloat())) super.mouseClicked(mouseX, mouseY, button) else false
+    }
+
    override fun getTooltip(): Tooltip? {
        tooltipText?.let { return Tooltip.create(Component.translatable(it)) } ?: return super.getTooltip()
    }
@@ -10,6 +10,7 @@ package com.cobblemon.mod.common.client.gui.interact.wheel

 import com.cobblemon.mod.common.api.gui.blitk
 import com.cobblemon.mod.common.client.gui.CobblemonRenderable
+import com.cobblemon.mod.common.client.gui.interact.wheel.InteractWheelButton.Companion.BUTTON_SIZE
 import com.cobblemon.mod.common.client.gui.startselection.widgets.preview.ArrowButton
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.google.common.collect.Multimap
@@ -23,8 +24,7 @@ import kotlin.math.max

 class InteractWheelGUI(private val options: Multimap<Orientation, InteractWheelOption>, title: Component) : Screen(title), CobblemonRenderable {
    companion object {
-        const val SIZE = 140
-        const val OPTION_SIZE = 71
+        const val SIZE = 138
        private val backgroundResource = cobblemonResource("textures/gui/interact/interact_base.png")
        private val buttonResources = mutableMapOf(
            Orientation.TOP_LEFT to cobblemonResource("textures/gui/interact/button_left_top.png"),
@@ -142,9 +142,9 @@ class InteractWheelGUI(private val options: Multimap<Orientation, InteractWheelO
        val (x, y) = getDimensions()
        return when (orientation) {
            Orientation.TOP_LEFT -> Pair(x, y)
-            Orientation.TOP_RIGHT -> Pair(x + OPTION_SIZE, y)
-            Orientation.BOTTOM_LEFT -> Pair(x, y + OPTION_SIZE)
-            Orientation.BOTTOM_RIGHT -> Pair(x + OPTION_SIZE, y + OPTION_SIZE)
+            Orientation.TOP_RIGHT -> Pair(x + BUTTON_SIZE, y)
+            Orientation.BOTTOM_LEFT -> Pair(x, y + BUTTON_SIZE)
+            Orientation.BOTTOM_RIGHT -> Pair(x + BUTTON_SIZE, y + BUTTON_SIZE)
        }
    }

@@ -23,6 +23,7 @@ import net.minecraft.client.gui.GuiGraphics
 import net.minecraft.client.gui.components.ContainerObjectSelectionList
 import net.minecraft.client.gui.components.EditBox
 import net.minecraft.client.gui.components.Tooltip
+import net.minecraft.client.gui.components.WidgetTooltipHolder
 import net.minecraft.client.gui.components.events.GuiEventListener
 import net.minecraft.client.gui.narration.NarratableEntry

@@ -124,6 +125,9 @@ class ConfigVariableList(
        var textValue = value
        var booleanValue = value.let { it.toDoubleOrNull() == 1.0 || it.toBooleanStrictOrNull() == true }

+        val tooltip = Tooltip.create(variable.description)
+        val tooltipHolder = WidgetTooltipHolder().also { it.set(tooltip) }
+
        val editBox = EditBox(
            client.font,
            parent.listX,
@@ -133,7 +137,6 @@ class ConfigVariableList(
            variable.displayName,
        ).also {
            it.isBordered = false
-            it.tooltip = Tooltip.create(variable.description)
            it.height = SLOT_HEIGHT - 16
            it.setMaxLength(250)
            it.value = value
@@ -145,6 +148,7 @@ class ConfigVariableList(
                it.setFilter { value -> value.toDoubleOrNull() != null || value.isBlank() || value == "." || value == "-" }
            }
        }
+
        val toggleButton = NPCEditorButton(
            parent.listX.toFloat(),
            parent.listY + 6F,
@@ -156,7 +160,7 @@ class ConfigVariableList(
            parent.parent.dto.variables[variable.variableName] = if (booleanValue) "1" else "0"
            (it as NPCEditorButton).cycleButtonState = booleanValue
        }.also {
-            it.tooltip = Tooltip.create(variable.description)
+            it.tooltip = tooltip
        }

        init {
@@ -211,6 +215,10 @@ class ConfigVariableList(
                editBox.x = x + 4
                editBox.y = y + 18
                editBox.render(context, mouseX, mouseY, partialTicks)
+
+                // Manually renders the tooltip for the edit box because disabling its border messes everything up
+                val isEditBoxHovered = mouseX >= x && mouseX <= x + SLOT_WIDTH - 1 && mouseY >= y + 15 && mouseY <= y + 15 + 14
+                tooltipHolder.refreshTooltipForNextRenderPass(isEditBoxHovered, editBox.isFocused, editBox.rectangle)
            }
        }
    }
@@ -192,7 +192,8 @@ class PasturePokemonScrollList(
            partialTicks: Float
        ) {
            val x = rowLeft - 4
-            val y = rowTop
+            val y = rowTop + 2
+
            val matrixStack = context.pose()
            blitk(
                matrixStack = matrixStack,
@@ -17,6 +17,10 @@ class GrabbedStorageSlot(
    private val pokemon: Pokemon
 ) : StorageSlot(x, y, parent, {}) {

+    init {
+        isSelected = true
+    }
+
    override fun renderWidget(context: GuiGraphics, mouseX: Int, mouseY: Int, delta: Float) {
        renderSlot(context = context, posX = mouseX - (width / 2), posY = mouseY - (height / 2), partialTicks = delta)
    }
@@ -40,7 +40,8 @@ import net.minecraft.sounds.SoundEvent
 class PCGUI(
    val pc: ClientPC,
    val party: ClientParty,
-    val configuration: PCGUIConfiguration
+    val configuration: PCGUIConfiguration,
+    val openOnBox: Int = 0
 ) : Screen(Component.translatable("cobblemon.ui.pc.title")), CobblemonRenderable {

    companion object {
@@ -110,6 +111,7 @@ class PCGUI(
            pc = pc,
            party = party
        )
+        this.storageWidget.box = openOnBox

        this.setPreviewPokemon(null)
        this.addRenderableWidget(storageWidget)
@@ -46,6 +46,8 @@ open class StorageSlot(
        private val slotOverlayMoveIconResource = cobblemonResource("textures/gui/pasture/pc_slot_icon_move.png")
    }

+    protected var isSelected = false;
+
    override fun playDownSound(soundManager: SoundManager) {
    }

@@ -82,50 +84,52 @@ open class StorageSlot(

        context.disableScissor()

-        // Ensure elements are not hidden behind Pokémon render
-        matrices.pushPose()
-        matrices.translate(0.0, 0.0, 100.0)
-        // Level
-        drawScaledText(
-            context = context,
-            text = lang("ui.lv.number", pokemon.level),
-            x = posX + 1,
-            y = posY + 1,
-            shadow = true,
-            scale = PCGUI.SCALE
-        )
-
-        if (pokemon.gender != Gender.GENDERLESS) {
-            blitk(
-                matrixStack = matrices,
-                texture = if (pokemon.gender == Gender.MALE) genderIconMale else genderIconFemale,
-                x = (posX + 21) / PCGUI.SCALE,
-                y = (posY + 1) / PCGUI.SCALE,
-                width = 6,
-                height = 8,
+        if (!isSelected) {
+            // Ensure elements are not hidden behind Pokémon render
+            matrices.pushPose()
+            matrices.translate(0.0, 0.0, 100.0)
+            // Level
+            drawScaledText(
+                context = context,
+                text = lang("ui.lv.number", pokemon.level),
+                x = posX + 1,
+                y = posY + 1,
+                shadow = true,
                scale = PCGUI.SCALE
            )
-        }

-        // Held Item
-        val heldItem = pokemon.heldItemNoCopy()
-        if (!heldItem.isEmpty) {
-            renderScaledGuiItemIcon(
-                itemStack = heldItem,
-                x = posX + 16.0,
-                y = posY + 16.0,
-                scale = 0.5,
-                matrixStack = matrices
-            )
+            if (pokemon.gender != Gender.GENDERLESS) {
+                blitk(
+                    matrixStack = matrices,
+                    texture = if (pokemon.gender == Gender.MALE) genderIconMale else genderIconFemale,
+                    x = (posX + 21) / PCGUI.SCALE,
+                    y = (posY + 1) / PCGUI.SCALE,
+                    width = 6,
+                    height = 8,
+                    scale = PCGUI.SCALE
+                )
+            }
+
+            // Held Item
+            val heldItem = pokemon.heldItemNoCopy()
+            if (!heldItem.isEmpty) {
+                renderScaledGuiItemIcon(
+                    itemStack = heldItem,
+                    x = posX + 16.0,
+                    y = posY + 16.0,
+                    scale = 0.5,
+                    matrixStack = matrices
+                )
+            }
+            matrices.popPose()
        }
-        matrices.popPose()

        // Ensure overlay elements are on top
        matrices.pushPose()
        matrices.translate(0.0, 0.0, 500.0)

        val config = parent.pcGui.configuration
-        if (pokemon.tetheringId != null) {
+        if (pokemon.tetheringId != null && !isSelected) {
            if (isStationary()) {
                blitk(
                    matrixStack = matrices,
@@ -286,7 +286,10 @@ class StorageWidget(
        }

        pastureWidget?.render(context, mouseX, mouseY, delta)
+        matrices.pushPose()
+        matrices.translate(0.0, 0.0, 1000.0)
        grabbedSlot?.render(context, mouseX, mouseY, delta)
+        matrices.popPose()
    }

    override fun mouseClicked(pMouseX: Double, pMouseY: Double, pButton: Int): Boolean {
@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.client.gui.pokedex

 import com.bedrockk.molang.runtime.MoLangRuntime
+import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.CobblemonSounds
 import com.cobblemon.mod.common.api.gui.blitk
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.setup
@@ -40,22 +41,17 @@ import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.TAB_DROPS
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.TAB_ICON_SIZE
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.TAB_SIZE
 import com.cobblemon.mod.common.client.gui.pokedex.PokedexGUIConstants.TAB_STATS
-import com.cobblemon.mod.common.client.gui.pokedex.widgets.AbilitiesWidget
-import com.cobblemon.mod.common.client.gui.pokedex.widgets.DescriptionWidget
-import com.cobblemon.mod.common.client.gui.pokedex.widgets.DropsScrollingWidget
-import com.cobblemon.mod.common.client.gui.pokedex.widgets.EntriesScrollingWidget
-import com.cobblemon.mod.common.client.gui.pokedex.widgets.PokemonInfoWidget
-import com.cobblemon.mod.common.client.gui.pokedex.widgets.SearchWidget
-import com.cobblemon.mod.common.client.gui.pokedex.widgets.SizeWidget
-import com.cobblemon.mod.common.client.gui.pokedex.widgets.StatsWidget
+import com.cobblemon.mod.common.client.gui.pokedex.widgets.*
 import com.cobblemon.mod.common.client.pokedex.PokedexType
 import com.cobblemon.mod.common.client.render.drawScaledText
 import com.cobblemon.mod.common.net.messages.server.block.AdjustBlockEntityViewerCountPacket
 import com.cobblemon.mod.common.pokemon.abilities.HiddenAbility
 import com.cobblemon.mod.common.util.cobblemonResource
+import com.cobblemon.mod.common.util.isInventoryKeyPressed
 import com.cobblemon.mod.common.util.lang
 import net.minecraft.client.Minecraft
 import net.minecraft.client.gui.GuiGraphics
+import net.minecraft.client.gui.components.EditBox
 import net.minecraft.client.gui.components.Renderable
 import net.minecraft.client.gui.components.events.GuiEventListener
 import net.minecraft.client.gui.narration.NarratableEntry
@@ -411,6 +407,13 @@ class PokedexGUI private constructor(
        var entries = filteredPokedex
            .flatMap { it.getEntries() }

+        if (Cobblemon.config.hideUnimplementedPokemonInThePokedex) {
+            entries = entries.filter {
+                val species = PokemonSpecies.getByIdentifier(it.speciesId) ?: return@filter false
+                return@filter species.implemented
+            }
+        }
+
        for (filter in getFilters()) {
            entries = entries.filter { filter.test(it) }
        }
@@ -580,6 +583,15 @@ class PokedexGUI private constructor(

    override fun isPauseScreen(): Boolean = false

+    override fun keyPressed(keyCode: Int, scanCode: Int, modifiers: Int): Boolean {
+        if (isInventoryKeyPressed(minecraft, keyCode, scanCode) && focused !is EditBox) {
+            onClose()
+            return true
+        }
+
+        return super.keyPressed(keyCode, scanCode, modifiers)
+    }
+
    fun playSound(soundEvent: SoundEvent) {
        Minecraft.getInstance().soundManager.play(SimpleSoundInstance.forUI(soundEvent, 1.0F))
    }
@@ -113,6 +113,7 @@ class PokemonInfoWidget(val pX: Int, val pY: Int, val updateForm: (PokedexForm)
    var selectedFormIndex: Int = 0

    var type: Array<ElementalType?> = arrayOf(null, null)
+    var seenShinyStates: Set<String> = setOf()
    var shiny = false
    var maleRatio = -1F
    var gender: Gender = Gender.GENDERLESS
@@ -207,9 +208,6 @@ class PokemonInfoWidget(val pX: Int, val pY: Int, val updateForm: (PokedexForm)
        20,
        buttonNone,
        clickAction = {
-            val currentEntry = currentEntry ?: return@ScaledButton
-            val currentForm = currentEntry.forms[selectedFormIndex]
-            val seenShinyStates = CobblemonClient.clientPokedexData.getSeenShinyStates(currentEntry, currentForm)
            if (seenShinyStates.size > 1) {
                shiny = !shiny
                updateAspects()
@@ -536,11 +534,11 @@ class PokemonInfoWidget(val pX: Int, val pY: Int, val updateForm: (PokedexForm)
            }
            selectedFormIndex = 0

-            setupButtons(pokedexEntry, forms[selectedFormIndex])
-
            if (visibleForms.isNotEmpty()) {
+                setupButtons(pokedexEntry, visibleForms[selectedFormIndex])
                updateAspects()
            } else {
+                setupButtons(pokedexEntry, forms[selectedFormIndex])
                type = arrayOf(null, null)
            }
        }
@@ -551,7 +549,7 @@ class PokemonInfoWidget(val pX: Int, val pY: Int, val updateForm: (PokedexForm)
        variationButtons.forEach { removeWidget(it.getWidget()) }
        variationButtons.clear()

-        val seenShinyStates = CobblemonClient.clientPokedexData.getSeenShinyStates(pokedexEntry, pokedexForm)
+        seenShinyStates = CobblemonClient.clientPokedexData.getSeenShinyStates(pokedexEntry, pokedexForm)
        shiny = seenShinyStates.count() == 1 && seenShinyStates.first() == "shiny"
        shinyButton.resource = if (shiny) buttonShiny else buttonNone
        shinyButton.visible = shiny || seenShinyStates.size > 1
@@ -595,6 +593,8 @@ class PokemonInfoWidget(val pX: Int, val pY: Int, val updateForm: (PokedexForm)
    }

    private fun switchForm(nextIndex: Boolean) {
+        selectedPoseIndex = 0
+
        if (nextIndex) {
            if (selectedFormIndex < visibleForms.lastIndex) selectedFormIndex++
            else selectedFormIndex = 0
@@ -163,8 +163,8 @@ class Summary private constructor(party: Collection<Pokemon?>, private val edita
                },
                text = lang("ui.evolve"),
                resource = evolveButtonResource,
-                renderRequirement = { selectedPokemon.evolutionProxy.client().isNotEmpty() },
-                clickRequirement = { selectedPokemon.evolutionProxy.client().isNotEmpty() }
+                renderRequirement = { selectedPokemon.evolutionProxy.client().isNotEmpty() && CobblemonClient.battle == null },
+                clickRequirement = { selectedPokemon.evolutionProxy.client().isNotEmpty() && CobblemonClient.battle == null }
            )
        )

@@ -16,6 +16,7 @@ import com.cobblemon.mod.common.client.CobblemonResources
 import com.cobblemon.mod.common.client.gui.summary.widgets.SoundlessWidget
 import com.cobblemon.mod.common.client.gui.summary.widgets.common.reformatNatureTextIfMinted
 import com.cobblemon.mod.common.client.render.drawScaledText
+import com.cobblemon.mod.common.client.settings.ServerSettings
 import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.util.asTranslated
 import com.cobblemon.mod.common.util.cobblemonResource
@@ -89,7 +90,12 @@ class InfoWidget(
        typeWidget.render(context, pMouseX, pMouseY, pPartialTicks)

        // Original Trainer
-        val otName: MutableComponent = Component.literal(pokemon.originalTrainerName ?: "")
+        val otName: MutableComponent = pokemon.originalTrainerName?.let { name ->
+            Component.literal(name)
+        } ?: pokemon.originalTrainer?.let { trainer ->
+            Component.literal("${trainer.take(15)}...")
+        } ?: Component.literal("")
+
        val otWidget = InfoOneLineWidget(
            pX = x,
            pY = y + 3 * ROW_HEIGHT,
@@ -164,8 +170,9 @@ class InfoWidget(
        val experience = pokemon.experience.toString().text()
        val experienceForThisLevel =
            pokemon.experience - if (pokemon.level == 1) 0 else pokemon.experienceGroup.getExperience(pokemon.level)
+        val nextLevel = (pokemon.level + 1).coerceAtMost(ServerSettings.maxPokemonLevel)
        val experienceToNext =
-            pokemon.experienceGroup.getExperience(pokemon.level + 1) - pokemon.experienceGroup.getExperience(pokemon.level)
+            pokemon.experienceGroup.getExperience(nextLevel) - pokemon.experienceGroup.getExperience(pokemon.level)

        drawScaledText(
            context = context,
@@ -176,10 +183,11 @@ class InfoWidget(
            shadow = true
        )

+        val experienceToNextText = Component.literal(experienceToNext.toString())
        drawScaledText(
            context = context,
-            text = experienceToNext.toString().text(),
-            x = (x + 127) - (mcFont.width(experienceToNext.toString().text()) * smallTextScale),
+            text = experienceToNextText,
+            x = (x + 127) - (mcFont.width(experienceToNextText) * smallTextScale),
            y = y + 137,
            scale = smallTextScale,
            shadow = true
@@ -8,18 +8,52 @@

 package com.cobblemon.mod.common.client.net.effect

+import com.bedrockk.molang.runtime.MoLangRuntime
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.setup
 import com.cobblemon.mod.common.api.net.ClientNetworkPacketHandler
+import com.cobblemon.mod.common.client.ClientMoLangFunctions.setupClient
 import com.cobblemon.mod.common.client.particle.BedrockParticleOptionsRepository
 import com.cobblemon.mod.common.client.particle.ParticleStorm
+import com.cobblemon.mod.common.client.render.models.blockbench.PosableState
+import com.cobblemon.mod.common.entity.PosableEntity
 import com.cobblemon.mod.common.net.messages.client.effect.SpawnSnowstormEntityParticlePacket
 import net.minecraft.client.Minecraft
-import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.Entity

 object SpawnSnowstormEntityParticleHandler : ClientNetworkPacketHandler<SpawnSnowstormEntityParticlePacket> {
    override fun handle(packet: SpawnSnowstormEntityParticlePacket, client: Minecraft) {
        val world = Minecraft.getInstance().level ?: return
        val effect = BedrockParticleOptionsRepository.getEffect(packet.effectId) ?: return
-        val entity = world.getEntity(packet.entityId) as? LivingEntity ?: return
-        ParticleStorm.createAtEntity(world, effect, entity, packet.locator).forEach(ParticleStorm::spawn)
+        val sourceEntity = world.getEntity(packet.sourceEntityId) as? PosableEntity ?: return
+        val targetedEntity = packet.targetedEntityId?.let { world.getEntity(it) }
+        sourceEntity as Entity
+        val sourceState = sourceEntity.delegate as PosableState
+        val targetState = (targetedEntity as? PosableEntity)?.delegate as? PosableState
+        val sourceLocators = packet.sourceLocators.firstNotNullOfOrNull { sourceState.getMatchingLocators(it).takeIf { it.isNotEmpty() } } ?: return
+        val targetedLocator = packet.targetLocators?.firstOrNull { targetState?.getMatchingLocators(it)?.isNotEmpty() == true }
+        val rootMatrix = sourceState.locatorStates["root"]!!
+
+        sourceLocators.forEach { locator ->
+            val locatorMatrix = sourceState.locatorStates[locator]!!
+
+            val particleMatrix = effect.emitter.space.initializeEmitterMatrix(rootMatrix, locatorMatrix)
+            val particleRuntime = MoLangRuntime().setup().setupClient()
+            particleRuntime.environment.query.addFunction("entity") { sourceState.runtime.environment.query }
+
+            val storm = ParticleStorm(
+                effect = effect,
+                emitterSpaceMatrix = particleMatrix,
+                locatorSpaceMatrix = locatorMatrix,
+                world = world,
+                runtime = particleRuntime,
+                sourceVelocity = { sourceEntity.deltaMovement },
+                sourceAlive = { !sourceEntity.isRemoved },
+                sourceVisible = { !sourceEntity.isInvisible },
+                targetPos =  if (targetedEntity != null) { { targetedLocator?.let { targetState?.locatorStates?.get(it) }?.getOrigin() ?: targetedEntity.position() } } else null,
+                entity = sourceEntity
+            )
+
+            storm.spawn()
+        }
    }
 }
@@ -11,13 +11,19 @@ package com.cobblemon.mod.common.client.net.effect
 import com.cobblemon.mod.common.api.net.ClientNetworkPacketHandler
 import com.cobblemon.mod.common.client.particle.BedrockParticleOptionsRepository
 import com.cobblemon.mod.common.client.particle.ParticleStorm
+import com.cobblemon.mod.common.client.render.MatrixWrapper
 import com.cobblemon.mod.common.net.messages.client.effect.SpawnSnowstormParticlePacket
 import net.minecraft.client.Minecraft
+import com.mojang.blaze3d.vertex.PoseStack

 object SpawnSnowstormParticleHandler : ClientNetworkPacketHandler<SpawnSnowstormParticlePacket> {
    override fun handle(packet: SpawnSnowstormParticlePacket, client: Minecraft) {
+        val wrapper = MatrixWrapper()
+        val matrix = PoseStack()
+        wrapper.updateMatrix(matrix.last().pose())
+        wrapper.updatePosition(packet.position)
        val world = Minecraft.getInstance().level ?: return
        val effect = BedrockParticleOptionsRepository.getEffect(packet.effectId) ?: return
-        ParticleStorm.createAtPosition(world, effect, packet.position).spawn()
+        ParticleStorm(effect, wrapper, wrapper, world).spawn()
    }
 }
@@ -18,6 +18,9 @@ object ServerSettingsPacketHandler : ClientNetworkPacketHandler<ServerSettingsPa
        ServerSettings.preventCompletePartyDeposit = packet.preventCompletePartyDeposit
        ServerSettings.displayEntityLevelLabel = packet.displayEntityLevelLabel
        ServerSettings.displayEntityNameLabel = packet.displayEntityNameLabel
+        ServerSettings.maxPokemonLevel = packet.maxPokemonLevel
+        ServerSettings.maxPokemonFriendship = packet.maxPokemonFriendship
+        ServerSettings.maxDynamaxLevel = packet.maxDynamaxLevel
    }

 }
@@ -18,6 +18,6 @@ import net.minecraft.client.Minecraft
 object OpenPCHandler : ClientNetworkPacketHandler<OpenPCPacket> {
    override fun handle(packet: OpenPCPacket, client: Minecraft) {
        val pc = CobblemonClient.storage.pcStores[packet.storeID] ?: return
-        Minecraft.getInstance().setScreen(PCGUI(pc, CobblemonClient.storage.myParty, PCGUIConfiguration()))
+        Minecraft.getInstance().setScreen(PCGUI(pc, CobblemonClient.storage.myParty, PCGUIConfiguration(), packet.box))
    }
 }
@@ -31,12 +31,16 @@ object BedrockParticleOptionsRepository {
    fun loadEffects(resourceManager: ResourceManager) {
        LOGGER.info("Loading particle effects...")
        effects.clear()
-
        resourceManager.listResources("bedrock/particles") { path -> path.endsWith(".particle.json") }.forEach { identifier, resource ->
-            resource.open().use { stream ->
-                val json = String(stream.readAllBytes(), StandardCharsets.UTF_8)
-                val effect = SnowstormParticleReader.loadEffect(GSON.fromJson(json, JsonObject::class.java))
-                effects[effect.id] = effect
+            try {
+                resource.open().use { stream ->
+                    val json = String(stream.readAllBytes(), StandardCharsets.UTF_8)
+                    val effect = SnowstormParticleReader.loadEffect(GSON.fromJson(json, JsonObject::class.java))
+                    effects[effect.id] = effect
+                }
+            }
+            catch (e: Exception) {
+                LOGGER.error(e)
            }
        }

--- a/Show More
+++ b/Show More