Changelog [skip-ci]

Wobbuffix (and charcadet)

See merge request cable-mc/cobblemon!1500

.gitlab-ci.yml

@@ -3,23 +3,155 @@ image: amazoncorretto:21
 before_script:
   - export GRADLE_USER_HOME=`pwd`/.gradle
 
+# TODO add client reference test process, search for import com.cobblemon.mod.common.client
+
 stages:
+  - preprocessing
+  - packsquash
+  - replaceresources
   - build
   - deploy
 
-#TODO add client reference test process, search for import com.cobblemon.mod.common.client
+check_assets_cache:
+  stage: preprocessing
+  script:
+    - echo "Checking if cached hash matches current hash"
+
+    # Calculate the current hash
+    - find common/src/main/resources/assets common/src/main/resources/data -type f -exec sha256sum {} + | sort -k 2 | sha256sum > current_hash.txt
+    - echo "Current hash:"
+    - cat current_hash.txt
+
+    # Check for the existence of the previous hash
+    - if [[ -f assets_data_hash.txt ]]; then
+      echo "Previous cached hash found:";
+      cat assets_data_hash.txt;
+      if cmp -s assets_data_hash.txt current_hash.txt; then
+      echo "Hashes match, skipping PackSquash";
+      rm -f run_packsquash.flag || true;
+      else
+      echo "Hashes differ, PackSquash needed";
+      touch run_packsquash.flag;
+      fi;
+      else
+      echo "No cached hash found, marking PackSquash as required";
+      touch run_packsquash.flag;
+      fi
+
+    # Save the current hash for future runs
+    - echo "Saving current hash to cache";
+    - cp current_hash.txt assets_data_hash.txt
+  artifacts:
+    paths:
+      - current_hash.txt
+      - assets_data_hash.txt
+      - run_packsquash.flag
+    expire_in: 7 days
+  cache:
+    key: "cache-${CI_COMMIT_REF_NAME}"
+    paths:
+      - assets_data_hash.txt
+      - ./compressed_pack.zip
+
+setup_resource_pack:
+  stage: preprocessing
+  script:
+    - echo "Setting up fake resource pack"
+    - mkdir ./fake_resource_pack
+    - cp -r common/src/main/resources/assets common/src/main/resources/data ./fake_resource_pack/
+    - echo '{"pack":{"pack_format":34,"description":"Fake Cobblemon Pack"}}' > ./fake_resource_pack/pack.mcmeta
+  artifacts:
+    paths:
+      - ./fake_resource_pack/
+    expire_in: 7 days
+
+setup_packsquash:
+  stage: preprocessing
+  script:
+    - echo "Installing wget & unzip"
+    - yum install -y wget unzip
+    - echo "Downloading PackSquash"
+    - wget https://github.com/ComunidadAylas/PackSquash/releases/download/v0.4.0/PackSquash.CLI.executable.x86_64-unknown-linux-musl.zip
+    - unzip PackSquash.CLI.executable.x86_64-unknown-linux-musl.zip -d ./packsquash_bin
+    - echo "Creating PackSquash options.toml"
+    - |
+      cat <<EOF > ./options.toml
+      pack_directory = "./fake_resource_pack/"
+      output_file_path = "./compressed_pack.zip"
+      zip_spec_conformance_level = "high"
+      ['**/*?.ogg']
+      transcode_ogg = false
+      two_pass_vorbis_optimization_and_validation = false
+      sampling_frequency = 999999
+      empty_audio_optimization=false
+      EOF
+  artifacts:
+    paths:
+      - ./packsquash_bin/
+      - ./options.toml
+    expire_in: 7 days
+
+default:
+  artifacts:
+    expire_in: 7 days
+
+run_packsquash:
+  stage: packsquash
+  dependencies:
+    - check_assets_cache
+    - setup_resource_pack
+    - setup_packsquash
+  script:
+    - ls -l
+    - if [[ ! -f ./compressed_pack.zip || -f run_packsquash.flag ]]; then
+      echo "Running PackSquash";
+      chmod +x ./packsquash_bin/packsquash;
+      ./packsquash_bin/packsquash ./options.toml;
+      else
+      echo "Skipping PackSquash; no changes detected and compressed pack exists";
+      fi
+  cache:
+    key: "cache-${CI_COMMIT_REF_NAME}"
+    policy: pull-push
+    paths:
+      - assets_data_hash.txt
+      - ./compressed_pack.zip
+  artifacts:
+    paths:
+      - ./compressed_pack.zip
+
+replace_resources:
+  stage: replaceresources
+  dependencies:
+    - run_packsquash
+  script:
+    - echo "Installing unzip"
+    - yum install -y unzip
+
+    - echo "Unzipping compressed pack"
+    - mkdir temp_unpack
+    - unzip ./compressed_pack.zip -d temp_unpack
+
+    - echo "Removing original assets and data"
+    - rm -rf common/src/main/resources/assets
+    - rm -rf common/src/main/resources/data
+
+    - echo "Replacing assets and data"
+    - mv temp_unpack/assets common/src/main/resources/
+    - mv temp_unpack/data common/src/main/resources/
+  artifacts:
+    paths:
+      - common/src/main/resources/
 
 build:
   stage: build
-  only:
-    - branches@cable-mc/cobblemon
+  dependencies:
+    - replace_resources
   script:
     - export GRADLE_OPTS="-Xmx4G -Xms4G"
     - chmod +x ./gradlew
     - ./gradlew build
-  cache:
-    key: "$CI_COMMIT_REF_NAME"
-    policy: push
+  artifacts:
     paths:
       - neoforge/build/libs
       - fabric/build/libs
@@ -28,39 +160,26 @@ publish:
   stage: deploy
   dependencies:
     - build
-  cache:
-    key: "CI_COMMIT_REF_NAME"
-    policy: pull
-    paths:
-      - neoforge/build/libs/*.jar
-      - fabric/build/libs/*.jar
   rules:
-    - if: '$CI_COMMIT_BRANCH == "main"'
+    - if: '$CI_PROJECT_PATH == "cable-mc/cobblemon" && $CI_COMMIT_BRANCH == "main"'
   script:
     - export GRADLE_OPTS="-Xmx4G -Xms4G"
     - chmod +x ./gradlew
     - ./gradlew publish
-
-# Separate step to deploy the artifacts, save Norry the headache of keeping even more shit around
-deploy:
-  stage: deploy
-  dependencies:
-    - build
-  when: manual
-  cache:
-    key: "$CI_COMMIT_REF_NAME"
-    policy: pull
+  artifacts:
     paths:
       - neoforge/build/libs/*.jar
       - fabric/build/libs/*.jar
-  script: 
+
+deploy_artifacts:
+  stage: deploy
+  dependencies:
+    - build
+  script:
     - echo "Collecting artifacts..."
-    - mv neoforge/build/libs/*+*.jar ./
-    - mv fabric/build/libs/*+*.jar ./
+    - find neoforge/build/libs/ -type f -name "*.jar" | grep -vE "dev-shadow|sources|javadoc" | xargs -I {} mv {} ./
+    - find fabric/build/libs/ -type f -name "*.jar" | grep -vE "dev-shadow|sources|javadoc" | xargs -I {} mv {} ./
     - for f in *.jar; do mv "$f" "$(echo "$f" | sed s/+/b$CI_PIPELINE_IID+/)"; done
   artifacts:
-    expire_in: 28 days
     paths:
       - ./*.jar
-#      - neoforge/build/libs/*+*.jar
-#      - fabric/build/libs/*+*.jar

CHANGELOG.md

@@ -1,62 +1,259 @@
 # Changelog
-## [1.6.0 - The Record Catch Update (Month Xth, 2024)](#1-6-0)
+## [1.6.1 (January 26th, 2025)](#1-6-1)
+
+### Additions
+- Added crossover paintings from Close Combat: Premonition, Altar, Slumber, and Nomad.
+- Added Galarica Nuts, used for crafting Galarica Cuffs and Wreaths. Dropped from certain Pokémon. Take a wild guess which.
+- Added compatibility with Repurposed Structures. (Thank you, TelepathicGrunt!)
+- Added an evolution method for Karrablast to evolve into Escavalier in singleplayer.
+- Pokédexes can now be placed in Chiseled Bookshelves.
+- Added optional box argument to the /pc command.
+- Pokédex and Dialogue screens now close when the inventory keybind is pressed.
+- Added config setting `maxPokedexScanningDetectionRange` to control from what distance the player can scan Pokémon using the Pokédex.
+- Added config setting `hideUnimplementedPokemonInThePokedex` which hides unimplemented Pokémon from the Pokédex when set to true. 
+- Added debug renderer for posable entity locators.
+
+### Pokémon Added
+
+#### Gen 5
+- Ducklett
+- Swanna
+- Shelmet
+- Accelgor
+- Karrablast
+- Escavalier
+- Rufflet
+- Braviary
+- Foongus
+- Amoonguss
+
+#### Gen 6
+- Binacle
+- Barbaracle
+
+#### Gen 7
+- Dewpider
+- Araquanid
+- Alolan Geodude
+- Alolan Graveler
+- Alolan Golem
+
+#### Gen 8
+- Galarian Slowpoke
+- Galarian Slowbro
+- Galarian Slowking
+
+#### Gen 9
+- Paldean Tauros
+
+### Added cries to the following Pokémon
+- All Nidorans
+- Shellder, Cloyster
+- Pinsir
+- Tyrogue, Hitmontop
+- Spinda
+
+### Animation updates for the following Pokémon
+- Primeape
+- Munchlax
+- Snorlax
+- Poliwrath
+- Goldeen
+- Seaking
+- Dondozo
+- Wobbuffet
+- Charcadet
+- Armarouge
+- Ceruledge
+- Geodude
+- Graveler
+- Golem
+- Sandile
+- Krokorok
+- Krookodile
+
+### Model updates for the following Pokémon
+- Slowpoke
+- Slowbro
+- Slowking
+- Eiscue
+- Tauros
+- Goldeen
+- Seaking
+- Charcadet
+- Armarouge
+- Ceruledge
+- Pinsir
+- Geodude
+- Graveler
+- Golem
+
+### Cry updates for the following Pokémon
+- Sceptile
+
+### Changes
+- Completely re-synced Pokémon move and stat data based on later games. Learnsets have changed considerably to maximise available moves.
+- Pokémon will now be dynamically revealed to the Pokédex as they're seen in battle instead of revealing entire parties at the end of battle.
+- Unseen wild Pokémon will update their name from '???' to their real name as soon as a battle starts to match how the battle UI shows the actual species name.
+- Pokémon under the illusion effect will reveal their disguise to the Pokédex first and then the base Pokémon once the disguise is broken.
+- Berries will now drop from berry trees if broken at age 0 so you aren't punished for mistaken planting.
+- Increased Fortune drops on Mint Seeds.
+- Updated Slowpoke's shiny texture.
+- Updated drops for many Pokémon.
+- Adjusted the evolution sound to match the timing of the particle effect.
+- Made berry trees shear-able by dispenser blocks. I'm sure nobody will make unholy contraptions with this.
+- Edited some recipes to utilize tags instead of direct item IDs, for better mod compatibility.
+- Added more support for a variety of Fabric/NeoForge conventional tags.
+- Reformatted some tags to be more consistent.
+
+### Fixes
+- Fixed Pokédex sometimes crashing when switching forms.
+- Fixed Pokédex interface not transitioning out when closed.
+- Fixed texture dimensions for the player and Pokémon interact interface.
+- Fixed crash related to Tom's Simple Storage mod and the Fossil Machine.
+- Fixed not being able to retrieve a fossil from the Fossil Machine with an empty hand.
+- Fixed Pokémon being collidable (collidible? collissionable? kaleidoscopable?) while being captured by a Poké Ball.
+- Fixed `full_party`, `own_zangoose_seviper`, `use_revive` and `use_candy` Advancement triggers.
+- Fixed `healing_machine` Advancement by using the correct 1.21 trigger.
+- Fix Display Cases not dropping items if destroyed through explosions.
+- Fixed an issue where the first Pokémon in the pastured Pokémon list clipped into the interface.
+- Fixed all Pokémon facing South on spawn.
+- Fixed bait being consumed even when not reeling in any Pokémon.
+- Fixed Miltank milk magically disappearing out of your bucket.
+- Fixed Pokémon nicknames migrating from 1.5.2 not being displayed properly.
+- Fixed capitalization in one of our config options. It was a very important fix. Very important. Old configs are fine.
+- Fixed Poké Rods not working if Lure or Luck of the Sea enchantments get removed by other mods.
+- Fixed crashes related to Pokémon when they are ready to evolve while holding an enchanted item. Very specific.
+- Fixed a crash that sometimes occurred when evolving Nincada.
+- Fixed Cobblemon plants not being compostable on NeoForge.
+- Fixed hide UI (F1 key) not hiding the party overlay.
+- Fixed NPC MoLang command `player_lose_command` not working.
+- Fixed misaligned tooltips with edit boxes in the NPC editor screen.
+- Fixed Pokémon riding two boats when attempting to deploy a platform on water.
+- Fixed the summary screen showing there's experience to reach the next level when they are at the level cap.
+- Fixed Pokémon forgetting moves when evolving on specific cases.
+- Fixed Adorn compatibility, including improvements when using JEI/REI (Apricorn items now show up under the collapsed entries rather than standalone).
+- Fixed error message appearing on battle log when using Solar Beam with Sunny Day.
+- Fixed Pokémon Model offsets for larger species.
+- Fixed `/pokedex grant all` command not giving male/female/shininess completion for some Pokémon.
+- Fixed `/pokedex grant only` and `/pokedex remove only` not respecting the form parameter passed.
+- Fixed variant forms appearing incorrectly in the Pokédex when the normal form had not been unlocked.
+- Fixed Pokémon occasionally being shot into the sky during battle. No Pokémon were harmed by this bug, probably.
+- Fixed NPC editing GUI not updating aspects until a game restart.
+- Fixed some users being unable to open their PC if a Pokémon in it had a lot of PP raises beyond normal bounds. How did you get those, anyway? Tell me or the Bellossom gets it.
+- Fixed some color variants (Dubwool, Conkeldurr and Undyed wooloo) being missing in the Pokédex.
+- Fixed invalid species or held items causing Players to not be able to load into their world anymore (commonly happening after removing addons/mods).
+- Fixed Wooloo variants not being automatically registered in the owner's Pokédex when dyed.
+- Fixed Vivichoke Dip and Leek & Potato Stew not returning a bowl upon consumption.
+- Fixed Fossil Restoration Tank not accepting Hay Bales as organic material.
+- Fixed Potion items applying double their intended healing value.
+- Fixed Fast Ball capture bonuses applying to all Pokémon, making it the Best Ball instead of the Mediocre Edge-Case Ball. 
+- Fixed "learned new move" messages appearing for already-known moves on Pokémon evolutions.
+- Fixed Pokémon Item Models breaking shadows nearby when being placed in Display Cases or Item Frames.
+- Fixed berries not giving bonus yields when planted in their preferred biomes. I'm sure we've fixed that 5 times now.
+- Fixed the NeoForge version not supporting "SodiumDynamicLights".
+- Fixed players disconnecting from servers if they made changes to certain config options.
+- Fixed players with shouldered Pokémon not being able to rejoin their 1.5.2 worlds using 1.6.
+- Fixed `PokemonProperties` utilizing `ability=<some ability>` being treated as a forced ability even when it is a legal ability for the Pokémon.
+- Fixed type formatting in Pokédex scanner mode when dual types require two lines.
+- Fixed trading sometimes crashing the game or server. 
+- Fixed Wild shiny sounds not respecting the `shinyNoticeParticlesDistance` config setting.
+- Fixed Pokémon being able to evolve mid-battle.
+- Fixed NPC held items being able to be stolen by players. Don't be a thief!
+- Fixed evolutions that require a held item consuming it as soon as meeting requirements when it should only be consumed upon evolution.
+- Fixed Pokémon showing only the default form when selecting them as a target in battle.
+- Fixed a possible error coming out of reeling fishing rods in specific situations.
+- Fixed incorrect weights being used when Poké Fishing with Luck of the Sea.
+- Parametric particle motion now works.
+- Event-spawned particles now work.
+- Particles can now have independent coordinate spaces.
+
+### Developer
+- Updated the Pokédex data updated events to always include a `Pokemon` instance, and optionally a `DisguiseData` instance.
+- Updated fields in `SpawnNPCPacket` and `SpawnPokemonPacket` to be visible and mutable.
+- Updated `UnvalidatedPlaySoundS2CPacket` to be public instead of internal and made its fields mutable.
+- Added `hideNameTag` field and `HideNPCNameTag` nbt tag to `NPCEntity` to allow hiding the name tag of the NPC.
+- Added the player to `PokerodReelEvent` so you know who is doing the reeling.
+
+### MoLang & Datapacks  
+- Added flows for:
+  - `forme_change`: Triggered when a Pokémon changes form in battle.
+  - `mega_evolution`: Triggered when a Pokémon mega evolves in battle. (Note: Third-party mods are required for this feature currently)
+  - `zpower_used`: Triggered when a Pokémon uses a Z-Power move in battle. (Note: Third-party mods are required for this feature currently)
+  - `terastallization`: Triggered when a Pokémon terastallizes in battle. (Note: Third-party mods are required for this feature currently)
+  - `battle_fainted`: Triggered when a Pokémon faints in battle.
+  - `battle_fled`: Triggered when a player flees from battle.
+  - `battle_started_pre`: Triggered when a battle starts. Cancelable!
+  - `battle_started_post`: Triggered when a battle starts.
+  - `apricorn_harvested`: Triggered when an Apricorn is harvested.
+  - `thrown_pokeball_hit`: Triggered when a thrown Pokéball hits a Pokémon.
+  - `level_up`: Triggered when a Pokémon levels up.
+  - `pokemon_fainted`: Triggered when a Pokémon faints.
+  - `pokemon_gained`: Triggered when a player gains a Pokémon.
+- Added MoLang functions:
+  - For Pokémon:
+    - `pokemon.apply(PokemonProperties)`: Applies the given properties to the Pokémon.
+    - `pokemon.owner`: Returns the owner of the Pokémon or 0.0 if there is no owner or they are not online.
+  - For all entities:
+    - `entity.is_standing_on_blocks(depth, blocks...)`: Returns whether the specified entity is standing on a specific block or set of blocks. Example usage: `q.is_standing_on_blocks(2, minecraft:sand)`
+- Added NPC field:
+  - `hideNameTag`: Hides the name tag of the NPC.
+  - Added `baseScale` property to NPCs.
+- Added MoLang particle queries for getting distance to targeted entities.
+
+## [1.6.0 - The Record Catch Update (December 25th, 2024)](#1-6-0)
 #### "Now that there's a fishing mechanic, the mod is actually good!"
 
 ### Additions
 - Added the Pokédex as a craftable item that can be placed on lecterns.
-- Added Pokémon (and item) fishing using modified fishing rods - Poké Rods! You'll need a Poké Rod smithing template, a fishing rod, and some type of Poké Ball. Each Poké Ball makes a differently themed rod. Why not?
+- Added Pokémon (and item) fishing using modified fishing rods - Poké Rods! You'll need a Poké Rod smithing template, a fishing rod, and some type of Poké Ball. Each Poké Ball makes a differently themed rod because it's cool.
 - Added Lure Ball functionality, increasing the catch rate of Pokémon that were caught on a fishing rod.
 - Added Repeat Ball functionality, increasing the catch rate of Pokémon that are already registered as caught in a player's Pokédex.
-- Added property chaining support for duplicate CustomPokemonPropertyType elements.
 - Added flat level battling with options to set all Pokémon to level 50, 100, or 5 for the duration of a battle. No experience or EVs are granted for a flat battle.
-- Added `aspect` and `unaspect` PokemonProperty arguments (which also includes commands such as `/pokemonedit`, `/spawnpokemon`, and `/givepokemon`) to allow forcing or un-forcing an aspect on a Pokémon.
-- Added `type` alternatively `elemental_type` PokemonProperty argument, this is only used for filtering and is not applied to Pokémon. Example `type=fire` would be true for Charmander but false for Squirtle.
 - Added support for Double Battles, Triple Battles, and Multi-battles.
+- Added raft platforms for non-swimming, non-flying Pokémon to stand on during battles that take place on the water's surface (Flying Pokémon will fly over water in battle, and water breathing Pokémon will swim in water during battle).
+- Added smarter send-out positions for Pokémon in battle. They should get in your way less!
 - CriticalCaptures and Pokédex progress capture multiplier now work with the Pokédex.
-- Added extra visuals to early berry growth stages.
-- Moves impacted by the abilities Pixelate, Refrigerate, Aerilate, Galvanize, and Normalize now display as their altered typing.
-- Added Polished Tumblestone and Tumblestone Brick block sets from Tumblestone, Black Tumblestone, and Sky Tumblestone.
-- Added Metronome, Protective Pads, Punching Glove, Room Service, Scope Lens, Shed Shell, Terrain Extender, Throat Spray, Utility Umbrella, Wide Lens, and Zoom Lens held items
-- Added particles for moves: Watersport, Mud Sport, and Psychic.
-- Added Fire, Water, Thunder, Leaf, Ice, Sun, Moon, Shiny, Dawn, and Dusk Stone storage blocks.
-- Added Eject Pack, Metronome, Protective Pads, Punching Glove, Room Service, Scope Lens, Shed Shell, Terrain Extender, Throat Spray, Utility Umbrella, Wide Lens, and Zoom Lens held items
-- Added `stonjourner_henge_ruins`, `luna_henge_ruins`, and `sol_henge_ruins` structures.
-- Added a `battleInvulnerability` gamerule to make players invulnerable to any damage during a battle.
-- Added a `mobTargetInBattle` gamerule to exclude players from being targeted by mobs during a battle.
-- Added battle log messages for switching out Pokémon.
-- Added Evolution particles and sounds for Pokémon that are sent out when evolution is started.
-- Added a Nurse profession that can be unlocked by having villagers claim a healing machine block.
-- Added Pokémon Centers to all 5 village types.
-- Added a `natural` block state property for the healing machine block; when property is set to true, the block will have a different texture and drop an iron ingot instead of itself.
-- New config setting `displayEntityNameLabel` and `displayEntityLabelsWhenCrouchingOnly` to control what and when is displayed for the pokemon label
-- `/freezepokemon` command to pause a Pokémon's animation at a specific point in time.
-- Added `no_ai` and `freeze_frame` options to the `/spawnpokemon` command.
-- Added shiny Pokémon effects.
-- Added effects for the burn status effect.
-- Added effects for the moves: Psychic, Water Sport, and Mud Sport.
-- Added a new universal locator called `top`.
-- Added `moves` option to Pokémon properties, allowing you to set the moves of a Pokémon in commands and spawn files using comma-separated move names.
-- Added shiny Pokémon effects.
+- Added shiny Pokémon particle effects and sounds to help find them.
 - Added effects for the burn status effect.
 - Added effects for the moves: Seismic Toss, Withdraw, Bite, Crunch, Super Fang, Hyper Fang, Pursuit, Mist, Haze, Lick, Kinesis, Psychic, Water Sport, and Mud Sport.
-- Added a new universal locator called `top`.
-- Added shiny Pokémon particles with sound effects.
+- Added extra visuals to early berry growth stages.
+- Added Polished Tumblestone and Tumblestone Brick block sets from Tumblestone, Black Tumblestone, and Sky Tumblestone.
+- Moves impacted by the abilities Pixelate, Refrigerate, Aerilate, Galvanize, and Normalize now display as their altered typing.
+- Added Fire, Water, Thunder, Leaf, Ice, Sun, Moon, Shiny, Dawn, and Dusk Stone storage blocks.
+- Added Eject Pack, Metronome, Protective Pads, Punching Glove, Room Service, Scope Lens, Shed Shell, Terrain Extender, Throat Spray, Utility Umbrella, Wide Lens, and Zoom Lens held items.
+- Added a full evolution particle effect for Pokémon that are sent out when evolution is started.
+- Added a Nurse profession that can be unlocked by having villagers claim a healing machine block.
+- Pokémon are now animated when seen in any GUI that isn't the party GUI.
 - Added animation and sounds for trading.
 - Added icons for pending trade, team-up, and battle requests from other players.
-- Added `/spawnnpc` and `/spawnnpcat` commands.
-- Pokémon are now animated when seen in any GUI that isn't the party GUI.
 - Quirk animations can now occur for Pokémon that are shoulder mounted.
-- Added `fishing boat` structures that contain an Explorer Map leading to a shipwreck cove and a Poké Rod Smithing Template.
-- Added `submerged_shipwreck_cove` and `lush_shipwreck_cove` structures.
 - Added new sounds for Poké Balls bouncing off of Pokémon and landing on the ground during capture.
 - Added a unique set of sounds for Ancient Poké Balls.
 - Added a sound for using Exp Candy and Rare Candy items.
-- Added raft platforms for non-swimming, non-flying Pokémon to stand on during battles that take place on the water's surface. (Flying Pokémon will fly over water in battle, and water breathing Pokémon will swim in water during battle.)
+- Added revamped Poké Ball animation for Pokémon breaking out.
+- Added battle log messages for switching out Pokémon.
+- Added config setting `displayEntityNameLabel` and `displayEntityLabelsWhenCrouchingOnly` to control what and when is displayed for the pokemon label.
+- Added `no_ai` and `freeze_frame` options to the `/spawnpokemon` command.
+- Added `moves` option to Pokémon properties, allowing you to set the moves of a Pokémon in commands and spawn files using comma-separated move names.
+- Added a `natural` block state property for the healing machine block; when property is set to true, the block will have a different texture and drop an iron ingot instead of itself.
+- Added a `battleInvulnerability` gamerule to make players invulnerable to any damage during a battle.
+- Added a `mobTargetInBattle` gamerule to exclude players from being targeted by mobs during a battle.
+- Added a `/freezepokemon` command to pause a Pokémon's animation at a specific point in time.
+- Added `/spawnnpc` and `/spawnnpcat` commands.
 - Added `hiddenability=false` option to `/spawnpokemon` and `/pokemonedit` commands, allowing the Pokémon's ability to be reverted to a normal ability.
+- Added `aspect` and `unaspect` PokemonProperty arguments (which also includes commands such as `/pokemonedit`, `/spawnpokemon`, and `/givepokemon`) to allow forcing or un-forcing an aspect on a Pokémon.
+- Added `type` alternatively `elemental_type` PokemonProperty argument, this is only used for filtering and is not applied to Pokémon. Example `type=fire` would be true for Charmander but false for Squirtle.
 
+### Structures Added
+- Fishing boat structure that contain an Explorer Map leading to a shipwreck cove and a Poké Rod Smithing Template.
+- Stonjourner Henge Ruins, Luna Henge Ruins, and Sol Henge Ruins.
+- Submerged Shipwreck Cove and Lush Shipwreck Cove.
+- Pokémon Centers to all 5 village types.
+ 
 ### Pokémon Added
 #### Gen 1
-- Alola Bias Cubone
+- Alola Bias Cubone (built-in resource pack)
 - Alolan Marowak
 
 #### Gen 2
@@ -71,6 +268,7 @@
 - Octillery
 - Mantine
 - Smeargle
+- Delibird
 
 #### Gen 3
 - Slakoth
@@ -128,9 +326,6 @@
 #### Gen 9
 - Wattrel
 - Kilowattrel
-- Wiglett
-- Wugtrio
-- Flamigo
 - Veluza
 - Farigiraf
 - Klawf
@@ -142,8 +337,8 @@
 - Dondozo
 
 #### Unique Forms
-- Magikarp Jump Variants
-- Gyarados Jump Variants
+- Magikarp Jump variants for Magikarp
+- Magikarp Jump variants for Gyarados (built-in resource pack, enabled by default on Fabric)
 
 ### Added cries to the following Pokémon
 - Sandshrew, Sandslash
@@ -250,6 +445,7 @@
 ### Model updates for the following Pokémon
 - Bulbasaur, Ivysaur, Venusaur
 - Charmander, Charmeleon, Charizard
+- Caterpie
 - Kakuna, Beedrill
 - Lapras
 - Porygon, Porygon2, Porygon-Z
@@ -285,9 +481,11 @@
 - Phantump, Trevenant
 - Litten, Torracat, Incineroar
 - Popplio, Brionne, Primarina
+- Mudbray
 - Lurantis
 - Scorbunny, Cinderace
 - Quaxly
+- Skeledirge
 - Tatsugiri
 
 ### Changes
@@ -297,43 +495,37 @@
 - Adjusted volumes of sounds made by Display Cases, Berry Bushes, Energy Root, Medicinal Leek, Vivichoke, Mints, Revival Herbs and Gilded Chests.
 - Changes to mulch buffs/durations.
 - Updated potion sprites.
-- Link Cable recipe has been redesigned.
+- Changed Link Cable recipe to be much cheaper.
 - Updated sounds for Medicinal Leeks, Big Roots, Energy Roots and Revival Herbs.
 - Updated UI sounds for clicking and evolving Pokémon.
 - Updated cries for Chansey, Crobat, Hoothoot, Noctowl.
 - Removed the interchangeable evolution results for the first stage Hisuian starters to prevent confusion. The method still exists for stage 2 to 3, but stage 1 to 2 was not distinguishable enough for many users.
-- Bulbasaur, Ivysaur, Venusaur, Kakuna, Beedrill, Snorlax, Munchlax, Krabby, Kingler, Lurantis, Horsea, Seadra, Kingdra, Litten, Torracat, Incineroar, Mudkip, Marshtomp, Swampert, Scorbunny, Cinderace, Prinplup, Empoleon, Relicanth, Goldeen, Seaking, Shellder, Cloyster, Tatsugiri, Igglybuff, Jigglypuff, Wigglytuff, Krookodile, Gible, Gabite, Garchomp, Rhyhorn, Rhydon, Rhyperior, and Carvanha received model updates.
 - Vivillon wings will stop being clear when you remove any Vivillon related resourcepacks. The default pattern will be the meadow wings.
-- Adjusted Pokémon sendout positions for single battles.
 - Wild Pokémon interaction range increased to 12 blocks (from 10 blocks).
 - Player trade range increased to 12 blocks (from 10 blocks).
 - PvP battle range increased to 32 blocks (from 10 blocks).
 - Spectate range increased to 64 blocks (from 10 blocks).
 - The inventory key now closes our GUIs if they are open, mirroring how Minecraft screens usually work.
 - The noise from the pasture and PC blocks being interacted with now activates Sculk sensors.
-- Updated dialogue GUI assets with proper assets.
+- Updated dialogue GUI assets with proper assets not made by a programmer. Well, it was still a programmer, but- someone who can also draw!
 - Updated party switching interface when in battle.
 - Relic coin pouches can now be waterlogged.
-- Pokémon name and level labels are now only visible when crouching by default. Set the `displayEntityLabelsWhenCrouchingOnly` config to `false` to always have them displayed.
-- The "Press R to start battle prompt" will now disappear after a player's first battle has been won.
-- The default number of digits for the Pokédex number in the summary has been increased, from 3 to 4.
+- The "Press R to start battle prompt" will now disappear after a player's first battle has been won. You've probably figured that detail out by then.
+- The default number of digits for the Pokédex number in the summary has been increased, from 3 to 4. There sure are a lot of Pokémon these days.
 - The pasture block model's screen is now off by default.
 - The Poké Balls creative tab is now named Utility Items as it also encompasses Poké Rod and Pokédex items.
 - Moves can now be benched without specifying a replacement move, allowing for empty move slots.
 - Moves learned via Sketch now persist after battle.
-- Updated potion sprites
-- Removed the interchangeable evolution results for the first stage Hisuian starters to prevent confusion. The method still exists for stage 2 to 3, but stage 1 to 2 was not distinguishable enough for many users.
 - Hidden Power now displays its effective typing.
 - Updated particles for moves: Confusion, Protect, Sand Attack, and Quick Attack.
 - Updated particles for status effects: Paralysis, Poison, and Sleep.
 - Updated particles on Gastly.
 - Revamped stat buff and de-buff particles.
 - Improved the performance of display cases that contain Pokémon photos.
-- Updated sounds for Poké Balls.
-- Updated the Poké Ball animation for Pokémon breaking out.
+- Updated sounds for Poké Balls closing, opening and for Pokémon breaking out.
 - Improved the performance of display cases that contain Pokémon Model items.
 - Removed species Base Stats from the summary interface as it is now viewable within the Pokédex.
-- Changed summary tab text labels to icons.
+- Changed summary tab text labels to icons. You'll get used to them. Or else.
 - Clicking the summary interface exit button while the swap moves or evolve screen is open will cause the interface to switch back to the party screen. The button will exit the interface otherwise.
 - Ancient Poke Balls now jump once rather than shaking 3 times when capturing Pokémon.
   - The jump height indicate the number of shakes that would have occurred.
@@ -343,12 +535,15 @@
     - A short jump indicates that you caught the Pokémon.
 - Pokémon sent out during battle will spawn facing their opponent.
 - Pokémon sent out outside a battle will spawn facing their trainer.
+- Wailord is now 25% bigger. ... [But I have an idea.](https://tenor.com/view/star-wars-more-gif-21856591)
+- Region-biased Pokémon forms are now optional to a built-in resource pack. This pack is enabled by default for Fabric. For NeoForge users, all our built-in resource packs default to disabled because that's all it supports right now.
+- Update item sprites for Cell Battery, Chipped Pot, Covert Cloak, Cracked Pot, Masterpiece Teacup, Red Card, Sachet, and Unremarkable Teacup.
 
 ### Fixes
 - Fixed Ability Patches not reverting Hidden Abilities back to Normal Abilities.
 - Fixed awarding Pokémon experience upon forfeiting battles.
 - Scaled down Amaura's fetus model to avoid clipping through the tank while animating.
-- Fixed Cubone's cry not having a sound.
+- Fixed Cubone's cry not having a sound (as if that Pokémon needed to be more tragic).
 - Fixed the sendout sound erroneously playing when a wild Pokémon breaks out of a Poké ball.
 - Flamethrower is no longer missing sounds.
 - Fixed the Seafloor spawning context not being a usable context.
@@ -356,64 +551,58 @@
 - Fixed Gilded Chests not dropping the chest itself when broken, only the contents.
 - Fixed Pokémon losing their Hidden Ability through evolution if the middle stage did not have a Hidden Ability.
 - Hidden Power no longer plays the water type action effect (It now plays the normal type action effect).
-- Fixed Chimchar and Monferno T-posing whenever they sleep.
-- Fixed Cetitan's cry breaking its walk and sleep animations. 
-- Fixed Crumbling Arch not blending in with the world.
-- Fixed Energy Root applying being usable on a fainted Pokémon.
-- Fixed Pokémon entity not spawning when starting a battle while recalling said Pokémon.
+- Fixed Crumbling Arch structures not blending in with the world.
+- Fixed Energy Root being usable on a fainted Pokémon.
+- Fixed Pokémon not being sent out when starting a battle while recalling said Pokémon.
 - Fixed species comparison not using namespace for both sides in `PokemonProperties.isSubsetOf`.
 - Fixed `PokemonProperties#asString` prefixing nicknames with a '$'.
-- Fixed PC not saving when Pokémon was changed outside.
 - Fixed shearable Pokémon not dropping correct wool colors.
 - Fixed pasture spawning Pokémon inside solid blocks when closest spawning position is blocked off.
 - Fixed Tumbling Down advancement not being granted by tumblestone variants.
 - Improve error handling when loading spawn sets to ensure invalid configurations don't crash the server.
 - Fixed empty `JsonPlayerData` files resulting in players being unable to join server/world.
-- Evolution notification and UI sound is now correctly playing (again).
+- Sound for evolving Pokémon through the Summary Menu is now correctly playing again.
 - Fix Starter prompt not showing up.
-- Fix evolution now granting Pokédex entries.
-- Fix Pokédex crash when a form is looked up without ever seeing the "normal" form.
-- Fixed owned poké balls floating upwards if pausing mid-transition.
+- Fixed owned Poké balls floating upwards if pausing the game mid-transition (which looked absolutely hilarious).
 - Fixed all mouse buttons working for Battle UI navigation (now it's only primary/left click).
 - Fixed trading Pokémon setting their friendship to 0 instead of the base value.
-- Fixed a scenario where a Pokémon that rolled to spawn with a special Tera type sometimes has a Tera type that is already a part of their natural typing.
+- Fixed a scenario where a Pokémon that rolled to spawn with a special Tera type sometimes having a Tera type that is already a part of their natural typing.
 - Fixed PokemonProperty argument suggestions for `tera` and `tera_type` not suggesting `stellar`.
 - Fixed being able to stack Relic Coin Pouches on top of each other.
-- Fixed Model loader generating misleading crash-reports when client is crashing.
+- Fixed model loader generating misleading crash-reports when client is crashing - that resurrection tank error wasn't our fault! We're innocent, your honour!
 - Big Roots and Energy Roots now share the same sounds as intended.
 - Fixed sounds made by blocks playing at a lower pitch than intended.
-- Fixed Chimchar and Monferno T posing whenever they sleep.
+- Fixed Chimchar and Monferno comically T posing whenever they sleep.
+- Fixed Cetitan's cry breaking its walk and sleep animations. 
 - Fixed the Magby line not having any placeholder walk animations.
 - Fixed Duskull and Dusclops using skylight levels for their nether spawn data. There is no sun in the Nether!
 - Fixed Hisuian Zoroark using base Zoroark stats.
 - Fixed Bellossom clipping into the player head when shoulder mounted.
 - Fixed Shroomish's look range to prevent it from looking higher than it should.
-- Fixed Maushold's faint animations not playing. It's sadder than Tandemaus!
+- Fixed Maushold's faint animations not playing. It's even sadder than Tandemaus!
 - Fixed Slowking's battle idle.
 - Fixed Grafaiai's walk speed to prevent model sliding.
-- Fixed Maushold's faint animations not playing. It's sadder than Tandemaus! 
-- Fixed Slowking's battle idle. 
-- Fixed Grafaiai's walk speed to prevent model sliding. 
 - Fixed Alolan Exeggutor's tail not showing in the party UI. It will now also stand in front of all Pokémon in the party menu :)
 - Fixed Timburr duplicating its log while fainting.
 - Fixed hitbox sizes for Grotle and Torterra being set to default values.
-- Fixed Hisuian Sneasel using Johtonian Sneasel's cry
-- Fixed Trevenant t-posing after 8 seconds of sleep.
-- Fixed Bewear t-posing for a bit if a wild one fainted.
-- Fixed reviving items throwing an exception when used in battle.
+- Fixed Hisuian Sneasel using Johtonian Sneasel's cry. Johto-nian. Jotonion. Jotunheim?
+- Fixed Trevenant T-posing after 8 seconds of sleeping. I also do that.
+- Fixed Bewear T-posing for a bit if a wild one faints where you can see.
+- Fixed Noctowl's placeholder fly animation.
+- Corrected Lotad blinking animation. 
+- Fixed reviving items causing errors when used in battle.
 - Fixed messages for Focus Sash, Confusion, Mummy, Ice Face, Own Tempo, and Revive.
 - Improve error handling when loading spawn-sets to ensure invalid configurations don't crash the server.
-- Fixed `crumbling_arch_ruins` from generating a giant cube of air and removed the chest.
+- Fixed Crumbling Arch Ruins generating a giant cube of air and removed the chest.
 - Fixed possible crash on large population servers due to concurrent access of data.
 - Quickly sending out and recalling Pokémon now looks smoother and can no longer be spammed to cause desync issues.
 - Pokémon are now invulnerable during sendout animation and intangible during recall animation.
-- Pokémon are now invincible during sendout animation and intangible during recall animation.
 - Scrolling with party keybinding now behaves properly when using high scroll speed or scroll sensitivity.
 - Fixed battle log GUI flashing when Battle GUI is opened.
 - Bag Items used during a turn will now be refunded if the battle ends before the next turn begins.
-- Pokémon whose current owner is not its Original Trainer now gains extra experience.
+- Pokémon whose current owner is not its Original Trainer now gain extra experience.
 - Fixed Fossil Resurrection advancement not being granted.
-- Fixed village generation caps not applying for berry farms. You were not meant to see more than two berry farms per village!
+- Fixed village generation caps not applying for berry farms. You were not meant to see more than two berry farms per village! This has been broken for ages but no one noticed... Hmmm... We could just remove it from here...
 - Fixed the Ice Face ability activation being displayed incorrectly in a battle.
 - Fixed edge case of F1 and R locking you in battle with no R functionality (requiring ESC to get out).
 - Fixed Poké Ball render orientation in battle interface when capturing.
@@ -426,27 +615,23 @@
 - Fixed top black border rendering in scroll interfaces in summary UI.
 - Fixed aspect tracking for Advancements.
 - Fixed illusion not copying aspects or caught ball.
-- Delay when successfully catching a Pokémon in an Ancient Poké Ball has been increased to account for the new sounds and particles.
 - Prevent summary stats tab from making sounds when clicking on an already open tab.
 - Fixed display case not being able to be fed items from underneath.
 - Fixed Pokémon battling in water continuously sinking to the bottom.
 - Fixed passive healing and wake from faint not disabling when their config values are set to 0.
+- Fixed an issue where rebinding the R key to a mouse button prevented players from closing the battle interface using that button.
 
 ### Developer
 - `SpawnCause` is now an implementation of `SpawningInfluence`.
 - Many types related to `Pokemon` including itself now have dedicated `Codec`, please migrate to them from the NBT/JSON/PacketBuffer write/read methods.
-- `TeraTypes` now implements `Iterable`.
 - `PokemonBattle` now starts on turn 0.
-- SpawnCause is now an implementation of SpawningInfluence.
 - Renamed Pokemon.hp to Pokemon.maxHealth to make it clearer. Backwards compatibility is provided but it is an active deprecation, please migrate away from it.
-- Many types related to ``Pokemon`` including itself now have dedicated ``Codec``, please migrate to them from the NBT/JSON/PacketBuffer write/read methods.
 - Serialization of PokemonStores and Pokemon themselves now require registry access, which will break some sidemods. This sucked for us more than it will suck for you! If you have a world or player instance, you can get it from there.
 - ``TeraTypes`` now implements ``Iterable``.
-- PokemonBattle now starts on turn 0.
 - Added `forcedAspects` to Pokémon to make it easier to easily add basic aspects to a Pokémon in a way that persists. We already know that everyone is going to overuse this.
 - Made the `Pokemon.aspects` setter private. This could technically break side-mods but if you are affected by this then you were using it wrong! Use `Pokemon.forcedAspects` to fix it.
 - Cobblemon's main logger is properly static now.
-- PokemonEntity.enablePoseTypeRecalculation can be used to disable automatic pose type recalculation.
+- `PokemonEntity.enablePoseTypeRecalculation` can be used to disable automatic pose type recalculation.
 - Added CollectEggEvent and HatchEggEvent for compatibility usage.
 - Added events for:
   - Showdown Instructions
@@ -462,32 +647,34 @@
     - Added HealingSource, an interface applied to all sources of healing from player actions, for easier tracking of healing sources.
   - Move Change
   - Shiny Chance Calculation Event (with player context)
-  - Dex Information Changed; this event is fired when the Pokédex is updated with new information.
+  - Dex Information Changed (Pre and Post); this event is fired when the Pokédex is updated with new information.
 - Rebuilt large swaths of the model animation code to simplify it.
 - Renamed a bunch of things from %Poseable% to %Posable% because spelling.
 - Renamed StatelessAnimation to PoseAnimation.
 - Renamed StatefulAnimation to ActiveAnimation.
 - Documented the animation system.
-- Allowed for SpawnSnowstormEntityParticleHandler to handle non-posable entities (due to being non-posable, locators are useless, to set the offset use the settings in the particle itself)
+- Allowed for SpawnSnowstormEntityParticleHandler to handle non-posable entities (due to being non-posable, locators are useless - to set the offset use the settings in the particle itself).
+- Added property chaining support for duplicate CustomPokemonPropertyType elements.
 
 ### Data Pack & Resource Pack Creators
+- Added experimental `flow` datapack directory for handling events using MoLang event handlers.
 - Added support for "shedders" similar to Shedinja's evolution logic.
 - Fixed the placeholder `WingFlapIdle` animation so the wings are not rotating opposite to each other.
 - 'player' type dialogue faces can now be explicitly stated so that NPC mods that use fake players can show in dialogue portraits.
 - Added `isLeftSide` field for dialogue faces. This determines what side of dialogue box the portrait is on.
-- "sounds/attacks" folder has been renamed to "sounds/move"
+- `sounds/attacks` directory has been renamed to `sounds/move`.
 - Moves sharing generic sounds now have unique sound events, allowing them to be changed with resource packs.
-- All move sound events have been renamed to "move.NAME.SOURCE" for consistency.
-- Status moves have been moved out of the 'attacks' folder and split into volatile and nonvolatile.
-- 'status.badlypoison.actor' sound event has been renamed to "status.toxpoison.actor"
-- Mulch and berry harvesting sound events have been renamed and moved to their respective folders in "sounds/block."
-- All sounds related to evolving Pokémon have been moved to the "sounds/evolution" folder.
-- Sound events for all blocks now start with "block."
+- All move sound events have been renamed to `move.<NAME>.<SOURCE>` for consistency.
+- Status moves have been moved out of the `attacks` directory and split into volatile and nonvolatile.
+- `status.badlypoison.actor` sound event has been renamed to `status.toxpoison.actor`
+- Mulch and berry harvesting sound events have been renamed and moved to their respective directories in `sounds/block`.
+- All sounds related to evolving Pokémon have been moved to the `sounds/evolution` directory.
+- Sound events for all blocks now start with `block`.
 - Gimmighoul chest and item interaction sounds have been moved to where its cry is.
 - Unused sound files and sound events have been removed.
 - Poké Ball sounds are now in their animation files, making them more flexible to edit.
 - Added MoLang compatibility in the isVisible property for transformed parts.
-- Added q.has_aspect('some_aspect') function to animations, posers, and entity particle effects.
+- Added `q.has_aspect('some_aspect')` function to animations, posers, and entity particle effects.
 - Added support for conditional pose animations.
 - Added a new universal locator called "top".
 - Added `eggs_collected` and `eggs_hatched` Advancement triggers.
@@ -496,6 +683,7 @@
   - `isTouchingWaterOrRain` has been changed to `isInWaterOrRain`
   - `isSubermegedInWater` has been changed to `isUnderWater`
 
+
 ### Localization
 - Updated translations for:
   - Czech, German, Greek, Spanish, Mexican Spanish, French, Canadian French, Hungarian, Italian, Japanese, Korean, Dutch, Polish, Portuguese, Brazilian Portuguese, Russian, Ukrainian, Simplified Chinese, and Traditional Chinese
@@ -1914,5 +2102,4 @@ Thank you so much to all of our community translators that bring the mod to the
 - Added species, ability, and move translations for `ko_ko`, `jp_jp`, `fr_fr`, `es_es`, `it_it`, and `zh_cn`.
 
 ## [1.0.0 (November 12th, 2022)](#1-0-0)
-- Initial release.
-
+- Initial release.

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

@@ -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();
+                });
+
+            }
+        }
+    }
 }

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

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

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

@@ -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
@@ -54,7 +55,10 @@ import com.cobblemon.mod.common.api.storage.pc.PCStore
 import com.cobblemon.mod.common.api.storage.pc.link.PCLinkManager
 import com.cobblemon.mod.common.api.storage.player.PlayerInstancedDataStoreManager
 import com.cobblemon.mod.common.api.storage.player.PlayerInstancedDataStoreTypes
-import com.cobblemon.mod.common.api.storage.player.adapter.*
+import com.cobblemon.mod.common.api.storage.player.adapter.DexDataMongoBackend
+import com.cobblemon.mod.common.api.storage.player.adapter.DexDataNbtBackend
+import com.cobblemon.mod.common.api.storage.player.adapter.PlayerDataJsonBackend
+import com.cobblemon.mod.common.api.storage.player.adapter.PlayerDataMongoBackend
 import com.cobblemon.mod.common.api.storage.player.factory.CachedPlayerDataStoreFactory
 import com.cobblemon.mod.common.api.tags.CobblemonEntityTypeTags
 import com.cobblemon.mod.common.api.tags.CobblemonItemTags
@@ -65,16 +69,8 @@ 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.command.argument.DexArgumentType
-import com.cobblemon.mod.common.command.argument.DialogueArgumentType
-import com.cobblemon.mod.common.command.argument.FormArgumentType
-import com.cobblemon.mod.common.command.argument.MoveArgumentType
-import com.cobblemon.mod.common.command.argument.NPCClassArgumentType
-import com.cobblemon.mod.common.command.argument.PartySlotArgumentType
-import com.cobblemon.mod.common.command.argument.PokemonPropertiesArgumentType
-import com.cobblemon.mod.common.command.argument.PokemonStoreArgumentType
-import com.cobblemon.mod.common.command.argument.SpawnBucketArgumentType
-import com.cobblemon.mod.common.command.argument.SpeciesArgumentType
+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
 import com.cobblemon.mod.common.config.constraint.IntConstraint
@@ -94,17 +90,21 @@ import com.cobblemon.mod.common.pokemon.evolution.variants.BlockClickEvolution
 import com.cobblemon.mod.common.pokemon.feature.TagSeasonResolver
 import com.cobblemon.mod.common.pokemon.helditem.CobblemonHeldItemManager
 import com.cobblemon.mod.common.pokemon.properties.AspectPropertyType
+import com.cobblemon.mod.common.pokemon.properties.BattleCloneProperty
 import com.cobblemon.mod.common.pokemon.properties.FreezeFrameProperty
 import com.cobblemon.mod.common.pokemon.properties.HiddenAbilityPropertyType
 import com.cobblemon.mod.common.pokemon.properties.NoAIProperty
 import com.cobblemon.mod.common.pokemon.properties.UnaspectPropertyType
 import com.cobblemon.mod.common.pokemon.properties.UncatchableProperty
-import com.cobblemon.mod.common.pokemon.properties.BattleCloneProperty
 import com.cobblemon.mod.common.pokemon.properties.tags.PokemonFlagProperty
 import com.cobblemon.mod.common.pokemon.stat.CobblemonStatProvider
 import com.cobblemon.mod.common.starter.CobblemonStarterHandler
-import com.cobblemon.mod.common.trade.TradeManager
-import com.cobblemon.mod.common.util.*
+import com.cobblemon.mod.common.util.DataKeys
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.cobblemon.mod.common.util.ifDedicatedServer
+import com.cobblemon.mod.common.util.isLaterVersion
+import com.cobblemon.mod.common.util.party
+import com.cobblemon.mod.common.util.server
 import com.cobblemon.mod.common.world.feature.CobblemonPlacedFeatures
 import com.cobblemon.mod.common.world.feature.ore.CobblemonOrePlacedFeatures
 import com.cobblemon.mod.common.world.gamerules.CobblemonGameRules
@@ -116,7 +116,7 @@ import java.io.File
 import java.io.FileReader
 import java.io.FileWriter
 import java.io.PrintWriter
-import java.util.*
+import java.util.UUID
 import kotlin.math.roundToInt
 import kotlin.properties.Delegates
 import kotlin.reflect.full.memberProperties
@@ -125,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
@@ -164,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
 
@@ -190,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()
@@ -208,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)
@@ -246,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
@@ -386,8 +400,13 @@ object Cobblemon {
                 BattleFormat.GEN_9_SINGLES,
                 BattleSide(PokemonBattleActor(UUID.randomUUID(), BattlePokemon(Pokemon().initialize()), -1F)),
                 BattleSide(PokemonBattleActor(UUID.randomUUID(), BattlePokemon(Pokemon().initialize()), -1F)),
-                true
-            ).ifSuccessful { it.mute = true }
+                false
+            ).ifSuccessful {
+                it.mute = true
+            }.ifErrored {
+                val errors = it.errors.joinToString("\n") { it.javaClass.name }
+                LOGGER.error("Failed to start dummy Showdown battle: $errors")
+            }
         }
 
         registerEventHandlers()

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

@@ -121,10 +121,17 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     val APRICORN_PRESSURE_PLATE = this.create("apricorn_pressure_plate", PressurePlateBlockInvoker.`cobblemon$create`(APRICORN_BLOCK_SET_TYPE, BlockBehaviour.Properties.of().mapColor(APRICORN_PLANKS.defaultMapColor()).noCollission().strength(0.5f).sound(SoundType.WOOD)))
     @JvmField
     val APRICORN_SIGN = this.create("apricorn_sign", CobblemonSignBlock(BlockBehaviour.Properties.ofFullCopy(Blocks.OAK_SIGN), APRICORN_WOOD_TYPE))
+
+    @JvmField //if you wonder why we don't copy of OAK_WALL_SIGN, then I can tell you its because it uses Properties#dropsLike to point to the SIGN loot table, but we cant use that in our setup due to a deeper rooted issue, so falling back to this and writing dedicated (duplicated) loot tables
+    val APRICORN_WALL_SIGN = this.create(
+        "apricorn_wall_sign",
+        CobblemonWallSignBlock(BlockBehaviour.Properties.ofFullCopy(Blocks.OAK_SIGN), APRICORN_WOOD_TYPE)
+    )
     @JvmField
-    val APRICORN_WALL_SIGN = this.create("apricorn_wall_sign", CobblemonWallSignBlock(BlockBehaviour.Properties.ofFullCopy(Blocks.OAK_WALL_SIGN), APRICORN_WOOD_TYPE))
-    @JvmField
-    val APRICORN_HANGING_SIGN = this.create("apricorn_hanging_sign", CobblemonHangingSignBlock(BlockBehaviour.Properties.ofFullCopy(Blocks.OAK_WALL_HANGING_SIGN), APRICORN_WOOD_TYPE))
+    val APRICORN_HANGING_SIGN = this.create(
+        "apricorn_hanging_sign",
+        CobblemonHangingSignBlock(BlockBehaviour.Properties.ofFullCopy(Blocks.OAK_HANGING_SIGN), APRICORN_WOOD_TYPE)
+    )
     @JvmField
     val APRICORN_WALL_HANGING_SIGN = this.create("apricorn_wall_hanging_sign", CobblemonWallHangingSignBlock(BlockBehaviour.Properties.ofFullCopy(Blocks.OAK_HANGING_SIGN), APRICORN_WOOD_TYPE))
     @JvmField

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

@@ -12,6 +12,7 @@ import com.bedrockk.molang.runtime.MoLangRuntime
 import com.bedrockk.molang.runtime.value.MoValue
 import com.cobblemon.mod.common.CobblemonNetwork.sendPacket
 import com.cobblemon.mod.common.api.data.DataRegistry
+import com.cobblemon.mod.common.api.events.Cancelable
 import com.cobblemon.mod.common.api.molang.ExpressionLike
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.setup
 import com.cobblemon.mod.common.api.reactive.SimpleObservable
@@ -50,19 +51,21 @@ object CobblemonFlows : DataRegistry {
     override fun reload(manager: ResourceManager) {
         clientFlows.clear()
         flows.clear()
+
+        val unsortedFlows = mutableMapOf<ResourceLocation, MutableList<Pair<String, ExpressionLike>>>()
         val folderBeforeNameRegex = ".*\\/([^\\/]+)\\/[^\\/]+\$".toRegex()
         manager.listResources("flows") { path -> path.endsWith(CobblemonScripts.MOLANG_EXTENSION) }.forEach { (identifier, resource) ->
             resource.openAsReader().use { stream ->
                 stream.buffered().use { reader ->
                     try {
                         val expression = reader.readText().asExpressionLike()
+
                         val event = folderBeforeNameRegex.find(identifier.path)?.groupValues?.get(1)
                             ?: throw IllegalArgumentException("Invalid flow path: $identifier. Should have a folder structure that includes the name of the event being flowed.")
-                        if (identifier.path.startsWith("flows/client/")) {
-                            clientFlows.getOrPut(ResourceLocation.fromNamespaceAndPath(identifier.namespace, event)) { mutableListOf() }.add(expression)
-                        } else {
-                            flows.getOrPut(ResourceLocation.fromNamespaceAndPath(identifier.namespace, event)) { mutableListOf() }.add(expression)
-                        }
+
+                        val flowKey = ResourceLocation.fromNamespaceAndPath(identifier.namespace, event)
+                        unsortedFlows.putIfAbsent(flowKey, mutableListOf())
+                        unsortedFlows[flowKey]!!.add(identifier.path to expression)
                     } catch (exception: Exception) {
                         throw ExecutionException("Error loading MoLang script for flow: $identifier", exception)
                     }
@@ -70,11 +73,31 @@ object CobblemonFlows : DataRegistry {
             }
         }
 
-        Cobblemon.LOGGER.info("Loaded ${CobblemonScripts.scripts.size} flows and ${CobblemonScripts.clientScripts.size} client flows")
+        unsortedFlows.forEach { (key, value) ->
+            value.sortBy { it.first }
+            if (key.path.startsWith("flows/client/")) {
+                clientFlows.getOrPut(key) { mutableListOf() }.addAll(value.map { it.second })
+            } else {
+                flows.getOrPut(key) { mutableListOf() }.addAll(value.map { it.second })
+            }
+        }
+
+        Cobblemon.LOGGER.info("Loaded ${flows.size} flows and ${clientFlows.size} client flows")
         observable.emit(this)
     }
 
-    fun run(eventResourceLocation: ResourceLocation, context: Map<String, MoValue>) {
-        flows[eventResourceLocation]?.forEach { it.resolve(runtime, context) }
+    fun run(eventResourceLocation: ResourceLocation, context: Map<String, MoValue>, cancelable: Cancelable? = null) {
+        if (cancelable == null) {
+            runtime.environment.query.functions.remove("cancel")
+        } else {
+            runtime.environment.query.addFunction("cancel") { cancelable }
+        }
+
+        flows[eventResourceLocation]?.forEach {
+            if (cancelable != null && cancelable.isCanceled) {
+                return
+            }
+            it.resolve(runtime, context)
+        }
     }
 }

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

@@ -8,25 +8,22 @@
 
 package com.cobblemon.mod.common
 
-import com.cobblemon.mod.common.api.data.JsonDataRegistry
 import com.cobblemon.mod.common.api.net.NetworkPacket
 import com.mojang.brigadier.arguments.ArgumentType
+import kotlin.reflect.KClass
 import net.minecraft.commands.synchronization.ArgumentTypeInfo
-import net.minecraft.network.chat.Component
 import net.minecraft.resources.ResourceKey
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.MinecraftServer
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.server.packs.PackType
 import net.minecraft.server.packs.resources.PreparableReloadListener
-import net.minecraft.server.packs.resources.ResourceManager
 import net.minecraft.tags.TagKey
 import net.minecraft.world.level.GameRules
 import net.minecraft.world.level.ItemLike
 import net.minecraft.world.level.biome.Biome
 import net.minecraft.world.level.levelgen.GenerationStep
 import net.minecraft.world.level.levelgen.placement.PlacedFeature
-import kotlin.reflect.KClass
 
 interface CobblemonImplementation {
     val modAPI: ModAPI
@@ -178,16 +175,6 @@ interface CobblemonImplementation {
      * @param chance The chance % of increasing the composter level, 0 to 1 expected.
      */
     fun registerCompostable(item: ItemLike, chance: Float)
-
-    /**
-     * Registers a builtin resource pack.
-     *
-     * @param id The unique [ResourceLocation] of this pack.
-     * @param title The title displayed in the resource pack GUI, the description is still a part of the pack metadata.
-     * @param activationBehaviour The [ResourcePackActivationBehaviour] for this pack.
-     */
-    fun registerBuiltinResourcePack(id: ResourceLocation, title: Component, activationBehaviour: ResourcePackActivationBehaviour)
-
 }
 
 enum class ResourcePackActivationBehaviour {

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

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

common/src/main/kotlin/com/cobblemon/mod/common/advancement/criterion/PartyCheckCriterion.kt

@@ -26,76 +26,25 @@ class PartyCheckCriterion(
     companion object {
         val CODEC: Codec<PartyCheckCriterion> = RecordCodecBuilder.create { it.group(
             EntityPredicate.ADVANCEMENT_CODEC.optionalFieldOf("player").forGetter(PartyCheckCriterion::playerCtx),
-            ResourceLocation.CODEC.listOf().optionalFieldOf("id", listOf()).forGetter(PartyCheckCriterion::party)
+            ResourceLocation.CODEC.listOf().optionalFieldOf("party", listOf()).forGetter(PartyCheckCriterion::party)
         ).apply(it, ::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)
             }
         }
-        return matches.containsAll(party) && matches.size == partyCount
+        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)*/

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

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

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

@@ -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) } }

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

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

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

@@ -61,7 +61,7 @@ open class ItemDropEntry : DropEntry {
 
         if (dropMethod == ItemDropMethod.ON_PLAYER && player != null) {
             world.addFreshEntity(ItemEntity(player.level(), player.x, player.y, player.z, stack))
-        } else if (dropMethod == ItemDropMethod.TO_INVENTORY && player != null) {
+        } else if (dropMethod == ItemDropMethod.TO_INVENTORY && player != null && !stack.isEmpty) {
             val name = stack.hoverName
             val count = stack.count
             val succeeded = player.addItem(stack)

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

@@ -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,7 +196,11 @@ object CobblemonEvents {
     @JvmField
     val POKEMON_SEEN = EventObservable<PokemonSeenEvent>()
     @JvmField
-    val POKEDEX_DATA_CHANGED = EventObservable<PokedexDataChangedEvent>()
+    val POKEMON_ASPECTS_CHANGED = EventObservable<PokemonAspectsChangedEvent>()
+    @JvmField
+    val POKEDEX_DATA_CHANGED_PRE = CancelableObservable<PokedexDataChangedEvent.Pre>()
+    @JvmField
+    val POKEDEX_DATA_CHANGED_POST = EventObservable<PokedexDataChangedEvent.Post>()
 
     // Fishing
     @JvmField

common/src/main/kotlin/com/cobblemon/mod/common/api/events/battles/BattleFaintedEvent.kt

@@ -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()) },
+            )
+        )
+    )
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/events/battles/BattleFledEvent.kt

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

common/src/main/kotlin/com/cobblemon/mod/common/api/events/battles/BattleStartedEvent.kt

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

common/src/main/kotlin/com/cobblemon/mod/common/api/events/battles/instruction/FormeChangeEvent.kt

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

common/src/main/kotlin/com/cobblemon/mod/common/api/events/battles/instruction/MegaEvolutionEvent.kt

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

common/src/main/kotlin/com/cobblemon/mod/common/api/events/battles/instruction/TerastallizationEvent.kt

@@ -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())
+    )
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/events/battles/instruction/ZMoveUsedEvent.kt

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

common/src/main/kotlin/com/cobblemon/mod/common/api/events/farming/ApricornHarvestEvent.kt

@@ -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()
+    )
 }

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

@@ -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()

common/src/main/kotlin/com/cobblemon/mod/common/api/events/pokeball/ThrownPokeballHitEvent.kt

@@ -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()
+    )
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/events/pokedex/scanning/PokemonScannedEvent.kt

@@ -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
+            }
+        },
+    )
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/events/pokemon/FriendshipUpdatedEvent.kt

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

common/src/main/kotlin/com/cobblemon/mod/common/api/events/pokemon/LevelUpEvent.kt

@@ -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())
+    )
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/events/pokemon/PokedexDataChangedEvent.kt

@@ -11,33 +11,48 @@ package com.cobblemon.mod.common.api.events.pokemon
 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.events.Cancelable
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
+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.api.pokedex.AbstractPokedexManager
 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.
  */
-data class PokedexDataChangedEvent(
-    val dataSource: Either<PokedexEntityData, Pokemon>,
-    val knowledge: PokedexEntryProgress,
-    val playerUUID: UUID,
+sealed interface PokedexDataChangedEvent {
+    val dataSource: PokedexEntityData
+    val knowledge: PokedexEntryProgress
+    val playerUUID: UUID
     val record: FormDexRecord
-) {
+
     val pokedexManager: AbstractPokedexManager
         get() = record.speciesDexRecord.pokedexManager
 
-    val context = mutableMapOf<String, MoValue>(
-        "player" to (playerUUID.getPlayer()?.asMoLangValue() ?: DoubleValue.ZERO),
-        "pokemon" to dataSource.map({ DoubleValue.ZERO }, { it.struct }),
-        "data" to dataSource.map({ it.struct }, { DoubleValue.ZERO }),
-        "knowledge" to StringValue(knowledge.name.lowercase()),
-        "pokedex" to pokedexManager.struct
-    )
-}
+    fun getContext(): MutableMap<String, MoValue> {
+        return mutableMapOf(
+            "player" to (playerUUID.getPlayer()?.asMoLangValue() ?: 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: PokedexEntityData,
+        override val knowledge: PokedexEntryProgress,
+        override val playerUUID: UUID,
+        override val record: FormDexRecord
+    ) : PokedexDataChangedEvent, Cancelable()
+
+    class Post(
+        override val dataSource: PokedexEntityData,
+        override val knowledge: PokedexEntryProgress,
+        override val playerUUID: UUID,
+        override val record: FormDexRecord
+    ) : PokedexDataChangedEvent
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/events/pokemon/PokemonAspectsChangedEvent.kt

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

common/src/main/kotlin/com/cobblemon/mod/common/api/events/pokemon/PokemonFaintedEvent.kt

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

common/src/main/kotlin/com/cobblemon/mod/common/api/events/pokemon/PokemonGainedEvent.kt

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

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

@@ -74,7 +74,7 @@ abstract class RequestManager<T : ServerPlayerActionRequest> {
         ?: this.getInboundRequest(receiver.uuid, requestID)
 
     /** Determines whether [player] can receive a [T]. */
-    open fun isBusy(player: ServerPlayer): Boolean = player.isInBattle() || player.isTrading()
+    open fun isBusy(player: ServerPlayer): Boolean = player.isInBattle() || player.isTrading() || player.party().find { it.entity?.isBusy == true } != null
 
     /** Determines if the [target] is a valid interaction request target. */
     abstract fun isValidInteraction(player: ServerPlayer, target: ServerPlayer): Boolean
@@ -176,7 +176,7 @@ abstract class RequestManager<T : ServerPlayerActionRequest> {
         else if (!this.isValidInteraction(player, target ?: request.sender))    // with teams anyone can accept
             request.notify(player, true, "ui.interact.failed")
         // if sending player is occupied, can't accept response
-        else if (this.isBusy(request.sender))                                   // TODO enhancement: allow retries - modify client so we don't remove request when sending acceptance
+        else if (this.isBusy(request.sender) || this.isBusy(request.receiver))  // TODO enhancement: allow retries - modify client so we don't remove request when sending acceptance
             request.notify(player, true, "ui.interact.unavailable")
         // if no condition is blocking acceptance, accept
         else if (this.canAccept(request))

common/src/main/kotlin/com/cobblemon/mod/common/api/item/PokemonSelectingItem.kt

@@ -38,8 +38,9 @@ import net.minecraft.world.phys.AABB
  */
 interface PokemonSelectingItem {
     fun use(player: ServerPlayer, stack: ItemStack): InteractionResultHolder<ItemStack> {
+        val range = player.entityInteractionRange()
         val entity = player.level()
-            .getEntities(player, AABB.ofSize(player.position(), 16.0, 16.0, 16.0))
+            .getEntities(player, AABB.ofSize(player.position(), range, range, range))
             .filter { player.isLookingAt(it, stepDistance = 0.1F) }
             .minByOrNull { it.distanceTo(player) } as? PokemonEntity?
 
@@ -95,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))
         }
     }
 
@@ -147,4 +149,4 @@ interface PokemonSelectingItem {
 
         return InteractionResultHolder.success(stack)
     }
-}
+}

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

@@ -47,6 +47,8 @@ import com.cobblemon.mod.common.api.storage.pc.PCStore
 import com.cobblemon.mod.common.api.text.text
 import com.cobblemon.mod.common.battles.BattleRegistry
 import com.cobblemon.mod.common.battles.actor.PlayerBattleActor
+import com.cobblemon.mod.common.client.particle.BedrockParticleOptionsRepository
+import com.cobblemon.mod.common.client.particle.ParticleStorm
 import com.cobblemon.mod.common.client.render.models.blockbench.wavefunction.WaveFunctions
 import com.cobblemon.mod.common.entity.PosableEntity
 import com.cobblemon.mod.common.entity.npc.NPCBattleActor
@@ -56,12 +58,15 @@ import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.entity.pokemon.ai.PokemonMoveControl
 import com.cobblemon.mod.common.net.messages.client.animation.PlayPosableAnimationPacket
 import com.cobblemon.mod.common.net.messages.client.effect.RunPosableMoLangPacket
+import com.cobblemon.mod.common.net.messages.client.effect.SpawnSnowstormEntityParticlePacket
+import com.cobblemon.mod.common.net.messages.client.effect.SpawnSnowstormParticlePacket
 import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.pokemon.Species
 import com.cobblemon.mod.common.util.*
 import com.mojang.datafixers.util.Either
 import java.util.UUID
 import kotlin.math.sqrt
+import net.minecraft.client.multiplayer.ClientLevel
 import net.minecraft.commands.arguments.EntityAnchorArgument
 import net.minecraft.core.BlockPos
 import net.minecraft.core.Holder
@@ -175,6 +180,30 @@ object MoLangFunctions {
             val expression = params.getString(0).asExpressionLike()
             runtime.resolve(expression)
         },
+        "system_time_millis" to java.util.function.Function { _ ->
+            DoubleValue(System.currentTimeMillis())
+        },
+        // the rest of the world use dd/MM/yyyy grow up america (this comment was generated by copilot)
+        "date_local_time" to java.util.function.Function { _ ->
+            val time = System.currentTimeMillis()
+            val date = java.util.Date(time)
+            val formatted = java.text.SimpleDateFormat("DD/MM/YYYY").format(date)
+            StringValue(formatted)
+        },
+        "date_of" to java.util.function.Function { params ->
+            val time = params.getDouble(0).toLong()
+            val date = java.util.Date(time)
+            val formatted = java.text.SimpleDateFormat("DD/MM/YYYY").format(date)
+            StringValue(formatted)
+        },
+        "date_is_after" to java.util.function.Function { params ->
+            val dateA = params.getString(0)
+            val dateB = params.getString(1)
+            val format = java.text.SimpleDateFormat("DD/MM/YYYY")
+            val a = format.parse(dateA)
+            val b = format.parse(dateB)
+            DoubleValue(a.after(b))
+        }
     )
     val biomeFunctions = mutableListOf<(Holder<Biome>) -> HashMap<String, java.util.function.Function<MoParams, Any>>>()
     val worldFunctions = mutableListOf<(Holder<Level>) -> HashMap<String, java.util.function.Function<MoParams, Any>>>(
@@ -235,6 +264,31 @@ object MoLangFunctions {
                 world.addFreshEntity(lightning)
                 return@put DoubleValue.ONE
             }
+            // q.entity.world.spawn_bedrock_particles(effect, x, y, z, [player]) - sends to everyone nearby or just to the player if they're set.
+            map.put("spawn_bedrock_particles") { params ->
+                val particle = params.getString(0).asResource()
+                val x = params.getDouble(1)
+                val y = params.getDouble(2)
+                val z = params.getDouble(3)
+                val player = params.getOrNull<MoValue>(4)?.let {
+                    if (it is StringValue) world.getPlayerByUUID(UUID.fromString(it.value))
+                    else if (it is ObjectValue<*>) it.obj
+                    else null
+                } as? ServerPlayer
+                val pos = Vec3(x, y, z)
+
+                if (world !is ClientLevel) {
+                    val packet = SpawnSnowstormParticlePacket(particle, pos)
+                    if (player != null) {
+                        packet.sendToPlayer(player)
+                    } else {
+                        packet.sendToPlayersAround(x, y, z, 64.0, world.dimension())
+                    }
+                } else {
+                    val effect = BedrockParticleOptionsRepository.getEffect(particle) ?: return@put DoubleValue.ZERO
+                    ParticleStorm.createAtPosition(world, effect, pos).spawn()
+                }
+            }
             map.put("get_entities_around") { params ->
                 val x = params.getDouble(0)
                 val y = params.getDouble(1)
@@ -408,6 +462,11 @@ object MoLangFunctions {
             }
             map.put("max_health") { _ -> DoubleValue(entity.maxHealth) }
             map.put("name") { _ -> StringValue(entity.effectiveName().string) }
+            map.put("type") { _ ->
+                entity.registryAccess().registry(Registries.ENTITY_TYPE).get().getKey(entity.type)?.toString()?.let {
+                    StringValue(it)
+                } ?: DoubleValue.ZERO
+            }
             map.put("yaw") { _ -> DoubleValue(entity.yRot.toDouble()) }
             map.put("pitch") { _ -> DoubleValue(entity.xRot.toDouble()) }
             map.put("x") { _ -> DoubleValue(entity.x) }
@@ -455,11 +514,57 @@ 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)
                     val packet = PlayPosableAnimationPacket(entity.id, setOf(animation), emptyList())
+                    val target = params.getStringOrNull(1)
+                    if (target != null) {
+                        val targetPlayer = if (target.asUUID != null) {
+                            entity.level().getPlayerByUUID(target.asUUID!!) as ServerPlayer
+                        } else if (entity.level() is ServerLevel) {
+                            entity.level().server!!.playerList.getPlayerByName(target)
+                        } else {
+                            null
+                        }
+                        if (targetPlayer != null) {
+                            packet.sendToPlayer(targetPlayer)
+                            return@put DoubleValue.ONE
+                        } else {
+                            return@put DoubleValue.ZERO
+                        }
+                    } else {
+                        packet.sendToPlayersAround(entity.x, entity.y, entity.z, 64.0, entity.level().dimension())
+                        return@put DoubleValue.ONE
+                    }
+                }
+            }
+            // q.entity.spawn_bedrock_particles(effect, locator, [player]) - sends to everyone nearby or just to the player if they're set. Locator is necessary even if unused on non-posables.
+            map.put("spawn_bedrock_particles") { params ->
+                val particle = params.getString(0).asResource()
+                val locator = params.getString(1)
+                val player = params.getOrNull<MoValue>(2)?.let {
+                    if (it is StringValue) entity.level().getPlayerByUUID(UUID.fromString(it.value))
+                    else if (it is ObjectValue<*>) it.obj
+                    else null
+                } as? ServerPlayer
+
+                val packet = SpawnSnowstormEntityParticlePacket(particle, entity.id, listOf(locator))
+                if (player == null) {
                     packet.sendToPlayersAround(entity.x, entity.y, entity.z, 64.0, entity.level().dimension())
+                } else {
+                    packet.sendToPlayer(player)
                 }
             }
             map
@@ -509,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)
@@ -612,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
         }
     )

common/src/main/kotlin/com/cobblemon/mod/common/api/moves/BenchedMove.kt

@@ -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) }

common/src/main/kotlin/com/cobblemon/mod/common/api/moves/Move.kt

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

common/src/main/kotlin/com/cobblemon/mod/common/api/moves/MoveSet.kt

@@ -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() {

common/src/main/kotlin/com/cobblemon/mod/common/api/moves/animations/ActionEffectTimeline.kt

@@ -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()
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/moves/animations/keyframes/AnimationActionEffectKeyframe.kt

@@ -36,7 +36,7 @@ class AnimationActionEffectKeyframe : ConditionalActionEffectKeyframe(), EntityC
         // Treat them as expressions if possible but otherwise yeah just send them as strings
         val animation = animation.map {
             try {
-                it.asExpressionLike().resolveString(context.runtime).takeIf { it != "0.0" } ?: it
+                it.asExpressionLike().resolveString(context.runtime).takeIf { it != "0" } ?: it
             } catch (e: Exception) {
                 it
             }

common/src/main/kotlin/com/cobblemon/mod/common/api/moves/animations/keyframes/EntityParticlesActionEffectKeyframe.kt

@@ -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,25 +33,50 @@ 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.0" } ?: effect
+            effect?.asExpressionLike()?.resolveString(context.runtime)?.takeIf { it != "0" } ?: effect
         } catch (e: Exception) {
             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))

common/src/main/kotlin/com/cobblemon/mod/common/api/moves/animations/keyframes/EntitySoundActionEffectKeyframe.kt

@@ -35,7 +35,7 @@ class EntitySoundActionEffectKeyframe : ConditionalActionEffectKeyframe(), Entit
             .flatMap { prov -> prov.entities.filter { test(context, it, isUser = prov is UsersProvider) } }
 
         val soundIdentifier = try {
-            sound?.asExpressionLike()?.resolveString(context.runtime)?.takeIf { it != "0.0" } ?: sound
+            sound?.asExpressionLike()?.resolveString(context.runtime)?.takeIf { it != "0" } ?: sound
         } catch (e: Exception) {
             sound
         }?.asIdentifierDefaultingNamespace() ?: return skip()

common/src/main/kotlin/com/cobblemon/mod/common/api/npc/NPCClass.kt

@@ -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,15 +57,17 @@ 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(this.hitbox.width)
-        buffer.writeFloat(this.hitbox.height)
-        buffer.writeBoolean(this.hitbox.fixed)
+        buffer.writeFloat(baseScale)
+        buffer.writeFloat(hitbox.width)
+        buffer.writeFloat(hitbox.height)
+        buffer.writeBoolean(hitbox.fixed)
         battleConfiguration.encode(buffer)
         buffer.writeNullable(interaction) { _, value ->
             buffer.writeString(value.type)
@@ -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()
     }
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/npc/NPCPreset.kt

@@ -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 }
     }
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/npc/README.md

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

common/src/main/kotlin/com/cobblemon/mod/common/api/pokeball/PokeBalls.kt

@@ -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 }

common/src/main/kotlin/com/cobblemon/mod/common/api/pokeball/catching/modifiers/BaseStatModifier.kt

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

common/src/main/kotlin/com/cobblemon/mod/common/api/pokedex/AbstractPokedexManager.kt

@@ -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
@@ -150,25 +168,4 @@ abstract class AbstractPokedexManager {
     open fun markDirty() {
         // Save stuff
     }
-
-    companion object {
-        const val NUM_CAUGHT_KEY = "cobblemon.pokedex.entries.caught"
-        const val NUM_SEEN_KEY = "cobblemon.pokedex.entries.seen"
-
-        fun getKeyForSpeciesBase(speciesId: ResourceLocation): String {
-            return "cobblemon.pokedex.${speciesId.path}"
-        }
-
-        fun getKnowledgeKeyForSpecies(speciesId: ResourceLocation): String {
-            return "${getKeyForSpeciesBase(speciesId)}.knowledge"
-        }
-
-        fun getKnowledgeKeyForForm(speciesId: ResourceLocation, formName: String): String {
-            return "${getKnowledgeKeyForSpecies(speciesId)}.${formName.lowercase()}"
-        }
-
-        fun getCaptureMethodKeyForSpecies(speciesId: ResourceLocation): String {
-            return "${getKeyForSpeciesBase(speciesId)}.capturemethod"
-        }
-    }
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/pokedex/FormDexRecord.kt

@@ -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
@@ -53,8 +54,11 @@ class FormDexRecord {
 
     /** The genders that the dex is aware of. */
     private val genders: MutableSet<Gender> = mutableSetOf()
+
     /** Shiny states could be shiny or non-shiny - on the off chance they only saw the shiny, they shouldn't know what the normal looks like. */
-    private val seenShinyStates = mutableSetOf<String>() // consider: radiants in the future (radiants should just be a resource pack tbh)
+    private val seenShinyStates =
+        mutableSetOf<String>() // consider: radiants in the future (radiants should just be a resource pack tbh)
+
     /** The current awareness of the form that the dex has. */
     var knowledge = PokedexEntryProgress.NONE
         private set
@@ -85,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)
         }
     }
 
@@ -109,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) {
@@ -118,47 +119,40 @@ class FormDexRecord {
         speciesDexRecord.onFormRecordUpdated(this)
     }
 
-    private fun addInformation(pokemon: Pokemon, knowledge: PokedexEntryProgress) {
-        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)
-
-        (speciesDexRecord.pokedexManager as? PokedexManager)?.let { pokedexManager ->
-            CobblemonEvents.POKEDEX_DATA_CHANGED.post(PokedexDataChangedEvent(Either.right(pokemon), knowledge, pokedexManager.uuid, this))
-        }
-    }
-
     private fun addInformation(pokedexEntityData: PokedexEntityData, knowledge: PokedexEntryProgress) {
-        genders.add(pokedexEntityData.gender)
-        seenShinyStates.add(if (pokedexEntityData.shiny) "shiny" else "normal")
-        if (knowledge.ordinal > this.knowledge.ordinal) {
-            this.knowledge = knowledge
-        }
-        speciesDexRecord.addInformation(pokedexEntityData, knowledge)
-        speciesDexRecord.onFormRecordUpdated(this)
-
         (speciesDexRecord.pokedexManager as? PokedexManager)?.let { pokedexManager ->
-            CobblemonEvents.POKEDEX_DATA_CHANGED.post(PokedexDataChangedEvent(Either.left(pokedexEntityData), knowledge, pokedexManager.uuid, this))
+            CobblemonEvents.POKEDEX_DATA_CHANGED_PRE.postThen(
+                PokedexDataChangedEvent.Pre(
+                    pokedexEntityData,
+                    knowledge,
+                    pokedexManager.uuid,
+                    this
+                ),
+                ifSucceeded = {
+                    genders.add(pokedexEntityData.pokemon.gender)
+                    seenShinyStates.add(if (pokedexEntityData.pokemon.shiny) "shiny" else "normal")
+                    if (knowledge.ordinal > this.knowledge.ordinal) {
+                        this.knowledge = knowledge
+                    }
+                    speciesDexRecord.addInformation(pokedexEntityData, knowledge)
+                    speciesDexRecord.onFormRecordUpdated(this)
+                    CobblemonEvents.POKEDEX_DATA_CHANGED_POST.post(
+                        PokedexDataChangedEvent.Post(
+                            pokedexEntityData,
+                            knowledge,
+                            pokedexManager.uuid,
+                            this
+                        )
+                    )
+                }
+            )
         }
     }
 
-    /** 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)
     }

common/src/main/kotlin/com/cobblemon/mod/common/api/pokedex/PokedexManager.kt

@@ -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() {

common/src/main/kotlin/com/cobblemon/mod/common/api/pokedex/SpeciesDexRecord.kt

@@ -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()) {

common/src/main/kotlin/com/cobblemon/mod/common/api/pokedex/filter/SearchFilter.kt

@@ -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>()

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

@@ -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)
     }
 
 }

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

@@ -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
@@ -22,6 +23,7 @@ import com.cobblemon.mod.common.api.moves.MoveTemplate
 import com.cobblemon.mod.common.api.pokemon.PokemonProperties
 import com.cobblemon.mod.common.api.pokemon.evolution.requirement.EvolutionRequirement
 import com.cobblemon.mod.common.api.tags.CobblemonItemTags
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.item.PokeBallItem
 import com.cobblemon.mod.common.net.messages.client.animation.PlayPosableAnimationPacket
 import com.cobblemon.mod.common.pokemon.Pokemon
@@ -31,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
@@ -79,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.
      *
@@ -99,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)
@@ -129,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
@@ -162,7 +165,7 @@ interface Evolution : EvolutionLike {
             evolutionMethod(pokemon)
             pokemon.getOwnerPlayer()?.sendSystemMessage(lang("ui.evolve.into", preEvoName, pokemon.species.translatedName))
         } else {
-            pokemonEntity.busyLocks.add("evolving")
+            pokemonEntity.entityData.set(PokemonEntity.EVOLUTION_STARTED, true)
             pokemonEntity.navigation.stop()
             pokemonEntity.after(1F) {
                 evolutionAnimation(pokemonEntity)
@@ -172,7 +175,7 @@ interface Evolution : EvolutionLike {
             }
             pokemonEntity.after( seconds = 12F ) {
                 cryAnimation(pokemonEntity)
-                pokemonEntity.busyLocks.remove("evolving")
+                pokemonEntity.entityData.set(PokemonEntity.EVOLUTION_STARTED, false)
                 pokemon.getOwnerPlayer()?.sendSystemMessage(lang("ui.evolve.into", preEvoName, pokemon.species.translatedName))
             }
         }
@@ -189,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))
     }
@@ -209,4 +242,4 @@ interface Evolution : EvolutionLike {
     fun applyTo(pokemon: Pokemon) {
         result.apply(pokemon)
     }
-}
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/pokemon/labels/CobblemonPokemonLabels.kt

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

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

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

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

@@ -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,

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

@@ -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
+    }
+}

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

@@ -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()
         }

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

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

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

@@ -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)) {

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

@@ -59,10 +59,6 @@ abstract class SpawningCondition<T : SpawningContext> {
     var isThundering: Boolean? = null
     var timeRange: TimeRange? = null
     var structures: MutableList<Either<ResourceLocation, TagKey<Structure>>>? = null
-    var minLureLevel: Int? = null
-    var maxLureLevel: Int? = null
-    var bait: ResourceLocation? = null
-    var rodType: ResourceLocation? = null
     var isSlimeChunk: Boolean? = null
 
     @Transient

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

@@ -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())
         }

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

@@ -33,6 +33,11 @@ open class PlayerLevelRangeInfluence(
     val noPokemonRange: IntRange = 1 .. config.minimumLevelRangeMax,
     val recalculationMillis: Long = 5000L
 ) : SpawningInfluence {
+    companion object {
+        /** The internally tuned variation for player level range influences */
+        val TYPICAL_VARIATION = 5
+    }
+
     val uuid = player.uuid
     var lastCalculatedTime: Long = 0
     var previousRange: IntRange = noPokemonRange

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

@@ -13,6 +13,7 @@ import com.cobblemon.mod.common.api.spawning.CobblemonSpawnRules
 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
@@ -42,7 +43,7 @@ object PlayerSpawnerFactory {
     var influenceBuilders = mutableListOf<(player: ServerPlayer) -> SpawningInfluence?>({
         PlayerLevelRangeInfluence(
             it,
-            variation = 5
+            variation = TYPICAL_VARIATION
         )
     }, { RestrictedSpawnBlocksInfluence() })
 

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

@@ -30,8 +30,9 @@ abstract class TriggerSpawner<T : SpawnCause>(override val name: String, var spa
     private var selector: SpawningSelector = FlatContextWeightedSelector()
     override val influences = mutableListOf<SpawningInfluence>()
 
-    open fun run(cause: T, world: ServerLevel, pos: BlockPos): CompletableFuture<*>? {
+    open fun run(cause: T, world: ServerLevel, pos: BlockPos, influences: List<SpawningInfluence> = emptyList()): CompletableFuture<*>? {
         val context = parseContext(cause, world, pos) ?: return null
+        context.influences.addAll(influences)
         selector.select(this, listOf(context))?.let { (_, spawn) ->
             val action = spawn.doSpawn(context)
             action.complete()

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

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

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

@@ -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
     }
 }

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

@@ -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 }

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

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

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

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

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

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

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

@@ -113,16 +113,13 @@ object BattleBuilder {
         player2Actor.battleTheme = player1.getBattleTheme()
 
         return if (errors.isEmpty) {
-            var result: BattleStartResult = errors
             BattleRegistry.startBattle(
                 battleFormat = battleFormat,
                 side1 = BattleSide(player1Actor),
                 side2 = BattleSide(player2Actor)
             ).ifSuccessful {
                 it.battlePartyStores.addAll(battlePartyStores)
-                result = SuccessfulBattleStart(it)
             }
-            result
         } else {
             errors
         }
@@ -214,13 +211,12 @@ object BattleBuilder {
 
         return if (errors.isEmpty) {
             BattleRegistry.startBattle(
-                    battleFormat = battleFormat,
-                    side1 = BattleSide(playerActors[0], playerActors[1]),
-                    side2 = BattleSide(playerActors[2], playerActors[3])
+                battleFormat = battleFormat,
+                side1 = BattleSide(playerActors[0], playerActors[1]),
+                side2 = BattleSide(playerActors[2], playerActors[3])
             ).ifSuccessful {
                 it.battlePartyStores.addAll(battlePartyStores)
             }
-            errors
         } else {
             errors
         }
@@ -287,7 +283,6 @@ object BattleBuilder {
         playerActor.battleTheme = pokemonEntity.getBattleTheme()
 
         return if (errors.isEmpty) {
-            var result: BattleStartResult = errors
             BattleRegistry.startBattle(
                 battleFormat = battleFormat,
                 side1 = BattleSide(playerActor),
@@ -296,9 +291,7 @@ object BattleBuilder {
                 if (!cloneParties) {
                     pokemonEntity.battleId = it.battleId
                 }
-                result = SuccessfulBattleStart(it)
             }
-            result
         } else {
             errors
         }
@@ -367,16 +360,13 @@ object BattleBuilder {
         playerActor.battleTheme = npcEntity.getBattleTheme()
 
         return if (errors.isEmpty) {
-            var result: BattleStartResult = errors
             BattleRegistry.startBattle(
                 battleFormat = battleFormat,
                 side1 = BattleSide(playerActor),
                 side2 = BattleSide(npcActor)
             ).ifSuccessful { battle ->
                 npcEntity.entityData.update(NPCEntity.BATTLE_IDS) { it + battle.battleId }
-                result = SuccessfulBattleStart(battle)
             }
-            result
         } else {
             errors
         }

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

@@ -8,6 +8,7 @@
 
 package com.cobblemon.mod.common.battles
 
+import com.cobblemon.mod.common.Cobblemon
 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.BattleStartedPostEvent
@@ -178,19 +179,35 @@ object BattleRegistry {
         ShowdownService.service.startBattle(battle, messages.toTypedArray())
     }
 
+    /**
+     * Instantiates a new [PokemonBattle] and launches the Showdown service.
+     *
+     * @param battleFormat The format to use for the battle.
+     * @param side1 The first side for the battle.
+     * @param side2 The second side for the battle.
+     * @param canPreempt Whether the battle can be blocked by subscribers to [CobblemonEvents.BATTLE_STARTED_PRE].
+     *
+     * NOTE: this does NOT validate the [battleFormat] or sides before launching Showdown.
+     * This creates the battle and hands it off to Showdown - YOU WILL GET ISSUES IF THE BATTLE IS INVALID!
+     * See [BattleBuilder] functions for how the various types of battles are built and validated.
+     */
     fun startBattle(
         battleFormat: BattleFormat,
         side1: BattleSide,
         side2: BattleSide,
-        silent: Boolean = false
+        canPreempt: Boolean = true
     ): BattleStartResult {
         val battle = PokemonBattle(battleFormat, side1, side2)
-        if (silent) return SuccessfulBattleStart(battle)
+        val start: () -> Unit = {
+            battleMap[battle.battleId] = battle
+            startShowdown(battle)
+        }
+
+        if (!canPreempt) start().also { return SuccessfulBattleStart(battle) }
 
         val preBattleEvent = BattleStartedPreEvent(battle)
         CobblemonEvents.BATTLE_STARTED_PRE.postThen(preBattleEvent) {
-            battleMap[battle.battleId] = battle
-            startShowdown(battle)
+            start()
             CobblemonEvents.BATTLE_STARTED_POST.post(BattleStartedPostEvent(battle))
             return SuccessfulBattleStart(battle)
         }

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

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

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

@@ -107,7 +107,7 @@ interface Targetable {
             MoveTarget.adjacentAllyOrSelf -> null
             MoveTarget.adjacentFoe -> null
             MoveTarget.foeSide -> getAllActivePokemon().filter { !it.isAllied(this) }
-            MoveTarget.scripted -> null
+            MoveTarget.scripted -> listOf(this)
             else -> null
         }
     }

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

@@ -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) }
@@ -69,7 +69,7 @@ object ShowdownInterpreter {
         updateInstructionParser["-copyboost"]            = { _, _, message, _ -> CopyBoostInstruction(message) }
         updateInstructionParser["-crit"]                 = { _, instructionSet, message, _ -> CritInstruction(message, instructionSet) }
         updateInstructionParser["-curestatus"]           = { _, _, message, _ -> CureStatusInstruction(message) }
-        updateInstructionParser["detailschange"]         = { _, _, message, _ -> DetailsChangeInstruction(message) }
+        updateInstructionParser["detailschange"]         = { _, _, message, _ -> FormeChangeInstruction(message) }
         updateInstructionParser["-endability"]           = { _, _, message, _ -> EndAbilityInstruction(message) }
         updateInstructionParser["-end"]                  = { _, _, message, _ -> EndInstruction(message) }
         updateInstructionParser["-enditem"]              = { _, _, message, _ -> EndItemInstruction(message) }
@@ -78,6 +78,7 @@ object ShowdownInterpreter {
         updateInstructionParser["-fieldactivate"]        = { _, _, message, _ -> FieldActivateInstruction(message) }
         updateInstructionParser["-fieldend"]             = { _, _, message, _ -> FieldEndInstruction(message) }
         updateInstructionParser["-fieldstart"]           = { _, _, message, _ -> FieldStartInstruction(message) }
+        updateInstructionParser["-formechange"]          = { _, _, message, _ -> FormeChangeInstruction(message) }
         updateInstructionParser["-hitcount"]             = { _, _, message, _ -> HitCountInstruction(message) }
         updateInstructionParser["-immune"]               = { _, _, message, _ -> ImmuneInstruction(message) }
         updateInstructionParser["-invertboost"]          = { _, _, message, _ -> InvertBoostInstruction(message) }

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

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

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

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

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

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

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

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

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

@@ -1,34 +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.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.battles.dispatch.InterpreterInstruction
-import com.cobblemon.mod.common.util.battleLang
-
-/**
- * Format: |detailschange|POKEMON|DETAILS|HP STATUS
- *
- * POKEMON has changed formes permanently (i.e. Mega Evolution) to DETAILS.
- * @author Segfault Guy
- * @since September 10th, 2023
- */
-class DetailsChangeInstruction(val message: BattleMessage): InterpreterInstruction {
-
-    override fun invoke(battle: PokemonBattle) {
-        val battlePokemon = message.battlePokemon(0, battle) ?: return
-        val formName = message.argumentAt(1)?.split(',')?.get(0)?.substringAfter('-')?.lowercase() ?: return
-        battle.dispatchWaiting {
-            val pokemonName = battlePokemon.getName()
-            battle.broadcastChatMessage(battleLang("detailschange.$formName", pokemonName))
-            battle.majorBattleActions[battlePokemon.uuid] = message
-        }
-    }
-}

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

@@ -0,0 +1,51 @@
+/*
+ * 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.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
+
+/**
+ * Format: |-formechange|POKEMON|SPECIES|HP STATUS or |detailschange|POKEMON|DETAILS|HP STATUS
+ *
+ * POKEMON has temporarily (-formechange) or permanently (detailschange) changed form to SPECIES/DETAILS.
+ * @author Segfault Guy
+ * @since December 9th, 2024
+ */
+class FormeChangeInstruction(val message: BattleMessage): InterpreterInstruction {
+
+    override fun invoke(battle: PokemonBattle) {
+        val battlePokemon = message.battlePokemon(0, battle) ?: return
+        val details = message.argumentAt(1)?.split(',')?.get(0)?.lowercase() ?: return
+        val speciesName = details.substringBefore('-')
+        val formName = details.substringAfterLast('-').ifBlank { speciesName }
+        val typeKey = if (message.id == "detailschange") "permanent" else "temporary"
+
+        ShowdownInterpreter.broadcastOptionalAbility(battle, message.effect(), battlePokemon)
+
+        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
+                "school", "wishiwashi", "meteor", "minior" -> battleLang("formechange.$formName", pokemonName)
+                speciesName -> battleLang("formechange.default.temporary.end", pokemonName)
+                else -> battleLang("formechange.default.$typeKey", pokemonName, formName)
+            }
+            battle.broadcastChatMessage(lang)
+        }
+    }
+}

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

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

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

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

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

@@ -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)
         }

common/src/main/kotlin/com/cobblemon/mod/common/battles/pokemon/BattlePokemon.kt

@@ -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
 }

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

@@ -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
+    }
 }