Fixes to mistypes and wrong tms getting in (looking at you terablast)

Changes for Default TMs By Slippy
2026-10-30 13:58:53 -04:00 · 2026-08-13 23:01:40 +03:00 · 2026-08-13 21:59:22 +03:00
3796 changed files with 25393 additions and 153436 deletions
@@ -1,41 +1,518 @@
 # Changelog
-## [1.8.1 (September 13th, 2026)](#1-8-1)
+## [1.8.0 (MONTH Xth, 2026)](#1-8-0)
 ### Additions
 - Added config options to award experience to fainted Pokémon for opponents they helped defeat (`awardExperienceToFaintedPokemon`) and to still award experience for defeated enemies even after battle loss/forfeit (`awardExperienceOnBattleLoss`)
 - Party Overlay Exp Gained Animation will now display the amount of EXP the Pokémon gained
 - Added a toast to notify players of how they can scroll through their party. Did you know you can hold R and scroll instead of using arrow keys??!
 - Added a new layer property that makes a layer scroll in a direction. "scrolling": {"speedU": 0.1, "speedV": 0.1}
 - Added missing crops to Botany Pots integration
 - Added a way to obtain Porygon by inserting the Upgrade or Dubious Disc into a data monitor
 - Added a new `cobblemon:structure`, which is a feature without any restrictions allowing the Builders to place certain structures in much more specific manner.
 - Added Configs for Infinite Use TMs and Unlocking all TMs
 - Added Type Gem blocks
 - Added Type Gem Clusters
 - Added TMs
 - Added TM Machine
 - Added Deepslate Core Block
 - Added /givetm Command
 - Added advancement triggers for learning TMs: `cobblemon:has_learn_specific_tm` (per-TM), `cobblemon:has_learn_all_tm` (all TMs learned), and `cobblemon:tms_learned` (count-based), backed by a new `totalTMLearnedCount` on player advancement data.
 - Added `cobblemon:catch_alpha_pokemon` advancement trigger and `totalAlphaCaptureCount` tracking for capturing Alpha Pokémon.
 - Added Move Dex to Pokédex
 - Added the Habitat Block, a spawner block for servers and adventure maps that controls spawning in an area.
 - Added Disk Rack for storing disks and being an audio sequencer for Noteblocks
 - Added intrinsic scaling to all Pokémon (+-5%). Some rendering cases, such as shoulder mounting, revert to 1.0 scaling to preserve animation accuracy.
 - Added scaling to "baby" Pokémon (smaller (-20%) at level 1 → normally sized at level 10)
 - Added conditional seats for riding. Seats can be gated by molang such as "is_alpha".
 - Added Alpha Pokémon
    - Added alpha scaling (alphas are larger than their normal counterparts)
    - Alphas will always lead herds and will spawn in herds
    - Alphas spawn with two random TM moves from their learnset
    - Alpha Pokémon will always defend themselves from players that attack them
    - Added alpha level matching and stat boost (based on level)
    - Added pitch-down and reverb to alpha cries
    - Added alpha Pokémon bait effect
    - Added alpha eye rendering including eye overlay, bloom, eye trail, and particles.
 - Added cobweb block slowness immunity for spider Pokémon
 - Added 49 new habitat structures. 34 as typical Minecraft structures and 15 as structures that get placed as biome features to allow for more natural placement in generation. Structures placed as biome features will not be able to be located with the `/locate structure` command.
 - Vanilla village house template pools have been adjusted to account for the new abandoned village structure habitat. Weights have changed within the JSON file for every piece to ensure too many habitats don't generate in a single village.
 - Added 10 new ruin structures.
 - rooted_arch_ruins & crumbling_arch_ruins have been transferred over to biome features, allowing for better placement in generation.
 - All ruin structures that did not generate with a gimmighoul/gilded chest before will now generate with one.
 - All ruin structures gilded chest loot tables have been updated to include a guaranteed TM not learned naturally by any Pokémon through their level-up moveset. Each ruin gets its own specific TM, so you can now go hunting ruins to complete your move dex!
 - All fossil structures have been transferred over to biome features, allowing for better placement in generation.
 - The prehistoric_underwater_fissure & prehistoric_submerged_impact fossil structures now use the biome tag `#cobblemon:is_temperate_ocean`.
 - Gimmighoul towers now generate at ground level rather than sinking one block into the ground.
 - A new shipwreck cove structure called the "magma_shipwreck_cove" has been added.
 - Shipwreck coves now generate slightly more frequently.
 - Added equipment loot tables for shipwreck cove enemies.
 - Maps from abandoned fishing boats leading to shipwreck coves now will skip explored chunks, allowing the player to find more shipwreck coves easier.
 - The lush shipwreck cove's phantom mob spawner has been replaced with breezes.
 - The lush shipwreck cove structure itself has been slightly cleaned up to be less noisy with the blocks it is built out of.
 - All shipwreck coves' spawners have been adjusted to give compatible mobs enchanted iron or diamond armour and weapons while in its ominous state. The armour given to the mobs will also use the automaton trim. We upped the difficulty because it was too easy now that your Pokémon can fight for you.
 - One TM of the elemental hyper beams has been added as guaranteed loot to the main treasure chest in every shipwreck cove. (Magma cove gets blast burn, lush cove gets frenzy plant, and submerged cove gets hydro cannon)
 - Added 7 new advancements
 - Pressing the inventory key now closes the Pokémon interact wheel GUI
 - Pokémon cries now play when clicking Pokémon in the summary screen.
 - Pressing the Summary key while either the starter selection or summary screen are open now closes those screens
 - Ice type Pokémon are now immune to Packed Snow
 - Held item visibility can now be controlled by the held_item_visible command argument.
 ### New rideable Pokémon
 - Crobat
 - Skarmory
 - Milotic
 - Archeops
 - Goodra 
 - Goodra (Hisuian Form)
 - Drampa
 - Duraludon
 - Archaludon
 ### Pokémon Added
 #### Generation 3
 - Wurmple
 - Silcoon
 - Beautifly
 - Cascoon
 - Dustox
 - Skitty
 - Delcatty
 - Seviper
 - Zangoose
 #### Generation 4
 - Cherubi
 - Cherrim
 - Stunky
 - Skuntank
 #### Generation 5
 - Audino
 - Pawniard
 - Bisharp
 #### Generation 6
 - Pancham (+ Cosmetic with Black Glasses)
 - Pangoro (+ Cosmetic with Black Glasses)
 #### Generation 7
 - Rockruff
 - Lycanroc
 #### Generation 8
 - Rolycoly
 - Carkol
 - Coalossal
 - Runerigus
 - Snom
 - Frosmoth
 - Indeedee
 - Duraludon
 - Applin
 - Flapple
 - Appletun
 #### Generation 9
 - Nymble
 - Lokix
 - Kingambit
 - Dipplin
 - Archaludon
 - Hydrapple
 #### Regional Forms
 - Sandshrew (Alolan Form)
 - Sandslash (Alolan Form)
 - Yamask (Galarian Form)
 - Avalugg (Hisuian Form)
 ### Model updates for the following Pokémon
 - Sandshrew
 - Sandslash
 - Nidoking
 - Zubat
 - Golbat
 - Crobat
 - Ditto
 - Porygon
 - Porygon2
 - Porygon-Z
 - Skarmory
 - Smoochum
 - Jynx
 - Popplio
 - Brionne
 - Primarina
 - Fletchling
 - Fletchinder
 - Talonflame
 - Sableye
 - Mawile
 - Goomy
 - Sliggoo
 - Goodra
 - Nacli
 - Naclstack
 - Garganacl
 - Bidoof
 - Cranidos
 - Chatot
 - Yamask
 - Cofagrigus
 - Tyranitar
 - Turtonator
 - Golett
 - Corsola
 - Arbok (New Patterns: Angry, Cartoon, Clown, Comedic, Crow, Grin, Ink, Modern, Rain, Scribble, Silence, Sloth, Suspicious, Will)
 - ... and Substitute
 #### Model changes to the regional bias resource pack:
 - Added Mime Jr. (Galar Bias)
 - Added Bergmite (Hisui Bias)
 - Changed models for every existing regional bias
 ### Animation updates for the following Pokémon
- Flapple, Appletun, Dipplin, Hydrapple (placeholder animations only).
+
 - Kakuna
 - Grimer
 - Nidoran♀ (+ New shoulder mount)
 - Nidorina
 - Nidoran♂ (+ New shoulder mount)
 - Sandshrew
 - Diglett
 - Dugtrio
 - Graveler
 - Happiny
 - Chansey
 - Blissey
 - Poliwhirl
 - Poliwrath
 - Zubat
 - Vulpix
 - Drowzee
 - Hypno
 - Noctowl
 - Skarmory
 - Skitty
 - Flygon
 - Shellos
 - Riolu
 - Lucario
 - Purrloin
 - Liepard
 - Joltik
 - Galvantula
 - Nidoking
 - Fletchling
 - Fletchinder
 - Talonflame
 - Archeops
 - Drampa
 - Sewaddle
 - Swadloon
 - Leavanny
 - Goomy
 - Sliggoo
 - Goodra
 - Shedinja
 - Skwovet
 - Greedent
 - Bidoof
 - Cranidos
 - Chatot
 - Yamask
 - Cofagrigus
 - Luvdisc
 - Staryu
 - Starmie
 - Togetic
 - Rellor
 - Rabsca
 - Yungoos
 - Gumshoos
 - Cottonee
 - Whimsicott
 - Corsola
 #### Added sounds to the following moves
 - Absorb
 - Aurora Beam
 - Double Team
 - Draco Meteor
 - Fire Punch
 - Fire Spin
 - Flame Charge
 - Flame Wheel
 - Giga Drain
 - Ice Punch
 - Leech Life
 - Magical Leaf
 - Mega Drain
 - Minimize
 - Poison Gas
 - Rock Throw
 - Scary Face
 - Seed bomb
 - Smokescreen
 - String Shot
 - Tail Whip
 ### Changes
 - Stat increase and decrease particles have been changed, with the addition of alpha boost particles. 
 - Dragonite's mailbag cosmetic can now also be obtained with a chest in the cosmetic slot
 - Adjusted Croagunk's walkspeed
 - Adjusted Aerodactyl's walkspeed
 - Sharp Beak can now be crafted
 - Metal Alloy can now be crafted
 - Ability Capsules can now be brewed
 - Using an Ability Capsule will now return an Empty Bottle
 - The following items can now be obtained by brushing the following Pokémon:
  - Pink Wool - Wigglytuff
  - White Wool - Swablu, Altaria
  - Shed Shell - Ekans, Arbok, Dratini, Dragonair, Dunsparce, Treecko, Grovyle, Sceptile, Seviper, Scraggy, Scrafty, Helioptile, Heliolisk, Salandit, Salazzle, Sobble, Drizzile, Inteleon, Silicoblra, Sandaconda, Toxel, Toxtricity, Orthworm, Dudunsparce
  - Phantom Membrane - Dreepy, Drakloak, Dragapult
 - The following items can now be obtained by evolving the following Pokémon into any of their evolutions:
  - Turtle Scute - Squirtle, Wartortle, Turtwig, Grotle, Tirtouga, Chewtle
  - Shed Shell - Metapod, Kakuna, Ekans, Paras, Venonat, Krabby, Scyther, Kabuto, Dratini, Dragonair, Ledyba, Spinarak, Yanma, Pineco, Dunsparce, GLigar, Pupitar, Treecko, Grovyle, Silcoon, Cascoon, Surskit, Nincada, Trapinch, Vibrava, Corphish, Anorith, Bagon, Shelgon, Kricketot, Burmy, Combee, Skorupi, Swadloon, Whirlipede, Dwebble, Scraggy, Karrablast, Joltik, Larvesta, Spewpa, Clauncher, Helioptile, Charjabug, Crabrawler, Cutiefly, Dewpider, Salandit, Wimpod, Poipole, Sobble, Drizzile, Dottler, Silicobra, Toxel, Sizzlipede, Snom, Tarountula, Nymble, Rellor
 - Saccharine Leaves now drop Tart, Sweet, or Syrupy Apples, depending on their honey coating stage, instead of vanilla Apples
 - Fixed the height of the Tumblestone Bud items when held in hand, placed on head, viewed in a GUI, and placed in an Item Frame
 - Refactored all advancements, removing several deemed unnecessary. Due to this refactor, all previously obtained advancements will be reset besides the root (for picking a starter Pokémon). We are sorry for the inconvience, but it makes the tab cleaner and simplifies future advancements.
 - Restructured Botany Pots integration folder structure
 - Decrease the default pastured mon wander radius to 32.
 - Factor in the weight of Pokémon when calculating pushing forces between hitboxes.
 - Remade the Starter Selection Screen with new assets
 - Refactored berry trees to be less impactful on TPS (more performant)
 - Changed the bait effects of the following items: (Vanilla) Sweet & Glow Berries, Golden & Enchanted Golden Apples (Cobblemon) Custap, Eggant, Hopo & Micle Berries, Sweet Hearts
 - Wild Pokémon now reliably have at least one offensive move if they can have offensive moves at that level.
 - Data Monitor can accept Disks (TMs, Music Disks, Upgrade, Dubious Disk, etc.) to change what's being displayed on the screen
 - Rider positioning is now client-driven (Remove poseOffsets and offset per seat/pose) in favour of sending real-time passenger position.
 - Cleaned up seat data. Removed all now unused fields from seats in all species files. Also made locator seat names explicit in the species files (however, this doesn't break the legacy format)
 - Marks can now provide aspects.
 - Added new shiny and Alpha chance configs
 - Apricorns now make a new sound when harvested
 - Lowered the volume of harvesting berries
 - Added alternate versions of the basic PC Wallpapers based on the original design of Cobblemon's PC, before public release
 - Improved compatibility with various mods
    - Farmer's Delight's cutting board can now be used to strip Apricorn and Saccharine's logs, or salvage their planks from various blocks. It can also separate their boats from chests
    - Farmer's Delight's cutting board can be used to get two white dye from Pep-Up Flowers and two magenta dye from Medicinal Leeks
    - Farmer's Delight's cutting board can separate Tumblestone Blocks back into Tumblestones
    - Farmer's Delight's cutting board can salvage Type Gems from their Gem Blocks
    - Farmer's Delight's Onions, Tomatoes, and Cabbages can be used to cook Open-Faced Sandwiches. Nature's Spirit's Olives also can be used
    - Farmer's Delight's cutting board can be used on Hearty Grains to obtain rice and straw, similarly to Farmer's Delight's Rice Panicles
    - Farmer's Delight's Apple Pies and Apple Ciders can now be made using Applin Apples, alongside the Vanilla counterpart
    - Amendments allows for cooking Leek and Potato Stew in a Cauldron
    - Any mods that utilise Moonlight's Soft Fluid system can store Leek and Potato Stew, Medicinal Brew, Antidote, Awakening, Burn Heal, Ice Heal, Paralyze Heal, Full Heal, Potion, Super Potion, Hyper Potion, Max Potion, Full Restore, Ability Capsules, Moomoo Milk, and Berry Juice in liquid form (such as Suplementaries' Jar or Goblet, or Cauldrons while using Amendments)
    - Supplementaries' Hourglass can now use Bright Powder, Quick Powder, Metal Powder, Heal Powder, Silver Powder, and Remedy
    - Berry Trees are now compatible with the Planter properly
    - Saccharine Way Signs (added by Supplementaries automagically) now use a premade texture to prevent odd visual issues
    - Supplementaries' Jar can now store various Cobblemon cookies, candies, and similar items
    - Some of Supplementaries' items have been added to the `#cobblemon:held/container_held_items` item tag, including sacks, safes, and lunch baskets
    - Experience Nuggets can be used in place of Sculk for making the EXP Candies if using Create
    - Rage Candy Bar has a Create Mixing recipe
    - All Cobblemon ores can now be crushed in Create's Crushing Wheels
    - All Gem and Tumblestone Clusters can be crushed for automatic, low return, gems
    - Hearty Grains can be milled like Farmer's Delight Rice Panicles if both Farmer's Delight and Create are installed
    - Big Roots and Revival Herbs can be milled to their respective powders
    - Pep-Up Flowers, Medicinal Leeks, and all 70 berries can be milled in Create's Millstone for additional dye drops
    - Auspicious Armour and Upgrades can be Haunted using Create's crafting systems
    - Applin Apples can be used to make Honeyed Apples in Create
 - Golden Apples can now be crafted using the Applin Apples
 - Prismarine Crystals and Amethyst Shards can now be used to craft Pokedexes
 - Updated Pokédex Screens item tag to support tagged variants of Redstone and Glowstone Dust
 - Sounds for interacting with various Cobblemon blocks now play from the centre of the block, rather than the corner
 - The `/pc` command no longer plays PC activation sounds
 ### Fixes
- Fixed a potential world generation stall caused by Type Gem clusters.
+- Fixed Blitzle's base scale being `1` rather than the intended `0.8`
- Fixed Pokémon on shoulders not animating if they are visibly holding a held item.
+- Fixed Magnezone's emissive layer for the shiny having the wrong name, thus displaying wrongly
- Fixed NPCs getting their own TM progress file.
+- Fixed Litleo not blinking
- Fixed odd NeoForge crash due to a dependency being outdated. It will now correctly flag the dependency for being outdated.
+- Fixed Omanyte and Omastar incorrectly using water animations on land.
- Fixed the TM Machine refusing move selections that the `unlockAllMoveDexMovesByDefault` config had made visible, leaving the move slot blank and the craft button unresponsive.
+- Fixed Pokédex layout for genderless variations
- Fixed the Beast Ball not applying its 0.1× penalty to Pokémon that are not Ultra Beasts.
+- Fixed odd stacking behaviour with the poke_bait item.
- Fixed the Moon Ball reading the world's total elapsed time instead of the time of day, so its bonus applied during the day instead.
+- Fixed a compatibility issue with World Game Rules which caused some log spam in specific cases.
- Fixed the Love Ball never awarding its 2.5× opposite gender bonus, and matching species by display name instead of identifier.
+- Fixed improper validation of Pokémon when performing a trade.
- Fixed the Timer Ball being weaker than a regular Poké Ball on early turns and only reaching 4× on turn 14 instead of turn 10.
+- Fixed an issue where particle like beam can disappear when you don't see the beginning of the beam, or you look away
- Fixed the Luxury Ball only doubling Friendship gains of 1, leaving level up and berry gains unaffected.
+- Fixed Bedrock particle materials (alpha/opaque/blend/add) sharing one render batch, which caused incorrect culling on mixed batches; each material now batches and draws with its own blend and cull state, and the alpha material renders as a true cutout
- Fixed Rufflet, Braviary, and Hisuian Braviary flooding logs with errors about missing sound events.
+- Fixed an occasional crash on retrieving revived fossils
- Fixed Pokémon property typos in Pangoro and Dedenne herd spawn files.
+- Fixed brushing not working on Neoforge
- Fixed unintentional watermelon cosmetic for Hisuian Electrode. 
+- Fixed braking not working for submarines (whoops).
- Fixed Blastoise having an unintentional passenger seat.
+- Fixed strafing not having the same friction as forward movement (funny whoops).
- Fixed form typo in Rockruff-Dusk spawn, preventing it from being able to spawn.
+- Fixed submarine's surface-water animations not playing when supposed to.
- Fixed the `stat_compare` and `stat_equal` evolution requirements crashing the game when given `special_attack` or `special_defence`, and made them treat any non-permanent stat as a failed requirement instead of crashing.
+- Fixed submarine camera freaking out when looking up or down on the surface.
- Fixed Rowap and Jacoba berries not correctly altering Pokémon sizes when used as bait.
+- Fixed pastured mons despawning and running away.
- Fixed Ampharos' eyes not emitting particles.
+- Fixed Apricorn trees crashing when other mods bonemeal it
- Fixed Alolan Raticate's cry not playing.
+- Fixed the issue that caused Hover Behaviour rides without a ground style to be rendered useless upon touching the ground on a server.
- Fixed several incorrect light-based spawning conditions for ghosts and bugs. 
+- Removed the "inAir" penalty for block destruction speed when on a hover mount.
- Removed unused, placeholder habitat pools.
+- Fixed horizontal and vertical collisions with hover mounts so they no longer accumulate or retain momentum
- Fixed Mantyke, Mantine, and Quaxly getting stuck in a recoil 'expression' during battles due to having an expression assigned as a recoil animation. 
+- Fixed NeoForge brewing stand unexpectedly crashing users when shift clicking items within its menu
- Fixed Lucario's aura particles not emitting.
+- Fixed NPCs switching Pokémon very often during battles
- Fixed Lycanroc's head movement.
+- Fixed Campfire pot causing crashes under certain circumstances
- Added head movement to Archaludon.
+- Fixed Type Gems not being consumed upon use
- Fixed Duraludon line not having their sleep animations.
+- Fixed Ancient Pokéball's to their respective modifiers
- Fixed Diglett line not having their faint animations.
+- Fixed a Server warning when recalling Pokémon
- Fixed Kingambit moving its legs while walking.
+- Fixed sliding particles incorrectly handling block collision
 - Fixed Full Heal not curing status conditions in battle
 - Fixed a rare issue with battles locking up when you are forced to switch, with the switch menu appearing instantly.
 - Fixed the combined effects of Pledge moves having broken Showdown message handling and localisation
 - Fixed rare Pokémon being far too likely to spawn multiple times in a single spawn cycle. The dev told me that the exact bug is too complicated to explain.
 - Resolved the niche issue where Structures would spawn in an incorrect location, creating very funky world gen.
 - Fixed Galarian Ponyta missing its cry.
 - Fixed various log warnings caused by redundant files and sound events.
 - Traded Pokémon will now retain the original friendship level when traded back to its OT
 - Clusters now display correctly on maps
 - Fixed removing mulch from berry trees with a shovel not working.
 - Fixed collecting honey from Saccharine Leaf blocks deleting Honey Bottles when the inventory was full
 - Fixed Stripped Saccharine Wood recipe being missing
 - Fixed CancelableSoundInstance causing lag by attempting to create sounds every tick when out of range of hearing
 - Fixed Stat Reducing Aprijuice not being possible to apply on a max out Pokémon, and the possibility of going into negatives
 - Fixed Exploit where you could take out the bait or drop your Pokérod with bait to avoid consuming bait, now the bobber will just disappear if you do so
 - Fixed Apricorn and Saccharine boats incorrectly using chest boat models
 - Fixed wild and trainer battle AI refusing to select moves with the `adjacentAlly` target type, even when it's their only option
 - Fixed gilded chests being more accessible than intended
 - Fixed fished up Pokémon not being added as "seen" to the Pokedex
 - Fixed surprised Gimmighoul encounters not being added as "seen" to the Pokedex
 - Fixed a crash involving berry trees that have been world edited.
 - Fixed visual desync in multiplayer for players mounting Pokémon outside other players' loaded chunks
 - Fixed Pokémon entities leveled by rare candy not getting stronger as Minecraft entities unless recalled.
 - Fixed a freeze during game load that occurred when multiple mods tried to load Cobblemon API classes at the same time.
 - Fixed random tick crashes from berry trees
 - Lowered the volume of Blitzle and Zebstrika's cry
 - Regional Foods will now prioritise being eaten instead of used for healing Pokémon, shift clicking will use it as healing
 - Resolved Z-Fighting on Pokédex Models
 - Restored Ninjask's ability to do barrel rolls
 - Fixed Raichu (male) and Alolan Raichu (both genders) not displaying the correct Partner Cap when Pewter Crunchies are in the cosmetic slot.
 - Fixed a crash caused by adding enchanted items to the Resurrection Machine
 - Fixed a crash that could occur when starting a PvN battle with only fainted Pokémon.
 - Fixed the Remember Riding Camera config not being respected when dismounting and resolved the incompatibility with the Auto Third Person mod
 - Fixed Full Heal block not dropping Full Heals
 - Fixed status cure items not returning an empty bottle when used
 - Fixed Panpour consuming its held item when evolving with a Water Stone
 - Fixed Smoked Tail Curry returning a Wooden Bowl when consumed despite it not being included in the recipe
 - Fixed `/giveallpokemon` not respecting the min and max parameters
 - Fixed the choose starter toast not disappearing when capturing a Pokémon instead of opening the starter selection screen
 - Fixed an issue where certain Sinister Tea seasonings were only applying as instant effects and would not apply over time
 - Long config option labels now scroll instead of overflowing
 ### Developer
 - Added `PokeSnackSpawnerFactory` which allows influence registration on PokeSnack encounters
 - Added `FishingSpawnerFactory` which allows influence registration on fishing encounters
 - Added `BattleFleeAttemptEvent` fired from `PokemonBattle.checkFleeAttempt`, allowing developers to intercept and control flee attempts
 - Tweaked the spawning selector interface to take a bucket function rather than a bucket directly.
 - Added a new `cobblemon:height_range` processor type to allow developers to restrict structure-spawning ranges.
 - Separated all the functions of MoLangFunctions.kt into their own files.
 - Spawn buckets and their base weights are now provided by the spawner, with different base weights for world, fishing, snack, and habitat spawn buckets.
 - Removed "SpawnBucket" class in favour of just storing maps of bucket names to weights.
 - Fixed nicknames not being applied to Pokémon spawned from `spawn_pool_world` files.
 - Added support for `profilePokedexScale`, `profilePokedexTranslation`, `profileSummaryScale`, and `profileSummaryTranslation` in poser files for finer control over profile displays.
 - Fixed riding camera offsets defined on Pokémon forms not being applied
 ### Molang & Datapacks
 - Added `moveset_builders` datapack folder for different styles of movesets.
 - Added `party_pools` datapack folder for defining groups of Pokémon for complex NPC party definitions.
 - Added `party_compositions` datapack folder for arranging parties on NPCs that rely on party pools.
 - Added `composed_pool` NPC party provider type which combines a party pool with a party composition to create more complex NPC parties.
 - Added basic chatter NPC Behaviour
 - Added `q.item.is_enchanted()`
 - Added `q.item.has_enchantment(minecraft:sharpness, 3)`
 - Added `has_chosen_starter` & `get_starter_uuid` as available Molang functions
 - Added `has_tm_move_unlocked`, `unlock_tm_move`, & `lock_tm_move` as available Molang functions for Players
 - Added `marks`, `has_mark`, & `remove_marks` as available Molang functions for Pokémon
 - Added Data Component support for species drops, eg `"components": {"minecraft:custom_model_data": 123}`
 - Added the new `sortOrder` field to mark entries, (defaults to 0 if not specified) which controls the order in which marks are rendered on the HUD, with higher numbers being rendered on top of lower numbers
 - Added optional `order` field to starter categories. It will allow explicitly sorting categories in the starter selection screen
 - SpeciesAdditions append vs override now matches wiki documentation
 - Added `weighted_choice` as a new feature type. It requires setting weights for each choice and allows developers to simplify the process of assigning random aspect choice based on marble chance
 - Added `q.world.spawn_loot_table_items(loot_table_id, x, y, z)` which spawns the items from the loot table at the position. (Use type: "minecraft:chest" for the loot table.)
 - Added `q.pokemon.entity` to access the entity of Pokémon.
 - Flamethrower and Seismic Toss had their action effect JSON cleaned up
 - Ride sounds can now be set as exclusive to passengers
 - Ride sounds no longer play when submerged unless specified with a new setting
 - NPC Trainers can now call a `command` animation when issuing a command in battle.
 - Added a q.failed function to move action effects.
 - Herd spawned Pokémon have their levels controlled differently. The `levelRange` property now acts as a clamp instead of a filter, with a new `herdLevelRange` property to do the filter behaviour.
 - `q.sound` now accepts three parameters (sound event, volume and pitch) instead of just the sound event and pitch.
 ### Particles
 #### New Move Animations
 - Blizzard
 - Disarming Voice
 - Draco Meteor
 - Dragon Breath
 - Dragon Rage
 - Drain Punch
 - Fairy Wind
 - Fire Fang
 - Gust
 - Horn Drill
 - Hydro Pump
 - Ice Fang
 - Leafage
 - Leaf Storm
 - Light Screen
 - Night Shade
 - Play Rough
 - Pyro Ball
 - Reflect
 - Rock Slide
 - Sonic Boom
 - Sucker Punch
 - Supersonic
 - Thunder Fang
 #### Tweaks and Fixes (Moves)
 - Confusion
 - Dragon Claw
 - Eruption
 - Fire Punch
 - Flame Burst
 - Flame Charge
 - Flamethrower
 - Frost Breath
 - Hypnosis
 - Ice Punch
 - Icy Wind
 - Mud Sport
 - Poison Fang
 - Protect
 - Psychic
 - Quick Attack
 - Rage Powder
 - Razor Leaf
 - Sand Attack
 - Scratch
 - Shadow Claw
 - Sing
 - Spore
 - String Shot
 - Tackle
 - Tail Whip
 - Thunder
 - Thunder Punch
 - Thunder Wave
 - Water Gun
 - Water Pulse
 - Water Sport
 #### Miscellaneous Particles
 + Added Wild Might particles for Alpha Pokémon
 + Updated stat increase and decrease particles
 ### Localization
 - Updated translations for:
  - Japanese
  - German
  - Spanish
  - Ecuadorian Spanish
  - Portuguese
  - Brazilian Portuguese
  - Simplified Chinese
-  - Japanese
+  - Traditional Chinese
  - Korean
@@ -1,529 +0,0 @@
 # Changelog
 ## [1.8.0 - Make Your Move Update (September 6th, 2026)](#1-8-0)
 #### I think the red eyes mean they're friendly!
 ### Additions
 - Added Alpha Pokémon
    - Alpha Pokémon are bigger, stronger, and more aggressive than regular Pokémon.
    - They are also scarier.
    - They always know a TM move and will adapt to be stronger than your party.
    - Alphas will always lead herds and spawn in herds.
 - Added alpha Pokémon attraction bait effect to Hopo Berries.
 - Added intrinsic scaling to all Pokémon (anywhere from 5% smaller to 5% bigger than normal). Some cases, such as shoulder mounting, will not scale so that the shoulder animations don't look silly.
 - Added scaling to "baby" Pokémon (10% smaller at level 1 → normally sized at level 10).
 - Added TMs.
    - Added TM Machine. TMs are made from elemental type gems, and their recipes are unlocked by having Pokémon that know the move.
    - Added config options for making TMs infinite-use and instant unlocking of all TM recipes.
    - Added Type Gem blocks as well as crystal clusters and deepslate core blocks that are used for growing elemental type gems.
 - Added a new Starter Selection menu that looks way better.
 - Added a "Move Dex" to the Pokédex to help identify what moves a Pokémon can learn and what Pokémon can get a move.
 - Added the Habitat Block, a spawner block for servers and adventure maps that controls spawning in an area.
 - Added 49 new habitat structures. In these habitats you will find rarer Pokémon and sometimes different Pokémon will appear on different days.
 - Added a toast to notify players of how they can scroll through their party. Did you know you can hold R and scroll instead of using arrow keys? It's true!!!
 - Added a way to obtain Porygon by inserting an Upgrade or Dubious Disc into a data monitor.
 - Added Disk Rack for storing disks and being an audio sequencer for Noteblocks. What does that have to do with Pokémon? How about you mind your own business!
 - Added missing crops to Botany Pots integration.
 - Added conditional seats for riding. Seats can be gated by Molang such as "is_alpha".
 - Added 10 new ruin structures.
 - Added a new shipwreck cove structure called the Magma Shipwreck Cove.
 - Added 7 new advancements.
 - Pokémon cries now play when clicking Pokémon in the summary screen.
 - Held item visibility can now be controlled by the `held_item_visible` command argument.
 - Added config option to disable Pokémon spawning on a per-world basis.
 - Added config options to award experience to fainted Pokémon for opponents they helped defeat (`awardExperienceToFaintedPokemon`) and to still award experience for defeated enemies even after battle loss/forfeit (`awardExperienceOnBattleLoss`).
 - Added `/givetm` command.
 - Added advancement triggers for learning TMs: `cobblemon:has_learn_specific_tm` (per-TM), `cobblemon:has_learn_all_tm` (all TMs learned), and `cobblemon:tms_learned` (count-based), backed by a new `totalTMLearnedCount` on player advancement data.
 - Added `cobblemon:catch_alpha_pokemon` advancement trigger and `totalAlphaCaptureCount` stat for captured Alpha Pokémon.
 ### New rideable Pokémon
 - Crobat
 - Skarmory
 - Milotic
 - Archeops
 - Goodra
 - Goodra (Hisuian Form)
 - Drampa
 - Duraludon
 - Archaludon
 ### Pokémon Added
 #### Generation 3
 - Wurmple
 - Silcoon
 - Beautifly
 - Cascoon
 - Dustox
 - Skitty
 - Delcatty
 - Seviper
 - Zangoose
 #### Generation 4
 - Cherubi
 - Cherrim
 - Stunky
 - Skuntank
 #### Generation 5
 - Audino
 - Pawniard
 - Bisharp
 #### Generation 6
 - Pancham (+ Cosmetic with Black Glasses)
 - Pangoro (+ Cosmetic with Black Glasses)
 #### Generation 7
 - Rockruff
 - Lycanroc
 #### Generation 8
 - Rolycoly
 - Carkol
 - Coalossal
 - Runerigus
 - Snom
 - Frosmoth
 - Indeedee
 - Duraludon
 - Applin
 - Flapple
 - Appletun
 #### Generation 9
 - Nymble
 - Lokix
 - Kingambit
 - Dipplin
 - Archaludon
 - Hydrapple
 #### Regional Forms
 - Sandshrew (Alolan Form)
 - Sandslash (Alolan Form)
 - Yamask (Galarian Form)
 - Avalugg (Hisuian Form)
 ### Model updates for the following Pokémon
 - Sandshrew
 - Sandslash
 - Nidoking
 - Zubat
 - Golbat
 - Crobat
 - Ditto
 - Porygon
 - Porygon2
 - Porygon-Z
 - Skarmory
 - Smoochum
 - Jynx
 - Popplio
 - Brionne
 - Primarina
 - Fletchling
 - Fletchinder
 - Talonflame
 - Sableye
 - Mawile
 - Goomy
 - Sliggoo
 - Goodra
 - Nacli
 - Naclstack
 - Garganacl
 - Bidoof
 - Cranidos
 - Chatot
 - Yamask
 - Cofagrigus
 - Tyranitar
 - Turtonator
 - Golett
 - Corsola
 - Arbok (New Patterns: Angry, Cartoon, Clown, Comedic, Crow, Grin, Ink, Modern, Rain, Scribble, Silence, Sloth, Suspicious, Will)
 - ... and Substitute
 #### Model changes to the regional bias resource pack:
 - Added Mime Jr. (Galar Bias)
 - Added Bergmite (Hisui Bias)
 - Changed models for every existing regional bias
 ### Animation updates for the following Pokémon
 - Kakuna
 - Grimer
 - Nidoran♀ (+ New shoulder mount)
 - Nidorina
 - Nidoran♂ (+ New shoulder mount)
 - Sandshrew
 - Diglett
 - Dugtrio
 - Graveler
 - Happiny
 - Chansey
 - Blissey
 - Poliwhirl
 - Poliwrath
 - Zubat
 - Vulpix
 - Drowzee
 - Hypno
 - Noctowl
 - Skarmory
 - Skitty
 - Flygon
 - Shellos
 - Riolu
 - Lucario
 - Purrloin
 - Liepard
 - Joltik
 - Galvantula
 - Nidoking
 - Fletchling
 - Fletchinder
 - Talonflame
 - Archeops
 - Drampa
 - Sewaddle
 - Swadloon
 - Leavanny
 - Goomy
 - Sliggoo
 - Goodra
 - Shedinja
 - Skwovet
 - Greedent
 - Bidoof
 - Cranidos
 - Chatot
 - Yamask
 - Cofagrigus
 - Luvdisc
 - Staryu
 - Starmie
 - Togetic
 - Rellor
 - Rabsca
 - Yungoos
 - Gumshoos
 - Cottonee
 - Whimsicott
 - Corsola
 #### Added sounds to the following moves
 - Absorb
 - Aurora Beam
 - Double Team
 - Draco Meteor
 - Fire Punch
 - Fire Spin
 - Flame Charge
 - Flame Wheel
 - Giga Drain
 - Ice Punch
 - Leech Life
 - Magical Leaf
 - Mega Drain
 - Minimize
 - Poison Gas
 - Rock Throw
 - Scary Face
 - Seed bomb
 - Smokescreen
 - String Shot
 - Tail Whip
 ### Changes
 - Removed the penalty for block destruction speed when on a hover mount, making them better for digging.
 - Golden Apples can now be crafted using the Applin Apples.
 - Prismarine Crystals and Amethyst Shards can now be used to craft Pokedexes.
 - Updated Pokédex Screens item tag to support tagged variants of Redstone and Glowstone Dust.
 - Sharp Beak can now be crafted using bones and Flying Gems.
 - Metal Alloy can now be crafted using iron and Thunder Stones.
 - Ability Capsules can now be brewed from Medicinal Brew and Dragon Breath.
 - Using an Ability Capsule will now return an Empty Bottle.
 - Decreased the default pastured wander radius to 32 blocks.
 - Added alternate versions of the basic PC Wallpapers based on the original design of Cobblemon's PC, before public release.
 - Rooted Arch Ruins, Crumbling Arch Ruins, and all fossil structures have been improved so that they generate more naturally in terrain.
 - Gimmighoul towers now generate at ground-level rather than sinking one block into the ground.
 - All ruin structures that did not generate with a gimmighoul/gilded chest before will now generate with one.
 - All ruin structures gilded chest loot tables have been updated to include a guaranteed TM not learned naturally by any Pokémon through their level-up moveset. Each ruin gets its own specific TM, so you can now go hunting ruins to complete your move dex!
 - The Prehistoric Underwater Fissure and Prehistoric Submerged Impact fossil structures now use the biome tag `#cobblemon:is_temperate_ocean`.
 - The lush shipwreck cove's phantom mob spawner has been replaced with breezes.
 - Shipwreck coves now generate slightly more frequently.
 - Added equipment loot tables for shipwreck cove enemies.
 - Maps from abandoned fishing boats leading to shipwreck coves now will skip explored chunks, allowing the player to find more shipwreck coves more easily.
 - All shipwreck coves' spawners have been adjusted to give compatible mobs enchanted iron or diamond armour and weapons while in its ominous state. The armour given to the mobs will also use the automaton trim. We upped the difficulty because it was too easy now that your Pokémon can fight for you.
 - One TM of the elemental hyper beams has been added as guaranteed loot to the main treasure chest in every shipwreck cove. (Magma Cove gets Blast Burn, Lush Cove gets Frenzy Plant, and Submerged Cove gets Hydro Cannon.)
 - The following items can now be obtained by brushing the following Pokémon:
    - Pink Wool - Wigglytuff
    - White Wool - Swablu, Altaria
    - Shed Shell - Ekans, Arbok, Dratini, Dragonair, Dunsparce, Treecko, Grovyle, Sceptile, Seviper, Scraggy, Scrafty, Helioptile, Heliolisk, Salandit, Salazzle, Sobble, Drizzile, Inteleon, Silicoblra, Sandaconda, Toxel, Toxtricity, Orthworm, Dudunsparce
    - Phantom Membrane - Dreepy, Drakloak, Dragapult
 - The following items can now be obtained by evolving the following Pokémon into any of their evolutions:
    - Turtle Scute - Squirtle, Wartortle, Turtwig, Grotle, Tirtouga, Chewtle
    - Shed Shell - Metapod, Kakuna, Ekans, Paras, Venonat, Krabby, Scyther, Kabuto, Dratini, Dragonair, Ledyba, Spinarak, Yanma, Pineco, Dunsparce, GLigar, Pupitar, Treecko, Grovyle, Silcoon, Cascoon, Surskit, Nincada, Trapinch, Vibrava, Corphish, Anorith, Bagon, Shelgon, Kricketot, Burmy, Combee, Skorupi, Swadloon, Whirlipede, Dwebble, Scraggy, Karrablast, Joltik, Larvesta, Spewpa, Clauncher, Helioptile, Charjabug, Crabrawler, Cutiefly, Dewpider, Salandit, Wimpod, Poipole, Sobble, Drizzile, Dottler, Silicobra, Toxel, Sizzlipede, Snom, Tarountula, Nymble, Rellor
 - Saccharine Leaves now drop Tart, Sweet, or Syrupy Apples, depending on their honey coating stage, instead of vanilla Apples.
 - Fixed the height of the Tumblestone Bud items when held in hand, placed on head, viewed in a GUI, and placed in an Item Frame.
 - Refactored all advancements, removing several deemed unnecessary. Due to this cleanup, all previously obtained advancements will be reset besides the root (for picking a starter Pokémon). This sucks, and we're sorry. We had to do this eventually so better now than later.
 - Forces between colliding hitboxes now factors in the weight of Pokémon.
 - Improved berry tree performance on singleplayer and servers.
 - Updated stat increase and decrease particle effects with the addition of alpha boost particles.
 - Improved the performance of pasture blocks on singleplayer and servers.
 - Changed the bait effects of the following items: (Vanilla) Sweet & Glow Berries, Golden & Enchanted Golden Apples (Cobblemon) Custap, Eggant, Hopo & Micle Berries, Sweet Hearts.
 - Wild Pokémon now reliably have at least one offensive move if they can have offensive moves at that level. No more free lunches with Pokémon that can't even hurt you.
 - Data Monitor can accept Disks (TMs, Music Disks, Upgrade, Dubious Disk, etc.) to change what's being displayed on the screen.
 - The party overlay's experience-gained animation now displays the amount of EXP the Pokémon gained.
 - Pressing the inventory key now closes the Pokémon interact wheel GUI.
 - Updated the sound for harvesting Apricorns.
 - Lowered the volume of harvesting berries.
 - Improved compatibility with various mods
    - Farmer's Delight's cutting board can now be used to strip Apricorn and Saccharine's logs, or salvage their planks from various blocks. It can also separate their boats from chests.
    - Farmer's Delight's cutting board can be used to get two white dye from Pep-Up Flowers and two magenta dye from Medicinal Leeks.
    - Farmer's Delight's cutting board can separate Tumblestone Blocks back into Tumblestones.
    - Farmer's Delight's cutting board can salvage Type Gems from their Gem Blocks.
    - Farmer's Delight's Onions, Tomatoes, and Cabbages can be used to cook Open-Faced Sandwiches. Nature's Spirit's Olives also can be used.
    - Farmer's Delight's cutting board can be used on Hearty Grains to obtain rice and straw, similarly to Farmer's Delight's Rice Panicles.
    - Farmer's Delight's Apple Pies and Apple Ciders can now be made using Applin Apples, alongside the Vanilla counterpart.
    - Amendments allows for cooking Leek and Potato Stew in a Cauldron.
    - Any mods that utilise Moonlight's Soft Fluid system can store Leek and Potato Stew, Medicinal Brew, Antidote, Awakening, Burn Heal, Ice Heal, Paralyze Heal, Full Heal, Potion, Super Potion, Hyper Potion, Max Potion, Full Restore, Ability Capsules, Moomoo Milk, and Berry Juice in liquid form (such as Suplementaries' Jar or Goblet, or Cauldrons while using Amendments).
    - Supplementaries' Hourglass can now use Bright Powder, Quick Powder, Metal Powder, Heal Powder, Silver Powder, and Remedy.
    - Berry Trees are now compatible with the Planter properly
    - Saccharine Way Signs (added by Supplementaries automagically) now use a premade texture to prevent odd visual issues.
    - Supplementaries' Jar can now store various Cobblemon cookies, candies, and similar items.
    - Some of Supplementaries' items have been added to the `#cobblemon:held/container_held_items` item tag, including sacks, safes, and lunch baskets.
    - Experience Nuggets can be used in place of Sculk for making the EXP Candies if using Create.
    - Rage Candy Bar has a Create Mixing recipe.
    - All Cobblemon ores can now be crushed in Create's Crushing Wheels. All Gem and Tumblestone Clusters can be crushed for automatic, low return, gems.
    - Hearty Grains can be milled like Farmer's Delight Rice Panicles if both Farmer's Delight and Create are installed.
    - Big Roots and Revival Herbs can be milled to their respective powders.
    - Pep-Up Flowers, Medicinal Leeks, and all 70 berries can be milled in Create's Millstone for additional dye drops.
    - Auspicious Armour and Upgrades can be Haunted using Create's crafting systems.
    - Applin Apples can be used to make Honeyed Apples in Create.
 - Sounds for interacting with various Cobblemon blocks now play from the centre of the block, rather than the corner. You probably didn't notice.
 - Dragonite's mailbag cosmetic can now also be obtained with a chest in the cosmetic slot.
 - Adjusted the walk speed for Croagunk and Aerodactyl.
 - The `/pc` command no longer plays PC activation sounds
 - Pressing the Summary key while either the starter selection or summary screen are open now closes those screens.
 - Ice type Pokémon are now immune to Packed Snow.
 - Added cobweb block slowness immunity for spider Pokémon
 ### Fixes
 - Fixed rare Pokémon being far too likely to spawn multiple times in a single spawn cycle. The dev told me that the exact bug is too complicated to explain.
 - Fixed Omanyte and Omastar incorrectly using water animations on land.
 - Fixed Pokédex layout for genderless variations.
 - Fixed odd stacking behaviour with Poké Baits.
 - Fixed a compatibility issue with World Game Rules which caused some log spam in specific cases.
 - Fixed improper validation of Pokémon when performing a trade.
 - Fixed an issue where particles like beams can disappear when you don't see the beginning of the beam, or you look away.
 - Fixed Bedrock particle materials sometimes being incorrectly invisible from some sides.
 - Fixed an occasional crash on retrieving revived fossils.
 - Fixed brushing not working on Neoforge. Again.
 - Fixed braking not working for submarine-style mounts (whoops).
 - Fixed strafing not having the same friction as forward movement (funny whoops).
 - Fixed submarine-style mounts' surface-water animations not playing when supposed to.
 - Fixed submarine-style mounts' camera freaking out when looking up or down on the surface.
 - Fixed pastured Pokémon despawning and running away.
 - Fixed Apricorn trees crashing when other mods bonemeal them.
 - Fixed the issue that caused hover-style mounts without a ground style to be rendered useless upon touching the ground on a server.
 - Fixed horizontal and vertical collisions with hover-style mounts so they no longer accumulate or retain momentum.
 - Fixed NeoForge brewing stand unexpectedly crashing users when shift clicking items within its menu. Well, I suppose all crashes are unexpected. You know what I mean.
 - Fixed NPCs switching Pokémon very often during battles.
 - Fixed Campfire Pot causing crashes under certain circumstances.
 - Fixed Type Gems not being consumed upon use in battles.
 - Fixed several Ancient Pokéball's not using the correct capture multiplier.
 - Fixed a server warning that could occur when recalling Pokémon.
 - Fixed sliding particles incorrectly handling block collision.
 - Fixed Full Heal not curing status conditions in battle. Literally it's one job.
 - Fixed a rare issue with battles locking up when you are forced to switch, with the switch menu appearing instantly.
 - Fixed the combined effects of Pledge moves having broken Showdown message handling and localisation.
 - Fixed a very niche issue where structures would spawn in an incorrect location, creating very funky world gen.
 - Fixed Galarian Ponyta missing its cry.
 - Fixed various log warnings caused by redundant files and sound events.
 - Traded Pokémon will now retain the original friendship level when traded back to its OT.
 - Tumblestone Clusters now display correctly on maps.
 - Fixed removing mulch from berry trees with a shovel not working. That was meant to be a thing.
 - Fixed collecting honey from Saccharine Leaf blocks deleting Honey Bottles when the inventory was full.
 - Fixed Stripped Saccharine Wood recipe being... not there.
 - Fixed some performance issues with a kind of sound event causing lag by attempting to create sounds every tick when out of range of hearing.
 - Fixed stat-reducing Aprijuice not being possible to apply on a maxed out Pokémon. Also fixed the possibility of going into negatives.
 - Fixed exploit where you could take out the bait or drop your Pokérod with bait to avoid consuming bait, now the bobber will just disappear if you do so.
 - Fixed Apricorn and Saccharine boats incorrectly using chest boat models.
 - Fixed wild and trainer battle AI refusing to select moves with the `adjacentAlly` target type, even when it's their only option.
 - Fixed gilded chests being more accessible than intended.
 - Fixed fished up Pokémon not being added as "seen" to the Pokédex.
 - Fixed surprised Gimmighoul encounters not being added as "seen" to the Pokédex.
 - Fixed a crash involving berry trees that have been world edited.
 - Fixed visual desync in multiplayer for players mounting Pokémon outside other players' loaded chunks.
 - Fixed Pokémon entities leveled by rare candy not getting stronger as Minecraft entities unless recalled.
 - Fixed a freeze during game load that occurred when multiple mods tried to load Cobblemon API classes at the same time.
 - Lowered the volume of Blitzle and Zebstrika's cry (shut up!).
 - Regional Foods will now prioritise being eaten instead of used for healing Pokémon - shift clicking will use it as healing.
 - Resolved z-fighting (texture flickering) on Pokédex Models.
 - Restored Ninjask's ability to do barrel rolls.
 - Fixed Raichu (male) and Alolan Raichu (both genders) not displaying the correct Partner Cap when Pewter Crunchies are in the cosmetic slot.
 - Fixed a crash caused by adding enchanted items to the Resurrection Machine.
 - Fixed a crash that could occur when starting a PvN battle with only fainted Pokémon.
 - Fixed the Remember Riding Camera config not being respected when dismounting and resolved the incompatibility with the Auto Third Person mod.
 - Fixed Full Heal block not dropping Full Heals. Lmao.
 - Fixed status cure items not returning an empty bottle when used.
 - Fixed Panpour consuming its held item when evolving with a Water Stone.
 - Fixed Smoked Tail Curry returning a Wooden Bowl when consumed despite it not being included in the recipe. Free bowls!
 - Fixed `/giveallpokemon` not respecting the min and max arguments.
 - Fixed the choose starter toast not disappearing when capturing a Pokémon instead of opening the starter selection screen.
 - Fixed an issue where certain Sinister Tea seasonings were only applying as instant effects and would not apply over time.
 - Long config option labels now scroll instead of overflowing in the configuration menu.
 - Fixed some z-fighting and clipping on Dewott and Hisui-Bias Dewott.
 - Eggant Berries can now be composted properly on NeoForge.
 - Composting chances are now the same on NeoForge as on Fabric.
 - Fixed problem where furnaces which had smelted Revival Herbs into Heal Powder in older versions would glitch out on trying to get the experience out of the block.
 - Fixed the Battle AI not recognizing Surging Strikes as a multistrike move.
 - Fixed Tentacool not using its swim animation when on water surface.
 - Fixed Eevee using its left shoulder pose when in battle.
 - Fixed Magikarp and Gyarados Jump Pattern resourcepacks replacing shiny textures of addons targeting Magikarp or Gyarados.
 - Fixed Combee's pollinated texture overwriting the shiny and female textures.
 - Fixed a colour mistake with Dracovish's shiny.
 - Fixed Togedemaru's back spikes z-fighting.
 - Fixed Sliggoo (+ Hisuian) evolving in the Nether and End where it can't actually rain.
 - Corrected the scales, hitbox sizes, and eye heights for Ariados, Cetoddle, Durant, Galvantula, Klink, Lanturn, Lumineon, Mantine, Mantyke, Mudbray, Numel, Staravia, and Torkoal.
 - Fixed Torkoal's walk speed not matching its animation. He will no longer move faster than Bunnelby and Buneary. This tortoise would've won.
 - Fixed Lanturn T-posing due to missing ground walk and sleep animations.
 - Fixed Oshawott and Dewott using their sleep animation in unintended scenarios.
 - Fixed Dudunsparce and Maushold always having the same form instead of having the 1 in 100 chance of being different.
 - Fixed bird mounts rapidly switching between their flying and gliding animations when flying at low speed.
 - Fixed some battles being startable with fainted Pokémon in the initial sendout.
 - Fixed random gender selection for forms with strict gender divides (such as Meowstic and Oinkologne) never choosing female (that's sexist).
 - Fixed the "Press R to battle" prompt not disappearing after you finish your first battle, at least until you relogged.
 - Fixed the composter block being listed as "composer" in the cosmetic items species feature
 - Fixed Castform's forms being tagged as introduced in generation 4 instead of 3.
 - Fixed Blitzle's base scale being `1` rather than the intended `0.8`.
 - Fixed Magnezone's emissive layer for the shiny having the wrong name, thus displaying wrongly.
 - Fixed Litleo not blinking.
 ### Developer
 - Added `PokeSnackSpawnerFactory` which allows influence registration on PokeSnack encounters.
 - Added `FishingSpawnerFactory` which allows influence registration on fishing encounters.
 - Added `BattleFleeAttemptEvent` fired from `PokemonBattle.checkFleeAttempt`, allowing developers to intercept and control flee attempts.
 - Tweaked the spawning selector interface to take a bucket function rather than a bucket directly.
 - Added a new `cobblemon:height_range` processor type to allow developers to restrict structure-spawning ranges.
 - Separated all the functions of MoLangFunctions.kt into their own files.
 - Spawn buckets and their base weights are now provided by the spawner, with different base weights for world, fishing, snack, and habitat spawn buckets.
 - Removed "SpawnBucket" class in favour of just storing maps of bucket names to weights.
 - Fixed nicknames not being applied to Pokémon spawned from `spawn_pool_world` files.
 - Added support for `profilePokedexScale`, `profilePokedexTranslation`, `profileSummaryScale`, and `profileSummaryTranslation` in poser files for finer control over profile displays.
 - Fixed riding camera offsets defined on Pokémon forms not being applied.
 - Marks can now provide aspects.
 ### Molang & Datapacks
 - Added `moveset_builders` datapack folder for different styles of movesets.
 - Added `party_pools` datapack folder for defining groups of Pokémon for complex NPC party definitions.
 - Added `party_compositions` datapack folder for arranging parties on NPCs that rely on party pools.
 - Added `composed_pool` NPC party provider type which combines a party pool with a party composition to create more complex NPC parties.
 - Added basic chatter NPC Behaviour.
 - Added `q.item.is_enchanted()`.
 - Added `q.item.has_enchantment(minecraft:sharpness, 3)`.
 - Added `has_chosen_starter` and `get_starter_uuid` as available Molang functions.
 - Added `has_tm_move_unlocked`, `unlock_tm_move`, and `lock_tm_move` as available Molang functions for Players.
 - Added `marks`, `has_mark`, and `remove_marks` as available Molang functions for Pokémon.
 - Added Data Component support for species drops, eg `"components": {"minecraft:custom_model_data": 123}`
 - Added the new `sortOrder` field to mark entries, (defaults to 0 if not specified) which controls the order in which marks are rendered on the HUD, with higher numbers being rendered on top of lower numbers.
 - Added optional `order` field to starter categories. It will allow explicitly sorting categories in the starter selection screen.
 - SpeciesAdditions append vs override now matches the wiki documentation.
 - Added `weighted_choice` as a new feature type. It requires setting weights for each choice and allows developers to simplify the process of assigning random aspect choice based on marble chance.
 - Added `q.world.spawn_loot_table_items(loot_table_id, x, y, z)` which spawns the items from the loot table at the position. Use type: `minecraft:chest` for the loot table.
 - Added `q.pokemon.entity` to access the entity of Pokémon.
 - Flamethrower and Seismic Toss had their action effect JSON cleaned up.
 - Ride sounds can now be set as exclusive to passengers.
 - Ride sounds no longer play when submerged unless specified with a new setting.
 - NPC Trainers can now call a `command` animation when issuing a command in battle.
 - Added a q.failed function to move action effects.
 - Herd spawned Pokémon have their levels controlled differently. The `levelRange` property now acts as a pre-offset clamp instead of a filter, with a new `herdLevelRange` property to do the filter behaviour.
 - `q.sound` now accepts three parameters (sound event, volume, and pitch) instead of just the sound event and pitch.
 - Added a new layer property that makes a layer scroll in a direction. "scrolling": {"speedU": 0.1, "speedV": 0.1}
 - Cleaned up seat data. Removed all now unused fields from seats in all species files. Also made locator seat names explicit in the species files (however, this doesn't break the legacy format)
 ### Particles
 #### New Move Animations
 - Blizzard
 - Disarming Voice
 - Draco Meteor
 - Dragon Breath
 - Dragon Rage
 - Drain Punch
 - Fairy Wind
 - Fire Fang
 - Gust
 - Horn Drill
 - Hydro Pump
 - Ice Fang
 - Leafage
 - Leaf Storm
 - Light Screen
 - Night Shade
 - Play Rough
 - Pyro Ball
 - Reflect
 - Rock Slide
 - Sonic Boom
 - Sucker Punch
 - Supersonic
 - Thunder Fang
 #### Tweaks and Fixes (Moves)
 - Confusion
 - Dragon Claw
 - Eruption
 - Fire Punch
 - Flame Burst
 - Flame Charge
 - Flamethrower
 - Frost Breath
 - Hypnosis
 - Ice Punch
 - Icy Wind
 - Mud Sport
 - Poison Fang
 - Protect
 - Psychic
 - Quick Attack
 - Rage Powder
 - Razor Leaf
 - Sand Attack
 - Scratch
 - Shadow Claw
 - Sing
 - Spore
 - String Shot
 - Tackle
 - Tail Whip
 - Thunder
 - Thunder Punch
 - Thunder Wave
 - Water Gun
 - Water Pulse
 - Water Sport
 #### Miscellaneous Particles
 - Added Wild Might particles for Alpha Pokémon.
 - Updated stat increase and decrease particles.
 ### Localization
 - Updated translations for:
    - Japanese
    - German
    - Spanish
    - Ecuadorian Spanish
    - Portuguese
    - Brazilian Portuguese
    - Simplified Chinese
    - Traditional Chinese
    - Korean
    - Russian
@@ -1,9 +1,9 @@
 import utilities.isSnapshot
 import utilities.version
 import java.time.OffsetDateTime
 import java.time.ZoneOffset
 import java.time.format.DateTimeFormatter
 import utilities.isSnapshot
 import utilities.version
 /*
 *
@@ -1,24 +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.duck;
 import net.minecraft.resources.ResourceKey;
 import net.minecraft.world.level.Level;
 import java.util.Optional;
 /**
 * Duck that facilitates getting a level key for a given level.
 *
 * @author dualspiral
 * @since August 30th, 2026
 */
 public interface MinecraftServerDuck {
    Optional<ResourceKey<Level>> cobblemon$getLevelKey(Level level);
 }
@@ -1,21 +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.duck;
 import net.minecraft.resources.ResourceLocation;
 /**
 * Duck that facilitates getting a level key that we store on the level.
 *
 * @author dualspiral
 * @since August 30th, 2026
 */
 public interface ServerLevelDuck {
    ResourceLocation cobblemon$getLevelResourceLocation();
 }
@@ -0,0 +1,54 @@
 /*
 * 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.mixin;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
 import net.minecraft.client.multiplayer.ClientLevel;
 import net.minecraft.client.multiplayer.ClientPacketListener;
 import net.minecraft.network.protocol.game.ClientboundSetPassengersPacket;
 import net.minecraft.world.entity.Entity;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Objects;
@Mixin(ClientPacketListener.class)
 public class ClientPacketListenerMixin {
    @Shadow private ClientLevel level;
    @Inject(method = "handleSetEntityPassengersPacket", at = @At(value = "INVOKE_ASSIGN", target = "Lnet/minecraft/world/entity/Entity;hasIndirectPassenger(Lnet/minecraft/world/entity/Entity;)Z", shift = At.Shift.BEFORE), cancellable = true)
    private void cobblemon$handlePokemonPassengers(ClientboundSetPassengersPacket packet, CallbackInfo ci) {
        Entity entity = this.level.getEntity(packet.getVehicle());
        if (entity instanceof PokemonEntity pokemon) {
            var passengers = new ArrayList<Entity>();
            for (int passenger : packet.getPassengers()) {
                passengers.add(this.level.getEntity(passenger));
            }
            pokemon.getOccupiedSeats().values().stream()
                    .filter(x -> !passengers.contains(x))
                    .filter(Objects::nonNull)
                    .forEach(Entity::stopRiding);
            // Mount passengers not yet in the map
            var currentPassengers = new ArrayList<>(pokemon.getOccupiedSeats().values());
            passengers.stream()
                    .filter(x -> !currentPassengers.contains(x))
                    .filter(Objects::nonNull)
                    .forEach(x -> x.startRiding(pokemon, true));
            ci.cancel();
        }
    }
 }
@@ -0,0 +1,111 @@
 /*
 * 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.mixin;
 import com.cobblemon.mod.common.mixin.accessor.SinglePoolElementAccessor;
 import com.cobblemon.mod.common.world.structureprocessors.HeightRangeStructureProcessor;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Holder;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.level.levelgen.Heightmap;
 import net.minecraft.world.level.levelgen.structure.Structure;
 import net.minecraft.world.level.levelgen.structure.pools.*;
 import net.minecraft.world.level.levelgen.structure.pools.alias.PoolAliasLookup;
 import net.minecraft.world.level.levelgen.structure.templatesystem.LiquidSettings;
 import net.minecraft.world.level.levelgen.structure.templatesystem.StructureProcessor;
 import net.minecraft.world.level.levelgen.structure.templatesystem.StructureProcessorList;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 import java.util.Optional;
@Mixin(JigsawPlacement.class)
 public class JigsawPlacementMixin {
 	@Inject(
 			method = "addPieces(Lnet/minecraft/world/level/levelgen/structure/Structure$GenerationContext;Lnet/minecraft/core/Holder;Ljava/util/Optional;ILnet/minecraft/core/BlockPos;ZLjava/util/Optional;ILnet/minecraft/world/level/levelgen/structure/pools/alias/PoolAliasLookup;Lnet/minecraft/world/level/levelgen/structure/pools/DimensionPadding;Lnet/minecraft/world/level/levelgen/structure/templatesystem/LiquidSettings;)Ljava/util/Optional;",
 			at = @At("RETURN"),
 			cancellable = true
 	)
 	private static void onAddPieces(
 			Structure.GenerationContext context,
 			Holder<StructureTemplatePool> startPool,
 			Optional<ResourceLocation> startJigsawName,
 			int maxDepth,
 			BlockPos pos,
 			boolean useExpansionHack,
 			Optional<Heightmap.Types> projectStartToHeightmap,
 			int maxDistanceFromCenter,
 			PoolAliasLookup aliasLookup,
 			DimensionPadding dimensionPadding,
 			LiquidSettings liquidSettings,
 			CallbackInfoReturnable<Optional<Structure.GenerationStub>> cir
 	) {
 		Optional<Structure.GenerationStub> result = cir.getReturnValue();
 		if (result.isEmpty()) {
 			return;
 		}
 		BlockPos spawnPos = result.get().position();
 		boolean canPlace = cobblemon$canAnyStartElementPlace(context, startPool, spawnPos);
 		if (canPlace) {
 			return;
 		}
 		cir.setReturnValue(Optional.empty());
 	}
 	@Unique
 	private static boolean cobblemon$canAnyStartElementPlace(
 			Structure.GenerationContext generationContext,
 			Holder<StructureTemplatePool> startPool,
 			BlockPos startPos
 	) {
 		for (StructurePoolElement element : startPool.value().templates) {
 			Optional<HeightRangeStructureProcessor> heightRangeProcessor = cobblemon$getHeightRangeProcessor(element);
 			if (heightRangeProcessor.isEmpty()) {
 				return true;
 			}
 			HeightRangeStructureProcessor processor = heightRangeProcessor.get();
 			boolean valid = processor.isValidPlacement(
 					generationContext.chunkGenerator(),
 					generationContext.heightAccessor(),
 					generationContext.randomState(),
 					startPos
 			);
 			if (valid) {
 				return true;
 			}
 		}
 		return false;
 	}
 	@Unique
 	private static Optional<HeightRangeStructureProcessor> cobblemon$getHeightRangeProcessor(StructurePoolElement element) {
 		if (!(element instanceof SinglePoolElement)) {
 			return Optional.empty();
 		}
 		StructureProcessorList processorList = ((SinglePoolElementAccessor) element).getProcessors().value();
 		for (StructureProcessor processor : processorList.list()) {
 			if (processor instanceof HeightRangeStructureProcessor heightRangeStructureProcessor) {
 				return Optional.of(heightRangeStructureProcessor);
 			}
 		}
 		return Optional.empty();
 	}
 }
@@ -8,6 +8,7 @@
 package com.cobblemon.mod.common.mixin;
 import com.cobblemon.mod.common.CobblemonNetwork;
 import com.cobblemon.mod.common.OrientationControllable;
 import com.cobblemon.mod.common.api.orientation.OrientationController;
 import com.cobblemon.mod.common.api.pokemon.effect.ShoulderEffectRegistry;
@@ -17,6 +18,7 @@ import com.cobblemon.mod.common.api.riding.behaviour.types.liquid.SubmarineBehav
 import com.cobblemon.mod.common.client.entity.PokemonClientDelegate;
 import com.cobblemon.mod.common.client.render.MatrixWrapper;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
 import com.cobblemon.mod.common.net.messages.server.orientation.ServerboundUpdateOrientationPacket;
 import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import net.minecraft.server.level.ServerPlayer;
@@ -1,40 +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.mixin;
 import com.cobblemon.mod.common.duck.MinecraftServerDuck;
 import net.minecraft.resources.ResourceKey;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.world.level.Level;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import java.util.Map;
 import java.util.Optional;
@Mixin(MinecraftServer.class)
 public class MinecraftServerMixin implements MinecraftServerDuck {
    @Shadow
    @Final
    private Map<ResourceKey<Level>, ServerLevel> levels;
    @Override
    public Optional<ResourceKey<Level>> cobblemon$getLevelKey(final Level level) {
        return this.levels.entrySet()
                .stream()
                // Reference equality is intended here, the level we're handed is the same one as in the
                // map so we don't need to check value semantics.
                .filter(entry -> entry.getValue() == level)
                .map(Map.Entry::getKey)
                .findFirst();
    }
 }
@@ -40,7 +40,6 @@ import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import java.util.List;
 import java.util.LinkedHashMap;
 import java.util.Set;
 import java.util.function.Consumer;
@@ -115,13 +114,15 @@ public abstract class ServerEntityMixin {
        if (currentPassengers.equals(cobblemon$lastSeatPassengers)) return;
        cobblemon$lastSeatPassengers = List.copyOf(currentPassengers);
        var assignments = new LinkedHashMap<String, Integer>();
        pokemon.getOccupiedSeats().forEach((seat, passenger) -> {
            if (seat.getLocator() == null) return;
            if (passenger == null) return;
-            assignments.put(seat.getLocator(), passenger.getId());
+            cobblemon$broadcast(new ClientboundSeatAssignmentPacket(
                    passenger.getId(),
                    pokemon.getId(),
                    seat.getLocator()
            ));
        });
        cobblemon$broadcast(new ClientboundSeatAssignmentPacket(pokemon.getId(), assignments));
    }
    private void cobblemon$broadcast(NetworkPacket<?> packet) {
@@ -8,69 +8,22 @@
 package com.cobblemon.mod.common.mixin;
 import com.cobblemon.mod.common.duck.MinecraftServerDuck;
 import com.cobblemon.mod.common.duck.ServerLevelDuck;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Holder;
 import net.minecraft.core.RegistryAccess;
 import net.minecraft.resources.ResourceKey;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.util.profiling.ProfilerFiller;
 import net.minecraft.world.entity.LivingEntity;
 import net.minecraft.world.level.Level;
 import net.minecraft.world.level.dimension.DimensionType;
 import net.minecraft.world.level.storage.WritableLevelData;
 import net.minecraft.world.phys.AABB;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 import java.util.List;
 import java.util.Optional;
 import java.util.function.Supplier;
@Mixin(ServerLevel.class)
-public abstract class ServerLevelMixin extends Level implements ServerLevelDuck {
+public abstract class ServerLevelMixin {
    // Ignored by Mixin, fulfils Java contract
    protected ServerLevelMixin(
            WritableLevelData levelData,
            ResourceKey<Level> dimension,
            RegistryAccess registryAccess,
            Holder<DimensionType> dimensionTypeRegistration,
            Supplier<ProfilerFiller> profiler,
            boolean isClientSide,
            boolean isDebug,
            long biomeZoomSeed,
            int maxChainedNeighborUpdates
    ) {
        super(levelData, dimension, registryAccess, dimensionTypeRegistration, profiler, isClientSide, isDebug, biomeZoomSeed, maxChainedNeighborUpdates);
    }
    @Shadow
    public abstract MinecraftServer shadow$getServer();
    /**
     * Cached to speed up level world key checks every tick.
     */
    private ResourceLocation cobblemon$levelResourceLocation;
    @Override
    public ResourceLocation cobblemon$getLevelResourceLocation() {
        if (this.cobblemon$levelResourceLocation == null) {
            this.cobblemon$levelResourceLocation = ((MinecraftServerDuck) this.shadow$getServer())
                    .cobblemon$getLevelKey(this)
                    .map(ResourceKey::location)
                    .orElse(null);
        }
        return this.cobblemon$levelResourceLocation;
    }
    @Inject(method = "findLightningRod", at = @At(value = "RETURN"), cancellable = true)
    private void cobblemon$findLightningRod(BlockPos blockPos, CallbackInfoReturnable<Optional<BlockPos>> ci) {
@@ -15,18 +15,15 @@ import com.cobblemon.mod.common.api.riding.RidingStyle;
 import com.cobblemon.mod.common.api.spawning.spawner.PlayerSpawner;
 import com.cobblemon.mod.common.api.spawning.spawner.PlayerSpawnerFactory;
 import com.cobblemon.mod.common.api.stats.CobblemonStats;
 import com.cobblemon.mod.common.duck.ServerLevelDuck;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
 import com.cobblemon.mod.common.world.gamerules.CobblemonGameRules;
 import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
 import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import com.llamalad7.mixinextras.sugar.Local;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.entity.Entity;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.Unique;
@@ -36,13 +33,9 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
@Mixin(ServerPlayer.class)
 public abstract class ServerPlayerMixin implements PlayerSpawnerAccessor {
    @Shadow
    public abstract ServerLevel serverLevel();
    @Shadow
    @Final
    public MinecraftServer server;
    @Unique
    public PlayerSpawner cobblemon$spawner;
@@ -62,9 +55,12 @@ public abstract class ServerPlayerMixin implements PlayerSpawnerAccessor {
    @Inject(method = "tick", at = @At("TAIL"))
    private void cobblemon$tickSpawner(CallbackInfo ci) {
-        if (cobblemon$canSpawn()) {
+        if (!Cobblemon.config.getEnableSpawning()) {
-            getPlayerSpawner().tick();
+            return;
        } else if (!serverLevel().getGameRules().getBoolean(CobblemonGameRules.DO_POKEMON_SPAWNING)) {
            return;
        }
        getPlayerSpawner().tick();
    }
    @Inject(method = "rideTick", at = @At("HEAD"))
@@ -125,21 +121,4 @@ public abstract class ServerPlayerMixin implements PlayerSpawnerAccessor {
        return entity;
    }
    /**
     * Gets whether we should spawn Cobblemon entities here.
     *
     * @return true if we can spawn cobblemon in the current level,
     *         false otherwise
     */
    @SuppressWarnings("resource")
    @Unique
    private boolean cobblemon$canSpawn() {
        return Cobblemon.config.getEnableSpawning() &&
                this.serverLevel().getGameRules().getBoolean(CobblemonGameRules.DO_POKEMON_SPAWNING) &&
                // intentionally last as this is a more expensive check, even with all the caching
                !Cobblemon.config.getWorldSpawningBlocklist().contains(
                        ((ServerLevelDuck) this.serverLevel()).cobblemon$getLevelResourceLocation()
                );
    }
 }
@@ -1,103 +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.mixin;
 import com.cobblemon.mod.common.mixin.accessor.SinglePoolElementAccessor;
 import com.cobblemon.mod.common.world.structureprocessors.HeightRangeStructureProcessor;
 import com.llamalad7.mixinextras.sugar.Local;
 import net.minecraft.core.Holder;
 import net.minecraft.core.RegistryAccess;
 import net.minecraft.world.level.ChunkPos;
 import net.minecraft.world.level.LevelHeightAccessor;
 import net.minecraft.world.level.biome.Biome;
 import net.minecraft.world.level.biome.BiomeSource;
 import net.minecraft.world.level.chunk.ChunkGenerator;
 import net.minecraft.world.level.levelgen.RandomState;
 import net.minecraft.world.level.levelgen.structure.PoolElementStructurePiece;
 import net.minecraft.world.level.levelgen.structure.Structure;
 import net.minecraft.world.level.levelgen.structure.StructurePiece;
 import net.minecraft.world.level.levelgen.structure.StructureStart;
 import net.minecraft.world.level.levelgen.structure.pools.SinglePoolElement;
 import net.minecraft.world.level.levelgen.structure.pools.StructurePoolElement;
 import net.minecraft.world.level.levelgen.structure.templatesystem.StructureProcessor;
 import net.minecraft.world.level.levelgen.structure.templatesystem.StructureProcessorList;
 import net.minecraft.world.level.levelgen.structure.templatesystem.StructureTemplateManager;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 import java.util.Optional;
 import java.util.function.Predicate;
@Mixin(Structure.class)
 public abstract class StructureMixin {
 	/**
 	 * Discards a structure start when any of its pieces carries a {@link HeightRangeStructureProcessor}
 	 * whose range the piece does not fit in.
 	 * Crab Note: We have to make this has to happen here rather than in the processor itself. Terrain adaptation and {@code /locate}
 	 * both read the start, so by the time processors run the terrain has already been generated and the
 	 * structure is already on the map which previously were left behdind when we were trying to make some structures not generate via processor. Now
 	 * Returning {@link StructureStart#INVALID_START} keeps the start from ever existing, which makes sure that weird generation isn't left behind.
 	 */
 	@Inject(
 			method = "generate",
 			at = @At(value = "INVOKE", target = "Lnet/minecraft/world/level/levelgen/structure/StructureStart;isValid()Z"),
 			cancellable = true
 	)
 	private void cobblemon$rejectStartsOutsideHeightRange(
 			RegistryAccess registryAccess, ChunkGenerator chunkGenerator, BiomeSource biomeSource,
 			RandomState randomState, StructureTemplateManager structureTemplateManager, long seed,
 			ChunkPos chunkPos, int references, LevelHeightAccessor heightAccessor,
 			Predicate<Holder<Biome>> validBiome,
 			CallbackInfoReturnable<StructureStart> cir,
 			@Local StructureStart structureStart
 	) {
 		for (StructurePiece piece : structureStart.getPieces()) {
 			if (!(piece instanceof PoolElementStructurePiece poolPiece)) {
 				continue;
 			}
 			Optional<HeightRangeStructureProcessor> heightRangeProcessor = cobblemon$getHeightRangeProcessor(poolPiece.getElement());
 			if (heightRangeProcessor.isEmpty()) {
 				continue;
 			}
 			boolean valid = heightRangeProcessor.get().isValidPlacement(
 					chunkGenerator,
 					heightAccessor,
 					randomState,
 					piece.getBoundingBox()
 			);
 			if (!valid) {
 				cir.setReturnValue(StructureStart.INVALID_START);
 				return;
 			}
 		}
 	}
 	@Unique
 	private static Optional<HeightRangeStructureProcessor> cobblemon$getHeightRangeProcessor(StructurePoolElement element) {
 		if (!(element instanceof SinglePoolElement)) {
 			return Optional.empty();
 		}
 		StructureProcessorList processorList = ((SinglePoolElementAccessor) element).getProcessors().value();
 		for (StructureProcessor processor : processorList.list()) {
 			if (processor instanceof HeightRangeStructureProcessor heightRangeStructureProcessor) {
 				return Optional.of(heightRangeStructureProcessor);
 			}
 		}
 		return Optional.empty();
 	}
 }
@@ -10,7 +10,9 @@ package com.cobblemon.mod.common.mixin.accessor;
 import net.minecraft.client.gui.components.StateSwitchingButton;
 import net.minecraft.client.gui.screens.recipebook.RecipeBookComponent;
 import net.minecraft.network.chat.Component;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Mutable;
 import org.spongepowered.asm.mixin.gen.Accessor;
@Mixin(RecipeBookComponent.class)
@@ -15,9 +15,11 @@ import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import com.llamalad7.mixinextras.sugar.Local;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
 import net.minecraft.core.NonNullList;
 import net.minecraft.world.Containers;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.Items;
 import net.minecraft.world.item.alchemy.PotionBrewing;
 import net.minecraft.world.item.crafting.RecipeHolder;
 import net.minecraft.world.item.crafting.RecipeManager;
@@ -32,7 +34,6 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 import java.util.List;
 import java.util.Optional;
@Mixin(BrewingStandBlockEntity.class)
 public class BrewingStandBlockEntityMixin {
@@ -9,11 +9,17 @@
 package com.cobblemon.mod.common.mixin.brewing;
 import com.cobblemon.mod.common.duck.RecipeAwareSlot;
 import com.cobblemon.mod.common.item.crafting.brewingstand.BrewingStandRecipe;
 import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import com.llamalad7.mixinextras.sugar.Local;
 import net.minecraft.world.Container;
 import net.minecraft.world.entity.player.Inventory;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.inventory.BrewingStandMenu;
 import net.minecraft.world.inventory.ContainerData;
 import net.minecraft.world.inventory.Slot;
 import net.minecraft.world.item.ItemStack;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
@@ -13,6 +13,7 @@ import com.cobblemon.mod.common.item.crafting.brewingstand.BrewingStandRecipe;
 import net.minecraft.world.inventory.BrewingStandMenu;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.crafting.RecipeManager;
 import net.minecraft.world.level.Level;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
@@ -19,6 +19,7 @@ import net.minecraft.client.Camera;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.level.BlockGetter;
 import net.minecraft.world.phys.Vec3;
 import org.joml.Quaternionf;
 import org.joml.Vector3f;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
@@ -10,7 +10,9 @@ package com.cobblemon.mod.common.mixin.client;
 import com.cobblemon.mod.common.CobblemonRecipeCategories;
 import com.cobblemon.mod.common.item.crafting.CookingPotBookCategory;
 import com.cobblemon.mod.common.item.crafting.CookingPotRecipe;
 import com.cobblemon.mod.common.item.crafting.CookingPotRecipeBase;
 import com.cobblemon.mod.common.item.crafting.CookingPotShapelessRecipe;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Maps;
@@ -20,7 +20,7 @@ import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-// There appears to be a data driven way to do this now, however I am not sure how it works since there is no wiki or anything so yolo
+//This is a yucky hack but better than what we were doing before
@Mixin(BlockVariantSets.class)
 public abstract class AdornRegisterInvoker {
    @Final
@@ -97,10 +97,10 @@ import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.pokemon.aspects.ALPHA_ASPECT
 import com.cobblemon.mod.common.pokemon.aspects.CHARACTERISTIC_RAINBOW_ASPECT
 import com.cobblemon.mod.common.pokemon.aspects.COSMETIC_SLOT_ASPECT
 import com.cobblemon.mod.common.pokemon.aspects.FORM_ASPECTS
 import com.cobblemon.mod.common.pokemon.aspects.GENDER_ASPECT
 import com.cobblemon.mod.common.pokemon.aspects.MARK_ASPECT
 import com.cobblemon.mod.common.pokemon.aspects.SHINY_ASPECT
 import com.cobblemon.mod.common.pokemon.evolution.variants.BlockClickEvolution
 import com.cobblemon.mod.common.pokemon.feature.SlowpokeTailRegrowthSpeciesFeature
 import com.cobblemon.mod.common.pokemon.feature.SlowpokeTailRegrowthSpeciesFeatureProvider
 import com.cobblemon.mod.common.pokemon.feature.TagSeasonResolver
@@ -115,7 +115,6 @@ 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.stat.CobblemonStatProvider
 import com.cobblemon.mod.common.pokemon.transformation.triggers.BlockClickTrigger
 import com.cobblemon.mod.common.starter.CobblemonStarterHandler
 import com.cobblemon.mod.common.util.*
 import com.cobblemon.mod.common.world.feature.CobblemonPlacedFeatures
@@ -274,8 +273,13 @@ object Cobblemon {
        PlatformEvents.RIGHT_CLICK_BLOCK.subscribe { event ->
            val player = event.player
            val block = player.level().getBlockState(event.pos).block
-            val context = BlockClickTrigger.Context(block, player.level())
+            player.party().forEach { pokemon ->
-            player.party().forEach { pokemon -> pokemon.triggerTransformations<BlockClickTrigger>(context) }
+                pokemon.lockedEvolutions
                    .filterIsInstance<BlockClickEvolution>()
                    .forEach { evolution ->
                        evolution.attemptEvolution(pokemon, BlockClickEvolution.BlockInteractionContext(block, player.level()))
                    }
            }
        }
        PlatformEvents.CHANGE_DIMENSION.subscribe {
@@ -319,7 +323,6 @@ object Cobblemon {
        SHINY_ASPECT.register()
        GENDER_ASPECT.register()
        FORM_ASPECTS.register()
        COSMETIC_SLOT_ASPECT.register()
        CHARACTERISTIC_RAINBOW_ASPECT.register()
        ALPHA_ASPECT.register()
@@ -9,7 +9,6 @@
 package com.cobblemon.mod.common
 import com.bedrockk.molang.Expression
 import com.cobblemon.mod.common.CobblemonBehaviours.autoPokemonBehaviours
 import com.cobblemon.mod.common.CobblemonNetwork.sendPacket
 import com.cobblemon.mod.common.api.ai.CobblemonBehaviour
 import com.cobblemon.mod.common.api.ai.config.BehaviourConfig
@@ -20,7 +19,16 @@ import com.cobblemon.mod.common.api.molang.ExpressionLike
 import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
 import com.cobblemon.mod.common.api.reactive.SimpleObservable
 import com.cobblemon.mod.common.net.messages.client.data.BehaviourSyncPacket
-import com.cobblemon.mod.common.util.adapters.*
+import com.cobblemon.mod.common.util.adapters.ActivityAdapter
 import com.cobblemon.mod.common.util.adapters.BehaviourConfigAdapter
 import com.cobblemon.mod.common.util.adapters.ExpressionAdapter
 import com.cobblemon.mod.common.util.adapters.ExpressionLikeAdapter
 import com.cobblemon.mod.common.util.adapters.ExpressionOrEntityVariableAdapter
 import com.cobblemon.mod.common.util.adapters.IdentifierAdapter
 import com.cobblemon.mod.common.util.adapters.MemoryModuleTypeAdapter
 import com.cobblemon.mod.common.util.adapters.SensorTypeAdapter
 import com.cobblemon.mod.common.util.adapters.TaskConfigAdapter
 import com.cobblemon.mod.common.util.adapters.TranslatedTextAdapter
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.cobblemon.mod.common.util.endsWith
 import com.google.gson.Gson
@@ -41,8 +41,6 @@ object CobblemonCommands {
        HeldItemCommand.register(dispatcher, registry)
        PcCommand.register(dispatcher)
        SpawnPokemonFromPool.register(dispatcher)
        SpawnMeteorCommand.register(dispatcher)
        SetMegaBondCommand.register(dispatcher)
        PokeboxCommand.register(dispatcher)
        PokedexCommand.register(dispatcher)
        TestStoreCommand.register(dispatcher)
@@ -16,7 +16,6 @@ import com.cobblemon.mod.common.entity.generic.GenericBedrockEntity
 import com.cobblemon.mod.common.entity.npc.NPCEntity
 import com.cobblemon.mod.common.entity.pokeball.EmptyPokeBallEntity
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.entity.projectile.FallingStarEntity
 import com.cobblemon.mod.common.platform.PlatformRegistry
 import com.cobblemon.mod.common.util.cobblemonResource
 import net.minecraft.core.Registry
@@ -96,15 +95,6 @@ object CobblemonEntities : PlatformRegistry<Registry<EntityType<*>>, ResourceKey
        EntityType.Builder.of({ _, world -> NPCEntity(world) }, MobCategory.CREATURE).build("$NPC_KEY")
    )
    @JvmField
    val FALLING_STAR_KEY = cobblemonResource("falling_star")
    @JvmField
    val FALLING_STAR: EntityType<FallingStarEntity> = create(
        FALLING_STAR_KEY.path,
        EntityType.Builder.of(::FallingStarEntity, MobCategory.MISC).sized(0.5F, 0.5F).clientTrackingRange(8)
            .build(FALLING_STAR_KEY.toString())
    )
    fun registerAttributes(consumer: (EntityType<out LivingEntity>, AttributeSupplier.Builder) -> Unit) {
        consumer(POKEMON, PokemonEntity.createAttributes())
        consumer(NPC, NPCEntity.createAttributes())
@@ -19,6 +19,7 @@ import net.minecraft.server.level.ServerPlayer
 import net.minecraft.server.packs.PackType
 import net.minecraft.server.packs.resources.PreparableReloadListener
 import net.minecraft.tags.TagKey
 import net.minecraft.world.inventory.MenuType
 import net.minecraft.world.level.GameRules
 import net.minecraft.world.level.ItemLike
 import net.minecraft.world.level.biome.Biome
@@ -33,12 +33,6 @@ object CobblemonItemComponents : PlatformRegistry<Registry<DataComponentType<*>>
        .networkSynchronized(HeldItemEffectComponent.PACKET_CODEC)
        .build())
    @JvmField
    val MEGA_BOND: DataComponentType<MegaBondComponent> = create("mega_bond", DataComponentType.builder<MegaBondComponent>()
        .persistent(MegaBondComponent.CODEC)
        .networkSynchronized(MegaBondComponent.PACKET_CODEC)
        .build())
    @JvmField
    val BAIT: DataComponentType<RodBaitComponent> = create("bait", DataComponentType.builder<RodBaitComponent>()
        .persistent(RodBaitComponent.CODEC)
@@ -914,10 +914,6 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    val THUNDER_STONE = noSettingsItem("thunder_stone")
    @JvmField
    val WATER_STONE = noSettingsItem("water_stone")
    @JvmField
    val MEGA_SHARD = noSettingsItem("mega_shard")
    @JvmField
    val DORMANT_MEGA_STONE = heldItem("dormant_mega_stone")
    val wearables = mutableListOf<WearableItem>()
    //Wearable items (these items should have a corresponding 3D model)
@@ -936,34 +932,14 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val ABILITY_SHIELD = heldItem("ability_shield")
    @JvmField
    val ABOMASITE = heldItem("abomasite")
    @JvmField
    val ABSOLITE = heldItem("absolite")
    @JvmField
    val ABSORB_BULB = heldItem("absorb_bulb")
    @JvmField
    val AERODACTYLITE = heldItem("aerodactylite")
    @JvmField
    val AGGRONITE = heldItem("aggronite")
    @JvmField
    val AIR_BALLOON = heldItem("air_balloon")
    @JvmField
    val ALAKAZITE = heldItem("alakazite")
    @JvmField
    val ALTARIANITE = heldItem("altarianite")
    @JvmField
    val AMPHAROSITE = heldItem("ampharosite")
    @JvmField
    val ASSAULT_VEST = heldItem("assault_vest")
    @JvmField
    val BIG_ROOT = compostableBlockItem("big_root", CobblemonBlocks.BIG_ROOT, 0.30f)
    @JvmField
    val AUDINITE = heldItem("audinite")
    @JvmField
    val BANETTITE = heldItem("banettite")
    @JvmField
    val BEEDRILLITE = heldItem("beedrillite")
    @JvmField
    val BINDING_BAND = heldItem("binding_band")
    @JvmField
    val BLACK_BELT = heldItem("black_belt")
@@ -972,20 +948,10 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val BLUNDER_POLICY = itemNameBlockItem("blunder_policy", CobblemonBlocks.BLUNDER_POLICY)
    @JvmField
    val BLASTOISINITE = heldItem("blastoisinite")
    @JvmField
    val BLAZIKENITE = heldItem("blazikenite")
    @JvmField
    val CAMERUPTITE = heldItem("cameruptite")
    @JvmField
    val CELL_BATTERY = heldItem("cell_battery")
    @JvmField
    val CHARCOAL = heldItem("charcoal_stick", remappedName = "charcoal")
    @JvmField
    val CHARIZARDITE_X = heldItem("charizardite_x")
    @JvmField
    val CHARIZARDITE_Y = heldItem("charizardite_y")
    @JvmField
    val CHOICE_SCARF = heldItem("choice_scarf")
    @JvmField
    val CLEANSE_TAG = itemNameBlockItem("cleanse_tag", CobblemonBlocks.CLEANSE_TAG)
@@ -996,8 +962,6 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val DESTINY_KNOT = heldItem("destiny_knot")
    @JvmField
    val DIANCITE = heldItem("diancite")
    @JvmField
    val DRAGON_FANG = heldItem("dragon_fang")
    @JvmField
    val EJECT_BUTTON = heldItem("eject_button")
@@ -1020,42 +984,20 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val FOCUS_SASH = heldItem("focus_sash")
    @JvmField
    val GALLADITE = heldItem("galladite")
    @JvmField
    val GARCHOMPITE = heldItem("garchompite")
    @JvmField
    val GARDEVOIRITE = heldItem("gardevoirite")
    @JvmField
    val GENGARITE = heldItem("gengarite")
    @JvmField
    val GLALITITE = heldItem("glalitite")
    @JvmField
    val GRASSY_SEED = heldItem("grassy_seed")
    @JvmField
    val GRIP_CLAW = heldItem("grip_claw")
    @JvmField
    val GYARADOSITE = heldItem("gyaradosite")
    @JvmField
    val HARD_STONE = heldItem("hard_stone")
    @JvmField
    val HEAVY_DUTY_BOOTS = heldItem("heavy_duty_boots")
    @JvmField
    val HERACRONITE = heldItem("heracronite")
    @JvmField
    val HOUNDOOMINITE = heldItem("houndoominite")
    @JvmField
    val IRON_BALL = heldItem("iron_ball")
    @JvmField
    val KANGASKHANITE = heldItem("kangaskhanite")
    @JvmField
    val LAGGING_TAIL = heldItem("lagging_tail")
    @JvmField
    val LEFTOVERS = compostableHeldItem("leftovers", null, 0.50f)
    @JvmField
    val LATIASITE = heldItem("latiasite")
    @JvmField
    val LATIOSITE = heldItem("latiosite")
    @JvmField
    val LIFE_ORB = heldItem("life_orb")
    @JvmField
    val LIGHT_BALL = heldItem("light_ball")
@@ -1064,40 +1006,20 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val LOADED_DICE = heldItem("loaded_dice")
    @JvmField
    val LOPUNNITE = heldItem("lopunnite")
    @JvmField
    val LUCARIONITE = heldItem("lucarionite")
    @JvmField
    val LUCKY_EGG = heldItem("lucky_egg")
    @JvmField
    val LUMINOUS_MOSS = heldItem("luminous_moss")
    @JvmField
    val MAGNET = heldItem("magnet")
    @JvmField
    val MANECTITE = heldItem("manectite")
    @JvmField
    val MAWILITE = heldItem("mawilite")
    @JvmField
    val MEDICHAMITE = heldItem("medichamite")
    @JvmField
    val METAGROSSITE = heldItem("metagrossite")
    @JvmField
    val METRONOME = heldItem("metronome")
    @JvmField
    val MEWTWONITE_X = heldItem("mewtwonite_x")
    @JvmField
    val MEWTWONITE_Y = heldItem("mewtwonite_y")
    @JvmField
    val MIRACLE_SEED = heldItem("miracle_seed")
    @JvmField
    val MYSTIC_WATER = heldItem("mystic_water")
    @JvmField
    val NEVER_MELT_ICE = heldItem("never_melt_ice")
    @JvmField
    val PIDGEOTITE = heldItem("pidgeotite")
    @JvmField
    val PINSIRITE = heldItem("pinsirite")
    @JvmField
    val POISON_BARB = heldItem("poison_barb")
    @JvmField
    val POWER_ANKLET = heldItem("power_anklet")
@@ -1126,20 +1048,10 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val ROOM_SERVICE = heldItem("room_service")
    @JvmField
    val SABLENITE = heldItem("sablenite")
    @JvmField
    val SALAMENCITE = heldItem("salamencite")
    @JvmField
    val SCEPTILITE = heldItem("sceptilite")
    @JvmField
    val SCIZORITE = heldItem("scizorite")
    @JvmField
    val SCOPE_LENS = heldItem("scope_lens")
    @JvmField
    val SHARP_BEAK = heldItem("sharp_beak")
    @JvmField
    val SHARPEDONITE = heldItem("sharpedonite")
    @JvmField
    val SHED_SHELL = heldItem("shed_shell")
    @JvmField
    val SHELL_BELL = heldItem("shell_bell")
@@ -1148,8 +1060,6 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val SILVER_POWDER = heldItem("silver_powder")
    @JvmField
    val SLOWBRONITE = heldItem("slowbronite")
    @JvmField
    val SOFT_SAND = heldItem("soft_sand")
    @JvmField
    val SPELL_TAG = itemNameBlockItem("spell_tag", CobblemonBlocks.SPELL_TAG)
@@ -1158,12 +1068,8 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val SOOTHE_BELL = heldItem("soothe_bell")
    @JvmField
    val STEELIXITE = heldItem("steelixite")
    @JvmField
    val STICKY_BARB = heldItem("sticky_barb")
    @JvmField
    val SWAMPERTITE = heldItem("swampertite")
    @JvmField
    val TERRAIN_EXTENDER = heldItem("terrain_extender")
    @JvmField
    val THROAT_SPRAY = heldItem("throat_spray")
@@ -1172,14 +1078,10 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val TWISTED_SPOON = heldItem("twisted_spoon")
    @JvmField
    val TYRANITARITE = heldItem("tyranitarite")
    @JvmField
    val UTILITY_UMBRELLA = heldItem("utility_umbrella")
    @JvmField
    val WEAKNESS_POLICY = itemNameBlockItem("weakness_policy", CobblemonBlocks.WEAKNESS_POLICY)
    @JvmField
    val VENUSAURITE = heldItem("venusaurite")
    @JvmField
    val WIDE_LENS = heldItem("wide_lens")
    @JvmField
    val ZOOM_LENS = heldItem("zoom_lens")
@@ -1854,4 +1756,4 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    private fun foodItem(nutrition: Int, saturationModifier: Float): Item {
        return CobblemonItem(Item.Properties().food(FoodProperties.Builder().nutrition(nutrition).saturationModifier(saturationModifier).build()))
    }
-}
+}
@@ -15,12 +15,12 @@ import com.cobblemon.mod.common.api.moves.animations.ActionEffectContext
 import com.mojang.serialization.Codec
 import com.mojang.serialization.codecs.ListCodec
 import com.mojang.serialization.codecs.PrimitiveCodec
 import java.util.Optional
 import java.util.UUID
 import net.minecraft.core.BlockPos
 import net.minecraft.core.GlobalPos
 import net.minecraft.core.UUIDUtil
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.ai.memory.MemoryModuleType
 import java.util.*
 object CobblemonMemories {
    val memories = mutableMapOf<String, MemoryModuleType<*>>()
@@ -107,14 +107,10 @@ import com.cobblemon.mod.common.net.messages.client.pokemon.update.evolution.Add
 import com.cobblemon.mod.common.net.messages.client.pokemon.update.evolution.ClearEvolutionsPacket
 import com.cobblemon.mod.common.net.messages.client.pokemon.update.evolution.ClientboundSeatAssignmentPacket
 import com.cobblemon.mod.common.net.messages.client.pokemon.update.evolution.RemoveEvolutionPacket
 import com.cobblemon.mod.common.net.messages.client.pokemon.update.form.AddFormPacket
 import com.cobblemon.mod.common.net.messages.client.pokemon.update.form.ClearFormsPacket
 import com.cobblemon.mod.common.net.messages.client.pokemon.update.form.RemoveFormPacket
 import com.cobblemon.mod.common.net.messages.client.settings.OpenCobblemonConfigScreenPacket
 import com.cobblemon.mod.common.net.messages.client.settings.ServerSettingsPacket
 import com.cobblemon.mod.common.net.messages.client.sound.UnvalidatedPlaySoundS2CPacket
 import com.cobblemon.mod.common.net.messages.client.spawn.SpawnGenericBedrockPacket
 import com.cobblemon.mod.common.net.messages.client.spawn.SpawnFallingStarPacket
 import com.cobblemon.mod.common.net.messages.client.spawn.SpawnNPCPacket
 import com.cobblemon.mod.common.net.messages.client.spawn.SpawnPokeballPacket
 import com.cobblemon.mod.common.net.messages.client.spawn.SpawnPokemonPacket
@@ -198,8 +194,6 @@ import com.cobblemon.mod.common.net.messages.server.pokemon.update.SetItemHidden
 import com.cobblemon.mod.common.net.messages.server.pokemon.update.SetMarkingsPacket
 import com.cobblemon.mod.common.net.messages.server.pokemon.update.SetNicknamePacket
 import com.cobblemon.mod.common.net.messages.server.pokemon.update.evolution.AcceptEvolutionPacket
 import com.cobblemon.mod.common.net.messages.server.pokemon.update.form.AcceptFormPacket
 import com.cobblemon.mod.common.net.messages.server.pokemon.update.form.RevertFormPacket
 import com.cobblemon.mod.common.net.messages.server.riding.DismountPokemonPacket
 import com.cobblemon.mod.common.net.messages.server.riding.ServerboundUpdateDriverInputPacket
 import com.cobblemon.mod.common.net.messages.server.riding.ServerboundUpdatePassengerPositionPacket
@@ -217,11 +211,9 @@ import com.cobblemon.mod.common.net.messages.server.trade.ChangeTradeAcceptanceP
 import com.cobblemon.mod.common.net.messages.server.trade.OfferTradePacket
 import com.cobblemon.mod.common.net.messages.server.trade.PerformTradePacket
 import com.cobblemon.mod.common.net.messages.server.trade.UpdateTradeOfferPacket
 import com.cobblemon.mod.common.net.serverhandling.AcceptFormHandler
 import com.cobblemon.mod.common.net.serverhandling.ChallengeHandler
 import com.cobblemon.mod.common.net.serverhandling.ChallengeResponseHandler
 import com.cobblemon.mod.common.net.serverhandling.RequestInteractionsHandler
 import com.cobblemon.mod.common.net.serverhandling.RevertFormHandler
 import com.cobblemon.mod.common.net.serverhandling.battle.BattleSelectActionsHandler
 import com.cobblemon.mod.common.net.serverhandling.battle.RemoveSpectatorHandler
 import com.cobblemon.mod.common.net.serverhandling.battle.SpectateBattleHandler
@@ -465,7 +457,6 @@ object CobblemonNetwork {
        list.add(PacketRegisterInfo(SpawnPokemonPacket.ID, SpawnPokemonPacket::decode, SpawnExtraDataEntityHandler()))
        list.add(PacketRegisterInfo(SpawnPokeballPacket.ID, SpawnPokeballPacket::decode, SpawnExtraDataEntityHandler()))
        list.add(PacketRegisterInfo(SpawnGenericBedrockPacket.ID, SpawnGenericBedrockPacket::decode, SpawnExtraDataEntityHandler()))
        list.add(PacketRegisterInfo(SpawnFallingStarPacket.ID, SpawnFallingStarPacket::decode, SpawnExtraDataEntityHandler()))
        list.add(PacketRegisterInfo(SpawnNPCPacket.ID, SpawnNPCPacket::decode, SpawnExtraDataEntityHandler()))
        list.add(PacketRegisterInfo(ToastPacket.ID, ToastPacket::decode, ToastPacketHandler))
@@ -515,11 +506,6 @@ object CobblemonNetwork {
        // Pokédex scanning
        list.add(PacketRegisterInfo(ServerConfirmedRegisterPacket.ID, ServerConfirmedRegisterPacket::decode, ServerConfirmedRegisterHandler))
        // Form packets
        list.add(PacketRegisterInfo(AddFormPacket.ID, AddFormPacket::decode, PokemonUpdatePacketHandler()))
        list.add(PacketRegisterInfo(ClearFormsPacket.ID, ClearFormsPacket::decode, PokemonUpdatePacketHandler()))
        list.add(PacketRegisterInfo(RemoveFormPacket.ID, RemoveFormPacket::decode, PokemonUpdatePacketHandler()))
        // Riding
        list.add(PacketRegisterInfo(ClientboundUpdateRidingStatePacket.ID, ClientboundUpdateRidingStatePacket::decode, ClientboundUpdateRidingStateHandler))
        list.add(PacketRegisterInfo(ClientboundUpdateDriverInputPacket.ID, ClientboundUpdateDriverInputPacket::decode, ClientboundUpdateDriverInputHandler))
@@ -635,10 +621,6 @@ object CobblemonNetwork {
        // NPC packets
        list.add(PacketRegisterInfo(SaveNPCPacket.ID, SaveNPCPacket::decode, SaveNPCHandler))
        // Form Packets
        list.add(PacketRegisterInfo(AcceptFormPacket.ID, AcceptFormPacket::decode, AcceptFormHandler))
        list.add(PacketRegisterInfo(RevertFormPacket.ID, RevertFormPacket::decode, RevertFormHandler))
        // Riding packet(s)
        list.add(PacketRegisterInfo(ServerboundUpdateOrientationPacket.ID, ServerboundUpdateOrientationPacket::decode, ServerboundUpdateOrientationHandler))
        list.add(PacketRegisterInfo(ServerboundUpdateRidingStatePacket.ID, ServerboundUpdateRidingStatePacket::decode, ServerboundUpdateRidingStateHandler))
@@ -9,9 +9,9 @@
 package com.cobblemon.mod.common
 import com.cobblemon.mod.common.entity.pokemon.ai.sensors.*
 import com.cobblemon.mod.common.pokemon.ai.PokemonDisturbancesSensor
 import com.cobblemon.mod.common.entity.sensor.BattlingPokemonSensor
 import com.cobblemon.mod.common.entity.sensor.NPCBattlingSensor
 import com.cobblemon.mod.common.pokemon.ai.PokemonDisturbancesSensor
 import java.util.function.Supplier
 import net.minecraft.world.entity.Entity
 import net.minecraft.world.entity.ai.sensing.Sensor
@@ -8,7 +8,6 @@
 package com.cobblemon.mod.common
 import java.util.Optional
 import net.minecraft.core.registries.BuiltInRegistries
 import net.minecraft.util.RandomSource
 import net.minecraft.world.entity.Entity
@@ -19,6 +18,7 @@ import net.minecraft.world.item.ItemStack
 import net.minecraft.world.item.Items
 import net.minecraft.world.item.trading.ItemCost
 import net.minecraft.world.item.trading.MerchantOffer
 import java.util.Optional
 /**
 * A generator for various trade offers in the mod.
@@ -11,10 +11,10 @@ package com.cobblemon.mod.common.advancement.criterion
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.mojang.serialization.Codec
 import com.mojang.serialization.codecs.RecordCodecBuilder
 import java.util.Optional
 import net.minecraft.advancements.critereon.ContextAwarePredicate
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerPlayer
 import java.util.Optional
 class AspectCriterion(
    playerCtx: Optional<ContextAwarePredicate>,
@@ -14,8 +14,8 @@ import com.mojang.serialization.codecs.RecordCodecBuilder
 import java.util.Optional
 import net.minecraft.advancements.critereon.ContextAwarePredicate
 import net.minecraft.advancements.critereon.EntityPredicate
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.resources.ResourceLocation
 class CastPokeRodContext(val baitId: ResourceLocation)
@@ -10,10 +10,10 @@ package com.cobblemon.mod.common.advancement.criterion
 import com.mojang.serialization.Codec
 import com.mojang.serialization.codecs.RecordCodecBuilder
 import java.util.Optional
 import net.minecraft.advancements.critereon.ContextAwarePredicate
 import net.minecraft.advancements.critereon.EntityPredicate
 import net.minecraft.server.level.ServerPlayer
 import java.util.Optional
 /**
 * A context that is used when you require a [CountableContext] along with some type string.
@@ -14,8 +14,8 @@ import com.mojang.serialization.codecs.RecordCodecBuilder
 import java.util.Optional
 import net.minecraft.advancements.critereon.ContextAwarePredicate
 import net.minecraft.advancements.critereon.EntityPredicate
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.resources.ResourceLocation
 class ReelInPokemonContext(val species : ResourceLocation, val baitId: ResourceLocation)
@@ -9,7 +9,6 @@
 package com.cobblemon.mod.common.api.abilities
 import com.cobblemon.mod.common.api.Priority
 import com.cobblemon.mod.common.api.data.ShowdownIdentifiable
 import com.cobblemon.mod.common.util.codec.CodecUtils
 import com.google.gson.JsonObject
 import com.mojang.serialization.Codec
@@ -26,7 +25,7 @@ class AbilityTemplate(
    var builder: (AbilityTemplate, forced: Boolean, priority: Priority) -> Ability = { template, forced, priority -> Ability(template, forced, priority) },
    val displayName: String = "cobblemon.ability.$name",
    val description: String = "cobblemon.ability.$name.desc"
-) : ShowdownIdentifiable {
+) {
    /**
     * Returns the Ability or if applicable the extension connected to this template
     */
@@ -46,8 +45,6 @@ class AbilityTemplate(
     */
    fun create(json: JsonObject) = create().loadFromJSON(json)
    override fun showdownId(): String = ShowdownIdentifiable.REGEX.replace(this.name.lowercase(), "")
    companion object {
        @JvmStatic
@@ -18,6 +18,7 @@ import com.cobblemon.mod.common.api.molang.MoLangFunctions.addStandardFunctions
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.setup
 import com.cobblemon.mod.common.api.molang.ObjectValue
 import com.cobblemon.mod.common.api.scripting.CobblemonScripts
 import com.cobblemon.mod.common.entity.MoLangScriptingEntity
 import com.cobblemon.mod.common.util.activityRegistry
 import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
@@ -13,6 +13,7 @@ import com.cobblemon.mod.common.api.ai.config.BehaviourConfig
 import com.cobblemon.mod.common.api.molang.ExpressionLike
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.setup
 import com.cobblemon.mod.common.api.scripting.CobblemonScripts
 import com.cobblemon.mod.common.util.asTranslated
 import com.cobblemon.mod.common.util.resolve
 import com.cobblemon.mod.common.util.withQueryValue
@@ -13,6 +13,7 @@ import com.cobblemon.mod.common.util.getBooleanOrNull
 import com.cobblemon.mod.common.util.getDoubleOrNull
 import kotlin.math.sqrt
 import net.minecraft.core.BlockPos
 import net.minecraft.world.entity.PathfinderMob
 /**
 * Used to maintain some settings around how the entity should wander this tick. The idea is you
@@ -8,12 +8,16 @@
 package com.cobblemon.mod.common.api.ai.config
 import com.bedrockk.molang.runtime.MoLangRuntime
 import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
 import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.setup
 import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
 import com.cobblemon.mod.common.util.asExpression
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.cobblemon.mod.common.util.resolveBoolean
 import com.cobblemon.mod.common.util.withQueryValue
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.world.entity.LivingEntity
@@ -11,8 +11,13 @@ package com.cobblemon.mod.common.api.ai.config.task
 import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
 import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
 import com.cobblemon.mod.common.api.ai.asVariables
 import com.cobblemon.mod.common.api.molang.ExpressionLike
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
 import com.cobblemon.mod.common.util.asExpression
 import com.cobblemon.mod.common.util.asExpressionLike
 import com.cobblemon.mod.common.util.resolveBoolean
 import com.cobblemon.mod.common.util.weightedSelection
 import com.cobblemon.mod.common.util.withQueryValue
 import com.mojang.datafixers.util.Either
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.ai.behavior.BehaviorControl
@@ -8,10 +8,12 @@
 package com.cobblemon.mod.common.api.ai.config.task
 import com.bedrockk.molang.runtime.MoLangRuntime
 import com.cobblemon.mod.common.CobblemonMemories
 import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
 import com.cobblemon.mod.common.api.ai.WrapperLivingEntityTask.Companion.wrapped
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.setup
 import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
 import com.cobblemon.mod.common.util.mainThreadRuntime
 import com.cobblemon.mod.common.util.resolveBoolean
@@ -10,6 +10,8 @@ package com.cobblemon.mod.common.api.ai.config.task
 import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
 import com.cobblemon.mod.common.api.ai.asVariables
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
 import com.cobblemon.mod.common.util.withQueryValue
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.ai.behavior.BehaviorControl
 import net.minecraft.world.entity.ai.behavior.StopBeingAngryIfTargetDead
@@ -9,7 +9,9 @@
 package com.cobblemon.mod.common.api.ai.config.task
 import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
 import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
 import com.cobblemon.mod.common.util.withQueryValue
 import net.minecraft.world.Difficulty
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.ai.behavior.declarative.BehaviorBuilder
@@ -15,6 +15,7 @@ import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
 import com.cobblemon.mod.common.entity.npc.ai.SwitchToBattleTask
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.ai.behavior.BehaviorControl
 import net.minecraft.world.entity.ai.memory.MemoryModuleType
 class SwitchToNPCBattleTaskConfig : SingleTaskConfig {
    override fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext) = emptyList<MoLangConfigVariable>()
@@ -10,6 +10,8 @@ package com.cobblemon.mod.common.api.ai.config.task
 import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
 import com.cobblemon.mod.common.api.ai.asVariables
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
 import com.cobblemon.mod.common.util.withQueryValue
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.PathfinderMob
 import net.minecraft.world.entity.ai.behavior.BehaviorControl
@@ -10,6 +10,8 @@ package com.cobblemon.mod.common.api.ai.config.task
 import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
 import com.cobblemon.mod.common.api.ai.asVariables
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
 import com.cobblemon.mod.common.util.withQueryValue
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.PathfinderMob
 import net.minecraft.world.entity.ai.behavior.BehaviorControl
@@ -25,6 +25,7 @@ import net.minecraft.world.entity.ai.behavior.BehaviorControl
 import net.minecraft.world.entity.ai.behavior.declarative.BehaviorBuilder
 import net.minecraft.world.entity.ai.behavior.declarative.Trigger
 import net.minecraft.world.entity.ai.memory.MemoryModuleType
 import net.minecraft.world.entity.ai.memory.MemoryStatus
 import net.minecraft.world.entity.ai.sensing.SensorType
 /**
@@ -22,7 +22,6 @@ import com.cobblemon.mod.common.util.mainThreadRuntime
 import com.cobblemon.mod.common.util.resolveFloat
 import com.cobblemon.mod.common.util.withQueryValue
 import com.mojang.datafixers.util.Either
 import kotlin.math.ceil
 import net.minecraft.core.BlockPos
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.PathfinderMob
@@ -35,6 +34,7 @@ import net.minecraft.world.entity.ai.memory.MemoryModuleType
 import net.minecraft.world.level.material.Fluids
 import net.minecraft.world.level.pathfinder.PathType
 import net.minecraft.world.phys.Vec3
 import kotlin.math.ceil
 class WaterWanderTaskConfig : SingleTaskConfig {
    val condition = booleanVariable(WANDER, "water_wanders", true).asExpressible()
@@ -54,9 +54,9 @@ import com.cobblemon.mod.common.net.messages.client.battle.BattleEndPacket
 import com.cobblemon.mod.common.net.messages.client.battle.BattleMakeChoicePacket
 import com.cobblemon.mod.common.net.messages.client.battle.BattleMessagePacket
 import com.cobblemon.mod.common.net.messages.client.battle.BattleQueueRequestPacket
-import com.cobblemon.mod.common.pokemon.transformation.progress.DefeatTransformationProgress
+import com.cobblemon.mod.common.pokemon.evolution.progress.DefeatEvolutionProgress
-import com.cobblemon.mod.common.pokemon.transformation.progress.LastBattleCriticalHitsTransformationProgress
+import com.cobblemon.mod.common.pokemon.evolution.progress.LastBattleCriticalHitsEvolutionProgress
-import com.cobblemon.mod.common.pokemon.transformation.requirements.DefeatRequirement
+import com.cobblemon.mod.common.pokemon.requirements.DefeatRequirement
 import com.cobblemon.mod.common.util.battleLang
 import com.cobblemon.mod.common.util.getPlayer
 import com.cobblemon.mod.common.util.giveOrDropItemStack
@@ -97,8 +97,8 @@ open class PokemonBattle(
        this.actors.forEach { actor ->
            actor.battle = this
            actor.pokemonList.forEach { battlePokemon ->
-                battlePokemon.effectedPokemon.requirementProgress
+                battlePokemon.effectedPokemon.evolutionProxy.current().progress()
-                    .filterIsInstance<LastBattleCriticalHitsTransformationProgress>()
+                    .filterIsInstance<LastBattleCriticalHitsEvolutionProgress>()
                    .forEach { it.reset() }
            }
        }
@@ -133,7 +133,7 @@ open class PokemonBattle(
        set(value) { field = value.coerceAtMost(Int.MAX_VALUE) } // go outside
    /** The current duration of the battle in seconds. */
-    val time: Int get() = ticks / 20
+    val time: Int get() = ticks % 20
    var dispatchResult = GO
    val dispatches = ConcurrentLinkedDeque<BattleDispatch>()
@@ -271,13 +271,12 @@ open class PokemonBattle(
                        val facedFainted = opponentPokemon.facedOpponents.contains(faintedPokemon)
                        val pokemon = opponentPokemon.effectedPokemon
                        if (facedFainted) {
-                            if (pokemon.hasMatchingRequirement<DefeatRequirement>({ it.target.matches(faintedPokemon.effectedPokemon) })) {
+                            pokemon.lockedEvolutions.forEach { evolution ->
-                                val requiredPokemonProperties = pokemon.getRelevantRequirements<DefeatRequirement> { it.target.matches(faintedPokemon.effectedPokemon) }
+                                evolution.requirements.filterIsInstance<DefeatRequirement>().forEach { defeatRequirement ->
-                                    .map { it.target }
+                                    if (defeatRequirement.target.matches(faintedPokemon.effectedPokemon)) {
-                                    .distinctBy { it.asString() }
+                                        val progress = pokemon.evolutionProxy.current().progressFirstOrCreate({ it is DefeatEvolutionProgress && it.currentProgress().target == defeatRequirement.target }) { DefeatEvolutionProgress() }
-                                for (props in requiredPokemonProperties) {
+                                        progress.updateProgress(DefeatEvolutionProgress.Progress(defeatRequirement.target, progress.currentProgress().amount + 1))
-                                    val progress = pokemon.progressFirstOrCreate({ it is DefeatTransformationProgress && it.currentProgress().target.asString().equals(props.asString(), ignoreCase = true) }, ::DefeatTransformationProgress)
+                                    }
                                    progress.updateProgress(DefeatTransformationProgress.Progress(props.copy(), progress.currentProgress().amount + 1))
                                }
                            }
                        }
@@ -22,9 +22,9 @@ import com.cobblemon.mod.common.item.battle.BagItem
 import com.cobblemon.mod.common.net.messages.client.battle.BattleApplyPassResponsePacket
 import com.cobblemon.mod.common.net.messages.client.battle.BattleMakeChoicePacket
 import com.cobblemon.mod.common.net.messages.client.battle.BattleMessagePacket
 import java.util.UUID
 import net.minecraft.network.chat.Component
 import net.minecraft.network.chat.MutableComponent
 import java.util.UUID
 import net.minecraft.server.level.ServerPlayer
 abstract class BattleActor(
@@ -21,7 +21,6 @@ import com.cobblemon.mod.common.util.adapters.*
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.google.gson.GsonBuilder
 import com.google.gson.reflect.TypeToken
 import java.awt.Color
 import net.minecraft.advancements.critereon.MinMaxBounds
 import net.minecraft.core.registries.Registries
 import net.minecraft.resources.ResourceLocation
@@ -31,6 +30,7 @@ import net.minecraft.tags.TagKey
 import net.minecraft.world.level.biome.Biome
 import net.minecraft.world.phys.AABB
 import net.minecraft.world.phys.Vec3
 import java.awt.Color
 /**
 * The data registry for [Berry].
@@ -26,10 +26,10 @@ import com.cobblemon.mod.common.util.writeBox
 import com.cobblemon.mod.common.util.writeEnumConstant
 import com.cobblemon.mod.common.util.writeIdentifier
 import com.google.gson.annotations.SerializedName
 import java.awt.Color
 import java.util.EnumSet
 import net.minecraft.core.BlockPos
 import net.minecraft.network.RegistryFriendlyByteBuf
 import java.awt.Color
 import java.util.EnumSet
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.tags.TagKey
 import net.minecraft.world.entity.LivingEntity
@@ -8,11 +8,11 @@
 package com.cobblemon.mod.common.api.drop
-import com.cobblemon.mod.common.api.pokemon.transformation.requirement.TransformationRequirement
+import com.cobblemon.mod.common.api.pokemon.requirement.Requirement
 import com.cobblemon.mod.common.pokemon.Pokemon
 class EvolutionItemDropEntry : ItemDropEntry() {
-    val requirements: MutableSet<TransformationRequirement> = mutableSetOf()
+    val requirements: MutableSet<Requirement> = mutableSetOf()
    override fun canDrop(pokemon: Pokemon?): Boolean = pokemon != null && requirements.all { it.check(pokemon) }
 }
@@ -48,10 +48,6 @@ import com.cobblemon.mod.common.api.events.pokemon.evolution.EvolutionAcceptedEv
 import com.cobblemon.mod.common.api.events.pokemon.evolution.EvolutionCompleteEvent
 import com.cobblemon.mod.common.api.events.pokemon.evolution.EvolutionDisplayEvent
 import com.cobblemon.mod.common.api.events.pokemon.evolution.EvolutionTestedEvent
 import com.cobblemon.mod.common.api.events.pokemon.form.FormAcceptedEvent
 import com.cobblemon.mod.common.api.events.pokemon.form.FormCompleteEvent
 import com.cobblemon.mod.common.api.events.pokemon.form.FormDisplayEvent
 import com.cobblemon.mod.common.api.events.pokemon.form.FormTestedEvent
 import com.cobblemon.mod.common.api.events.pokemon.healing.PokemonHealedEvent
 import com.cobblemon.mod.common.api.events.pokemon.interaction.ExperienceCandyUseEvent
 import com.cobblemon.mod.common.api.events.pokemon.interaction.PokemonInteractionGUICreationEvent
@@ -107,18 +103,6 @@ object CobblemonEvents {
    @JvmField
    val EVOLUTION_COMPLETE = EventObservable<EvolutionCompleteEvent>()
    @JvmField
    val FORM_ACCEPTED = CancelableObservable<FormAcceptedEvent>()
    @JvmField
    val FORM_DISPLAY = EventObservable<FormDisplayEvent>()
    @JvmField
    val FORM_TESTED = EventObservable<FormTestedEvent>()
    @JvmField
    val FORM_COMPLETE = EventObservable<FormCompleteEvent>()
    @JvmField
    val POKEMON_NICKNAMED = CancelableObservable<PokemonNicknamedEvent>()
@@ -15,7 +15,9 @@ import com.cobblemon.mod.common.api.battles.model.actor.ActorType
 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.molang.MoLangFunctions.asMostSpecificMoLangValue
 import com.cobblemon.mod.common.battles.actor.PlayerBattleActor
 import com.cobblemon.mod.common.entity.MoLangScriptingEntity
 import com.cobblemon.mod.common.entity.npc.NPCBattleActor
 import com.cobblemon.mod.common.util.asArrayValue
 import net.minecraft.world.entity.LivingEntity
@@ -21,8 +21,7 @@ import com.cobblemon.mod.common.pokemon.Pokemon
 */
 data class FriendshipUpdatedEvent(
    val pokemon: Pokemon,
-    val newFriendshipInitial: Int,
+    val newFriendshipInitial: Int
    val earned: Boolean = false
 ) {
    var newFriendship: Int = newFriendshipInitial
        set(value) {
@@ -12,6 +12,7 @@ import com.bedrockk.molang.runtime.value.DoubleValue
 import com.cobblemon.mod.common.api.events.Cancelable
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.trade.TradeParticipant
 import com.cobblemon.mod.common.util.getPlayer
@@ -12,8 +12,8 @@ import com.bedrockk.molang.runtime.value.MoValue
 import com.cobblemon.mod.common.api.events.Cancelable
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.api.pokemon.evolution.Evolution
 import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.pokemon.transformation.evolution.Evolution
 /**
 * Fired when an evolution is accepted.
@@ -10,8 +10,8 @@ package com.cobblemon.mod.common.api.events.pokemon.evolution
 import com.bedrockk.molang.runtime.value.MoValue
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.api.pokemon.evolution.Evolution
 import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.pokemon.transformation.evolution.Evolution
 /**
 * Fired after an evolution finishes.
@@ -8,9 +8,9 @@
 package com.cobblemon.mod.common.api.events.pokemon.evolution
-import com.cobblemon.mod.common.pokemon.transformation.evolution.Evolution
+import com.cobblemon.mod.common.api.pokemon.evolution.Evolution
 import com.cobblemon.mod.common.api.pokemon.evolution.EvolutionDisplay
 import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.pokemon.transformation.evolution.EvolutionDisplay
 /**
 * Fired before an evolution is sent to clients.
@@ -8,7 +8,7 @@
 package com.cobblemon.mod.common.api.events.pokemon.evolution
-import com.cobblemon.mod.common.pokemon.transformation.evolution.Evolution
+import com.cobblemon.mod.common.api.pokemon.evolution.Evolution
 import com.cobblemon.mod.common.pokemon.Pokemon
 /**
@@ -12,8 +12,8 @@ import com.bedrockk.molang.runtime.value.DoubleValue
 import com.bedrockk.molang.runtime.value.MoValue
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.api.pokemon.evolution.Evolution
 import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.pokemon.transformation.evolution.Evolution
 import com.cobblemon.mod.common.util.getBoolean
 /**
@@ -1,37 +0,0 @@
 /*
 * Copyright (C) 2023 Cobblemon Contributors
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */
 package com.cobblemon.mod.common.api.events.pokemon.form
 import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.events.Cancelable
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.pokemon.transformation.form.TemporaryForm
 /**
 * Fired when a temporary form change is accepted.
 * Cancelling will not notify users nor remove the form from the pending list.
 *
 * @param pokemon The [Pokemon] about to change form.
 * @param form The [TemporaryForm] being used.
 *
 * @author Hiroku
 * @since June 3rd, 2026
 */
 data class FormAcceptedEvent(
    override val pokemon: Pokemon,
    override val form: TemporaryForm
 ) : Cancelable(), FormEvent {
    val context = mutableMapOf(
        "pokemon" to pokemon.struct,
        "form" to StringValue(form.formOnlyShowdownId())
    )
    val functions = moLangFunctionMap(cancelFunc)
 }
@@ -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.api.events.pokemon.form
 import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.pokemon.transformation.form.TemporaryForm
 /**
 * Fired after a temporary form change finishes.
 *
 * @param pokemon The [Pokemon] resulting from the form change.
 * @param form The [TemporaryForm] that was used.
 *
 * @author Hiroku
 * @since June 3rd, 2026
 */
 data class FormCompleteEvent(
    /** The [Pokemon] that did the form change. */
    override val pokemon: Pokemon,
    /** The [TemporaryForm] that was used. */
    override val form: TemporaryForm
 ) : FormEvent {
    val context = mutableMapOf(
        "pokemon" to pokemon.struct,
        "form" to StringValue(form.formOnlyShowdownId())
    )
 }
@@ -1,37 +0,0 @@
 /*
 * Copyright (C) 2023 Cobblemon Contributors
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */
 package com.cobblemon.mod.common.api.events.pokemon.form
 import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.pokemon.transformation.form.FormDisplay
 import com.cobblemon.mod.common.pokemon.transformation.form.TemporaryForm
 /**
 * Fired before a form is sent to clients. For modifications on the actual output when they accept it modify
 * the [display] directly.
 *
 * @param pokemon The [Pokemon] that will change form if this proposition is accepted.
 * @param display The current [FormDisplay] the client will see.
 * @param form The [TemporaryForm] being used.
 *
 * @author Hiroku
 * @since June 3rd, 2026
 */
 data class FormDisplayEvent(
    override val pokemon: Pokemon,
    var display: FormDisplay,
    override val form: TemporaryForm
 ) : FormEvent {
    val context = mutableMapOf(
        "pokemon" to pokemon.struct,
        "display" to display.struct,
        "form" to StringValue(form.formOnlyShowdownId())
    )
 }
@@ -1,22 +0,0 @@
 /*
 * Copyright (C) 2023 Cobblemon Contributors
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */
 package com.cobblemon.mod.common.api.events.pokemon.form
 import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.pokemon.transformation.form.TemporaryForm
 /**
 * The root of the various [TemporaryForm]-related events.
 */
 interface FormEvent {
    /** The Pokémon impacted in this event.*/
    val pokemon: Pokemon
    /*** The form triggering this event.*/
    val form: TemporaryForm
 }
@@ -1,47 +0,0 @@
 /*
 * Copyright (C) 2023 Cobblemon Contributors
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */
 package com.cobblemon.mod.common.api.events.pokemon.form
 import com.bedrockk.molang.runtime.value.DoubleValue
 import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.pokemon.transformation.form.TemporaryForm
 import com.cobblemon.mod.common.util.getBoolean
 /**
 * An event fired when [TemporaryForm.test] has been performed.
 * The final state [result] will be the return value of the test function.
 *
 * @property pokemon The [Pokemon] being tested against.
 * @property form The [TemporaryForm] instance performing the test.
 * @property originalResult The base result from the Cobblemon implementation.
 * @property result The final value returned by [TemporaryForm.test].
 */
 data class FormTestedEvent(
    override val pokemon: Pokemon,
    override val form: TemporaryForm,
    val originalResult: Boolean,
 ) : FormEvent {
    var result: Boolean = originalResult
    val context = mutableMapOf(
        "pokemon" to pokemon.struct,
        "form" to StringValue(form.formOnlyShowdownId()),
        "original_result" to DoubleValue(originalResult),
    )
    val functions = moLangFunctionMap(
        "result" to { DoubleValue(result) },
        "set_result" to {
            result = it.getBoolean(0)
            DoubleValue.ONE
        }
    )
 }
@@ -15,6 +15,7 @@ import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.api.pokemon.PokemonProperties
 import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.util.getPlayer
 import net.minecraft.server.level.ServerPlayer
 /**
@@ -8,6 +8,7 @@
 package com.cobblemon.mod.common.api.events.storage
 import com.bedrockk.molang.runtime.value.DoubleValue
 import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.events.Cancelable
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
@@ -16,7 +16,9 @@ import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.api.storage.PokemonStore
 import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.util.getPlayer
 import net.minecraft.server.level.ServerPlayer
 import java.util.UUID
 /**
 * The base of the events around the release of Pokémon from pc or party.
@@ -14,7 +14,7 @@ import com.cobblemon.mod.common.api.data.JsonDataRegistry
 import com.cobblemon.mod.common.api.pokemon.PokemonProperties
 import com.cobblemon.mod.common.api.reactive.SimpleObservable
 import com.cobblemon.mod.common.net.messages.client.data.FossilRegistrySyncPacket
-import com.cobblemon.mod.common.pokemon.transformation.adapters.LegacyItemConditionWrapperAdapter
+import com.cobblemon.mod.common.pokemon.evolution.adapters.LegacyItemConditionWrapperAdapter
 import com.cobblemon.mod.common.util.adapters.IdentifierAdapter
 import com.cobblemon.mod.common.util.adapters.ItemLikeConditionAdapter
 import com.cobblemon.mod.common.util.adapters.pokemonPropertiesShortAdapter
@@ -65,7 +65,7 @@ class HabitatSpawn {
    /** The maximum light level that the Pokémon can spawn in. */
    var maxLight: Int? = null
-    fun writeToNBT(nbt: CompoundTag) {
+    open fun writeToNBT(nbt: CompoundTag) {
        nbt.putString(DataKeys.HABITAT_POOL_SPAWN_SPECIES, species.resourceIdentifier.toString())
        nbt.putString(DataKeys.HABITAT_POOL_SPAWN_POSITION_TYPE, spawnablePositionType)
        nbt.putFloat(DataKeys.HABITAT_POOL_SPAWN_WEIGHT, weight)
@@ -78,7 +78,7 @@ class HabitatSpawn {
        nbt.putString(DataKeys.HABITAT_POOL_SPAWN_BUCKET, bucket)
    }
-    fun readFromNBT(nbt: CompoundTag) {
+    open fun readFromNBT(nbt: CompoundTag) {
        species = PokemonSpecies.getByIdentifier(nbt.getString(DataKeys.HABITAT_POOL_SPAWN_SPECIES).asIdentifierDefaultingNamespace())!!
        spawnablePositionType = nbt.getString(DataKeys.HABITAT_POOL_SPAWN_POSITION_TYPE)
        weight = nbt.getFloat(DataKeys.HABITAT_POOL_SPAWN_WEIGHT)
@@ -91,7 +91,7 @@ class HabitatSpawn {
        bucket = if (nbt.contains(DataKeys.HABITAT_POOL_SPAWN_BUCKET)) nbt.getString(DataKeys.HABITAT_POOL_SPAWN_BUCKET) else "common"
    }
-    fun encode(buffer: RegistryFriendlyByteBuf) {
+    open fun encode(buffer: RegistryFriendlyByteBuf) {
        buffer.writeResourceLocation(species.resourceIdentifier)
        buffer.writeUtf(spawnablePositionType)
        buffer.writeFloat(weight)
@@ -104,7 +104,7 @@ class HabitatSpawn {
        buffer.writeUtf(bucket)
    }
-    fun decode(buffer: RegistryFriendlyByteBuf) {
+    open fun decode(buffer: RegistryFriendlyByteBuf) {
        species = PokemonSpecies.getByIdentifier(buffer.readResourceLocation())!!
        spawnablePositionType = buffer.readUtf()
        weight = buffer.readFloat()
@@ -118,7 +118,7 @@ class HabitatSpawn {
    }
    /** Creates the [PokemonSpawnDetail] that will be used in the spawner. This is done per habitat block. */
-    fun createSpawnDetail(habitatBlockEntity: HabitatBlockEntity): PokemonSpawnDetail? {
+    open fun createSpawnDetail(habitatBlockEntity: HabitatBlockEntity): PokemonSpawnDetail? {
        val spawnDetail = PokemonSpawnDetail()
        // If the habitat block specifies a level range, it restricts how and if this spawn exists
@@ -13,13 +13,13 @@ import com.cobblemon.mod.common.api.conditional.RegistryLikeCondition
 import com.cobblemon.mod.common.api.data.JsonDataRegistry
 import com.cobblemon.mod.common.api.molang.ExpressionLike
 import com.cobblemon.mod.common.api.pokemon.PokemonProperties
-import com.cobblemon.mod.common.api.pokemon.transformation.requirement.TransformationRequirement
+import com.cobblemon.mod.common.api.pokemon.requirement.Requirement
 import com.cobblemon.mod.common.api.reactive.SimpleObservable
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.net.messages.client.data.PokemonInteractionsSyncPacket
-import com.cobblemon.mod.common.pokemon.transformation.adapters.CobblemonRequirementAdapter
+import com.cobblemon.mod.common.pokemon.adapters.CobblemonRequirementAdapter
-import com.cobblemon.mod.common.pokemon.transformation.adapters.LegacyItemConditionWrapperAdapter
+import com.cobblemon.mod.common.pokemon.evolution.adapters.LegacyItemConditionWrapperAdapter
-import com.cobblemon.mod.common.pokemon.transformation.requirements.PokemonPropertiesRequirement
+import com.cobblemon.mod.common.pokemon.requirements.PokemonPropertiesRequirement
 import com.cobblemon.mod.common.util.adapters.*
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.google.gson.Gson
@@ -46,7 +46,7 @@ object PokemonInteractions : JsonDataRegistry<PokemonInteractionSet> {
        .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
        .registerTypeAdapter(PokemonProperties::class.java, pokemonPropertiesShortAdapter)
        .registerTypeAdapter(ItemPredicate::class.java, LegacyItemConditionWrapperAdapter)
-        .registerTypeAdapter(TransformationRequirement::class.java, CobblemonRequirementAdapter)
+        .registerTypeAdapter(Requirement::class.java, CobblemonRequirementAdapter)
        .registerTypeAdapter(InteractionEffect::class.java, InteractionEffectAdapter)
        .registerTypeAdapter(ExpressionLike::class.java, ExpressionLikeAdapter)
        .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Biome::class.java).type, BiomeLikeConditionAdapter)
@@ -12,16 +12,11 @@ import com.bedrockk.molang.runtime.MoLangRuntime
 import com.cobblemon.mod.common.api.molang.ExpressionLike
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.setup
-import com.cobblemon.mod.common.api.pokemon.transformation.requirement.TransformationRequirement
+import com.cobblemon.mod.common.api.pokemon.requirement.Requirement
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.net.messages.client.sound.UnvalidatedPlaySoundS2CPacket
-import com.cobblemon.mod.common.pokemon.transformation.adapters.CobblemonRequirementAdapter
+import com.cobblemon.mod.common.pokemon.adapters.CobblemonRequirementAdapter
-import com.cobblemon.mod.common.util.asExpressionLike
+import com.cobblemon.mod.common.util.*
 import com.cobblemon.mod.common.util.giveOrDropItemStack
 import com.cobblemon.mod.common.util.readExpressionLike
 import com.cobblemon.mod.common.util.withPlayerValue
 import com.cobblemon.mod.common.util.withQueryValue
 import com.cobblemon.mod.common.util.writeExpressionLike
 import com.google.gson.annotations.SerializedName
 import net.minecraft.core.registries.Registries
 import net.minecraft.network.FriendlyByteBuf
@@ -34,7 +29,7 @@ import net.minecraft.world.entity.item.ItemEntity
 import net.minecraft.world.item.ItemStack
 data class PokemonInteractionSet(
-    val requirements: List<TransformationRequirement> = listOf(),
+    val requirements: List<Requirement> = listOf(),
    val interactions: List<PokemonInteraction> = listOf(),
 ) {
    fun encode(buffer: FriendlyByteBuf) {
@@ -56,7 +51,7 @@ data class PokemonInteractionSet(
 }
 data class PokemonInteraction(
-    val requirements: List<TransformationRequirement> = listOf(),
+    val requirements: List<Requirement> = listOf(),
    val effects: List<InteractionEffect> = listOf(),
    val cooldown: ExpressionLike = "0".asExpressionLike()
 ) {
@@ -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.isBusy() || player.isPartyBusy()
+    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
@@ -9,7 +9,6 @@
 package com.cobblemon.mod.common.api.item
 import com.cobblemon.mod.common.api.data.DataRegistry
 import com.cobblemon.mod.common.api.data.ShowdownIdentifiable
 import com.cobblemon.mod.common.api.reactive.SimpleObservable
 import com.cobblemon.mod.common.battles.runner.ShowdownService
 import com.cobblemon.mod.common.pokemon.helditem.CobblemonHeldItemManager
@@ -30,11 +29,9 @@ object HeldItems : DataRegistry {
    // val heldItems = PrioritizedList<BagItemLike>()
    internal val heldItemsScripts = mutableMapOf<String, String>() // showdown item ID to JavaScript
    val showdownItems = hashSetOf<String>()
    val megaStones = hashMapOf<String, String>()
    override fun reload(manager: ResourceManager) {
        heldItemsScripts.clear()
        megaStones.clear()
        ShowdownService.service.resetRegistryData("heldItem")
        manager.listResources("held_items") { it.path.endsWith(".js") }.forEach { (identifier, resource) ->
            resource.open().use { stream ->
@@ -51,9 +48,6 @@ object HeldItems : DataRegistry {
        for (i in 0 until itemsJson.size()) {
            val jsItem = itemsJson[i].asJsonObject
            showdownItems += jsItem.get("id").asString
            if (jsItem.has("megaEvolves")) {
                megaStones[jsItem.get("id").asString] = ShowdownIdentifiable.REGEX.replace(jsItem.get("megaEvolves").asString.lowercase(), "")
            }
        }
        CobblemonHeldItemManager.load()
@@ -21,9 +21,34 @@ 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.drop.DropEntry
-import com.cobblemon.mod.common.api.molang.function.*
+import com.cobblemon.mod.common.api.molang.function.BattleActorMoLangFunctions
 import com.cobblemon.mod.common.api.molang.function.BattleMessageMoLangFunctions
 import com.cobblemon.mod.common.api.molang.function.BattleMoLangFunctions
 import com.cobblemon.mod.common.api.molang.function.BiomeMoLangFunctions
 import com.cobblemon.mod.common.api.molang.function.BlockMoLangFunctions
 import com.cobblemon.mod.common.api.molang.function.DimensionTypeMoLangFunctions
 import com.cobblemon.mod.common.api.molang.function.DropEntryMoLangFunctions
 import com.cobblemon.mod.common.api.molang.function.EntityMoLangFunctions
 import com.cobblemon.mod.common.api.molang.function.EvolutionMoLangFunctions
 import com.cobblemon.mod.common.api.molang.function.GeneralMoLangFunctions
 import com.cobblemon.mod.common.api.molang.function.ItemStackMoLangFunctions
 import com.cobblemon.mod.common.api.molang.function.LivingEntityMoLangFunctions
 import com.cobblemon.mod.common.api.molang.function.NPCMoLangFunctions
 import com.cobblemon.mod.common.api.molang.function.PCMoLangFunctions
 import com.cobblemon.mod.common.api.molang.function.PartyMoLangFunctions
 import com.cobblemon.mod.common.api.molang.function.PlayerMoLangFunctions
 import com.cobblemon.mod.common.api.molang.function.PokedexMoLangFunctions
 import com.cobblemon.mod.common.api.molang.function.PokemonEntityMoLangFunctions
 import com.cobblemon.mod.common.api.molang.function.PokemonMoLangFunctions
 import com.cobblemon.mod.common.api.molang.function.PokemonPropertiesMoLangFunctions
 import com.cobblemon.mod.common.api.molang.function.PokemonStoreMoLangFunctions
 import com.cobblemon.mod.common.api.molang.function.ServerMoLangFunctions
 import com.cobblemon.mod.common.api.molang.function.SpawnablePositionMoLangFunctions
 import com.cobblemon.mod.common.api.molang.function.SpeciesMoLangFunctions
 import com.cobblemon.mod.common.api.molang.function.WorldMoLangFunctions
 import com.cobblemon.mod.common.api.pokedex.AbstractPokedexManager
 import com.cobblemon.mod.common.api.pokemon.PokemonProperties
 import com.cobblemon.mod.common.api.pokemon.evolution.Evolution
 import com.cobblemon.mod.common.api.scripting.CobblemonScripts
 import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
 import com.cobblemon.mod.common.api.storage.PokemonStore
@@ -33,10 +58,8 @@ import com.cobblemon.mod.common.entity.npc.NPCEntity
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.pokemon.Species
 import com.cobblemon.mod.common.pokemon.transformation.evolution.Evolution
 import com.cobblemon.mod.common.util.effectiveName
 import com.mojang.datafixers.util.Either
 import java.util.function.Function
 import net.minecraft.core.Holder
 import net.minecraft.core.Registry
 import net.minecraft.core.RegistryAccess
@@ -60,7 +83,14 @@ import net.minecraft.world.level.Level
 import net.minecraft.world.level.biome.Biome
 import net.minecraft.world.level.block.Block
 import net.minecraft.world.level.dimension.DimensionType
 import net.minecraft.world.level.levelgen.Heightmap
 import net.minecraft.world.level.pathfinder.PathType
 import net.minecraft.world.level.storage.loot.LootParams
 import net.minecraft.world.level.storage.loot.parameters.LootContextParamSets
 import net.minecraft.world.level.storage.loot.parameters.LootContextParams
 import net.minecraft.world.phys.AABB
 import net.minecraft.world.phys.Vec3
 import java.util.function.Function
 /**
 * Holds a bunch of useful MoLang trickery that can be used or extended in API
@@ -69,31 +99,25 @@ import net.minecraft.world.phys.Vec3
 * @since October 2nd, 2023
 */
 object MoLangFunctions {
-    fun ItemStack.asMoLangValue(registryAccess: RegistryAccess) =
+    fun ItemStack.asMoLangValue(registryAccess: RegistryAccess) = ObjectValue(this)
-        ObjectValue(this)
+        .addStandardFunctions()
-            .addStandardFunctions()
+        .addFunctions(ItemStackMoLangFunctions.attach(Pair(this, registryAccess)))
            .addFunctions(ItemStackMoLangFunctions.attach(Pair(this, registryAccess)))
-    fun Holder<Biome>.asBiomeMoLangValue() =
+    fun Holder<Biome>.asBiomeMoLangValue() = asMoLangValue(Registries.BIOME)
-        asMoLangValue(Registries.BIOME)
+        .addFunctions(BiomeMoLangFunctions.attach(this))
            .addFunctions(BiomeMoLangFunctions.attach(this))
-    fun Holder<Level>.asWorldMoLangValue() =
+    fun Holder<Level>.asWorldMoLangValue() = asMoLangValue(Registries.DIMENSION)
-        asMoLangValue(Registries.DIMENSION)
+        .addFunctions(WorldMoLangFunctions.attach(this))
            .addFunctions(WorldMoLangFunctions.attach(this))
-    fun Holder<Block>.asBlockMoLangValue() =
+    fun Holder<Block>.asBlockMoLangValue() = asMoLangValue(Registries.BLOCK)
-        asMoLangValue(Registries.BLOCK)
+        .addFunctions(BlockMoLangFunctions.attach(this))
            .addFunctions(BlockMoLangFunctions.attach(this))
-    fun MinecraftServer.asMoLangValue() =
+    fun MinecraftServer.asMoLangValue() = ObjectValue(this)
-        ObjectValue(this)
+        .addStandardFunctions()
-            .addStandardFunctions()
+        .addFunctions(ServerMoLangFunctions.attach(this))
            .addFunctions(ServerMoLangFunctions.attach(this))
-    fun Holder<DimensionType>.asDimensionTypeMoLangValue() =
+    fun Holder<DimensionType>.asDimensionTypeMoLangValue() = asMoLangValue(Registries.DIMENSION_TYPE)
-        asMoLangValue(Registries.DIMENSION_TYPE)
+        .addFunctions(DimensionTypeMoLangFunctions.attach(this))
            .addFunctions(DimensionTypeMoLangFunctions.attach(this))
    fun Player.asMoLangValue(): ObjectValue<Player> {
        if (this is ServerPlayer && uuid in Cobblemon.serverPlayerStructs) {
@@ -105,11 +129,10 @@ object MoLangFunctions {
            }
        }
-        val value =
+        val value = ObjectValue(
-            ObjectValue(
+            obj = this,
-                obj = this,
+            stringify = { it.effectiveName().string }
-                stringify = { it.effectiveName().string },
+        )
            )
        value.addFunctions(EntityMoLangFunctions.attach(this))
        value.addFunctions(LivingEntityMoLangFunctions.attach(this))
@@ -130,63 +153,57 @@ object MoLangFunctions {
    }
    fun PartyStore.asMoLangValue(): ObjectValue<PartyStore> {
-        val value =
+        val value = ObjectValue(
-            ObjectValue(
+            obj = this,
-                obj = this,
+            stringify = { it.toString() }
-                stringify = { it.toString() },
+        )
            )
        value.addFunctions(PokemonStoreMoLangFunctions.attach(this))
        value.addFunctions(PartyMoLangFunctions.attach(this))
        return value
    }
    fun DropEntry.asMoLangValue(): ObjectValue<DropEntry> {
-        val value =
+        val value = ObjectValue(
-            ObjectValue(
+            obj = this,
-                obj = this,
+            stringify = { it.toString() }
-                stringify = { it.toString() },
+        )
            )
        value.addFunctions(DropEntryMoLangFunctions.attach(this))
        return value
    }
    fun PokemonProperties.asMoLangValue(): ObjectValue<PokemonProperties> {
-        val value =
+        val value = ObjectValue(
-            ObjectValue(
+            obj = this,
-                obj = this,
+            stringify = { it.asString() }
-                stringify = { it.asString() },
+        )
            )
        value.addFunctions(PokemonPropertiesMoLangFunctions.attach(this))
        return value
    }
    fun Evolution.asMoLangValue(): ObjectValue<Evolution> {
-        val value =
+        val value = ObjectValue(
-            ObjectValue(
+            obj = this,
-                obj = this,
+            stringify = { it.toString() }
-                stringify = { it.toString() },
+        )
            )
        value.addFunctions(EvolutionMoLangFunctions.attach(this))
        return value
    }
    fun PCStore.asMoLangValue(): ObjectValue<PCStore> {
-        val value =
+        val value = ObjectValue(
-            ObjectValue(
+            obj = this,
-                obj = this,
+            stringify = { it.toString() }
-                stringify = { it.toString() },
+        )
            )
        value.addFunctions(PokemonStoreMoLangFunctions.attach(this))
        value.addFunctions(PCMoLangFunctions.attach(this))
        return value
    }
    fun NPCEntity.asMoLangValue(): ObjectValue<NPCEntity> {
-        val value =
+        val value = ObjectValue(
-            ObjectValue(
+            obj = this,
-                obj = this,
+            stringify = { it.name.string }
-                stringify = { it.name.string },
+        )
            )
        value.addFunctions(EntityMoLangFunctions.attach(this))
        value.addFunctions(LivingEntityMoLangFunctions.attach(this))
        value.addFunctions(NPCMoLangFunctions.attach(this))
@@ -194,11 +211,10 @@ object MoLangFunctions {
    }
    fun PokemonEntity.asMoLangValue(): ObjectValue<PokemonEntity> {
-        val value =
+        val value = ObjectValue(
-            ObjectValue(
+            obj = this,
-                obj = this,
+            stringify = { it.pokemon.uuid.toString() }
-                stringify = { it.pokemon.uuid.toString() },
+        )
            )
        value.addFunctions(EntityMoLangFunctions.attach(this))
        value.addFunctions(LivingEntityMoLangFunctions.attach(this))
@@ -209,40 +225,36 @@ object MoLangFunctions {
    }
    fun PokemonBattle.asMoLangValue(): ObjectValue<PokemonBattle> {
-        val value =
+        val value = ObjectValue(
-            ObjectValue(
+            obj = this,
-                obj = this,
+            stringify = { it.battleId.toString() }
-                stringify = { it.battleId.toString() },
+        )
            )
        value.addFunctions(BattleMoLangFunctions.attach(this))
        return value
    }
    fun BattleActor.asMoLangValue(): ObjectValue<BattleActor> {
-        val value =
+        val value = ObjectValue(
-            ObjectValue(
+            obj = this,
-                obj = this,
+            stringify = { it.toString() }
-                stringify = { it.toString() },
+        )
            )
        value.addFunctions(BattleActorMoLangFunctions.attach(this))
        return value
    }
    fun SpawnablePosition.asMoLangValue(): ObjectValue<SpawnablePosition> {
-        val value =
+        val value = ObjectValue(
-            ObjectValue(
+            obj = this,
-                obj = this,
+            stringify = { it.toString() }
-                stringify = { it.toString() },
+        )
            )
        value.addFunctions(SpawnablePositionMoLangFunctions.attach(this))
        return value
    }
    fun Vec3.asMoLangValue(): ObjectValue<Vec3> {
-        val value =
+        val value = ObjectValue(
-            ObjectValue(
+            obj = this
-                obj = this,
+        )
            )
        value.addFunction("x") { this.x }
        value.addFunction("y") { this.y }
        value.addFunction("z") { this.z }
@@ -253,66 +265,45 @@ object MoLangFunctions {
    /**
     * Different functions exist depending on the entity type, this tries to make the struct that's most specific to the type.
     */
-    fun Entity.asMostSpecificMoLangValue(): ObjectValue<out Entity> =
+    fun Entity.asMostSpecificMoLangValue(): ObjectValue<out Entity> {
-        when (this) {
+        return when (this) {
-            is Player -> {
+            is Player -> asMoLangValue()
-                asMoLangValue()
+            is PokemonEntity -> struct
            is NPCEntity -> struct
            is ItemEntity -> ObjectValue(this).also { item ->
                item.addStandardFunctions()
                item.addFunctions(EntityMoLangFunctions.attach(this))
                item.addFunctions(ItemStackMoLangFunctions.attach(Pair(this.item, this.registryAccess())))
            }
-            is PokemonEntity -> {
+            else -> ObjectValue(this).also { objectValue ->
-                struct
+                objectValue.addStandardFunctions()
-            }
+                objectValue.addFunctions(EntityMoLangFunctions.attach(this))
-
+                if (this is LivingEntity) {
-            is NPCEntity -> {
+                    objectValue.addFunctions(LivingEntityMoLangFunctions.attach(this))
                struct
            }
            is ItemEntity -> {
                ObjectValue(this).also { item ->
                    item.addStandardFunctions()
                    item.addFunctions(EntityMoLangFunctions.attach(this))
                    item.addFunctions(ItemStackMoLangFunctions.attach(Pair(this.item, this.registryAccess())))
                }
            }
            else -> {
                ObjectValue(this).also { objectValue ->
                    objectValue.addStandardFunctions()
                    objectValue.addFunctions(EntityMoLangFunctions.attach(this))
                    if (this is LivingEntity) {
                        objectValue.addFunctions(LivingEntityMoLangFunctions.attach(this))
                    }
                }
            }
        }
    }
    fun <T> Holder<T>.asMoLangValue(key: ResourceKey<Registry<T>>): ObjectValue<Holder<T>> {
-        val value =
+        val value = ObjectValue(
-            ObjectValue(
+            obj = this,
-                obj = this,
+            stringify = { it.unwrapKey().get().location().toString() }
-                stringify = {
+        )
-                    it
+        value.functions["is_in"] = Function put@{ params: MoParams ->
-                        .unwrapKey()
+            val tag = TagKey.create(key, ResourceLocation.parse(params.getString(0).replace("#", "")))
-                        .get()
+            return@put DoubleValue(if (value.obj.`is`(tag)) 1.0 else 0.0)
-                        .location()
+        }
-                        .toString()
+        value.functions["is_of"] = Function put@{ params: MoParams ->
-                },
+            val identifier = ResourceLocation.parse(params.getString(0))
-            )
+            return@put DoubleValue(if (value.obj.`is`(identifier)) 1.0 else 0.0)
-        value.functions["is_in"] =
+        }
            Function put@{ params: MoParams ->
                val tag = TagKey.create(key, ResourceLocation.parse(params.getString(0).replace("#", "")))
                return@put DoubleValue(if (value.obj.`is`(tag)) 1.0 else 0.0)
            }
        value.functions["is_of"] =
            Function put@{ params: MoParams ->
                val identifier = ResourceLocation.parse(params.getString(0))
                return@put DoubleValue(if (value.obj.`is`(identifier)) 1.0 else 0.0)
            }
        return value
    }
    fun QueryStruct.addStandardFunctions(): QueryStruct {
-        addFunctions(GeneralMoLangFunctions.functions)
+        addFunctions(GeneralMoLangFunctions.holder)
        return this
    }
@@ -379,17 +370,23 @@ object MoLangFunctions {
        return this
    }
-    fun moLangFunctionMap(vararg functions: Pair<String, (MoParams) -> MoValue>): Map<String, (MoParams) -> MoValue> = functions.toMap()
+    fun moLangFunctionMap(
        vararg functions: Pair<String, (MoParams) -> MoValue>
    ): Map<String, (MoParams) -> MoValue> {
        return functions.toMap()
    }
-    fun queryStructOf(vararg functions: Pair<String, (MoParams) -> MoValue>): QueryStruct =
+    fun queryStructOf(
-        QueryStruct(
+        vararg functions: Pair<String, (MoParams) -> MoValue>
    ): QueryStruct {
        return QueryStruct(
            hashMapOf<String, Function<MoParams, Any>>(
-                *functions
+                *functions.map { (name, func) ->
-                    .map { (name, func) ->
+                    name to Function<MoParams, Any> { params -> func(params) }
-                        name to Function<MoParams, Any> { params -> func(params) }
+                }.toTypedArray()
-                    }.toTypedArray(),
+            )
            ),
        )
    }
    fun MoLangRuntime.setup(): MoLangRuntime {
        environment.query.addStandardFunctions()
@@ -398,14 +395,8 @@ object MoLangFunctions {
    fun writeMoValueToNBT(value: MoValue): Tag? {
        return when (value) {
-            is DoubleValue -> {
+            is DoubleValue -> DoubleTag.valueOf(value.value)
-                DoubleTag.valueOf(value.value)
+            is StringValue -> StringTag.valueOf(value.value)
            }
            is StringValue -> {
                StringTag.valueOf(value.value)
            }
            is ArrayStruct -> {
                val list = value.map.values
                val nbtList = ListTag()
@@ -422,22 +413,14 @@ object MoLangFunctions {
                nbt
            }
-            else -> {
+            else -> null
                null
            }
        }
    }
-    fun readMoValueFromNBT(nbt: Tag): MoValue =
+    fun readMoValueFromNBT(nbt: Tag): MoValue {
-        when (nbt) {
+        return when (nbt) {
-            is DoubleTag -> {
+            is DoubleTag -> DoubleValue(nbt.asDouble)
-                DoubleValue(nbt.asDouble)
+            is StringTag -> StringValue(nbt.asString)
            }
            is StringTag -> {
                StringValue(nbt.asString)
            }
            is ListTag -> {
                val array = ArrayStruct(hashMapOf())
                var index = 0
@@ -458,12 +441,11 @@ object MoLangFunctions {
                variable
            }
-            else -> {
+            else -> VariableStruct()
                VariableStruct()
            }
        }
    }
 }
 // TODO: this one is unused. Should we move it to [MoLangFunctions] object?
 fun Either<ResourceLocation, ExpressionLike>.runScript(runtime: MoLangRuntime) =
-    map({ CobblemonScripts.run(it, runtime) }, { it.resolve(runtime) })
+    map({ CobblemonScripts.run(it, runtime) }, { it.resolve(runtime) })
@@ -17,29 +17,30 @@ import com.cobblemon.mod.common.battles.actor.PlayerBattleActor
 import com.cobblemon.mod.common.battles.actor.PokemonBattleActor
 import com.cobblemon.mod.common.entity.npc.NPCBattleActor
 object BattleActorMoLangFunctions : AbstractMoLangFunctionHolder<BattleActor>() {
    override fun BattleActor.moLangFunctions(): MutableMap<String, (MoParams) -> Any> {
        val actor = this
-        val functions = hashMapOf<String, (MoParams) -> Any>()
+        val map = mutableMapOf<String, (MoParams) -> Any>(
-
+            "is_npc" to { DoubleValue(actor.type == ActorType.NPC) },
-        functions["is_npc"] = { DoubleValue(actor.type == ActorType.NPC) }
+            "is_player" to { DoubleValue(actor.type == ActorType.PLAYER) },
-        functions["is_player"] = { DoubleValue(actor.type == ActorType.PLAYER) }
+            "is_wild" to { DoubleValue(actor.type == ActorType.WILD) }
-        functions["is_wild"] = { DoubleValue(actor.type == ActorType.WILD) }
+        )
        when (actor) {
            is NPCBattleActor -> {
-                functions["npc"] = { actor.entity.struct }
+                map["npc"] = { actor.entity.struct }
            }
            is PlayerBattleActor -> {
-                functions["player"] = { actor.entity?.asMoLangValue() ?: DoubleValue.ZERO }
+                map["player"] = { actor.entity?.asMoLangValue() ?: DoubleValue.ZERO }
            }
            is PokemonBattleActor -> {
-                functions["pokemon"] = { actor.entity?.asMoLangValue() ?: DoubleValue.ZERO }
+                map["pokemon"] = { actor.entity?.asMoLangValue() ?: DoubleValue.ZERO }
            }
        }
-        return functions
+        return map
    }
 }
@@ -16,19 +16,17 @@ import com.cobblemon.mod.common.util.getStringOrNull
 object BattleMessageMoLangFunctions : AbstractMoLangFunctionHolder<BattleMessage>() {
    override fun BattleMessage.moLangFunctions(): MutableMap<String, (MoParams) -> Any> {
        val battleMessage = this
-        val functions = hashMapOf<String, (MoParams) -> Any>()
+        return mutableMapOf(
-
+            "has_argument_at" to { params ->
-        functions["has_argument_at"] = { params ->
+                val index = params.getInt(0)
-            val index = params.getInt(0)
+                val value = params.getStringOrNull(1) ?: ""
-            val value = params.getStringOrNull(1) ?: ""
+                DoubleValue(value == battleMessage.argumentAt(index))
-            DoubleValue(value == battleMessage.argumentAt(index))
+            },
-        }
+            "has_argument" to { params ->
-        functions["has_argument"] = { params ->
+                val argumentName = params.getString(0)
-            val argumentName = params.getString(0)
+                val value = params.getStringOrNull(1) ?: ""
-            val value = params.getStringOrNull(1) ?: ""
+                DoubleValue(value == battleMessage.optionalArgument(argumentName))
-            DoubleValue(value == battleMessage.optionalArgument(argumentName))
+            }
-        }
+        )
        return functions
    }
 }
@@ -13,27 +13,25 @@ import com.bedrockk.molang.runtime.value.DoubleValue
 import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.battles.model.PokemonBattle
 import com.cobblemon.mod.common.util.asArrayValue
-import java.util.UUID
+import java.util.*
 object BattleMoLangFunctions : AbstractMoLangFunctionHolder<PokemonBattle>() {
    override fun PokemonBattle.moLangFunctions(): MutableMap<String, (MoParams) -> Any> {
        val battle = this
-        val functions = hashMapOf<String, (MoParams) -> Any>()
+        return mutableMapOf(
-
+            "environment" to { battle.runtime.environment },
-        functions["environment"] = { battle.runtime.environment }
+            "battle_id" to { StringValue(battle.battleId.toString()) },
-        functions["battle_id"] = { StringValue(battle.battleId.toString()) }
+            "battle_type" to { StringValue(battle.format.toString()) },
-        functions["battle_type"] = { StringValue(battle.format.toString()) }
+            "is_pvn" to { DoubleValue(battle.isPvN) },
-        functions["is_pvn"] = { DoubleValue(battle.isPvN) }
+            "is_pvp" to { DoubleValue(battle.isPvP) },
-        functions["is_pvp"] = { DoubleValue(battle.isPvP) }
+            "is_pvw" to { DoubleValue(battle.isPvW) },
-        functions["is_pvw"] = { DoubleValue(battle.isPvW) }
+            "stop" to { battle.stop() },
-        functions["stop"] = { battle.stop() }
+            "actors" to { battle.actors.toList().asArrayValue { it.struct } },
-        functions["actors"] = { battle.actors.toList().asArrayValue { it.struct } }
+            "get_actor" to getActor@{ params ->
-        functions["get_actor"] = getActor@{ params ->
+                val uuid = UUID.fromString(params.getString(0))
-            val uuid = UUID.fromString(params.getString(0))
+                val actor = battle.actors.find { it.uuid == uuid } ?: return@getActor DoubleValue.ZERO
-            val actor = battle.actors.find { it.uuid == uuid } ?: return@getActor DoubleValue.ZERO
+                actor.struct
-            actor.struct
+            }
-        }
+        )
        return functions
    }
 }
@@ -12,11 +12,8 @@ import com.bedrockk.molang.runtime.MoParams
 import net.minecraft.core.Holder
 import net.minecraft.world.level.biome.Biome
-object BiomeMoLangFunctions : AbstractMoLangFunctionHolder<Holder<Biome>>() {
+object BiomeMoLangFunctions: AbstractMoLangFunctionHolder<Holder<Biome>>() {
    override fun Holder<Biome>.moLangFunctions(): MutableMap<String, (MoParams) -> Any> {
-        val biome = this
+        return mutableMapOf()
        val functions = hashMapOf<String, (MoParams) -> Any>()
        return functions
    }
 }
@@ -12,11 +12,8 @@ import com.bedrockk.molang.runtime.MoParams
 import net.minecraft.core.Holder
 import net.minecraft.world.level.block.Block
-object BlockMoLangFunctions : AbstractMoLangFunctionHolder<Holder<Block>>() {
+object BlockMoLangFunctions: AbstractMoLangFunctionHolder<Holder<Block>>() {
    override fun Holder<Block>.moLangFunctions(): MutableMap<String, (MoParams) -> Any> {
-        val block = this
+        return mutableMapOf()
        val functions = hashMapOf<String, (MoParams) -> Any>()
        return functions
    }
 }
@@ -14,9 +14,6 @@ import net.minecraft.world.level.dimension.DimensionType
 object DimensionTypeMoLangFunctions : AbstractMoLangFunctionHolder<Holder<DimensionType>>() {
    override fun Holder<DimensionType>.moLangFunctions(): MutableMap<String, (MoParams) -> Any> {
-        val dimension = this
+        return mutableMapOf()
        val functions = hashMapOf<String, (MoParams) -> Any>()
        return functions
    }
 }
@@ -18,16 +18,15 @@ import com.cobblemon.mod.common.util.getOrNull
 object DropEntryMoLangFunctions : AbstractMoLangFunctionHolder<DropEntry>() {
    override fun DropEntry.moLangFunctions(): MutableMap<String, (MoParams) -> Any> {
        val drop = this
-        val functions = hashMapOf<String, (MoParams) -> Any>()
+        val map = mutableMapOf<String, (MoParams) -> Any>()
-        functions["percentage"] = { DoubleValue(drop.percentage.toDouble()) }
+        map["percentage"] = { DoubleValue(drop.percentage.toDouble()) }
-        functions["quantity"] = { DoubleValue(drop.quantity.toDouble()) }
+        map["quantity"] = { DoubleValue(drop.quantity.toDouble()) }
-        functions["max_selectable_times"] = { DoubleValue(drop.maxSelectableTimes.toDouble()) }
+        map["max_selectable_times"] = { DoubleValue(drop.maxSelectableTimes.toDouble()) }
-        functions["can_drop"] = { params ->
+        map["can_drop"] = { params ->
            val pokemon = params.getOrNull<ObjectValue<Pokemon>>(0)?.obj
            DoubleValue(if (drop.canDrop(pokemon)) 1.0 else 0.0)
        }
-
+        return map
        return functions
    }
 }
@@ -56,300 +56,258 @@ import kotlin.math.sqrt
 object EntityMoLangFunctions : AbstractMoLangFunctionHolder<Entity>() {
    override fun Entity.moLangFunctions(): MutableMap<String, (MoParams) -> Any> {
-        val entity = this
+        val thisEntity = this
-        val functions = hashMapOf<String, (MoParams) -> Any>()
+        val map = mutableMapOf<String, (MoParams) -> Any>(
-
+            "uuid" to { StringValue(thisEntity.uuid.toString()) },
-        functions["uuid"] = { StringValue(entity.uuid.toString()) }
+            "name" to { _ -> StringValue(thisEntity.effectiveName().string) },
-        functions["name"] = { StringValue(entity.effectiveName().string) }
+            "yaw" to { _ -> DoubleValue(thisEntity.yRot.toDouble()) },
-        functions["yaw"] = { DoubleValue(entity.yRot.toDouble()) }
+            "pitch" to { _ -> DoubleValue(thisEntity.xRot.toDouble()) },
-        functions["pitch"] = { DoubleValue(entity.xRot.toDouble()) }
+            "x" to { _ -> DoubleValue(thisEntity.x) },
-        functions["x"] = { DoubleValue(entity.x) }
+            "y" to { _ -> DoubleValue(thisEntity.y) },
-        functions["y"] = { DoubleValue(entity.y) }
+            "z" to { _ -> DoubleValue(thisEntity.z) },
-        functions["z"] = { DoubleValue(entity.z) }
+            "velocity_x" to { _ -> DoubleValue(thisEntity.deltaMovement.x) },
-        functions["velocity_x"] = { DoubleValue(entity.deltaMovement.x) }
+            "velocity_y" to { _ -> DoubleValue(thisEntity.deltaMovement.y) },
-        functions["velocity_y"] = { DoubleValue(entity.deltaMovement.y) }
+            "velocity_z" to { _ -> DoubleValue(thisEntity.deltaMovement.z) },
-        functions["velocity_z"] = { DoubleValue(entity.deltaMovement.z) }
+            "width" to { DoubleValue(thisEntity.boundingBox.xsize) },
-        functions["width"] = { DoubleValue(entity.boundingBox.xsize) }
+            "height" to { DoubleValue(thisEntity.boundingBox.ysize) },
-        functions["height"] = { DoubleValue(entity.boundingBox.ysize) }
+            "this_size" to { DoubleValue(thisEntity.boundingBox.run { if (xsize > ysize) xsize else ysize }) },
-        functions["this_size"] = { DoubleValue(entity.boundingBox.run { if (xsize > ysize) xsize else ysize }) }
+            "this_width" to { DoubleValue(thisEntity.boundingBox.xsize) },
-        functions["this_width"] = { DoubleValue(entity.boundingBox.xsize) }
+            "this_height" to { DoubleValue(thisEntity.boundingBox.ysize) },
-        functions["this_height"] = { DoubleValue(entity.boundingBox.ysize) }
+            "id_modulo" to { params -> DoubleValue(thisEntity.uuid.hashCode() % params.getDouble(0)) },
-        functions["id_modulo"] = { params -> DoubleValue(entity.uuid.hashCode() % params.getDouble(0)) }
+            "horizontal_velocity" to { _ -> DoubleValue(thisEntity.deltaMovement.horizontalDistance()) },
-        functions["horizontal_velocity"] = { DoubleValue(entity.deltaMovement.horizontalDistance()) }
+            "vertical_velocity" to { DoubleValue(thisEntity.deltaMovement.y) },
-        functions["vertical_velocity"] = { DoubleValue(entity.deltaMovement.y) }
+            "is_on_ground" to { _ -> DoubleValue(thisEntity.onGround()) },
-        functions["is_on_ground"] = { DoubleValue(entity.onGround()) }
+            "world" to { _ -> thisEntity.level().worldRegistry.wrapAsHolder(thisEntity.level()).asWorldMoLangValue() },
-        functions["world"] = {
+            "biome" to { _ -> thisEntity.level().getBiome(thisEntity.blockPosition()).asBiomeMoLangValue() },
-            entity
+            "is_passenger" to { DoubleValue(thisEntity.isPassenger) },
-                .level()
+            "discard" to { thisEntity.discard() },
-                .worldRegistry
+            "is_sneaking" to { _ -> DoubleValue(thisEntity.isShiftKeyDown) },
-                .wrapAsHolder(entity.level())
+            "is_sprinting" to { _ -> DoubleValue(thisEntity.isSprinting) },
-                .asWorldMoLangValue()
+            "is_in_water" to { _ -> DoubleValue(thisEntity.isUnderWater) },
-        }
+            "is_in_rain" to { _ -> DoubleValue(thisEntity.isInWaterOrRain && !thisEntity.isInWater) },
-        functions["biome"] = { entity.level().getBiome(entity.blockPosition()).asBiomeMoLangValue() }
+            "is_touching_water_or_rain" to { _ -> DoubleValue(thisEntity.isInWaterRainOrBubble) },
-        functions["is_passenger"] = { DoubleValue(entity.isPassenger) }
+            "is_touching_water" to { _ -> DoubleValue(thisEntity.isInWater) },
-        functions["discard"] = { entity.discard() }
+            "is_underwater" to { DoubleValue(thisEntity.getIsSubmerged()) },
-        functions["is_sneaking"] = { DoubleValue(entity.isShiftKeyDown) }
+            "is_in_lava" to { _ -> DoubleValue(thisEntity.isInLava) },
-        functions["is_sprinting"] = { DoubleValue(entity.isSprinting) }
+            "is_on_fire" to { _ -> DoubleValue(thisEntity.isOnFire) },
-        functions["is_in_water"] = { DoubleValue(entity.isUnderWater) }
+            "is_invisible" to { _ -> DoubleValue(thisEntity.isInvisible) },
-        functions["is_in_rain"] = { DoubleValue(entity.isInWaterOrRain && !entity.isInWater) }
+            "is_riding" to { _ -> DoubleValue(thisEntity.isPassenger) },
-        functions["is_touching_water_or_rain"] = { DoubleValue(entity.isInWaterRainOrBubble) }
+            "set_name" to { params ->
-        functions["is_touching_water"] = { DoubleValue(entity.isInWater) }
+                val name = params.getString(0)
-        functions["is_underwater"] = { DoubleValue(entity.getIsSubmerged()) }
+                thisEntity.customName = name.text()
-        functions["is_in_lava"] = { DoubleValue(entity.isInLava) }
+                DoubleValue.ONE
-        functions["is_on_fire"] = { DoubleValue(entity.isOnFire) }
+            },
-        functions["is_invisible"] = { DoubleValue(entity.isInvisible) }
+            "damage" to { params ->
-        functions["is_riding"] = { DoubleValue(entity.isPassenger) }
+                val amount = params.getDouble(0)
-        functions["set_name"] = { params ->
+                val source = DamageSource(
-            val name = params.getString(0)
+                    thisEntity.level().registryAccess().registryOrThrow(Registries.DAMAGE_TYPE)
-            entity.customName = name.text()
+                        .getHolder(DamageTypes.GENERIC).get()
            DoubleValue.ONE
        }
        functions["damage"] = { params ->
            val amount = params.getDouble(0)
            val source =
                DamageSource(
                    entity
                        .level()
                        .registryAccess()
                        .registryOrThrow(Registries.DAMAGE_TYPE)
                        .getHolder(DamageTypes.GENERIC)
                        .get(),
                )
-            entity.hurt(source, amount.toFloat())
+                thisEntity.hurt(source, amount.toFloat())
-        }
+            },
-        functions["distance_to_owner"] = distanceToOwner@{
+            "distance_to_owner" to distanceToOwner@{
-            if (entity !is TamableAnimal) {
+                if (thisEntity !is TamableAnimal) {
-                return@distanceToOwner DoubleValue.ZERO
+                    return@distanceToOwner DoubleValue.ZERO
-            }
+                }
-            val owner = entity.owner ?: return@distanceToOwner DoubleValue.ZERO
+                val owner = thisEntity.owner ?: return@distanceToOwner DoubleValue.ZERO
-            DoubleValue(entity.distanceTo(owner))
+                DoubleValue(thisEntity.distanceTo(owner))
-        }
+            },
-        functions["owner"] = owner@{
+            "owner" to owner@{
-            if (entity !is TamableAnimal) return@owner DoubleValue.ZERO
+                if (thisEntity !is TamableAnimal) return@owner DoubleValue.ZERO
-            val owner = entity.owner
+                val owner = thisEntity.owner
-            owner?.asMostSpecificMoLangValue() ?: DoubleValue.ZERO
+                owner?.asMostSpecificMoLangValue() ?: DoubleValue.ZERO
-        }
+            },
-        functions["delta_movement"] = {
+            "delta_movement" to {
-            listOf(entity.deltaMovement.x, entity.deltaMovement.y, entity.deltaMovement.z)
+                listOf(thisEntity.deltaMovement.x, thisEntity.deltaMovement.y, thisEntity.deltaMovement.z)
-                .asArrayValue(::DoubleValue)
+                    .asArrayValue(::DoubleValue)
-        }
+            },
-        functions["tags"] = {
+            "tags" to {
-            val tags = entity.tags
+                val tags = thisEntity.tags
-            val array = ArrayStruct(hashMapOf())
+                val array = ArrayStruct(hashMapOf())
-            tags.forEachIndexed { index, tag -> array.setDirectly("$index", StringValue(tag)) }
+                tags.forEachIndexed { index, tag -> array.setDirectly("$index", StringValue(tag)) }
-            array
+                array
-        }
+            },
-        functions["add_tag"] = { params ->
+            "add_tag" to { params ->
-            val tag = params.getString(0)
+                val tag = params.getString(0)
-            entity.addTag(tag)
+                thisEntity.addTag(tag)
-            DoubleValue.ONE
+                DoubleValue.ONE
-        }
+            },
-        functions["remove_tag"] = { params ->
+            "remove_tag" to { params ->
-            val tag = params.getString(0)
+                val tag = params.getString(0)
-            entity.removeTag(tag)
+                thisEntity.removeTag(tag)
-            DoubleValue.ONE
+                DoubleValue.ONE
-        }
+            },
-        functions["has_tag"] = { params ->
+            "has_tag" to { params ->
-            val tag = params.getString(0)
+                val tag = params.getString(0)
-            DoubleValue(entity.tags.contains(tag))
+                DoubleValue(thisEntity.tags.contains(tag))
-        }
+            },
-        functions["distance_to_pos"] = { params ->
+            "distance_to_pos" to { params ->
-            val x = params.getDouble(0)
+                val x = params.getDouble(0)
-            val y = params.getDouble(1)
+                val y = params.getDouble(1)
-            val z = params.getDouble(2)
+                val z = params.getDouble(2)
-            DoubleValue(sqrt(entity.distanceToSqr(Vec3(x, y, z))))
+                DoubleValue(sqrt(thisEntity.distanceToSqr(Vec3(x, y, z))))
-        }
+            },
-        functions["type"] = {
+            "type" to { _ ->
-            entity
+                thisEntity.registryAccess().registry(Registries.ENTITY_TYPE).get().getKey(thisEntity.type)?.toString()?.let {
                .registryAccess()
                .registry(Registries.ENTITY_TYPE)
                .get()
                .getKey(entity.type)
                ?.toString()
                ?.let {
                    StringValue(it)
                } ?: DoubleValue.ZERO
-        }
+            },
-        functions["find_nearby_block"] = findNearbyBlock@{ params ->
+            "find_nearby_block" to findNearbyBlock@{ params ->
-            val input = params.getString(0)
+                val input = params.getString(0)
-            val isTag = input.contains("#")
+                val isTag = input.contains("#")
-            val type = input.replace("#", "").asIdentifierDefaultingNamespace(namespace = "minecraft")
+                val type = input.replace("#", "").asIdentifierDefaultingNamespace(namespace = "minecraft")
-            val range = params.getDoubleOrNull(1) ?: 10
+                val range = params.getDoubleOrNull(1) ?: 10
-            val blockPos =
+                val blockPos = thisEntity.level().getBlockStatesWithPos(
-                entity
+                    AABB.ofSize(
-                    .level()
+                        thisEntity.position(),
-                    .getBlockStatesWithPos(
+                        range.toDouble(),
-                        AABB.ofSize(
+                        range.toDouble(),
-                            entity.position(),
+                        range.toDouble()
-                            range.toDouble(),
+                    )
                            range.toDouble(),
                            range.toDouble(),
                        ),
                    ).filter { blockPosPair ->
                        blockPosPair.first.blockHolder.let {
                            if (isTag) {
                                it.`is`(
                                    TagKey.create(
                                        Registries.BLOCK,
                                        type,
                                    ),
                                )
                            } else {
                                it.`is`(type)
                            }
                        }
                    }.minByOrNull { it.second.distSqr(entity.blockPosition()) }
                    ?.second
            if (blockPos != null) {
                return@findNearbyBlock ArrayStruct(
                    mapOf(
                        "0" to DoubleValue(blockPos.x),
                        "1" to DoubleValue(blockPos.y),
                        "2" to DoubleValue(blockPos.z),
                    ),
                )
-            }
+                    .filter { blockPosPair ->
-            return@findNearbyBlock DoubleValue.ZERO
+                        blockPosPair.first.blockHolder.let {
-        }
+                            if (isTag) it.`is`(
-        functions["get_nearby_entities"] = { params ->
+                                TagKey.create(
-            val distance = params.getDouble(0)
+                                    Registries.BLOCK,
-            val entities =
+                                    type
-                entity
+                                )
-                    .level()
+                            ) else it.`is`(type)
-                    .getEntities(entity, AABB.ofSize(entity.position(), distance, distance, distance))
+                        }
                    }
                    .minByOrNull { it.second.distSqr(thisEntity.blockPosition()) }
                    ?.second
                if (blockPos != null) {
                    return@findNearbyBlock ArrayStruct(
                        mapOf(
                            "0" to DoubleValue(blockPos.x),
                            "1" to DoubleValue(blockPos.y),
                            "2" to DoubleValue(blockPos.z)
                        )
                    )
                }
                return@findNearbyBlock DoubleValue.ZERO
            },
            "get_nearby_entities" to { params ->
                val distance = params.getDouble(0)
                val entities =
                    thisEntity.level().getEntities(thisEntity, AABB.ofSize(thisEntity.position(), distance, distance, distance))
-            entities
+                entities
-                .filterIsInstance<Entity>()
+                    .filterIsInstance<Entity>()
-                .map { it.asMostSpecificMoLangValue() }
+                    .map { it.asMostSpecificMoLangValue() }
-                .asArrayValue()
+                    .asArrayValue()
-        }
+            },
-        functions["is_standing_on_blocks"] = { params ->
+            "is_standing_on_blocks" to { params ->
-            val depth = params.getDouble(0).toInt()
+                val depth = params.getDouble(0).toInt()
-            val blockStrings: MutableSet<String> = mutableSetOf()
+                val blockStrings: MutableSet<String> = mutableSetOf()
-            for (blockIndex in 1..<params.params.size) {
+                for (blockIndex in 1..<params.params.size) {
-                blockStrings.add(params.getString(blockIndex))
+                    blockStrings.add(params.getString(blockIndex))
-            }
+                }
-            if (entity.isStandingOn(blockStrings, depth)) DoubleValue.ONE else DoubleValue.ZERO
+                if (thisEntity.isStandingOn(blockStrings, depth)) DoubleValue.ONE else DoubleValue.ZERO
-        }
+            },
-        // q.entity.spawn_bedrock_particles(effect, locator, [player])
+            // q.entity.spawn_bedrock_particles(effect, locator, [player])
-        // sends to everyone nearby or just to the player if they're set.
+            // sends to everyone nearby or just to the player if they're set.
-        // Locator is necessary even if unused on non-posables.
+            // Locator is necessary even if unused on non-posables.
-        functions["spawn_bedrock_particles"] = { params ->
+            "spawn_bedrock_particles" to { params ->
-            val particle = params.getString(0).asResource()
+                val particle = params.getString(0).asResource()
-            val locator = params.getString(1)
+                val locator = params.getString(1)
-            val player =
+                val player = params.getOrNull<MoValue>(2)?.let {
                params.getOrNull<MoValue>(2)?.let {
                    when (it) {
-                        is StringValue -> entity.level().getPlayerByUUID(UUID.fromString(it.value))
+                        is StringValue -> thisEntity.level().getPlayerByUUID(UUID.fromString(it.value))
                        is ObjectValue<*> -> it.obj
                        else -> null
                    }
                } as? ServerPlayer
-            val packet = SpawnSnowstormEntityParticlePacket(particle, entity.id, listOf(locator))
+                val packet = SpawnSnowstormEntityParticlePacket(particle, thisEntity.id, listOf(locator))
-            if (player == null) {
+                if (player == null) {
-                packet.sendToPlayersAround(
+                    packet.sendToPlayersAround(thisEntity.x, thisEntity.y, thisEntity.z, 64.0, thisEntity.level().dimension())
-                    entity.x,
+                } else {
-                    entity.y,
+                    packet.sendToPlayer(player)
-                    entity.z,
+                }
-                    64.0,
+            },
-                    entity.level().dimension(),
+            "make_intangible" to { params ->
-                )
+                val intangible = params.getBooleanOrNull(0) ?: true
-            } else {
+                thisEntity.noPhysics = intangible
-                packet.sendToPlayer(player)
+                DoubleValue.ONE
            }
-        }
+        )
        functions["make_intangible"] = { params ->
            val intangible = params.getBooleanOrNull(0) ?: true
            entity.noPhysics = intangible
            DoubleValue.ONE
        }
-        when (entity) {
+
-            is PosableEntity -> {
+        if (thisEntity is PosableEntity) {
-                functions["play_animation"] = playAnimation@{ params ->
+            map["play_animation"] = playAnimation@{ params ->
-                    val animation = params.getString(0)
+                val animation = params.getString(0)
-                    val packet = PlayPosableAnimationPacket(entity.id, setOf(animation), emptyList())
+                val packet = PlayPosableAnimationPacket(thisEntity.id, setOf(animation), emptyList())
-                    val target = params.getStringOrNull(1)
+                val target = params.getStringOrNull(1)
-                    if (target != null) {
+                if (target != null) {
-                        val targetPlayer =
+                    val targetPlayer = if (target.asUUID != null) {
-                            if (target.asUUID != null) {
+                        thisEntity.level().getPlayerByUUID(target.asUUID!!) as ServerPlayer
-                                entity.level().getPlayerByUUID(target.asUUID!!) as ServerPlayer
+                    } else if (thisEntity.level() is ServerLevel) {
-                            } else if (entity.level() is ServerLevel) {
+                        thisEntity.level().server!!.playerList.getPlayerByName(target)
                                entity
                                    .level()
                                    .server!!
                                    .playerList
                                    .getPlayerByName(target)
                            } else {
                                null
                            }
                        if (targetPlayer != null) {
                            packet.sendToPlayer(targetPlayer)
                            return@playAnimation DoubleValue.ONE
                        } else {
                            return@playAnimation DoubleValue.ZERO
                        }
                    } else {
-                        packet.sendToPlayersAround(
+                        null
-                            entity.x,
+                    }
-                            entity.y,
+                    if (targetPlayer != null) {
-                            entity.z,
+                        packet.sendToPlayer(targetPlayer)
                            64.0,
                            entity.level().dimension(),
                        )
                        return@playAnimation DoubleValue.ONE
                    }
                }
                functions["face"] = { params ->
                    ObjectValue(ReferenceDialogueFaceProvider(entity.id, params.getBooleanOrNull(0) != false))
                }
            }
            is Schedulable -> {
                functions["run_molang_after"] = { params ->
                    val expression = params.getString(0).asExpressionLike()
                    val delayInSeconds = params.getDouble(1).toFloat()
                    val runtime = MoLangRuntime()
                    runtime.environment.cloneFrom(params.environment)
                    entity.after(delayInSeconds) {
                        runtime.resolve(expression)
                    }
                }
            }
            is MoLangScriptingEntity -> {
                functions["add_callback"] = { params ->
                    val type = params.getString(0).asIdentifierDefaultingNamespace()
                    val callback = params.getString(1).asIdentifierDefaultingNamespace()
                    val allowDuplicates = params.getBooleanOrNull(2) ?: false
                    entity.callbacks.addCallback(type, callback, allowDuplicates)
                }
                functions["remove_callback"] = { params ->
                    val type = params.getString(0).asIdentifierDefaultingNamespace()
                    val callback = params.getString(1).asIdentifierDefaultingNamespace()
                    entity.callbacks.removeCallback(type, callback)
                }
                functions["has_callback"] = { params ->
                    val type = params.getString(0).asIdentifierDefaultingNamespace()
                    val callback = params.getString(1).asIdentifierDefaultingNamespace()
                    DoubleValue(callback in (entity.callbacks[type] ?: emptySet()))
                }
                functions["clear_callbacks"] = { params ->
                    val type = params.getStringOrNull(0)?.asIdentifierDefaultingNamespace()
                    if (type != null) {
                        entity.callbacks[type]?.clear()
                    } else {
-                        entity.callbacks.clear()
+                        return@playAnimation DoubleValue.ZERO
                    }
-                    DoubleValue.ONE
+                } else {
                    packet.sendToPlayersAround(thisEntity.x, thisEntity.y, thisEntity.z, 64.0, thisEntity.level().dimension())
                    return@playAnimation DoubleValue.ONE
                }
            }
            map["face"] = { params ->
                ObjectValue(ReferenceDialogueFaceProvider(thisEntity.id, params.getBooleanOrNull(0) != false))
            }
        }
        if (thisEntity is Schedulable) {
            map["run_molang_after"] = { params ->
                val expression = params.getString(0).asExpressionLike()
                val delayInSeconds = params.getDouble(1).toFloat()
                val runtime = MoLangRuntime()
                runtime.environment.cloneFrom(params.environment)
                thisEntity.after(delayInSeconds) {
                    runtime.resolve(expression)
                }
            }
        }
-        return functions
+        if (thisEntity is MoLangScriptingEntity) {
            map["add_callback"] = { params ->
                val type = params.getString(0).asIdentifierDefaultingNamespace()
                val callback = params.getString(1).asIdentifierDefaultingNamespace()
                val allowDuplicates = params.getBooleanOrNull(2) ?: false
                thisEntity.callbacks.addCallback(type, callback, allowDuplicates)
            }
            map["remove_callback"] = { params ->
                val type = params.getString(0).asIdentifierDefaultingNamespace()
                val callback = params.getString(1).asIdentifierDefaultingNamespace()
                thisEntity.callbacks.removeCallback(type, callback)
            }
            map["has_callback"] = { params ->
                val type = params.getString(0).asIdentifierDefaultingNamespace()
                val callback = params.getString(1).asIdentifierDefaultingNamespace()
                DoubleValue(callback in (thisEntity.callbacks[type] ?: emptySet()))
            }
            map["clear_callbacks"] = { params ->
                val type = params.getStringOrNull(0)?.asIdentifierDefaultingNamespace()
                if (type != null) {
                    thisEntity.callbacks[type]?.clear()
                } else {
                    thisEntity.callbacks.clear()
                }
                DoubleValue.ONE
            }
        }
        return map
    }
 }
@@ -11,37 +11,34 @@ package com.cobblemon.mod.common.api.molang.function
 import com.bedrockk.molang.runtime.MoParams
 import com.bedrockk.molang.runtime.value.DoubleValue
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
-import com.cobblemon.mod.common.api.pokemon.transformation.Transformation
+import com.cobblemon.mod.common.api.pokemon.evolution.Evolution
-import com.cobblemon.mod.common.pokemon.transformation.evolution.Evolution
+import com.cobblemon.mod.common.pokemon.evolution.variants.ItemInteractionEvolution
-import com.cobblemon.mod.common.pokemon.transformation.triggers.ItemInteractionTrigger
+import com.cobblemon.mod.common.pokemon.evolution.variants.LevelUpEvolution
-import com.cobblemon.mod.common.pokemon.transformation.triggers.LevelUpTrigger
+import com.cobblemon.mod.common.pokemon.evolution.variants.TradeEvolution
 import com.cobblemon.mod.common.pokemon.transformation.triggers.TradeTrigger
-object EvolutionMoLangFunctions : AbstractMoLangFunctionHolder<Transformation>() {
+object EvolutionMoLangFunctions : AbstractMoLangFunctionHolder<Evolution>() {
-    override fun Transformation.moLangFunctions(): MutableMap<String, (MoParams) -> Any> {
+    override fun Evolution.moLangFunctions(): MutableMap<String, (MoParams) -> Any> {
        val evolution = this
-        val functions = hashMapOf<String, (MoParams) -> Any>()
+        val map = hashMapOf<String, (MoParams) -> Any>()
-        functions["reevaluate"] = { DoubleValue(evolution.reevaluate) }
+        map["result"] = { evolution.result.asMoLangValue() }
-        functions["is_optional"] = { DoubleValue(evolution.optional) }
+        map["is_optional"] = { DoubleValue(evolution.optional) }
        map["consumes_held_item"] = { DoubleValue(evolution.consumeHeldItem) }
-        if (evolution is Evolution) {
+        when (evolution) {
-            functions["result"] = { evolution.result.asMoLangValue() }
+            is LevelUpEvolution -> {
-            when (evolution.trigger) {
+                map["is_level_up"] = { DoubleValue.ONE }
-                is LevelUpTrigger -> {
+            }
                    functions["is_level_up"] = { DoubleValue.ONE }
                }
-                is TradeTrigger -> {
+            is TradeEvolution -> {
-                    functions["is_trade"] = { DoubleValue.ONE }
+                map["is_trade"] = { DoubleValue.ONE }
-                }
+            }
-                is ItemInteractionTrigger -> {
+            is ItemInteractionEvolution -> {
-                    functions["is_item"] = { DoubleValue.ONE }
+                map["is_item"] = { DoubleValue.ONE }
                }
            }
        }
-        return functions
+        return map
    }
 }
@@ -42,99 +42,101 @@ import net.minecraft.world.item.ItemStack
 import java.text.ParseException
 object GeneralMoLangFunctions {
-    val functions: MutableMap<String, (MoParams) -> Any> = mutableMapOf()
+    val holder: HashMap<String, (MoParams) -> Any> = hashMapOf(
-
+        "print" to { params ->
    init {
        functions["print"] = { params ->
            val message = params.get<MoValue>(0).asString()
            LOGGER.info(message)
-        }
+        },
-        functions["delete_variable"] = { params ->
+        "delete_variable" to deleteVar@{ params ->
            val struct = params.get<VariableStruct>(0)
            val variable = params.getString(1)
            struct.map.remove(variable)
            return@deleteVar DoubleValue.ONE
        },
        "delete_variables" to { params ->
            val struct = params.get<VariableStruct>(0)
            struct.map.clear()
            DoubleValue.ONE
-        }
+        },
-        functions["get_variable"] = { params ->
+        "get_variable" to { params ->
            val struct = params.get<VariableStruct>(0)
            val variable = params.getString(1)
            struct.map[variable] ?: DoubleValue.ZERO
-        }
+        },
-        functions["set_variable"] = { params ->
+        "set_variable" to { params ->
            val struct = params.get<VariableStruct>(0)
            val variable = params.getString(1)
            val value = params.get<MoValue>(2)
            struct.map[variable] = value
            value
-        }
+        },
-        functions["set_query"] = { params ->
+        "set_query" to { params ->
            val variable = params.getString(0)
            val value = params.get<MoValue>(1)
            params.environment.query.addFunction(variable) { value }
            value
-        }
+        },
-        functions["replace"] = { params ->
+        "replace" to { params ->
            val text = params.getString(0)
            val search = params.getString(1)
            val replace = params.getString(2)
            StringValue(text.replace(search, replace))
-        }
+        },
-        functions["is_included"] = { params ->
+        "is_included" to { params ->
            val text = params.getString(0)
            val search = params.getString(1)
            DoubleValue(text.contains(search))
-        }
+        },
-        functions["to_lower"] = { params ->
+        "to_lower" to { params ->
            StringValue(params.getString(0).lowercase())
-        }
+        },
-        functions["to_upper"] = { params ->
+        "to_upper" to { params ->
            StringValue(params.getString(0).uppercase())
-        }
+        },
-        functions["string_length"] = { params ->
+        "string_length" to { params ->
            DoubleValue(params.getString(0).length)
-        }
+        },
-        functions["split_string"] = { params ->
+        "split_string" to { params ->
            val text = params.getString(0)
            val delimiter = params.getString(1)
            val parts = text.split(delimiter).map { StringValue(it) }
            val struct = ArrayStruct(hashMapOf())
            parts.forEachIndexed { index, moValue -> struct.setDirectly("$index", moValue) }
            struct
-        }
+        },
-        functions["is_blank"] = { params ->
+        "is_blank" to { params ->
            val arg = params.get<MoValue>(0)
-            DoubleValue(
+            DoubleValue((arg is StringValue && (arg.value.isBlank() || arg.value.toDoubleOrNull() == 0.0)) || (arg is DoubleValue && arg.value == 0.0))
-                (arg is StringValue && (arg.value.isBlank() || arg.value.toDoubleOrNull() == 0.0)) ||
+        },
-                    (arg is DoubleValue && arg.value == 0.0),
+        "run_command" to { params ->
            )
        }
        functions["run_command"] = { params ->
            val command = params.getString(0)
            try {
                server()!!.commands.performPrefixedCommand(server()!!.createCommandSourceStack(), command)
            } catch (_: NullPointerException) {
                DoubleValue.ZERO
            }
-        }
+        },
-        functions["is_int"] = { params -> DoubleValue(params.get<MoValue>(0).asString().isInt()) }
+        "is_int" to { params -> DoubleValue(params.get<MoValue>(0).asString().isInt()) },
-        functions["is_number"] = { params ->
+        "is_number" to { params ->
            DoubleValue(
-                params.get<MoValue>(0).asString().toDoubleOrNull() != null,
+                params.get<MoValue>(0).asString().toDoubleOrNull() != null
            )
-        }
+        },
-        functions["to_number"] = { params ->
+        "to_number" to { params ->
            DoubleValue(
-                params.get<MoValue>(0).asString().toDoubleOrNull() ?: 0.0,
+                params.get<MoValue>(0).asString().toDoubleOrNull() ?: 0.0
            )
-        }
+        },
-        functions["to_int"] = { params ->
+        "to_int" to { params ->
            DoubleValue(
-                params.get<MoValue>(0).asString().toIntOrNull() ?: 0,
+                params.get<MoValue>(0).asString().toIntOrNull() ?: 0
            )
-        }
+        },
-        functions["to_string"] = { params -> StringValue(params.get<MoValue>(0).asString()) }
+        "to_string" to { params -> StringValue(params.get<MoValue>(0).asString()) },
-        functions["do_effect_walks"] = { DoubleValue(Cobblemon.config.walkingInBattleAnimations) }
+        "do_effect_walks" to { _ ->
-        functions["random"] = { params ->
+            DoubleValue(Cobblemon.config.walkingInBattleAnimations)
        },
        "random" to { params ->
            val options = mutableListOf<MoValue>()
            var index = 0
            while (params.contains(index)) {
@@ -142,35 +144,35 @@ object GeneralMoLangFunctions {
                index++
            }
            options.random() // Can throw an exception if they specified no args. They'd be idiots though.
-        }
+        },
-        functions["curve"] = { params ->
+        "curve" to { params ->
            val curveName = params.getString(0)
            val curve =
                WaveFunctions.functions[curveName] ?: throw IllegalArgumentException("Unknown curve: $curveName")
            ObjectValue(curve)
-        }
+        },
-        functions["array"] = { params ->
+        "array" to { params ->
            val values = params.params
            val array = ArrayStruct(hashMapOf())
            values.forEachIndexed { index, moValue -> array.setDirectly("$index", moValue) }
            array
-        }
+        },
-        functions["length"] = { params ->
+        "length" to { params ->
            val array = (params.getOrNull<MoValue>(0) as? VariableStruct)
            if (array == null) {
                DoubleValue.ZERO
            } else {
                DoubleValue(array.map.size.toDouble())
            }
-        }
+        },
-        functions["append"] = { params ->
+        "append" to { params ->
            val array = params.get<ArrayStruct>(0)
            val value = params.get<MoValue>(1)
            val nextIndex = array.map.size
            array.setDirectly("$nextIndex", value)
            array
-        }
+        },
-        functions["insert"] = { params ->
+        "insert" to { params ->
            val array = params.get<ArrayStruct>(0)
            val index = params.getInt(1)
            val value = params.get<MoValue>(2)
@@ -185,40 +187,36 @@ object GeneralMoLangFunctions {
            }
            array.map[index.toString()] = value
            array
-        }
+        },
-        functions["delete"] = { params ->
+        "delete" to { params ->
            val array = params.get<ArrayStruct>(0)
            val index = params.getInt(1)
            if (index in 0 until array.map.size) {
                array.map.remove(index.toString())
                // Re-index the array to keep keys sequential in numerical order
                val newMap = hashMapOf<String, MoValue>()
-                array.map.keys
+                array.map.keys.mapNotNull { it.toIntOrNull() }
                    .mapNotNull { it.toIntOrNull() }
                    .sorted()
                    .forEachIndexed { i, k -> newMap[i.toString()] = array.map[k.toString()]!! }
                array.map.clear()
                array.map.putAll(newMap)
            }
            array
-        }
+        },
-        functions["run_script"] = { params ->
+        "run_script" to { params ->
            val runtime = MoLangRuntime()
            runtime.environment.query = params.environment.query
            runtime.environment.variable = params.environment.variable
            val args = params.params.subList(1, params.params.size)
-            runtime.environment.context =
+            runtime.environment.context = ContextStruct(
-                ContextStruct(
+                (params.environment.context?.map
-                    (
+                    ?: emptyMap()) + args.mapIndexed { index, value -> "arg_${index + 1}" to value }.toMap()
-                        params.environment.context?.map
+            )
                            ?: emptyMap()
                    ) + args.mapIndexed { index, value -> "arg_${index + 1}" to value }.toMap(),
                )
            val script = params.getString(0).asIdentifierDefaultingNamespace()
            // store the args in the
            CobblemonScripts.run(script, runtime) ?: DoubleValue.ZERO
-        }
+        },
-        functions["run_molang"] = { params ->
+        "run_molang" to { params ->
            val runtime = MoLangRuntime()
            runtime.environment.query = params.environment.query
            runtime.environment.variable = params.environment.variable
@@ -226,16 +224,17 @@ object GeneralMoLangFunctions {
            val expression = params.getString(0).asExpressionLike()
            val delayInSeconds = params.getDoubleOrNull(1)?.toFloat() ?: 0.0f
-            fun evaluate(): MoValue =
+            fun evaluate(): MoValue {
-                try {
+                return try {
                    runtime.resolve(expression)
                } catch (ex: Exception) {
                    LOGGER.warn(
                        "Failed to evaluate MoLang expression${if (delayInSeconds > 0.0f) " (delayed)" else ""}: $expression",
-                        ex,
+                        ex
                    )
                    DoubleValue.ZERO
                }
            }
            if (delayInSeconds > 0.0f) {
                val tracker =
@@ -247,55 +246,55 @@ object GeneralMoLangFunctions {
            } else {
                evaluate()
            }
-        }
+        },
-        functions["system_time_millis"] = { DoubleValue(System.currentTimeMillis()) }
+        "system_time_millis" to { _ ->
            DoubleValue(System.currentTimeMillis())
        },
        // the rest of the world use dd/MM/yyyy grow up america (this comment was generated by copilot)
-        functions["date_local_time"] = {
+        "date_local_time" to { _ ->
            val time = System.currentTimeMillis()
            val date = java.util.Date(time)
            val formatted = java.text.SimpleDateFormat("dd/MM/yyyy").format(date)
            StringValue(formatted)
-        }
+        },
-        functions["date_of"] = { params ->
+        "date_of" to { 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)
-        }
+        },
-        functions["date_is_after"] = { params ->
+        "date_is_after" to { params ->
            val dateA = params.getString(0)
            val dateB = params.getString(1)
            val format = java.text.SimpleDateFormat("dd/MM/yyyy")
-            val a =
+            val a = try {
-                try {
+                 format.parse(dateA)
-                    format.parse(dateA)
+            } catch (_: ParseException) {
-                } catch (_: ParseException) {
+                throw RuntimeException("Cannot parse date ${dateA}, expected it to be in dd/MM/yyyy format, other provided")
-                    throw RuntimeException("Cannot parse date $dateA, expected it to be in dd/MM/yyyy format, other provided")
+            }
-                }
+            val b = try {
-            val b =
+                format.parse(dateB)
-                try {
+            } catch (_: ParseException) {
-                    format.parse(dateB)
+                throw RuntimeException("Cannot parse date ${dateB}, expected it to be in dd/MM/yyyy format, other provided")
-                } catch (_: ParseException) {
+            }
                    throw RuntimeException("Cannot parse date $dateB, expected it to be in dd/MM/yyyy format, other provided")
                }
            DoubleValue(a.after(b))
-        }
+        },
-        functions["get_move_from_id"] = { params ->
+        "get_move_from_id" to { params ->
            val moveId = params.getString(0)
            val moveTemplate = Moves.getByName(moveId)
            moveTemplate?.struct ?: DoubleValue.ZERO
-        }
+        },
-        functions["create_simple_party_provider"] = {
+        "create_simple_party_provider" to { _ ->
            val partyProvider = SimplePartyProvider()
            partyProvider.struct
-        }
+        },
-        functions["create_pickup_item"] = { params ->
+        "create_pickup_item" to { params ->
            val item = params.getOrNull<MoValue>(0)?.asString()?.let(ObtainableItemCondition::parseFromString)
            val pickupPriority = params.getIntOrNull(1) ?: 0
            val pickupItem = ObtainableItem(item = item, pickupPriority = pickupPriority)
            pickupItem.struct
-        }
+        },
-        functions["create_itemstack"] = { params ->
+        "create_itemstack" to { params ->
            val itemId = params.getString(0).asIdentifierDefaultingNamespace()
            try {
                val item = BuiltInRegistries.ITEM.get(itemId)
@@ -306,7 +305,7 @@ object GeneralMoLangFunctions {
                LOGGER.error("Cannot create item stack from identifier: $itemId, item with that ID does not exist. Possible typo?")
                DoubleValue.ZERO
            }
-        }
+        },
-        functions["file"] = { MoLangLoadedFilesCache.struct }
+        "file" to { MoLangLoadedFilesCache.struct }
-    }
+    )
 }
@@ -26,44 +26,43 @@ object ItemStackMoLangFunctions : AbstractMoLangFunctionHolder<Pair<ItemStack, R
        val registryAccess = this.second
        val itemRegistry = registryAccess.registryOrThrow(Registries.ITEM)
        val holder = itemRegistry.wrapAsHolder(stack.item)
        val functions = mutableMapOf<String, (MoParams) -> Any>()
-        functions["item"] = { holder.asMoLangValue(Registries.ITEM) }
+        val map = hashMapOf<String, (MoParams) -> Any>()
-        functions["count"] = { DoubleValue(stack.count.toDouble()) }
+        map["item"] = { _ -> holder.asMoLangValue(Registries.ITEM) }
-        functions["damage_value"] = { DoubleValue(stack.damageValue) }
+        map["count"] = { _ -> DoubleValue(stack.count.toDouble()) }
-        functions["max_damage"] = { DoubleValue(stack.maxDamage) }
+        map["damage_value"] = { _ -> DoubleValue(stack.damageValue) }
-        functions["is_empty"] = { DoubleValue(stack.isEmpty) }
+        map["max_damage"] = { _ -> DoubleValue(stack.maxDamage) }
-        functions["shrink"] = { params -> stack.shrink(params.getInt(0)) }
+        map["is_empty"] = { _ -> DoubleValue(stack.isEmpty) }
-        functions["grow"] = { params -> stack.grow(params.getInt(0)) }
+        map["shrink"] = { params -> stack.shrink(params.getInt(0)) }
-        functions["is_of"] = { params ->
+        map["grow"] = { params -> stack.grow(params.getInt(0)) }
        map["is_of"] = { params ->
            DoubleValue(
                holder.`is`(
-                    params.getString(0).asIdentifierDefaultingNamespace(),
+                    params.getString(0).asIdentifierDefaultingNamespace()
-                ),
+                )
            )
        }
-        functions["is_in"] = { params ->
+        map["is_in"] = { params ->
            DoubleValue(
                holder.`is`(
                    TagKey.create(
                        Registries.ITEM,
-                        params.getString(0).replace("#", "").asIdentifierDefaultingNamespace(),
+                        params.getString(0).replace("#", "").asIdentifierDefaultingNamespace()
-                    ),
+                    )
-                ),
+                )
            )
        }
-        functions["is_food"] = { DoubleValue(stack.has(DataComponents.FOOD)) }
+        map["is_food"] = { _ -> DoubleValue(stack.has(DataComponents.FOOD)) }
-        functions["is_enchanted"] = { DoubleValue(stack.hasFoil()) }
+        map["is_enchanted"] = { _ -> DoubleValue(stack.hasFoil()) }
-        functions["has_enchantment"] = hasEnchantment@{ params ->
+        map["has_enchantment"] = put@{ params ->
            val enchantmentId = params.getString(0).asIdentifierDefaultingNamespace()
            val minLevel = params.getIntOrNull(1) ?: 1
            val enchantmentRegistry = registryAccess.registryOrThrow(Registries.ENCHANTMENT)
            val holder =
-                enchantmentRegistry.getHolder(enchantmentId).orElse(null) ?: return@hasEnchantment DoubleValue.ZERO
+                enchantmentRegistry.getHolder(enchantmentId).orElse(null) ?: return@put DoubleValue.ZERO
            val level = EnchantmentHelper.getItemEnchantmentLevel(holder, stack)
-            DoubleValue(level >= minLevel)
+            return@put DoubleValue(level >= minLevel)
        }
-
+        return map
        return functions
    }
 }
@@ -53,27 +53,26 @@ import java.util.*
 object LivingEntityMoLangFunctions : AbstractMoLangFunctionHolder<LivingEntity>() {
    override fun LivingEntity.moLangFunctions(): MutableMap<String, (MoParams) -> Any> {
        val entity = this
-        val functions = hashMapOf<String, (MoParams) -> Any>()
+        val map = mutableMapOf<String, (MoParams) -> Any>()
-
+        map["is_player"] = { _ -> DoubleValue(entity is Player) }
-        functions["is_player"] = { DoubleValue(entity is Player) }
+        map["is_npc"] = { _ -> DoubleValue(entity is NPCEntity) }
-        functions["is_npc"] = { DoubleValue(entity is NPCEntity) }
+        map["is_mob"] = { _ -> DoubleValue(entity is Mob) }
-        functions["is_mob"] = { DoubleValue(entity is Mob) }
+        map["is_pokemon"] = { _ -> DoubleValue(entity is PokemonEntity) }
-        functions["is_pokemon"] = { DoubleValue(entity is PokemonEntity) }
+        map["is_animal"] = { _ -> DoubleValue(entity is Animal) }
-        functions["is_animal"] = { DoubleValue(entity is Animal) }
+        map["is_tamable"] = { _ -> DoubleValue(entity is TamableAnimal) }
-        functions["is_tamable"] = { DoubleValue(entity is TamableAnimal) }
+        map["is_tamed"] = { _ -> DoubleValue(entity is TamableAnimal && entity.isTame) }
-        functions["is_tamed"] = { DoubleValue(entity is TamableAnimal && entity.isTame) }
+        map["is_hostile"] = { _ -> DoubleValue(entity is Monster) }
-        functions["is_hostile"] = { DoubleValue(entity is Monster) }
+        map["is_baby"] = { _ -> DoubleValue(entity.isBaby) }
-        functions["is_baby"] = { DoubleValue(entity.isBaby) }
+        map["is_adult"] = { _ -> DoubleValue(!entity.isBaby) }
-        functions["is_adult"] = { DoubleValue(!entity.isBaby) }
+        map["remove_effect"] = put@{ params ->
        functions["remove_effect"] = removeEffect@{ params ->
            val effectId = params.getString(0).asIdentifierDefaultingNamespace()
            val effectHolder = BuiltInRegistries.MOB_EFFECT.getHolder(effectId).orElse(null)
            if (effectHolder != null) {
                entity.removeEffect(effectHolder)
-                return@removeEffect DoubleValue.ONE
+                return@put DoubleValue.ONE
            }
        }
-        functions["add_effect"] = addEffect@{ params ->
+        map["add_effect"] = put@{ params ->
            val effectId = params.getString(0).asIdentifierDefaultingNamespace()
            val duration = params.getInt(1)
            val amplifier = params.getIntOrNull(2) ?: 0
@@ -82,37 +81,36 @@ object LivingEntityMoLangFunctions : AbstractMoLangFunctionHolder<LivingEntity>(
            val effectHolder = BuiltInRegistries.MOB_EFFECT.getHolder(effectId).orElse(null)
            if (effectHolder != null) {
                entity.addEffect(MobEffectInstance(effectHolder, duration, amplifier, ambient, visible))
-                return@addEffect DoubleValue.ONE
+                return@put DoubleValue.ONE
            }
        }
-        functions["has_effect"] = { params ->
+        map["has_effect"] = put@{ params ->
            val effectId = params.getString(0).asIdentifierDefaultingNamespace()
            val effectHolder = BuiltInRegistries.MOB_EFFECT.getHolder(effectId).orElse(null)
-            DoubleValue(effectHolder != null && entity.hasEffect(effectHolder))
+            return@put DoubleValue(if (effectHolder != null) entity.hasEffect(effectHolder) else false)
        }
-        functions["heal"] = { params ->
+        map["heal"] = { params ->
            val amount = params.getDouble(0)
            entity.heal(amount.toFloat())
        }
-        functions["is_looking_at"] = isLookingAt@{ params ->
+        map["is_looking_at"] = put@{ params ->
            val targetEntity = params.get<MoValue>(0)
            val maxDistance = params.getDoubleOrNull(1)?.toFloat() ?: 2.0F
-            val entity =
+            val entity = if (targetEntity is ObjectValue<*> && targetEntity.obj is Entity) {
-                if (targetEntity is ObjectValue<*> && targetEntity.obj is Entity) {
+                targetEntity.obj as Entity
-                    targetEntity.obj as Entity
+            } else {
-                } else {
+                return@put DoubleValue.ZERO
-                    return@isLookingAt DoubleValue.ZERO
+            }
                }
-            DoubleValue(entity.isLookingAt(entity, maxDistance))
+            return@put DoubleValue(entity.isLookingAt(entity, maxDistance))
        }
-        functions["is_living_entity"] = { DoubleValue.ONE }
+        map["is_living_entity"] = { DoubleValue.ONE }
-        functions["is_flying"] = { DoubleValue(entity.isFallFlying) }
+        map["is_flying"] = { _ -> DoubleValue(entity.isFallFlying) }
-        functions["is_sleeping"] = { DoubleValue(entity.isSleeping) }
+        map["is_sleeping"] = { _ -> DoubleValue(entity.isSleeping) }
-        functions["health"] = { DoubleValue(entity.health) }
+        map["health"] = { _ -> DoubleValue(entity.health) }
-        functions["max_health"] = { DoubleValue(entity.maxHealth) }
+        map["max_health"] = { _ -> DoubleValue(entity.maxHealth) }
-        functions["look_at_position"] = { params ->
+        map["look_at_position"] = { params ->
            val x = params.getDouble(0)
            val y = params.getDouble(1)
            val z = params.getDouble(2)
@@ -122,174 +120,159 @@ object LivingEntityMoLangFunctions : AbstractMoLangFunctionHolder<LivingEntity>(
            brain.setMemoryWithExpiry(
                MemoryModuleType.LOOK_TARGET,
                CobblemonBlockPosTracker(Vec3(x, y, z), flags.toSet()),
-                duration.toLong(),
+                duration.toLong()
            )
        }
-        functions["get_wander_control_memory"] = {
+        map["get_wander_control_memory"] = put@{
-            val value =
+            val value = entity.brain.getMemorySafely(CobblemonMemories.WANDER_CONTROL).orElse(null)
-                entity.brain.getMemorySafely(CobblemonMemories.WANDER_CONTROL).orElse(null)
+                ?: CobblemonWanderControl()
                    ?: CobblemonWanderControl()
            if (
-                !entity.brain.checkMemory(CobblemonMemories.WANDER_CONTROL, MemoryStatus.VALUE_PRESENT) &&
+                !entity.brain.checkMemory(CobblemonMemories.WANDER_CONTROL, MemoryStatus.VALUE_PRESENT)
-                entity.brain.checkMemory(CobblemonMemories.WANDER_CONTROL, MemoryStatus.REGISTERED)
+                && entity.brain.checkMemory(CobblemonMemories.WANDER_CONTROL, MemoryStatus.REGISTERED)
            ) {
                entity.brain.setMemory(CobblemonMemories.WANDER_CONTROL, value)
            }
-            value.struct
+            return@put value.struct
        }
-        functions["get_position_memory"] = getPosMemory@{ params ->
+        map["get_position_memory"] = put@{ params ->
            val id = params.getString(0).asIdentifierDefaultingNamespace()
            val memoryType = BuiltInRegistries.MEMORY_MODULE_TYPE.get(id)
            if (entity.brain.checkMemory(memoryType, MemoryStatus.VALUE_PRESENT)) {
-                return@getPosMemory when (val memory = entity.brain.getMemory(memoryType).get()) {
+                return@put when (val memory = entity.brain.getMemory(memoryType).get()) {
-                    is Vec3i -> {
+                    is Vec3i -> VariableStruct(
-                        VariableStruct(
+                        mapOf(
-                            mapOf(
+                            "x" to DoubleValue(memory.x),
-                                "x" to DoubleValue(memory.x),
+                            "y" to DoubleValue(memory.y),
-                                "y" to DoubleValue(memory.y),
+                            "z" to DoubleValue(memory.z)
                                "z" to DoubleValue(memory.z),
                            ),
                        )
-                    }
+                    )
-                    is Position -> {
+                    is Position -> VariableStruct(
-                        VariableStruct(
+                        mapOf(
-                            mapOf(
+                            "x" to DoubleValue(memory.x()),
-                                "x" to DoubleValue(memory.x()),
+                            "y" to DoubleValue(memory.y()),
-                                "y" to DoubleValue(memory.y()),
+                            "z" to DoubleValue(memory.z())
                                "z" to DoubleValue(memory.z()),
                            ),
                        )
-                    }
+                    )
-                    else -> {
+                    else -> DoubleValue.ZERO
                        DoubleValue.ZERO
                    }
                }
            } else {
                return@put DoubleValue.ZERO
            }
            DoubleValue.ZERO
        }
-        functions["set_uuid_memory"] = setUuidMemory@{ params ->
+        map["set_uuid_memory"] = put@{ params ->
-            val memory =
+            val memory = params.getString(0).asIdentifierDefaultingNamespace()
-                params
+                .let(BuiltInRegistries.MEMORY_MODULE_TYPE::get) as MemoryModuleType<UUID>
-                    .getString(0)
+            val uuid = params.getString(1).asUUID ?: return@put DoubleValue.ZERO
                    .asIdentifierDefaultingNamespace()
                    .let(BuiltInRegistries.MEMORY_MODULE_TYPE::get) as MemoryModuleType<UUID>
            val uuid = params.getString(1).asUUID ?: return@setUuidMemory DoubleValue.ZERO
            val expiry = params.getIntOrNull(2) ?: -1
            if (expiry != -1) {
                entity.brain.setMemoryWithExpiry(memory, uuid, expiry.toLong())
            } else {
                entity.brain.setMemory(memory, uuid)
            }
-            DoubleValue.ONE
+            return@put DoubleValue.ONE
        }
-        functions["erase_memory"] = { params ->
+        map["erase_memory"] = put@{ params ->
-            val memories =
+            val memories = params.params.map { it.asString().asIdentifierDefaultingNamespace() }
-                params.params
+                .map(BuiltInRegistries.MEMORY_MODULE_TYPE::get)
                    .map { it.asString().asIdentifierDefaultingNamespace() }
                    .map(BuiltInRegistries.MEMORY_MODULE_TYPE::get)
            memories.forEach { entity.brain.eraseMemory(it) }
-            DoubleValue.ONE
+            return@put DoubleValue.ONE
        }
-        functions["has_memory_value"] = hasMemoryValue@{ params ->
+        map["has_memory_value"] = put@{ params ->
            for (param in params.params) {
                if (!entity.hasMemoryFromString(param.asString())) {
-                    return@hasMemoryValue DoubleValue.ZERO
+                    return@put DoubleValue.ZERO
                }
            }
-            DoubleValue.ONE
+            return@put DoubleValue.ONE
        }
-        functions["lacks_memory_value"] = lacksMemoryValue@{ params ->
+        map["lacks_memory_value"] = put@{ params ->
            for (param in params.params) {
                if (entity.hasMemoryFromString(param.asString())) {
-                    return@lacksMemoryValue DoubleValue.ZERO
+                    return@put DoubleValue.ZERO
                }
            }
-            DoubleValue.ONE
+            return@put DoubleValue.ONE
        }
-        functions["is_doing_activity"] = isDoingActivity@{ params ->
+        map["is_doing_activity"] = put@{ params ->
            for (param in params.params) {
                if (entity.isDoingActivityFromString(param.asString())) {
-                    return@isDoingActivity DoubleValue.ONE
+                    return@put DoubleValue.ONE
                }
            }
-            DoubleValue.ZERO
+            return@put DoubleValue.ZERO
        }
-        functions["can_see"] = canSee@{ params ->
+        map["can_see"] = put@{ params ->
            val target = params.get<MoValue>(0)
            val range = params.getDoubleOrNull(1) ?: 32.0
            if (target is ObjectValue<*>) {
-                val targetEntity = target.obj as? LivingEntity ?: return@canSee DoubleValue.ZERO
+                val targetEntity = target.obj as? LivingEntity ?: return@put DoubleValue.ZERO
                val vector = targetEntity.eyePosition.subtract(entity.eyePosition).normalize()
-                val trace =
+                val trace = entity.traceEntityCollision(
-                    entity.traceEntityCollision(
+                    maxDistance = range.toFloat(),
-                        maxDistance = range.toFloat(),
+                    stepDistance = 0.1F,
-                        stepDistance = 0.1F,
+                    direction = vector,
-                        direction = vector,
+                    entityClass = targetEntity.javaClass,
-                        entityClass = targetEntity.javaClass,
+                    collideBlock = ClipContext.Fluid.NONE
-                        collideBlock = ClipContext.Fluid.NONE,
+                )
                return@put DoubleValue(targetEntity in (trace?.entities ?: emptyList()))
            } else {
                return@put DoubleValue.ZERO
            }
        }
        if (entity is PathfinderMob) {
            map["walk_to"] = { params ->
                val x = params.getDouble(0)
                val y = params.getDouble(1)
                val z = params.getDouble(2)
                val speedMultiplier = params.getDoubleOrNull(3) ?: 0.35
                if (entity.brain.checkMemory(MemoryModuleType.WALK_TARGET, MemoryStatus.REGISTERED)) {
                    entity.brain.setMemory(
                        MemoryModuleType.WALK_TARGET,
                        WalkTarget(Vec3(x, y, z), speedMultiplier.toFloat(), 1)
                    )
-                return@canSee DoubleValue(targetEntity in (trace?.entities ?: emptyList()))
+                    entity.brain.setMemory(
-            }
+                        MemoryModuleType.LOOK_TARGET,
-            DoubleValue.ZERO
+                        BlockPosTracker(Vec3(x, y + entity.eyeHeight, z))
-        }
+                    )
-
+                } else {
-        when (entity) {
+                    entity.navigation.moveTo(x, y, z, speedMultiplier)
-            is PathfinderMob -> {
+                    entity.lookControl.setLookAt(Vec3(x, y + entity.eyeHeight, z))
                functions["walk_to"] = { params ->
                    val x = params.getDouble(0)
                    val y = params.getDouble(1)
                    val z = params.getDouble(2)
                    val speedMultiplier = params.getDoubleOrNull(3) ?: 0.35
                    if (entity.brain.checkMemory(MemoryModuleType.WALK_TARGET, MemoryStatus.REGISTERED)) {
                        entity.brain.setMemory(
                            MemoryModuleType.WALK_TARGET,
                            WalkTarget(Vec3(x, y, z), speedMultiplier.toFloat(), 1),
                        )
                        entity.brain.setMemory(
                            MemoryModuleType.LOOK_TARGET,
                            BlockPosTracker(Vec3(x, y + entity.eyeHeight, z)),
                        )
                    } else {
                        entity.navigation.moveTo(x, y, z, speedMultiplier)
                        entity.lookControl.setLookAt(Vec3(x, y + entity.eyeHeight, z))
                    }
                }
                functions["has_walk_target"] = {
                    DoubleValue(entity.brain.getMemorySafely(MemoryModuleType.WALK_TARGET).isPresent || entity.isPathFinding)
                }
                functions["set_can_float"] = { params ->
                    val canFloat = params.getBooleanOrNull(0) != false
                    entity.navigation.setCanFloat(canFloat)
                    DoubleValue.ONE
                }
                functions["get_pathfinding_malus"] = getPfMalus@{ params ->
                    val type = PathType.entries.find { it.name == params.getString(0).uppercase() }
                    if (type != null) {
                        return@getPfMalus DoubleValue(entity.getPathfindingMalus(type))
                    }
                    Cobblemon.LOGGER.error("Cannot get pathfinding type, unknown value: ${params.getString(0)}")
                    DoubleValue.ZERO
                }
                functions["set_pathfinding_malus"] = setPfMalus@{ params ->
                    val type = PathType.entries.find { it.name == params.getString(0).uppercase() }
                    val malus = params.getDouble(1).toFloat()
                    if (type != null) {
                        entity.setPathfindingMalus(type, malus)
                        return@setPfMalus DoubleValue.ONE
                    }
                    Cobblemon.LOGGER.error("Cannot set pathfinding type, unknown value: ${params.getString(0)}")
                    DoubleValue.ZERO
                }
            }
        }
-        return functions
+            map["has_walk_target"] = { _ ->
                DoubleValue(entity.brain.getMemorySafely(MemoryModuleType.WALK_TARGET).isPresent || entity.isPathFinding)
            }
            map["set_can_float"] = { params ->
                val canFloat = params.getBooleanOrNull(0) != false
                entity.navigation.setCanFloat(canFloat)
                DoubleValue.ONE
            }
            map["get_pathfinding_malus"] = put@{ params ->
                val type = PathType.entries.find { it.name == params.getString(0).uppercase() }
                if (type != null) {
                    return@put DoubleValue(entity.getPathfindingMalus(type))
                }
                Cobblemon.LOGGER.error("Unknown pathfinding type: ${params.getString(0)}")
                return@put DoubleValue.ZERO
            }
            map["set_pathfinding_malus"] = put@{ params ->
                val type = PathType.entries.find { it.name == params.getString(0).uppercase() }
                val malus = params.getDouble(1).toFloat()
                if (type != null) {
                    entity.setPathfindingMalus(type, malus)
                    return@put DoubleValue.ONE
                }
                Cobblemon.LOGGER.error("Unknown pathfinding type: ${params.getString(0)}")
                return@put DoubleValue.ZERO
            }
        }
        return map
    }
 }
@@ -50,23 +50,18 @@ import kotlin.collections.any
 object NPCMoLangFunctions : AbstractMoLangFunctionHolder<NPCEntity>() {
    override fun NPCEntity.moLangFunctions(): MutableMap<String, (MoParams) -> Any> {
        val npc = this
-        val functions = hashMapOf<String, (MoParams) -> Any>()
+        val map = hashMapOf<String, (MoParams) -> Any>()
-
+        map["class"] = { StringValue(npc.npc.id.toString()) }
-        functions["class"] = { StringValue(npc.npc.id.toString()) }
+        map["name"] = { StringValue(npc.name.string) }
-        functions["name"] = { StringValue(npc.name.string) }
+        map["level"] = { DoubleValue(npc.level) }
-        functions["level"] = { DoubleValue(npc.level) }
+        map["has_aspect"] = { params -> DoubleValue(npc.aspects.contains(params.getString(0))) }
-        functions["has_aspect"] = { params -> DoubleValue(npc.aspects.contains(params.getString(0))) }
+        map["in_battle"] = { DoubleValue(npc.isInBattle()) }
-        functions["in_battle"] = { DoubleValue(npc.isInBattle()) }
+        map["battles"] = {
-        functions["battles"] = {
+            ArrayStruct(npc.battleIds.mapNotNull { BattleRegistry.getBattle(it)?.struct }
-            ArrayStruct(
+                .mapIndexed { index, value -> "$index" to value }.toMap())
                npc.battleIds
                    .mapNotNull { BattleRegistry.getBattle(it)?.struct }
                    .mapIndexed { index, value -> "$index" to value }
                    .toMap(),
            )
        }
-        functions["stop_battles"] = { npc.battleIds.forEach { BattleRegistry.getBattle(it)?.stop() } }
+        map["stop_battles"] = { _ -> npc.battleIds.forEach { BattleRegistry.getBattle(it)?.stop() } }
-        functions["run_script_on_client"] = { params ->
+        map["run_script_on_client"] = { params ->
            val world = npc.level()
            if (world is ServerLevel) {
                val script = params.getString(0)
@@ -75,142 +70,141 @@ object NPCMoLangFunctions : AbstractMoLangFunctionHolder<NPCEntity>() {
            }
            Unit
        }
-        functions["run_script"] = { params ->
+        map["run_script"] = { params ->
            val script = params.getString(0).asIdentifierDefaultingNamespace()
            val runtime = MoLangRuntime()
            runtime.environment.cloneFrom(params.environment)
            CobblemonScripts.run(script, runtime) ?: DoubleValue(0)
        }
-        functions["set_movable"] = { params ->
+        map["set_movable"] = put@{ params ->
            val movable = params.getBooleanOrNull(0) != false
            npc.isMovable = movable
-            DoubleValue.ONE
+            return@put DoubleValue.ONE
        }
-        functions["set_invulnerable"] = { params ->
+        map["set_invulnerable"] = put@{ params ->
            val invulnerable = params.getBooleanOrNull(0) != false
            npc.isInvulnerable = invulnerable
-            DoubleValue.ONE
+            return@put DoubleValue.ONE
        }
-        functions["set_leashable"] = { params ->
+        map["set_leashable"] = put@{ params ->
            val leashable = params.getBooleanOrNull(0) != false
            npc.isLeashable = leashable
-            DoubleValue.ONE
+            return@put DoubleValue.ONE
        }
-        functions["set_allow_projectile_hits"] = { params ->
+        map["set_allow_projectile_hits"] = put@{ params ->
            val allowProjectileHits = params.getBooleanOrNull(0) != false
            npc.allowProjectileHits = allowProjectileHits
-            DoubleValue.ONE
+            return@put DoubleValue.ONE
        }
-        functions["set_name_tag_visible"] = { params ->
+        map["set_name_tag_visible"] = put@{ params ->
            val nameTagVisible = params.getBooleanOrNull(0) != false
            npc.hideNameTag = !nameTagVisible
-            DoubleValue.ONE
+            return@put DoubleValue.ONE
        }
-        functions["unset_interaction"] = {
+        map["unset_interaction"] = put@{
            npc.interaction = null
-            DoubleValue.ONE
+            return@put DoubleValue.ONE
        }
-        functions["set_dialogue_interaction"] = { params ->
+        map["set_dialogue_interaction"] = put@{ params ->
            val dialogue = params.getString(0).asIdentifierDefaultingNamespace()
-            npc.interaction =
+            npc.interaction = DialogueNPCInteractionConfiguration().also {
-                DialogueNPCInteractionConfiguration().also {
+                it.dialogue = dialogue
-                    it.dialogue = dialogue
+            }
-                }
+            return@put DoubleValue.ONE
            DoubleValue.ONE
        }
-        functions["set_script_interaction"] = { params ->
+        map["set_script_interaction"] = put@{ params ->
            val script = params.getString(0).asIdentifierDefaultingNamespace()
-            npc.interaction =
+            npc.interaction = ScriptNPCInteractionConfiguration().also {
-                ScriptNPCInteractionConfiguration().also {
+                it.script = script
-                    it.script = script
+            }
-                }
+            return@put DoubleValue.ONE
            DoubleValue.ONE
        }
-        functions["set_player_texture"] = setPlayerTexture@{ params ->
+        map["set_player_texture"] = put@{ params ->
            val username = params.getString(0)
            // Re-applying it would be unnecessarily laggy.
            if (username == npc.data.map["player_texture_username"]?.asString()) {
-                return@setPlayerTexture DoubleValue.ZERO
+                return@put DoubleValue.ZERO
            }
            npc.loadTextureFromGameProfileName(username)
-            DoubleValue.ONE
+            return@put DoubleValue.ONE
        }
-        functions["unset_player_texture"] = {
+        map["unset_player_texture"] = put@{
            npc.unloadTexture()
-            DoubleValue.ONE
+            return@put DoubleValue.ONE
        }
-        functions["set_resource_identifier"] = { params ->
+        map["set_resource_identifier"] = put@{ params ->
            val identifier = params.getStringOrNull(0)?.asIdentifierDefaultingNamespace()
            npc.forcedResourceIdentifier = identifier
-            DoubleValue.ONE
+            return@put DoubleValue.ONE
        }
-        functions["unset_resource_identifier"] = {
+        map["unset_resource_identifier"] = put@{
            npc.forcedResourceIdentifier = null
-            DoubleValue.ONE
+            return@put DoubleValue.ONE
        }
-        functions["set_class"] = setClass@{ params ->
+        map["set_class"] = put@{ params ->
            val identifier = params.getString(0).asIdentifierDefaultingNamespace()
            val npcClass = NPCClasses.getByIdentifier(identifier)
            if (npcClass != null) {
                npc.npc = npcClass
-                return@setClass DoubleValue.ONE
+                return@put DoubleValue.ONE
            } else {
                Cobblemon.LOGGER.error("Unknown NPC class: $identifier")
                return@put DoubleValue.ZERO
            }
            Cobblemon.LOGGER.error("Unknown NPC class: $identifier")
            DoubleValue.ZERO
        }
-        functions["set_render_scale"] = { params ->
+        map["set_render_scale"] = put@{ params ->
            val scale = params.getDouble(0)
            npc.renderScale = scale.toFloat()
-            DoubleValue.ONE
+            return@put DoubleValue.ONE
        }
-        functions["render_scale"] = { DoubleValue(npc.renderScale) }
+        map["render_scale"] = { _ -> DoubleValue(npc.renderScale) }
-        functions["set_hitbox_scale"] = { params ->
+        map["set_hitbox_scale"] = put@{ params ->
            val scale = params.getDouble(0).toFloat()
            npc.hitboxScale = scale
            npc.refreshDimensions()
-            DoubleValue.ONE
+            return@put DoubleValue.ONE
        }
-        functions["hitbox_scale"] = { DoubleValue(npc.hitboxScale) }
+        map["hitbox_scale"] = { _ -> DoubleValue(npc.hitboxScale) }
-        functions["set_hitbox"] = setHitbox@{ params ->
+        map["set_hitbox"] = put@{ params ->
            if (params.params.isEmpty()) {
                npc.hitbox = null
-                return@setHitbox DoubleValue.ONE
+                return@put DoubleValue.ONE
            }
            val width = params.getDouble(0).toFloat()
            val height = params.getDouble(1).toFloat()
            val eyeHeight = params.getDoubleOrNull(2)?.toFloat() ?: (height * 0.85F)
            npc.hitbox = EntityDimensions.scalable(width, height).withEyeHeight(eyeHeight)
-            DoubleValue.ONE
+            return@put DoubleValue.ONE
        }
-        functions["unset_hitbox"] = {
+        map["unset_hitbox"] = put@{
            npc.hitbox = null
-            DoubleValue.ONE
+            return@put DoubleValue.ONE
        }
-        functions["aspects"] = {
+        map["aspects"] = put@{
            val aspects = npc.aspects
-            aspects.asArrayValue { StringValue(it) }
+            return@put aspects.asArrayValue { StringValue(it) }
        }
-        functions["add_aspect"] = { params ->
+        map["add_aspect"] = put@{ params ->
            val aspects = params.params.map { it.asString() }
            npc.appliedAspects.addAll(aspects)
            npc.updateAspects()
-            DoubleValue.ONE
+            return@put DoubleValue.ONE
        }
-        functions["remove_aspect"] = { params ->
+        map["remove_aspect"] = put@{ params ->
            val aspects = params.params.map { it.asString() }
            npc.appliedAspects.removeAll(aspects.toSet())
            npc.updateAspects()
-            DoubleValue.ONE
+            return@put DoubleValue.ONE
        }
-        functions["party"] = party@{
+        map["party"] = put@{
-            val party = npc.party ?: return@party DoubleValue.ZERO
+            val party = npc.party ?: return@put DoubleValue.ZERO
-            party.asMoLangValue()
+            return@put party.asMoLangValue()
        }
-        functions["create_npc_party"] = {
+        map["create_npc_party"] = put@{
            val party = NPCPartyStore(npc)
-            party.asMoLangValue()
+            return@put party.asMoLangValue()
        }
-        functions["set_npc_party"] = { params ->
+        map["set_npc_party"] = { params ->
            val party = params.get<MoValue>(0)
            if (party is ObjectValue<*>) {
                npc.party = party.obj as NPCPartyStore
@@ -219,19 +213,18 @@ object NPCMoLangFunctions : AbstractMoLangFunctionHolder<NPCEntity>() {
            }
            DoubleValue.ONE
        }
-        functions["run_action_effect"] = runActionEffect@{ params ->
+        map["run_action_effect"] = put@{ params ->
            val runtime = MoLangRuntime().setup()
            runtime.environment.cloneFrom(params.environment)
            runtime.withNPCValue(value = npc)
            val actionEffect = ActionEffects.actionEffects[params.getString(0).asIdentifierDefaultingNamespace()]
            if (actionEffect != null) {
-                val context =
+                val context = ActionEffectContext(
-                    ActionEffectContext(
+                    actionEffect = actionEffect,
-                        actionEffect = actionEffect,
+                    providers = mutableListOf(NPCProvider(npc)),
-                        providers = mutableListOf(NPCProvider(npc)),
+                    runtime = runtime,
-                        runtime = runtime,
+                    level = npc.level()
-                        level = npc.level(),
+                )
                    )
                npc.actionEffect = context
                npc.brain.setMemory(CobblemonMemories.ACTIVE_ACTION_EFFECT, context)
                npc.brain.setActiveActivityIfPossible(CobblemonActivities.ACTION_EFFECT)
@@ -243,40 +236,37 @@ object NPCMoLangFunctions : AbstractMoLangFunctionHolder<NPCEntity>() {
                    }
                }
-                return@runActionEffect DoubleValue.ONE
+                return@put DoubleValue.ONE
            }
-            DoubleValue.ZERO
+            return@put DoubleValue.ZERO
        }
-        functions["put_pokemon_in_healer"] = putPokeInHealer@{ params ->
+        map["put_pokemon_in_healer"] = put@{ params ->
-            val healer =
+            val healer = npc.level()
-                npc
+                .getBlockEntity(params.get<ArrayStruct>(0).asBlockPos(), CobblemonBlockEntities.HEALING_MACHINE)
-                    .level()
+                .orElse(null) ?: return@put DoubleValue.ZERO
-                    .getBlockEntity(params.get<ArrayStruct>(0).asBlockPos(), CobblemonBlockEntities.HEALING_MACHINE)
+            val party = npc.party ?: return@put DoubleValue.ZERO
                    .orElse(null) ?: return@putPokeInHealer DoubleValue.ZERO
            val party = npc.party ?: return@putPokeInHealer DoubleValue.ZERO
            if (healer.canHeal(party)) {
                healer.activate(npc.uuid, party)
-                return@putPokeInHealer DoubleValue.ONE
+                return@put DoubleValue.ONE
            } else {
                return@put DoubleValue.ZERO
            }
            DoubleValue.ZERO
        }
-        functions["look_at_position"] = { params ->
+        map["look_at_position"] = { params ->
            val pos = Vec3(params.getDouble(0), params.getDouble(1), params.getDouble(2))
            npc.lookAt(EntityAnchorArgument.Anchor.EYES, pos)
        }
-        functions["environment"] = { npc.runtime.environment }
+        map["environment"] = { _ -> npc.runtime.environment }
-        functions["party"] = { npc.party?.struct ?: DoubleValue.ZERO }
+        map["party"] = { npc.party?.struct ?: DoubleValue.ZERO }
-        functions["has_party"] = { DoubleValue(npc.party != null) }
+        map["has_party"] = { DoubleValue(npc.party != null) }
-        functions["is_npc"] = { DoubleValue.ONE }
+        map["is_npc"] = { DoubleValue.ONE }
-        functions["can_battle"] = {
+        map["can_battle"] =
-            DoubleValue(npc.party?.any { it.currentHealth > 0 } == true || npc.npc.party?.isStatic == false)
+            { DoubleValue(npc.party?.any { it.currentHealth > 0 } == true || npc.npc.party?.isStatic == false) }
-        }
+        map["set_battle_theme"] = put@{ params ->
        functions["set_battle_theme"] = { params ->
            val soundId = params.getString(0).asResource()
            npc.npc.battleTheme = soundId
-            DoubleValue.ONE
+            return@put DoubleValue.ONE
        }
-
+        return map
        return functions
    }
 }
@@ -23,40 +23,40 @@ import com.cobblemon.mod.common.util.getBooleanOrNull
 object PCMoLangFunctions : AbstractMoLangFunctionHolder<PCStore>() {
    override fun PCStore.moLangFunctions(): MutableMap<String, (MoParams) -> Any> {
        val pc = this
-        val functions = hashMapOf<String, (MoParams) -> Any>()
+        val map = mutableMapOf<String, (MoParams) -> Any>()
-        functions["get_pokemon"] = getPokemon@{ params ->
+        map["get_pokemon"] = getPokemon@{ params ->
            val box = params.getInt(0)
            val slot = params.getInt(1)
            val pokemon = pc[PCPosition(box, slot)] ?: return@getPokemon DoubleValue.ZERO
-            pokemon.struct
+            return@getPokemon pokemon.struct
        }
-        functions["set_pokemon"] = { params ->
+        map["set_pokemon"] = { params ->
            val box = params.getInt(0)
            val slot = params.getInt(1)
            val pokemon = params.get<ObjectValue<Pokemon>>(2).obj
            pc[PCPosition(box, slot)] = pokemon
            DoubleValue.ONE
        }
-        functions["resize"] = { params ->
+        map["resize"] = { params ->
            val newSize = params.getInt(0)
            val lockNewSize = params.getBooleanOrNull(1) == true
            pc.resize(newSize, lockNewSize)
            DoubleValue.ONE
        }
-        functions["get_box_count"] = { DoubleValue(pc.boxes.size.toDouble()) }
+        map["get_box_count"] = { DoubleValue(pc.boxes.size.toDouble()) }
-        functions["has_unlocked_wallpaper"] = { params ->
+        map["has_unlocked_wallpaper"] = { params ->
            val wallpaper = params.getString(0).asIdentifierDefaultingNamespace()
            DoubleValue(pc.unlockedWallpapers.contains(wallpaper))
        }
-        functions["get_unlocked_wallpapers"] = { pc.unlockedWallpapers.asArrayValue { StringValue(it.toString()) } }
+        map["get_unlocked_wallpapers"] = { pc.unlockedWallpapers.asArrayValue { StringValue(it.toString()) } }
-        functions["unlock_wallpaper"] = unlockWallpaper@{
+        map["unlock_wallpaper"] = unlockWallpaper@{
            val wallpaper = it.getString(0).asIdentifierDefaultingNamespace()
            val playSound = it.getBooleanOrNull(1) != false
            CobblemonUnlockableWallpapers.unlockableWallpapers[wallpaper] ?: return@unlockWallpaper DoubleValue.ZERO
-            DoubleValue(pc.unlockWallpaper(wallpaper, playSound))
+            return@unlockWallpaper DoubleValue(pc.unlockWallpaper(wallpaper, playSound))
        }
-        return functions
+        return map
    }
 }
@@ -14,23 +14,21 @@ import com.cobblemon.mod.common.api.molang.ObjectValue
 import com.cobblemon.mod.common.api.storage.party.PartyStore
 import com.cobblemon.mod.common.pokemon.Pokemon
-object PartyMoLangFunctions : AbstractMoLangFunctionHolder<PartyStore>() {
+object PartyMoLangFunctions: AbstractMoLangFunctionHolder<PartyStore>() {
    override fun PartyStore.moLangFunctions(): MutableMap<String, (MoParams) -> Any> {
        val party = this
-        val functions = hashMapOf<String, (MoParams) -> Any>()
+        val map = hashMapOf<String, (MoParams) -> Any>()
-
+        map["get_pokemon"] = getPokemon@{ params ->
        functions["get_pokemon"] = getPokemon@{ params ->
            val index = params.getInt(0)
            val pokemon = party.get(index) ?: return@getPokemon DoubleValue.ZERO
            pokemon.struct
        }
-        functions["set_pokemon"] = { params ->
+        map["set_pokemon"] = { params ->
            val index = params.getInt(0)
            val pokemon = params.get<ObjectValue<Pokemon>>(1).obj
            party.set(index, pokemon)
            DoubleValue.ONE
        }
-
+        return map
        return functions
    }
 }
@@ -17,12 +17,12 @@ import com.bedrockk.molang.runtime.value.MoValue
 import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.CobblemonBlockEntities
 import com.cobblemon.mod.common.api.moves.Moves
 import com.cobblemon.mod.common.api.tms.TechnicalMachines
 import com.cobblemon.mod.common.api.dialogue.PlayerDialogueFaceProvider
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.api.molang.ObjectValue
 import com.cobblemon.mod.common.api.moves.Moves
 import com.cobblemon.mod.common.api.text.text
 import com.cobblemon.mod.common.api.tms.TechnicalMachines
 import com.cobblemon.mod.common.battles.BattleBuilder
 import com.cobblemon.mod.common.battles.BattleFormat
 import com.cobblemon.mod.common.entity.npc.NPCEntity
@@ -52,389 +52,355 @@ import net.minecraft.core.registries.Registries
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.sounds.SoundSource
 import net.minecraft.stats.Stats
 import net.minecraft.world.entity.player.Player
 import net.minecraft.world.item.ItemStack
 import net.minecraft.world.level.GameType
 import kotlin.collections.iterator
 object PlayerMoLangFunctions : AbstractMoLangFunctionHolder<Player>() {
    override fun Player.moLangFunctions(): MutableMap<String, (MoParams) -> Any> {
        val player = this
-        val functions = hashMapOf<String, (MoParams) -> Any>()
+        val map = mutableMapOf<String, (MoParams) -> Any>()
-
+        map["username"] = { _ -> StringValue(player.gameProfile.name) }
-        functions["username"] = { StringValue(player.gameProfile.name) }
+        map["uuid"] = { _ -> StringValue(player.gameProfile.id.toString()) }
-        functions["uuid"] = { StringValue(player.gameProfile.id.toString()) }
+        map["main_held_item"] = { _ -> player.mainHandItem.asMoLangValue(player.registryAccess()) }
-        functions["main_held_item"] = { player.mainHandItem.asMoLangValue(player.registryAccess()) }
+        map["off_held_item"] = { _ -> player.offhandItem.asMoLangValue(player.registryAccess()) }
-        functions["off_held_item"] = { player.offhandItem.asMoLangValue(player.registryAccess()) }
+        map["inventory"] = put@{ _ ->
        functions["inventory"] = {
            val inventory = player.inventory
            val items = ArrayStruct(hashMapOf())
            for (i in 0 until inventory.containerSize) {
                items.setDirectly("$i", inventory.getItem(i).asMoLangValue(player.registryAccess()))
            }
-            items
+            return@put items
        }
-        functions["has_inventory_space"] = {
+        map["has_inventory_space"] = put@{ _ ->
            val inventory = player.inventory
-            if (inventory.freeSlot != -1) DoubleValue.ONE else DoubleValue.ZERO
+            return@put if (inventory.getFreeSlot() != -1) DoubleValue.ONE else DoubleValue.ZERO
        }
-        functions["set_inventory_slot"] = setInvSlot@{ params ->
+        map["set_inventory_slot"] = put@{ params ->
            val slot = params.getInt(0)
            val inventory = player.inventory
-            if (slot !in 0 until inventory.containerSize) return@setInvSlot DoubleValue.ZERO
+            if (slot !in 0 until inventory.containerSize) return@put DoubleValue.ZERO
-            val value = params.getOrNull<MoValue>(1) ?: return@setInvSlot DoubleValue.ZERO
+            val value = params.getOrNull<MoValue>(1) ?: return@put DoubleValue.ZERO
-            val stack: ItemStack? =
+            val stack: ItemStack? = when (value) {
-                when (value) {
+                is ObjectValue<*> -> value.obj as? ItemStack
-                    is ObjectValue<*> -> {
+                is StringValue -> {
-                        value.obj as? ItemStack
+                    val id = ResourceLocation.parse(value.value)
-                    }
+                    val item = player.registryAccess().registryOrThrow(Registries.ITEM).get(id)
-
+                        ?: return@put DoubleValue.ZERO
-                    is StringValue -> {
+                    ItemStack(item)
                        val id = ResourceLocation.parse(value.value)
                        val item =
                            player.registryAccess().registryOrThrow(Registries.ITEM).get(id)
                                ?: return@setInvSlot DoubleValue.ZERO
                        ItemStack(item)
                    }
                    else -> {
                        null
                    }
                }
-            if (stack == null) return@setInvSlot DoubleValue.ZERO
+                else -> null
            }
            if (stack == null) return@put DoubleValue.ZERO
            inventory.setItem(slot, stack)
-            DoubleValue.ONE
+            return@put DoubleValue.ONE
        }
-        functions["give_item"] = giveItem@{ params ->
+        map["give_item"] = put@{ params ->
            val inventory = player.inventory
-            val freeSlot = inventory.freeSlot
+            val freeSlot = inventory.getFreeSlot()
-            val value = params.getOrNull<MoValue>(0) ?: return@giveItem DoubleValue.ZERO
+            val value = params.getOrNull<MoValue>(0) ?: return@put DoubleValue.ZERO
            val dropIfFull = params.getBooleanOrNull(1) ?: false
-            val stack: ItemStack? =
+            val stack: ItemStack? = when (value) {
-                when (value) {
+                is ObjectValue<*> -> value.obj as? ItemStack
-                    is ObjectValue<*> -> {
+                is StringValue -> {
-                        value.obj as? ItemStack
+                    val id = ResourceLocation.parse(value.value)
-                    }
+                    val item = player.registryAccess().registryOrThrow(Registries.ITEM).get(id)
-
+                        ?: return@put DoubleValue.ZERO
-                    is StringValue -> {
+                    ItemStack(item)
                        val id = ResourceLocation.parse(value.value)
                        val item =
                            player.registryAccess().registryOrThrow(Registries.ITEM).get(id)
                                ?: return@giveItem DoubleValue.ZERO
                        ItemStack(item)
                    }
                    else -> {
                        null
                    }
                }
-            if (stack == null) return@giveItem DoubleValue.ZERO
+                else -> null
            }
            if (stack == null) return@put DoubleValue.ZERO
            if (freeSlot == -1) {
                if (dropIfFull) {
                    player.drop(stack, false)
-                    return@giveItem DoubleValue.ONE
+                    return@put DoubleValue.ONE
                } else {
-                    return@giveItem DoubleValue.ZERO
+                    return@put DoubleValue.ZERO
                }
            }
            inventory.setItem(freeSlot, stack)
-            DoubleValue.ONE
+            return@put DoubleValue.ONE
        }
-        functions["face"] = { params ->
+        map["face"] = { params ->
            ObjectValue(
                PlayerDialogueFaceProvider(
                    player.uuid,
-                    params.getBooleanOrNull(0) != false,
+                    params.getBooleanOrNull(0) != false
-                ),
+                )
            )
        }
-        functions["swing_hand"] = { player.swing(player.usedItemHand) }
+        map["swing_hand"] = { _ -> player.swing(player.usedItemHand) }
-        functions["food_level"] = { DoubleValue(player.foodData.foodLevel) }
+        map["food_level"] = { _ -> DoubleValue(player.foodData.foodLevel) }
-        functions["saturation_level"] = { DoubleValue(player.foodData.saturationLevel) }
+        map["saturation_level"] = { _ -> DoubleValue(player.foodData.saturationLevel) }
-        functions["tell"] = { params ->
+        map["tell"] = { params ->
            val message = params.getString(0).text()
            val overlay = params.getBooleanOrNull(1) == true
            player.displayClientMessage(message, overlay)
        }
-        functions["teleport"] = { params ->
+        map["teleport"] = { params ->
            val x = params.getDouble(0)
            val y = params.getDouble(1)
            val z = params.getDouble(2)
-            val playParticleOptions = params.getBooleanOrNull(3) ?: false
+            val playParticleOptionss = params.getBooleanOrNull(3) ?: false
-            player.randomTeleport(x, y, z, playParticleOptions)
+            player.randomTeleport(x, y, z, playParticleOptionss)
        }
-        functions["heal"] = { params ->
+        map["heal"] = { params ->
            val amount = params.getDoubleOrNull(0) ?: player.maxHealth
            player.heal(amount.toFloat())
        }
-        functions["environment"] = {
+        map["environment"] = {
            val environment = MoLangEnvironment()
            environment.query = player.asMoLangValue()
            environment
        }
-        functions["is_player"] = { DoubleValue.ONE }
+        map["is_player"] = { DoubleValue.ONE }
-        functions["riding_pokemon"] = ridingPokemon@{
+        map["riding_pokemon"] = put@{
            val vehicle = player.vehicle
            if (vehicle is PokemonEntity) {
-                return@ridingPokemon vehicle.struct
+                return@put vehicle.struct
            } else {
                return@put DoubleValue.ZERO
            }
            DoubleValue.ZERO
        }
-
+        if (player is ServerPlayer) {
-        when (player) {
+            map["seen_credits"] = { _ ->
-            is ServerPlayer -> {
+                DoubleValue(player.seenCredits)
-                functions["seen_credits"] = { DoubleValue(player.seenCredits) }
+            }
-                functions["is_in_dialogue"] = { DoubleValue(player.isInDialogue) }
+            map["is_in_dialogue"] = { _ ->
-                functions["active_dialogue"] = activeDialogue@{
+                DoubleValue(player.isInDialogue)
-                    if (player.isInDialogue) {
+            }
-                        return@activeDialogue player.activeDialogue?.toMoLangStruct() ?: DoubleValue.ZERO
+            map["active_dialogue"] = put@{ _ ->
-                    }
+                if (player.isInDialogue) {
                    return@put player.activeDialogue?.toMoLangStruct() ?: DoubleValue.ZERO
                } else {
                    DoubleValue.ZERO
                }
-                functions["is_spectator"] = { DoubleValue(player.isSpectator) }
+            }
-                functions["is_creative"] = { DoubleValue(player.isCreative) }
+            map["is_spectator"] = { DoubleValue(player.isSpectator) }
-                functions["is_survival"] = { DoubleValue(player.gameMode.isSurvival) }
+            map["is_creative"] = { DoubleValue(player.isCreative) }
-                functions["is_adventure"] = { DoubleValue(player.gameMode.gameModeForPlayer == GameType.ADVENTURE) }
+            map["is_survival"] = { DoubleValue(player.gameMode.isSurvival) }
-                functions["run_command"] = { params ->
+            map["is_adventure"] = { DoubleValue(player.gameMode.gameModeForPlayer == GameType.ADVENTURE) }
-                    val command = params.getString(0)
+            map["run_command"] = { params ->
-                    player.server.commands.performPrefixedCommand(player.createCommandSourceStack(), command)
+                val command = params.getString(0)
-                }
+                player.server.commands.performPrefixedCommand(player.createCommandSourceStack(), command)
-                functions["set_battle_theme"] = { params ->
+            }
-                    val soundId = params.getString(0).asResource()
+            map["set_battle_theme"] = put@{ params ->
-                    Cobblemon.playerDataManager.getGenericData(player).battleTheme = soundId
+                val soundId = params.getString(0).asResource()
-                    DoubleValue.ONE
+                Cobblemon.playerDataManager.getGenericData(player).battleTheme = soundId
-                }
+                return@put DoubleValue.ONE
-                functions["battle_music"] = battleMusic@{ params ->
+            }
-                    val soundId = params.getString(0).asResource()
+            map["battle_music"] = put@{ params ->
-                    val volume = params.getDoubleOrNull(1)?.toFloat() ?: 1.0f
+                val soundId = params.getString(0).asResource()
-                    val pitch = params.getDoubleOrNull(2)?.toFloat() ?: 1.0f
+                val volume = params.getDoubleOrNull(1)?.toFloat() ?: 1.0f
-                    val restart = params.getBooleanOrNull(3) ?: true
+                val pitch = params.getDoubleOrNull(2)?.toFloat() ?: 1.0f
                val restart = params.getBooleanOrNull(3) ?: true
-                    if (soundId != null) {
+                if (soundId != null) {
-                        val packet = BattleMusicPacket(soundId, volume, pitch, restart)
+                    val packet = BattleMusicPacket(soundId, volume, pitch, restart)
                        packet.sendToPlayer(player)
                        return@battleMusic DoubleValue.ONE
                    }
                    DoubleValue.ZERO
                }
                functions["stop_battle_music"] = {
                    val packet = BattleMusicPacket(null)
                    packet.sendToPlayer(player)
-                    DoubleValue.ONE
+                    return@put DoubleValue.ONE
                } else {
                    return@put DoubleValue.ZERO
                }
-                functions["play_sound_on_server"] = { params ->
+            }
-                    val sound = params.getString(0).asResource()
+            map["stop_battle_music"] = put@{ _ ->
-                    val soundSource = SoundSource.valueOf(params.getString(1).uppercase())
+                val packet = BattleMusicPacket(null)
-                    val volume = params.getDoubleOrNull(2)?.toFloat() ?: 1.0f
+                packet.sendToPlayer(player)
-                    val pitch = params.getDoubleOrNull(3)?.toFloat() ?: 1.0f
+                return@put DoubleValue.ONE
            }
            map["play_sound_on_server"] = { params ->
                val sound = params.getString(0).asResource()
                val soundSource = SoundSource.valueOf(params.getString(1).uppercase())
                val volume = params.getDoubleOrNull(2)?.toFloat() ?: 1.0f
                val pitch = params.getDoubleOrNull(3)?.toFloat() ?: 1.0f
-                    val packet =
+                val packet =
-                        UnvalidatedPlaySoundS2CPacket(
+                    UnvalidatedPlaySoundS2CPacket(sound, soundSource, player.x, player.y, player.z, volume, pitch)
-                            sound,
+                packet.sendToPlayer(player)
-                            soundSource,
+            }
-                            player.x,
+            map["is_party_at_full_health"] = { _ ->
-                            player.y,
+                DoubleValue(player.party().none(Pokemon::canBeHealed))
-                            player.z,
+            }
-                            volume,
+            map["can_heal_at_healer"] = put@{ params ->
-                            pitch,
+                val pos = params.get<ArrayStruct>(0).asBlockPos()
-                        )
+                val healer = player.level().getBlockEntity(pos, CobblemonBlockEntities.HEALING_MACHINE).orElse(null)
-
+                    ?: return@put DoubleValue.ZERO
-                    packet.sendToPlayer(player)
+                val party = player.party()
                return@put DoubleValue(healer.canHeal(party))
            }
            map["put_pokemon_in_healer"] = put@{ params ->
                val healer = player.level()
                    .getBlockEntity(params.get<ArrayStruct>(0).asBlockPos(), CobblemonBlockEntities.HEALING_MACHINE)
                    .orElse(null) ?: return@put DoubleValue.ZERO
                val party = player.party()
                if (healer.canHeal(party)) {
                    healer.activate(player.uuid, party)
                    return@put DoubleValue.ONE
                } else {
                    return@put DoubleValue.ZERO
                }
-                functions["is_party_at_full_health"] = { DoubleValue(player.party().none(Pokemon::canBeHealed)) }
+            }
-                functions["can_heal_at_healer"] = canHealAtHealer@{ params ->
+            map["party"] = { player.party().struct }
-                    val pos = params.get<ArrayStruct>(0).asBlockPos()
+            map["pc"] = { player.pc().struct }
-                    val healer =
+            map["has_permission"] = { params ->
-                        player.level().getBlockEntity(pos, CobblemonBlockEntities.HEALING_MACHINE).orElse(null)
+                DoubleValue(
-                            ?: return@canHealAtHealer DoubleValue.ZERO
+                    Cobblemon.permissionValidator.hasPermission(
-                    val party = player.party()
+                        player,
-                    DoubleValue(healer.canHeal(party))
+                        params.getString(0),
-                }
+                        params.getIntOrNull(1) ?: 4
                functions["put_pokemon_in_healer"] = putPokemonAtHealer@{ params ->
                    val healer =
                        player
                            .level()
                            .getBlockEntity(
                                params.get<ArrayStruct>(0).asBlockPos(),
                                CobblemonBlockEntities.HEALING_MACHINE,
                            ).orElse(null) ?: return@putPokemonAtHealer DoubleValue.ZERO
                    val party = player.party()
                    if (healer.canHeal(party)) {
                        healer.activate(player.uuid, party)
                        return@putPokemonAtHealer DoubleValue.ONE
                    }
                    DoubleValue.ZERO
                }
                functions["party"] = { player.party().struct }
                functions["pc"] = { player.pc().struct }
                functions["has_permission"] = { params ->
                    DoubleValue(
                        Cobblemon.permissionValidator.hasPermission(
                            player,
                            params.getString(0),
                            params.getIntOrNull(1) ?: 4,
                        ),
                    )
-                }
+                )
-                functions["data"] = { params -> Cobblemon.molangData.load(player.uuid, params.getStringOrNull(0)) }
+            }
-                functions["save_data"] = { params -> Cobblemon.molangData.save(player.uuid, params.getStringOrNull(0)) }
+            map["data"] = { params -> Cobblemon.molangData.load(player.uuid, params.getStringOrNull(0)) }
-                functions["in_battle"] = { DoubleValue(player.isInBattle()) }
+            map["save_data"] = { params -> Cobblemon.molangData.save(player.uuid, params.getStringOrNull(0)) }
-                functions["battle"] = { player.getBattleState()?.first?.struct ?: DoubleValue.ZERO }
+            map["in_battle"] = { DoubleValue(player.isInBattle()) }
-                functions["get_npc_data"] = getNpcData@{ params ->
+            map["battle"] = { player.getBattleState()?.first?.struct ?: DoubleValue.ZERO }
-                    val npcId =
+            map["get_npc_data"] = put@{ params ->
-                        ((params.get<MoValue>(0) as? ObjectValue<*>)?.obj as? NPCEntity)?.stringUUID
+                val npcId = ((params.get<MoValue>(0) as? ObjectValue<*>)?.obj as? NPCEntity)?.stringUUID
-                            ?: params.getString(0)
+                    ?: params.getString(0)
-                    val data = Cobblemon.molangData.load(player.uuid, params.getStringOrNull(1))
+                val data = Cobblemon.molangData.load(player.uuid, params.getStringOrNull(1))
-                    if (data.map.containsKey(npcId)) {
+                if (data.map.containsKey(npcId)) {
-                        return@getNpcData data.map[npcId]!!
+                    return@put data.map[npcId]!!
-                    }
+                } else {
                    val vars = VariableStruct()
                    data.map[npcId] = vars
-                    vars
+                    return@put vars
                }
                functions["get_npc_variable"] = getNpcVariable@{ params ->
                    val npcId =
                        ((params.get<MoValue>(0) as? ObjectValue<*>)?.obj as? NPCEntity)?.stringUUID
                            ?: params.getString(0)
                    val variable = params.getString(1)
                    val data = Cobblemon.molangData.load(player.uuid, params.getStringOrNull(2))
                    if (data.map.containsKey(npcId)) {
                        return@getNpcVariable (data.map[npcId] as VariableStruct).map[variable] ?: DoubleValue.ZERO
                    }
                    DoubleValue.ZERO
                }
                functions["set_npc_variable"] = { params ->
                    val npcId =
                        ((params.get<MoValue>(0) as? ObjectValue<*>)?.obj as? NPCEntity)?.stringUUID
                            ?: params.getString(0)
                    val variable = params.getString(1)
                    val value = params.get<MoValue>(2)
                    val saveAfterwards = params.getBooleanOrNull(3) != false
                    val path = params.getStringOrNull(4)
                    val data = Cobblemon.molangData.load(player.uuid, path)
                    val npcData = data.map.getOrPut(npcId) { VariableStruct() } as VariableStruct
                    npcData.map[variable] = value
                    if (saveAfterwards) {
                        Cobblemon.molangData.save(player.uuid, path)
                    }
                    DoubleValue.ONE
                }
                functions["pokedex"] = { player.pokedex().struct }
                functions["has_advancement"] = hasAdvancement@{ params ->
                    val requiredAdvancement = ResourceLocation.parse(params.getString(0))
                    player.advancements.progress.forEach { (holder, progress) ->
                        if (holder.id == requiredAdvancement && progress.isDone) {
                            return@hasAdvancement DoubleValue.ONE
                        }
                    }
                    DoubleValue.ZERO
                }
                functions["has_tm_move_unlocked"] = hasTmMoveUnlocked@{ params ->
                    val move = Moves.getByName(params.getString(0)) ?: return@hasTmMoveUnlocked DoubleValue.ZERO
                    val tm = TechnicalMachines.moveToTM[move] ?: return@hasTmMoveUnlocked DoubleValue.ZERO
                    DoubleValue(if (player.tmList().learnedTMs.contains(tm.id)) 1.0 else 0.0)
                }
                functions["unlock_tm_move"] = unlockTmMove@{ params ->
                    val move = Moves.getByName(params.getString(0)) ?: return@unlockTmMove DoubleValue.ZERO
                    val tm = TechnicalMachines.moveToTM[move] ?: return@unlockTmMove DoubleValue.ZERO
                    player.tmList().syncTMFromMove(move)
                    DoubleValue(if (player.tmList().learnedTMs.contains(tm.id)) 1.0 else 0.0)
                }
                functions["lock_tm_move"] = lockTmMove@{ params ->
                    val move = Moves.getByName(params.getString(0)) ?: return@lockTmMove DoubleValue.ZERO
                    val tm = TechnicalMachines.moveToTM[move] ?: return@lockTmMove DoubleValue.ZERO
                    player.tmList().syncTMLockFromMove(move)
                    DoubleValue(if (player.tmList().learnedTMs.contains(tm.id)) 0.0 else 1.0)
                }
                functions["start_battle"] = startBattle@{ params ->
                    val opponentValue = params.get<MoValue>(0)
                    val opponent =
                        if (opponentValue is ObjectValue<*>) {
                            opponentValue.obj as ServerPlayer
                        } else {
                            val paramString = opponentValue.asString()
                            val playerUUID = paramString.asUUID
                            if (playerUUID != null) {
                                server()?.playerList?.getPlayer(playerUUID) ?: return@startBattle DoubleValue.ZERO
                            } else {
                                server()?.playerList?.getPlayerByName(paramString)
                                    ?: return@startBattle DoubleValue.ZERO
                            }
                        }
                    val format =
                        params
                            .getStringOrNull(1)
                            ?.let(BattleFormat::fromFormatIdentifier)
                            ?: BattleFormat.GEN_9_SINGLES
                    val setLevel = params.getIntOrNull(2) ?: -1
                    format.adjustLevel = setLevel
                    val rules =
                        params
                            .getStringOrNull(5)
                            ?.split(",")
                            ?.toSet()
                            ?: emptySet()
                    val modifiedBattleFormat =
                        BattleFormat.setBattleRules(
                            battleFormat = format,
                            rules = rules,
                        )
                    val cloneParties = (setLevel != -1) || (params.getBooleanOrNull(3) ?: false)
                    val healFirst = params.getBooleanOrNull(4) ?: false
                    val battleStartResult =
                        BattleBuilder.pvp1v1(
                            player1 = player,
                            player2 = opponent,
                            battleFormat = modifiedBattleFormat,
                            cloneParties = cloneParties,
                            healFirst = healFirst,
                        )
                    var returnValue: MoValue = DoubleValue.ZERO
                    battleStartResult.ifSuccessful { returnValue = it.struct }
                    returnValue
                }
                functions["get_custom_stat"] = getCustomStat@{ params ->
                    val statName = params.getString(0)
                    val resourceLocation = ResourceLocation.tryParse(statName) ?: return@getCustomStat DoubleValue.ZERO
                    val statResourceLocation =
                        BuiltInRegistries.CUSTOM_STAT.get(resourceLocation) ?: return@getCustomStat DoubleValue.ZERO
                    val exists = Stats.CUSTOM.contains(statResourceLocation)
                    if (!exists) return@getCustomStat DoubleValue.ZERO
                    val stat = Stats.CUSTOM.get(statResourceLocation)
                    val value = player.stats.getValue(stat)
                    DoubleValue(value)
                }
                functions["get_starter_uuid"] = {
                    Cobblemon.playerDataManager.getGenericData(player).starterUUID?.let {
                        StringValue(
                            it.toString(),
                        )
                    } ?: DoubleValue.ZERO
                }
                functions["has_chosen_starter"] = {
                    DoubleValue(Cobblemon.playerDataManager.getGenericData(player).starterSelected)
                }
            }
            map["get_npc_variable"] = put@{ params ->
                val npcId = ((params.get<MoValue>(0) as? ObjectValue<*>)?.obj as? NPCEntity)?.stringUUID
                    ?: params.getString(0)
                val variable = params.getString(1)
                val data = Cobblemon.molangData.load(player.uuid, params.getStringOrNull(2))
                if (data.map.containsKey(npcId)) {
                    return@put (data.map[npcId] as VariableStruct).map[variable] ?: DoubleValue.ZERO
                } else {
                    return@put DoubleValue.ZERO
                }
            }
            map["set_npc_variable"] = put@{ params ->
                val npcId = ((params.get<MoValue>(0) as? ObjectValue<*>)?.obj as? NPCEntity)?.stringUUID
                    ?: params.getString(0)
                val variable = params.getString(1)
                val value = params.get<MoValue>(2)
                val saveAfterwards = params.getBooleanOrNull(3) != false
                val path = params.getStringOrNull(4)
                val data = Cobblemon.molangData.load(player.uuid, path)
                val npcData = data.map.getOrPut(npcId) { VariableStruct() } as VariableStruct
                npcData.map[variable] = value
                if (saveAfterwards) {
                    Cobblemon.molangData.save(player.uuid, path)
                }
                return@put DoubleValue.ONE
            }
            map["pokedex"] = { player.pokedex().struct }
            map["has_advancement"] = put@{ params ->
                val requiredAdvancement = ResourceLocation.parse(params.getString(0))
                for (entry in player.advancements.progress) {
                    if (entry.key.id == requiredAdvancement && entry.value.isDone) {
                        return@put DoubleValue.ONE
                    }
                }
                return@put DoubleValue.ZERO
            }
            map["has_tm_move_unlocked"] = put@{ params ->
                val move = Moves.getByName(params.getString(0)) ?: return@put DoubleValue.ZERO
                val tm = TechnicalMachines.moveToTM[move] ?: return@put DoubleValue.ZERO
                DoubleValue(if (player.tmList().learnedTMs.contains(tm.id)) 1.0 else 0.0)
            }
            map["unlock_tm_move"] = put@{ params ->
                val move = Moves.getByName(params.getString(0)) ?: return@put DoubleValue.ZERO
                val tm = TechnicalMachines.moveToTM[move] ?: return@put DoubleValue.ZERO
                player.tmList().syncTMFromMove(move)
                DoubleValue(if (player.tmList().learnedTMs.contains(tm.id)) 1.0 else 0.0)
            }
            map["lock_tm_move"] = put@{ params ->
                val move = Moves.getByName(params.getString(0)) ?: return@put DoubleValue.ZERO
                val tm = TechnicalMachines.moveToTM[move] ?: return@put DoubleValue.ZERO
                player.tmList().syncTMLockFromMove(move)
                DoubleValue(if (player.tmList().learnedTMs.contains(tm.id)) 0.0 else 1.0)
            }
            map["start_battle"] = put@{ params ->
                val opponentValue = params.get<MoValue>(0)
                val opponent = if (opponentValue is ObjectValue<*>) {
                    opponentValue.obj as ServerPlayer
                } else {
                    val paramString = opponentValue.asString()
                    val playerUUID = paramString.asUUID
                    if (playerUUID != null) {
                        server()?.playerList?.getPlayer(playerUUID) ?: return@put DoubleValue.ZERO
                    } else {
                        server()?.playerList?.getPlayerByName(paramString) ?: return@put DoubleValue.ZERO
                    }
                }
                val format = params.getStringOrNull(1)
                    ?.let(BattleFormat::fromFormatIdentifier)
                    ?: BattleFormat.GEN_9_SINGLES
                val setLevel = params.getIntOrNull(2) ?: -1
                format.adjustLevel = setLevel
                val rules = params.getStringOrNull(5)
                    ?.split(",")
                    ?.toSet()
                    ?: emptySet()
                val modifiedBattleFormat = BattleFormat.setBattleRules(
                    battleFormat = format,
                    rules = rules
                )
                val cloneParties = (setLevel != -1) || (params.getBooleanOrNull(3) ?: false)
                val healFirst = params.getBooleanOrNull(4) ?: false
                val battleStartResult = BattleBuilder.pvp1v1(
                    player1 = player,
                    player2 = opponent,
                    battleFormat = modifiedBattleFormat,
                    cloneParties = cloneParties,
                    healFirst = healFirst
                )
                var returnValue: MoValue = DoubleValue.ZERO
                battleStartResult.ifSuccessful { returnValue = it.struct }
                return@put returnValue
            }
            map["get_custom_stat"] = put@{ params ->
                val statName = params.getString(0)
                val resourceLocation = ResourceLocation.tryParse(statName) ?: return@put DoubleValue.ZERO
                val statResourceLocation =
                    BuiltInRegistries.CUSTOM_STAT.get(resourceLocation) ?: return@put DoubleValue.ZERO
                val exists = net.minecraft.stats.Stats.CUSTOM.contains(statResourceLocation)
                if (!exists) return@put DoubleValue.ZERO
                val stat = net.minecraft.stats.Stats.CUSTOM.get(statResourceLocation)
                val value = player.stats.getValue(stat)
                DoubleValue(value)
            }
            map["get_starter_uuid"] = { _ ->
                Cobblemon.playerDataManager.getGenericData(player).starterUUID?.let {
                    StringValue(
                        it.toString()
                    )
                } ?: DoubleValue.ZERO
            }
            map["has_chosen_starter"] = { _ -> DoubleValue(Cobblemon.playerDataManager.getGenericData(player).starterSelected) }
        }
-        return functions
+        return map
    }
 }
@@ -27,69 +27,57 @@ import com.cobblemon.mod.common.util.getStringOrNull
 object PokedexMoLangFunctions : AbstractMoLangFunctionHolder<AbstractPokedexManager>() {
    override fun AbstractPokedexManager.moLangFunctions(): MutableMap<String, (MoParams) -> Any> {
        val pokedex = this
-        val functions = hashMapOf<String, (MoParams) -> Any>()
+        val map = mutableMapOf<String, (MoParams) -> Any>()
-
+        map["get_species_record"] = { params ->
        functions["get_species_record"] = { params ->
            val speciesId = params.getString(0).asIdentifierDefaultingNamespace()
            pokedex.speciesRecords[speciesId]?.struct ?: QueryStruct(hashMapOf())
        }
-        functions["has_seen"] = hasSeen@{ params ->
+        map["has_seen"] = put@{ params ->
            val speciesId = params.getString(0).asIdentifierDefaultingNamespace()
-            val formName =
+            val formName = params.getStringOrNull(1)
                params.getStringOrNull(1)
                    ?: return@hasSeen DoubleValue(
                        pokedex.getHighestKnowledgeForSpecies(speciesId).ordinal >= PokedexEntryProgress.SEEN.ordinal,
                    )
-            DoubleValue(
+            if (formName == null) {
-                (
+                return@put DoubleValue(pokedex.getHighestKnowledgeForSpecies(speciesId).ordinal >= PokedexEntryProgress.SEEN.ordinal)
-                    pokedex
+            } else {
-                        .getSpeciesRecord(speciesId)
+                return@put DoubleValue(
-                        ?.getFormRecord(formName)
+                    (pokedex.getSpeciesRecord(speciesId)?.getFormRecord(formName)?.knowledge?.ordinal
-                        ?.knowledge
+                        ?: 0) >= PokedexEntryProgress.SEEN.ordinal
                        ?.ordinal
                        ?: 0
                ) >= PokedexEntryProgress.SEEN.ordinal,
            )
        }
        functions["has_caught"] = hasCaught@{ params ->
            val speciesId = params.getString(0).asIdentifierDefaultingNamespace()
            val formName =
                params.getStringOrNull(1) ?: return@hasCaught DoubleValue(
                    pokedex.getHighestKnowledgeForSpecies(
                        speciesId,
                    ) == PokedexEntryProgress.OWNED,
                )
            DoubleValue(
                pokedex
                    .getSpeciesRecord(speciesId)
                    ?.getFormRecord(formName)
                    ?.knowledge == PokedexEntryProgress.OWNED,
            )
        }
        functions["caught_count"] = { DoubleValue(pokedex.getGlobalCalculatedValue(CaughtCount)) }
        functions["seen_count"] = { DoubleValue(pokedex.getGlobalCalculatedValue(SeenCount)) }
        functions["caught_percent"] = { DoubleValue(pokedex.getGlobalCalculatedValue(CaughtPercent)) }
        functions["seen_percent"] = { DoubleValue(pokedex.getGlobalCalculatedValue(SeenPercent)) }
        when (pokedex) {
            is PokedexManager -> {
                functions["player_id"] = { StringValue(pokedex.uuid.toString()) }
                functions["see"] = { params ->
                    val pokemon = params.get<ObjectValue<Pokemon>>(0).obj
                    pokedex.encounter(pokemon)
                    DoubleValue.ONE
                }
                functions["catch"] = { params ->
                    val pokemon = params.get<ObjectValue<Pokemon>>(0).obj
                    pokedex.obtain(pokemon)
                    DoubleValue.ONE
                }
            }
        }
-        return functions
+        map["has_caught"] = put@{ params ->
            val speciesId = params.getString(0).asIdentifierDefaultingNamespace()
            val formName = params.getStringOrNull(1)
            if (formName == null) {
                return@put DoubleValue(pokedex.getHighestKnowledgeForSpecies(speciesId) == PokedexEntryProgress.OWNED)
            } else {
                return@put DoubleValue(
                    pokedex.getSpeciesRecord(speciesId)
                        ?.getFormRecord(formName)?.knowledge == PokedexEntryProgress.OWNED
                )
            }
        }
        map["caught_count"] = { DoubleValue(pokedex.getGlobalCalculatedValue(CaughtCount)) }
        map["seen_count"] = { DoubleValue(pokedex.getGlobalCalculatedValue(SeenCount)) }
        map["caught_percent"] = { DoubleValue(pokedex.getGlobalCalculatedValue(CaughtPercent)) }
        map["seen_percent"] = { DoubleValue(pokedex.getGlobalCalculatedValue(SeenPercent)) }
        if (pokedex is PokedexManager) {
            map["player_id"] = { StringValue(pokedex.uuid.toString()) }
            map["see"] = put@{ params ->
                val pokemon = params.get<ObjectValue<Pokemon>>(0).obj
                pokedex.encounter(pokemon)
                return@put DoubleValue.ONE
            }
            map["catch"] = put@{ params ->
                val pokemon = params.get<ObjectValue<Pokemon>>(0).obj
                pokedex.obtain(pokemon)
                return@put DoubleValue.ONE
            }
        }
        return map
    }
 }
@@ -32,113 +32,100 @@ import com.cobblemon.mod.common.util.withQueryValue
 object PokemonEntityMoLangFunctions : AbstractMoLangFunctionHolder<PokemonEntity>() {
    override fun PokemonEntity.moLangFunctions(): MutableMap<String, (MoParams) -> Any> {
        val pokemonEntity = this
-        val functions = hashMapOf<String, (MoParams) -> Any>()
+        val map = mutableMapOf<String, (MoParams) -> Any>()
-
+        map["is_busy"] = { DoubleValue(pokemonEntity.isBusy) }
-        functions["is_busy"] = { DoubleValue(pokemonEntity.isBusy) }
+        map["in_battle"] = { DoubleValue(pokemonEntity.isBattling) }
-        functions["in_battle"] = { DoubleValue(pokemonEntity.isBattling) }
+        map["is_moving"] = { DoubleValue((pokemonEntity.moveControl as? PokemonMoveControl)?.hasWanted() == true) }
-        functions["is_moving"] =
+        map["is_flying"] = { DoubleValue(pokemonEntity.getBehaviourFlag(PokemonBehaviourFlag.FLYING)) }
-            { DoubleValue((pokemonEntity.moveControl as? PokemonMoveControl)?.hasWanted() == true) }
+        map["get_riding_state"] = { params ->
        functions["is_flying"] = { DoubleValue(pokemonEntity.getBehaviourFlag(PokemonBehaviourFlag.FLYING)) }
        functions["get_riding_state"] = { params ->
            val name = params.getStringOrNull(0)
            pokemonEntity.ifRidingAvailableSupply(DoubleValue.ZERO) { behaviour, settings, state ->
                val moValue = behaviour.asMoLangValue(settings, state, pokemonEntity)
                return@ifRidingAvailableSupply moValue.functions[name]?.apply(MoParams.EMPTY) as? MoValue ?: moValue
            }
        }
-        functions["is_gliding"] = {
+        map["is_gliding"] = {
            pokemonEntity.ifRidingAvailableSupply(DoubleValue.ZERO) { behaviour, settings, state ->
                val moValue = behaviour.asMoLangValue(settings, state, pokemonEntity)
                return@ifRidingAvailableSupply moValue.functions["gliding"]?.apply(MoParams.EMPTY) as? MoValue
                    ?: DoubleValue.ZERO
            }
        }
-        functions["is_sprinting"] = {
+        map["is_sprinting"] = {
            pokemonEntity.ifRidingAvailableSupply(DoubleValue.ZERO) { behaviour, settings, state ->
                val moValue = behaviour.asMoLangValue(settings, state, pokemonEntity)
                return@ifRidingAvailableSupply moValue.functions["sprinting"]?.apply(MoParams.EMPTY) as? MoValue
                    ?: DoubleValue.ZERO
            }
        }
-        functions["is_drifting"] = {
+        map["is_drifting"] = {
            pokemonEntity.ifRidingAvailableSupply(DoubleValue.ZERO) { behaviour, settings, state ->
                val moValue = behaviour.asMoLangValue(settings, state, pokemonEntity)
                return@ifRidingAvailableSupply moValue.functions["drifting"]?.apply(MoParams.EMPTY) as? MoValue
                    ?: DoubleValue.ZERO
            }
        }
-        functions["is_powered_drifting"] = {
+        map["is_powered_drifting"] = {
            pokemonEntity.ifRidingAvailableSupply(DoubleValue.ZERO) { behaviour, settings, state ->
                val moValue = behaviour.asMoLangValue(settings, state, pokemonEntity)
                return@ifRidingAvailableSupply moValue.functions["powered_drifting"]?.apply(MoParams.EMPTY) as? MoValue
                    ?: DoubleValue.ZERO
            }
        }
-        functions["in_air"] = {
+        map["in_air"] = {
            pokemonEntity.ifRidingAvailableSupply(DoubleValue.ZERO) { behaviour, settings, state ->
                val moValue = behaviour.asMoLangValue(settings, state, pokemonEntity)
                return@ifRidingAvailableSupply moValue.functions["in_air"]?.apply(MoParams.EMPTY) as? MoValue
                    ?: DoubleValue.ZERO
            }
        }
-        functions["is_wild"] = { DoubleValue(pokemonEntity.ownerUUID == null) }
+        map["is_wild"] = { DoubleValue(pokemonEntity.ownerUUID == null) }
-        functions["is_in_party"] = {
+        map["is_in_party"] = { DoubleValue(pokemonEntity.pokemon.storeCoordinates.get()?.store is PartyStore) }
-            DoubleValue(
+        map["is_ridden"] = { DoubleValue(pokemonEntity.hasControllingPassenger()) }
-                pokemonEntity.pokemon.storeCoordinates
+        map["has_aspect"] = { DoubleValue(it.getString(0) in pokemonEntity.aspects) }
-                    .get()
+        map["is_pokemon"] = { DoubleValue.ONE }
-                    ?.store is PartyStore,
+        map["is_holding_item"] = {
-            )
+            DoubleValue(!pokemonEntity.entityData.get(PokemonEntity.SHOWN_HELD_ITEM).let {
                it.isEmpty || it.`is`(CobblemonItemTags.WEARABLE_HAT_ITEMS) || it.`is`(CobblemonItemTags.WEARABLE_FACE_ITEMS)
            })
        }
-        functions["is_ridden"] = { DoubleValue(pokemonEntity.hasControllingPassenger()) }
+        map["riding_style"] = {
-        functions["has_aspect"] = { DoubleValue(it.getString(0) in pokemonEntity.aspects) }
+            StringValue(pokemonEntity.ifRidingAvailableSupply("") { behaviour, settings, state ->
-        functions["is_pokemon"] = { DoubleValue.ONE }
+                behaviour.getRidingStyle(settings, state).name
-        functions["is_holding_item"] = {
+            })
            DoubleValue(
                !pokemonEntity.entityData.get(PokemonEntity.SHOWN_HELD_ITEM).let {
                    it.isEmpty || it.`is`(CobblemonItemTags.WEARABLE_HAT_ITEMS) || it.`is`(CobblemonItemTags.WEARABLE_FACE_ITEMS)
                },
            )
        }
-        functions["riding_style"] = {
+        map["is_wearing_hat"] = {
            StringValue(
                pokemonEntity.ifRidingAvailableSupply("") { behaviour, settings, state ->
                    behaviour.getRidingStyle(settings, state).name
                },
            )
        }
        functions["is_wearing_hat"] = {
            DoubleValue(
                pokemonEntity.entityData
                    .get(PokemonEntity.SHOWN_HELD_ITEM)
-                    .`is`(CobblemonItemTags.WEARABLE_HAT_ITEMS),
+                    .`is`(CobblemonItemTags.WEARABLE_HAT_ITEMS)
            )
        }
-        functions["is_wearing_face"] = {
+        map["is_wearing_face"] = {
            DoubleValue(
                pokemonEntity.entityData
                    .get(PokemonEntity.SHOWN_HELD_ITEM)
-                    .`is`(CobblemonItemTags.WEARABLE_FACE_ITEMS),
+                    .`is`(CobblemonItemTags.WEARABLE_FACE_ITEMS)
            )
        }
-        functions["is_pastured"] = {
+        map["is_pastured"] = {
            DoubleValue((pokemonEntity.tethering != null))
        }
-        functions["pasture_conflict_enabled"] = {
+        map["pasture_conflict_enabled"] = {
            DoubleValue(pokemonEntity.getBehaviourFlag(PokemonBehaviourFlag.PASTURE_CONFLICT))
        }
-        functions["run_action_effect"] = runActionEffect@{ params ->
+        map["run_action_effect"] = runActionEffect@{ params ->
            val runtime = MoLangRuntime().setup()
            runtime.environment.cloneFrom(params.environment)
            runtime.withQueryValue("entity", pokemonEntity.struct)
            val actionEffect = ActionEffects.actionEffects[params.getString(0).asIdentifierDefaultingNamespace()]
            if (actionEffect != null) {
-                val context =
+                val context = ActionEffectContext(
-                    ActionEffectContext(
+                    actionEffect = actionEffect,
-                        actionEffect = actionEffect,
+                    providers = mutableListOf(TargetsProvider(pokemonEntity)),
-                        providers = mutableListOf(TargetsProvider(pokemonEntity)),
+                    runtime = runtime,
-                        runtime = runtime,
+                    level = pokemonEntity.level()
-                        level = pokemonEntity.level(),
+                )
                    )
                // This was taken from NPC run_action_effect but this variable isn't used, so I just commented it out.
                // pokemonEntity.actionEffect = context
                pokemonEntity.brain.setMemory(CobblemonMemories.ACTIVE_ACTION_EFFECT, context)
@@ -148,16 +135,14 @@ object PokemonEntityMoLangFunctions : AbstractMoLangFunctionHolder<PokemonEntity
                        pokemonEntity.brain.getMemory(CobblemonMemories.ACTIVE_ACTION_EFFECT).orElse(null)
                    if (pokemonActionEffect == context && pokemonEntity.brain.isActive(CobblemonActivities.ACTION_EFFECT)) {
                        pokemonEntity.brain.eraseMemory(CobblemonMemories.ACTIVE_ACTION_EFFECT)
-                        // pokemonEntity.actionEffect = null
+                        //pokemonEntity.actionEffect = null
                    }
                }
                return@runActionEffect DoubleValue.ONE
            }
-
+            return@runActionEffect DoubleValue.ZERO
            DoubleValue.ZERO
        }
-
+        return map
        return functions
    }
 }
@@ -33,214 +33,218 @@ import com.cobblemon.mod.common.util.getDoubleOrNull
 import com.cobblemon.mod.common.util.getIntOrNull
 import com.cobblemon.mod.common.util.server
 import com.cobblemon.mod.common.util.toProperties
 import net.minecraft.resources.ResourceLocation
 import kotlin.random.Random
 import net.minecraft.resources.ResourceLocation
 object PokemonMoLangFunctions : AbstractMoLangFunctionHolder<Pokemon>() {
    override fun Pokemon.moLangFunctions(): MutableMap<String, (MoParams) -> Any> {
        val pokemon = this
-        val functions = hashMapOf<String, (MoParams) -> Any>()
+        val map = mutableMapOf<String, (MoParams) -> Any>()
-
+        map["id"] = { StringValue(pokemon.uuid.toString()) }
-        functions["id"] = { StringValue(pokemon.uuid.toString()) }
+        map["nickname"] = { StringValue(pokemon.nickname.toString()) }
-        functions["nickname"] = { StringValue(pokemon.nickname.toString()) }
+        map["level"] = { DoubleValue(pokemon.level.toDouble()) }
-        functions["level"] = { DoubleValue(pokemon.level.toDouble()) }
+        map["max_hp"] = { DoubleValue(pokemon.maxHealth.toDouble()) }
-        functions["max_hp"] = { DoubleValue(pokemon.maxHealth.toDouble()) }
+        map["current_hp"] = { DoubleValue(pokemon.currentHealth.toDouble()) }
-        functions["current_hp"] = { DoubleValue(pokemon.currentHealth.toDouble()) }
+        map["friendship"] = { DoubleValue(pokemon.friendship.toDouble()) }
-        functions["friendship"] = { DoubleValue(pokemon.friendship.toDouble()) }
+        map["max_fullness"] = { DoubleValue(pokemon.getMaxFullness().toDouble()) }
-        functions["max_fullness"] = { DoubleValue(pokemon.getMaxFullness().toDouble()) }
+        map["fullness"] = { DoubleValue(pokemon.currentFullness.toDouble()) }
-        functions["fullness"] = { DoubleValue(pokemon.currentFullness.toDouble()) }
+        map["lose_fullness"] = { params ->
        functions["lose_fullness"] = { params ->
            val amount = params.getDouble(0)
            pokemon.loseFullness(amount.toInt())
        }
-        functions["feed_pokemon"] = { params ->
+        map["feed_pokemon"] = { params ->
            val amount = params.getDouble(0)
            val playSound = params.getBooleanOrNull(1) ?: true
            pokemon.feedPokemon(amount.toInt(), playSound)
        }
-        functions["behaviour"] = { pokemon.form.behaviour.struct }
+        map["behaviour"] = { pokemon.form.behaviour.struct }
-        functions["behavior"] = { pokemon.form.behaviour.struct } // Inferior
+        map["behavior"] = { pokemon.form.behaviour.struct } // Inferior
-        functions["pokeball"] = { StringValue(pokemon.caughtBall.toString()) }
+        map["pokeball"] = { StringValue(pokemon.caughtBall.toString()) }
-        functions["ability"] = { StringValue(pokemon.ability.name) }
+        map["ability"] = { StringValue(pokemon.ability.name) }
-        functions["has_learned"] = hasLearned@{ params ->
+        map["has_learned"] = put@{ params ->
            val moveName = params.getString(0)
            val move = pokemon.allAccessibleMoves.find { it.name == moveName }
-            if (move != null) return@hasLearned DoubleValue.ONE
+            if (move != null) {
-            DoubleValue.ZERO
+                return@put DoubleValue.ONE
            } else {
                return@put DoubleValue.ZERO
            }
        }
-        functions["moveset"] = {
+        map["moveset"] = {
            val struct = QueryStruct(hashMapOf())
            for ((index, move) in pokemon.moveSet.withIndex()) {
                struct.addFunction(index.toString()) { move.struct }
            }
            struct
        }
-        functions["evs"] = {
+        map["evs"] = {
            val struct = QueryStruct(hashMapOf())
            for (stat in Stats.PERMANENT) {
                struct.addFunction(stat.showdownId) { DoubleValue(pokemon.evs.getOrDefault(stat).toDouble()) }
            }
            struct
        }
-        functions["ivs"] = {
+        map["ivs"] = {
            val struct = QueryStruct(hashMapOf())
            for (stat in Stats.PERMANENT) {
                struct.addFunction(stat.showdownId) { DoubleValue(pokemon.ivs.getOrDefault(stat).toDouble()) }
            }
            struct
        }
-        functions["hyper_trained_ivs"] = {
+        map["hyper_trained_ivs"] = {
            val struct = QueryStruct(hashMapOf())
            for (stat in Stats.PERMANENT) {
                struct.addFunction(stat.showdownId) { DoubleValue(pokemon.ivs.hyperTrainedIVs[stat] ?: -1.0) }
            }
            struct
        }
-        functions["ride_boosts"] = {
+        map["ride_boosts"] = {
            val struct = QueryStruct(hashMapOf())
            for (stat in RidingStat.entries) {
                struct.addFunction(stat.name.lowercase()) { DoubleValue(pokemon.getRideBoost(stat)) }
            }
            struct
        }
-        functions["natdex_number"] = {
+        map["natdex_number"] = {
            DoubleValue(pokemon.species.nationalPokedexNumber.toDouble())
        }
-        functions["types"] = {
+        map["types"] = {
-            pokemon.form.types
+            pokemon.form.types.map { it.showdownId }.asArrayValue(::StringValue)
                .map { it.showdownId }
                .asArrayValue(::StringValue)
        }
-        functions["gender_ratio"] = {
+        map["gender_ratio"] = {
            DoubleValue(pokemon.form.maleRatio.toDouble())
        }
-        functions["ev_yield"] = {
+        map["ev_yield"] = {
            val struct = QueryStruct(hashMapOf())
            for (stat in Stats.PERMANENT) {
                struct.addFunction(stat.showdownId) { DoubleValue(pokemon.form.evYield[stat]?.toDouble()) }
            }
            struct
        }
-        functions["base_stats"] = {
+        map["base_stats"] = {
            val struct = QueryStruct(hashMapOf())
            for (stat in Stats.PERMANENT) {
                struct.addFunction(stat.showdownId) { DoubleValue(pokemon.form.baseStats[stat]?.toDouble()) }
            }
            struct
        }
-        functions["catch_rate"] = {
+        map["catch_rate"] = {
            DoubleValue(pokemon.form.catchRate.toDouble())
        }
-        functions["base_experience_yield"] = {
+        map["base_experience_yield"] = {
            DoubleValue(pokemon.form.baseExperienceYield.toDouble())
        }
-        functions["drops"] = {
+        map["drops"] = {
            val struct = QueryStruct(hashMapOf())
-            for ((index, drop) in pokemon.form.drops.entries
+            for ((index, drop) in pokemon.form.drops.entries.withIndex()) {
                .withIndex()) {
                struct.addFunction(index.toString()) { drop }
            }
            struct
        }
-        functions["tm_learnset"] = {
+        map["tm_learnset"] = {
            val struct = QueryStruct(hashMapOf())
-            for ((index, move) in pokemon.form.moves.tmMoves
+            for ((index, move) in pokemon.form.moves.tmMoves.withIndex()) {
                .withIndex()) {
                struct.addFunction(index.toString()) { move.struct }
            }
            struct
        }
-        functions["egg_learnset"] = {
+        map["egg_learnset"] = {
            val struct = QueryStruct(hashMapOf())
-            for ((index, move) in pokemon.form.moves.eggMoves
+            for ((index, move) in pokemon.form.moves.eggMoves.withIndex()) {
                .withIndex()) {
                struct.addFunction(index.toString()) { move.struct }
            }
            struct
        }
-        functions["tutor_learnset"] = {
+        map["tutor_learnset"] = {
            val struct = QueryStruct(hashMapOf())
-            for ((index, move) in pokemon.form.moves.tutorMoves
+            for ((index, move) in pokemon.form.moves.tutorMoves.withIndex()) {
                .withIndex()) {
                struct.addFunction(index.toString()) { move.struct }
            }
            struct
        }
-        functions["level_learnset"] = {
+        map["level_learnset"] = {
            val struct = QueryStruct(hashMapOf())
            for ((index, move) in pokemon.form.moves.levelUpMoves) {
                struct.addFunction(index.toString()) { move }
            }
            struct
        }
-        functions["ability_pool"] = {
+        map["ability_pool"] = {
            val struct = QueryStruct(hashMapOf())
            for ((index, ability) in pokemon.form.abilities.withIndex()) {
                struct.addFunction(index.toString()) { StringValue(ability.toString()) }
            }
            struct
        }
-        functions["egg_groups"] = {
+        map["egg_groups"] = {
            val struct = QueryStruct(hashMapOf())
            for ((index, group) in pokemon.form.eggGroups.withIndex()) {
                struct.addFunction(index.toString()) { StringValue(group.toString()) }
            }
            struct
        }
-        functions["egg_cycles"] = {
+        map["egg_cycles"] = {
            DoubleValue(pokemon.species.eggCycles.toDouble())
        }
-        functions["labels"] = {
+        map["labels"] = {
            val struct = QueryStruct(hashMapOf())
            for ((index, label) in pokemon.form.labels.withIndex()) {
                struct.addFunction(index.toString()) { StringValue(label) }
            }
            struct
        }
-        functions["aspects"] = {
+        map["aspects"] = {
            val aspects = pokemon.aspects
            aspects.asArrayValue { StringValue(it) }
        }
-        functions["form_aspects"] = {
+        map["form_aspects"] = {
            val aspects = pokemon.form.aspects
            aspects.asArrayValue { StringValue(it) }
        }
-        functions["form_name"] = {
+        map["form_name"] = {
            StringValue(pokemon.form.name)
        }
        // Yes, this is the lazy call for a single hardcoded pre-evolution.
        // Lol. Lmao, even.
        // TO-DO: Subscribe to [PokemonSpecies.observable].
-        functions["pre_evolution"] = { pokemon.species.preEvolution ?: DoubleValue.ZERO }
+        // Gito: surely this is just a typo, right? not touching the function name just in case
-        functions["nature"] = { StringValue(pokemon.nature.toString()) }
+        map["prevolution"] = preEvolution@{
-        functions["is_wild"] = { DoubleValue(pokemon.entity?.let { it.ownerUUID == null } == true) }
+            val preEvolution = pokemon.species.preEvolution ?: return@preEvolution DoubleValue.ZERO
-        functions["is_shiny"] = { DoubleValue(pokemon.shiny) }
+            return@preEvolution preEvolution
-        functions["is_in_party"] = { DoubleValue(pokemon.storeCoordinates.get()?.store is PartyStore) }
+        }
-        functions["species"] = { pokemon.species.struct }
+        map["nature"] = { StringValue(pokemon.nature.toString()) }
-        functions["form"] = { StringValue(pokemon.form.name) }
+        map["is_wild"] = { DoubleValue(pokemon.entity?.let { it.ownerUUID == null } == true) }
-        functions["weight"] = { DoubleValue(pokemon.species.weight.toDouble()) }
+        map["is_shiny"] = { DoubleValue(pokemon.shiny) }
-        functions["matches"] = { params -> DoubleValue(params.getString(0).toProperties().matches(pokemon)) }
+        map["is_in_party"] = { DoubleValue(pokemon.storeCoordinates.get()?.store is PartyStore) }
-        functions["apply"] = { params ->
+        map["species"] = { pokemon.species.struct }
        map["form"] = { StringValue(pokemon.form.name) }
        map["weight"] = { DoubleValue(pokemon.species.weight.toDouble()) }
        map["matches"] = { params -> DoubleValue(params.getString(0).toProperties().matches(pokemon)) }
        map["apply"] = { params ->
            params.getString(0).toProperties().apply(pokemon)
            DoubleValue.ONE
        }
-        functions["owner"] = { pokemon.getOwnerPlayer()?.asMoLangValue() ?: DoubleValue.ZERO }
+        map["owner"] = { pokemon.getOwnerPlayer()?.asMoLangValue() ?: DoubleValue.ZERO }
-        functions["held_item"] = { pokemon.heldItem().asMoLangValue(server()!!.registryAccess()) }
+        map["held_item"] = { pokemon.heldItem().asMoLangValue(server()!!.registryAccess()) }
-        functions["remove_held_item"] = { pokemon.removeHeldItem() }
+        map["remove_held_item"] = { _ ->
-        functions["add_aspects"] = { params ->
+            pokemon.removeHeldItem()
        }
        map["add_aspects"] = { params ->
            for (aspect in params.params) pokemon.forcedAspects += aspect.asString()
            pokemon.updateAspects()
        }
-        functions["remove_aspects"] = { params ->
+        map["remove_aspects"] = { params ->
            for (aspect in params.params) pokemon.forcedAspects -= aspect.asString()
            pokemon.updateAspects()
        }
-        functions["cosmetic_item"] = {
+        map["cosmetic_item"] = {
            pokemon.cosmeticItem().asMoLangValue(server()!!.registryAccess())
        }
-        functions["remove_cosmetic_item"] = { pokemon.removeCosmeticItem() }
+        map["remove_cosmetic_item"] = { _ ->
-        functions["marks"] = { pokemon.marks.asArrayValue { StringValue(it.identifier.toString()) } }
+            pokemon.removeCosmeticItem()
-        functions["has_mark"] = { params ->
+        }
        map["marks"] = { _ -> pokemon.marks.asArrayValue { StringValue(it.identifier.toString()) } }
        map["has_mark"] = { params ->
            var hasMark = false
            val identifier = params.getString(0).asIdentifierDefaultingNamespace()
            val mark = Marks.getByIdentifier(identifier)
@@ -250,7 +254,7 @@ object PokemonMoLangFunctions : AbstractMoLangFunctionHolder<Pokemon>() {
            DoubleValue(hasMark)
        }
-        functions["remove_marks"] = { params ->
+        map["remove_marks"] = { params ->
            var removedMark = false
            for (param in params.params) {
                val identifier = param.asString().asIdentifierDefaultingNamespace()
@@ -263,7 +267,7 @@ object PokemonMoLangFunctions : AbstractMoLangFunctionHolder<Pokemon>() {
            DoubleValue(removedMark)
        }
-        functions["add_marks"] = { params ->
+        map["add_marks"] = { params ->
            var appliedMark = false
            for (param in params.params) {
                val identifier = param.asString().asIdentifierDefaultingNamespace()
@@ -276,7 +280,7 @@ object PokemonMoLangFunctions : AbstractMoLangFunctionHolder<Pokemon>() {
            DoubleValue(appliedMark)
        }
-        functions["add_marks_with_chance"] = { params ->
+        map["add_marks_with_chance"] = { params ->
            var appliedMark = false
            for (param in params.params) {
                val identifier = param.asString().asIdentifierDefaultingNamespace()
@@ -294,15 +298,17 @@ object PokemonMoLangFunctions : AbstractMoLangFunctionHolder<Pokemon>() {
            DoubleValue(appliedMark)
        }
-        functions["add_potential_marks"] = { params ->
+        map["add_potential_marks"] = { params ->
            for (param in params.params) {
                val identifier = param.asString().asIdentifierDefaultingNamespace()
                val mark = Marks.getByIdentifier(identifier)
                if (mark != null) pokemon.addPotentialMark(mark)
            }
        }
-        functions["apply_potential_marks"] = { DoubleValue(pokemon.applyPotentialMarks()) }
+        map["apply_potential_marks"] = put@{
-        functions["hyper_train_iv"] = hyperTrainIv@{ params ->
+            return@put DoubleValue(pokemon.applyPotentialMarks())
        }
        map["hyper_train_iv"] = hyperTrainIv@{ params ->
            val statId = params.getString(0)
            val stat = Stats.getStat(statId)
            val value = params.getIntOrNull(1) ?: IVs.MAX_VALUE
@@ -315,12 +321,12 @@ object PokemonMoLangFunctions : AbstractMoLangFunctionHolder<Pokemon>() {
                return@hyperTrainIv DoubleValue.ZERO
            }
        }
-        functions["add_exp"] = { params ->
+        map["add_exp"] = { params ->
            val exp = params.getDouble(0).toInt()
            pokemon.addExperience(SidemodExperienceSource("molang"), exp)
            DoubleValue.ONE
        }
-        functions["set_iv"] = setIv@{ params ->
+        map["set_iv"] = setIv@{ params ->
            val statId = params.getString(0)
            val stat = Stats.getStat(statId)
            val value = params.getIntOrNull(1)?.coerceIn(0, IVs.MAX_VALUE) ?: IVs.MAX_VALUE
@@ -332,7 +338,7 @@ object PokemonMoLangFunctions : AbstractMoLangFunctionHolder<Pokemon>() {
                return@setIv DoubleValue.ZERO
            }
        }
-        functions["set_ev"] = setEv@{ params ->
+        map["set_ev"] = setEv@{ params ->
            val statId = params.getString(0)
            val stat = Stats.getStat(statId)
            val value = (params.getIntOrNull(1) ?: 0).coerceIn(0, 255)
@@ -344,54 +350,49 @@ object PokemonMoLangFunctions : AbstractMoLangFunctionHolder<Pokemon>() {
                return@setEv DoubleValue.ZERO
            }
        }
-        functions["set_ride_boost"] = setRideBoost@{ params ->
+        map["set_ride_boost"] = setRideBoost@{ params ->
            val statName = params.getString(0).uppercase()
-            val stat =
+            val stat = RidingStat.entries.find { it.name.equals(statName, ignoreCase = true) }
-                RidingStat.entries.find { it.name.equals(statName, ignoreCase = true) }
+                ?: return@setRideBoost DoubleValue.ZERO
                    ?: return@setRideBoost DoubleValue.ZERO
            val value = params.getDoubleOrNull(1)?.toFloat() ?: return@setRideBoost DoubleValue.ZERO
            pokemon.setRideBoost(stat, value)
-            DoubleValue.ONE
+            return@setRideBoost DoubleValue.ONE
        }
-        functions["add_ride_boost"] = addRideBoost@{ params ->
+        map["add_ride_boost"] = addRideBoost@{ params ->
            val statName = params.getString(0).uppercase()
-            val stat =
+            val stat = RidingStat.entries.find { it.name.equals(statName, ignoreCase = true) }
-                RidingStat.entries.find { it.name.equals(statName, ignoreCase = true) }
+                ?: return@addRideBoost DoubleValue.ZERO
                    ?: return@addRideBoost DoubleValue.ZERO
            val value = params.getDoubleOrNull(1)?.toFloat() ?: return@addRideBoost DoubleValue.ZERO
-            DoubleValue(if (pokemon.addRideBoost(stat, value)) 1.0 else 0.0)
+            return@addRideBoost DoubleValue(if (pokemon.addRideBoost(stat, value)) 1.0 else 0.0)
        }
-        functions["initialize_moveset"] = initializeMoveset@{ params ->
+        map["initialize_moveset"] = put@{ params ->
            val param = params.get<MoValue>(0) ?: StringValue(pokemon.form.defaultWildMovesetBuilder.toString())
            if (param is DoubleValue) {
                pokemon.initializeMoveset(param == DoubleValue.ONE)
            } else {
                val movesetBuilderId = ResourceLocation.parse(param.asString())
-                val movesetBuilder =
+                val movesetBuilder = CobblemonMovesetBuilders.movesetBuilders[movesetBuilderId]
-                    CobblemonMovesetBuilders.movesetBuilders[movesetBuilderId]
+                    ?: run {
-                        ?: run {
+                        Cobblemon.LOGGER.error("Tried initializing moveset from moveset builder ${param.asString()} but it does not exist.")
-                            Cobblemon.LOGGER.error(
+                        return@put DoubleValue.ZERO
-                                "Tried initializing moveset from moveset builder ${param.asString()} but it does not exist.",
+                    }
                            )
                            return@initializeMoveset DoubleValue.ZERO
                        }
                pokemon.initializeMovesetFrom(movesetBuilder)
            }
            DoubleValue.ONE
        }
-        functions["validate_moveset"] = { params ->
+        map["validate_moveset"] = { params ->
            val includeLegacy = params.getBooleanOrNull(0) ?: true
            pokemon.validateMoveset(includeLegacy)
            DoubleValue.ONE
        }
-        functions["teach_learnable_moves"] = { params ->
+        map["teach_learnable_moves"] = { params ->
            val includeLegacy = params.getBooleanOrNull(0) ?: true
            pokemon.teachLearnableMoves(includeLegacy)
            DoubleValue.ONE
        }
-        functions["teach_move"] = teachMove@{ params ->
+        map["teach_move"] = teachMove@{ params ->
            val moveName = params.getString(0)
            val moveTemplate = Moves.getByName(moveName) ?: return@teachMove DoubleValue.ZERO
            val bypass = params.getBooleanOrNull(1) ?: false
@@ -401,9 +402,8 @@ object PokemonMoLangFunctions : AbstractMoLangFunctionHolder<Pokemon>() {
                return@teachMove DoubleValue.ZERO
            }
-            val alreadyKnows =
+            val alreadyKnows = pokemon.moveSet.getMoves().any { it.template == moveTemplate } ||
-                pokemon.moveSet.getMoves().any { it.template == moveTemplate } ||
+                pokemon.benchedMoves.any { it.moveTemplate == moveTemplate }
                    pokemon.benchedMoves.any { it.moveTemplate == moveTemplate }
            if (alreadyKnows) {
                return@teachMove DoubleValue.ZERO
            }
@@ -416,43 +416,42 @@ object PokemonMoLangFunctions : AbstractMoLangFunctionHolder<Pokemon>() {
            DoubleValue.ONE
        }
-        functions["can_learn_move"] = canLearnMove@{ params ->
+        map["can_learn_move"] = canLearnMove@{ params ->
            val moveName = params.getString(0)
            val moveTemplate = Moves.getByName(moveName) ?: return@canLearnMove DoubleValue.ZERO
            val includeLegacy = params.getBooleanOrNull(1) ?: true
-            val canLearn =
+            val canLearn = if (includeLegacy) {
-                if (includeLegacy) {
+                LearnsetQuery.ANY.canLearn(moveTemplate, pokemon.form.moves)
-                    LearnsetQuery.ANY.canLearn(moveTemplate, pokemon.form.moves)
+            } else {
-                } else {
+                LearnsetQuery.LEGAL.canLearn(moveTemplate, pokemon.form.moves)
-                    LearnsetQuery.LEGAL.canLearn(moveTemplate, pokemon.form.moves)
+            }
-                }
+            return@canLearnMove DoubleValue(if (canLearn) 1.0 else 0.0)
            DoubleValue(if (canLearn) 1.0 else 0.0)
        }
-        functions["unlearn_move"] = unlearnMove@{ params ->
+        map["unlearn_move"] = unlearnMove@{ params ->
            val moveName = params.getString(0)
            val moveTemplate = Moves.getByName(moveName)
            if (moveTemplate != null) {
                pokemon.unlearnMove(moveTemplate)
                return@unlearnMove DoubleValue.ONE
            } else {
                return@unlearnMove DoubleValue.ZERO
            }
            DoubleValue.ZERO
        }
-        functions["can_evolve"] = { DoubleValue(pokemon.evolutions.any()) }
+        map["can_evolve"] = { _ ->
-        functions["force_evolve"] = forceEvolve@{ params ->
+            DoubleValue(pokemon.evolutions.any())
        }
        map["force_evolve"] = forceEvolve@{ params ->
            val idx = params.getInt(0)
-            val evolution =
+            val evolution = if (idx >= 0) pokemon.evolutions.elementAtOrNull(idx) else return@forceEvolve DoubleValue.ZERO
-                if (idx >= 0) pokemon.evolutions.elementAtOrNull(idx) else return@forceEvolve DoubleValue.ZERO
+            evolution?.forceEvolve(pokemon)
            evolution?.perform(pokemon)
            StringValue(evolution.toString())
        }
-        functions["entity"] = { pokemon.entity?.asMoLangValue() ?: DoubleValue.ZERO }
+        map["entity"] = { pokemon.entity?.asMoLangValue() ?: DoubleValue.ZERO }
-        functions["is_alpha"] = { DoubleValue(pokemon.isAlpha) }
+        map["is_alpha"] = { DoubleValue(pokemon.isAlpha) }
-        functions["size_category"] = { StringValue(pokemon.getSizeCategory().name) }
+        map["size_category"] = { _ -> StringValue(pokemon.getSizeCategory().name) }
-        return functions
+        return map
    }
 }
@@ -20,50 +20,52 @@ import com.cobblemon.mod.common.util.getStringOrNull
 object PokemonPropertiesMoLangFunctions : AbstractMoLangFunctionHolder<PokemonProperties>() {
    override fun PokemonProperties.moLangFunctions(): MutableMap<String, (MoParams) -> Any> {
        val props = this
-        val functions = hashMapOf<String, (MoParams) -> Any>()
+        val map = mutableMapOf<String, (MoParams) -> Any>()
-        functions["level"] = { DoubleValue(props.level?.toDouble() ?: 0) }
+        map["level"] = { DoubleValue(props.level?.toDouble() ?: 0) }
-        functions["set_level"] = { params ->
+        map["set_level"] = { params ->
            props.level = params.getIntOrNull(0)
            DoubleValue.ONE
        }
-        functions["shiny"] = { DoubleValue(props.shiny) }
+        map["shiny"] = { DoubleValue(props.shiny) }
-        functions["set_shiny"] = { params ->
+        map["set_shiny"] = { params ->
            props.shiny = params.getBooleanOrNull(0)
            DoubleValue.ONE
        }
-        functions["species"] = { props.species?.let { StringValue(it) } ?: DoubleValue.ZERO }
+        map["species"] = { props.species?.let { StringValue(it) } ?: DoubleValue.ZERO }
-        functions["set_species"] = { params ->
+        map["set_species"] = { params ->
            props.species = params.getStringOrNull(0)
            DoubleValue.ONE
        }
-        functions["gender"] = { props.gender?.let { StringValue(it.name) } ?: DoubleValue.ZERO }
+        map["gender"] = { props.gender?.let { StringValue(it.name) } ?: DoubleValue.ZERO }
-        functions["set_gender"] = { params ->
+        map["set_gender"] = { params ->
            props.gender = params.getStringOrNull(0)?.let { Gender.valueOf(it) }
            DoubleValue.ONE
        }
-        functions["form"] = { props.form?.let { StringValue(it) } ?: DoubleValue.ZERO }
+        map["form"] = { props.form?.let { StringValue(it) } ?: DoubleValue.ZERO }
-        functions["ivs"] = ivs@{
+        map["ivs"] = ivs@{
            val ivs = props.ivs ?: return@ivs DoubleValue.ZERO
-            ivs.struct
+            return@ivs ivs.struct
        }
-        functions["evs"] = evs@{
+        map["evs"] = evs@{
            val evs = props.evs ?: return@evs DoubleValue.ZERO
-            evs.struct
+            return@evs evs.struct
        }
-        functions["friendship"] = { DoubleValue(props.friendship?.toDouble() ?: DoubleValue.ZERO) }
+        map["friendship"] = { DoubleValue(props.friendship?.toDouble() ?: DoubleValue.ZERO) }
-        functions["set_friendship"] = { params ->
+        map["set_friendship"] = { params ->
            props.friendship = params.getIntOrNull(0)
            DoubleValue.ONE
        }
-        functions["create"] = { (props.create()).struct }
+        map["create"] = {
-        functions["to_string"] = { params ->
+            val pokemon = props.create()
            pokemon.struct
        }
        map["to_string"] = { params ->
            val separator = params.getStringOrNull(0) ?: " "
            StringValue(props.asString(separator = separator))
        }
-
+        return map
        return functions
    }
 }
@@ -22,84 +22,83 @@ import com.cobblemon.mod.common.util.asUUID
 import com.cobblemon.mod.common.util.getPlayer
 import com.cobblemon.mod.common.util.toProperties
-object PokemonStoreMoLangFunctions : AbstractMoLangFunctionHolder<PokemonStore<*>>() {
+object PokemonStoreMoLangFunctions: AbstractMoLangFunctionHolder<PokemonStore<*>>() {
    override fun PokemonStore<*>.moLangFunctions(): MutableMap<String, (MoParams) -> Any> {
        val store = this
-        val functions = hashMapOf<String, (MoParams) -> Any>()
+        val map = mutableMapOf<String, (MoParams) -> Any>()
-
+        map["uuid"] = { StringValue(store.uuid.toString()) }
-        functions["uuid"] = { StringValue(store.uuid.toString()) }
+        map["add"] = { params ->
        functions["add"] = { params ->
            val pokemon = params.get<ObjectValue<Pokemon>>(0)
            DoubleValue(store.add(pokemon.obj))
        }
-        functions["add_by_properties"] = { params ->
+        map["add_by_properties"] = { params ->
            val props = params.getString(0).toProperties()
-            val player =
+            val player = (store as? PlayerPartyStore)?.playerUUID?.getPlayer() // Only really know for sure when it's a player party store
                (store as? PlayerPartyStore)?.playerUUID?.getPlayer() // Only really know for sure when it's a player party store
            val pokemon = props.create(player = player)
            DoubleValue(store.add(pokemon))
        }
-        functions["find_by_properties"] = { params ->
+        map["find_by_properties"] = { params ->
            val props = params.getString(0).toProperties()
            val pokemon = store.find { props.matches(it) }
            pokemon?.asStruct() ?: DoubleValue.ZERO
        }
-        functions["find_all_by_properties"] = { params ->
+        map["find_all_by_properties"] = { params ->
            val props = params.getString(0).toProperties()
            val pokemon = store.filter { props.matches(it) }
            ArrayStruct(pokemon.mapIndexed { index, value -> "$index" to value.asStruct() }.toMap())
        }
-        functions["find_by_id"] = { params ->
+        map["find_by_id"] = { params ->
            val id = params.getString(0).asUUID
            val pokemon = store.find { it.uuid == id }
            pokemon?.asStruct() ?: DoubleValue.ZERO
        }
-        functions["remove_by_id"] = removeById@{ params ->
+        map["remove_by_id"] = removeById@{ params ->
            val id = params.getString(0).asUUID
            val pokemon = store.find { it.uuid == id } ?: return@removeById DoubleValue.ZERO
-            DoubleValue(store.remove(pokemon))
+            return@removeById DoubleValue(store.remove(pokemon))
        }
-        functions["average_level"] = averageLevel@{
+        map["average_level"] = averageLevel@{ _ ->
            var numberOfPokemon = 0
            var totalLevel = 0
            for (pokemon in store) {
                totalLevel += pokemon.level
                numberOfPokemon++
            }
-
+            if (numberOfPokemon == 0) {
-            if (numberOfPokemon == 0) return@averageLevel DoubleValue.ZERO
+                return@averageLevel DoubleValue.ZERO
-
+            }
-            DoubleValue(totalLevel.toDouble() / numberOfPokemon)
+            return@averageLevel DoubleValue(totalLevel.toDouble() / numberOfPokemon)
        }
-        functions["count"] = { DoubleValue(store.count()) }
+        map["count"] = { _ -> DoubleValue(store.count()) }
-        functions["count_by_properties"] = { params ->
+        map["count_by_properties"] = { params ->
            val props = params.getString(0).toProperties()
            DoubleValue(store.count { props.matches(it) })
        }
-        functions["highest_level"] = {
+        map["highest_level"] = {
            val highest = store.maxOfOrNull { it.level } ?: 0
            DoubleValue(highest)
        }
-        functions["lowest_level"] = {
+        map["lowest_level"] = {
            val lowest = store.minOfOrNull { it.level } ?: 0
            DoubleValue(lowest)
        }
-        functions["heal"] = {
+        map["heal"] = {
            for (pokemon in store) {
                pokemon.heal()
            }
            DoubleValue.ONE
        }
-        functions["healing_remainder_percent"] = {
+        map["healing_remainder_percent"] = { _ ->
            var totalPercent = 0.0f
            for (pokemon in store) {
                totalPercent += (1.0f - (pokemon.currentHealth.toFloat() / pokemon.maxHealth))
            }
            DoubleValue(totalPercent)
        }
-        functions["has_usable_pokemon"] = { DoubleValue(store.any { !it.isFainted() }) }
+        map["has_usable_pokemon"] = { _ -> DoubleValue(store.any { !it.isFainted() }) }
-        functions["pokemon"] = { store.map { it.asStruct() }.asArrayValue() }
+        map["pokemon"] = {
-
+            store.map { it.asStruct() }.asArrayValue()
-        return functions
+        }
        return map
    }
 }
@@ -25,63 +25,62 @@ import java.util.*
 object ServerMoLangFunctions : AbstractMoLangFunctionHolder<MinecraftServer>() {
    override fun MinecraftServer.moLangFunctions(): MutableMap<String, (MoParams) -> Any> {
        val server = this
-        val functions = hashMapOf<String, (MoParams) -> Any>()
+        val map = mutableMapOf<String, (MoParams) -> Any>()
-        functions["get_world"] = getWorld@{ params ->
+        map["get_world"] = getWorld@{ params ->
-            val world =
+            val world = server.getLevel(
-                server.getLevel(
+                ResourceKey.create(
-                    ResourceKey.create(
+                    Registries.DIMENSION,
-                        Registries.DIMENSION,
+                    params.getString(0).asIdentifierDefaultingNamespace(namespace = "minecraft")
-                        params.getString(0).asIdentifierDefaultingNamespace(namespace = "minecraft"),
+                )
-                    ),
+            ) ?: return@getWorld DoubleValue.ZERO
                ) ?: return@getWorld DoubleValue.ZERO
-            world
+            return@getWorld world
                .registryAccess()
                .registryOrThrow(Registries.DIMENSION)
                .wrapAsHolder(world)
                .asWorldMoLangValue()
        }
-        functions["broadcast"] = { params ->
+        map["broadcast"] = { params ->
            val message = params.getString(0)
            server.playerList.broadcastSystemMessage(message.text(), params.getBooleanOrNull(1) == true)
            DoubleValue.ONE
        }
-        functions["get_player_by_uuid"] = getPlayerByUuid@{ params ->
+        map["get_player_by_uuid"] = getPlayerByUuid@{ params ->
            val uuid = UUID.fromString(params.getString(0))
            val player = server.playerList.getPlayer(uuid) ?: return@getPlayerByUuid DoubleValue.ZERO
-            player.asMoLangValue()
+            return@getPlayerByUuid player.asMoLangValue()
        }
-        functions["get_player_by_username"] = getPlayerByUsername@{ params ->
+        map["get_player_by_username"] = getPlayerByUsername@{ params ->
            val username = params.getString(0)
            val player = server.playerList.getPlayerByName(username) ?: return@getPlayerByUsername DoubleValue.ZERO
-            player.asMoLangValue()
+            return@getPlayerByUsername player.asMoLangValue()
        }
-        functions["data"] = { params ->
+        map["data"] = { params ->
            Cobblemon.molangData.load(
                UUID(0L, 0L),
-                params.getStringOrNull(0),
+                params.getStringOrNull(0)
            )
        }
-        functions["save_data"] = { params ->
+        map["save_data"] = { params ->
            Cobblemon.molangData.save(
                UUID(0L, 0L),
-                params.getStringOrNull(index = 0),
+                params.getStringOrNull(index = 0)
            )
            DoubleValue.ONE
        }
        // Maybe later...
-//            functions.put("stop") { params ->
+//            map.put("stop") { params ->
 //                Cobblemon.LOGGER.warn("Server is being stopped from a MoLang script.")
 //                server.stopServer()
 //            }
-        return functions
+        return map
    }
 }
Author	SHA1	Message	Date
Gertimoshka	844c03bbbe	Fixes to mistypes and wrong tms getting in (looking at you terablast)	2026-08-13 23:01:40 +03:00
Gertimoshka	426e83546c	Changes for Default TMs By Slippy	2026-08-13 21:59:22 +03:00