Merge remote-tracking branch 'origin/1.6.1-faster-spawner' into test-observable-bypass

Maybe perhaps fixed some data loss
just make it compile
2026-10-24 08:06:24 -04:00 · 2025-07-19 08:11:49 +10:00 · 2025-07-18 18:31:56 +10:00 · 2025-03-11 12:54:12 +10:00 · 2025-03-11 11:13:36 +10:00 · 2025-03-11 11:13:35 +10:00
3547 changed files with 279755 additions and 155672 deletions
@@ -1,5 +1,267 @@
 # Changelog
-## [1.6.0 - The Record Catch Update (Month Xth, 2024)](#1-6-0)
+## [1.7.0 (Month xth, 2025)](#1-7-0)
+
+### Additions
+- Added an in-game configuration screen, allowing all settings from `main.json` to be edited directly in-game.
+- Added `/cobblemonconfig reload` command to reload `main.json` configuration. **Note:** Some settings require a server restart to take effect; use this command cautiously.
+- Added `blacklisted_items_to_hold` and `whitelisted_items_to_hold` tags to allow for controlling which items players can give to their Pokémon. If the whitelist is empty, it will consider all item as allowed (unless they are in the blacklist).
+- Pokémon now follow the mouse cursor on the Summary screen, with an option to disable this in the settings.
+- Pokémon's held items can now be rendered, with a visibility toggle in the Summary screen.
+- Added cosmetic item functionality for Pokémon. Certain cosmetic items can be given to applicable Pokémon via the interact menu.
+  - Added the various log blocks as cosmetic items for Timburr and Komala.
+- Added `visibility/hidden`, `visibility/hat` and `visibility/face` tags to control where and how certain items are rendered.
+
+### Changes
+- Renamed `chargeGainedPerTick` config to `secondsToChargeHealingMachine`.
+- Made Blocks of Gold count as Big Nuggets when held by a Pokémon (for Fling functionality)
+- Substantially optimised spawning checks mainly by front-loading biome filtering.
+
+### Fixes
+- Fixed Particles sometimes facing the wrong direction (looking at you, Swords Dance)
+- Fixed PCs always opening at box 2 instead of box 1.
+- Fixed not being able to do complex item requirements aside from just NBT with evolution conditions, requirements and fossil items.
+- Fixed the usage `hiddenability` in `pokegive` or other spawn commands resulting in a forced hidden ability
+- Fixed the consumption of friendship berries (or EV berries) not making any noise
+- Fixed Instantly breaking and replacing a fossil analyzer with any block entity crashing the game in a complete multi-structure
+- Fixed players getting disconnected when sidemods update a Pokémon's teratype
+- Fixed fling not using Item Names for minecraft held items that substitute Pokémon items
+- Fixed evolutions sometimes preventing players from logging in to servers
+- Fixed rendering of shoulder-mounted Pokémon desyncing between clients
+- Fixed apricorn chest boats forgetting their inventories when being unloaded
+- Fixed moves not updating correctly between form changes resulting in illegal movesets
+- Fixed crash sometimes occurring with the "Oritech" mod
+- Fixed crashes due to an incorrect Java version handing out an obscure crash.
+- Fixed some berries being able to rarely get too many berries and cause a crash.
+- Fixed status curing berries not playing the berry eating sound, same for healing berries used mid-battle.
+- Fixed owned Pokémon sometimes being un-interactable after the player relogs fast
+- Fixed field name in evolution requirements for Spewpa Pokeball.
+- Fixed LevelUpCriterion logic to correctly check that the Pokémon is a preEvo.
+- Fixed `hide_additional_tooltip` vanilla flag not properly hiding tooltips on pokerod and bait items
+
+### Developer
+- A finished battle now has winners and losers set inside of `PokemonBattle` instead of them always being empty.
+- Dialogues are correctly removed from memory when they are stopped.
+- Dialogues with variably-set initial pages now properly start timeout tracking.
+- Added `EvGainedEvent.Pre` and `EvGainedEvent.Post`.
+- Deprecated `EVs#add(Stat, Int)`, you will not be able to compile against this code please migrate to the `EVs#add(Stat, Int, EvSource)` you most likely want to use `SidemodEvSource` but please check other implementations or make your own.
+- Removed the NbtItemPredicate class, all the mod usages now use the vanilla item predicate solution, this causes breaking changes on Fossil, HeldItemRequirement & ItemInteractionEvolution
+- Renamed Cobblemon's creative tabs to start with "Cobblemon: " to distinguish Cobblemon's tabs from tabs for other mods.
+- Various items now have a rarity value.
+
+### Changes
+- When using the `cobblemon` or `generation_9` capture calculators a critical capture with a single shake will always play for successful captures when you've already registered the Pokémon as caught in your Pokédex.
+
+### MoLang & Datapacks
+- The following usages for item predicates can now use item conditions like advancements do, you can learn about them in the [Minecraft wiki](https://minecraft.wiki/w/Advancement_definition#minecraft:filled_bucket)
+  - The `requiredContext` for an item interaction evolution
+  - The `itemCondition` for a held item evolution requirement
+  - The `fossils` for a fossil entry
+- Added MoLang flows for `poke_ball_capture_calculated`, `evolution_tested`, `evolution_accepted`, `evolution_completed`
+- Added `interpolate` boolean property to animated textures to allow gradual colour changes between frames.
+
+## [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 +386,6 @@
 #### Gen 9
 - Wattrel
 - Kilowattrel
- Wiglett
- Wugtrio
- Flamigo
 - Veluza
 - Farigiraf
 - Klawf
@@ -1903,5 +2162,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
@@ -372,8 +388,8 @@ object Cobblemon {
            storage.unregisterAll(it.server.registryAccess())
            playerDataManager.saveAllStores()
        }
-        PlatformEvents.SERVER_STARTED.subscribe {
-            bestSpawner.onServerStarted()
+        PlatformEvents.SERVER_STARTED.subscribe { event ->
+            bestSpawner.onServerStarted(event.server)
            battleRegistry.onServerStarted()
        }
        PlatformEvents.SERVER_TICK_POST.subscribe { ServerTickHandler.onTick(it.server) }
@@ -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.conditional

+import net.minecraft.core.Holder
 import net.minecraft.core.Registry

 /**
@@ -17,5 +18,10 @@ import net.minecraft.core.Registry
 * @since July 16th, 2022
 */
 interface RegistryLikeCondition<T> {
-    fun fits(t: T, registry: Registry<T>): Boolean
+    fun fits(t: T, registry: Registry<T>): Boolean {
+        val holder = registry.wrapAsHolder(t)
+        return holder != null && fits(holder)
+    }
+
+    fun fits(holder: Holder<T>): Boolean
 }
@@ -9,7 +9,7 @@
 package com.cobblemon.mod.common.api.conditional

 import com.google.gson.JsonElement
-import net.minecraft.core.Registry
+import net.minecraft.core.Holder
 import net.minecraft.resources.ResourceLocation

 /**
@@ -24,5 +24,6 @@ open class RegistryLikeIdentifierCondition<T : Any>(val identifier: ResourceLoca
            constructor: (ResourceLocation) -> RegistryLikeIdentifierCondition<T>
        ): (JsonElement) -> RegistryLikeIdentifierCondition<T>? = { constructor(ResourceLocation.parse(it.asString)) }
    }
-    override fun fits(t: T, registry: Registry<T>) = registry.getKey(t) == identifier
+
+    override fun fits(t: Holder<T>) = t.`is`(identifier)
 }
@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.api.conditional

 import com.google.gson.JsonElement
+import net.minecraft.core.Holder
 import net.minecraft.core.Registry
 import net.minecraft.resources.ResourceKey
 import net.minecraft.resources.ResourceLocation
@@ -39,16 +40,5 @@ open class RegistryLikeTagCondition<T : Any>(val tag: TagKey<T>) : RegistryLikeC
        }
    }

-    override fun fits(t: T, registry: Registry<T>): Boolean {
-//        val registryHasTag = registry.containsTag(tag)
-//        if (!registryHasTag) {
-////            LOGGER.warn("No tag in registry: ${tag.id}")
-//            return false
-//        }
-
-        return registry.getResourceKey(t)
-            .flatMap(registry::getHolder)
-            .map { entry -> entry.`is`(tag) }
-            .orElse(false)
-    }
+    override fun fits(t: Holder<T>) = t.`is`(tag)
 }
@@ -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
        }
    )
@@ -833,7 +850,7 @@ object MoLangFunctions {
        { spawningContext ->
            val map = hashMapOf<String, java.util.function.Function<MoParams, Any>>()
            val worldValue = spawningContext.world.registryAccess().registryOrThrow(Registries.DIMENSION).wrapAsHolder(spawningContext.world).asWorldMoLangValue()
-            val biomeValue = spawningContext.biomeRegistry.wrapAsHolder(spawningContext.biome).asBiomeMoLangValue()
+            val biomeValue = spawningContext.biomeHolder.asBiomeMoLangValue()
            map.put("biome") { _ -> biomeValue }
            map.put("world") { _ -> worldValue }
            map.put("light") { _ -> DoubleValue(spawningContext.light.toDouble()) }
@@ -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)
@@ -10,7 +10,14 @@ package com.cobblemon.mod.common.api.spawning

 import com.cobblemon.mod.common.Cobblemon.LOGGER
 import com.cobblemon.mod.common.api.entity.Despawner
-import com.cobblemon.mod.common.api.spawning.condition.*
+import com.cobblemon.mod.common.api.spawning.condition.AreaSpawningCondition
+import com.cobblemon.mod.common.api.spawning.condition.BasicSpawningCondition
+import com.cobblemon.mod.common.api.spawning.condition.FishingSpawningCondition
+import com.cobblemon.mod.common.api.spawning.condition.GroundedSpawningCondition
+import com.cobblemon.mod.common.api.spawning.condition.SeafloorSpawningCondition
+import com.cobblemon.mod.common.api.spawning.condition.SpawningCondition
+import com.cobblemon.mod.common.api.spawning.condition.SubmergedSpawningCondition
+import com.cobblemon.mod.common.api.spawning.condition.SurfaceSpawningCondition
 import com.cobblemon.mod.common.api.spawning.context.AreaContextResolver
 import com.cobblemon.mod.common.api.spawning.context.FishingSpawningContext
 import com.cobblemon.mod.common.api.spawning.context.GroundedSpawningContext
@@ -44,6 +51,7 @@ import com.cobblemon.mod.common.api.spawning.spawner.Spawner
 import com.cobblemon.mod.common.api.spawning.spawner.TickingSpawner
 import com.cobblemon.mod.common.entity.pokemon.CobblemonAgingDespawner
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import net.minecraft.server.MinecraftServer

 /**
 * A grouping of all the overarching behaviours of the Best Spawner system. This is a convenient accessor to
@@ -119,7 +127,8 @@ object BestSpawner {
        SpawnDetailPresets.registerPresetType(PokemonSpawnDetailPreset.NAME, PokemonSpawnDetailPreset::class.java)
    }

-    fun onServerStarted() {
+    fun onServerStarted(server: MinecraftServer) {
+        CobblemonSpawnPools.onServerLoad(server)
        spawnerManagers.forEach(SpawnerManager::onServerStarted)
        fishingSpawner = FishingSpawner()
    }
@@ -8,10 +8,13 @@

 package com.cobblemon.mod.common.api.spawning

+import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.api.spawning.condition.BiomePrecalculation
 import com.cobblemon.mod.common.api.spawning.condition.BucketPrecalculation
 import com.cobblemon.mod.common.api.spawning.condition.ContextPrecalculation
 import com.cobblemon.mod.common.api.spawning.detail.SpawnPool
 import com.cobblemon.mod.common.data.CobblemonDataProvider
+import net.minecraft.server.MinecraftServer

 /**
 * A collection of all of Cobblemon's general-purpose [SpawnPool]s. These
@@ -26,6 +29,18 @@ object CobblemonSpawnPools {
    lateinit var WORLD_SPAWN_POOL: SpawnPool

    fun load() {
-        WORLD_SPAWN_POOL = CobblemonDataProvider.register(SpawnPool("world").addPrecalculators(ContextPrecalculation, BucketPrecalculation))
+        WORLD_SPAWN_POOL = CobblemonDataProvider.register(SpawnPool("world")
+            .addPrecalculators(
+                ContextPrecalculation,
+                BucketPrecalculation,
+                BiomePrecalculation
+            )
+        )
+    }
+
+    fun onServerLoad(server: MinecraftServer) {
+        Cobblemon.LOGGER.info("Optimizing spawn pools...")
+        WORLD_SPAWN_POOL.forEach { it.onServerLoad(server) }
+        WORLD_SPAWN_POOL.precalculate()
    }
 }
@@ -32,7 +32,7 @@ abstract class AreaTypeSpawningCondition<T : AreaSpawningContext> : SpawningCond
            return false
        } else if (maxHeight != null && ctx.height > maxHeight!!) {
            return false
-        } else if (neededNearbyBlocks != null && neededNearbyBlocks!!.none { cond -> ctx.nearbyBlockTypes.any { cond.fits(it, ctx.blockRegistry) } }) {
+        } else if (neededNearbyBlocks != null && neededNearbyBlocks!!.none { cond -> ctx.nearbyBlockHolders.any { cond.fits(it) } }) {
            return false
        } else {
            return true
@@ -10,6 +10,8 @@ package com.cobblemon.mod.common.api.spawning.condition

 import com.cobblemon.mod.common.api.spawning.context.SpawningContext
 import com.cobblemon.mod.common.api.spawning.detail.SpawnDetail
+import net.minecraft.core.Holder
+import net.minecraft.world.level.biome.Biome

 /**
 * A spawning condition that is composed of a list of conditions and anticonditions.
@@ -30,6 +32,15 @@ class CompositeSpawningCondition {
    var conditions = mutableListOf<SpawningCondition<*>>()
    var anticonditions = mutableListOf<SpawningCondition<*>>()

+    fun isBiomeValid(holder: Holder<Biome>): Boolean {
+        if (conditions.isEmpty() || conditions.any { it.biomes == null || it.biomes!!.isEmpty() || it.biomes!!.any { it.fits(holder) } }) {
+            if (anticonditions.isEmpty() || anticonditions.none { it.biomes != null && it.biomes!!.any { it.fits(holder) } }) {
+                return true
+            }
+        }
+        return false
+    }
+
    fun satisfiedBy(ctx: SpawningContext): Boolean {
        return if (conditions.isNotEmpty() && conditions.none { it.isSatisfiedBy(ctx) }) {
            false
@@ -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)) {
@@ -30,7 +30,11 @@ abstract class GroundedTypeSpawningCondition<T : GroundedSpawningContext> : Area
            return false
        } else if (maxHeight != null && ctx.height > maxHeight!!) {
            return false
-        } else !(neededBaseBlocks != null && neededBaseBlocks!!.none { it.fits(ctx.baseBlock.block, ctx.blockRegistry) })
+        } else if (neededBaseBlocks != null && neededBaseBlocks!!.none { it.fits(ctx.baseBlockHolder) }) {
+            return false
+        } else {
+            return true
+        }
    }

    override fun copyFrom(other: SpawningCondition<*>, merger: Merger) {
@@ -30,10 +30,14 @@ abstract class SeafloorTypeSpawningCondition<T : SeafloorSpawningContext> : Area
        return if (!super.fits(ctx)) {
            false
        } else if (minHeight != null && ctx.height < minHeight!!) {
-            return false
+            false
        } else if (maxHeight != null && ctx.height > maxHeight!!) {
-            return false
-        } else !(neededBaseBlocks != null && neededBaseBlocks!!.none { it.fits(ctx.baseBlock.block, ctx.blockRegistry) })
+            false
+        } else if (neededBaseBlocks != null && neededBaseBlocks!!.none { it.fits(ctx.baseBlockHolder) }) {
+            false
+        } else {
+            true
+        }
    }

    override fun copyFrom(other: SpawningCondition<*>, merger: Merger) {
@@ -44,7 +48,7 @@ abstract class SeafloorTypeSpawningCondition<T : SeafloorSpawningContext> : Area
    }

    override fun isValid(): Boolean {
-        val containsNullValues = neededBaseBlocks != null && neededBaseBlocks!!.any {it == null}
+        val containsNullValues = neededBaseBlocks != null && neededBaseBlocks!!.any { it == null }
        return super.isValid() && !containsNullValues
    }
 }
@@ -42,6 +42,7 @@ abstract class SpawningCondition<T : SpawningContext> {
    }

    var dimensions: MutableList<ResourceLocation>? = null
+    /** This gets checked in a precalculation but still needs to be checked for things like rarity multipliers. */
    var biomes: MutableSet<RegistryLikeCondition<Biome>>? = null
    var moonPhase: MoonPhaseRange? = null
    var canSeeSky: Boolean? = null
@@ -59,10 +60,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
@@ -102,7 +99,7 @@ abstract class SpawningCondition<T : SpawningContext> {
            return false
        } else if (dimensions != null && dimensions!!.isNotEmpty() && ctx.world.dimensionType().effectsLocation !in dimensions!!) {
            return false
-        } else if (biomes != null && biomes!!.isNotEmpty() && biomes!!.none { condition -> condition.fits(ctx.biome, ctx.biomeRegistry) }) {
+        } else if (biomes != null && biomes!!.isNotEmpty() && biomes!!.none { condition -> condition.fits(ctx.biomeHolder) }) {
            return false
        } else if (appendages.any { !it.fits(ctx) }) {
            return false
@@ -157,11 +154,11 @@ abstract class SpawningCondition<T : SpawningContext> {
    }

    open fun isValid(): Boolean {
-        if(biomes != null && biomes!!.any {it == null})
+        if (biomes != null && biomes!!.any { it == null })
            return false
-        if(dimensions != null && dimensions!!.any {it == null})
+        if (dimensions != null && dimensions!!.any { it == null })
            return false
-        if(structures != null && structures!!.any {it == null})
+        if (structures != null && structures!!.any { it == null })
            return false
        return true
    }
@@ -12,6 +12,7 @@ import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.context.SpawningContext
 import com.cobblemon.mod.common.api.spawning.detail.SpawnDetail
 import com.cobblemon.mod.common.api.spawning.spawner.Spawner
+import net.minecraft.resources.ResourceLocation

 /**
 * A type of precalculation that can occur on a list of [SpawnDetail] to accelerate
@@ -31,7 +32,7 @@ import com.cobblemon.mod.common.api.spawning.spawner.Spawner
 */
 interface SpawningPrecalculation<T : Any> {
    /** Retrieves the precalculation keys for the given spawn detail. */
-    fun select(detail: SpawnDetail): List<T>
+    fun select(detail: SpawnDetail): Collection<T>
    /** Retrieves the precalculation key for the given context, if that key exists for this context. */
    fun select(ctx: SpawningContext): T?

@@ -71,7 +72,8 @@ interface SpawningPrecalculation<T : Any> {
 * @since January 31st, 2022
 */
 object RootPrecalculation : SpawningPrecalculation<Any> {
-    override fun select(detail: SpawnDetail): List<Any> = listOf(Unit)
+    val list = listOf(Unit)
+    override fun select(detail: SpawnDetail): List<Any> = list
    override fun select(ctx: SpawningContext): Any = Unit
 }

@@ -89,7 +91,15 @@ object ContextPrecalculation : SpawningPrecalculation<Class<out SpawningContext>
 object BucketPrecalculation : SpawningPrecalculation<SpawnBucket> {
    override fun select(detail: SpawnDetail) = listOf(detail.bucket)
    override fun select(ctx: SpawningContext) = ctx.cause.bucket
+}

+/**
+ * This isn't so much of a precalculation as it is a yoinking of another precalculation.
+ * Uses pre-established [SpawnDetail.validBiomes] to shortcut knowing which spawns are valid for a biome.
+ */
+object BiomePrecalculation : SpawningPrecalculation<ResourceLocation> {
+    override fun select(detail: SpawnDetail) = detail.validBiomes
+    override fun select(ctx: SpawningContext) = ctx.biomeHolder.unwrapKey().map { it.location() }.orElse(null)
 }

 /**
@@ -18,6 +18,7 @@ import net.minecraft.world.level.block.Block
 import net.minecraft.world.level.block.state.BlockState
 import net.minecraft.server.level.ServerLevel
 import net.minecraft.core.BlockPos
+import net.minecraft.core.Holder

 /**
 * A [SpawningContext] that is for a particular area, and therefore has spatial properties.
@@ -39,6 +40,7 @@ open class AreaSpawningContext(
    val slice: WorldSlice
 ) : SpawningContext() {
    val nearbyBlockTypes: List<Block> by lazy { nearbyBlocks.mapNotNull { it.block }.distinct() }
+    val nearbyBlockHolders: List<Holder<Block>> by lazy { nearbyBlockTypes.mapNotNull(blockRegistry::wrapAsHolder) }

    override fun getStructureCache(pos: BlockPos): StructureChunkCache {
        return slice.getStructureCache(pos)
@@ -11,9 +11,12 @@ package com.cobblemon.mod.common.api.spawning.context
 import com.cobblemon.mod.common.api.spawning.SpawnCause
 import com.cobblemon.mod.common.api.spawning.WorldSlice
 import com.cobblemon.mod.common.api.spawning.influence.SpawningInfluence
+import com.cobblemon.mod.common.util.blockRegistry
 import net.minecraft.core.BlockPos
+import net.minecraft.core.Holder
 import net.minecraft.server.level.ServerLevel
 import net.minecraft.tags.FluidTags
+import net.minecraft.world.level.block.Block
 import net.minecraft.world.level.block.state.BlockState

 /**
@@ -36,6 +39,7 @@ abstract class FlooredSpawningContext(
 ) : AreaSpawningContext(cause, world, position, light, skyLight, canSeeSky, influences, height, nearbyBlocks, slice) {
    /** The block that the spawning is occurring on. */
    val baseBlock = slice.getBlockState(position.x, position.y, position.z)
+    val baseBlockHolder: Holder<Block> by lazy { world.blockRegistry.wrapAsHolder(baseBlock.block) }
 }

 /**
@@ -82,7 +82,9 @@ abstract class SpawningContext {
    /** The current phase of the moon at this location. */
    val moonPhase: Int by lazy { world.moonPhase }
    /** The biome of this location. */
-    val biome: Biome by lazy { world.getBiome(position).value() }
+    val biome: Biome by lazy { biomeHolder.value() }
+    /** The registry holder for the biome this context is in. */
+    val biomeHolder: Holder<Biome> by lazy { world.getBiome(position) }

    val biomeRegistry: Registry<Biome> by lazy { world.registryAccess().registryOrThrow(Registries.BIOME) }
    val blockRegistry: Registry<Block> by lazy { world.registryAccess().registryOrThrow(Registries.BLOCK) }
@@ -13,6 +13,7 @@ import com.cobblemon.mod.common.api.Priority
 import com.cobblemon.mod.common.api.spawning.SpawnCause
 import com.cobblemon.mod.common.api.spawning.context.SpawningContext
 import net.minecraft.server.level.ServerLevel
+import net.minecraft.tags.BlockTags
 import net.minecraft.tags.FluidTags
 import net.minecraft.world.level.block.state.BlockState

@@ -29,7 +30,7 @@ import net.minecraft.world.level.block.state.BlockState
 */
 interface SpawningContextCalculator<I : SpawningContextInput, O : SpawningContext> {
    companion object {
-        val isAirCondition: (BlockState) -> Boolean = { it.isAir || (!it.isSolid && !it.fluidState.`is`(FluidTags.WATER)) }
+        val isAirCondition: (BlockState) -> Boolean = { it.isAir || (!it.isSolid && !it.fluidState.`is`(FluidTags.WATER) && !it.`is`(BlockTags.RAILS)) }
        val isSolidCondition: (BlockState) -> Boolean = { it.isSolid }
        val isWaterCondition: (BlockState) -> Boolean = { it.fluidState.`is`(FluidTags.WATER) && it.fluidState.isSource  }
        val isLavaCondition: (BlockState) -> Boolean = { it.fluidState.`is`(FluidTags.LAVA) && it.fluidState.isSource }
@@ -88,7 +88,6 @@ class PokemonSpawnDetail : SpawnDetail() {
            }
        }

-        struct.setDirectly("pokemon", pokemonStruct)
        super.autoLabel()
    }

@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.api.spawning.detail

 import com.bedrockk.molang.runtime.struct.ArrayStruct
+import com.bedrockk.molang.runtime.struct.QueryStruct
 import com.bedrockk.molang.runtime.struct.VariableStruct
 import com.bedrockk.molang.runtime.value.DoubleValue
 import com.bedrockk.molang.runtime.value.StringValue
@@ -22,6 +23,9 @@ import com.cobblemon.mod.common.api.spawning.context.SpawningContext
 import com.cobblemon.mod.common.api.spawning.multiplier.WeightMultiplier
 import com.cobblemon.mod.common.api.text.text
 import com.cobblemon.mod.common.util.asTranslated
+import net.minecraft.core.registries.Registries
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.server.MinecraftServer

 /**
 * A spawnable unit in the Best Spawner API. This is extended for any kind of entity
@@ -55,24 +59,41 @@ abstract class SpawnDetail : ModDependant {

    var labels = mutableListOf<String>()

-    val struct: VariableStruct = VariableStruct()
+    /**
+     * This is calculated when the server starts. It is a set of all biome identifiers in which this spawn
+     * is possible. It is used as part of the [com.cobblemon.mod.common.api.spawning.condition.BiomePrecalculation].
+     */
+    @Transient
+    val validBiomes = mutableSetOf<ResourceLocation>()
+
+    @Transient
+    val struct: QueryStruct = QueryStruct(hashMapOf())

    override var neededInstalledMods = listOf<String>()
    override var neededUninstalledMods = listOf<String>()

    open fun autoLabel() {
-        struct.setDirectly("weight", DoubleValue(weight.toDouble()))
-        struct.setDirectly("percentage", DoubleValue(percentage.toDouble()))
-        struct.setDirectly("id", StringValue(id))
-        struct.setDirectly("bucket", StringValue(bucket.name))
-        struct.setDirectly("width", DoubleValue(width.toDouble()))
-        struct.setDirectly("height", DoubleValue(height.toDouble()))
-        struct.setDirectly("context", StringValue(context.name))
-        struct.setDirectly("labels", ArrayStruct(labels.mapIndexed { index, s -> "$index" to StringValue(s) }.toMap()))
    }

    open fun getName() = displayName?.asTranslated() ?: id.text()

+    open fun onServerLoad(server: MinecraftServer) {
+        val biomeRegistry = server.registryAccess().registryOrThrow(Registries.BIOME)
+        validBiomes.clear()
+
+        // Calculate in advance what biomes of this world the spawn detail is valid for.
+        biomeRegistry.holders().forEach { holder ->
+            val key = holder.unwrapKey().orElse(null) ?: return@forEach
+            if (conditions.isEmpty() || conditions.any { it.biomes == null || it.biomes!!.isEmpty() || it.biomes!!.any { it.fits(holder) } }) {
+                if (anticonditions.isEmpty() || anticonditions.none { it.biomes != null && it.biomes!!.any { it.fits(holder) } }) {
+                    if (compositeCondition?.isBiomeValid(holder) != false) {
+                        validBiomes.add(key.location())
+                    }
+                }
+            }
+        }
+    }
+
    open fun isSatisfiedBy(ctx: SpawningContext): Boolean {
        if (!ctx.preFilter(this)) {
            return false
@@ -10,6 +10,7 @@ package com.cobblemon.mod.common.api.spawning.detail

 import com.cobblemon.mod.common.api.data.JsonDataRegistry
 import com.cobblemon.mod.common.api.reactive.SimpleObservable
+import com.cobblemon.mod.common.api.spawning.CobblemonSpawnPools
 import com.cobblemon.mod.common.api.spawning.SpawnLoader
 import com.cobblemon.mod.common.api.spawning.SpawnSet
 import com.cobblemon.mod.common.api.spawning.condition.PrecalculationResult
@@ -18,6 +19,7 @@ import com.cobblemon.mod.common.api.spawning.condition.SpawningPrecalculation
 import com.cobblemon.mod.common.api.spawning.context.SpawningContext
 import com.cobblemon.mod.common.api.spawning.spawner.Spawner
 import com.cobblemon.mod.common.util.cobblemonResource
+import com.cobblemon.mod.common.util.server
 import com.google.gson.Gson
 import com.google.gson.reflect.TypeToken
 import net.minecraft.resources.ResourceLocation
@@ -48,6 +50,10 @@ class SpawnPool(val name: String) : JsonDataRegistry<SpawnSet>, Iterable<SpawnDe
        for (set in data.values) {
            details.addAll(set.filter { it.isValid() })
        }
+        val server = server()
+        if (server != null && server.isRunning) {
+            CobblemonSpawnPools.onServerLoad(server)
+        }
        precalculate()
    }

@@ -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())
        }
@@ -1,51 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.api.spawning.influence
-
-import com.cobblemon.mod.common.api.spawning.context.SpawningContext
-import com.cobblemon.mod.common.api.spawning.detail.SpawnDetail
-import net.minecraft.tags.BlockTags
-
-/**
- * Implements a [SpawningInfluence] that prevents Pokémon spawning on certain blocks.
- * This ensures that Pokémon don't spawn in areas that could disrupt player-built structures or mechanisms.
- * The influence checks the block directly above the potential spawn location; if the block is in the restricted list,
- * the spawn is disallowed.
- *
- * @author Aethen
- * @since February 20th, 2024
- */
-open class RestrictedSpawnBlocksInfluence
-    : SpawningInfluence {
-
-    // The list of blocks that Pokémon are not allowed to spawn on.
-    private val restrictedBlocks = BlockTags.RAILS
-
-
-
-    /**
-     * Affects the spawnable status of a Pokémon spawn detail.
-     * If the block directly above the spawn location is in the restricted list, the spawn is disallowed.
-     *
-     * @param detail The Pokémon spawn detail to be affected.
-     * @param ctx The context of the spawning event.
-     * @return `true` if the spawn is allowed, `false` if it is disallowed.
-     */
-    override fun affectSpawnable(detail: SpawnDetail, ctx: SpawningContext): Boolean {
-        // If the spawn detail is not a Pokémon, it is not affected by this influence.
-        if (detail.type != "pokemon") return true
-
-        // Get the position of the potential spawn location.
-        val pokemonSpawnPos = ctx.position
-
-        // Examine the block immediately above the spawn block to check for a rail
-        // Potentially need a refactor if we ever want to check the spawn block itself.
-        return ctx.world.getBlockState(pokemonSpawnPos.atY(pokemonSpawnPos.y + 1)).`is`(restrictedBlocks).not()
-    }
-}
@@ -14,7 +14,6 @@ import com.cobblemon.mod.common.api.spawning.SpawnerManager
 import com.cobblemon.mod.common.api.spawning.detail.SpawnPool
 import com.cobblemon.mod.common.api.spawning.influence.PlayerLevelRangeInfluence
 import com.cobblemon.mod.common.api.spawning.influence.PlayerLevelRangeInfluence.Companion.TYPICAL_VARIATION
-import com.cobblemon.mod.common.api.spawning.influence.RestrictedSpawnBlocksInfluence
 import com.cobblemon.mod.common.api.spawning.influence.SpawningInfluence
 import com.cobblemon.mod.common.api.spawning.rules.SpawnRule
 import com.cobblemon.mod.common.util.mutableLazy
@@ -45,7 +44,7 @@ object PlayerSpawnerFactory {
            it,
            variation = TYPICAL_VARIATION
        )
-    }, { RestrictedSpawnBlocksInfluence() })
+    })

    fun create(spawnerManager: SpawnerManager, player: ServerPlayer): PlayerSpawner {
        val influences = influenceBuilders.mapNotNull { it(player) }
@@ -45,9 +45,9 @@ open class BottomlessStore(override val uuid: UUID) : PokemonStore<BottomlessPos
    override fun initialize() {
        pokemon.forEachIndexed { index, pokemon ->
            pokemon.storeCoordinates.set(StoreCoordinates(this, BottomlessPosition(index)))
-            pokemon.getChangeObservable().pipe(
-                stopAfter { it.storeCoordinates.get()?.store != this }
-            ).subscribe { storeChangeObservable.emit(Unit) }
+//            pokemon.getChangeObservable().pipe(
+//                stopAfter { it.storeCoordinates.get()?.store != this }
+//            ).subscribe { storeChangeObservable.emit(Unit) }
        }
    }

@@ -98,6 +98,10 @@ open class BottomlessStore(override val uuid: UUID) : PokemonStore<BottomlessPos

    override fun getAnyChangeObservable() = storeChangeObservable

+    override fun onPokemonChange(pokemon: Pokemon) {
+        this.storeChangeObservable.emit(Unit)
+    }
+
    override fun setAtPosition(position: BottomlessPosition, pokemon: Pokemon?) {
        if (position.currentIndex == this.pokemon.size && pokemon != null) {
            this.pokemon.add(pokemon)
@@ -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)
@@ -162,4 +168,6 @@ abstract class PokemonStore<T : StorePosition> : Iterable<Pokemon> {
     * each change, accessed by [Pokemon.getChangeObservable].
     */
    abstract fun getAnyChangeObservable(): Observable<Unit>
+
+    abstract fun onPokemonChange(pokemon: Pokemon)
 }
@@ -73,9 +73,13 @@ open class PartyStore(override val uuid: UUID) : PokemonStore<PartyPosition>() {
    }

    fun trackPokemon(pokemon: Pokemon) {
-        pokemon.getChangeObservable()
-            .pipe(stopAfter { pokemon.storeCoordinates.get()?.store != this })
-            .subscribe { anyChangeObservable.emit(Unit) }
+//        pokemon.getChangeObservable()
+//            .pipe(stopAfter { pokemon.storeCoordinates.get()?.store != this })
+//            .subscribe { anyChangeObservable.emit(Unit) }
+    }
+
+    override fun onPokemonChange(pokemon: Pokemon) {
+        anyChangeObservable.emit(Unit)
    }

    override fun getFirstAvailablePosition(): PartyPosition? {
@@ -89,14 +89,14 @@ open class PCBox(val pc: PCStore) : Iterable<Pokemon> {
    }

    fun trackPokemon(pokemon: Pokemon) {
-        pokemon.getChangeObservable()
-            .pipe(
-                stopAfter {
-                    val coordinates = it.storeCoordinates.get() ?: return@stopAfter true
-                    return@stopAfter coordinates.store !is PCStore || coordinates.store.uuid != pc.uuid || (coordinates.position as PCPosition).box != boxNumber
-                }
-            )
-            .subscribe { boxChangeEmitter.emit(Unit) }
+//        pokemon.getChangeObservable()
+//            .pipe(
+//                stopAfter {
+//                    val coordinates = it.storeCoordinates.get() ?: return@stopAfter true
+//                    return@stopAfter coordinates.store !is PCStore || coordinates.store.uuid != pc.uuid || (coordinates.position as PCPosition).box != boxNumber
+//                }
+//            )
+//            .subscribe { boxChangeEmitter.emit(Unit) }
    }

    fun sendTo(player: ServerPlayer) {
@@ -250,6 +250,10 @@ open class PCStore(
        }
    }

+    override fun onPokemonChange(pokemon: Pokemon) {
+        this.pcChangeObservable.emit(Unit)
+    }
+
    fun clearPC() {
        boxes.forEach { box ->
            box.getNonEmptySlots().forEach{
@@ -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
                }
--- a/Show More
+++ b/Show More