Remove test logging

# Conflicts:
#	common/src/main/kotlin/com/cobblemon/mod/common/client/pokedex/PokedexScannerRenderer.kt
#	common/src/main/kotlin/com/cobblemon/mod/common/pokedex/scanner/PokedexUsageContext.kt

.gitignore

@@ -24,7 +24,6 @@ eclipse
 run
 runClient
 runServer
-utilityscripts/implementation/*.txt
 
 # Files from Forge MDK
 forge*changelog.txt

.gitlab-ci.yml

@@ -16,7 +16,6 @@ check_assets_cache:
   stage: preprocessing
   script:
     - echo "Checking if cached hash matches current hash"
-    - yum install -y findutils
 
     # Calculate the current hash
     - find common/src/main/resources/assets common/src/main/resources/data -type f -exec sha256sum {} + | sort -k 2 | sha256sum > current_hash.txt
@@ -72,8 +71,8 @@ setup_packsquash:
     - echo "Installing wget & unzip"
     - yum install -y wget unzip
     - echo "Downloading PackSquash"
-    - wget https://github.com/ComunidadAylas/PackSquash/releases/download/v0.4.1/packsquash-x86_64-unknown-linux-musl.zip
-    - unzip packsquash-x86_64-unknown-linux-musl.zip -d ./packsquash_bin
+    - wget https://github.com/ComunidadAylas/PackSquash/releases/download/v0.4.0/PackSquash.CLI.executable.x86_64-unknown-linux-musl.zip
+    - unzip PackSquash.CLI.executable.x86_64-unknown-linux-musl.zip -d ./packsquash_bin
     - echo "Creating PackSquash options.toml"
     - |
       cat <<EOF > ./options.toml
@@ -149,7 +148,6 @@ build:
   dependencies:
     - replace_resources
   script:
-    - yum install -y findutils
     - export GRADLE_OPTS="-Xmx4G -Xms4G"
     - chmod +x ./gradlew
     - ./gradlew build
@@ -165,7 +163,6 @@ publish:
   rules:
     - if: '$CI_PROJECT_PATH == "cable-mc/cobblemon" && $CI_COMMIT_BRANCH == "main"'
   script:
-    - yum install -y findutils
     - export GRADLE_OPTS="-Xmx4G -Xms4G"
     - chmod +x ./gradlew
     - ./gradlew publish
@@ -179,7 +176,6 @@ deploy_artifacts:
   dependencies:
     - build
   script:
-    - yum install -y findutils
     - echo "Collecting artifacts..."
     - find neoforge/build/libs/ -type f -name "*.jar" | grep -vE "dev-shadow|sources|javadoc" | xargs -I {} mv {} ./
     - find fabric/build/libs/ -type f -name "*.jar" | grep -vE "dev-shadow|sources|javadoc" | xargs -I {} mv {} ./

CHANGELOG.md

@@ -1,225 +1,136 @@
 # Changelog
-## [1.8.0 - Make Your Move Update (September 6th, 2026)](#1-8-0)
-#### I think the red eyes mean they're friendly!
+## [1.8.0 (MONTH Xth, 2026)](#1-8-0)
 
 ### 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 trades for Saccharine Saplings, Hearty Grains, Chipped Pot, and Masterpiece Teacup to the Wandering Trader.
+- Added brewing recipe for Throat Spray.
+- Added Berry Tree scanning for Pokedex
+- Added Datapackable Pokedex Scanning for Block Entities
+- 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` stat for captured Alpha Pokémon.
+- 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 mons (+-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`.
+- A new Biome tag called `#cobblemon:is_stony_beach` has been added.
+- Gimmighoul towers now generate at ground level rather than sinking one block into the ground.
+- 1 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
 
 ### New rideable Pokémon
-- Crobat
-- Skarmory
-- Milotic
-- Archeops
-- Goodra 
-- Goodra (Hisuian Form)
 - Drampa
-- Duraludon
-- Archaludon
+- Archeops
 
 ### Pokémon Added
-#### Generation 3
+- Pancham (+ Cosmetic with Black Glasses)
+- Pangoro (+ Cosmetic with Black Glasses)
+- Skitty
+- Delcatty
 - 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)
+- Sandshrew (Alolan)
+- Sandslash (Alolan)
+- Seviper
+- Zangoose
+- Stunky
+- Skuntank
+- Pawniard
+- Bisharp
+- Kingambit
 
 ### Model updates for the following Pokémon
-
-- Sandshrew
-- Sandslash
-- Nidoking
-- Zubat
-- Golbat
-- Crobat
-- Ditto
+- Goomy
+- Sliggoo
+- Goodra
 - Porygon
 - Porygon2
 - Porygon-Z
-- Skarmory
-- Smoochum
-- Jynx
-- Popplio
-- Brionne
-- Primarina
-- Fletchling
-- Fletchinder
-- Talonflame
+- Zubat
+- Golbat
+- Crobat
+- Pidgey
+- Pidgeotto
+- Pidgeot
+- Sandslash
+- Nidoking
 - Sableye
 - Mawile
-- Goomy
-- Sliggoo
-- Goodra
 - Nacli
-- Naclstack
+- Naclestack
 - 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
+- Skarmory
 
 ### 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
+- Drampa
+- Archeops
 - Skarmory
-- Skitty
-- Flygon
-- Shellos
 - Riolu
 - Lucario
+- Shellos
+- Skitty
+- Joltik
 - 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
+- Flygon
 
 #### Added sounds to the following moves
-
 - Absorb
 - Aurora Beam
 - Double Team
-- Draco Meteor
 - Fire Punch
 - Fire Spin
 - Flame Charge
@@ -239,27 +150,10 @@
 - 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.)
+- Dragonite's mailbag cosmetic can now also be obtained with a chest in the cosmetic slot
+- Sharp Beak can now be crafted
+- Metal Alloy can now be crafted
+- Ability Capsules can now be brewed
 - The following items can now be obtained by brushing the following Pokémon:
   - Pink Wool - Wigglytuff
   - White Wool - Swablu, Altaria
@@ -268,262 +162,90 @@
 - 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
+- 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
 
 ### 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 Croagunk's walkspeed
+- 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
+- Fixed Pokédex layout for genderless variations
+- Fixed odd stacking behaviour with the poke_bait item.
 - 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 an issue where particle like beam can disappear when you don't see the beginning of the beam, or you look away
+- Fixed an occasional crash on retrieving revived fossils
+- Fixed brushing not working on Neoforge
+- Fixed braking not working for submarines (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 submarine's surface-water animations not playing when supposed to.
+- Fixed submarine camera freaking out when looking up or down on the surface.
+- Fixed pastured mons despawning and running away.
+- Fixed Apricorn trees crashing when other mods bonemeal it
+- Fixed the issue that caused Hover Behaviour rides without a ground style to be rendered useless upon touching the ground on a server.
+- Removed the "inAir" penalty for block destruction speed when on a hover mount.
+- Fixed horizontal and vertical collisions with hover mounts so they no longer accumulate or retain momentum
+- Fixed NeoForge brewing stand unexpectedly crashing users when shift clicking items within its menu
+- 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
+- Fixed Ancient Pokéball's to their respective modifiers
+- Fixed a Server warning when recalling Pokémon
+- 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 a very niche issue where structures would spawn in an incorrect location, creating very funky world gen.
+- 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.
-- 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.
+- Traded Pokémon will now retain the original friendship level when traded back to its OT
 
 ### 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.
+- 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 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 `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 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 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.
+- 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

common/build.gradle.kts

@@ -72,10 +72,6 @@ tasks.withType<Test> {
     }
 }
 
-tasks.processResources {
-    exclude("data/**/README.md")
-}
-
 sourceSets {
     main {
         blossom {

common/src/main/java/com/cobblemon/mod/common/duck/MinecraftServerDuck.java

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

common/src/main/java/com/cobblemon/mod/common/duck/ServerLevelDuck.java

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

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

@@ -6,7 +6,7 @@
  * file, You can obtain one at https://mozilla.org/MPL/2.0/.
  */
 
-package com.cobblemon.mod.common.mixin.client;
+package com.cobblemon.mod.common.mixin;
 
 import com.cobblemon.mod.common.duck.ChannelDuck;
 import com.mojang.blaze3d.audio.Channel;

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

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

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

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

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

@@ -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) {
@@ -138,4 +139,23 @@ public abstract class ServerEntityMixin {
             CobblemonNetwork.INSTANCE.sendPacketToPlayer(player, packet);
         }
     }
+
+    @Inject(method = "sendPairingData", at = @At("TAIL"))
+    private void cobblemon$sendPairingSeatAssignments(
+            ServerPlayer player,
+            Consumer<Packet<ClientGamePacketListener>> consumer,
+            CallbackInfo ci
+    ) {
+        if (!(entity instanceof PokemonEntity pokemon)) return;
+        if (pokemon.getOccupiedSeats().isEmpty()) return;
+
+        pokemon.getOccupiedSeats().forEach((seat, passenger) -> {
+            if (seat.getLocator() == null) return;
+            CobblemonNetwork.INSTANCE.sendPacketToPlayer(
+                    player,
+                    new ClientboundSeatAssignmentPacket(passenger.getId(), pokemon.getId(), seat.getLocator())
+            );
+        });
+    }
+
 }

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

@@ -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 {
-
-    // 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;
-    }
+public abstract class ServerLevelMixin {
 
     @Inject(method = "findLightningRod", at = @At(value = "RETURN"), cancellable = true)
     private void cobblemon$findLightningRod(BlockPos blockPos, CallbackInfoReturnable<Optional<BlockPos>> ci) {

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

@@ -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()) {
-            getPlayerSpawner().tick();
+        if (!Cobblemon.config.getEnableSpawning()) {
+            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()
-                );
-    }
 }

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

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

common/src/main/java/com/cobblemon/mod/common/mixin/accessor/SinglePoolElementAccessor.java

@@ -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.mixin.accessor;
-
-import net.minecraft.core.Holder;
-import net.minecraft.world.level.levelgen.structure.pools.SinglePoolElement;
-import net.minecraft.world.level.levelgen.structure.templatesystem.StructureProcessorList;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.gen.Accessor;
-
-@Mixin(SinglePoolElement.class)
-public interface SinglePoolElementAccessor {
-    @Accessor("processors")
-    Holder<StructureProcessorList> getProcessors();
-}
-

common/src/main/java/com/cobblemon/mod/common/mixin/invoker/AdornRegisterInvoker.java

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

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

@@ -93,6 +93,8 @@ import com.cobblemon.mod.common.events.StatHandler
 import com.cobblemon.mod.common.net.messages.client.settings.ServerSettingsPacket
 import com.cobblemon.mod.common.permission.LaxPermissionValidator
 import com.cobblemon.mod.common.platform.events.PlatformEvents
+import com.cobblemon.mod.common.api.pokedex.scan.BlockScanProviderRegistry
+import com.cobblemon.mod.common.pokedex.scanner.block.BerryBlockScanProvider
 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
@@ -108,7 +110,6 @@ import com.cobblemon.mod.common.pokemon.helditem.CobblemonHeldItemManager
 import com.cobblemon.mod.common.pokemon.properties.AspectPropertyType
 import com.cobblemon.mod.common.pokemon.properties.BattleCloneProperty
 import com.cobblemon.mod.common.pokemon.properties.FreezeFrameProperty
-import com.cobblemon.mod.common.pokemon.properties.HeldItemVisibleProperty
 import com.cobblemon.mod.common.pokemon.properties.HiddenAbilityPropertyType
 import com.cobblemon.mod.common.pokemon.properties.LabelProperty
 import com.cobblemon.mod.common.pokemon.properties.NoAIProperty
@@ -309,9 +310,7 @@ object Cobblemon {
             this.config.maxPokemonLevel,
             this.config.maxPokemonFriendship,
             this.config.maxDynamaxLevel,
-            this.config.unlockAllMoveDexMovesByDefault,
-            this.config.pokemonIntrinsicSizeMin,
-            this.config.pokemonIntrinsicSizeMax
+            this.config.unlockAllMoveDexMovesByDefault
         ).sendToPlayer(player)
     }
 
@@ -351,10 +350,11 @@ object Cobblemon {
         CustomPokemonProperty.register(UnaspectPropertyType)
         CustomPokemonProperty.register(FreezeFrameProperty)
         CustomPokemonProperty.register(NoAIProperty)
-        CustomPokemonProperty.register(HeldItemVisibleProperty)
 
         CobblemonEvents.POKEMON_PROPERTY_INITIALISED.emit(Unit)
 
+        BlockScanProviderRegistry.register(cobblemonResource("berry"), BerryBlockScanProvider)
+
         CallbackHandler.setup()
         EntityCallbackHandler.setup()
 

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

@@ -255,31 +255,31 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     val POKE_SNACK = this.create("poke_snack", PokeSnackBlock(BlockBehaviour.Properties.of().forceSolidOn().strength(0.5F).sound(SoundType.WOOL).pushReaction(PushReaction.DESTROY).lightLevel { if (it.getValue(BlockStateProperties.LIT)) 3 else 0 }, true))
 
     @JvmField
-    val TUMBLESTONE_CLUSTER = tumblestoneBlock("tumblestone_cluster", TumblestoneBlock.STAGE_3, 7, 3, null, MapColor.TERRACOTTA_ORANGE)
+    val TUMBLESTONE_CLUSTER = tumblestoneBlock("tumblestone_cluster", TumblestoneBlock.STAGE_3, 7, 3, null)
     @JvmField
-    val LARGE_BUDDING_TUMBLESTONE = tumblestoneBlock("large_budding_tumblestone", TumblestoneBlock.STAGE_2, 5, 3, TUMBLESTONE_CLUSTER, MapColor.TERRACOTTA_ORANGE)
+    val LARGE_BUDDING_TUMBLESTONE = tumblestoneBlock("large_budding_tumblestone", TumblestoneBlock.STAGE_2, 5, 3, TUMBLESTONE_CLUSTER)
     @JvmField
-    val MEDIUM_BUDDING_TUMBLESTONE = tumblestoneBlock("medium_budding_tumblestone", TumblestoneBlock.STAGE_1, 4, 3, LARGE_BUDDING_TUMBLESTONE, MapColor.TERRACOTTA_ORANGE)
+    val MEDIUM_BUDDING_TUMBLESTONE = tumblestoneBlock("medium_budding_tumblestone", TumblestoneBlock.STAGE_1, 4, 3, LARGE_BUDDING_TUMBLESTONE)
     @JvmField
-    val SMALL_BUDDING_TUMBLESTONE = tumblestoneBlock("small_budding_tumblestone", TumblestoneBlock.STAGE_0, 3, 4, MEDIUM_BUDDING_TUMBLESTONE, MapColor.TERRACOTTA_ORANGE)
+    val SMALL_BUDDING_TUMBLESTONE = tumblestoneBlock("small_budding_tumblestone", TumblestoneBlock.STAGE_0, 3, 4, MEDIUM_BUDDING_TUMBLESTONE)
 
     @JvmField
-    val SKY_TUMBLESTONE_CLUSTER = tumblestoneBlock("sky_tumblestone_cluster", TumblestoneBlock.STAGE_3, 7, 3, null, MapColor.COLOR_LIGHT_BLUE)
+    val SKY_TUMBLESTONE_CLUSTER = tumblestoneBlock("sky_tumblestone_cluster", TumblestoneBlock.STAGE_3, 7, 3, null)
     @JvmField
-    val LARGE_BUDDING_SKY_TUMBLESTONE = tumblestoneBlock("large_budding_sky_tumblestone", TumblestoneBlock.STAGE_2, 5, 3, SKY_TUMBLESTONE_CLUSTER, MapColor.COLOR_LIGHT_BLUE)
+    val LARGE_BUDDING_SKY_TUMBLESTONE = tumblestoneBlock("large_budding_sky_tumblestone", TumblestoneBlock.STAGE_2, 5, 3, SKY_TUMBLESTONE_CLUSTER)
     @JvmField
-    val MEDIUM_BUDDING_SKY_TUMBLESTONE = tumblestoneBlock("medium_budding_sky_tumblestone", TumblestoneBlock.STAGE_1, 4, 3, LARGE_BUDDING_SKY_TUMBLESTONE, MapColor.COLOR_LIGHT_BLUE)
+    val MEDIUM_BUDDING_SKY_TUMBLESTONE = tumblestoneBlock("medium_budding_sky_tumblestone", TumblestoneBlock.STAGE_1, 4, 3, LARGE_BUDDING_SKY_TUMBLESTONE)
     @JvmField
-    val SMALL_BUDDING_SKY_TUMBLESTONE = tumblestoneBlock("small_budding_sky_tumblestone", TumblestoneBlock.STAGE_0, 3, 4, MEDIUM_BUDDING_SKY_TUMBLESTONE, MapColor.COLOR_LIGHT_BLUE)
+    val SMALL_BUDDING_SKY_TUMBLESTONE = tumblestoneBlock("small_budding_sky_tumblestone", TumblestoneBlock.STAGE_0, 3, 4, MEDIUM_BUDDING_SKY_TUMBLESTONE)
 
     @JvmField
-    val BLACK_TUMBLESTONE_CLUSTER = tumblestoneBlock("black_tumblestone_cluster", TumblestoneBlock.STAGE_3, 7, 3, null, MapColor.TERRACOTTA_BLACK)
+    val BLACK_TUMBLESTONE_CLUSTER = tumblestoneBlock("black_tumblestone_cluster", TumblestoneBlock.STAGE_3, 7, 3, null)
     @JvmField
-    val LARGE_BUDDING_BLACK_TUMBLESTONE = tumblestoneBlock("large_budding_black_tumblestone", TumblestoneBlock.STAGE_2, 5, 3, BLACK_TUMBLESTONE_CLUSTER, MapColor.TERRACOTTA_BLACK)
+    val LARGE_BUDDING_BLACK_TUMBLESTONE = tumblestoneBlock("large_budding_black_tumblestone", TumblestoneBlock.STAGE_2, 5, 3, BLACK_TUMBLESTONE_CLUSTER)
     @JvmField
-    val MEDIUM_BUDDING_BLACK_TUMBLESTONE = tumblestoneBlock("medium_budding_black_tumblestone", TumblestoneBlock.STAGE_1, 4, 3, LARGE_BUDDING_BLACK_TUMBLESTONE, MapColor.TERRACOTTA_BLACK)
+    val MEDIUM_BUDDING_BLACK_TUMBLESTONE = tumblestoneBlock("medium_budding_black_tumblestone", TumblestoneBlock.STAGE_1, 4, 3, LARGE_BUDDING_BLACK_TUMBLESTONE)
     @JvmField
-    val SMALL_BUDDING_BLACK_TUMBLESTONE = tumblestoneBlock("small_budding_black_tumblestone", TumblestoneBlock.STAGE_0, 3, 4, MEDIUM_BUDDING_BLACK_TUMBLESTONE, MapColor.TERRACOTTA_BLACK)
+    val SMALL_BUDDING_BLACK_TUMBLESTONE = tumblestoneBlock("small_budding_black_tumblestone", TumblestoneBlock.STAGE_0, 3, 4, MEDIUM_BUDDING_BLACK_TUMBLESTONE)
 
     @JvmField
     val TUMBLESTONE_BLOCK = this.create("tumblestone_block", Block(BlockBehaviour.Properties.of().mapColor(MapColor.TERRACOTTA_ORANGE).strength(1.0F).sound(CobblemonSounds.TUMBLESTONE_BLOCK_SOUNDS).requiresCorrectToolForDrops().instrument(NoteBlockInstrument.BASEDRUM)))
@@ -289,85 +289,85 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     val BLACK_TUMBLESTONE_BLOCK = this.create("black_tumblestone_block", Block(BlockBehaviour.Properties.of().mapColor(MapColor.TERRACOTTA_BLACK).strength(1.0F).sound(CobblemonSounds.TUMBLESTONE_BLOCK_SOUNDS).requiresCorrectToolForDrops().instrument(NoteBlockInstrument.BASEDRUM)))
 
     @JvmField
-    val TYPE_GEM_CORE = this.create("deepslate_crystal_core", TypeGemCoreBlock(BlockBehaviour.Properties.of().strength(4.0F, 10.0F).requiresCorrectToolForDrops().mapColor(MapColor.DEEPSLATE)))
+    val TYPE_GEM_CORE = this.create("deepslate_crystal_core", TypeGemCoreBlock(BlockBehaviour.Properties.of().strength(4.0F, 10.0F).requiresCorrectToolForDrops()))
 
     private val typeGemBlocks = mutableMapOf<ResourceLocation, Block>()
 
     @JvmField
-    val TYPE_GEM_BLOCK_NORMAL = typeGemBlock("normal_gem_block", MapColor.QUARTZ)
+    val TYPE_GEM_BLOCK_NORMAL = typeGemBlock("normal_gem_block")
     @JvmField
-    val TYPE_GEM_BLOCK_FIRE = typeGemBlock("fire_gem_block", MapColor.FIRE)
+    val TYPE_GEM_BLOCK_FIRE = typeGemBlock("fire_gem_block")
     @JvmField
-    val TYPE_GEM_BLOCK_WATER = typeGemBlock("water_gem_block", MapColor.WATER)
+    val TYPE_GEM_BLOCK_WATER = typeGemBlock("water_gem_block")
     @JvmField
-    val TYPE_GEM_BLOCK_GRASS = typeGemBlock("grass_gem_block", MapColor.COLOR_LIGHT_GREEN)
+    val TYPE_GEM_BLOCK_ELECTRIC = typeGemBlock("electric_gem_block")
     @JvmField
-    val TYPE_GEM_BLOCK_ELECTRIC = typeGemBlock("electric_gem_block", MapColor.GOLD)
+    val TYPE_GEM_BLOCK_GRASS = typeGemBlock("grass_gem_block")
     @JvmField
-    val TYPE_GEM_BLOCK_ICE = typeGemBlock("ice_gem_block", MapColor.ICE)
+    val TYPE_GEM_BLOCK_ICE = typeGemBlock("ice_gem_block")
     @JvmField
-    val TYPE_GEM_BLOCK_FIGHTING = typeGemBlock("fighting_gem_block", MapColor.COLOR_RED)
+    val TYPE_GEM_BLOCK_FIGHTING = typeGemBlock("fighting_gem_block")
     @JvmField
-    val TYPE_GEM_BLOCK_POISON = typeGemBlock("poison_gem_block", MapColor.COLOR_PURPLE)
+    val TYPE_GEM_BLOCK_POISON = typeGemBlock("poison_gem_block")
     @JvmField
-    val TYPE_GEM_BLOCK_GROUND = typeGemBlock("ground_gem_block", MapColor.PODZOL)
+    val TYPE_GEM_BLOCK_GROUND = typeGemBlock("ground_gem_block")
     @JvmField
-    val TYPE_GEM_BLOCK_FLYING = typeGemBlock("flying_gem_block", MapColor.COLOR_LIGHT_BLUE)
+    val TYPE_GEM_BLOCK_FLYING = typeGemBlock("flying_gem_block")
     @JvmField
-    val TYPE_GEM_BLOCK_PSYCHIC = typeGemBlock("psychic_gem_block", MapColor.COLOR_MAGENTA)
+    val TYPE_GEM_BLOCK_PSYCHIC = typeGemBlock("psychic_gem_block")
     @JvmField
-    val TYPE_GEM_BLOCK_BUG = typeGemBlock("bug_gem_block", MapColor.TERRACOTTA_LIGHT_GREEN)
+    val TYPE_GEM_BLOCK_BUG = typeGemBlock("bug_gem_block")
     @JvmField
-    val TYPE_GEM_BLOCK_ROCK = typeGemBlock("rock_gem_block", MapColor.TERRACOTTA_LIGHT_GRAY)
+    val TYPE_GEM_BLOCK_ROCK = typeGemBlock("rock_gem_block")
     @JvmField
-    val TYPE_GEM_BLOCK_GHOST = typeGemBlock("ghost_gem_block", MapColor.TERRACOTTA_MAGENTA)
+    val TYPE_GEM_BLOCK_GHOST = typeGemBlock("ghost_gem_block")
     @JvmField
-    val TYPE_GEM_BLOCK_DRAGON = typeGemBlock("dragon_gem_block", MapColor.COLOR_BLUE)
+    val TYPE_GEM_BLOCK_DRAGON = typeGemBlock("dragon_gem_block")
     @JvmField
-    val TYPE_GEM_BLOCK_DARK = typeGemBlock("dark_gem_block", MapColor.TERRACOTTA_BLACK)
+    val TYPE_GEM_BLOCK_DARK = typeGemBlock("dark_gem_block")
     @JvmField
-    val TYPE_GEM_BLOCK_STEEL = typeGemBlock("steel_gem_block", MapColor.METAL)
+    val TYPE_GEM_BLOCK_STEEL = typeGemBlock("steel_gem_block")
     @JvmField
-    val TYPE_GEM_BLOCK_FAIRY = typeGemBlock("fairy_gem_block", MapColor.COLOR_PINK)
+    val TYPE_GEM_BLOCK_FAIRY = typeGemBlock("fairy_gem_block")
 
     private val typeGemClusters = mutableMapOf<ResourceLocation, TypeGemClusterBlock>()
 
     @JvmField
-    val TYPE_GEM_CLUSTER_NORMAL = typeGemCluster("normal_gem_cluster", TYPE_GEM_BLOCK_NORMAL, cobblemonResource("normal_gem"), MapColor.QUARTZ)
+    val TYPE_GEM_CLUSTER_NORMAL = typeGemCluster("normal_gem_cluster", TYPE_GEM_BLOCK_NORMAL, cobblemonResource("normal_gem"))
     @JvmField
-    val TYPE_GEM_CLUSTER_FIRE = typeGemCluster("fire_gem_cluster", TYPE_GEM_BLOCK_FIRE, cobblemonResource("fire_gem"), MapColor.FIRE)
+    val TYPE_GEM_CLUSTER_FIRE = typeGemCluster("fire_gem_cluster", TYPE_GEM_BLOCK_FIRE, cobblemonResource("fire_gem"))
     @JvmField
-    val TYPE_GEM_CLUSTER_WATER = typeGemCluster("water_gem_cluster", TYPE_GEM_BLOCK_WATER, cobblemonResource("water_gem"), MapColor.WATER)
+    val TYPE_GEM_CLUSTER_WATER = typeGemCluster("water_gem_cluster", TYPE_GEM_BLOCK_WATER, cobblemonResource("water_gem"))
     @JvmField
-    val TYPE_GEM_CLUSTER_GRASS = typeGemCluster("grass_gem_cluster", TYPE_GEM_BLOCK_GRASS, cobblemonResource("grass_gem"), MapColor.COLOR_LIGHT_GREEN)
+    val TYPE_GEM_CLUSTER_ELECTRIC = typeGemCluster("electric_gem_cluster", TYPE_GEM_BLOCK_ELECTRIC, cobblemonResource("electric_gem"))
     @JvmField
-    val TYPE_GEM_CLUSTER_ELECTRIC = typeGemCluster("electric_gem_cluster", TYPE_GEM_BLOCK_ELECTRIC, cobblemonResource("electric_gem"), MapColor.GOLD)
+    val TYPE_GEM_CLUSTER_GRASS = typeGemCluster("grass_gem_cluster", TYPE_GEM_BLOCK_GRASS, cobblemonResource("grass_gem"))
     @JvmField
-    val TYPE_GEM_CLUSTER_ICE = typeGemCluster("ice_gem_cluster", TYPE_GEM_BLOCK_ICE, cobblemonResource("ice_gem"), MapColor.ICE)
+    val TYPE_GEM_CLUSTER_ICE = typeGemCluster("ice_gem_cluster", TYPE_GEM_BLOCK_ICE, cobblemonResource("ice_gem"))
     @JvmField
-    val TYPE_GEM_CLUSTER_FIGHTING = typeGemCluster("fighting_gem_cluster", TYPE_GEM_BLOCK_FIGHTING, cobblemonResource("fighting_gem"), MapColor.COLOR_RED)
+    val TYPE_GEM_CLUSTER_FIGHTING = typeGemCluster("fighting_gem_cluster", TYPE_GEM_BLOCK_FIGHTING, cobblemonResource("fighting_gem"))
     @JvmField
-    val TYPE_GEM_CLUSTER_POISON = typeGemCluster("poison_gem_cluster", TYPE_GEM_BLOCK_POISON, cobblemonResource("poison_gem"), MapColor.COLOR_PURPLE)
+    val TYPE_GEM_CLUSTER_POISON = typeGemCluster("poison_gem_cluster", TYPE_GEM_BLOCK_POISON, cobblemonResource("poison_gem"))
     @JvmField
-    val TYPE_GEM_CLUSTER_GROUND = typeGemCluster("ground_gem_cluster", TYPE_GEM_BLOCK_GROUND, cobblemonResource("ground_gem"), MapColor.PODZOL)
+    val TYPE_GEM_CLUSTER_GROUND = typeGemCluster("ground_gem_cluster", TYPE_GEM_BLOCK_GROUND, cobblemonResource("ground_gem"))
     @JvmField
-    val TYPE_GEM_CLUSTER_FLYING = typeGemCluster("flying_gem_cluster", TYPE_GEM_BLOCK_FLYING, cobblemonResource("flying_gem"), MapColor.COLOR_LIGHT_BLUE)
+    val TYPE_GEM_CLUSTER_FLYING = typeGemCluster("flying_gem_cluster", TYPE_GEM_BLOCK_FLYING, cobblemonResource("flying_gem"))
     @JvmField
-    val TYPE_GEM_CLUSTER_PSYCHIC = typeGemCluster("psychic_gem_cluster", TYPE_GEM_BLOCK_PSYCHIC, cobblemonResource("psychic_gem"), MapColor.COLOR_MAGENTA)
+    val TYPE_GEM_CLUSTER_PSYCHIC = typeGemCluster("psychic_gem_cluster", TYPE_GEM_BLOCK_PSYCHIC, cobblemonResource("psychic_gem"))
     @JvmField
-    val TYPE_GEM_CLUSTER_BUG = typeGemCluster("bug_gem_cluster", TYPE_GEM_BLOCK_BUG, cobblemonResource("bug_gem"), MapColor.TERRACOTTA_LIGHT_GREEN)
+    val TYPE_GEM_CLUSTER_BUG = typeGemCluster("bug_gem_cluster", TYPE_GEM_BLOCK_BUG, cobblemonResource("bug_gem"))
     @JvmField
-    val TYPE_GEM_CLUSTER_ROCK = typeGemCluster("rock_gem_cluster", TYPE_GEM_BLOCK_ROCK, cobblemonResource("rock_gem"), MapColor.TERRACOTTA_LIGHT_GRAY)
+    val TYPE_GEM_CLUSTER_ROCK = typeGemCluster("rock_gem_cluster", TYPE_GEM_BLOCK_ROCK, cobblemonResource("rock_gem"))
     @JvmField
-    val TYPE_GEM_CLUSTER_GHOST = typeGemCluster("ghost_gem_cluster", TYPE_GEM_BLOCK_GHOST, cobblemonResource("ghost_gem"), MapColor.TERRACOTTA_MAGENTA)
+    val TYPE_GEM_CLUSTER_GHOST = typeGemCluster("ghost_gem_cluster", TYPE_GEM_BLOCK_GHOST, cobblemonResource("ghost_gem"))
     @JvmField
-    val TYPE_GEM_CLUSTER_DRAGON = typeGemCluster("dragon_gem_cluster", TYPE_GEM_BLOCK_DRAGON, cobblemonResource("dragon_gem"), MapColor.COLOR_BLUE)
+    val TYPE_GEM_CLUSTER_DRAGON = typeGemCluster("dragon_gem_cluster", TYPE_GEM_BLOCK_DRAGON, cobblemonResource("dragon_gem"))
     @JvmField
-    val TYPE_GEM_CLUSTER_DARK = typeGemCluster("dark_gem_cluster", TYPE_GEM_BLOCK_DARK, cobblemonResource("dark_gem"), MapColor.TERRACOTTA_BLACK)
+    val TYPE_GEM_CLUSTER_DARK = typeGemCluster("dark_gem_cluster", TYPE_GEM_BLOCK_DARK, cobblemonResource("dark_gem"))
     @JvmField
-    val TYPE_GEM_CLUSTER_STEEL = typeGemCluster("steel_gem_cluster", TYPE_GEM_BLOCK_STEEL, cobblemonResource("steel_gem"), MapColor.METAL)
+    val TYPE_GEM_CLUSTER_STEEL = typeGemCluster("steel_gem_cluster", TYPE_GEM_BLOCK_STEEL, cobblemonResource("steel_gem"))
     @JvmField
-    val TYPE_GEM_CLUSTER_FAIRY = typeGemCluster("fairy_gem_cluster", TYPE_GEM_BLOCK_FAIRY, cobblemonResource("fairy_gem"), MapColor.COLOR_PINK)
+    val TYPE_GEM_CLUSTER_FAIRY = typeGemCluster("fairy_gem_cluster", TYPE_GEM_BLOCK_FAIRY, cobblemonResource("fairy_gem"))
 
     @JvmField
     val POLISHED_TUMBLESTONE = this.create("polished_tumblestone", Block(BlockBehaviour.Properties.of().mapColor(MapColor.TERRACOTTA_ORANGE).strength(1.0F).sound(CobblemonSounds.TUMBLESTONE_BLOCK_SOUNDS).requiresCorrectToolForDrops().instrument(NoteBlockInstrument.BASEDRUM)))
@@ -558,7 +558,7 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     @JvmField
     val RELIC_COIN_POUCH = create("relic_coin_pouch", CoinPouchBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.RELIC_COIN_POUCH_SOUNDS).pushReaction(PushReaction.DESTROY).noOcclusion(), true))
     @JvmField
-    val RELIC_COIN_SACK = create("relic_coin_sack", CoinPouchBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.RELIC_COIN_SACK_SOUNDS).pushReaction(PushReaction.DESTROY).strength(0.4F).mapColor(MapColor.GOLD), false))
+    val RELIC_COIN_SACK = create("relic_coin_sack", CoinPouchBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.RELIC_COIN_SACK_SOUNDS).pushReaction(PushReaction.DESTROY).strength(0.4F), false))
 
     @JvmField
     val GILDED_CHEST = create("gilded_chest", GildedChestBlock(BlockBehaviour.Properties.ofFullCopy(Blocks.CHEST).noOcclusion().sound(CobblemonSounds.GILDED_CHEST_SOUNDS), GildedChestBlock.Type.RED))
@@ -777,9 +777,8 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
 
     private fun apricornBlock(name: String, apricorn: Apricorn): ApricornBlock = this.create(name, ApricornBlock(BlockBehaviour.Properties.of().mapColor(apricorn.mapColor()).randomTicks().strength(Blocks.OAK_LOG.defaultDestroyTime(), Blocks.OAK_LOG.explosionResistance).sound(SoundType.WOOD).noOcclusion(), apricorn))
 
-    private fun tumblestoneBlock(name: String, stage: Int, height: Int, xzOffset: Int, nextStage: Block?, mapColor: MapColor) : Block {
+    private fun tumblestoneBlock(name: String, stage: Int, height: Int, xzOffset: Int, nextStage: Block?) : Block {
         return this.create(name, TumblestoneBlock(BlockBehaviour.Properties.of()
-            .mapColor(mapColor)
             .pushReaction(PushReaction.DESTROY)
             .noOcclusion()
             .strength(1.5F)
@@ -1009,8 +1008,8 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
         return this.create(name, block)
     }
 
-    private fun typeGemBlock(name: String, mapColor: MapColor): Block {
-        val typeGemBlock = this.create(name, Block(BlockBehaviour.Properties.of().mapColor(mapColor).strength(3.0F, 6.0F).sound(CobblemonSounds.TYPE_GEM_BLOCK_SOUNDS)))
+    private fun typeGemBlock(name: String): Block {
+        val typeGemBlock = this.create(name, Block(BlockBehaviour.Properties.of().strength(3.0F, 6.0F).sound(CobblemonSounds.TYPE_GEM_BLOCK_SOUNDS)))
 
         val identifier = cobblemonResource(name)
         typeGemBlocks[identifier] = typeGemBlock
@@ -1020,8 +1019,8 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
 
     fun typeGemBlocks() = typeGemBlocks.toMap()
 
-    private fun typeGemCluster(name: String, gemBlock: Block, dropItemId: ResourceLocation, mapColor: MapColor): Block {
-        val gemClusterBlock = this.create(name, TypeGemClusterBlock(BlockBehaviour.Properties.of().mapColor(mapColor).strength(2.0F, 3.0F).sound(CobblemonSounds.TYPE_GEM_CLUSTER_SOUNDS).pushReaction(PushReaction.DESTROY), gemBlock, dropItemId))
+    private fun typeGemCluster(name: String, gemBlock: Block, dropItemId: ResourceLocation): Block {
+        val gemClusterBlock = this.create(name, TypeGemClusterBlock(BlockBehaviour.Properties.of().strength(2.0F, 3.0F).sound(CobblemonSounds.TYPE_GEM_CLUSTER_SOUNDS).pushReaction(PushReaction.DESTROY), gemBlock, dropItemId))
 
         TypeGemClusterBlock.gemToClusterMap[gemBlock] = gemClusterBlock
 
@@ -1032,4 +1031,4 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     }
 
     fun typeGemClusters() = typeGemClusters.toMap()
-}
+}

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

@@ -405,7 +405,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val BIG_MALASADA = regionalFoodItem("big_malasada", 64, 7, 0.3f, false)
     @JvmField
-    val SMOKED_TAIL_CURRY = regionalFoodItem("smoked_tail_curry", 64, 10, 0.6f, false)
+    val SMOKED_TAIL_CURRY = regionalFoodItem("smoked_tail_curry", 64, 10, 0.6f, false, ItemStack(Items.BOWL, 1))
     @JvmField
     val JUBILIFE_MUFFIN = regionalFoodItem("jubilife_muffin", 64, 7, 0.3f, false)
     @JvmField

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

@@ -35,7 +35,6 @@ import com.cobblemon.mod.common.client.net.gui.PokedexUIPacketHandler
 import com.cobblemon.mod.common.client.net.gui.SetActiveTMPacketHandler
 import com.cobblemon.mod.common.client.net.gui.SetTMMachineContainerDataPacketHandler
 import com.cobblemon.mod.common.client.net.gui.SummaryUIPacketHandler
-import com.cobblemon.mod.common.client.net.gui.SynchronizeActiveTMHandler
 import com.cobblemon.mod.common.client.net.habitat.OpenHabitatBlockEditorHandler
 import com.cobblemon.mod.common.client.net.npc.CloseNPCEditorHandler
 import com.cobblemon.mod.common.client.net.npc.OpenNPCEditorHandler
@@ -132,7 +131,6 @@ import com.cobblemon.mod.common.net.messages.client.storage.pc.wallpaper.ChangeP
 import com.cobblemon.mod.common.net.messages.client.storage.pc.wallpaper.RequestPCBoxWallpapersPacket
 import com.cobblemon.mod.common.net.messages.client.storage.pc.wallpaper.SetPCBoxWallpapersPacket
 import com.cobblemon.mod.common.net.messages.client.storage.pc.wallpaper.UnlockPCBoxWallpaperPacket
-import com.cobblemon.mod.common.net.messages.client.tms.TechnicalMachineRegistrySyncPacket
 import com.cobblemon.mod.common.net.messages.client.toast.ToastPacket
 import com.cobblemon.mod.common.net.messages.client.trade.TradeAcceptanceChangedPacket
 import com.cobblemon.mod.common.net.messages.client.trade.TradeCancelledPacket
@@ -148,7 +146,6 @@ import com.cobblemon.mod.common.net.messages.client.ui.PokedexUIPacket
 import com.cobblemon.mod.common.net.messages.client.ui.SetActiveTMPacket
 import com.cobblemon.mod.common.net.messages.client.ui.SetTMMachineContainerDataPacket
 import com.cobblemon.mod.common.net.messages.client.ui.SummaryUIPacket
-import com.cobblemon.mod.common.net.messages.client.ui.SynchronizeActiveTMPacket
 import com.cobblemon.mod.common.net.messages.server.BattleChallengePacket
 import com.cobblemon.mod.common.net.messages.server.BattleChallengeResponsePacket
 import com.cobblemon.mod.common.net.messages.server.BenchMovePacket
@@ -377,7 +374,6 @@ object CobblemonNetwork {
         list.add(PacketRegisterInfo(PlayerInteractOptionsPacket.ID, PlayerInteractOptionsPacket::decode, PlayerInteractOptionsHandler))
         list.add(PacketRegisterInfo(PokedexUIPacket.ID, PokedexUIPacket::decode, PokedexUIPacketHandler))
         list.add(PacketRegisterInfo(ExpGainedDataPacket.ID, ExpGainedDataPacket::decode, ExpGainedDataPacketHandler))
-        list.add(PacketRegisterInfo(SynchronizeActiveTMPacket.ID, SynchronizeActiveTMPacket::decode, SynchronizeActiveTMHandler))
 
         // Starter packets
         list.add(PacketRegisterInfo(OpenStarterUIPacket.ID, OpenStarterUIPacket::decode, StarterUIPacketHandler))
@@ -443,7 +439,6 @@ object CobblemonNetwork {
         list.add(PacketRegisterInfo(BehaviourSyncPacket.ID, BehaviourSyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(MarkRegistrySyncPacket.ID, MarkRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(RideSettingsSyncPacket.ID, RideSettingsSyncPacket::decode, RideSettingsSyncHandler))
-        list.add(PacketRegisterInfo(TechnicalMachineRegistrySyncPacket.ID, TechnicalMachineRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
 
         // Effects
         list.add(PacketRegisterInfo(SpawnSnowstormParticlePacket.ID, SpawnSnowstormParticlePacket::decode, SpawnSnowstormParticleHandler))

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

@@ -108,9 +108,6 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
     @JvmField
     val LEVELUP = this.create("gui.levelup")
 
-    @JvmField
-    val MOVE_LEARN = this.create("gui.move_learn")
-
     @JvmField
     val PVN_BATTLE = this.create("battle.pvn.default")
     @JvmField
@@ -145,8 +142,6 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
     val MONITOR_INSERT = this.create("block.monitor.insert")
     @JvmField
     val MONITOR_LOADING = this.create("block.monitor.loading")
-    @JvmField
-    val MONITOR_GLITCHING = this.create("block.monitor.glitching")
 
     @JvmField
     val FOSSIL_MACHINE_ACTIVATE = this.create("block.fossil_machine.activate")
@@ -215,23 +210,17 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
     @JvmField
     val TM_USE = this.create("item.tm.use")
     @JvmField
-    val TM_MACHINE_BURN_LOOP = this.create("block.tm_machine.burn_loop")
-    @JvmField
     val TM_MACHINE_CRAFT = this.create("block.tm_machine.craft")
     @JvmField
-    val TM_MACHINE_START = this.create("block.tm_machine.start")
+    val TM_MACHINE_OFF = this.create("block.tm_machine.off")
+    @JvmField
+    val TM_MACHINE_ON = this.create("block.tm_machine.on")
     @JvmField
     val TM_MACHINE_OPEN = this.create("block.tm_machine.open")
     @JvmField
     val TM_MACHINE_CLOSE = this.create("block.tm_machine.close")
     @JvmField
-    val TM_MACHINE_TM_INSERT = this.create("block.tm_machine.tm_insert")
-    @JvmField
-    val TM_MACHINE_TM_RETRIEVE = this.create("block.tm_machine.tm_retrieve")
-    @JvmField
-    val TM_MACHINE_ITEM_INSERT = this.create("block.tm_machine.item_insert")
-    @JvmField
-    val TM_MACHINE_ITEM_RETRIEVE = this.create("block.tm_machine.item_retrieve")
+    val TM_MACHINE_PLACE_DISC = this.create("block.tm_machine.place_disc")
 
 
     @JvmField
@@ -272,9 +261,6 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
     @JvmField
     val BERRY_EAT_FULL = this.create("item.berry.eat.full")
 
-    @JvmField
-    val APRICORN_HARVEST = this.create("block.apricorn.harvest")
-
     @JvmField
     val BIG_ROOT_BREAK = this.create("block.big_root.break")
     @JvmField
@@ -422,9 +408,9 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
     )
 
     @JvmField
-    val TYPE_GEM_BLOCK_BREAK = this.create("block.type_gem_block.break")
+    val TYPE_GEM_BLOCK_BREAK = this.create("block.type_gem_cluster.break")
     @JvmField
-    val TYPE_GEM_CLUSTER_BREAK = this.create("block.type_gem_cluster.break")
+    val TYPE_GEM_CLUSTER_BREAK = this.create("block.type_gem_block.break")
     @JvmField
     val TYPE_GEM_BLOCK_HIT = this.create("block.type_gem_block.hit")
     @JvmField
@@ -433,7 +419,7 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
     val TYPE_GEM_BLOCK_STEP = this.create("block.type_gem_block.step")
 
     @JvmField
-    val TYPE_GEM_CLUSTER_SOUNDS = SoundType(1f, 1.1f,
+    val TYPE_GEM_CLUSTER_SOUNDS = SoundType(1f, 1.2f,
         TYPE_GEM_CLUSTER_BREAK,
         TYPE_GEM_BLOCK_STEP,
         TYPE_GEM_BLOCK_PLACE,

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

@@ -48,7 +48,7 @@ class RidingStatBoostCriterion(
                     val max = context.pokemon.pokemon.getMaxRideBoost(rideStat).toDouble()
                     val min = context.pokemon.pokemon.getBaseRideStat(rideStat).toDouble()
                     val value = context.pokemon.getRideStat(rideStat, ridingStyle, min, max)
-                    val isSufficient = (value >= this.statValue && this.statValue > 0.0) || !context.pokemon.pokemon.canApplyRideBoost(rideStat)
+                    val isSufficient = (value >= this.statValue && this.statValue > 0.0) || !context.pokemon.pokemon.canAddRideBoost(rideStat)
                     if (isSufficient && this.rideStat == "any") {
                         return true
                     } else if (!isSufficient && this.rideStat == "all") {

common/src/main/kotlin/com/cobblemon/mod/common/api/battles/model/PokemonBattle.kt

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

common/src/main/kotlin/com/cobblemon/mod/common/api/cooking/effects/CleanseAllEffect.kt

@@ -8,7 +8,6 @@
 
 package com.cobblemon.mod.common.api.cooking.effects
 
-import net.minecraft.server.level.ServerPlayer
 import net.minecraft.world.effect.MobEffect
 import net.minecraft.world.effect.MobEffectCategory
 import net.minecraft.world.entity.Entity
@@ -19,13 +18,5 @@ class CleanseAllEffect : MobEffect(MobEffectCategory.BENEFICIAL, 0xFFFFFF) {
     override fun applyInstantenousEffect(source: Entity?, indirect: Entity?, target: LivingEntity, amplifier: Int, proximity: Double) {
         target.removeAllEffects()
     }
-
-    override fun applyEffectTick(livingEntity: LivingEntity, amplifier: Int): Boolean {
-        if (livingEntity is ServerPlayer){
-            livingEntity.removeAllEffects()
-        }
-        return true
-    }
-
-    override fun shouldApplyEffectTickThisTick(duration: Int, amplifier: Int) = true
+    override fun shouldApplyEffectTickThisTick(duration: Int, amplifier: Int) = false
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/cooking/effects/CleanseNegativeEffect.kt

@@ -8,7 +8,6 @@
 
 package com.cobblemon.mod.common.api.cooking.effects
 
-import net.minecraft.server.level.ServerPlayer
 import net.minecraft.world.effect.MobEffect
 import net.minecraft.world.effect.MobEffectCategory
 import net.minecraft.world.entity.Entity
@@ -24,18 +23,5 @@ class CleanseNegativeEffect : MobEffect(MobEffectCategory.BENEFICIAL, 0xFFFFFF)
             }
         }
     }
-
-    override fun applyEffectTick(livingEntity: LivingEntity, amplifier: Int): Boolean {
-        if (livingEntity is ServerPlayer){
-            val snapshot = livingEntity.activeEffects.toList()
-            for (ei in snapshot) {
-                if (ei.effect.value().category == MobEffectCategory.HARMFUL) {
-                    livingEntity.removeEffect(ei.effect)
-                }
-            }
-        }
-        return true
-    }
-
-    override fun shouldApplyEffectTickThisTick(duration: Int, amplifier: Int) = true
+    override fun shouldApplyEffectTickThisTick(duration: Int, amplifier: Int) = false
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/data/ClientDataSynchronizer.kt

@@ -0,0 +1,33 @@
+/*
+ * 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.data
+
+import com.cobblemon.mod.common.api.net.Decodable
+import com.cobblemon.mod.common.api.net.Encodable
+
+// TODO this is implemented in multiple places but unused. Can we scratch this?
+/**
+ * Represents an object that will possibly be synchronized to the client during datapack synchronization.
+ *
+ * @param T The type of the object being synchronized.
+ *
+ * @author Licious
+ * @since October 14th, 2022
+ */
+interface ClientDataSynchronizer<T> : Decodable, Encodable {
+
+    /**
+     * Compares an object of type [T] with this instance to see if synchronization is necessary.
+     *
+     * @param other The other instance of type [T].
+     * @return If synchronization is necessary.
+     */
+    fun shouldSynchronize(other: T): Boolean
+
+}

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

@@ -8,6 +8,7 @@
 
 package com.cobblemon.mod.common.api.events.entity
 
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.SpawnCause
 import com.cobblemon.mod.common.api.spawning.spawner.Spawner
 
@@ -20,7 +21,7 @@ class SpawnBucketChosenEvent(
     /** The cause of the spawn. */
     val spawnCause: SpawnCause,
     /** The bucket that was chosen. You can alter this. */
-    var bucket: String,
+    var bucket: SpawnBucket,
     /** The final weights that were used to make the choice. */
-    val bucketWeights: Map<String, Float>
+    val bucketWeights: Map<SpawnBucket, Float>
 )

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

@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.api.events.fishing
 
 import com.cobblemon.mod.common.api.events.Cancelable
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.entity.fishing.PokeRodFishingBobberEntity
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import net.minecraft.world.item.ItemStack
@@ -26,7 +27,7 @@ interface BaitSpawnPokemonEvent {
      */
     data class Pre(
         val bobber: PokeRodFishingBobberEntity, // todo replace this with the bait entity
-        val chosenBucket: String,
+        val chosenBucket: SpawnBucket,
         val rod: ItemStack
     ) : Cancelable(), BobberSpawnPokemonEvent
 
@@ -37,7 +38,7 @@ interface BaitSpawnPokemonEvent {
      * @param pokemon The Pokemon that is modified.
      */
     data class Modify(
-        val chosenBucket: String,
+        val chosenBucket: SpawnBucket,
         val rod: ItemStack,
         val pokemon: PokemonEntity
     ) : BobberSpawnPokemonEvent
@@ -51,7 +52,7 @@ interface BaitSpawnPokemonEvent {
      */
     data class Post(
         val bobber: PokeRodFishingBobberEntity,
-        val chosenBucket: String,
+        val chosenBucket: SpawnBucket,
         val bait: ItemStack,
         val pokemon: PokemonEntity
     ) : BobberSpawnPokemonEvent

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

@@ -8,10 +8,12 @@
 
 package com.cobblemon.mod.common.api.events.fishing
 
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
+
 /**
  * Event that is fired when a bucket is chosen by the bobber.
  * @param chosenBucket The bucket that is chosen.
  * @param buckets The list of buckets that the bobber can choose from.
  * @param luckOfTheSeaLevel The level of the Luck of the Sea enchantment on the rod.
  */
-class BobberBucketChosenEvent(var chosenBucket: String, val buckets: MutableList<String>, val luckOfTheSeaLevel: Int)
+class BobberBucketChosenEvent(var chosenBucket: SpawnBucket, val buckets: MutableList<SpawnBucket>, val luckOfTheSeaLevel: Int)

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

@@ -12,7 +12,10 @@ import com.bedrockk.molang.runtime.value.MoValue
 import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.events.Cancelable
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
+import com.cobblemon.mod.common.api.molang.ObjectValue
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.detail.SpawnAction
 import com.cobblemon.mod.common.entity.fishing.PokeRodFishingBobberEntity
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
@@ -70,8 +73,8 @@ interface BobberSpawnPokemonEvent {
         val bait: ItemStack,
         val pokemon: PokemonEntity
     ) : BobberSpawnPokemonEvent {
-        val context = mutableMapOf(
-            "chosen_bucket" to StringValue(spawnAction.bucket),
+        val context = mutableMapOf<String, MoValue>(
+            "chosen_bucket" to ObjectValue(spawnAction.bucket, { it.name }),
             "bait" to pokemon.level().itemRegistry.wrapAsHolder(bait.item).asMoLangValue(Registries.ITEM),
             "pokemon_entity" to pokemon.asMoLangValue()
         )

common/src/main/kotlin/com/cobblemon/mod/common/api/habitats/ActivatedHabitatPool.kt

@@ -0,0 +1,37 @@
+/*
+ * 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.habitats
+
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
+import net.minecraft.network.RegistryFriendlyByteBuf
+import net.minecraft.resources.ResourceLocation
+
+/**
+ * A [HabitatPool] of [ActivatedHabitatSpawn]s. Mainly just to help with deserialization and ensuring
+ * a single type for everything that's applied to a habitat block.
+ *
+ * @author Hiroku
+ * @since February 13th, 2026
+ */
+class ActivatedHabitatPool : HabitatPool<ActivatedHabitatSpawn>() {
+    override val type: ResourceLocation = ActivatedHabitatSpawn.TYPE
+    override var spawns: List<ActivatedHabitatSpawn> = listOf()
+
+    companion object {
+        fun default() = ActivatedHabitatPool().apply {
+            id = ResourceLocation("cobblemon", "custom__default_activated_pool")
+            name = "Custom"
+        }
+    }
+
+    override fun decode(buffer: RegistryFriendlyByteBuf, buckets: List<SpawnBucket>) {
+        super.decode(buffer, buckets)
+        spawns = buffer.readList { ActivatedHabitatSpawn().apply { decode(buffer, buckets) } }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/habitats/ActivatedHabitatSpawn.kt

@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.habitats
+
+import com.cobblemon.mod.common.util.cobblemonResource
+
+/**
+ * A basic [HabitatSpawn] that will be triggered via activated spawning in a habitat. Nothing to it, really.
+ *
+ * @author Hiroku
+ * @since February 13th, 2026
+ */
+class ActivatedHabitatSpawn : HabitatSpawn() {
+    companion object {
+        val TYPE = cobblemonResource("activated")
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/habitats/HabitatPool.kt

@@ -8,81 +8,39 @@
 
 package com.cobblemon.mod.common.api.habitats
 
-import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.detail.PokemonSpawnDetail
 import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
 import com.cobblemon.mod.common.block.habitat.HabitatBlockEntity
-import com.cobblemon.mod.common.util.DataKeys
-import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
-import net.minecraft.nbt.CompoundTag
-import net.minecraft.nbt.ListTag
-import net.minecraft.nbt.Tag
 import net.minecraft.network.RegistryFriendlyByteBuf
 import net.minecraft.resources.ResourceLocation
 
 /**
- * A pool of [HabitatSpawn]s. This is filled with [HabitatSpawn]s. The pool is responsible for converting
+ * A pool of [HabitatSpawn]s. This is either filled with [NaturalHabitatSpawn]s or [ActivatedHabitatSpawn]s depending
+ * on whether the pool is a [NaturalHabitatPool] or an [ActivatedHabitatPool]. The pool is responsible for converting
  * its spawns into [PokemonSpawnDetail]s.
  *
  * @author Hiroku
  * @since February 13th, 2026
  */
-class HabitatPool {
+abstract class HabitatPool<T : HabitatSpawn> {
     companion object {
-        fun default() = HabitatPool().apply {
-            id = ResourceLocation("cobblemon", "custom__default_pool")
-            name = "Custom"
-        }
-
-        fun writePoolToNBT(pool: HabitatPool, nbt: CompoundTag) {
-            nbt.putString(DataKeys.HABITAT_POOL_ID, pool.id.toString())
-            if (pool.id.path.startsWith("custom__")) {
-                nbt.putString(DataKeys.HABITAT_POOL_NAME, pool.name)
-                val spawnsListNBT = ListTag()
-                for (spawn in pool.spawns) {
-                    val spawnTag = CompoundTag()
-                    spawn.writeToNBT(spawnTag)
-                    spawnsListNBT.add(spawnTag)
-                }
-                nbt.put(DataKeys.HABITAT_POOL_SPAWNS, spawnsListNBT)
-            }
-        }
-
-        fun readPoolFromNBT(nbt: CompoundTag): HabitatPool {
-            val poolId = nbt.getString(DataKeys.HABITAT_POOL_ID).asIdentifierDefaultingNamespace()
-            if (nbt.contains(DataKeys.HABITAT_POOL_NAME)) {
-                // It's one that was stored on the block
-                val pool = HabitatPool()
-                pool.id = poolId
-                pool.name = nbt.getString(DataKeys.HABITAT_POOL_NAME)
-                val spawnsListNBT = nbt.getList(DataKeys.HABITAT_POOL_SPAWNS, Tag.TAG_COMPOUND.toInt())
-                val spawns = mutableListOf<HabitatSpawn>()
-                spawnsListNBT.forEach { spawnTag ->
-                    try {
-                        val spawn = HabitatSpawn().apply { readFromNBT(spawnTag as CompoundTag) }
-                        spawns.add(spawn)
-                    } catch (_: Exception) {
-                        // If there's an error reading a spawn, skip it and log the error.
-                        Cobblemon.LOGGER.error("Error reading activated habitat spawn from NBT for habitat block, skipping.")
-                    }
-                }
-                pool.spawns = spawns
-                return pool
-            } else {
-                return HabitatPools.habitatPoolsById[poolId] ?: default()
-            }
-        }
+        val types = mutableMapOf(
+            ActivatedHabitatSpawn.TYPE to ActivatedHabitatPool::class.java,
+            NaturalHabitatSpawn.TYPE to NaturalHabitatPool::class.java
+        )
     }
 
     lateinit var id: ResourceLocation
     var name: String = ""
-    var spawns: List<HabitatSpawn> = listOf()
+    abstract val type: ResourceLocation
+    abstract var spawns: List<T>
 
     /** Whether a pool is editable is just down to whether it's not from a datapack. */
     @Transient
     var editable: Boolean = false
 
-    fun validate() {
+    open fun validate() {
         for (spawn in spawns) {
             if (SpawnablePosition.getByName(spawn.spawnablePositionType) == null) {
                 throw IllegalArgumentException("$id mentions non-existent spawnable position type ${spawn.spawnablePositionType} on spawn for ${spawn.species}")
@@ -94,23 +52,14 @@ class HabitatPool {
         return spawns.mapNotNull { it.createSpawnDetail(habitatBlockEntity) }
     }
 
-    fun getPhaseCount(): Int {
-        return spawns
-            .flatMap { it.phases?.ranges?.flatten() ?: emptySet() }
-            .toSet()
-            .count()
-            .coerceAtLeast(1)
-    }
-
     fun encode(buffer: RegistryFriendlyByteBuf) {
         buffer.writeResourceLocation(id)
         buffer.writeUtf(name)
         buffer.writeCollection(spawns) { _, it -> it.encode(buffer) }
     }
 
-    fun decode(buffer: RegistryFriendlyByteBuf) {
+    open fun decode(buffer: RegistryFriendlyByteBuf, buckets: List<SpawnBucket>) {
         id = buffer.readResourceLocation()
         name = buffer.readUtf()
-        spawns = buffer.readList { HabitatSpawn().apply { decode(buffer) } }
     }
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/habitats/HabitatPools.kt

@@ -12,13 +12,16 @@ 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.api.spawning.IntRanges
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.TimeRange
 import com.cobblemon.mod.common.api.spawning.position.SpawnablePositionType
 import com.cobblemon.mod.common.pokemon.Species
+import com.cobblemon.mod.common.util.adapters.HabitatPoolAdapter
 import com.cobblemon.mod.common.util.adapters.IdentifierAdapter
 import com.cobblemon.mod.common.util.adapters.IntRangeAdapter
 import com.cobblemon.mod.common.util.adapters.IntRangesAdapter
 import com.cobblemon.mod.common.util.adapters.RegisteredSpawnablePositionAdapter
+import com.cobblemon.mod.common.util.adapters.SpawnBucketAdapter
 import com.cobblemon.mod.common.util.adapters.SpeciesAdapter
 import com.cobblemon.mod.common.util.adapters.pokemonPropertiesShortAdapter
 import com.cobblemon.mod.common.util.cobblemonResource
@@ -33,16 +36,18 @@ import net.minecraft.server.level.ServerPlayer
 import net.minecraft.server.packs.PackType
 import net.minecraft.world.level.storage.LevelResource
 
-object HabitatPools : JsonDataRegistry<HabitatPool> {
+object HabitatPools : JsonDataRegistry<HabitatPool<*>> {
     override val id = cobblemonResource("habitat_pools")
     override val type = PackType.SERVER_DATA
     override val observable = SimpleObservable<HabitatPools>()
-    override val typeToken: TypeToken<HabitatPool> = TypeToken.get(HabitatPool::class.java)
+    override val typeToken: TypeToken<HabitatPool<*>> = TypeToken.get(HabitatPool::class.java)
     override val resourcePath = "habitat_pools"
 
     override val gson: Gson = GsonBuilder()
         .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
+        .registerTypeAdapter(HabitatPool::class.java, HabitatPoolAdapter)
         .registerTypeAdapter(SpawnablePositionType::class.java, RegisteredSpawnablePositionAdapter)
+        .registerTypeAdapter(SpawnBucket::class.java, SpawnBucketAdapter)
         .registerTypeAdapter(Species::class.java, SpeciesAdapter)
         .registerTypeAdapter(IntRange::class.java, IntRangeAdapter)
         .registerTypeAdapter(TimeRange::class.java, TimeRange.adapter)
@@ -51,10 +56,10 @@ object HabitatPools : JsonDataRegistry<HabitatPool> {
         .setPrettyPrinting()
         .create()
 
-    private val datapacked = mutableMapOf<ResourceLocation, HabitatPool>()
-    private val worldSaved = mutableMapOf<ResourceLocation, HabitatPool>()
+    private val datapacked = mutableMapOf<ResourceLocation, HabitatPool<*>>()
+    private val worldSaved = mutableMapOf<ResourceLocation, HabitatPool<*>>()
 
-    val habitatPoolsById = mutableMapOf<ResourceLocation, HabitatPool>()
+    val habitatPoolsById = mutableMapOf<ResourceLocation, HabitatPool<*>>()
 
     private lateinit var worldSavedPoolsFolder: File
 
@@ -68,7 +73,7 @@ object HabitatPools : JsonDataRegistry<HabitatPool> {
 
         worldSavedPoolsFolder.listFiles { it.endsWith(".json") }.forEach {
             val identifier = ResourceLocation.parse(it.nameWithoutExtension)
-            val habitat = gson.fromJson<HabitatPool>(it.reader())
+            val habitat = gson.fromJson<HabitatPool<*>>(it.reader())
             habitat.id = identifier
             habitat.validate()
             habitat.editable = true
@@ -77,7 +82,7 @@ object HabitatPools : JsonDataRegistry<HabitatPool> {
         setupHabitatPoolsById()
     }
 
-    override fun reload(data: Map<ResourceLocation, HabitatPool>) {
+    override fun reload(data: Map<ResourceLocation, HabitatPool<*>>) {
         datapacked.clear()
         datapacked.putAll(data)
         data.entries.forEach { (identifier, habitat) ->

common/src/main/kotlin/com/cobblemon/mod/common/api/habitats/HabitatSpawn.kt

@@ -10,7 +10,9 @@ package com.cobblemon.mod.common.api.habitats
 
 import com.cobblemon.mod.common.api.pokemon.PokemonProperties
 import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
+import com.cobblemon.mod.common.api.spawning.BestSpawner
 import com.cobblemon.mod.common.api.spawning.IntRanges
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.TimeRange
 import com.cobblemon.mod.common.api.spawning.condition.AppendageCondition
 import com.cobblemon.mod.common.api.spawning.condition.SpawningCondition
@@ -28,7 +30,9 @@ import net.minecraft.nbt.CompoundTag
 import net.minecraft.network.RegistryFriendlyByteBuf
 
 /**
- * A kind of simplified spawn definition for the purposes of spawning from [HabitatBlockEntity] instances.
+ * A kind of simplified spawn definition for the purposes of spawning from [HabitatBlockEntity] instances. This is a
+ * very shallow class tree, with [ActivatedHabitatSpawn] being a trivial subclass but the other subclass being
+ * [NaturalHabitatSpawn] which introduces the need to supply a spawn bucket.
  *
  * These have only a small subset of the properties that a regular [PokemonSpawnDetail] would have to align with the
  * fact that these are configured from a simple GUI. There are limits to how many properties and conditions could be
@@ -42,13 +46,11 @@ import net.minecraft.network.RegistryFriendlyByteBuf
  * @author Hiroku
  * @since February 13th, 2026
  */
-class HabitatSpawn {
+sealed class HabitatSpawn {
     /** The species that will be spawned. */
     lateinit var species: Species
     /** The kind of position the Pokémon will spawn in. Things like "grounded", "seafloor", "fishing". */
     lateinit var spawnablePositionType: String
-    /** The bucket to spawn from. */
-    var bucket: String = "common"
 
     /** Selection weight. */
     var weight: Float = 1F
@@ -65,7 +67,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)
@@ -75,10 +77,9 @@ class HabitatSpawn {
         timeRange?.let { nbt.putString(DataKeys.HABITAT_POOL_SPAWN_TIMES, TimeRange.adapter.serialize(it)) }
         minLight?.let { nbt.putInt(DataKeys.HABITAT_POOL_SPAWN_MIN_LIGHT, it) }
         maxLight?.let { nbt.putInt(DataKeys.HABITAT_POOL_SPAWN_MAX_LIGHT, it) }
-        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)
@@ -88,10 +89,9 @@ class HabitatSpawn {
         timeRange = if (nbt.contains(DataKeys.HABITAT_POOL_SPAWN_TIMES)) TimeRange.adapter.deserialize(nbt.getString(DataKeys.HABITAT_POOL_SPAWN_TIMES)) else null
         minLight = if (nbt.contains(DataKeys.HABITAT_POOL_SPAWN_MIN_LIGHT)) nbt.getInt(DataKeys.HABITAT_POOL_SPAWN_MIN_LIGHT) else null
         maxLight = if (nbt.contains(DataKeys.HABITAT_POOL_SPAWN_MAX_LIGHT)) nbt.getInt(DataKeys.HABITAT_POOL_SPAWN_MAX_LIGHT) else null
-        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)
@@ -101,10 +101,12 @@ class HabitatSpawn {
         buffer.writeNullable(timeRange) { _, value -> buffer.writeUtf(TimeRange.adapter.serialize(value)) }
         buffer.writeNullable(minLight) { _, value -> buffer.writeInt(value) }
         buffer.writeNullable(maxLight) { _, value -> buffer.writeInt(value) }
-        buffer.writeUtf(bucket)
     }
 
-    fun decode(buffer: RegistryFriendlyByteBuf) {
+    open fun decode(
+        buffer: RegistryFriendlyByteBuf,
+        buckets: List<SpawnBucket>
+    ) {
         species = PokemonSpecies.getByIdentifier(buffer.readResourceLocation())!!
         spawnablePositionType = buffer.readUtf()
         weight = buffer.readFloat()
@@ -114,11 +116,10 @@ class HabitatSpawn {
         timeRange = buffer.readNullable { _ -> TimeRange.adapter.deserialize(buffer.readUtf()) }
         minLight = buffer.readNullable { _ -> buffer.readInt() }
         maxLight = buffer.readNullable { _ -> buffer.readInt() }
-        bucket = buffer.readUtf()
     }
 
     /** 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
@@ -137,7 +138,7 @@ class HabitatSpawn {
         spawnDetail.apply {
             this.id = "habitat_${species.resourceIdentifier}"
             this.pokemon = properties
-            this.bucket = this@HabitatSpawn.bucket
+            this.bucket = BestSpawner.config.buckets.first { it.weight > 0 }
             this.weight = this@HabitatSpawn.weight
             this.levelRange = levelRange
             this.conditions = mutableListOf(condition)

common/src/main/kotlin/com/cobblemon/mod/common/api/habitats/NaturalHabitatPool.kt

@@ -0,0 +1,37 @@
+/*
+ * 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.habitats
+
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
+import net.minecraft.network.RegistryFriendlyByteBuf
+import net.minecraft.resources.ResourceLocation
+
+/**
+ * A [HabitatPool] of [NaturalHabitatSpawn]s. Mainly just to help with deserialization and ensuring
+ * a single type for everything that's applied to a habitat block.
+ *
+ * @author Hiroku
+ * @since February 13th, 2026
+ */
+class NaturalHabitatPool : HabitatPool<NaturalHabitatSpawn>() {
+    override val type: ResourceLocation = NaturalHabitatSpawn.TYPE
+    override var spawns: List<NaturalHabitatSpawn> = listOf()
+
+    companion object {
+        fun default() = NaturalHabitatPool().apply {
+            id = ResourceLocation("cobblemon", "custom__default_natural_pool")
+            name = "Custom"
+        }
+    }
+
+    override fun decode(buffer: RegistryFriendlyByteBuf, buckets: List<SpawnBucket>) {
+        super.decode(buffer, buckets)
+        spawns = buffer.readList { NaturalHabitatSpawn().apply { decode(buffer, buckets) } }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/habitats/NaturalHabitatSpawn.kt

@@ -0,0 +1,63 @@
+/*
+ * 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.habitats
+
+import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
+import com.cobblemon.mod.common.api.spawning.detail.PokemonSpawnDetail
+import com.cobblemon.mod.common.block.habitat.HabitatBlockEntity
+import com.cobblemon.mod.common.util.DataKeys
+import com.cobblemon.mod.common.util.cobblemonResource
+import net.minecraft.nbt.CompoundTag
+import net.minecraft.network.RegistryFriendlyByteBuf
+
+/**
+ * A type of [HabitatSpawn] that spawns Pokémon as part of natural world spawning, and therefore
+ * needs to indicate the [SpawnBucket] it will be part of.
+ *
+ * @author Hiroku
+ * @since February 13th, 2026
+ */
+class NaturalHabitatSpawn : HabitatSpawn() {
+    companion object {
+        val TYPE = cobblemonResource("natural")
+    }
+
+    lateinit var bucket: SpawnBucket
+
+    override fun createSpawnDetail(habitatBlockEntity: HabitatBlockEntity): PokemonSpawnDetail? {
+        val spawnDetail = super.createSpawnDetail(habitatBlockEntity)
+        spawnDetail?.bucket = bucket
+        return spawnDetail
+    }
+
+    override fun writeToNBT(nbt: CompoundTag) {
+        super.writeToNBT(nbt)
+        nbt.putString(DataKeys.HABITAT_POOL_SPAWN_BUCKET, bucket.name)
+    }
+
+    override fun readFromNBT(nbt: CompoundTag) {
+        super.readFromNBT(nbt)
+        bucket = Cobblemon.bestSpawner.config.buckets.first { it.name == nbt.getString(DataKeys.HABITAT_POOL_SPAWN_BUCKET) }
+    }
+
+    override fun encode(buffer: RegistryFriendlyByteBuf) {
+        super.encode(buffer)
+        buffer.writeUtf(bucket.name)
+    }
+
+    override fun decode(
+        buffer: RegistryFriendlyByteBuf,
+        buckets: List<SpawnBucket>
+    ) {
+        super.decode(buffer, buckets)
+        val bucketName = buffer.readUtf()
+        bucket = buckets.first { it.name == bucketName }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/habitats/dto/ActivatedHabitatSettingsDTO.kt

@@ -8,7 +8,9 @@
 
 package com.cobblemon.mod.common.api.habitats.dto
 
+import com.cobblemon.mod.common.api.habitats.ActivatedHabitatPool
 import com.cobblemon.mod.common.api.habitats.spawningstyle.ActivatedHabitatSpawning
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import net.minecraft.network.RegistryFriendlyByteBuf
 
 class ActivatedHabitatSettingsDTO() {
@@ -18,6 +20,7 @@ class ActivatedHabitatSettingsDTO() {
     var spawnRange = 16
     var maxSpawns = -1
     var maxSpawnsPerActivation = 1
+    var habitatPool: HabitatPoolSettingsDTO = HabitatPoolSettingsDTO(ActivatedHabitatPool.default())
 
     constructor(activatedHabitatSpawning: ActivatedHabitatSpawning): this() {
         this.chance = activatedHabitatSpawning.chance
@@ -26,6 +29,7 @@ class ActivatedHabitatSettingsDTO() {
         this.spawnRange = activatedHabitatSpawning.spawnRange
         this.maxSpawns = activatedHabitatSpawning.maxSpawns
         this.maxSpawnsPerActivation = activatedHabitatSpawning.maxSpawnsPerActivation
+        this.habitatPool = HabitatPoolSettingsDTO(activatedHabitatSpawning.pool)
     }
 
     fun encode(buffer: RegistryFriendlyByteBuf) {
@@ -35,14 +39,20 @@ class ActivatedHabitatSettingsDTO() {
         buffer.writeInt(spawnRange)
         buffer.writeInt(maxSpawns)
         buffer.writeInt(maxSpawnsPerActivation)
+        habitatPool.encode(buffer)
     }
 
-    fun decode(buffer: RegistryFriendlyByteBuf) {
+    fun decode(
+        buffer: RegistryFriendlyByteBuf,
+        buckets: List<SpawnBucket>
+    ) {
         this.chance = buffer.readFloat()
         this.trigger = buffer.readEnum(ActivatedHabitatSpawning.Trigger::class.java)
         this.cancelledNaturalSpawningRange = buffer.readInt()
         this.spawnRange = buffer.readInt()
         this.maxSpawns = buffer.readInt()
         this.maxSpawnsPerActivation = buffer.readInt()
+        this.habitatPool = HabitatPoolSettingsDTO()
+        habitatPool.decode(buffer, buckets)
     }
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/habitats/dto/HabitatPoolSettingsDTO.kt

@@ -9,23 +9,30 @@
 package com.cobblemon.mod.common.api.habitats.dto
 
 import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.api.habitats.ActivatedHabitatPool
+import com.cobblemon.mod.common.api.habitats.ActivatedHabitatSpawn
 import com.cobblemon.mod.common.api.habitats.HabitatPool
 import com.cobblemon.mod.common.api.habitats.HabitatPools
 import com.cobblemon.mod.common.api.habitats.HabitatSpawn
+import com.cobblemon.mod.common.api.habitats.NaturalHabitatPool
+import com.cobblemon.mod.common.api.habitats.NaturalHabitatSpawn
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import net.minecraft.network.RegistryFriendlyByteBuf
 import net.minecraft.resources.ResourceLocation
 
 class HabitatPoolSettingsDTO() {
     lateinit var id: ResourceLocation
     var isReference = false
+    var isActivated = false
 
     // Below properties are only there when it's not a reference, otherwise the handler will have to look them up from the id
     var name: String? = null
     var spawns: MutableList<HabitatSpawn>? = null
 
-    constructor(habitatPool: HabitatPool): this() {
+    constructor(habitatPool: HabitatPool<*>): this() {
         this.id = habitatPool.id
         this.isReference = !id.path.startsWith("custom__")
+        this.isActivated = habitatPool is ActivatedHabitatPool
         if (!this.isReference) {
             this.name = habitatPool.name
             this.spawns = habitatPool.spawns.toMutableList()
@@ -35,6 +42,7 @@ class HabitatPoolSettingsDTO() {
     fun encode(buffer: RegistryFriendlyByteBuf) {
         buffer.writeResourceLocation(id)
         buffer.writeBoolean(isReference)
+        buffer.writeBoolean(isActivated)
         if (!isReference) {
             buffer.writeUtf(name!!)
             buffer.writeCollection(spawns!!) { _, spawn ->
@@ -44,32 +52,50 @@ class HabitatPoolSettingsDTO() {
     }
 
     fun decode(
-        buffer: RegistryFriendlyByteBuf
+        buffer: RegistryFriendlyByteBuf,
+        buckets: List<SpawnBucket>
     ) {
         this.id = buffer.readResourceLocation()
         this.isReference = buffer.readBoolean()
+        this.isActivated = buffer.readBoolean()
         if (!isReference) {
             this.name = buffer.readUtf()
             this.spawns = buffer.readList {
-                val spawn = HabitatSpawn()
-                spawn.decode(buffer)
+                val spawn = if (isActivated) {
+                    ActivatedHabitatSpawn()
+                } else {
+                    NaturalHabitatSpawn()
+                }
+                spawn.decode(buffer, buckets)
                 spawn
             }.toMutableList()
         }
     }
 
-    fun toHabitatPool(): HabitatPool? {
+    fun toHabitatPool(): HabitatPool<*>? {
         if (isReference) {
             val pool = HabitatPools.habitatPoolsById[id]
             if (pool == null) {
                 Cobblemon.LOGGER.error("Could not find habitat pool with id $id")
+            } else if (pool is ActivatedHabitatPool && !isActivated) {
+                Cobblemon.LOGGER.error("Pool with id $id is an activated habitat pool but was deserialized as a natural pool")
+            } else if (pool !is ActivatedHabitatPool && isActivated) {
+                Cobblemon.LOGGER.error("Pool with id $id is a natural habitat pool but was deserialized as an activated pool")
             }
             return pool
         }
-        val pool = HabitatPool()
-        pool.id = id
-        pool.name = name!!
-        pool.spawns = spawns!!
-        return pool
+        return if (isActivated) {
+            val pool = ActivatedHabitatPool()
+            pool.id = id
+            pool.name = name!!
+            pool.spawns = spawns!!.map { it as ActivatedHabitatSpawn }
+            pool
+        } else {
+            val pool = NaturalHabitatPool()
+            pool.id = id
+            pool.name = name!!
+            pool.spawns = spawns!!.map { it as NaturalHabitatSpawn }
+            pool
+        }
     }
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/habitats/dto/HabitatSettingsDTO.kt

@@ -9,29 +9,29 @@
 package com.cobblemon.mod.common.api.habitats.dto
 
 import com.cobblemon.mod.common.api.habitats.HabitatPhaseOrder
-import com.cobblemon.mod.common.api.habitats.HabitatPool
 import com.cobblemon.mod.common.api.habitats.spawningstyle.ActivatedHabitatSpawning
 import com.cobblemon.mod.common.api.habitats.spawningstyle.NaturalHabitatSpawning
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.block.habitat.HabitatBlockEntity
 import net.minecraft.network.RegistryFriendlyByteBuf
 import net.minecraft.resources.ResourceLocation
 
 class HabitatSettingsDTO() {
+    var numberOfPhases = 1
     var phaseOrder = HabitatPhaseOrder.SIMPLE
     lateinit var levelRange: IntRange
     var modifiers: String = ""
     lateinit var mimicId: ResourceLocation
     var isActivatedSpawning = false
-    var pool: HabitatPoolSettingsDTO = HabitatPoolSettingsDTO(HabitatPool.default())
     var activatedSettings: ActivatedHabitatSettingsDTO? = null
     var naturalSettings: NaturalHabitatSettingsDTO? = null
 
     constructor(habitatBlockEntity: HabitatBlockEntity) : this() {
+        this.numberOfPhases = habitatBlockEntity.numberOfPhases
         this.phaseOrder = habitatBlockEntity.phaseOrder
         this.levelRange = habitatBlockEntity.levelRange
         this.modifiers = habitatBlockEntity.modifiers.asString()
         this.mimicId = habitatBlockEntity.mimicId
-        this.pool = HabitatPoolSettingsDTO(habitatBlockEntity.pool)
         val style = habitatBlockEntity.spawningStyle
         if (style is ActivatedHabitatSpawning) {
             this.isActivatedSpawning = true
@@ -42,12 +42,12 @@ class HabitatSettingsDTO() {
     }
 
     fun encode(buffer: RegistryFriendlyByteBuf) {
+        buffer.writeInt(numberOfPhases)
         buffer.writeEnum(phaseOrder)
         buffer.writeInt(levelRange.first)
         buffer.writeInt(levelRange.last)
         buffer.writeUtf(modifiers)
         buffer.writeResourceLocation(mimicId)
-        pool.encode(buffer)
         buffer.writeBoolean(isActivatedSpawning)
         if (isActivatedSpawning) {
             activatedSettings?.encode(buffer)
@@ -56,25 +56,27 @@ class HabitatSettingsDTO() {
         }
     }
 
-    fun decode(buffer: RegistryFriendlyByteBuf) {
+    fun decode(
+        buffer: RegistryFriendlyByteBuf,
+        buckets: List<SpawnBucket>
+    ) {
+        this.numberOfPhases = buffer.readInt()
         this.phaseOrder = buffer.readEnum(HabitatPhaseOrder::class.java)
         val levelRangeStart = buffer.readInt()
         val levelRangeEnd = buffer.readInt()
         this.levelRange = levelRangeStart..levelRangeEnd
         this.modifiers = buffer.readUtf()
         this.mimicId = buffer.readResourceLocation()
-        this.pool = HabitatPoolSettingsDTO()
-        this.pool.decode(buffer)
         if (buffer.readBoolean()) {
             this.isActivatedSpawning = true
             this.naturalSettings = null
             val activatedSettings = ActivatedHabitatSettingsDTO()
-            activatedSettings.decode(buffer)
+            activatedSettings.decode(buffer, buckets)
             this.activatedSettings = activatedSettings
         } else {
             this.activatedSettings = null
             val naturalSettings = NaturalHabitatSettingsDTO()
-            naturalSettings.decode(buffer)
+            naturalSettings.decode(buffer, buckets)
             this.naturalSettings = naturalSettings
         }
     }

common/src/main/kotlin/com/cobblemon/mod/common/api/habitats/dto/NaturalHabitatSettingsDTO.kt

@@ -8,25 +8,35 @@
 
 package com.cobblemon.mod.common.api.habitats.dto
 
+import com.cobblemon.mod.common.api.habitats.NaturalHabitatPool
 import com.cobblemon.mod.common.api.habitats.spawningstyle.NaturalHabitatSpawning
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import net.minecraft.network.RegistryFriendlyByteBuf
 
 class NaturalHabitatSettingsDTO() {
     var replaceSpawns = false
     var rangeOfInfluence = 16
+    var habitatPool: HabitatPoolSettingsDTO = HabitatPoolSettingsDTO(NaturalHabitatPool.default())
 
     constructor(naturalHabitatSpawning: NaturalHabitatSpawning): this() {
         this.replaceSpawns = naturalHabitatSpawning.replaceSpawns
         this.rangeOfInfluence = naturalHabitatSpawning.rangeOfInfluence
+        this.habitatPool = HabitatPoolSettingsDTO(naturalHabitatSpawning.pool)
     }
 
     fun encode(buffer: RegistryFriendlyByteBuf) {
         buffer.writeBoolean(replaceSpawns)
         buffer.writeInt(rangeOfInfluence)
+        habitatPool.encode(buffer)
     }
 
-    fun decode(buffer: RegistryFriendlyByteBuf, ) {
+    fun decode(
+        buffer: RegistryFriendlyByteBuf,
+        buckets: List<SpawnBucket>
+    ) {
         this.replaceSpawns = buffer.readBoolean()
         this.rangeOfInfluence = buffer.readInt()
+        this.habitatPool = HabitatPoolSettingsDTO()
+        habitatPool.decode(buffer, buckets)
     }
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/habitats/spawningstyle/ActivatedHabitatSpawning.kt

@@ -8,16 +8,17 @@
 
 package com.cobblemon.mod.common.api.habitats.spawningstyle
 
-import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.api.events.CobblemonEvents
 import com.cobblemon.mod.common.api.events.habitats.HabitatSpawnActivatedEvent
+import com.cobblemon.mod.common.api.habitats.ActivatedHabitatPool
+import com.cobblemon.mod.common.api.habitats.ActivatedHabitatSpawn
 import com.cobblemon.mod.common.api.habitats.ActivatedHabitatSpawningInfluence
 import com.cobblemon.mod.common.api.spawning.SpawnCause
+import com.cobblemon.mod.common.api.spawning.detail.SpawnDetail
 import com.cobblemon.mod.common.api.spawning.detail.SpawnPool
 import com.cobblemon.mod.common.api.spawning.spawner.FixedAreaSpawner
 import com.cobblemon.mod.common.block.habitat.HabitatBlockEntity
 import com.cobblemon.mod.common.util.DataKeys
-import com.cobblemon.mod.common.util.cobblemonResource
 import net.minecraft.core.BlockPos
 import net.minecraft.nbt.CompoundTag
 import net.minecraft.server.level.ServerLevel
@@ -26,7 +27,7 @@ import net.minecraft.server.level.ServerLevel
  * A habitat spawning style defined by being triggered by something. The activation trigger, [trigger], is either
  * a redstone pulse, every tick, or every random tick.
  *
- * The spawn details are generated from the pool every time there is some change to the habitat block's settings,
+ * The spawn details are generated from the [pool] every time there is some change to the habitat block's settings,
  * then those spawn details are used for spawning Pokémon when the habitat block is triggered.
  *
  * The [chance] property is applied after the trigger logic so that not every activation necessarily results in a spawn
@@ -36,10 +37,6 @@ import net.minecraft.server.level.ServerLevel
  * @since February 14th, 2026
  */
 class ActivatedHabitatSpawning(val habitatBlockEntity: HabitatBlockEntity) : HabitatSpawningStyle {
-    companion object {
-        val TYPE = cobblemonResource("activated")
-    }
-
     enum class Trigger {
         /** Requires a redstone pulse. */
         REDSTONE,
@@ -49,8 +46,7 @@ class ActivatedHabitatSpawning(val habitatBlockEntity: HabitatBlockEntity) : Hab
         RANDOM_TICK
     }
 
-    @Transient
-    override val type = TYPE
+    override val type = ActivatedHabitatSpawn.TYPE
 
     /** The chance that an activation by the [trigger] will result in a spawn attempt. The spawn attempt may still fail. */
     var chance = 1F
@@ -64,7 +60,11 @@ class ActivatedHabitatSpawning(val habitatBlockEntity: HabitatBlockEntity) : Hab
     var maxSpawns = -1
     /** The maximum number of Pokémon that can spawn in a single activation. This will still be capped by [maxSpawns]. */
     var maxSpawnsPerActivation = 1
+    /** The pool of spawns to choose from. */
+    var pool: ActivatedHabitatPool = ActivatedHabitatPool.default()
 
+    // This is cached here so that it doesn't have to be regenerated every time the block is triggered, updated when settings change.
+    var spawnDetails: List<SpawnDetail> = listOf()
     lateinit var spawner: FixedAreaSpawner
 
     override fun writeToNBT(nbt: CompoundTag) {
@@ -75,6 +75,10 @@ class ActivatedHabitatSpawning(val habitatBlockEntity: HabitatBlockEntity) : Hab
         nbt.putInt(DataKeys.HABITAT_ACTIVATED_SPAWN_RANGE, spawnRange)
         nbt.putInt(DataKeys.HABITAT_ACTIVATED_MAX_SPAWNS, maxSpawns)
         nbt.putInt(DataKeys.HABITAT_ACTIVATED_MAX_SPAWNS_PER_ACTIVATION, maxSpawnsPerActivation)
+
+        val poolNBT = CompoundTag()
+        writePoolToNBT(pool, poolNBT)
+        nbt.put(DataKeys.HABITAT_POOL, poolNBT)
     }
 
     override fun readFromNBT(nbt: CompoundTag) {
@@ -84,18 +88,25 @@ class ActivatedHabitatSpawning(val habitatBlockEntity: HabitatBlockEntity) : Hab
         spawnRange = nbt.getInt(DataKeys.HABITAT_ACTIVATED_SPAWN_RANGE)
         maxSpawns = nbt.getInt(DataKeys.HABITAT_ACTIVATED_MAX_SPAWNS)
         maxSpawnsPerActivation = nbt.getInt(DataKeys.HABITAT_ACTIVATED_MAX_SPAWNS_PER_ACTIVATION)
+
+        pool = HabitatSpawningStyle.readPoolFromNBT(
+            nbt = nbt.getCompound(DataKeys.HABITAT_POOL),
+            poolInitializer = ::ActivatedHabitatPool,
+            spawnInitializer = ::ActivatedHabitatSpawn,
+            defaultPool = ActivatedHabitatPool::default
+        )
     }
 
     fun generateSpawnDetails(world: ServerLevel, pos: BlockPos) {
+        spawnDetails = pool.createSpawnDetails(habitatBlockEntity)
         spawner = FixedAreaSpawner(
             name = "habitat_spawner_$pos",
             world = world,
             position = pos,
             spawnPool = SpawnPool("habitat_block").also {
-                it.details.addAll(habitatBlockEntity.spawnDetails)
+                it.details.addAll(spawnDetails)
                 it.precalculate()
             },
-            buckets = Cobblemon.bestSpawner.config.activatedHabitatBuckets,
             maxPokemonPerChunk = 16F,
             verticalRadius = spawnRange,
             horizontalRadius = spawnRange
@@ -107,7 +118,7 @@ class ActivatedHabitatSpawning(val habitatBlockEntity: HabitatBlockEntity) : Hab
         // Check if the spawn attempt should even happen based on chance.
         if (chance < 1F && world.random.nextFloat() >= chance) {
             return
-        } else if (habitatBlockEntity.spawnDetails.isEmpty()) {
+        } else if (spawnDetails.isEmpty()) {
             // If there are no spawn details, then there's no point in trying to spawn anything.
             return
         }

common/src/main/kotlin/com/cobblemon/mod/common/api/habitats/spawningstyle/HabitatSpawningStyle.kt

@@ -8,7 +8,15 @@
 
 package com.cobblemon.mod.common.api.habitats.spawningstyle
 
+import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.api.habitats.HabitatPool
+import com.cobblemon.mod.common.api.habitats.HabitatPools
+import com.cobblemon.mod.common.api.habitats.HabitatSpawn
+import com.cobblemon.mod.common.util.DataKeys
+import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
 import net.minecraft.nbt.CompoundTag
+import net.minecraft.nbt.ListTag
+import net.minecraft.nbt.Tag
 import net.minecraft.resources.ResourceLocation
 
 /**
@@ -25,4 +33,47 @@ sealed interface HabitatSpawningStyle {
 
     fun writeToNBT(nbt: CompoundTag)
     fun readFromNBT(nbt: CompoundTag)
+
+    fun writePoolToNBT(pool: HabitatPool<*>, nbt: CompoundTag) {
+        nbt.putString(DataKeys.HABITAT_POOL_ID, pool.id.toString())
+        if (pool.id.path.startsWith("custom__")) {
+            nbt.putString(DataKeys.HABITAT_POOL_NAME, pool.name)
+            val spawnsListNBT = ListTag()
+            for (spawn in pool.spawns) {
+                val spawnTag = CompoundTag()
+                spawn.writeToNBT(spawnTag)
+                spawnsListNBT.add(spawnTag)
+            }
+            nbt.put(DataKeys.HABITAT_POOL_SPAWNS, spawnsListNBT)
+        }
+    }
+    
+    companion object {
+        fun <T : HabitatSpawn, P : HabitatPool<T>> readPoolFromNBT(nbt: CompoundTag, poolInitializer: () -> P, spawnInitializer: () -> T, defaultPool: () -> P): P {
+            var pool: P
+            val poolId = nbt.getString(DataKeys.HABITAT_POOL_ID).asIdentifierDefaultingNamespace()
+            if (nbt.contains(DataKeys.HABITAT_POOL_NAME)) {
+                // It's one that was stored on the block
+                pool = poolInitializer()
+                pool.id = poolId
+                pool.name = nbt.getString(DataKeys.HABITAT_POOL_NAME)
+                val spawnsListNBT = nbt.getList(DataKeys.HABITAT_POOL_SPAWNS, Tag.TAG_COMPOUND.toInt())
+                val spawns = mutableListOf<T>()
+                spawnsListNBT.forEach { spawnTag ->
+                    try {
+                        val spawn = spawnInitializer().apply { readFromNBT(spawnTag as CompoundTag) }
+                        spawns.add(spawn)
+                    } catch (_: Exception) {
+                        // If there's an error reading a spawn, skip it and log the error.
+                        Cobblemon.LOGGER.error("Error reading activated habitat spawn from NBT for habitat block, skipping.")
+                    }
+                }
+                pool.spawns = spawns
+            } else {
+                pool = HabitatPools.habitatPoolsById[poolId] as? P ?: defaultPool()
+            }
+            
+            return pool
+        }
+    }
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/habitats/spawningstyle/NaturalHabitatSpawning.kt

@@ -8,18 +8,21 @@
 
 package com.cobblemon.mod.common.api.habitats.spawningstyle
 
+import com.cobblemon.mod.common.api.habitats.NaturalHabitatPool
+import com.cobblemon.mod.common.api.habitats.NaturalHabitatSpawn
+import com.cobblemon.mod.common.api.habitats.spawningstyle.HabitatSpawningStyle.Companion.readPoolFromNBT
+import com.cobblemon.mod.common.api.spawning.detail.SpawnDetail
 import com.cobblemon.mod.common.block.habitat.HabitatBlockEntity
 import com.cobblemon.mod.common.util.DataKeys
-import com.cobblemon.mod.common.util.cobblemonResource
 import net.minecraft.nbt.CompoundTag
 import net.minecraft.resources.ResourceLocation
 
 /**
  * A habitat spawning style defined by tapping into regular spawning methods. This works by adding to the spawn list
  * for spawning that's occurring nearby. When [replaceSpawns] is set to true, the original spawns will be
- * removed completely in favour of the spawns provided in this habitat's pool.
+ * removed completely in favour of the spawns provided in this habitat's [pool].
  *
- * The spawn details are generated from the pool every time there is some change to the habitat block's settings,
+ * The spawn details are generated from the [pool] every time there is some change to the habitat block's settings,
  * then those spawn details are used for spawning Pokémon when world spawning is occurring nearby.
  *
  * Whether or not this interactions with overworld or fishing spawns is determined by whether the habitat pool has
@@ -29,13 +32,10 @@ import net.minecraft.resources.ResourceLocation
  * @since February 22nd, 2026
  */
 class NaturalHabitatSpawning(val habitatBlockEntity: HabitatBlockEntity) : HabitatSpawningStyle {
-    companion object {
-        val TYPE = cobblemonResource("natural")
-    }
-
     @Transient
-    override val type: ResourceLocation = TYPE
+    override val type: ResourceLocation = NaturalHabitatSpawn.TYPE
 
+    var pool: NaturalHabitatPool = NaturalHabitatPool.default()
     var replaceSpawns = false
     var rangeOfInfluence = 16
 
@@ -43,19 +43,33 @@ class NaturalHabitatSpawning(val habitatBlockEntity: HabitatBlockEntity) : Habit
     var affectsFishing = false
     @Transient
     var affectsOverworld = false
+    @Transient
+    var spawnDetails: List<SpawnDetail> = listOf()
 
     fun generateSpawnDetails() {
-        affectsFishing = habitatBlockEntity.spawnDetails.any { it.spawnablePositionType.name == "fishing" }
-        affectsOverworld = habitatBlockEntity.spawnDetails.any { it.spawnablePositionType.name != "fishing" }
+        spawnDetails = pool.createSpawnDetails(habitatBlockEntity = habitatBlockEntity)
+        affectsFishing = spawnDetails.any { it.spawnablePositionType.name == "fishing" }
+        affectsOverworld = spawnDetails.any { it.spawnablePositionType.name != "fishing" }
     }
 
     override fun writeToNBT(nbt: CompoundTag) {
         nbt.putBoolean(DataKeys.HABITAT_NATURAL_REPLACE_SPAWNS, replaceSpawns)
         nbt.putInt(DataKeys.HABITAT_NATURAL_RANGE_OF_INFLUENCE, rangeOfInfluence)
+
+        val poolNBT = CompoundTag()
+        writePoolToNBT(pool, poolNBT)
+        nbt.put(DataKeys.HABITAT_POOL, poolNBT)
     }
 
     override fun readFromNBT(nbt: CompoundTag) {
         replaceSpawns = nbt.getBoolean(DataKeys.HABITAT_NATURAL_REPLACE_SPAWNS)
         rangeOfInfluence = nbt.getInt(DataKeys.HABITAT_NATURAL_RANGE_OF_INFLUENCE)
+
+        pool = readPoolFromNBT(
+            nbt = nbt.getCompound(DataKeys.HABITAT_POOL),
+            poolInitializer = ::NaturalHabitatPool,
+            spawnInitializer = ::NaturalHabitatSpawn,
+            defaultPool = NaturalHabitatPool::default
+        )
     }
 }

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

@@ -51,15 +51,11 @@ data class PokemonInteractionSet(
 }
 
 data class PokemonInteraction(
+    val grouping: ResourceLocation,
     val requirements: List<Requirement> = listOf(),
     val effects: List<InteractionEffect> = listOf(),
     val cooldown: ExpressionLike = "0".asExpressionLike()
 ) {
-    // Not put as a necessary constructor parameter because then there isn't a default constructor
-    // and that means Gson just gives null for everything in the constructor and falls back to the JSON
-    // properties - completely ignoring the default values above.
-    lateinit var grouping: ResourceLocation
-
     fun encode(buffer: FriendlyByteBuf) {
         buffer.writeResourceLocation(grouping)
         buffer.writeCollection(requirements) { it, requirement ->
@@ -80,12 +76,11 @@ data class PokemonInteraction(
             val cooldown = buffer.readExpressionLike()
 
             return PokemonInteraction(
+                grouping,
                 requirements,
                 effects,
                 cooldown,
-            ).also {
-                it.grouping = grouping
-            }
+            )
         }
     }
 }

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

@@ -38,7 +38,7 @@ import net.minecraft.world.phys.AABB
  * @since July 29th, 2023
  */
 interface PokemonSelectingItem {
-    fun use(player: ServerPlayer, stack: ItemStack, ignoreShift: Boolean = false): InteractionResultHolder<ItemStack> {
+    fun use(player: ServerPlayer, stack: ItemStack): InteractionResultHolder<ItemStack> {
         val range = player.entityInteractionRange()
         val entity = player.level()
             .getEntities(player, AABB.ofSize(player.position(), range, range, range))
@@ -60,7 +60,7 @@ interface PokemonSelectingItem {
                 return interactWithSpecificBattle(player, stack, battlePokemon)
             }
         } ?: run {
-            if (ignoreShift || !player.isShiftKeyDown) {
+            if (!player.isShiftKeyDown) {
                 return if (entity != null) {
                     val pokemon = entity.pokemon
                     if (entity.ownerUUID == player.uuid) {

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

@@ -17,8 +17,6 @@ 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
@@ -46,7 +44,6 @@ import com.cobblemon.mod.common.util.party
 import com.cobblemon.mod.common.util.pc
 import com.cobblemon.mod.common.util.pokedex
 import com.cobblemon.mod.common.util.server
-import com.cobblemon.mod.common.util.tmList
 import net.minecraft.core.registries.BuiltInRegistries
 import net.minecraft.core.registries.Registries
 import net.minecraft.resources.ResourceLocation
@@ -315,23 +312,6 @@ object PlayerMoLangFunctions : AbstractMoLangFunctionHolder<Player>() {
                 }
                 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<*>) {

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

@@ -109,7 +109,7 @@ object PokemonMoLangFunctions : AbstractMoLangFunctionHolder<Pokemon>() {
             DoubleValue(pokemon.species.nationalPokedexNumber.toDouble())
         }
         map["types"] = {
-            pokemon.form.types.map { it.showdownId }.asArrayValue(::StringValue)
+            pokemon.form.types.map { it.toString() }.asArrayValue(::StringValue)
         }
         map["gender_ratio"] = {
             DoubleValue(pokemon.form.maleRatio.toDouble())

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

@@ -49,12 +49,7 @@ class FormDexRecord {
                     it.genders.addAll(genders.map(Gender::valueOf))
                     it.seenShinyStates.addAll(seenShinyStates)
                     it.highestLevel = highestLevel
-                    it.knowledge = when (knowledge) { // The string checks are due to legacy enum names which got changes in 1.8
-                        "NONE" -> PokedexEntryProgress.UNREGISTERED
-                        "ENCOUNTERED" -> PokedexEntryProgress.SEEN
-                        "CAUGHT" -> PokedexEntryProgress.OWNED
-                        else -> PokedexEntryProgress.valueOf(knowledge)
-                    }
+                    it.knowledge = PokedexEntryProgress.valueOf(knowledge)
                 }
             }
         }

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

@@ -25,4 +25,11 @@ enum class PokedexEntryProgress : StringRepresentable, Comparable<PokedexEntryPr
     OWNED;
 
     override fun getSerializedName() = this.name
+    companion object {
+        val CODEC: Codec<PokedexEntryProgress> = RecordCodecBuilder.create { instance ->
+            instance.map ({
+                PokedexEntryProgress.valueOf(it)
+            }, PrimitiveCodec.STRING.fieldOf("name").forGetter { it.name })
+        }
+    }
 }

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

@@ -56,8 +56,10 @@ class AggregatePokedexDef(
             return speciesToEntry.values.toList()
         }
     }
-	
-    fun decode(buffer: RegistryFriendlyByteBuf) {
+
+    override fun shouldSynchronize(other: PokedexDef) = true
+
+    override fun decode(buffer: RegistryFriendlyByteBuf) {
         sortOrder = buffer.readSizedInt(IntSize.U_BYTE)
         val size = buffer.readInt()
         for (i in 0 until size) {
@@ -65,7 +67,7 @@ class AggregatePokedexDef(
         }
     }
 
-    fun encode(buffer: RegistryFriendlyByteBuf) {
+    override fun encode(buffer: RegistryFriendlyByteBuf) {
         buffer.writeSizedInt(IntSize.U_BYTE, sortOrder)
         buffer.writeInt(subDexIds.size)
         subDexIds.forEach {

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

@@ -8,6 +8,8 @@
 
 package com.cobblemon.mod.common.api.pokedex.def
 
+import com.cobblemon.mod.common.api.data.ClientDataSynchronizer
+import com.cobblemon.mod.common.api.pokedex.entry.DexEntries
 import com.cobblemon.mod.common.api.pokedex.entry.PokedexEntry
 import com.mojang.serialization.Codec
 import com.mojang.serialization.MapCodec
@@ -21,7 +23,7 @@ import net.minecraft.resources.ResourceLocation
  * @since August 24, 2024
  * @author Apion
  */
-abstract class PokedexDef {
+abstract class PokedexDef: ClientDataSynchronizer<PokedexDef> {
     //The ID used to find the codecs for this "type" of PokedexDef
     abstract val typeId: ResourceLocation
     //The ID of this dex in the Dexes registry

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

@@ -45,7 +45,9 @@ class SimplePokedexDef(
 
     override fun getEntries() = entries.mapNotNull { DexEntries.entries[it] }
 
-    fun decode(buffer: RegistryFriendlyByteBuf) {
+    override fun shouldSynchronize(other: PokedexDef) = true
+
+    override fun decode(buffer: RegistryFriendlyByteBuf) {
         sortOrder = buffer.readSizedInt(IntSize.U_BYTE)
         val size = buffer.readInt()
         for (i in 0 until size) {
@@ -53,7 +55,7 @@ class SimplePokedexDef(
         }
     }
 
-    fun encode(buffer: RegistryFriendlyByteBuf) {
+    override fun encode(buffer: RegistryFriendlyByteBuf) {
         buffer.writeSizedInt(IntSize.U_BYTE, sortOrder)
         buffer.writeInt(entries.size)
         entries.forEach {

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

@@ -41,18 +41,16 @@ class PokedexCategoryFilter(
             PokedexCategoryFilterType.UNDISCOVERED_TM_MOVE -> hasUndiscoveredLevelUpTM(entry)
             PokedexCategoryFilterType.RIDEABLE -> {
                 val species = PokemonSpecies.getByIdentifier(entry.speciesId)
-                // we were silly as standard forms also can be rideable and we were ingoring those
-                (species?.forms.orEmpty() + listOfNotNull(species?.standardForm)).any { form -> !form.riding.behaviours.isNullOrEmpty() }
-                    && (pokedexManager.getHighestKnowledgeFor(entry) >= PokedexEntryProgress.OWNED ||
-                        pokedexManager.getHighestKnowledgeFor(entry) >= PokedexEntryProgress.SEEN)
+                species?.forms?.any { form -> !form.riding.behaviours.isNullOrEmpty() } == true
+                    && pokedexManager.getHighestKnowledgeFor(entry) >= PokedexEntryProgress.OWNED
             }
         }
     }
 
     private fun hasUndiscoveredLevelUpTM(entry: PokedexEntry): Boolean {
-        if (pokedexManager.getHighestKnowledgeFor(entry) == PokedexEntryProgress.UNREGISTERED) return false
+        if (pokedexManager.getHighestKnowledgeFor(entry) != PokedexEntryProgress.OWNED) return false
         val species = PokemonSpecies.getByIdentifier(entry.speciesId) ?: return false
-        val forms = pokedexManager.getEncounteredForms(entry)
+        val forms = pokedexManager.getCaughtForms(entry)
         val formData = if (forms.isEmpty()) {
             listOf(species.standardForm)
         } else {

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

@@ -72,7 +72,7 @@ class SearchFilter(val pokedexManager: AbstractPokedexManager, val searchString:
                 }
             }
             SearchByType.DROPS -> {
-                if (pokedexManager.getHighestKnowledgeFor(entry) == PokedexEntryProgress.UNREGISTERED) return false
+                if (pokedexManager.getHighestKnowledgeFor(entry) !== PokedexEntryProgress.OWNED) return false
                 val dropsList = mutableListOf<String>()
                 val formsList = if (species.forms.isEmpty()) mutableListOf(species.standardForm) else species.forms
                 formsList.forEach {
@@ -131,7 +131,9 @@ class SearchFilter(val pokedexManager: AbstractPokedexManager, val searchString:
             form.moves.tutorMoves,
             form.moves.eggMoves,
             form.moves.evolutionMoves,
-            form.moves.formChangeMoves
+            form.moves.formChangeMoves,
+            form.moves.specialMoves,
+            form.moves.legacyMoves
         )
 
         for (moves in alwaysDiscovered) {

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

@@ -0,0 +1,15 @@
+package com.cobblemon.mod.common.api.pokedex.scan
+
+object BlockScanDefinition {
+    data class Frame(
+        val slot: Int,
+        val text: ScanText,
+        val scale: Float? = null
+    )
+
+    sealed interface ScanText {
+        data class Literal(val text: String) : ScanText
+        data class Key(val key: String) : ScanText
+        data class Translate(val key: String, val with: List<ScanText> = emptyList()) : ScanText
+    }
+}

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

@@ -0,0 +1,14 @@
+package com.cobblemon.mod.common.api.pokedex.scan
+
+import com.cobblemon.mod.common.pokedex.scanner.block.BlockScanProvider
+import net.minecraft.resources.ResourceLocation
+
+object BlockScanProviderRegistry {
+    private val providers = mutableMapOf<ResourceLocation, BlockScanProvider>()
+
+    fun register(typeId: ResourceLocation, provider: BlockScanProvider) {
+        providers[typeId] = provider
+    }
+
+    fun get(typeId: ResourceLocation): BlockScanProvider? = providers[typeId]
+}

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

@@ -674,6 +674,9 @@ open class PokemonProperties {
     @JvmOverloads
     fun createEntity(world: Level, player: ServerPlayer? = null): PokemonEntity {
         val pokemon = create(player)
+        if (pokemon.isAlpha) {
+            pokemon.initializeMovesetWithRandomTm()
+        }
         return PokemonEntity(world, pokemon).also { applyCustomProperties(it) }
     }
 
@@ -759,7 +762,6 @@ open class PokemonProperties {
         shiny?.let { json.addProperty(DataKeys.POKEMON_SHINY, it) }
         gender?.let { json.addProperty(DataKeys.POKEMON_GENDER, it.name) }
         species?.let { json.addProperty(DataKeys.POKEMON_SPECIES_TEXT, it) }
-        nickname?.let { json.addProperty(DataKeys.POKEMON_NICKNAME, it.string) }
         form?.let { json.addProperty(DataKeys.POKEMON_FORM_ID, it) }
         friendship?.let { json.addProperty(DataKeys.POKEMON_FRIENDSHIP, it) }
         fullness?.let { json.addProperty(DataKeys.POKEMON_FULLNESS, it) }
@@ -796,7 +798,6 @@ open class PokemonProperties {
         shiny = json.get(DataKeys.POKEMON_SHINY)?.asBoolean
         gender = json.get(DataKeys.POKEMON_GENDER)?.asString?.let { Gender.valueOf(it) }
         species = json.get(DataKeys.POKEMON_SPECIES_TEXT)?.asString
-        nickname = json.get(DataKeys.POKEMON_NICKNAME)?.asString?.let(Component::literal)
         form = json.get(DataKeys.POKEMON_FORM_ID)?.asString
         friendship = json.get(DataKeys.POKEMON_FRIENDSHIP)?.asInt
         fullness = json.get(DataKeys.POKEMON_FULLNESS)?.asInt

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

@@ -8,6 +8,7 @@
 
 package com.cobblemon.mod.common.api.pokemon.moves
 
+import com.cobblemon.mod.common.api.data.ClientDataSynchronizer
 import com.cobblemon.mod.common.api.moves.MoveTemplate
 import com.cobblemon.mod.common.api.moves.Moves
 import com.cobblemon.mod.common.net.IntSize
@@ -17,7 +18,7 @@ import com.cobblemon.mod.common.util.writeSizedInt
 import com.google.gson.JsonElement
 import net.minecraft.network.RegistryFriendlyByteBuf
 
-open class Learnset {
+open class Learnset : ClientDataSynchronizer<Learnset> {
     class Interpreter(val loadMove: (JsonElement, Learnset) -> Boolean) {
         companion object {
             fun parseFromPrefixIntoList(prefix: String, list: (Learnset) -> MutableList<MoveTemplate>): Interpreter {
@@ -109,12 +110,10 @@ open class Learnset {
                 evolutionMoves
     }
 
-    // Syncs level up, TM, and egg moves.
-    fun shouldSynchronize(other: Learnset) = other.levelUpMoves != this.levelUpMoves
-            || other.tmMoves != this.tmMoves
-            || other.eggMoves != this.eggMoves
+    // We only sync level up moves atm
+    override fun shouldSynchronize(other: Learnset) = other.levelUpMoves != this.levelUpMoves
 
-    fun decode(buffer: RegistryFriendlyByteBuf) {
+    override fun decode(buffer: RegistryFriendlyByteBuf) {
         this.levelUpMoves.clear()
         repeat(times = buffer.readSizedInt(IntSize.U_BYTE)) {
             val level = buffer.readSizedInt(IntSize.U_SHORT)
@@ -124,11 +123,9 @@ open class Learnset {
             }
             levelUpMoves[level] = moves
         }
-        decodeMoveList(buffer, this.tmMoves)
-        decodeMoveList(buffer, this.eggMoves)
     }
 
-    fun encode(buffer: RegistryFriendlyByteBuf) {
+    override fun encode(buffer: RegistryFriendlyByteBuf) {
         buffer.writeSizedInt(IntSize.U_BYTE, levelUpMoves.size)
         for ((level, moves) in levelUpMoves) {
             buffer.writeSizedInt(IntSize.U_SHORT, level)
@@ -137,21 +134,5 @@ open class Learnset {
                 buffer.writeInt(move.num)
             }
         }
-        encodeMoveList(buffer, this.tmMoves)
-        encodeMoveList(buffer, this.eggMoves)
-    }
-
-    private fun decodeMoveList(buffer: RegistryFriendlyByteBuf, list: MutableList<MoveTemplate>) {
-        list.clear()
-        repeat(times = buffer.readSizedInt(IntSize.U_SHORT)) {
-            Moves.getByNumericalId(buffer.readInt())?.let(list::add)
-        }
-    }
-
-    private fun encodeMoveList(buffer: RegistryFriendlyByteBuf, list: List<MoveTemplate>) {
-        buffer.writeSizedInt(IntSize.U_SHORT, list.size)
-        for (move in list) {
-            buffer.writeInt(move.num)
-        }
     }
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/Seat.kt

@@ -22,8 +22,8 @@ import net.minecraft.network.RegistryFriendlyByteBuf
  */
 data class Seat(
     val locator: String = "",
-    val condition: Expression? = null,
-    val poseAnimations: MutableList<SeatPoseAnimations>? = null,
+    val condition: Expression?,
+    val poseAnimations: MutableList<SeatPoseAnimations>?,
     val handsBusy: Boolean = false,
 ) : Encodable {
 

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/types/air/BirdBehaviour.kt

@@ -40,10 +40,6 @@ import kotlin.math.*
 class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
     companion object {
         val KEY = cobblemonResource("air/bird")
-
-        private const val FLY_POSE_SPEED = 0.1
-        private const val GLIDE_ENTRY_SPEED = 0.19
-        private const val GLIDE_EXIT_SPEED = 0.13
     }
 
     override val key: ResourceLocation = KEY
@@ -53,7 +49,7 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
     }
 
     val poseProvider = PoseProvider<BirdSettings, BirdState>(PoseType.HOVER)
-        .with(PoseOption(PoseType.FLY) { _, state, _ -> state.rideVelocity.get().z > FLY_POSE_SPEED })
+        .with(PoseOption(PoseType.FLY) { _, state, _ -> state.rideVelocity.get().z > 0.2 })
 
     val globalBird: BirdSettings
         get() = CobblemonRideSettings.bird
@@ -196,23 +192,21 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
         }
 
         // speed up and slow down based on input
-        if (driver.zza != 0.0f && state.stamina.get() > 0.0) {
-            activeInput = true
-
-            if (newVelocity.length() < glideTopSpeed) {
-                //make sure it can't exceed top speed
-                val forwardInput = when {
-                    state.stamina.get() == 0.0f -> 0.0
-                    driver.zza > 0 && newVelocity.z > topSpeed -> 0.0
-                    driver.zza < 0 && newVelocity.z < (-topSpeed / 3.0) -> 0.0
-                    else -> driver.zza.sign
-                }
-
-                newVelocity = Vec3(
-                    newVelocity.x,
-                    newVelocity.y,
-                    (newVelocity.z + (accel * forwardInput.toDouble())))
+        if (driver.zza != 0.0f && state.stamina.get() > 0.0 && newVelocity.length() < glideTopSpeed) {
+            //make sure it can't exceed top speed
+            val forwardInput = when {
+                state.stamina.get() == 0.0f -> 0.0
+                driver.zza > 0 && newVelocity.z > topSpeed -> 0.0
+                driver.zza < 0 && newVelocity.z < (-topSpeed / 3.0) -> 0.0
+                else -> driver.zza.sign
             }
+
+            newVelocity = Vec3(
+                newVelocity.x,
+                newVelocity.y,
+                (newVelocity.z + (accel * forwardInput.toDouble())))
+
+            activeInput = true
         }
 
         val controller = (vehicle as? OrientationControllable)?.orientationController
@@ -270,9 +264,11 @@ class BirdBehaviour : RidingBehaviour<BirdSettings, BirdState> {
 
         //Check if the ride should be gliding
         if (driver.isLocalPlayer) {
-            val powered = activeInput && state.stamina.get() > 0.0
-            val requiredSpeed = if (state.gliding.get()) GLIDE_EXIT_SPEED else GLIDE_ENTRY_SPEED
-            state.gliding.set(!powered && newVelocity.z >= requiredSpeed)
+            if ((activeInput && state.stamina.get() > 0.0) || state.rideVelocity.get().z < 0.2) {
+                state.gliding.set(false)
+            } else {
+                state.gliding.set(true)
+            }
         }
 
         //air resistance

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/types/land/HorseBehaviour.kt

@@ -193,7 +193,7 @@ class HorseBehaviour : RidingBehaviour<HorseSettings, HorseState> {
         val newStam = if (state.sprinting.get()) {
             max(0.0f,stam - stamDrainRate)
         } else {
-            min(1.0f,stam + stamDrainRate * 8) // Need to change this to probably be in seconds eventually? idk something that isn't this magic number.
+            min(1.0f,stam + stamDrainRate * 4)
         }
 
         state.stamina.set(newStam.coerceIn(0F, 1F))

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/types/liquid/DolphinBehaviour.kt

@@ -147,7 +147,7 @@ class DolphinBehaviour : RidingBehaviour<DolphinSettings, DolphinState> {
         val stamDrainRate = (1.0f / boostTime).toFloat()
 
         val newStam = if (state.boosting.get()) max(0.0f,stam - stamDrainRate)
-            else (stam + stamDrainRate * 2).coerceIn(0F, 1F)
+            else (stam + stamDrainRate).coerceIn(0F, 1F)
 
         state.stamina.set(newStam)
     }

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

@@ -8,6 +8,7 @@
 
 package com.cobblemon.mod.common.api.snowstorm
 
+import com.cobblemon.mod.common.client.render.shader.CobblemonShaders
 import com.mojang.blaze3d.platform.GlStateManager
 import com.mojang.blaze3d.systems.RenderSystem
 import com.mojang.blaze3d.vertex.BufferBuilder
@@ -15,7 +16,6 @@ import com.mojang.blaze3d.vertex.DefaultVertexFormat
 import com.mojang.blaze3d.vertex.Tesselator
 import com.mojang.blaze3d.vertex.VertexFormat
 import net.minecraft.client.particle.ParticleRenderType
-import net.minecraft.client.renderer.GameRenderer
 import net.minecraft.client.renderer.texture.TextureAtlas
 import net.minecraft.client.renderer.texture.TextureManager
 
@@ -23,9 +23,8 @@ object ParticleMaterials {
     val ALPHA = object : ParticleRenderType {
         override fun begin(tessellator: Tesselator, textureManager: TextureManager): BufferBuilder {
             RenderSystem.enableBlend()
-            RenderSystem.enableCull()
             RenderSystem.depthMask(true)
-            RenderSystem.setShader { GameRenderer.getParticleShader() }
+            RenderSystem.setShader { CobblemonShaders.PARTICLE_CUTOUT }
             RenderSystem.setShaderTexture(0, TextureAtlas.LOCATION_PARTICLES)
             RenderSystem.blendFunc(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA)
             return tessellator.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.PARTICLE)
@@ -37,11 +36,10 @@ object ParticleMaterials {
     val ADD = object : ParticleRenderType {
         override fun begin(tessellator: Tesselator, textureManager: TextureManager): BufferBuilder {
             RenderSystem.enableBlend()
-            RenderSystem.disableCull()
             RenderSystem.depthMask(true)
-            RenderSystem.setShader { GameRenderer.getParticleShader() }
+            RenderSystem.setShader { CobblemonShaders.PARTICLE_BLEND }
             RenderSystem.setShaderTexture(0, TextureAtlas.LOCATION_PARTICLES)
-            RenderSystem.blendFunc(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE)
+            RenderSystem.blendFunc(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA)
             return tessellator.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.PARTICLE)
         }
 
@@ -51,11 +49,10 @@ object ParticleMaterials {
     val BLEND = object : ParticleRenderType {
         override fun begin(tessellator: Tesselator, textureManager: TextureManager): BufferBuilder {
             RenderSystem.enableBlend()
-            RenderSystem.disableCull()
             RenderSystem.depthMask(true)
-            RenderSystem.setShader { GameRenderer.getParticleShader() }
+            RenderSystem.setShader { CobblemonShaders.PARTICLE_BLEND }
             RenderSystem.setShaderTexture(0, TextureAtlas.LOCATION_PARTICLES)
-            RenderSystem.blendFunc(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA)
+            RenderSystem.blendFunc(GlStateManager.SourceFactor.DST_COLOR, GlStateManager.DestFactor.ZERO)
             return tessellator.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.PARTICLE)
         }
 
@@ -65,11 +62,10 @@ object ParticleMaterials {
     val OPAQUE = object : ParticleRenderType {
         override fun begin(tessellator: Tesselator, textureManager: TextureManager): BufferBuilder {
             RenderSystem.enableBlend()
-            RenderSystem.enableCull()
             RenderSystem.depthMask(true)
-            RenderSystem.setShader { GameRenderer.getParticleShader() }
+            RenderSystem.setShader { CobblemonShaders.PARTICLE_BLEND }
             RenderSystem.setShaderTexture(0, TextureAtlas.LOCATION_PARTICLES)
-            RenderSystem.blendFunc(GlStateManager.SourceFactor.SRC_COLOR, GlStateManager.DestFactor.ZERO)
+            RenderSystem.blendFunc(GlStateManager.SourceFactor.ONE, GlStateManager.DestFactor.ONE)
             return tessellator.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.PARTICLE)
         }
 

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

@@ -18,12 +18,12 @@ import com.cobblemon.mod.common.api.spawning.condition.SeafloorSpawningCondition
 import com.cobblemon.mod.common.api.spawning.condition.SpawningCondition
 import com.cobblemon.mod.common.api.spawning.condition.SubmergedSpawningCondition
 import com.cobblemon.mod.common.api.spawning.condition.SurfaceSpawningCondition
-import com.cobblemon.mod.common.api.spawning.detail.EmptySpawnDetail
 import com.cobblemon.mod.common.api.spawning.detail.NPCSpawnDetail
 import com.cobblemon.mod.common.api.spawning.detail.PokemonHerdSpawnDetail
 import com.cobblemon.mod.common.api.spawning.detail.PokemonSpawnDetail
 import com.cobblemon.mod.common.api.spawning.detail.SpawnAction
 import com.cobblemon.mod.common.api.spawning.detail.SpawnDetail
+import com.cobblemon.mod.common.api.spawning.influence.BucketMultiplyingInfluence
 import com.cobblemon.mod.common.api.spawning.influence.SpawningInfluence
 import com.cobblemon.mod.common.api.spawning.position.AreaSpawnablePositionResolver
 import com.cobblemon.mod.common.api.spawning.position.FishingSpawnablePosition
@@ -121,7 +121,6 @@ object BestSpawner {
         SpawnDetail.registerSpawnType(name = PokemonSpawnDetail.TYPE, PokemonSpawnDetail::class.java)
         SpawnDetail.registerSpawnType(name = NPCSpawnDetail.TYPE, NPCSpawnDetail::class.java)
         SpawnDetail.registerSpawnType(name = PokemonHerdSpawnDetail.TYPE, PokemonHerdSpawnDetail::class.java)
-        SpawnDetail.registerSpawnType(name = EmptySpawnDetail.TYPE, EmptySpawnDetail::class.java)
         LOGGER.info("Loaded ${SpawnDetail.spawnDetailTypes.size} spawn detail types.")
 
         loadConfig()

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

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.spawning
+
+/**
+ * A spawn bucket is a simple referenceable object by spawn files. The bucket is used at the beginning of
+ * the selection process to decide which set of spawns will be used for spawning on that attempt. Weights are used to
+ * make entire buckets more or less likely, and then weighted selections will occur within whichever bucket
+ * was chosen.
+ *
+ * Spawn buckets are configured in the main config.
+ *
+ * @author Hiroku
+ * @since June 20th, 2022
+ */
+class SpawnBucket() {
+    lateinit var name: String
+    var weight = 0F
+
+    constructor(name: String, weight: Float): this() {
+        this.name = name
+        this.weight = weight
+    }
+
+    override fun hashCode() = name.hashCode()
+    override fun equals(other: Any?) = other is SpawnBucket && other.name == name
+}

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

@@ -49,6 +49,7 @@ object SpawnDetailPresets : JsonDataRegistry<SpawnDetailPreset> {
         .setPrettyPrinting()
         .setLenient()
         .disableHtmlEscaping()
+        .registerTypeAdapter(SpawnBucket::class.java, SpawnBucketAdapter)
         .registerTypeAdapter(SpawnablePositionType::class.java, RegisteredSpawnablePositionAdapter)
         .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Biome::class.java).type, BiomeLikeConditionAdapter)
         .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Block::class.java).type, BlockLikeConditionAdapter)

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

@@ -67,6 +67,7 @@ object SpawnLoader {
         .registerTypeAdapter(MoonPhaseRange::class.java, IntRangesAdapter(MoonPhaseRange.moonPhaseRanges) { MoonPhaseRange(*it) })
         .registerTypeAdapter(ItemDropMethod::class.java, ItemDropMethod.adapter)
         .registerTypeAdapter(PokemonProperties::class.java, pokemonPropertiesShortAdapter)
+        .registerTypeAdapter(SpawnBucket::class.java, SpawnBucketAdapter)
         .registerTypeAdapter(CompoundTag::class.java, NbtCompoundAdapter)
         .registerTypeAdapter(IntRange::class.java, IntRangeAdapter)
         .registerTypeAdapter(PossibleHeldItem::class.java, PossibleHeldItemAdapter)

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

@@ -12,7 +12,6 @@ import com.cobblemon.mod.common.api.conditional.RegistryLikeCondition
 import com.cobblemon.mod.common.api.spawning.MoonPhaseRange
 import com.cobblemon.mod.common.api.spawning.TimeRange
 import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
-import com.cobblemon.mod.common.block.entity.PokeSnackBlockEntity
 import com.cobblemon.mod.common.util.Merger
 import com.cobblemon.mod.common.util.math.orMax
 import com.cobblemon.mod.common.util.math.orMin
@@ -60,7 +59,6 @@ abstract class SpawningCondition<T : SpawnablePosition> {
     var structures: MutableList<Either<ResourceLocation, TagKey<Structure>>>? = null
     var isSlimeChunk: Boolean? = null
     var markers: MutableList<String>? = null
-    var isPokeSnack: Boolean? = null
 
     @Transient
     var appendages = mutableListOf<AppendageCondition>()
@@ -77,9 +75,7 @@ abstract class SpawningCondition<T : SpawnablePosition> {
     }
 
     protected open fun fits(spawnablePosition: T): Boolean {
-        if (isPokeSnack != null && (spawnablePosition.spawner is PokeSnackBlockEntity.Spawner != isPokeSnack!!)) {
-            return false
-        } else if (spawnablePosition.position.x < minX.orMin() || spawnablePosition.position.x > maxX.orMax()) {
+        if (spawnablePosition.position.x < minX.orMin() || spawnablePosition.position.x > maxX.orMax()) {
             return false
         } else if (spawnablePosition.position.y < minY.orMin() || spawnablePosition.position.y > maxY.orMax()) {
             return false

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

@@ -8,9 +8,10 @@
 
 package com.cobblemon.mod.common.api.spawning.condition
 
-import com.cobblemon.mod.common.api.spawning.detail.SpawnDetail
-import com.cobblemon.mod.common.api.spawning.detail.SpawnPool
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
+import com.cobblemon.mod.common.api.spawning.detail.SpawnDetail
+import com.cobblemon.mod.common.api.spawning.spawner.Spawner
 import net.minecraft.resources.ResourceLocation
 
 /**
@@ -21,8 +22,8 @@ import net.minecraft.resources.ResourceLocation
  * time as sharing that value. The requirement of implementations is only to get that
  * key from both a [SpawnDetail] and a [SpawnablePosition].
  *
- * When a precalculation has been registered with a [SpawnPool] by adding to [SpawnPool.precalculators],
- * the precalculation result will need to be updated by running [SpawnPool.precalculate]. That
+ * When a precalculation has been registered with a [Spawner] by adding to [Spawner.precalculators],
+ * the precalculation result will need to be updated by running [Spawner.precalculate]. That
  * might take it a hot minute, but the result will be that there is an extra layer of
  * shortcutting to the matching algorithm.
  *
@@ -33,7 +34,7 @@ interface SpawningPrecalculation<T : Any> {
     /** Retrieves the precalculation keys for the given spawn detail. */
     fun select(detail: SpawnDetail): Collection<T>
     /** Retrieves the precalculation key for the given spawnable position, if that key exists for this position. */
-    fun select(bucket: String, spawnablePosition: SpawnablePosition): T?
+    fun select(bucket: SpawnBucket, spawnablePosition: SpawnablePosition): T?
 
     /**
      * Generates a precalculation result for the list of [SpawnDetail]s and the subsequent precalculations.
@@ -73,7 +74,7 @@ interface SpawningPrecalculation<T : Any> {
 object RootPrecalculation : SpawningPrecalculation<Any> {
     val list = listOf(Unit)
     override fun select(detail: SpawnDetail): List<Any> = list
-    override fun select(bucket: String, spawnablePosition: SpawnablePosition): Any = Unit
+    override fun select(bucket: SpawnBucket, spawnablePosition: SpawnablePosition): Any = Unit
 }
 
 /**
@@ -84,12 +85,12 @@ object RootPrecalculation : SpawningPrecalculation<Any> {
  */
 object SpawnablePositionTypePrecalculation : SpawningPrecalculation<Class<out SpawnablePosition>> {
     override fun select(detail: SpawnDetail) = listOf(detail.spawnablePositionType.clazz)
-    override fun select(bucket: String, spawnablePosition: SpawnablePosition) = spawnablePosition::class.java
+    override fun select(bucket: SpawnBucket, spawnablePosition: SpawnablePosition) = spawnablePosition::class.java
 }
 
-object BucketPrecalculation : SpawningPrecalculation<String> {
+object BucketPrecalculation : SpawningPrecalculation<SpawnBucket> {
     override fun select(detail: SpawnDetail) = listOf(detail.bucket)
-    override fun select(bucket: String, spawnablePosition: SpawnablePosition) = bucket
+    override fun select(bucket: SpawnBucket, spawnablePosition: SpawnablePosition) = bucket
 }
 
 /**
@@ -98,7 +99,7 @@ object BucketPrecalculation : SpawningPrecalculation<String> {
  */
 object BiomePrecalculation : SpawningPrecalculation<ResourceLocation> {
     override fun select(detail: SpawnDetail) = detail.validBiomes
-    override fun select(bucket: String, spawnablePosition: SpawnablePosition) = spawnablePosition.biomeHolder.unwrapKey().map { it.location() }.orElse(null)
+    override fun select(bucket: SpawnBucket, spawnablePosition: SpawnablePosition) = spawnablePosition.biomeHolder.unwrapKey().map { it.location() }.orElse(null)
 }
 
 /**
@@ -113,7 +114,7 @@ sealed class PrecalculationResult<T : Any>(
     val calculation: SpawningPrecalculation<*>
 ) {
     /** Gets the list of spawn details that fit this spawnable position. */
-    abstract fun retrieve(bucket: String, spawnablePosition: SpawnablePosition): List<SpawnDetail>
+    abstract fun retrieve(bucket: SpawnBucket, spawnablePosition: SpawnablePosition): List<SpawnDetail>
 }
 
 /**
@@ -126,7 +127,7 @@ class NestedPrecalculationResult<T : Any>(
     calculation: SpawningPrecalculation<T>,
     val mapping: Map<T, PrecalculationResult<*>> = mutableMapOf()
 ) : PrecalculationResult<T>(calculation) {
-    override fun retrieve(bucket: String, spawnablePosition: SpawnablePosition) = mapping[calculation.select(bucket, spawnablePosition)]?.retrieve(bucket, spawnablePosition) ?: emptyList()
+    override fun retrieve(bucket: SpawnBucket, spawnablePosition: SpawnablePosition) = mapping[calculation.select(bucket, spawnablePosition)]?.retrieve(bucket, spawnablePosition) ?: emptyList()
 }
 
 /**
@@ -140,5 +141,5 @@ class FinalPrecalculationResult<T : Any>(
     calculation: SpawningPrecalculation<*>,
     val mapping: Map<T, List<SpawnDetail>>
 ) : PrecalculationResult<T>(calculation) {
-    override fun retrieve(bucket: String, spawnablePosition: SpawnablePosition) = mapping[calculation.select(bucket, spawnablePosition)] ?: emptyList()
+    override fun retrieve(bucket: SpawnBucket, spawnablePosition: SpawnablePosition) = mapping[calculation.select(bucket, spawnablePosition)] ?: emptyList()
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/detail/EmptySpawnAction.kt

@@ -1,25 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.api.spawning.detail
-
-import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
-
-/**
- * Does a whole lot of nothing. Spawns nothing.
- *
- * @author Hiroku
- * @since May 16th, 2026
- */
-class EmptySpawnAction(
-    spawnablePosition: SpawnablePosition,
-    bucket: String,
-    detail: EmptySpawnDetail
-) : SpawnAction<Unit>(spawnablePosition, bucket, detail) {
-    override fun run() {}
-}

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/detail/EmptySpawnDetail.kt

@@ -1,49 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.api.spawning.detail
-
-import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
-import com.cobblemon.mod.common.api.spawning.selection.SpawnSelectionData
-
-/**
- * A spawn detail for nothing. It is used to take a slot, like to weigh down a spawn attempt,
- * with something that ultimately doesn't spawn anything.
- *
- * The use case for this is very niche. With 1.8, the buckets that can be selected by a spawner
- * during a spawn attempt will be narrowed down to the buckets that are used by the spawn
- * pool. That means that if a bucket is never used by the pool, it will never be selected. That
- * way, a bucket won't be selected when it never had any chance of being selected. This is what
- * you would want in almost every case.
- *
- * However, in some cases you may want spawning to not spawn anything or you may want to preserve
- * the relative rarity of the other buckets, and in that case you'd put something like this in a
- * bucket so that it technically exists in the spawn pool without actually resulting in a spawned
- * entity.
- *
- * @author Hiroku
- * @since May 16th, 2026
- */
-class EmptySpawnDetail : SpawnDetail() {
-    companion object {
-        val TYPE = "empty"
-        val EMPTY = EmptySpawnDetail()
-    }
-
-    override val type: String = TYPE
-
-    override fun createSpawnAction(
-        spawnablePosition: SpawnablePosition,
-        bucket: String,
-        selectionData: SpawnSelectionData
-    ) = EmptySpawnAction(
-        spawnablePosition = spawnablePosition,
-        bucket = bucket,
-        detail = this
-    )
-}

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/detail/NPCSpawnAction.kt

@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.api.spawning.detail
 
 import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
 import com.cobblemon.mod.common.entity.npc.NPCEntity
 import com.cobblemon.mod.common.util.resolveInt
@@ -19,7 +20,7 @@ import com.cobblemon.mod.common.util.resolveInt
  * @author Hiroku
  * @since October 8th, 2023
  */
-class NPCSpawnAction(spawnablePosition: SpawnablePosition, bucket: String, override val detail: NPCSpawnDetail) : SingleEntitySpawnAction<NPCEntity>(spawnablePosition, bucket, detail) {
+class NPCSpawnAction(spawnablePosition: SpawnablePosition, bucket: SpawnBucket, override val detail: NPCSpawnDetail) : SingleEntitySpawnAction<NPCEntity>(spawnablePosition, bucket, detail) {
     override fun createEntity(): NPCEntity {
         val npc = NPCEntity(spawnablePosition.world)
         npc.npc = detail.npcClass

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/detail/NPCSpawnDetail.kt

@@ -11,11 +11,13 @@ package com.cobblemon.mod.common.api.spawning.detail
 import com.bedrockk.molang.Expression
 import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.npc.NPCClass
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
 import com.cobblemon.mod.common.api.spawning.selection.SpawnSelectionData
 import com.cobblemon.mod.common.entity.npc.NPCEntity
 import com.cobblemon.mod.common.util.asExpression
 import com.google.gson.annotations.SerializedName
+import kotlin.math.ceil
 
 /**
  * A [SpawnDetail] describing an [NPCEntity] spawn.
@@ -49,7 +51,7 @@ class NPCSpawnDetail : SpawnDetail() {
 
     override fun createSpawnAction(
         spawnablePosition: SpawnablePosition,
-        bucket: String,
+        bucket: SpawnBucket,
         selectionData: SpawnSelectionData
     ) = NPCSpawnAction(spawnablePosition, bucket, this)
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/detail/PokemonHerdSpawnDetail.kt

@@ -11,19 +11,15 @@ package com.cobblemon.mod.common.api.spawning.detail
 import com.cobblemon.mod.common.Cobblemon.LOGGER
 import com.cobblemon.mod.common.api.drop.DropTable
 import com.cobblemon.mod.common.api.pokemon.PokemonProperties
-import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
-import com.cobblemon.mod.common.api.spawning.position.AreaSpawnablePosition
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
 import com.cobblemon.mod.common.api.spawning.selection.SpawnSelectionData
-import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
 import com.cobblemon.mod.common.util.weightedSelection
 import com.google.gson.annotations.SerializedName
 import net.minecraft.core.registries.Registries
 import net.minecraft.resources.ResourceLocation
-import net.minecraft.util.Mth.clamp
 import net.minecraft.world.item.ItemStack
 import net.minecraft.world.item.Items
-import kotlin.math.ceil
 
 /**
  * A spawn detail that spawns a herd of Pokémon. This relies on the same [PokemonSpawnAction]s as
@@ -41,6 +37,7 @@ import kotlin.math.ceil
 class PokemonHerdSpawnDetail : SpawnDetail() {
     companion object {
         val TYPE = "pokemon-herd"
+        const val HERD_LEADER = "leader"
     }
 
     override val type: String = TYPE
@@ -54,14 +51,12 @@ class PokemonHerdSpawnDetail : SpawnDetail() {
         get() = "${id}__LEVEL"
 
     class Herdable {
-        var pokemon = PokemonProperties()
+        var pokemon: PokemonProperties = PokemonProperties()
         val levelRange: IntRange? = null
         var levelRangeOffset: IntRange? = null
-        val herdLevelRange: IntRange? = null
         var dropTable: DropTable? = null
-        var isLeader = false
-        var isFollower = true
-        var weight = 1F
+        var isLeader: Boolean? = null
+        var weight: Float = 1F
         var maxTimes = 10
         var heldItem: ResourceLocation? = null
     }
@@ -73,23 +68,22 @@ class PokemonHerdSpawnDetail : SpawnDetail() {
         selectionData: SpawnSelectionData
     ) {
         selectionData.removeSpawnDetails { it != this }
-        selectionData.guaranteedBucket = bucket
         selectionData.removeSpawnablePositions { _, pos -> pos.distanceTo(spawnablePosition) < minDistanceBetweenSpawns }
 
         val herdSpawnCount = selectionData.spawnActions.count { it.detail == this } + 1
-        val lacksPossibleLeader = lacksPossibleLeader(selectionData)
 
-        if (herdSpawnCount >= maxHerdSize || getValidHerdMembersForRole(selectionData, useLeaderRole = lacksPossibleLeader).isEmpty()) {
+        if (herdSpawnCount >= maxHerdSize || getValidHerdMembers(selectionData).isEmpty()) {
             // We can't spawn any more in the herd so remove this spawn from the selection pool.
             selectionData.removeSpawnDetails { it == this }
         }
     }
 
     fun lacksPossibleLeader(selectionData: SpawnSelectionData): Boolean {
+        val level = getOrSetHerdLevel(selectionData)
         val herdable = getValidHerdMembers(selectionData)
         val herdCounts = getHerdMemberCounts(selectionData)
 
-        val leaderIsPossible = herdable.any { it.isLeader }
+        val leaderIsPossible = herdable.any { it.levelRange?.contains(level) != false && it.isLeader == true }
         val leaderIsSelected = herdCounts.any { it.key?.isLeader == true && it.value > 0 }
         return leaderIsPossible && !leaderIsSelected
     }
@@ -98,42 +92,23 @@ class PokemonHerdSpawnDetail : SpawnDetail() {
         return (selectionData.context[herdLevelKey] as? Int) ?: run {
             val level = levelRange.random()
             selectionData.context[herdLevelKey] = level
-            level
+            return level
         }
     }
 
-    private fun getValidHerdMembersForRole(selectionData: SpawnSelectionData, useLeaderRole: Boolean): List<Herdable> {
-        return getValidHerdMembers(selectionData).filter { (useLeaderRole && it.isLeader) || (!useLeaderRole && it.isFollower) }
-    }
-
     override fun createSpawnAction(
         spawnablePosition: SpawnablePosition,
-        bucket: String,
+        bucket: SpawnBucket,
         selectionData: SpawnSelectionData
-    ): SpawnAction<*> {
-        val herdable = getValidHerdMembersForRole(
-            selectionData = selectionData,
-            useLeaderRole = lacksPossibleLeader(selectionData)
-        ).weightedSelection { it.weight } ?: herdablePokemon[0]
-
-        var level = selectionData.context[herdLevelKey] as? Int ?: 1
-
-        // Attempt to do more detailed anti-wall-spawn logic. Herd members could spawn in walls because
-        // we've just been assuming they're 1 block wide (or at least, all in the herd have the same size).
-        // Some pokemon are not that though.
-        if (spawnablePosition is AreaSpawnablePosition) {
-            val species = herdable.pokemon.species?.let { PokemonSpecies.getByIdentifier(it.asIdentifierDefaultingNamespace()) }
-            if (species != null) {
-                val height = ceil(species.hitbox.height * species.baseScale).toInt()
-                val width = ceil(species.hitbox.width * species.baseScale).toInt()
-                if (!spawnablePosition.hasSpace(width, height)) {
-                    return EmptySpawnAction(spawnablePosition, bucket, EmptySpawnDetail.EMPTY)
-                }
-            }
-        }
-
-        level = herdable.levelRange?.let { clamp(level, it.first, it.last) } ?: level
+    ): PokemonSpawnAction {
+        val validHerdMembers = getValidHerdMembers(selectionData)
+        val herdable = if (lacksPossibleLeader(selectionData)) {
+            validHerdMembers.filter { it.isLeader == true }
+        } else {
+            validHerdMembers
+        }.weightedSelection { it.weight } ?: herdablePokemon[0]
 
+        val level = selectionData.context[herdLevelKey] as? Int ?: 1
         val levelRange = herdable.levelRangeOffset?.let { offset ->
             val min = level + offset.first
             val max = level + offset.last
@@ -158,7 +133,11 @@ class PokemonHerdSpawnDetail : SpawnDetail() {
             drops = herdable.dropTable,
             heldItem = heldItem,
             levelRange = levelRange
-        )
+        ).also {
+            if (herdable.isLeader == true) {
+                it.labels += HERD_LEADER
+            }
+        }
     }
 
     fun getHerdMemberCounts(selectionData: SpawnSelectionData): Map<Herdable?, Int> {
@@ -174,7 +153,7 @@ class PokemonHerdSpawnDetail : SpawnDetail() {
             val count = counts[herdable] ?: 0
             return@filter when {
                 count >= herdable.maxTimes -> false
-                herdable.herdLevelRange != null && level !in herdable.herdLevelRange -> false
+                herdable.levelRange != null && level !in herdable.levelRange -> false
                 else -> true
             }
         }

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/detail/PokemonSpawnAction.kt

@@ -11,6 +11,7 @@ package com.cobblemon.mod.common.api.spawning.detail
 import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.api.drop.DropTable
 import com.cobblemon.mod.common.api.pokemon.PokemonProperties
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.pokemon.feature.SeasonFeatureHandler
@@ -25,7 +26,7 @@ import net.minecraft.world.item.ItemStack
  */
 class PokemonSpawnAction(
     spawnablePosition: SpawnablePosition,
-    bucket: String,
+    bucket: SpawnBucket,
     override val detail: SpawnDetail,
     /**
      * The [PokemonProperties] that are about to be used. When using it, a copy will be taken.

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/detail/PokemonSpawnDetail.kt

@@ -14,6 +14,7 @@ import com.cobblemon.mod.common.api.drop.DropTable
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.api.pokemon.PokemonProperties
 import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
 import com.cobblemon.mod.common.api.spawning.selection.SpawnSelectionData
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
@@ -103,8 +104,7 @@ class PokemonSpawnDetail : SpawnDetail() {
     }
 
     override fun createSpawnAction(
-        spawnablePosition: SpawnablePosition,
-        bucket: String,
+        spawnablePosition: SpawnablePosition, bucket: SpawnBucket,
         selectionData: SpawnSelectionData
     ): SingleEntitySpawnAction<PokemonEntity> {
         val levelRange = pokemon.deriveLevelRange(levelRange)

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/detail/SingleEntitySpawnAction.kt

@@ -11,6 +11,7 @@ package com.cobblemon.mod.common.api.spawning.detail
 import com.cobblemon.mod.common.api.events.CobblemonEvents
 import com.cobblemon.mod.common.api.events.entity.SpawnEvent
 import com.cobblemon.mod.common.api.reactive.SimpleObservable
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
 import com.cobblemon.mod.common.util.toVec3d
 import net.minecraft.world.entity.Entity
@@ -25,7 +26,7 @@ import net.minecraft.world.entity.MobSpawnType
  */
 abstract class SingleEntitySpawnAction<T : Entity>(
     spawnablePosition: SpawnablePosition,
-    bucket: String,
+    bucket: SpawnBucket,
     detail: SpawnDetail
 ) : SpawnAction<EntitySpawnResult>(spawnablePosition, bucket, detail) {
     abstract fun createEntity(): T?

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/detail/SpawnAction.kt

@@ -8,6 +8,7 @@
 
 package com.cobblemon.mod.common.api.spawning.detail
 
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
 import java.util.concurrent.CompletableFuture
 
@@ -20,7 +21,7 @@ import java.util.concurrent.CompletableFuture
  */
 abstract class SpawnAction<R>(
     val spawnablePosition: SpawnablePosition,
-    val bucket: String,
+    val bucket: SpawnBucket,
     open val detail: SpawnDetail
 ) {
     val labels = mutableListOf<String>()

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/detail/SpawnDetail.kt

@@ -15,6 +15,7 @@ import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.Cobblemon.LOGGER
 import com.cobblemon.mod.common.api.ModDependant
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.queryStructOf
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.condition.CompositeSpawningCondition
 import com.cobblemon.mod.common.api.spawning.condition.SpawningCondition
 import com.cobblemon.mod.common.api.spawning.multiplier.WeightMultiplier
@@ -53,7 +54,7 @@ abstract class SpawnDetail : ModDependant {
     var displayName: String? = null
     @SerializedName("spawnablePositionType", alternate = ["context"])
     lateinit var spawnablePositionType: SpawnablePositionType<*>
-    var bucket = ""
+    var bucket = SpawnBucket("", 0F)
     var conditions = mutableListOf<SpawningCondition<*>>()
     var anticonditions = mutableListOf<SpawningCondition<*>>()
     var compositeCondition: CompositeSpawningCondition? = null
@@ -78,7 +79,7 @@ abstract class SpawnDetail : ModDependant {
         "weight" to { DoubleValue(weight) },
         "percentage" to { DoubleValue(percentage) },
         "id" to { StringValue(id) },
-        "bucket" to { StringValue(bucket) },
+        "bucket" to { StringValue(bucket.name) },
         "width" to { DoubleValue(width.toDouble()) },
         "height" to { DoubleValue(height.toDouble()) },
         "spawnable_position_type" to { StringValue(spawnablePositionType.name) },
@@ -135,10 +136,6 @@ abstract class SpawnDetail : ModDependant {
             containsNullValues = true
             LOGGER.error("Spawn Detail with id $id is invalid as it contains invalid values in its anticonditions (commonly caused by trailing comma in biomes or other arrays)")
         }
-        if (bucket.isBlank()) {
-            containsNullValues = true
-            LOGGER.error("Spawn Detail with id $id is invalid as it does not have a bucket assigned")
-        }
         return super.isModDependencySatisfied() && !containsNullValues
     }
 
@@ -166,7 +163,7 @@ abstract class SpawnDetail : ModDependant {
      */
     fun choose(
         spawnablePosition: SpawnablePosition,
-        bucket: String,
+        bucket: SpawnBucket,
         selectionData: SpawnSelectionData
     ): SpawnAction<*> {
         val action = createSpawnAction(spawnablePosition, bucket, selectionData)
@@ -178,10 +175,10 @@ abstract class SpawnDetail : ModDependant {
         return action
     }
 
-    /** Instantiates an action at the given [SpawnablePosition] for the given spawn bucket. */
+    /** Instantiates an action at the given [SpawnablePosition] for the given [SpawnBucket]. */
     protected abstract fun createSpawnAction(
         spawnablePosition: SpawnablePosition,
-        bucket: String,
+        bucket: SpawnBucket,
         selectionData: SpawnSelectionData
     ): SpawnAction<*>
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/detail/SpawnPool.kt

@@ -11,6 +11,7 @@ package com.cobblemon.mod.common.api.spawning.detail
 import com.cobblemon.mod.common.api.data.JsonDataRegistry
 import com.cobblemon.mod.common.api.reactive.SimpleObservable
 import com.cobblemon.mod.common.api.spawning.CobblemonSpawnPools
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.SpawnLoader
 import com.cobblemon.mod.common.api.spawning.SpawnSet
 import com.cobblemon.mod.common.api.spawning.condition.PrecalculationResult
@@ -60,13 +61,12 @@ class SpawnPool(val name: String) : JsonDataRegistry<SpawnSet>, Iterable<SpawnDe
     }
 
     val details = mutableListOf<SpawnDetail>()
-    /** Tracks which buckets are in use by the pool, to prevent spawners for rolling buckets that don't exist. */
-    val buckets = mutableListOf<String>()
     var precalculation: PrecalculationResult<*> = RootPrecalculation.generate(details, emptyList())
     val precalculators = mutableListOf<SpawningPrecalculation<*>>()
 
     override fun iterator() = details.iterator()
 
+
     fun addPrecalculators(vararg precalculators: SpawningPrecalculation<*>): SpawnPool {
         this.precalculators.addAll(precalculators)
         precalculate()
@@ -88,9 +88,6 @@ class SpawnPool(val name: String) : JsonDataRegistry<SpawnSet>, Iterable<SpawnDe
      * be slow, especially if there are many precalculators and spawns.
      */
     fun precalculate() {
-        buckets.clear()
-        buckets.addAll(details.asSequence().map(SpawnDetail::bucket).distinct())
-
         if (precalculators.isEmpty()) {
             precalculation = RootPrecalculation.generate(details, emptyList())
         } else {
@@ -106,7 +103,7 @@ class SpawnPool(val name: String) : JsonDataRegistry<SpawnSet>, Iterable<SpawnDe
      * to leverage the precalculation to get a smaller list of spawns as quickly
      * as possible.
      */
-    fun retrieve(bucket: String, spawnablePosition: SpawnablePosition): List<SpawnDetail> {
+    fun retrieve(bucket: SpawnBucket, spawnablePosition: SpawnablePosition): List<SpawnDetail> {
         return precalculation.retrieve(bucket, spawnablePosition)
     }
 

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

@@ -145,7 +145,7 @@ class FishingSpawnCause(
                 return
             }
             pokemonEntity.pokemon.isAlpha = true
-            pokemonEntity.pokemon.initializeMovesetFromDefault()
+            pokemonEntity.pokemon.initializeMovesetWithRandomTm(2)
             if (!pokemonEntity.level().isClientSide) {
                 // Alpha status is applied after entity creation in bait flows, so rebuild the brain
                 // to ensure alpha-only sensors/memories are actually attached.

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

@@ -8,19 +8,19 @@
 
 package com.cobblemon.mod.common.api.spawning.influence
 
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
+
 /**
  * A [SpawningInfluence] that multiplies bucket weights by the provided values
  * and then normalizes the resulting weights so that their total adds up to 100.
- *
- * No longer used by the mod, but kept for external suers.
  */
 class BucketMultiplyingInfluence(
     val multipliers: Map<String, Float>,
 ) : SpawningInfluence {
-    override fun affectBucketWeights(bucketWeights: MutableMap<String, Float>) {
-        val updates = mutableMapOf<String, Float>()
+    override fun affectBucketWeights(bucketWeights: MutableMap<SpawnBucket, Float>) {
+        val updates = mutableMapOf<SpawnBucket, Float>()
         for ((bucket, weight) in bucketWeights) {
-            val multiplier = multipliers[bucket]
+            val multiplier = multipliers[bucket.name]
             if (multiplier != null) {
                 updates[bucket] = weight * multiplier
             }

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

@@ -8,6 +8,7 @@
 
 package com.cobblemon.mod.common.api.spawning.influence
 
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import kotlin.math.pow
 
 /**
@@ -32,7 +33,7 @@ open class BucketNormalizingInfluence(
     val gradient: Float = 0.2F,
     val firstTier: Float = 1.29F
 ) : SpawningInfluence {
-    override fun affectBucketWeights(bucketWeights: MutableMap<String, Float>) {
+    override fun affectBucketWeights(bucketWeights: MutableMap<SpawnBucket, Float>) {
         if (tier == 0) {
             return
         }

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

@@ -150,7 +150,7 @@ class SaccharineLogSlatheredInfluence(val pos: BlockPos? = null) : SpawningInflu
         val chance = Cobblemon.config.honeySlatherAlphaChance
         if (chance > 0 && Random.nextInt(chance) == 0) {
             pokemon.isAlpha = true
-            pokemon.initializeMovesetFromDefault()
+            pokemon.initializeMovesetWithRandomTm(2)
         }
     }
 

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

@@ -21,8 +21,6 @@ import com.cobblemon.mod.common.api.spawning.detail.SpawnDetail
 import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
 import com.cobblemon.mod.common.api.types.ElementalTypes
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.entity.pokemon.ai.sensors.AlphaLevelMatchingSensor
-import net.minecraft.server.level.ServerPlayer
 import net.minecraft.world.entity.Entity
 
 /**
@@ -49,13 +47,6 @@ open class SpawnBaitInfluence(val effects: List<SpawnBait.Effect>, val onUsed: (
                     Effects.getEffectFunction(effect.type)?.invoke(entity, effect)
                 }
             }
-
-            if (entity.pokemon.isAlpha) {
-                val spawningPlayer = action.spawnablePosition.cause.entity as? ServerPlayer
-                if (spawningPlayer != null) {
-                    AlphaLevelMatchingSensor.applyLevelMatching(entity, spawningPlayer)
-                }
-            }
         }
     }
 
@@ -139,4 +130,4 @@ open class SpawnBaitInfluence(val effects: List<SpawnBait.Effect>, val onUsed: (
         if (used) markUsed()
         return super.affectWeight(detail, spawnablePosition, newWeight)
     }
-}
+}

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

@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.api.spawning.influence
 
 import com.cobblemon.mod.common.api.spawning.BestSpawner
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.detail.SpawnAction
 import com.cobblemon.mod.common.api.spawning.detail.SpawnDetail
 import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
@@ -38,9 +39,9 @@ interface SpawningInfluence {
     /** Applies some influence over the entity that's been spawned. */
     fun affectSpawn(action: SpawnAction<*>, entity: Entity) {}
     /** Applies some influence over the weight of spawn buckets. */
-    fun affectBucketWeights(bucketWeights: MutableMap<String, Float>) {}
+    fun affectBucketWeights(bucketWeights: MutableMap<SpawnBucket, Float>) {}
     /** Normalizes all bucket weights to add up to 100 */
-    fun normalizeBucketWeights(bucketWeights: MutableMap<String, Float>) {
+    fun normalizeBucketWeights(bucketWeights: MutableMap<SpawnBucket, Float>) {
         val sum = bucketWeights.values.sum()
         val to100 = 100F / sum
         bucketWeights.keys.toList().forEach {
@@ -55,5 +56,5 @@ interface SpawningInfluence {
      *
      * You should make sure the spawn position satisfies any spawn details that you inject.
      */
-    fun injectSpawns(bucket: String, spawnablePosition: SpawnablePosition): List<SpawnDetail>? = null
+    fun injectSpawns(bucket: SpawnBucket, spawnablePosition: SpawnablePosition): List<SpawnDetail>? = null
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/position/AreaSpawnablePosition.kt

@@ -53,39 +53,34 @@ open class AreaSpawnablePosition(
      */
     open fun isSafeSpace(world: ServerLevel, pos: BlockPos, state: BlockState): Boolean = !state.isSolid
 
-    fun hasSpace(width: Int, height: Int): Boolean {
-        val sizeX = width.takeIf { it > 0 } ?: 1
-        val sizeY = height.takeIf { it > 0 } ?: 1
-
-        val minX = floor(position.x + 0.5 - (sizeX - 1) / 2F).toInt() - 1
-        val maxX = ceil(position.x + 0.5 + (sizeX + 1) / 2F).toInt() + 1
-
-        val maxY = ceil(position.y + (sizeY + 1) / 2F).toInt() + 1
-
-        val minZ = floor(position.z + 0.5 - (sizeX - 1) / 2F).toInt() - 1
-        val maxZ = ceil(position.z + 0.5 + (sizeX + 1) / 2F).toInt() + 1
-
-        val mutable = BlockPos.MutableBlockPos()
-        for (x in minX until maxX) {
-            for (y in (position.y + 1)..maxY) {
-                for (z in minZ until maxZ) {
-                    val state = zone.getBlockState(mutable.set(x, y, z))
-                    if (!isSafeSpace(world, mutable, state)) {
-                        return false
-                    }
-                }
-            }
-        }
-        return true
-    }
-
     override fun postFilter(detail: SpawnDetail): Boolean {
         if (!super.postFilter(detail)) {
             return false
         }
 
         if (detail.width > 1 || detail.height > 1) {
-            return hasSpace(detail.width, detail.height)
+            val sizeX = detail.width.takeIf { it > 0 } ?: 1
+            val sizeY = detail.height.takeIf { it > 0 } ?: 1
+
+            val minX = floor(position.x + 0.5 - (sizeX - 1) / 2F).toInt() - 1
+            val maxX = ceil(position.x + 0.5 + (sizeX + 1) / 2F).toInt() + 1
+
+            val maxY = ceil(position.y + (sizeY + 1) / 2F).toInt() + 1
+
+            val minZ = floor(position.z + 0.5 - (sizeX - 1) / 2F).toInt() - 1
+            val maxZ = ceil(position.z + 0.5 + (sizeX + 1) / 2F).toInt() + 1
+
+            val mutable = BlockPos.MutableBlockPos()
+            for (x in minX until maxX) {
+                for (y in (position.y + 1)..maxY) {
+                    for (z in minZ until maxZ) {
+                        val state = zone.getBlockState(mutable.set(x, y, z))
+                        if (!isSafeSpace(world, mutable, state)) {
+                            return false
+                        }
+                    }
+                }
+            }
         }
 
         return true

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/preset/BestSpawnerConfig.kt

@@ -11,6 +11,7 @@ package com.cobblemon.mod.common.api.spawning.preset
 import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.Cobblemon.LOGGER
 import com.cobblemon.mod.common.api.spawning.BestSpawner
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.position.SpawnablePositionType
 import com.cobblemon.mod.common.util.adapters.RegisteredSpawnablePositionAdapter
 import com.google.gson.GsonBuilder
@@ -28,7 +29,7 @@ import java.io.InputStreamReader
  * @since July 8th, 2022
  */
 class BestSpawnerConfig {
-    val version = 2
+    val version = 0
     /** Whether an external config will be replaced by an internal one once [version] is higher on the internal. */
     val replaceWithNewVersion = true
     @SerializedName("spawnablePositionTypeWeights", alternate = ["contextWeights"])
@@ -38,34 +39,11 @@ class BestSpawnerConfig {
         "surface" to 0.01F,
         "seafloor" to 1F
     )
-
-    val worldBuckets = mutableMapOf(
-        "common" to 94.05F,
-        "uncommon" to 5F,
-        "rare" to 0.5F,
-        "ultra-rare" to 0.2F,
-        "boss" to 0.25F,
-    )
-
-    val fishingBuckets = mutableMapOf(
-        "common" to 83.25F,
-        "uncommon" to 11.25F,
-        "rare" to 4.125F,
-        "ultra-rare" to 1.375F
-    )
-
-    val activatedHabitatBuckets: MutableMap<String, Float> = mutableMapOf(
-        "common" to 83.25F,
-        "uncommon" to 11.25F,
-        "rare" to 4.125F,
-        "ultra-rare" to 1.375F
-    )
-
-    val pokeSnackBuckets = mutableMapOf(
-        "common" to 83.25F,
-        "uncommon" to 11.25F,
-        "rare" to 4.125F,
-        "ultra-rare" to 1.375F
+    val buckets = mutableListOf(
+        SpawnBucket("common", 94.3F),
+        SpawnBucket("uncommon", 5F),
+        SpawnBucket("rare", 0.5F),
+        SpawnBucket("ultra-rare", 0.2F)
     )
 
     companion object {

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/preset/SpawnDetailPreset.kt

@@ -8,12 +8,13 @@
 
 package com.cobblemon.mod.common.api.spawning.preset
 
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.SpawnDetailPresets
 import com.cobblemon.mod.common.api.spawning.SpawnLoader
 import com.cobblemon.mod.common.api.spawning.condition.SpawningCondition
+import com.cobblemon.mod.common.api.spawning.position.SpawnablePositionType
 import com.cobblemon.mod.common.api.spawning.detail.SpawnDetail
 import com.cobblemon.mod.common.api.spawning.multiplier.WeightMultiplier
-import com.cobblemon.mod.common.api.spawning.position.SpawnablePositionType
 import com.cobblemon.mod.common.util.MergeMode
 import com.cobblemon.mod.common.util.adapters.SpawnDetailAdapter
 import com.google.gson.JsonObject
@@ -40,7 +41,7 @@ import com.google.gson.annotations.SerializedName
  * @since July 8th, 2022
  */
 abstract class SpawnDetailPreset {
-    var bucket: String? = null
+    var bucket: SpawnBucket? = null
     var spawnDetailType: String? = null
     @SerializedName("spawnablePositionType", alternate = ["context"])
     var spawnablePositionType: SpawnablePositionType<*>? = null

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/selection/FlatSelector.kt

@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.api.spawning.selection
 
 import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.detail.SpawnAction
 import com.cobblemon.mod.common.api.spawning.detail.SpawnDetail
 import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
@@ -87,13 +88,12 @@ open class FlatSelector : SpawningSelector<FlatSelector.SpawnablePositionSelecti
     class SpawnablePositionSelectionData(
         val spawner: Spawner,
         val spawnablePositions: List<SpawnablePosition>,
-        val selectingSpawnInformation: MutableMap<String, SpawnablePositionBucketSelectionData>,
+        val selectingSpawnInformation: MutableMap<SpawnBucket, SpawnablePositionBucketSelectionData>,
     ): SpawnSelectionData {
-        override var guaranteedBucket: String? = null
         override val spawnActions = mutableListOf<SpawnAction<*>>()
         override val context = mutableMapOf<String, Any>()
 
-        fun getDataForBucket(bucket: String): SpawnablePositionBucketSelectionData {
+        fun getDataForBucket(bucket: SpawnBucket): SpawnablePositionBucketSelectionData {
             val existing = selectingSpawnInformation[bucket]
             if (existing != null) {
                 return existing
@@ -130,14 +130,14 @@ open class FlatSelector : SpawningSelector<FlatSelector.SpawnablePositionSelecti
         spawner: Spawner,
         spawnablePositions: List<SpawnablePosition>
     ): SpawnablePositionSelectionData {
-        val selectingSpawnInformation: MutableMap<String, SpawnablePositionBucketSelectionData> = mutableMapOf()
+        val selectingSpawnInformation: MutableMap<SpawnBucket, SpawnablePositionBucketSelectionData> = mutableMapOf()
 
         return SpawnablePositionSelectionData(spawner, spawnablePositions, selectingSpawnInformation)
     }
 
     override fun selectSpawnAction(
         spawner: Spawner,
-        bucket: String,
+        bucket: SpawnBucket,
         selectionData: SpawnablePositionSelectionData,
     ): SpawnAction<*>? {
         val selectingSpawnInformation = selectionData.getDataForBucket(bucket) ?: return null
@@ -149,7 +149,7 @@ open class FlatSelector : SpawningSelector<FlatSelector.SpawnablePositionSelecti
             if (percentSum > 100) {
                 Cobblemon.LOGGER.warn(
                     """
-                        A spawn list for ${spawner.name} exceeded 100% on percentage sums in bucket $bucket...
+                        A spawn list for ${spawner.name} exceeded 100% on percentage sums in bucket ${bucket.name}...
                         This means you don't understand how this option works.
                     """.trimIndent()
                 )
@@ -186,7 +186,7 @@ open class FlatSelector : SpawningSelector<FlatSelector.SpawnablePositionSelecti
 
     override fun getTotalWeights(
         spawner: Spawner,
-        bucket: String,
+        bucket: SpawnBucket,
         spawnablePositions: List<SpawnablePosition>
     ): Map<SpawnDetail, Float> {
         val selectionData = getSelectionData(spawner, spawnablePositions).getDataForBucket(bucket)

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/selection/FlatSpawnablePositionWeightedSelector.kt

@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.api.spawning.selection
 
 import com.cobblemon.mod.common.Cobblemon.LOGGER
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.detail.SpawnAction
 import com.cobblemon.mod.common.api.spawning.detail.SpawnDetail
 import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
@@ -101,11 +102,10 @@ open class FlatSpawnablePositionWeightedSelector : SpawningSelector<FlatSpawnabl
         val spawner: Spawner,
         val spawnablePositions: List<SpawnablePosition>
     ) : SpawnSelectionData {
-        override var guaranteedBucket: String? = null
         override val spawnActions = mutableListOf<SpawnAction<*>>()
         override val context = mutableMapOf<String, Any>()
 
-        val bucketData = mutableMapOf<String, MutableMap<SpawnablePositionType<*>, SpawnablePositionSelectionData>>()
+        val bucketData = mutableMapOf<SpawnBucket, MutableMap<SpawnablePositionType<*>, SpawnablePositionSelectionData>>()
 
         override fun removeSpawnDetails(shouldRemove: (SpawnDetail) -> Boolean) {
             bucketData.values.forEach {
@@ -121,7 +121,7 @@ open class FlatSpawnablePositionWeightedSelector : SpawningSelector<FlatSpawnabl
             }
         }
 
-        fun getDataForBucket(bucket: String): MutableMap<SpawnablePositionType<*>, SpawnablePositionSelectionData> {
+        fun getDataForBucket(bucket: SpawnBucket): MutableMap<SpawnablePositionType<*>, SpawnablePositionSelectionData> {
             bucketData[bucket]?.let { return it }
 
             val spawnablePositionTypeToSpawns = mutableMapOf<SpawnablePositionType<*>, SpawnablePositionSelectionData>()
@@ -149,7 +149,7 @@ open class FlatSpawnablePositionWeightedSelector : SpawningSelector<FlatSpawnabl
 
     override fun selectSpawnAction(
         spawner: Spawner,
-        bucket: String,
+        bucket: SpawnBucket,
         selectionData: SeparatedSelectionData
     ): SpawnAction<*>? {
         val bucketData = selectionData.getDataForBucket(bucket)
@@ -172,7 +172,7 @@ open class FlatSpawnablePositionWeightedSelector : SpawningSelector<FlatSpawnabl
             if (percentSum > 100) {
                 LOGGER.warn(
                     """
-                        A spawn list for ${spawner.name} exceeded 100% on percentage sums in bucket $bucket...
+                        A spawn list for ${spawner.name} exceeded 100% on percentage sums in bucket ${bucket.name}...
                         This means you don't understand how this option works.
                     """.trimIndent()
                 )
@@ -244,7 +244,7 @@ open class FlatSpawnablePositionWeightedSelector : SpawningSelector<FlatSpawnabl
 
     override fun getTotalWeights(
         spawner: Spawner,
-        bucket: String,
+        bucket: SpawnBucket,
         spawnablePositions: List<SpawnablePosition>
     ): Map<SpawnDetail, Float> {
         val selectionData = getSelectionData(spawner, spawnablePositions).getDataForBucket(bucket)

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/selection/SpawnSelectionData.kt

@@ -21,7 +21,6 @@ import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
  * @since April 21st, 2025
  */
 interface SpawnSelectionData {
-    var guaranteedBucket: String?
     val context: MutableMap<String, Any>
     val spawnActions: MutableList<SpawnAction<*>>
     fun removeSpawnDetails(shouldRemove: (SpawnDetail) -> Boolean)
@@ -29,7 +28,6 @@ interface SpawnSelectionData {
 
     companion object {
         val EMPTY = object : SpawnSelectionData {
-            override var guaranteedBucket: String? = null
             override val context: MutableMap<String, Any> = mutableMapOf()
             override val spawnActions: MutableList<SpawnAction<*>> = mutableListOf()
             override fun removeSpawnDetails(shouldRemove: (SpawnDetail) -> Boolean) {}

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/selection/SpawningSelector.kt

@@ -8,6 +8,7 @@
 
 package com.cobblemon.mod.common.api.spawning.selection
 
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.detail.SpawnAction
 import com.cobblemon.mod.common.api.spawning.detail.SpawnDetail
 import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
@@ -32,13 +33,13 @@ interface SpawningSelector<T : SpawnSelectionData> {
 
     fun selectSpawnAction(
         spawner: Spawner,
-        bucket: String,
+        bucket: SpawnBucket,
         selectionData: T
     ): SpawnAction<*>?
 
     fun select(
         spawner: Spawner,
-        bucketSelector: () -> String,
+        bucketSelector: () -> SpawnBucket,
         spawnablePositions: List<SpawnablePosition>,
         maxSpawns: Int
     ): List<SpawnAction<*>> {
@@ -47,7 +48,7 @@ interface SpawningSelector<T : SpawnSelectionData> {
         val spawnActions = selectionData.spawnActions
 
         while (spawnActions.size < maxSpawns) {
-            val bucket = selectionData.guaranteedBucket ?: bucketSelector()
+            val bucket = bucketSelector()
             val spawnAction = selectSpawnAction(
                 spawner = spawner,
                 bucket = bucket,
@@ -64,7 +65,7 @@ interface SpawningSelector<T : SpawnSelectionData> {
         return spawnActions
     }
 
-    fun getProbabilities(spawner: Spawner, bucket: String, spawnablePositions: List<SpawnablePosition>): Map<SpawnDetail, Float> {
+    fun getProbabilities(spawner: Spawner, bucket: SpawnBucket, spawnablePositions: List<SpawnablePosition>): Map<SpawnDetail, Float> {
         val weights = getTotalWeights(spawner, bucket, spawnablePositions)
         val totalWeight = weights.values.sum()
         val percentages = mutableMapOf<SpawnDetail, Float>()
@@ -72,5 +73,5 @@ interface SpawningSelector<T : SpawnSelectionData> {
         return percentages
     }
 
-    fun getTotalWeights(spawner: Spawner, bucket: String, spawnablePositions: List<SpawnablePosition>): Map<SpawnDetail, Float>
+    fun getTotalWeights(spawner: Spawner, bucket: SpawnBucket, spawnablePositions: List<SpawnablePosition>): Map<SpawnDetail, Float>
 }

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

@@ -25,8 +25,7 @@ import com.cobblemon.mod.common.api.spawning.selection.SpawningSelector
 open class BasicSpawner(
     override val name: String,
     override var spawnPool: SpawnPool,
-    override var maxPokemonPerChunk: Float = Cobblemon.config.pokemonPerChunk,
-    override val buckets: Map<String, Float>
+    override var maxPokemonPerChunk: Float = Cobblemon.config.pokemonPerChunk
 ) : Spawner {
     override var selector: SpawningSelector<*> = SpawningSelector.DEFAULT
     override var generator: SpawningZoneGenerator = Cobblemon.spawningZoneGenerator

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

@@ -8,11 +8,11 @@
 
 package com.cobblemon.mod.common.api.spawning.spawner
 
-import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.CobblemonPoiTypes
 import com.cobblemon.mod.common.api.spawning.BestSpawner
 import com.cobblemon.mod.common.api.spawning.CobblemonSpawnPools
 import com.cobblemon.mod.common.api.spawning.detail.SpawnPool
+import com.cobblemon.mod.common.api.spawning.influence.BucketMultiplyingInfluence
 import com.cobblemon.mod.common.api.spawning.influence.BucketNormalizingInfluence
 import com.cobblemon.mod.common.api.spawning.influence.PlayerLevelRangeInfluence
 import com.cobblemon.mod.common.api.spawning.influence.PlayerLevelRangeInfluence.Companion.TYPICAL_VARIATION
@@ -72,9 +72,16 @@ object FishingSpawnerFactory {
     fun createSharedSpawner(): BasicSpawner {
         return BasicSpawner(
             name = "fishing",
-            spawnPool = spawnPool,
-            buckets = Cobblemon.bestSpawner.config.fishingBuckets,
-        )
+            spawnPool = spawnPool
+        ).also { spawner ->
+            spawner.influences += BucketMultiplyingInfluence(
+                multipliers = mapOf(
+                    "uncommon" to 2.25f,
+                    "rare" to 5.5f,
+                    "ultra-rare" to 5.5f,
+                )
+            )
+        }
     }
 
     fun findHabitatInfluences(world: ServerLevel, position: BlockPos, spawner: Spawner): Array<HabitatBlockEntity> {

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

@@ -11,8 +11,8 @@ package com.cobblemon.mod.common.api.spawning.spawner
 import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.api.spawning.SpawnCause
 import com.cobblemon.mod.common.api.spawning.detail.SpawnPool
-import net.minecraft.core.BlockPos
 import net.minecraft.server.level.ServerLevel
+import net.minecraft.core.BlockPos
 
 /**
  * A spawner that works within a fixed area. Instances provide the center point and the radii and then the spawner
@@ -24,13 +24,12 @@ import net.minecraft.server.level.ServerLevel
 open class FixedAreaSpawner(
     name: String,
     spawnPool: SpawnPool,
-    buckets: Map<String, Float>,
     val world: ServerLevel,
     val position: BlockPos,
     val horizontalRadius: Int,
     val verticalRadius: Int,
     maxPokemonPerChunk: Float = Cobblemon.config.pokemonPerChunk
-) : BasicSpawner(name, spawnPool, maxPokemonPerChunk, buckets) {
+) : BasicSpawner(name, spawnPool, maxPokemonPerChunk) {
     fun run(cause: SpawnCause, maxSpawns: Int? = null): List<Any> {
         return runForArea(
             zoneInput = getZoneInput(cause),

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

@@ -8,21 +8,20 @@
 
 package com.cobblemon.mod.common.api.spawning.spawner
 
-import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.Cobblemon.config
 import com.cobblemon.mod.common.api.spawning.SpawnCause
 import com.cobblemon.mod.common.api.spawning.detail.SpawnPool
 import com.cobblemon.mod.common.util.getPlayer
 import com.cobblemon.mod.common.util.nextBetween
-import java.util.UUID
-import kotlin.math.atan
-import kotlin.math.cos
-import kotlin.math.sin
-import kotlin.random.Random
 import net.minecraft.server.level.ServerLevel
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.util.Mth.PI
 import net.minecraft.util.Mth.ceil
+import java.util.*
+import kotlin.math.atan
+import kotlin.math.cos
+import kotlin.math.sin
+import kotlin.random.Random
 
 /**
  * A spawner that works around a single player. It will do basic tracking of a player's speed
@@ -36,8 +35,7 @@ open class PlayerSpawner(
     spawnPool: SpawnPool
 ) : BasicSpawner(
     name = player.name.string,
-    spawnPool = spawnPool,
-    buckets = Cobblemon.bestSpawner.config.worldBuckets
+    spawnPool = spawnPool
 ) {
     val uuid: UUID = player.uuid
 

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

@@ -8,16 +8,15 @@
 
 package com.cobblemon.mod.common.api.spawning.spawner
 
-import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.api.fishing.SpawnBait
 import com.cobblemon.mod.common.api.spawning.CobblemonSpawnPools
 import com.cobblemon.mod.common.api.spawning.CobblemonSpawnRules
 import com.cobblemon.mod.common.api.spawning.detail.SpawnPool
+import com.cobblemon.mod.common.api.spawning.influence.BucketMultiplyingInfluence
 import com.cobblemon.mod.common.api.spawning.influence.BucketNormalizingInfluence
 import com.cobblemon.mod.common.api.spawning.influence.SpawnBaitInfluence
 import com.cobblemon.mod.common.api.spawning.influence.SpawningInfluence
 import com.cobblemon.mod.common.api.spawning.rules.SpawnRule
-import com.cobblemon.mod.common.block.entity.PokeSnackBlockEntity
 import com.cobblemon.mod.common.util.mutableLazy
 import net.minecraft.core.BlockPos
 import net.minecraft.server.level.ServerLevel
@@ -62,18 +61,26 @@ object PokeSnackSpawnerFactory {
                 firstTier = 1.2F
             )
         },
+        { _ ->
+            BucketMultiplyingInfluence(
+                mapOf(
+                    "uncommon" to 2.25f,
+                    "rare" to 5.5f,
+                    "ultra-rare" to 5.5f,
+                )
+            )
+        },
         { ctx ->
             SpawnBaitInfluence(effects = ctx.baitEffects)
         },
     )
 
-    fun create(ctx: Context): PokeSnackBlockEntity.Spawner {
+    fun create(ctx: Context): FixedAreaSpawner {
         val influences = influenceBuilders.mapNotNull { it(ctx) }
 
-        return PokeSnackBlockEntity.Spawner(
+        return FixedAreaSpawner(
             name = ctx.name,
             spawnPool = spawnPool,
-            buckets = Cobblemon.bestSpawner.config.pokeSnackBuckets,
             world = ctx.world,
             position = ctx.pos,
             horizontalRadius = ctx.horizontalRadius,

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

@@ -12,6 +12,7 @@ import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.api.events.CobblemonEvents
 import com.cobblemon.mod.common.api.events.entity.SpawnBucketChosenEvent
 import com.cobblemon.mod.common.api.spawning.BestSpawner
+import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.SpawnCause
 import com.cobblemon.mod.common.api.spawning.SpawningZoneGenerator
 import com.cobblemon.mod.common.api.spawning.detail.EntitySpawnResult
@@ -25,7 +26,6 @@ import com.cobblemon.mod.common.api.spawning.position.calculators.SpawnablePosit
 import com.cobblemon.mod.common.api.spawning.selection.SpawningSelector
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.isBoxLoaded
-import com.cobblemon.mod.common.util.removeIf
 import com.cobblemon.mod.common.util.squeezeWithinBounds
 import com.cobblemon.mod.common.util.toVec3f
 import com.cobblemon.mod.common.util.weightedSelection
@@ -52,7 +52,6 @@ import net.minecraft.world.phys.Vec3
 interface Spawner {
     val name: String
     val influences: MutableList<SpawningInfluence>
-    val buckets: Map<String, Float>
     var spawnPool: SpawnPool
     var selector: SpawningSelector<*>
     var generator: SpawningZoneGenerator
@@ -66,7 +65,7 @@ interface Spawner {
         const val ENTITY_LIMIT_CHUNK_RANGE = 3
     }
 
-    fun getMatchingSpawns(bucket: String, spawnablePosition: SpawnablePosition): List<SpawnDetail> {
+    fun getMatchingSpawns(bucket: SpawnBucket, spawnablePosition: SpawnablePosition): List<SpawnDetail> {
         val spawns = mutableListOf<SpawnDetail>()
         spawns.addAll(spawnPool.retrieve(bucket, spawnablePosition).filter { it.isSatisfiedBy(spawnablePosition) })
         spawnablePosition.influences.forEach { influence ->
@@ -173,12 +172,11 @@ interface Spawner {
 
     fun copyInfluences() = influences.filter { !it.isExpired() }.toMutableList()
 
-    fun chooseBucket(cause: SpawnCause, influences: List<SpawningInfluence>): String {
-        val bucketWeights = buckets.toMutableMap()
+    fun chooseBucket(cause: SpawnCause, influences: List<SpawningInfluence>): SpawnBucket {
+        val buckets = Cobblemon.bestSpawner.config.buckets
+        val bucketWeights = buckets.associateWith { it.weight }.toMutableMap()
         influences.forEach { it.affectBucketWeights(bucketWeights) }
-        val usedBuckets = spawnPool.buckets.intersect(bucketWeights.keys)
-        bucketWeights.removeIf { it.key !in usedBuckets }
-        val bucket = bucketWeights.entries.weightedSelection { it.value }?.key ?: buckets.keys.first()
+        val bucket = bucketWeights.entries.weightedSelection { it.value }?.key ?: buckets.first()
         val event = SpawnBucketChosenEvent(
             spawner = this,
             spawnCause = cause,

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

@@ -46,7 +46,6 @@ open class BottomlessStore(override val uuid: UUID) : PokemonStore<BottomlessPos
         pokemon.forEachIndexed { index, pokemon ->
             pokemon.storeCoordinates.set(StoreCoordinates(this, BottomlessPosition(index)))
         }
-        rebuildPokemonByUuid()
     }
 
     override fun saveToNBT(nbt: CompoundTag, registryAccess: RegistryAccess): CompoundTag {