Added category to Behaviours backend

Added majority of functionality for premade NPCs
Outline work for premade NPCs as a logical replacement for NPC presets
2026-10-27 20:46:27 -04:00 · 2026-04-25 11:21:47 +10:00 · 2026-04-20 09:43:00 +10:00 · 2026-04-18 11:35:40 +10:00 · 2026-04-13 13:35:52 +10:00
15250 changed files with 122584 additions and 872078 deletions
@@ -24,7 +24,6 @@ eclipse
 run
 runClient
 runServer
-utilityscripts/implementation/*.txt

 # Files from Forge MDK
 forge*changelog.txt
@@ -37,11 +36,9 @@ common/src/main/resources/assets/cobblemon/showdown
 # Generated files
 */generated/resources/*
 /fabric/src/generated/resources/cobblemon-common.accesswidener
-/fabric/src/main/generated/*
 /.ignored/
 common/.fabric
 .kotlin/

 # MacOS
 .DS_Store
-/common/config/*
@@ -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
@@ -157,9 +155,6 @@ build:
    paths:
      - neoforge/build/libs
      - fabric/build/libs
-    exclude:
-      - neoforge/build/libs/*-dev-shadow.jar
-      - fabric/build/libs/*-dev-shadow.jar

 publish:
  stage: deploy
@@ -168,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
@@ -182,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 {} ./
@@ -1,8 +0,0 @@
-
-### Additions
- Added Pokémon breeding for Pokémon left in pasture blocks.
- Added nest blocks that Pokémon can lay eggs in.
-
-### Developer
- Spawning Influences now have the context of what the other buckets are when adjusting bucket weights. This will break existing influences that do bucket weight adjustment.
- Renamed heaps of things in the spawning system to make more sense.
@@ -1,101 +1,58 @@
 # Changelog
-## [1.8.2 (MONTH xth, 2026)](#1-8-2)
+## [1.7.4 (MONTH Xth, 2026)](#1-7-4)

 ### Additions
- The following items can now be placed on the ground as blocks:
-  - King's Rock, Galarica Cuff, Unremarkable Teacup, Masterpiece Teacup, Chipped Pot, Cracked Pot, Sachet, Metal Powder, Quick Powder, Bright Powder, Icy Rock, Heat Rock, Smooth Rock, Damp Rock, Destiny Knot, Luminous Moss, Never-Melt Ice, Wide Lens, Scope Lens, and Zoom Lens.
-  - Iron Ball, Metal Coat, Throat Spray, HP Up, Protein, Iron, Carbos, Calcium, Zinc, PP Up, PP Max, Upgrade, Dubious Disc, and Loaded Dice.
- The following items can now be placed on various surfaces:
-  - Galarica Wreath, Magnet, Flame Orb, Life Orb, Toxic Orb, Light Ball, and Smoke Ball.
- The following items can now be placed as blocks and have additional functionality:
-  - Ring Target, Metronome, and Eject Button.
- The following items can now be worn by Players and Pokémon:
-  - Galarica Wreath, Cleanse Tag, Spell Tag, Sharp Beak, Covert Cloak, Shell Helmet, and Never-Melt Ice.
- Wearable items can now be equipped by a player by holding it and right-clicking (or rebound use/interact)
-  - Wearable items that can be placed down are exempt from this behaviour.
+- 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 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
+
+### New rideable Pokémon

 ### Pokémon Added
-#### Generation 4
- Snover
- Abomasnow
- Burmy
- Wormadam
- Mothim
-
-#### Generation 5
- Tympole
- Palpitoad
- Seismitoad
-
-#### Generation 6
- Helioptile
- Heliolisk
-
-#### Generation 7
- Grubbin
- Charjabug
- Vikavolt
-
-#### Generation 9
- Greavard
- Houndstone

 ### Model updates for the following Pokémon
- Cacnea
- Cacturne
- Binacle
- Barbaracle
- Glimmet
- Glimmora
- Deerling
- Sawsbuck (All forms)
- Absol

 ### Animation updates for the following Pokémon
- Cacnea
- Cacturne

 ### Changes
- Updated various recipes to display in Recipe Groups within the Recipe Book
- Updated most recipes to display more logically/consistently within the Recipe Book's categories
- Make ride rotations less jittery in multiplayer.
- Changes tm shelf discs to use textures instead of tinting and overlays to line up with item display
- Blank TM can now be inserted into the Disc Shelf
+- Restructured Botany Pots integration folder structure
+- Decrease default pastured mon wander radius to 32.
+- Factor in the weight of pokemon 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)

 ### Fixes
- Correctly grants "They're Minerals!" advancement when planting a type gem
- Type Gem Blocks now have advancements to give you the recipe in the recipe book (the data for the advancements were inside the recipes somehow??)
- Some other recipes without advancements have also been corrected
- Corrected the TM Recipes for Charge Beam and Payday
- Type Gem blocks now properly generate clusters off of the block.
- Starter Screen Categories will no longer stop rendering if they are bigger than the viewport, and you are not viewing top or bottom edges
- Random Starter option now properly handled in height calculation, so now it won't run off into other categories or be un-accessible due to scroll limits if it causes a new row
- Mochi and Feathers no longer drop glass bottles on use
- Fixed a rare set of concurrency bugs related to reloading packs on NeoForge; fixes a ModernFix issue
- Removed unnecessary conditions for Mimikyu's standing pose. Hopefully fixes the rare instance of it using its shoulder animations during battle in multiplayer scenarios.
- Fixed Rockruff line not blinking
- Fixed Flygon sometimes using its running animation instead of walking
- Fixed Bramblin always sleeping outside of battle
- Fixed Dragonair using its battle idle as a normal idle
- Fixed Lycanroc's head movement
- Added head movement to Archaludon
- Fixed Duraludon line not having any sleep animations
- Fixed Diglett line not having their faint animations
- Fixed Kingambit moving its legs while walking
- Various Structure fixes
- Fixed shiny pokemon under certain circumstances forgetting taught TMs
+- Fixes https://gitlab.com/cable-mc/cobblemon/-/issues/1943
+- Fix occasional crash on retrieving revived fossils
+- 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 issue where particle like beam can disappear when you don't see the beginning of the beam or you look away
+ - Fixes https://gitlab.com/cable-mc/cobblemon/-/issues/1943
+ - Fix occasional crash on retrieving revived fossils
+ - Fix brushing not working on Neoforge
+ - [Various Submarine Ride Fixes](https://gitlab.com/cable-mc/cobblemon/-/merge_requests/2157)
+ - Fix Pastured mons despawning and running away.
+ - Fix Apricorn trees crashing when other mods bonemeal it
+ - [Various UFO Ride Improvements](https://gitlab.com/cable-mc/cobblemon/-/merge_requests/2156)
+- Fixed NeoForge brewing stand unexpectedly crashing users when shift clicking items within it's menu
+- Fixed NPCs switching pokemon very often during battles
+- Fixed Campfire pot causing crashes under certain circumstances
+- Fixed Type Gems not being consumed upon use
+- Fixed Ancient Pokeball's to their respective modifiers
+- Fixed a Server warning when recalling Pokemon

 ### Developer
- Fixed wrong order of operations in the code flow prior to the `FOSSIL_REVIVED` event causing pokemon to appear without entity link
- Fixed TestPartySlot command not correctly comparing the provided spec with the target Pokémon
+- 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

 ### Molang & Datapacks
- A new `negate` variant for evolution requirements has been added, which will negate (invert) the provided inner condition.
- Added Molang functions for individual Pokédex ids, wherein a subdex is passed in as a string to `dex_caught_count` etc.
-
-### Particles
-
-#### New Move Animations
+- q.item.is_enchanted()
+- 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 pokemon

 ### Localization
- Updated translations for:
+- Updated translations for:
@@ -1,223 +0,0 @@
-# Habitat Block GUI Editor - Developer Instructions
-These instructions are brought to you by AI slop with Hiroku reviewing it afterwards. It does seem fairly accurate 
-though.
-
-## Overview
-The Habitat Block is a spawning tool that allows creative mode players to configure custom Pokémon spawning behavior. We need a GUI editor so read below to understand what it needs to do.
-
-Phases might need a bit of explanation. The idea is that each habitat block will have a current "phase", which changes every day. The number of different phases is something that can be configured per block, as well as what order the phase will move through when it changes.
-
-In the case of 3 phases, the different phase orders do the following:
-SIMPLE:       1-2-3-1-2-3-1-2-3
-FIXED_RANDOM: 1-3-2-1-3-2-1-3-2 (or some other repeating pattern, based on the position of the habitat block)
-FULL_RANDOM:  1-3-1-2-3-1-3-1-2 (completely random value each day)
-
-The idea is like, if you had set 3 phases for a habitat block, you could make Rattata spawn in phase 1, Patrat in phase 2, and Zigzagoon in phase 3.
-
-## Entry Point
- GUI opens when a creative mode player right-clicks a Habitat Block
- Packet: `OpenHabitatBlockEditorPacket` sends current settings to client
- When you're done you send a `SaveHabitatBlockSettingsPacket` back to the server with the same settings DTO instance (but modified, one would assume)
- Settings are applied via `HabitatBlockEntity.applySettings(HabitatSettingsDTO)`
-
-## Data Structure
-
-### Root: `HabitatSettingsDTO`
-All settings are contained in this DTO which is sent between client and server.
-
-#### Common Settings (always present)
-```kotlin
-numberOfPhases: Int = 1              // Number of spawn phases (TODO: not yet implemented)
-phaseOrder: HabitatPhaseOrder        // How the passage of phases will work with each day
-levelRange: IntRange                 // Min..Max level for spawned Pokémon
-modifiers: String                    // PokemonProperties string (e.g., "shiny gender=male")
-mimicId: ResourceLocation            // Block appearance (e.g., "minecraft:stone")
-```
-
-#### Spawning Mode Toggle
-```kotlin
-isActivatedSpawning: Boolean         // true = Activated mode, false = Natural mode
-```
-
-Based on this boolean, EITHER `activatedSettings` OR `naturalSettings` will be populated (never both).
-
---
-
-## Spawning Modes
-
-### Mode 1: Activated Spawning (`ActivatedHabitatSettingsDTO`)
-Triggered spawning system - spawns occur based on specific triggers.
-
-```kotlin
-trigger: Enum                        // REDSTONE, TICK, or RANDOM_TICK
-chance: Float = 1.0                  // Probability (0.0-1.0) spawn attempt occurs on trigger
-cancelledNaturalSpawningRange: Int   // Radius (blocks) where natural spawning is disabled
-spawnRange: Int                      // Radius (blocks) where spawning can occur
-maxSpawns: Int = -1                  // Max concurrent spawns from this block (-1 = infinite)
-maxSpawnsPerActivation: Int = 1      // Max spawns per single trigger event
-habitatPool: HabitatPoolSettingsDTO  // What Pokémon can spawn (see below)
-```
-
-**Trigger Types:**
- `REDSTONE`: Spawns on redstone pulse (rising edge)
- `TICK`: Attempts spawn every game tick (very frequent)
- `RANDOM_TICK`: Attempts spawn on random tick events
-
-### Mode 2: Natural Spawning (`NaturalHabitatSettingsDTO`)
-Modifies the natural spawning system in the area.
-
-```kotlin
-replaceSpawns: Boolean               // true = only this pool spawns, false = adds to natural spawns
-rangeOfInfluence: Int                // Radius (blocks) where this influences spawning
-habitatPool: HabitatPoolSettingsDTO  // What Pokémon can spawn (see below)
-```
-
---
-
-## Habitat Pool Settings (`HabitatPoolSettingsDTO`)
-
-Defines what Pokémon can spawn. Can reference existing pools or define custom ones.
-
-```kotlin
-id: ResourceLocation                 // Pool identifier
-isReference: Boolean                 // true = use existing pool, false = custom pool
-isActivated: Boolean                 // Must match parent spawning mode
-
-// Only present when isReference = false:
-name: String?                        // Display name for custom pool
-spawns: List<HabitatSpawn>?          // List of spawn entries
-```
-
-**Pool Types:**
- **Reference Pool**: `isReference = true` - Uses a pre-defined pool by ID (e.g., `cobblemon:forest_day`)
- **Custom Pool**: `isReference = false` - Defines spawns inline with `name` and `spawns` list
-
-**Custom Pool IDs**: Must start with `custom__` prefix (e.g., `cobblemon:custom__my_pool`)
-
---
-
-## GUI Requirements
-
-### Layout Sections
-
-#### 1. Common Settings Panel
- **Number of Phases**: Integer input greater than zero (default: 1)
- **Phase Order**: Habitat Phase Order dropdown (default: SIMPLE)
- **Level Range**: Two integer inputs (Min/Max) - Default: 1 to config max Pokémon level
- **Modifiers**: Text input for PokemonProperties string
-  - Examples: `shiny`, `gender=male`, `shiny gender=female level=50`
- **Mimic Block**: Block selector/dropdown
-  - Default: `minecraft:stone`
-  - See `HabitatBlockEntity.mimicCycle` for suggested blocks
-
-#### 2. Spawning Mode Selector
-Radio buttons or toggle:
- **Activated Spawning** (trigger-based)
- **Natural Spawning** (world spawning influenced)
-
-#### 3. Mode-Specific Settings
-
-**If Activated Spawning:**
- **Trigger**: Dropdown (REDSTONE / TICK / RANDOM_TICK)
- **Chance**: Float slider (0.0 - 1.0, default: 1.0)
- **Cancel Natural Spawning Range**: Integer input (blocks)
- **Spawn Range**: Integer input (blocks)
- **Max Spawns**: Integer input (-1 for infinite, default: -1)
- **Max Spawns Per Activation**: Integer input (default: 1)
- **Habitat Pool**: Pool selector (see below)
-
-**If Natural Spawning:**
- **Replace Spawns**: Checkbox (true = exclusive, false = additive)
- **Range of Influence**: Integer input (blocks)
- **Habitat Pool**: Pool selector (see below)
-
-#### 4. Habitat Pool Selector
-Two options:
- **Use Existing Pool**: Dropdown of registered pools
-  - Set `isReference = true`
-  - Set `id` to selected pool
-  - Ensure `isActivated` matches spawning mode
- **Create Custom Pool**: Opens pool editor
-  - Set `isReference = false`
-  - Generate ID with `custom__` prefix
-  - Set `name` and `spawns` list
-  - User defines spawn entries (implementation depends on `HabitatSpawn` structure)
-
---
-
-## Validation Rules
-
-1. **Level Range**: Min must be ≥ 1, Max must be ≤ config max, Min ≤ Max
-2. **Number of Phases**: Must be greater than zero
-3. **Chance**: Must be between 0.0 and 1.0
-4. **Ranges**: All range values must be ≥ 0
-5. **Pool Validation**: 
-   - If `isActivated = true`, pool must be `ActivatedHabitatPool`
-   - If `isActivated = false`, pool must be `NaturalHabitatPool`
-   - If reference pool not found, server logs error and rejects settings
-6. **Custom Pool IDs**: Must start with `custom__`
-
---
-
-## Network Flow
-
-1. **Opening GUI**: Server sends `OpenHabitatBlockEditorPacket` with current `HabitatSettingsDTO`
-2. **Saving Changes**: Client sends updated `HabitatSettingsDTO` back to server
-3. **Server Processing**: 
-   - `HabitatBlockEntity.applySettings()` validates and applies changes
-   - Calls `refreshFromSettings()` to regenerate spawn details
-   - Marks block entity as changed and syncs to clients
-
---
-
-## Implementation Notes
-
- **Creative Mode Only**: GUI should only be accessible to creative mode players
-
---
-
-## Example Configurations
-
-### Example 1: Redstone-Triggered Shiny Spawner
-```kotlin
-isActivatedSpawning = true
-phaseOrder = FIXED_RANDOM
-numberOfPhases = 4
-levelRange = 50..60
-modifiers = "shiny"
-mimicId = "minecraft:diamond_block"
-
-activatedSettings:
-  trigger = REDSTONE
-  chance = 1.0
-  spawnRange = 10
-  maxSpawns = 1
-  maxSpawnsPerActivation = 1
-  habitatPool = (reference to existing pool)
-```
-
-### Example 2: Natural Spawn Replacement Zone
-```kotlin
-isActivatedSpawning = false
-levelRange = 1..100
-phaseOrder = SIMPLE
-numberOfPhases = 1
-modifiers = ""
-mimicId = "minecraft:moss_block"
-
-naturalSettings:
-  replaceSpawns = true
-  rangeOfInfluence = 32
-  habitatPool = (custom pool with specific Pokémon)
-```
-
---
-
-## Related Files
- `HabitatBlockEntity.kt` - Main block entity logic
- `HabitatSettingsDTO.kt` - Root settings container
- `ActivatedHabitatSettingsDTO.kt` - Activated mode settings
- `NaturalHabitatSettingsDTO.kt` - Natural mode settings
- `HabitatPoolSettingsDTO.kt` - Pool configuration
- `ActivatedHabitatSpawning.kt` - Activated spawning implementation
- `NaturalHabitatSpawning.kt` - Natural spawning implementation
@@ -1,9 +0,0 @@
-IVs layer
-Move layer
-Remove nature layer in favour of modification layer
-Reconsider form layer. Its timing seems more important than anything else
-Remove cosmetic layer
-Add shiny layer
-
-Fix the way the client is the one deciding when hatching will happen from that TriggerEggHatchHandler
-Clean up duplication in hatchPokemon logic for nest and incubator, should be a common function in EggComponent probably for hatching into a player's party
@@ -1,6 +1,3 @@
-import utilities.gitBranch
-import utilities.gitShortCommit
-
 plugins {
    id("cobblemon.root-conventions")
 }
@@ -9,6 +6,6 @@ version = "${project.property("mod_version")}+${project.property("mc_version")}"

 val isSnapshot = project.property("snapshot")?.equals("true") == true
 if (isSnapshot) {
-    val fixedBranchName = gitBranch().substringAfter("/")
-    version = "$version-${fixedBranchName}-${gitShortCommit()}"
+    val fixedBranchName = versioning.info.branch.substringAfter("/")
+    version = "$version-${fixedBranchName}-${versioning.info.build}"
 }
@@ -1,529 +0,0 @@
-# Changelog
-## [1.8.0 - Make Your Move Update (September 6th, 2026)](#1-8-0)
-#### I think the red eyes mean they're friendly!
-
-### Additions
- Added Alpha Pokémon
-    - Alpha Pokémon are bigger, stronger, and more aggressive than regular Pokémon.
-    - They are also scarier.
-    - They always know a TM move and will adapt to be stronger than your party.
-    - Alphas will always lead herds and spawn in herds.
- Added alpha Pokémon attraction bait effect to Hopo Berries.
- Added intrinsic scaling to all Pokémon (anywhere from 5% smaller to 5% bigger than normal). Some cases, such as shoulder mounting, will not scale so that the shoulder animations don't look silly.
- Added scaling to "baby" Pokémon (10% smaller at level 1 → normally sized at level 10).
- Added TMs.
-    - Added TM Machine. TMs are made from elemental type gems, and their recipes are unlocked by having Pokémon that know the move.
-    - Added config options for making TMs infinite-use and instant unlocking of all TM recipes.
-    - Added Type Gem blocks as well as crystal clusters and deepslate core blocks that are used for growing elemental type gems.
- Added a new Starter Selection menu that looks way better.
- Added a "Move Dex" to the Pokédex to help identify what moves a Pokémon can learn and what Pokémon can get a move.
- Added the Habitat Block, a spawner block for servers and adventure maps that controls spawning in an area.
- Added 49 new habitat structures. In these habitats you will find rarer Pokémon and sometimes different Pokémon will appear on different days.
- Added a toast to notify players of how they can scroll through their party. Did you know you can hold R and scroll instead of using arrow keys? It's true!!!
- Added a way to obtain Porygon by inserting an Upgrade or Dubious Disc into a data monitor.
- Added Disk Rack for storing disks and being an audio sequencer for Noteblocks. What does that have to do with Pokémon? How about you mind your own business!
- Added missing crops to Botany Pots integration.
- Added conditional seats for riding. Seats can be gated by Molang such as "is_alpha".
- Added 10 new ruin structures.
- Added a new shipwreck cove structure called the Magma Shipwreck Cove.
- Added 7 new advancements.
- Pokémon cries now play when clicking Pokémon in the summary screen.
- Held item visibility can now be controlled by the `held_item_visible` command argument.
- Added config option to disable Pokémon spawning on a per-world basis.
- Added config options to award experience to fainted Pokémon for opponents they helped defeat (`awardExperienceToFaintedPokemon`) and to still award experience for defeated enemies even after battle loss/forfeit (`awardExperienceOnBattleLoss`).
- Added `/givetm` command.
- Added advancement triggers for learning TMs: `cobblemon:has_learn_specific_tm` (per-TM), `cobblemon:has_learn_all_tm` (all TMs learned), and `cobblemon:tms_learned` (count-based), backed by a new `totalTMLearnedCount` on player advancement data.
- Added `cobblemon:catch_alpha_pokemon` advancement trigger and `totalAlphaCaptureCount` stat for captured Alpha Pokémon.
-
-### New rideable Pokémon
- Crobat
- Skarmory
- Milotic
- Archeops
- Goodra
- Goodra (Hisuian Form)
- Drampa
- Duraludon
- Archaludon
-
-### Pokémon Added
-#### Generation 3
- Wurmple
- Silcoon
- Beautifly
- Cascoon
- Dustox
- Skitty
- Delcatty
- Seviper
- Zangoose
-
-#### Generation 4
- Cherubi
- Cherrim
- Stunky
- Skuntank
-
-#### Generation 5
- Audino
- Pawniard
- Bisharp
-
-#### Generation 6
- Pancham (+ Cosmetic with Black Glasses)
- Pangoro (+ Cosmetic with Black Glasses)
-
-#### Generation 7
- Rockruff
- Lycanroc
-
-#### Generation 8
- Rolycoly
- Carkol
- Coalossal
- Runerigus
- Snom
- Frosmoth
- Indeedee
- Duraludon
- Applin
- Flapple
- Appletun
-
-#### Generation 9
-
- Nymble
- Lokix
- Kingambit
- Dipplin
- Archaludon
- Hydrapple
-
-#### Regional Forms
- Sandshrew (Alolan Form)
- Sandslash (Alolan Form)
- Yamask (Galarian Form)
- Avalugg (Hisuian Form)
-
-### Model updates for the following Pokémon
-
- Sandshrew
- Sandslash
- Nidoking
- Zubat
- Golbat
- Crobat
- Ditto
- Porygon
- Porygon2
- Porygon-Z
- Skarmory
- Smoochum
- Jynx
- Popplio
- Brionne
- Primarina
- Fletchling
- Fletchinder
- Talonflame
- Sableye
- Mawile
- Goomy
- Sliggoo
- Goodra
- Nacli
- Naclstack
- Garganacl
- Bidoof
- Cranidos
- Chatot
- Yamask
- Cofagrigus
- Tyranitar
- Turtonator
- Golett
- Corsola
- Arbok (New Patterns: Angry, Cartoon, Clown, Comedic, Crow, Grin, Ink, Modern, Rain, Scribble, Silence, Sloth, Suspicious, Will)
- ... and Substitute
-
-#### Model changes to the regional bias resource pack:
- Added Mime Jr. (Galar Bias)
- Added Bergmite (Hisui Bias)
- Changed models for every existing regional bias
-
-### Animation updates for the following Pokémon
-
- Kakuna
- Grimer
- Nidoran♀ (+ New shoulder mount)
- Nidorina
- Nidoran♂ (+ New shoulder mount)
- Sandshrew
- Diglett
- Dugtrio
- Graveler
- Happiny
- Chansey
- Blissey
- Poliwhirl
- Poliwrath
- Zubat
- Vulpix
- Drowzee
- Hypno
- Noctowl
- Skarmory
- Skitty
- Flygon
- Shellos
- Riolu
- Lucario
- Purrloin
- Liepard
- Joltik
- Galvantula
- Nidoking
- Fletchling
- Fletchinder
- Talonflame
- Archeops
- Drampa
- Sewaddle
- Swadloon
- Leavanny
- Goomy
- Sliggoo
- Goodra
- Shedinja
- Skwovet
- Greedent
- Bidoof
- Cranidos
- Chatot
- Yamask
- Cofagrigus
- Luvdisc
- Staryu
- Starmie
- Togetic
- Rellor
- Rabsca
- Yungoos
- Gumshoos
- Cottonee
- Whimsicott
- Corsola
-
-#### Added sounds to the following moves
-
- Absorb
- Aurora Beam
- Double Team
- Draco Meteor
- Fire Punch
- Fire Spin
- Flame Charge
- Flame Wheel
- Giga Drain
- Ice Punch
- Leech Life
- Magical Leaf
- Mega Drain
- Minimize
- Poison Gas
- Rock Throw
- Scary Face
- Seed bomb
- Smokescreen
- String Shot
- Tail Whip
-
-### Changes
- Removed the penalty for block destruction speed when on a hover mount, making them better for digging.
- Golden Apples can now be crafted using the Applin Apples.
- Prismarine Crystals and Amethyst Shards can now be used to craft Pokedexes.
- Updated Pokédex Screens item tag to support tagged variants of Redstone and Glowstone Dust.
- Sharp Beak can now be crafted using bones and Flying Gems.
- Metal Alloy can now be crafted using iron and Thunder Stones.
- Ability Capsules can now be brewed from Medicinal Brew and Dragon Breath.
- Using an Ability Capsule will now return an Empty Bottle.
- Decreased the default pastured wander radius to 32 blocks.
- Added alternate versions of the basic PC Wallpapers based on the original design of Cobblemon's PC, before public release.
- Rooted Arch Ruins, Crumbling Arch Ruins, and all fossil structures have been improved so that they generate more naturally in terrain.
- Gimmighoul towers now generate at ground-level rather than sinking one block into the ground.
- All ruin structures that did not generate with a gimmighoul/gilded chest before will now generate with one.
- All ruin structures gilded chest loot tables have been updated to include a guaranteed TM not learned naturally by any Pokémon through their level-up moveset. Each ruin gets its own specific TM, so you can now go hunting ruins to complete your move dex!
- The Prehistoric Underwater Fissure and Prehistoric Submerged Impact fossil structures now use the biome tag `#cobblemon:is_temperate_ocean`.
- The lush shipwreck cove's phantom mob spawner has been replaced with breezes.
- Shipwreck coves now generate slightly more frequently.
- Added equipment loot tables for shipwreck cove enemies.
- Maps from abandoned fishing boats leading to shipwreck coves now will skip explored chunks, allowing the player to find more shipwreck coves more easily.
- All shipwreck coves' spawners have been adjusted to give compatible mobs enchanted iron or diamond armour and weapons while in its ominous state. The armour given to the mobs will also use the automaton trim. We upped the difficulty because it was too easy now that your Pokémon can fight for you.
- One TM of the elemental hyper beams has been added as guaranteed loot to the main treasure chest in every shipwreck cove. (Magma Cove gets Blast Burn, Lush Cove gets Frenzy Plant, and Submerged Cove gets Hydro Cannon.)
- The following items can now be obtained by brushing the following Pokémon:
-    - Pink Wool - Wigglytuff
-    - White Wool - Swablu, Altaria
-    - Shed Shell - Ekans, Arbok, Dratini, Dragonair, Dunsparce, Treecko, Grovyle, Sceptile, Seviper, Scraggy, Scrafty, Helioptile, Heliolisk, Salandit, Salazzle, Sobble, Drizzile, Inteleon, Silicoblra, Sandaconda, Toxel, Toxtricity, Orthworm, Dudunsparce
-    - Phantom Membrane - Dreepy, Drakloak, Dragapult
- The following items can now be obtained by evolving the following Pokémon into any of their evolutions:
-    - Turtle Scute - Squirtle, Wartortle, Turtwig, Grotle, Tirtouga, Chewtle
-    - Shed Shell - Metapod, Kakuna, Ekans, Paras, Venonat, Krabby, Scyther, Kabuto, Dratini, Dragonair, Ledyba, Spinarak, Yanma, Pineco, Dunsparce, GLigar, Pupitar, Treecko, Grovyle, Silcoon, Cascoon, Surskit, Nincada, Trapinch, Vibrava, Corphish, Anorith, Bagon, Shelgon, Kricketot, Burmy, Combee, Skorupi, Swadloon, Whirlipede, Dwebble, Scraggy, Karrablast, Joltik, Larvesta, Spewpa, Clauncher, Helioptile, Charjabug, Crabrawler, Cutiefly, Dewpider, Salandit, Wimpod, Poipole, Sobble, Drizzile, Dottler, Silicobra, Toxel, Sizzlipede, Snom, Tarountula, Nymble, Rellor
- Saccharine Leaves now drop Tart, Sweet, or Syrupy Apples, depending on their honey coating stage, instead of vanilla Apples.
- Fixed the height of the Tumblestone Bud items when held in hand, placed on head, viewed in a GUI, and placed in an Item Frame.
- Refactored all advancements, removing several deemed unnecessary. Due to this cleanup, all previously obtained advancements will be reset besides the root (for picking a starter Pokémon). This sucks, and we're sorry. We had to do this eventually so better now than later.
- Forces between colliding hitboxes now factors in the weight of Pokémon.
- Improved berry tree performance on singleplayer and servers.
- Updated stat increase and decrease particle effects with the addition of alpha boost particles.
- Improved the performance of pasture blocks on singleplayer and servers.
- Changed the bait effects of the following items: (Vanilla) Sweet & Glow Berries, Golden & Enchanted Golden Apples (Cobblemon) Custap, Eggant, Hopo & Micle Berries, Sweet Hearts.
- Wild Pokémon now reliably have at least one offensive move if they can have offensive moves at that level. No more free lunches with Pokémon that can't even hurt you.
- Data Monitor can accept Disks (TMs, Music Disks, Upgrade, Dubious Disk, etc.) to change what's being displayed on the screen.
- The party overlay's experience-gained animation now displays the amount of EXP the Pokémon gained.
- Pressing the inventory key now closes the Pokémon interact wheel GUI.
- Updated the sound for harvesting Apricorns.
- Lowered the volume of harvesting berries.
- Improved compatibility with various mods
-    - Farmer's Delight's cutting board can now be used to strip Apricorn and Saccharine's logs, or salvage their planks from various blocks. It can also separate their boats from chests.
-    - Farmer's Delight's cutting board can be used to get two white dye from Pep-Up Flowers and two magenta dye from Medicinal Leeks.
-    - Farmer's Delight's cutting board can separate Tumblestone Blocks back into Tumblestones.
-    - Farmer's Delight's cutting board can salvage Type Gems from their Gem Blocks.
-    - Farmer's Delight's Onions, Tomatoes, and Cabbages can be used to cook Open-Faced Sandwiches. Nature's Spirit's Olives also can be used.
-    - Farmer's Delight's cutting board can be used on Hearty Grains to obtain rice and straw, similarly to Farmer's Delight's Rice Panicles.
-    - Farmer's Delight's Apple Pies and Apple Ciders can now be made using Applin Apples, alongside the Vanilla counterpart.
-    - Amendments allows for cooking Leek and Potato Stew in a Cauldron.
-    - Any mods that utilise Moonlight's Soft Fluid system can store Leek and Potato Stew, Medicinal Brew, Antidote, Awakening, Burn Heal, Ice Heal, Paralyze Heal, Full Heal, Potion, Super Potion, Hyper Potion, Max Potion, Full Restore, Ability Capsules, Moomoo Milk, and Berry Juice in liquid form (such as Suplementaries' Jar or Goblet, or Cauldrons while using Amendments).
-    - Supplementaries' Hourglass can now use Bright Powder, Quick Powder, Metal Powder, Heal Powder, Silver Powder, and Remedy.
-    - Berry Trees are now compatible with the Planter properly
-    - Saccharine Way Signs (added by Supplementaries automagically) now use a premade texture to prevent odd visual issues.
-    - Supplementaries' Jar can now store various Cobblemon cookies, candies, and similar items.
-    - Some of Supplementaries' items have been added to the `#cobblemon:held/container_held_items` item tag, including sacks, safes, and lunch baskets.
-    - Experience Nuggets can be used in place of Sculk for making the EXP Candies if using Create.
-    - Rage Candy Bar has a Create Mixing recipe.
-    - All Cobblemon ores can now be crushed in Create's Crushing Wheels. All Gem and Tumblestone Clusters can be crushed for automatic, low return, gems.
-    - Hearty Grains can be milled like Farmer's Delight Rice Panicles if both Farmer's Delight and Create are installed.
-    - Big Roots and Revival Herbs can be milled to their respective powders.
-    - Pep-Up Flowers, Medicinal Leeks, and all 70 berries can be milled in Create's Millstone for additional dye drops.
-    - Auspicious Armour and Upgrades can be Haunted using Create's crafting systems.
-    - Applin Apples can be used to make Honeyed Apples in Create.
- Sounds for interacting with various Cobblemon blocks now play from the centre of the block, rather than the corner. You probably didn't notice.
- Dragonite's mailbag cosmetic can now also be obtained with a chest in the cosmetic slot.
- Adjusted the walk speed for Croagunk and Aerodactyl.
- The `/pc` command no longer plays PC activation sounds
- Pressing the Summary key while either the starter selection or summary screen are open now closes those screens.
- Ice type Pokémon are now immune to Packed Snow.
- Added cobweb block slowness immunity for spider Pokémon
-
-### Fixes
- Fixed rare Pokémon being far too likely to spawn multiple times in a single spawn cycle. The dev told me that the exact bug is too complicated to explain.
- Fixed Omanyte and Omastar incorrectly using water animations on land.
- Fixed Pokédex layout for genderless variations.
- Fixed odd stacking behaviour with Poké Baits.
- Fixed a compatibility issue with World Game Rules which caused some log spam in specific cases.
- Fixed improper validation of Pokémon when performing a trade.
- Fixed an issue where particles like beams can disappear when you don't see the beginning of the beam, or you look away.
- Fixed Bedrock particle materials sometimes being incorrectly invisible from some sides.
- Fixed an occasional crash on retrieving revived fossils.
- Fixed brushing not working on Neoforge. Again.
- Fixed braking not working for submarine-style mounts (whoops).
- Fixed strafing not having the same friction as forward movement (funny whoops).
- Fixed submarine-style mounts' surface-water animations not playing when supposed to.
- Fixed submarine-style mounts' camera freaking out when looking up or down on the surface.
- Fixed pastured Pokémon despawning and running away.
- Fixed Apricorn trees crashing when other mods bonemeal them.
- Fixed the issue that caused hover-style mounts without a ground style to be rendered useless upon touching the ground on a server.
- Fixed horizontal and vertical collisions with hover-style mounts so they no longer accumulate or retain momentum.
- Fixed NeoForge brewing stand unexpectedly crashing users when shift clicking items within its menu. Well, I suppose all crashes are unexpected. You know what I mean.
- Fixed NPCs switching Pokémon very often during battles.
- Fixed Campfire Pot causing crashes under certain circumstances.
- Fixed Type Gems not being consumed upon use in battles.
- Fixed several Ancient Pokéball's not using the correct capture multiplier.
- Fixed a server warning that could occur when recalling Pokémon.
- Fixed sliding particles incorrectly handling block collision.
- Fixed Full Heal not curing status conditions in battle. Literally it's one job.
- Fixed a rare issue with battles locking up when you are forced to switch, with the switch menu appearing instantly.
- Fixed the combined effects of Pledge moves having broken Showdown message handling and localisation.
- Fixed a very niche issue where structures would spawn in an incorrect location, creating very funky world gen.
- Fixed Galarian Ponyta missing its cry.
- Fixed various log warnings caused by redundant files and sound events.
- Traded Pokémon will now retain the original friendship level when traded back to its OT.
- Tumblestone Clusters now display correctly on maps.
- Fixed removing mulch from berry trees with a shovel not working. That was meant to be a thing.
- Fixed collecting honey from Saccharine Leaf blocks deleting Honey Bottles when the inventory was full.
- Fixed Stripped Saccharine Wood recipe being... not there.
- Fixed some performance issues with a kind of sound event causing lag by attempting to create sounds every tick when out of range of hearing.
- Fixed stat-reducing Aprijuice not being possible to apply on a maxed out Pokémon. Also fixed the possibility of going into negatives.
- Fixed exploit where you could take out the bait or drop your Pokérod with bait to avoid consuming bait, now the bobber will just disappear if you do so.
- Fixed Apricorn and Saccharine boats incorrectly using chest boat models.
- Fixed wild and trainer battle AI refusing to select moves with the `adjacentAlly` target type, even when it's their only option.
- Fixed gilded chests being more accessible than intended.
- Fixed fished up Pokémon not being added as "seen" to the Pokédex.
- Fixed surprised Gimmighoul encounters not being added as "seen" to the Pokédex.
- Fixed a crash involving berry trees that have been world edited.
- Fixed visual desync in multiplayer for players mounting Pokémon outside other players' loaded chunks.
- Fixed Pokémon entities leveled by rare candy not getting stronger as Minecraft entities unless recalled.
- Fixed a freeze during game load that occurred when multiple mods tried to load Cobblemon API classes at the same time.
- Lowered the volume of Blitzle and Zebstrika's cry (shut up!).
- Regional Foods will now prioritise being eaten instead of used for healing Pokémon - shift clicking will use it as healing.
- Resolved z-fighting (texture flickering) on Pokédex Models.
- Restored Ninjask's ability to do barrel rolls.
- Fixed Raichu (male) and Alolan Raichu (both genders) not displaying the correct Partner Cap when Pewter Crunchies are in the cosmetic slot.
- Fixed a crash caused by adding enchanted items to the Resurrection Machine.
- Fixed a crash that could occur when starting a PvN battle with only fainted Pokémon.
- Fixed the Remember Riding Camera config not being respected when dismounting and resolved the incompatibility with the Auto Third Person mod.
- Fixed Full Heal block not dropping Full Heals. Lmao.
- Fixed status cure items not returning an empty bottle when used.
- Fixed Panpour consuming its held item when evolving with a Water Stone.
- Fixed Smoked Tail Curry returning a Wooden Bowl when consumed despite it not being included in the recipe. Free bowls!
- Fixed `/giveallpokemon` not respecting the min and max arguments.
- Fixed the choose starter toast not disappearing when capturing a Pokémon instead of opening the starter selection screen.
- Fixed an issue where certain Sinister Tea seasonings were only applying as instant effects and would not apply over time.
- Long config option labels now scroll instead of overflowing in the configuration menu.
- Fixed some z-fighting and clipping on Dewott and Hisui-Bias Dewott.
- Eggant Berries can now be composted properly on NeoForge.
- Composting chances are now the same on NeoForge as on Fabric.
- Fixed problem where furnaces which had smelted Revival Herbs into Heal Powder in older versions would glitch out on trying to get the experience out of the block.
- Fixed the Battle AI not recognizing Surging Strikes as a multistrike move.
- Fixed Tentacool not using its swim animation when on water surface.
- Fixed Eevee using its left shoulder pose when in battle.
- Fixed Magikarp and Gyarados Jump Pattern resourcepacks replacing shiny textures of addons targeting Magikarp or Gyarados.
- Fixed Combee's pollinated texture overwriting the shiny and female textures.
- Fixed a colour mistake with Dracovish's shiny.
- Fixed Togedemaru's back spikes z-fighting.
- Fixed Sliggoo (+ Hisuian) evolving in the Nether and End where it can't actually rain.
- Corrected the scales, hitbox sizes, and eye heights for Ariados, Cetoddle, Durant, Galvantula, Klink, Lanturn, Lumineon, Mantine, Mantyke, Mudbray, Numel, Staravia, and Torkoal.
- Fixed Torkoal's walk speed not matching its animation. He will no longer move faster than Bunnelby and Buneary. This tortoise would've won.
- Fixed Lanturn T-posing due to missing ground walk and sleep animations.
- Fixed Oshawott and Dewott using their sleep animation in unintended scenarios.
- Fixed Dudunsparce and Maushold always having the same form instead of having the 1 in 100 chance of being different.
- Fixed bird mounts rapidly switching between their flying and gliding animations when flying at low speed.
- Fixed some battles being startable with fainted Pokémon in the initial sendout.
- Fixed random gender selection for forms with strict gender divides (such as Meowstic and Oinkologne) never choosing female (that's sexist).
- Fixed the "Press R to battle" prompt not disappearing after you finish your first battle, at least until you relogged.
- Fixed the composter block being listed as "composer" in the cosmetic items species feature
- Fixed Castform's forms being tagged as introduced in generation 4 instead of 3.
- Fixed Blitzle's base scale being `1` rather than the intended `0.8`.
- Fixed Magnezone's emissive layer for the shiny having the wrong name, thus displaying wrongly.
- Fixed Litleo not blinking.
-
-### Developer
- Added `PokeSnackSpawnerFactory` which allows influence registration on PokeSnack encounters.
- Added `FishingSpawnerFactory` which allows influence registration on fishing encounters.
- Added `BattleFleeAttemptEvent` fired from `PokemonBattle.checkFleeAttempt`, allowing developers to intercept and control flee attempts.
- Tweaked the spawning selector interface to take a bucket function rather than a bucket directly.
- Added a new `cobblemon:height_range` processor type to allow developers to restrict structure-spawning ranges.
- Separated all the functions of MoLangFunctions.kt into their own files.
- Spawn buckets and their base weights are now provided by the spawner, with different base weights for world, fishing, snack, and habitat spawn buckets.
- Removed "SpawnBucket" class in favour of just storing maps of bucket names to weights.
- Fixed nicknames not being applied to Pokémon spawned from `spawn_pool_world` files.
- Added support for `profilePokedexScale`, `profilePokedexTranslation`, `profileSummaryScale`, and `profileSummaryTranslation` in poser files for finer control over profile displays.
- Fixed riding camera offsets defined on Pokémon forms not being applied.
- Marks can now provide aspects.
-
-### Molang & Datapacks
- Added `moveset_builders` datapack folder for different styles of movesets.
- Added `party_pools` datapack folder for defining groups of Pokémon for complex NPC party definitions.
- Added `party_compositions` datapack folder for arranging parties on NPCs that rely on party pools.
- Added `composed_pool` NPC party provider type which combines a party pool with a party composition to create more complex NPC parties.
- Added basic chatter NPC Behaviour.
- Added `q.item.is_enchanted()`.
- Added `q.item.has_enchantment(minecraft:sharpness, 3)`.
- Added `has_chosen_starter` and `get_starter_uuid` as available Molang functions.
- Added `has_tm_move_unlocked`, `unlock_tm_move`, and `lock_tm_move` as available Molang functions for Players.
- Added `marks`, `has_mark`, and `remove_marks` as available Molang functions for Pokémon.
- Added Data Component support for species drops, eg `"components": {"minecraft:custom_model_data": 123}`
- Added the new `sortOrder` field to mark entries, (defaults to 0 if not specified) which controls the order in which marks are rendered on the HUD, with higher numbers being rendered on top of lower numbers.
- Added optional `order` field to starter categories. It will allow explicitly sorting categories in the starter selection screen.
- SpeciesAdditions append vs override now matches the wiki documentation.
- Added `weighted_choice` as a new feature type. It requires setting weights for each choice and allows developers to simplify the process of assigning random aspect choice based on marble chance.
- Added `q.world.spawn_loot_table_items(loot_table_id, x, y, z)` which spawns the items from the loot table at the position. Use type: `minecraft:chest` for the loot table.
- Added `q.pokemon.entity` to access the entity of Pokémon.
- Flamethrower and Seismic Toss had their action effect JSON cleaned up.
- Ride sounds can now be set as exclusive to passengers.
- Ride sounds no longer play when submerged unless specified with a new setting.
- NPC Trainers can now call a `command` animation when issuing a command in battle.
- Added a q.failed function to move action effects.
- Herd spawned Pokémon have their levels controlled differently. The `levelRange` property now acts as a pre-offset clamp instead of a filter, with a new `herdLevelRange` property to do the filter behaviour.
- `q.sound` now accepts three parameters (sound event, volume, and pitch) instead of just the sound event and pitch.
- Added a new layer property that makes a layer scroll in a direction. "scrolling": {"speedU": 0.1, "speedV": 0.1}
- Cleaned up seat data. Removed all now unused fields from seats in all species files. Also made locator seat names explicit in the species files (however, this doesn't break the legacy format)
-
-### Particles
-
-#### New Move Animations
- Blizzard
- Disarming Voice
- Draco Meteor
- Dragon Breath
- Dragon Rage
- Drain Punch
- Fairy Wind
- Fire Fang
- Gust
- Horn Drill
- Hydro Pump
- Ice Fang
- Leafage
- Leaf Storm
- Light Screen
- Night Shade
- Play Rough
- Pyro Ball
- Reflect
- Rock Slide
- Sonic Boom
- Sucker Punch
- Supersonic
- Thunder Fang
-
-#### Tweaks and Fixes (Moves)
-
- Confusion
- Dragon Claw
- Eruption
- Fire Punch
- Flame Burst
- Flame Charge
- Flamethrower
- Frost Breath
- Hypnosis
- Ice Punch
- Icy Wind
- Mud Sport
- Poison Fang
- Protect
- Psychic
- Quick Attack
- Rage Powder
- Razor Leaf
- Sand Attack
- Scratch
- Shadow Claw
- Sing
- Spore
- String Shot
- Tackle
- Tail Whip
- Thunder
- Thunder Punch
- Thunder Wave
- Water Gun
- Water Pulse
- Water Sport
-
-#### Miscellaneous Particles
-
- Added Wild Might particles for Alpha Pokémon.
- Updated stat increase and decrease particles.
-
-### Localization
- Updated translations for:
-    - Japanese
-    - German
-    - Spanish
-    - Ecuadorian Spanish
-    - Portuguese
-    - Brazilian Portuguese
-    - Simplified Chinese
-    - Traditional Chinese
-    - Korean
-    - Russian
@@ -1,41 +0,0 @@
-# Changelog
-## [1.8.1 (September 13th, 2026)](#1-8-1)
-
-### Animation updates for the following Pokémon
- Flapple, Appletun, Dipplin, Hydrapple (placeholder animations only).
-
-### Fixes
- Fixed a potential world generation stall caused by Type Gem clusters.
- Fixed Pokémon on shoulders not animating if they are visibly holding a held item.
- Fixed NPCs getting their own TM progress file.
- Fixed odd NeoForge crash due to a dependency being outdated. It will now correctly flag the dependency for being outdated.
- Fixed the TM Machine refusing move selections that the `unlockAllMoveDexMovesByDefault` config had made visible, leaving the move slot blank and the craft button unresponsive.
- Fixed the Beast Ball not applying its 0.1× penalty to Pokémon that are not Ultra Beasts.
- Fixed the Moon Ball reading the world's total elapsed time instead of the time of day, so its bonus applied during the day instead.
- Fixed the Love Ball never awarding its 2.5× opposite gender bonus, and matching species by display name instead of identifier.
- Fixed the Timer Ball being weaker than a regular Poké Ball on early turns and only reaching 4× on turn 14 instead of turn 10.
- Fixed the Luxury Ball only doubling Friendship gains of 1, leaving level up and berry gains unaffected.
- Fixed Rufflet, Braviary, and Hisuian Braviary flooding logs with errors about missing sound events.
- Fixed Pokémon property typos in Pangoro and Dedenne herd spawn files.
- Fixed unintentional watermelon cosmetic for Hisuian Electrode. 
- Fixed Blastoise having an unintentional passenger seat.
- Fixed form typo in Rockruff-Dusk spawn, preventing it from being able to spawn.
- Fixed the `stat_compare` and `stat_equal` evolution requirements crashing the game when given `special_attack` or `special_defence`, and made them treat any non-permanent stat as a failed requirement instead of crashing.
- Fixed Rowap and Jacoba berries not correctly altering Pokémon sizes when used as bait.
- Fixed Ampharos' eyes not emitting particles.
- Fixed Alolan Raticate's cry not playing.
- Fixed several incorrect light-based spawning conditions for ghosts and bugs. 
- Removed unused, placeholder habitat pools.
- Fixed Mantyke, Mantine, and Quaxly getting stuck in a recoil 'expression' during battles due to having an expression assigned as a recoil animation. 
- Fixed Lucario's aura particles not emitting.
- Fixed Lycanroc's head movement.
- Added head movement to Archaludon.
- Fixed Duraludon line not having their sleep animations.
- Fixed Diglett line not having their faint animations.
- Fixed Kingambit moving its legs while walking.
-
-### Localization
- Updated translations for:
-  - Brazilian Portuguese
-  - Simplified Chinese
-  - Japanese
@@ -1,8 +1,9 @@

 import utilities.isSnapshot
 import utilities.version
-import utilities.gitBranch
-import utilities.gitCommit
+import java.time.OffsetDateTime
+import java.time.ZoneOffset
+import java.time.format.DateTimeFormatter

 /*
 *
@@ -71,18 +72,6 @@ tasks.withType<Test> {
    }
 }

-// Git info lives in its own output dir (not processResources) so a new commit only rewrites this one file.
-val writeGitInfo by tasks.registering(WriteProperties::class) {
-    destinationFile = layout.buildDirectory.file("generated/gitInfo/cobblemon-git.properties")
-    property("commit", gitCommit())
-    property("branch", gitBranch())
-}
-sourceSets.main { output.dir(mapOf("builtBy" to writeGitInfo), layout.buildDirectory.dir("generated/gitInfo")) }
-
-tasks.processResources {
-    exclude("data/**/README.md")
-}
-
 sourceSets {
    main {
        blossom {
@@ -105,13 +94,11 @@ sourceSets {
                property("modid", "cobblemon")
                property("version", project.version())
                property("isSnapshot", if(rootProject.isSnapshot()) "true" else "false")
+                property("gitCommit", versioning.info.commit)
+                property("branch", versioning.info.branch)
                System.getProperty("buildNumber")?.let { property("buildNumber", it) }
+                property("timestamp", OffsetDateTime.now(ZoneOffset.UTC).format(DateTimeFormatter.ofPattern("MM/dd/yyyy hh:mm:ss")) + " UTC")
            }
        }
    }
 }
-
-// The platform jars are built from :common:jar, so the remapped common jars are only needed by `publish`
-tasks.assemble {
-    setDependsOn(dependsOn.filterNot { (it as? TaskProvider<*>)?.name in setOf("remapJar", "remapSourcesJar") })
-}
@@ -13,6 +13,5 @@ public interface ChannelDuck {
    void cobblemon$inverseAttenuation(float rolloffFactor);
    void cobblemon$clearFilters();

-    void cobblemon$applyReverb(float decayTime, float gain, float diffusion, float density);
-    void cobblemon$clearReverb();
+//    void cobblemon$exponentialAttenuation(float rolloff, float refDistance, float maxDistance);
 }
@@ -1,24 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.duck;
-
-import net.minecraft.resources.ResourceKey;
-import net.minecraft.world.level.Level;
-
-import java.util.Optional;
-
-/**
- * Duck that facilitates getting a level key for a given level.
- *
- * @author dualspiral
- * @since August 30th, 2026
- */
-public interface MinecraftServerDuck {
-    Optional<ResourceKey<Level>> cobblemon$getLevelKey(Level level);
-}
@@ -1,21 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.duck;
-
-import net.minecraft.resources.ResourceLocation;
-
-/**
- * Duck that facilitates getting a level key that we store on the level.
- *
- * @author dualspiral
- * @since August 30th, 2026
- */
-public interface ServerLevelDuck {
-    ResourceLocation cobblemon$getLevelResourceLocation();
-}
@@ -0,0 +1,70 @@
+/*
+ * 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.ChannelDuck;
+import com.mojang.blaze3d.audio.Channel;
+import org.lwjgl.openal.AL10;
+import org.lwjgl.openal.EXTEfx;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+
+@Mixin(Channel.class)
+public abstract class ChannelMixin implements ChannelDuck {
+
+    @Shadow
+    private int source;
+
+    // Id of filter applied when sound is obstructed
+    private int cobblemon$lowPassFilterId = 0;
+
+    @Override
+    public void cobblemon$applyLowPassFilter(float gain, float hfGain) {
+        // Delete old filter if it exists
+        if (cobblemon$lowPassFilterId != 0) {
+            AL10.alSourcei(source, EXTEfx.AL_DIRECT_FILTER, 0); // Detach filter from source
+            EXTEfx.alDeleteFilters(cobblemon$lowPassFilterId);  // Delete old filter
+            cobblemon$lowPassFilterId = 0;
+        }
+
+        // Generate a fresh filter
+        int filterId = EXTEfx.alGenFilters();
+        if (!EXTEfx.alIsFilter(filterId)) {
+            System.err.println("Failed to create OpenAL low-pass filter");
+            return;
+        }
+
+        EXTEfx.alFilteri(filterId, EXTEfx.AL_FILTER_TYPE, EXTEfx.AL_FILTER_LOWPASS);
+        EXTEfx.alFilterf(filterId, EXTEfx.AL_LOWPASS_GAIN, gain);
+        EXTEfx.alFilterf(filterId, EXTEfx.AL_LOWPASS_GAINHF, hfGain);
+
+        AL10.alSourcei(source, EXTEfx.AL_DIRECT_FILTER, filterId);
+
+        // Save the new filter ID
+        cobblemon$lowPassFilterId = filterId;
+    }
+
+    @Override
+    public void cobblemon$inverseAttenuation(float rolloffFactor) {
+        AL10.alSourcei(source, AL10.AL_DISTANCE_MODEL, AL10.AL_INVERSE_DISTANCE);
+        AL10.alSourcef(source, AL10.AL_ROLLOFF_FACTOR,    rolloffFactor);
+        AL10.alSourcef(source, AL10.AL_REFERENCE_DISTANCE, 1.0f);
+        AL10.alSourcef(source, AL10.AL_MAX_DISTANCE,       0.0f);
+    }
+
+    @Override
+    public void cobblemon$clearFilters() {
+        AL10.alSourcei(source, EXTEfx.AL_DIRECT_FILTER, 0);
+
+        if (EXTEfx.alIsFilter(cobblemon$lowPassFilterId)) {
+            EXTEfx.alDeleteFilters(cobblemon$lowPassFilterId);
+            cobblemon$lowPassFilterId = 0;
+        }
+    }
+}
@@ -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));
+            }
+            Arrays
+                    .stream(pokemon.getOccupiedSeats())
+                    .filter(x -> !passengers.contains(x))
+                    .filter(Objects::nonNull)
+                    .forEach(Entity::stopRiding);
+
+            var occupiedSeats = Arrays.asList(pokemon.getOccupiedSeats());
+            passengers.stream()
+                    .filter(x -> !occupiedSeats.contains(x))
+                    .filter(Objects::nonNull)
+                    .forEach(x -> x.startRiding(pokemon, true));
+            ci.cancel();
+        }
+    }
+
+}
@@ -1,36 +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.CobblemonItemComponents;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.renderer.ItemModelShaper;
-import net.minecraft.client.resources.model.BakedModel;
-import net.minecraft.client.resources.model.ModelResourceLocation;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.item.ItemStack;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-@Mixin(ItemModelShaper.class)
-public class ItemModelShaperMixin {
-
-    @Inject(method = "getItemModel(Lnet/minecraft/world/item/ItemStack;)Lnet/minecraft/client/resources/model/BakedModel;", at = @At("HEAD"), cancellable = true)
-    public void getItemModel(ItemStack stack, CallbackInfoReturnable<BakedModel> cir) {
-        String eggModel = stack.get(CobblemonItemComponents.EGG_MODEL);
-        if (eggModel == null) return;
-
-        ModelResourceLocation modelResourceLocation = ModelResourceLocation.inventory(ResourceLocation.parse("cobblemon:egg/" + eggModel));
-        BakedModel bakedModel = Minecraft.getInstance().getModelManager().getModel(modelResourceLocation);
-        cir.setReturnValue(bakedModel);
-    }
-
-}
@@ -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();
-    }
-}
@@ -1,55 +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 net.minecraft.client.color.block.BlockColors;
-import net.minecraft.client.renderer.block.model.BlockModel;
-import net.minecraft.client.resources.model.BlockStateModelLoader;
-import net.minecraft.client.resources.model.ModelBakery;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.util.profiling.ProfilerFiller;
-import org.spongepowered.asm.mixin.Final;
-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.List;
-import java.util.Map;
-
-@Mixin(ModelBakery.class)
-public abstract class ModelBakeryMixin {
-
-    @Final
-    @Shadow
-    private Map<ResourceLocation, BlockModel> modelResources;
-
-    @Shadow
-    protected abstract void loadItemModelAndDependencies(ResourceLocation modelLocation);
-
-    @Inject(method = "<init>", at = @At("TAIL"))
-    private void cobblemon$loadEggModels(
-          BlockColors blockColors,
-          ProfilerFiller profilerFiller,
-          Map<ResourceLocation, BlockModel> modelResources,
-          Map<ResourceLocation, List<BlockStateModelLoader.LoadedJson>> blockStateResources,
-          CallbackInfo ci
-    ) {
-        for (ResourceLocation fileLocation : this.modelResources.keySet()) {
-            if (!fileLocation.getNamespace().equals("cobblemon")) continue;
-            String path = fileLocation.getPath();
-
-            if (!path.startsWith("models/item/egg/")) continue;
-            String modelPath = path.replace("models/item/", "").replace(".json", "");
-            ResourceLocation modelId = new ResourceLocation("cobblemon", modelPath);
-            this.loadItemModelAndDependencies(modelId);
-        }
-    }
-}
@@ -1,52 +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.block.entity.DiscShelfBlockEntity;
-import net.minecraft.core.BlockPos;
-import net.minecraft.core.Holder;
-import net.minecraft.sounds.SoundEvent;
-import net.minecraft.sounds.SoundEvents;
-import net.minecraft.world.level.Level;
-import net.minecraft.world.level.block.NoteBlock;
-import net.minecraft.world.level.block.state.properties.NoteBlockInstrument;
-import net.minecraft.world.level.block.entity.BlockEntity;
-import net.minecraft.world.level.block.state.BlockState;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-@Mixin(NoteBlock.class)
-public abstract class NoteBlockMixin {
-    @Inject(method = "triggerEvent", at = @At("HEAD"), cancellable = true)
-    private void cobblemon$triggerTMShelfSequencer(BlockState state, Level level, BlockPos pos, int type, int data, CallbackInfoReturnable<Boolean> cir) {
-        final BlockPos shelfPos = pos.below();
-        final BlockEntity blockEntity = level.getBlockEntity(shelfPos);
-        if (!(blockEntity instanceof DiscShelfBlockEntity discShelfBlockEntity)) {
-            return;
-        }
-
-        if (!level.isClientSide) {
-            final BlockPos instrumentPos = shelfPos.below();
-            final SoundEvent soundEvent;
-            if (level.getBlockState(instrumentPos).isAir()) {
-                soundEvent = SoundEvents.NOTE_BLOCK_BIT.value();
-            } else {
-                final NoteBlockInstrument instrument = level.getBlockState(instrumentPos).instrument();
-                final Holder<SoundEvent> holder = instrument.getSoundEvent();
-                soundEvent = holder.value();
-            }
-            discShelfBlockEntity.onNoteBlockPulse(level, pos, soundEvent);
-        }
-
-        // Suppress vanilla note-block playback while it is on top of a TM Shelf.
-        cir.setReturnValue(false);
-    }
-}
@@ -19,10 +19,8 @@ import com.cobblemon.mod.common.mixin.accessor.TrackedEntityAccessor;
 import com.cobblemon.mod.common.net.messages.client.orientation.ClientboundUpdateDriverInputPacket;
 import com.cobblemon.mod.common.net.messages.client.orientation.ClientboundUpdateOrientationPacket;
 import com.cobblemon.mod.common.net.messages.client.pokemon.update.ClientboundUpdateRidingStatePacket;
-import com.cobblemon.mod.common.net.messages.client.pokemon.update.evolution.ClientboundSeatAssignmentPacket;
 import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
 import net.minecraft.network.protocol.Packet;
-import net.minecraft.network.protocol.game.ClientGamePacketListener;
 import net.minecraft.server.level.ChunkMap;
 import net.minecraft.server.level.ServerEntity;
 import net.minecraft.server.level.ServerLevel;
@@ -39,8 +37,6 @@ 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.List;
-import java.util.LinkedHashMap;
 import java.util.Set;
 import java.util.function.Consumer;

@@ -57,15 +53,12 @@ public abstract class ServerEntityMixin {
    private Matrix3f cobblemon$lastSentOrientation;
    @Unique
    private boolean cobblemon$lastSentActive;
-    @Unique
-    private List<Entity> cobblemon$lastSeatPassengers = List.of();

    @Inject(method = "sendChanges", at = @At("TAIL"))
    private void cobblemon$sendChanges(CallbackInfo ci) {
        cobblemon$sendOrientationChanges();
        cobblemon$sendRidingStateChanges();
        cobblemon$sendDriverInput();
-        cobblemon$sendOccupiedSeatsChange();
    }

    private void cobblemon$sendRidingStateChanges() {
@@ -108,22 +101,6 @@ public abstract class ServerEntityMixin {
        cobblemon$broadcast(new ClientboundUpdateDriverInputPacket(driverInput, entity.getId()));
    }

-    private void cobblemon$sendOccupiedSeatsChange() {
-        if (!(this.entity instanceof PokemonEntity pokemon)) return;
-
-        List<Entity> currentPassengers = pokemon.getPassengers();
-        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(pokemon.getId(), assignments));
-    }
-
    private void cobblemon$broadcast(NetworkPacket<?> packet) {
        if (!(entity.level() instanceof ServerLevel level)) return;
        ChunkMap chunkMap = level.getChunkSource().chunkMap;
@@ -138,4 +115,5 @@ public abstract class ServerEntityMixin {
            CobblemonNetwork.INSTANCE.sendPacketToPlayer(player, packet);
        }
    }
+
 }
@@ -8,69 +8,22 @@

 package com.cobblemon.mod.common.mixin;

-import com.cobblemon.mod.common.duck.MinecraftServerDuck;
-import com.cobblemon.mod.common.duck.ServerLevelDuck;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
 import net.minecraft.core.BlockPos;
-import net.minecraft.core.Holder;
-import net.minecraft.core.RegistryAccess;
-import net.minecraft.resources.ResourceKey;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.level.ServerLevel;
-import net.minecraft.util.profiling.ProfilerFiller;
 import net.minecraft.world.entity.LivingEntity;
-import net.minecraft.world.level.Level;
-import net.minecraft.world.level.dimension.DimensionType;
-import net.minecraft.world.level.storage.WritableLevelData;
 import net.minecraft.world.phys.AABB;
 import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;

 import java.util.List;
 import java.util.Optional;
-import java.util.function.Supplier;


@Mixin(ServerLevel.class)
-public abstract class ServerLevelMixin extends Level implements ServerLevelDuck {
-
-    // 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) {
@@ -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()
-                );
-    }
 }
@@ -23,7 +23,6 @@ import net.minecraft.client.sounds.ChannelAccess;
 import net.minecraft.client.sounds.SoundEngine;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.sounds.SoundSource;
-import net.minecraft.util.Mth;
 import net.minecraft.world.phys.Vec3;
 import org.jetbrains.annotations.Nullable;
 import org.spongepowered.asm.mixin.Final;
@@ -33,7 +32,6 @@ import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 import org.spongepowered.asm.mixin.injection.callback.LocalCapture;

 import java.util.Iterator;
@@ -110,17 +108,6 @@ public abstract class SoundEngineMixin implements SoundEngineDuck {
        }
    }

-    /**
-     * TM Shelf can intentionally push note-block pitches above vanilla's 2.0f ceiling for octave-up playback.
-     * Keep vanilla clamping for all other sounds.
-     */
-    @Inject(method = "calculatePitch", at = @At("HEAD"), cancellable = true)
-    private void cobblemon$allowExtendedNoteblockPitch(SoundInstance sound, CallbackInfoReturnable<Float> cir) {
-        if (sound.getLocation().getPath().startsWith("block.note_block.")) {
-            cir.setReturnValue(Mth.clamp(sound.getPitch(), 0.5F, 4.0F));
-        }
-    }
-
    /** Different behavior for resuming SoundInstances while a BattleMusicInstance is being played. We do not want to resume filtered sounds. */
    @Inject(method = "resume()V", at = @At("HEAD"), cancellable = true)
    public void resume(CallbackInfo cb) {
@@ -8,25 +8,21 @@

 package com.cobblemon.mod.common.mixin;

-import com.cobblemon.mod.common.mixin.accessor.SinglePoolElementAccessor;
-import com.cobblemon.mod.common.world.structureprocessors.HeightRangeStructureProcessor;
+import com.cobblemon.mod.common.world.CobblemonStructureIDs;
 import com.llamalad7.mixinextras.sugar.Local;
 import net.minecraft.core.Holder;
 import net.minecraft.core.RegistryAccess;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.ResourceLocation;
 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;
@@ -34,70 +30,38 @@ 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.Arrays;
+import java.util.HashSet;
+import java.util.Set;
 import java.util.function.Predicate;

@Mixin(Structure.class)
 public abstract class StructureMixin {
+    // Define a set of structures that should not spawn below Sea Level
+    @Unique
+    private static final Set<ResourceLocation> RESTRICTED_STRUCTURES = new HashSet<>(Arrays.asList(
+            CobblemonStructureIDs.STONJOURNER_HENGE,
+            CobblemonStructureIDs.LUNA_HENGE,
+            CobblemonStructureIDs.SOL_HENGE
+    ));

-	/**
-	 * 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();
-	}
+    @Inject(method = "generate", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/level/levelgen/structure/StructureStart;isValid()Z"),
+            cancellable = true)
+    public void cobblemon$isValid(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) {
+        ResourceLocation structureKey = registryAccess.registryOrThrow(Registries.STRUCTURE).getKey((Structure) (Object) this);
+        if(!RESTRICTED_STRUCTURES.contains(structureKey)) {
+            return;
+        }
+        for (StructurePiece piece : structureStart.getPieces()) {
+            if (piece.getBoundingBox().minY() < chunkGenerator.getSeaLevel()) {
+                cir.setReturnValue(StructureStart.INVALID_START);
+                return;
+            }
+        }
+    }
 }
@@ -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();
-}
-
@@ -1,29 +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.client;
-
-import com.cobblemon.mod.common.client.CobblemonClient;
-import net.minecraft.client.Minecraft;
-import net.minecraft.world.entity.Entity;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-@Mixin(Minecraft.class)
-public class AIDebugGlowMixin {
-
-    @Inject(method = "shouldEntityAppearGlowing", at = @At("HEAD"), cancellable = true)
-    public void cobblemon$debugEntityGlow(Entity entity, CallbackInfoReturnable<Boolean> cir) {
-        if (entity.getId() == CobblemonClient.INSTANCE.getDebuggedEntityId()) {
-            cir.setReturnValue(true);
-        }
-    }
-
-}
@@ -1,123 +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.client;
-
-import com.cobblemon.mod.common.duck.ChannelDuck;
-import com.mojang.blaze3d.audio.Channel;
-import org.lwjgl.openal.AL10;
-import org.lwjgl.openal.AL11;
-import org.lwjgl.openal.EXTEfx;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-
-@Mixin(Channel.class)
-public abstract class ChannelMixin implements ChannelDuck {
-
-    @Shadow
-    private int source;
-
-    // Ids of effects applied to the channel
-    private int cobblemon$lowPassFilterId = 0;
-    private int cobblemon$reverbEffectId = 0;
-    private int cobblemon$reverbSlotId = 0;
-
-    @Override
-    public void cobblemon$applyLowPassFilter(float gain, float hfGain) {
-        // Delete old filter if it exists
-        if (cobblemon$lowPassFilterId != 0) {
-            AL10.alSourcei(source, EXTEfx.AL_DIRECT_FILTER, 0); // Detach filter from source
-            EXTEfx.alDeleteFilters(cobblemon$lowPassFilterId);  // Delete old filter
-            cobblemon$lowPassFilterId = 0;
-        }
-
-        // Generate a fresh filter
-        int filterId = EXTEfx.alGenFilters();
-        if (!EXTEfx.alIsFilter(filterId)) {
-            System.err.println("Failed to create OpenAL low-pass filter");
-            return;
-        }
-
-        EXTEfx.alFilteri(filterId, EXTEfx.AL_FILTER_TYPE, EXTEfx.AL_FILTER_LOWPASS);
-        EXTEfx.alFilterf(filterId, EXTEfx.AL_LOWPASS_GAIN, gain);
-        EXTEfx.alFilterf(filterId, EXTEfx.AL_LOWPASS_GAINHF, hfGain);
-
-        AL10.alSourcei(source, EXTEfx.AL_DIRECT_FILTER, filterId);
-
-        // Save the new filter ID
-        cobblemon$lowPassFilterId = filterId;
-    }
-
-    @Override
-    public void cobblemon$inverseAttenuation(float rolloffFactor) {
-        AL10.alSourcei(source, AL10.AL_DISTANCE_MODEL, AL10.AL_INVERSE_DISTANCE);
-        AL10.alSourcef(source, AL10.AL_ROLLOFF_FACTOR,    rolloffFactor);
-        AL10.alSourcef(source, AL10.AL_REFERENCE_DISTANCE, 1.0f);
-        AL10.alSourcef(source, AL10.AL_MAX_DISTANCE,       0.0f);
-    }
-
-    @Override
-    public void cobblemon$clearFilters() {
-        AL10.alSourcei(source, EXTEfx.AL_DIRECT_FILTER, 0);
-
-        if (EXTEfx.alIsFilter(cobblemon$lowPassFilterId)) {
-            EXTEfx.alDeleteFilters(cobblemon$lowPassFilterId);
-            cobblemon$lowPassFilterId = 0;
-        }
-    }
-
-    @Override
-    public void cobblemon$applyReverb(float decayTime, float gain, float diffusion, float density) {
-        // Clean up existing reverb first if it exists
-        cobblemon$clearReverb();
-
-        // Create the effect object
-        int effectId = EXTEfx.alGenEffects();
-        if (!EXTEfx.alIsEffect(effectId)) {
-            System.err.println("Failed to create OpenAL reverb effect");
-            return;
-        }
-
-        EXTEfx.alEffecti(effectId, EXTEfx.AL_EFFECT_TYPE, EXTEfx.AL_EFFECT_REVERB);
-        EXTEfx.alEffectf(effectId, EXTEfx.AL_REVERB_DECAY_TIME, decayTime);
-        EXTEfx.alEffectf(effectId, EXTEfx.AL_REVERB_GAIN, gain);
-        EXTEfx.alEffectf(effectId, EXTEfx.AL_REVERB_DIFFUSION, diffusion);
-        EXTEfx.alEffectf(effectId, EXTEfx.AL_REVERB_DENSITY, density);
-
-        // Create auxiliary effect slot and load effect into it
-        int slotId = EXTEfx.alGenAuxiliaryEffectSlots();
-        if (!EXTEfx.alIsAuxiliaryEffectSlot(slotId)) {
-            System.err.println("Failed to create OpenAL auxiliary effect slot");
-            EXTEfx.alDeleteEffects(effectId);
-            return;
-        }
-
-        EXTEfx.alAuxiliaryEffectSloti(slotId, EXTEfx.AL_EFFECTSLOT_EFFECT, effectId);
-
-        // Route source through the slot — send 0, no direct filter
-        AL11.alSource3i(source, EXTEfx.AL_AUXILIARY_SEND_FILTER, slotId, 0, EXTEfx.AL_FILTER_NULL);
-
-        cobblemon$reverbEffectId = effectId;
-        cobblemon$reverbSlotId = slotId;
-    }
-
-    @Override
-    public void cobblemon$clearReverb() {
-        if (cobblemon$reverbSlotId != 0) {
-            // Detach source from slot
-            AL11.alSource3i(source, EXTEfx.AL_AUXILIARY_SEND_FILTER,
-                    EXTEfx.AL_EFFECTSLOT_NULL, 0, EXTEfx.AL_FILTER_NULL);
-            EXTEfx.alDeleteAuxiliaryEffectSlots(cobblemon$reverbSlotId);
-            cobblemon$reverbSlotId = 0;
-        }
-        if (cobblemon$reverbEffectId != 0) {
-            EXTEfx.alDeleteEffects(cobblemon$reverbEffectId);
-            cobblemon$reverbEffectId = 0;
-        }
-    }
-}
@@ -9,15 +9,10 @@
 package com.cobblemon.mod.common.mixin.client;

 import com.cobblemon.mod.common.Cobblemon;
-import com.cobblemon.mod.common.CobblemonItemComponents;
-import com.cobblemon.mod.common.CobblemonItems;
 import com.cobblemon.mod.common.ModAPI;
-import com.cobblemon.mod.common.api.breeding.EggTextures;
 import com.cobblemon.mod.common.item.PokeBallItem;
 import com.cobblemon.mod.common.item.PokedexItem;
 import com.cobblemon.mod.common.item.WearableItem;
-import com.cobblemon.mod.common.item.components.EggComponent;
-import com.cobblemon.mod.common.item.components.TMMoveComponent;
 import com.mojang.blaze3d.vertex.PoseStack;
 import net.minecraft.client.multiplayer.ClientLevel;
 import net.minecraft.client.renderer.ItemModelShaper;
@@ -58,29 +53,14 @@ public abstract class ItemRendererMixin {
        at = @At("HEAD"),
        cancellable = true
    )
-    private void cobblemon$overrideItemModel(ItemStack stack, ItemDisplayContext renderMode, boolean leftHanded, PoseStack matrices, MultiBufferSource multiBufferSource, int light, int overlay, BakedModel model, CallbackInfo ci) throws Exception {
-        boolean shouldBe2d = renderMode == ItemDisplayContext.GUI || renderMode == ItemDisplayContext.FIXED || stack.getItem() == CobblemonItems.POKEMON_EGG || stack.getItem() == CobblemonItems.TECHNICAL_MACHINE;
+    private void cobblemon$overrideItemModel(ItemStack stack, ItemDisplayContext renderMode, boolean leftHanded, PoseStack matrices, MultiBufferSource multiBufferSource, int light, int overlay, BakedModel model, CallbackInfo ci) {
+        boolean shouldBe2d = renderMode == ItemDisplayContext.GUI || renderMode == ItemDisplayContext.FIXED;
        ResourceLocation resourceLocation = null;
        if (shouldBe2d) {
-            if (stack.getItem() instanceof PokeBallItem pokeBallItem) {
-                resourceLocation = pokeBallItem.getPokeBall().getModel2d();
-            } else if (stack.getItem() instanceof PokedexItem pokedexItem) {
-                resourceLocation = pokedexItem.getType().getItemSpritePath();
-            } else if (stack.getItem() == CobblemonItems.POKEMON_EGG) {
-                EggComponent component = stack.get(CobblemonItemComponents.EGG_DATA);
-                if (component != null) {
-                    resourceLocation = EggTextures.getEggTexture(component.getIdentifier(), component.getVariant());
-                }
-            } else if (stack.getItem() == CobblemonItems.TECHNICAL_MACHINE) {
-                TMMoveComponent component = stack.get(CobblemonItemComponents.TM_MOVE);
-                if (component != null) {
-                    resourceLocation = new ResourceLocation(Cobblemon.MODID, "tm/" + component.getMove().getElementalType().showdownId() + "_tm");
-                }
-            }
-        }
-        if (renderMode != ItemDisplayContext.HEAD && stack.getItem() instanceof WearableItem wearableItem) {
-            resourceLocation = wearableItem.getModel2d();
+            if (stack.getItem() instanceof PokeBallItem pokeBallItem) resourceLocation = pokeBallItem.getPokeBall().getModel2d();
+            else if (stack.getItem() instanceof PokedexItem pokedexItem) resourceLocation = pokedexItem.getType().getItemSpritePath();
        }
+        if (renderMode != ItemDisplayContext.HEAD && stack.getItem() instanceof WearableItem wearableItem) resourceLocation = wearableItem.getModel2d();

        if (resourceLocation != null) {
            BakedModel replacementModel = this.itemModelShaper.getModelManager().getModel(new ModelResourceLocation(resourceLocation, "inventory"));
@@ -23,7 +23,6 @@ import com.cobblemon.mod.common.duck.RidePassenger;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
 import com.cobblemon.mod.common.net.messages.server.orientation.ServerboundUpdateOrientationPacket;
 import com.cobblemon.mod.common.net.messages.server.riding.ServerboundUpdateDriverInputPacket;
-import com.cobblemon.mod.common.net.messages.server.riding.ServerboundUpdatePassengerPositionPacket;
 import com.cobblemon.mod.common.net.messages.server.riding.ServerboundUpdateRiderRotationPacket;
 import com.mojang.authlib.GameProfile;
 import net.minecraft.client.CameraType;
@@ -149,22 +148,10 @@ public abstract class LocalPlayerMixin extends AbstractClientPlayer implements O
            cobblemon$lastRideYRot = rideYRot;
            cobblemon$lastRideEyePos = rideEyePos;

-            CobblemonNetwork.INSTANCE.sendToServer(
-                    new ServerboundUpdateRiderRotationPacket(rideXRot, rideYRot, rideEyePos)
-            );
+            CobblemonNetwork.INSTANCE.sendToServer(new ServerboundUpdateRiderRotationPacket(rideXRot, rideYRot, rideEyePos));
        }
-    }

-    @Inject(method = "rideTick", at = @At("TAIL"))
-    private void cobblemon$updatePassengerPosition(CallbackInfo ci) {
-        if (Minecraft.getInstance().player != (Object)this) return;
-        if (!(this.getVehicle() instanceof PokemonEntity pokemonEntity)) return;
-        if (pokemonEntity.getSeatForPassenger(this) == null) return;

-        var offset = this.position().subtract(pokemonEntity.position());
-        CobblemonNetwork.INSTANCE.sendToServer(
-                new ServerboundUpdatePassengerPositionPacket(this.getId(), offset)
-        );
    }

    @Unique
@@ -230,10 +217,9 @@ public abstract class LocalPlayerMixin extends AbstractClientPlayer implements O
    private void cobblemon$isHandsBusy(CallbackInfoReturnable<Boolean> cir) {
        Entity vehicle = this.getVehicle();
        if (vehicle instanceof PokemonEntity pokemonEntity) {
-            Seat seat = pokemonEntity.getSeatForPassenger(this);;
-            if (seat != null) {
-                cir.setReturnValue(seat.getHandsBusy());
-            }
+            int seatIndex = pokemonEntity.getPassengers().indexOf(this);
+            Seat seat = pokemonEntity.getSeats().get(seatIndex);
+            cir.setReturnValue(seat.getHandsBusy());
        }
    }

@@ -9,7 +9,8 @@
 package com.cobblemon.mod.common.mixin.client;

 import com.cobblemon.mod.common.client.CobblemonBakingOverrides;
-import net.minecraft.client.Minecraft;
+import java.util.List;
+import java.util.Map;
 import net.minecraft.client.color.block.BlockColors;
 import net.minecraft.client.renderer.block.model.BlockModel;
 import net.minecraft.client.resources.model.BlockStateModelLoader;
@@ -17,76 +18,29 @@ import net.minecraft.client.resources.model.ModelBakery;
 import net.minecraft.client.resources.model.ModelResourceLocation;
 import net.minecraft.client.resources.model.UnbakedModel;
 import net.minecraft.resources.ResourceLocation;
-import net.minecraft.server.packs.resources.Resource;
 import net.minecraft.util.profiling.ProfilerFiller;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
-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.CallbackInfo;

-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-
@Mixin(ModelBakery.class)
 public abstract class ModelLoaderMixin {
+
    @Shadow abstract UnbakedModel getModel(ResourceLocation resourceLocation);

    @Shadow protected abstract void registerModel(ModelResourceLocation modelId, UnbakedModel unbakedModel);

-    @Shadow protected abstract void loadItemModelAndDependencies(ResourceLocation resourceLocation);
-
-    @Unique
-    List<String> dynamicFolders = Arrays.asList("egg", "tm");
-
    @Inject(
-            method = "<init>",
-            at = @At(
-                    value = "INVOKE",
-                    target = "Lnet/minecraft/util/profiling/ProfilerFiller;popPush(Ljava/lang/String;)V",
-                    ordinal = 1
-            )
-    )
-    public void loadCustomItemModels(BlockColors blockColors,
-                                     ProfilerFiller profiler,
-                                     Map<ResourceLocation, BlockModel> jsonUnbakedModels,
-                                     Map<ResourceLocation, List<BlockStateModelLoader.LoadedJson>> blockStates,
-                                     CallbackInfo ci
-    ) {
-        /*
-         * The models/item/*.json's only get loaded if there's an item in the registry that actually asks for it. It
-         * naively looks for things in the root with an item ID and calls upon it, and some of those JSONs reference
-         * other model JSONs and so it cascades a little bit. Used for block models but more importantly here, sprites.
-         *
-         * The thing about the eggs (and TMs) is, we really want the eggs to be addon-compatible in a way that doesn't restrict
-         * the species that can have eggs, so we can't pre-plan all of them. This mixin looks for the things inside the
-         * egg subfolder (which won't get loaded automagically) and manually inserts them into the unbaked model list so
-         * Minecraft loads them for us. We'll then dynamically call these models from the ItemRendererMixin; so it's
-         * hacky at the init stage and hacky at the render stage. Pretty cool in the gameplay stage though.
-         *
-         * - Hiro
-         */
-
-        dynamicFolders.forEach(folder -> {
-            Map<ResourceLocation, Resource> map = Minecraft.getInstance().getResourceManager().listResources("models/item/" + folder, (t) -> true);
-            map.forEach((key, value) -> {
-                ResourceLocation resourceLocation = new ResourceLocation(key.getNamespace(), key.getPath().replace("models/item/", "").replace(".json", ""));
-                this.loadItemModelAndDependencies(resourceLocation);
-            });
-        });
-    }
-
-    @Inject(
-            method = "<init>",
-            at = @At("TAIL")
+        method = "<init>",
+        at = @At("TAIL")
    )
    public void init(BlockColors blockColors,
-                     ProfilerFiller profiler,
-                     Map<ResourceLocation, BlockModel> jsonUnbakedModels,
-                     Map<ResourceLocation, List<BlockStateModelLoader.LoadedJson>> blockStates,
-                     CallbackInfo ci) {
+        ProfilerFiller profiler,
+        Map<ResourceLocation, BlockModel> jsonUnbakedModels,
+        Map<ResourceLocation, List<BlockStateModelLoader.LoadedJson>> blockStates,
+        CallbackInfo ci) {
        CobblemonBakingOverrides.INSTANCE.getModels().forEach(bakingOverride -> {
            var unbakedModel = this.getModel(bakingOverride.getModelLocation());
            this.registerModel(bakingOverride.getModelIdentifier(), unbakedModel);
@@ -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
@@ -8,12 +8,8 @@ object CobblemonBuildDetails {
    const val VERSION = "{{ version }}"
    const val SNAPSHOT = {{ isSnapshot }}

-    // Read at runtime rather than templated in, so a new commit doesn't invalidate compiled code.
-    private val git = java.util.Properties().apply {
-        CobblemonBuildDetails::class.java.getResourceAsStream("/cobblemon-git.properties")?.use(::load)
-    }
-    @JvmField val GIT_COMMIT: String = git.getProperty("commit", "Not Specified")
-    @JvmField val BRANCH: String = git.getProperty("branch", "Not Specified")
+    const val GIT_COMMIT = "{{ gitCommit | default("Not Specified") }}"
+    const val BRANCH = "{{ branch | default("Not Specified") }}"

    fun smallCommitHash(): String {
        return this.GIT_COMMIT.substring(0, 7)
@@ -18,10 +18,10 @@ import com.cobblemon.mod.common.api.drop.EvolutionItemDropEntry
 import com.cobblemon.mod.common.api.drop.ItemDropEntry
 import com.cobblemon.mod.common.api.events.CobblemonEvents
 import com.cobblemon.mod.common.api.events.CobblemonEvents.DATA_SYNCHRONIZED
-import com.cobblemon.mod.common.api.habitats.HabitatPools
 import com.cobblemon.mod.common.api.interaction.RequestManager
 import com.cobblemon.mod.common.api.molang.MoLangLoadedFilesCache
 import com.cobblemon.mod.common.api.molang.ObjectValue
+import com.cobblemon.mod.common.api.npc.premades.PremadeNPCs
 import com.cobblemon.mod.common.api.permission.PermissionValidator
 import com.cobblemon.mod.common.api.pokeball.catching.calculators.CaptureCalculator
 import com.cobblemon.mod.common.api.pokeball.catching.calculators.CaptureCalculators
@@ -34,7 +34,6 @@ import com.cobblemon.mod.common.api.pokemon.feature.ChoiceSpeciesFeatureProvider
 import com.cobblemon.mod.common.api.pokemon.feature.FlagSpeciesFeatureProvider
 import com.cobblemon.mod.common.api.pokemon.feature.IntSpeciesFeatureProvider
 import com.cobblemon.mod.common.api.pokemon.feature.SpeciesFeatures
-import com.cobblemon.mod.common.api.pokemon.feature.WeightedChoiceSpeciesFeatureProvider
 import com.cobblemon.mod.common.api.pokemon.helditem.HeldItemProvider
 import com.cobblemon.mod.common.api.pokemon.stats.EvCalculator
 import com.cobblemon.mod.common.api.pokemon.stats.Generation8EvCalculator
@@ -54,10 +53,6 @@ import com.cobblemon.mod.common.api.storage.adapter.database.MongoDBStoreAdapter
 import com.cobblemon.mod.common.api.storage.adapter.flatfile.FileStoreAdapter
 import com.cobblemon.mod.common.api.storage.adapter.flatfile.JSONStoreAdapter
 import com.cobblemon.mod.common.api.storage.adapter.flatfile.NBTStoreAdapter
-import com.cobblemon.mod.common.api.storage.egg.EggStoreManager
-import com.cobblemon.mod.common.api.storage.egg.JsonEggStoreBackend
-import com.cobblemon.mod.common.api.storage.egg.MongoEggStoreBackend
-import com.cobblemon.mod.common.api.storage.egg.NbtEggStoreBackend
 import com.cobblemon.mod.common.api.storage.factory.FileBackedPokemonStoreFactory
 import com.cobblemon.mod.common.api.storage.molang.NbtMoLangDataStoreFactory
 import com.cobblemon.mod.common.api.storage.pc.PCStore
@@ -68,8 +63,6 @@ import com.cobblemon.mod.common.api.storage.player.adapter.DexDataMongoBackend
 import com.cobblemon.mod.common.api.storage.player.adapter.DexDataNbtBackend
 import com.cobblemon.mod.common.api.storage.player.adapter.PlayerDataJsonBackend
 import com.cobblemon.mod.common.api.storage.player.adapter.PlayerDataMongoBackend
-import com.cobblemon.mod.common.api.storage.player.adapter.TMMoveMongoBackend
-import com.cobblemon.mod.common.api.storage.player.adapter.TMMoveNbtBackend
 import com.cobblemon.mod.common.api.storage.player.factory.CachedPlayerDataStoreFactory
 import com.cobblemon.mod.common.api.tags.CobblemonEntityTypeTags
 import com.cobblemon.mod.common.api.tags.CobblemonItemTags
@@ -98,11 +91,9 @@ import com.cobblemon.mod.common.net.messages.client.settings.ServerSettingsPacke
 import com.cobblemon.mod.common.permission.LaxPermissionValidator
 import com.cobblemon.mod.common.platform.events.PlatformEvents
 import com.cobblemon.mod.common.pokemon.Pokemon
-import com.cobblemon.mod.common.pokemon.aspects.ALPHA_ASPECT
 import com.cobblemon.mod.common.pokemon.aspects.CHARACTERISTIC_RAINBOW_ASPECT
 import com.cobblemon.mod.common.pokemon.aspects.COSMETIC_SLOT_ASPECT
 import com.cobblemon.mod.common.pokemon.aspects.GENDER_ASPECT
-import com.cobblemon.mod.common.pokemon.aspects.MARK_ASPECT
 import com.cobblemon.mod.common.pokemon.aspects.SHINY_ASPECT
 import com.cobblemon.mod.common.pokemon.evolution.variants.BlockClickEvolution
 import com.cobblemon.mod.common.pokemon.feature.SlowpokeTailRegrowthSpeciesFeature
@@ -112,7 +103,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
@@ -120,7 +110,13 @@ import com.cobblemon.mod.common.pokemon.properties.UnaspectPropertyType
 import com.cobblemon.mod.common.pokemon.properties.UncatchableProperty
 import com.cobblemon.mod.common.pokemon.stat.CobblemonStatProvider
 import com.cobblemon.mod.common.starter.CobblemonStarterHandler
-import com.cobblemon.mod.common.util.*
+import com.cobblemon.mod.common.util.DataKeys
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.cobblemon.mod.common.util.ifDedicatedServer
+import com.cobblemon.mod.common.util.isLaterVersion
+import com.cobblemon.mod.common.util.party
+import com.cobblemon.mod.common.util.requestWallpapers
+import com.cobblemon.mod.common.util.server
 import com.cobblemon.mod.common.world.feature.CobblemonPlacedFeatures
 import com.cobblemon.mod.common.world.feature.ore.CobblemonOrePlacedFeatures
 import com.cobblemon.mod.common.world.gamerules.CobblemonGameRules
@@ -179,7 +175,6 @@ object Cobblemon {
    var storage = PokemonStoreManager()
    var molangData = NbtMoLangDataStoreFactory
    lateinit var playerDataManager: PlayerInstancedDataStoreManager
-    lateinit var eggStoreManager: EggStoreManager
    lateinit var starterConfig: StarterConfig
    val dataProvider: DataProvider = CobblemonDataProvider
    var permissionValidator: PermissionValidator by Delegates.observable(LaxPermissionValidator().also { it.initialize() }) { _, _, newValue -> newValue.initialize() }
@@ -212,8 +207,6 @@ object Cobblemon {
            this.LOGGER.info("  - Branch: ${CobblemonBuildDetails.BRANCH}")
        }

-        this.loadConfig()
-
        implementation.registerRecipeSerializers()
        implementation.registerRecipeTypes()
        implementation.registerPermissionValidator()
@@ -242,6 +235,7 @@ object Cobblemon {
        ExperienceGroups.registerDefaults()
        CaptureCalculators.registerDefaults()

+        this.loadConfig()
 //        CobblemonBlockPredicates.touch()
        CobblemonOrePlacedFeatures.register()
        CobblemonPlacedFeatures.register()
@@ -253,8 +247,6 @@ object Cobblemon {

        DATA_SYNCHRONIZED.subscribe {
            storage.onPlayerDataSync(it)
-            it.tmList().scheduleFullSyncFromStores(it.party(), it.pc())
-            it.pokedex().scheduleFullSyncFromStores(it.party(), it.pc())
            playerDataManager.syncAllToPlayer(it)
            starterHandler.handleJoin(it)
            it.requestWallpapers()
@@ -318,9 +310,6 @@ object Cobblemon {
            this.config.maxPokemonLevel,
            this.config.maxPokemonFriendship,
            this.config.maxDynamaxLevel,
-            this.config.unlockAllMoveDexMovesByDefault,
-            this.config.pokemonIntrinsicSizeMin,
-            this.config.pokemonIntrinsicSizeMax
        ).sendToPlayer(player)
    }

@@ -334,11 +323,8 @@ object Cobblemon {
        GENDER_ASPECT.register()
        COSMETIC_SLOT_ASPECT.register()
        CHARACTERISTIC_RAINBOW_ASPECT.register()
-        ALPHA_ASPECT.register()
-        MARK_ASPECT.register()

        SpeciesFeatures.types["choice"] = ChoiceSpeciesFeatureProvider::class.java
-        SpeciesFeatures.types["weighted_choice"] = WeightedChoiceSpeciesFeatureProvider::class.java
        SpeciesFeatures.types["flag"] = FlagSpeciesFeatureProvider::class.java
        SpeciesFeatures.types["integer"] = IntSpeciesFeatureProvider::class.java

@@ -360,7 +346,6 @@ object Cobblemon {
        CustomPokemonProperty.register(UnaspectPropertyType)
        CustomPokemonProperty.register(FreezeFrameProperty)
        CustomPokemonProperty.register(NoAIProperty)
-        CustomPokemonProperty.register(HeldItemVisibleProperty)

        CobblemonEvents.POKEMON_PROPERTY_INITIALISED.emit(Unit)

@@ -380,15 +365,9 @@ object Cobblemon {
        }
        PlatformEvents.SERVER_STARTING.subscribe { event ->
            val server = event.server
+            PremadeNPCs.onServerLoading(server)
            MoLangLoadedFilesCache.initialize(server)
            playerDataManager = PlayerInstancedDataStoreManager().also { it.setup(server) }
-            HabitatPools.onServerLoading(server)
-
-            val eggBackend = when (config.storageFormat) {
-                "nbt" -> NbtEggStoreBackend()
-                "json" -> JsonEggStoreBackend()
-                else -> null // MongoDB handled below
-            }

            val mongoClient: MongoClient?

@@ -401,12 +380,8 @@ object Cobblemon {
                    val pokedexNbtFactory = CachedPlayerDataStoreFactory(DexDataNbtBackend())
                    pokedexNbtFactory.setup(server)

-                    val tmMoveFactory = CachedPlayerDataStoreFactory(TMMoveNbtBackend())
-                    tmMoveFactory.setup(server)
-
                    playerDataManager.setFactory(generalJsonFactory, PlayerInstancedDataStoreTypes.GENERAL)
                    playerDataManager.setFactory(pokedexNbtFactory, PlayerInstancedDataStoreTypes.POKEDEX)
-                    playerDataManager.setFactory(tmMoveFactory, PlayerInstancedDataStoreTypes.TM_MOVES)

                    if (config.storageFormat == "nbt") {
                        NBTStoreAdapter(pokemonStoreRoot.absolutePath, useNestedFolders = true, folderPerClass = true)
@@ -433,18 +408,8 @@ object Cobblemon {
                        val pokedexMongoFactory = CachedPlayerDataStoreFactory(DexDataMongoBackend(mongoClient, config.mongoDBDatabaseName, "PokeDexCollection"))
                        pokedexMongoFactory.setup(server)

-                        val tmMovesMongoFactory = CachedPlayerDataStoreFactory(
-                                TMMoveMongoBackend(mongoClient, config.mongoDBDatabaseName, "TMMovesCollection")
-                        )
-                        tmMovesMongoFactory.setup(server)
-
                        playerDataManager.setFactory(generalMongoFactory, PlayerInstancedDataStoreTypes.GENERAL)
                        playerDataManager.setFactory(pokedexMongoFactory, PlayerInstancedDataStoreTypes.POKEDEX)
-                        playerDataManager.setFactory(tmMovesMongoFactory, PlayerInstancedDataStoreTypes.TM_MOVES)
-
-                        eggStoreManager = EggStoreManager(MongoEggStoreBackend(mongoClient, config.mongoDBDatabaseName))
-                        eggStoreManager.setup(server)
-
                        MongoDBStoreAdapter(mongoClient, config.mongoDBDatabaseName)
                    } catch (e: ClassNotFoundException) {
                        LOGGER.error("MongoDB driver not found.")
@@ -458,11 +423,6 @@ object Cobblemon {
            }
                .with(ReforgedConversion(server.getWorldPath(LevelResource.ROOT))) as FileStoreAdapter<*>

-            if (eggBackend != null) {
-                eggStoreManager = EggStoreManager(eggBackend)
-                eggStoreManager.setup(server)
-            }
-
            storage.registerFactory(
                priority = Priority.LOWEST,
                factory = FileBackedPokemonStoreFactory(
@@ -475,7 +435,6 @@ object Cobblemon {

        PlatformEvents.SERVER_STOPPED.subscribe {
            storage.unregisterAll(it.server.registryAccess())
-            eggStoreManager.shutdown()
            playerDataManager.saveAllStores()
            playerDataManager.saveExecutor.shutdown()
            playerDataManager.saveExecutor.awaitTermination(30L, TimeUnit.SECONDS)
@@ -634,7 +593,6 @@ object Cobblemon {
        this.implementation.registerCommandArgument(cobblemonResource("mark"), MarkArgumentType::class, SingletonArgumentInfo.contextFree(MarkArgumentType::mark))
        this.implementation.registerCommandArgument(cobblemonResource("transform_type"), TransformTypeArgumentType::class, SingletonArgumentInfo.contextFree(TransformTypeArgumentType::transformType))
        this.implementation.registerCommandArgument(cobblemonResource("model_part"), ModelPartArgumentType::class, SingletonArgumentInfo.contextFree(ModelPartArgumentType::modelPart))
-        this.implementation.registerCommandArgument(cobblemonResource("tm"), TmArgumentType::class, SingletonArgumentInfo.contextFree(TmArgumentType::tm))
    }

 }
@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common

 import com.bedrockk.molang.Expression
+import com.cobblemon.mod.common.CobblemonBehaviours.autoPokemonBehaviours
 import com.cobblemon.mod.common.CobblemonNetwork.sendPacket
 import com.cobblemon.mod.common.api.ai.CobblemonBehaviour
 import com.cobblemon.mod.common.api.ai.config.BehaviourConfig
@@ -21,18 +22,7 @@ import com.cobblemon.mod.common.api.molang.ExpressionLike
 import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
 import com.cobblemon.mod.common.api.reactive.SimpleObservable
 import com.cobblemon.mod.common.net.messages.client.data.BehaviourSyncPacket
-import com.cobblemon.mod.common.util.adapters.ActivityAdapter
-import com.cobblemon.mod.common.util.adapters.BehaviourConfigAdapter
-import com.cobblemon.mod.common.util.adapters.ExpressionAdapter
-import com.cobblemon.mod.common.util.adapters.ExpressionLikeAdapter
-import com.cobblemon.mod.common.util.adapters.ExpressionOrEntityVariableAdapter
-import com.cobblemon.mod.common.util.adapters.IdentifierAdapter
-import com.cobblemon.mod.common.util.adapters.MemoryModuleTypeAdapter
-import com.cobblemon.mod.common.util.adapters.ObjectiveConfigAdapter
-import com.cobblemon.mod.common.util.adapters.SenseConfigAdapter
-import com.cobblemon.mod.common.util.adapters.SensorTypeAdapter
-import com.cobblemon.mod.common.util.adapters.TaskConfigAdapter
-import com.cobblemon.mod.common.util.adapters.TranslatedTextAdapter
+import com.cobblemon.mod.common.util.adapters.*
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.cobblemon.mod.common.util.endsWith
 import com.google.gson.Gson
@@ -108,6 +98,7 @@ object CobblemonBehaviours : JsonDataRegistry<CobblemonBehaviour> {
                        autoNPCBehaviours.add(behaviour)
                    }
                    data[resolvedIdentifier] = behaviour
+                    behaviour.id = resolvedIdentifier
                }
            }
        }
@@ -8,16 +8,22 @@

 package com.cobblemon.mod.common

+import com.cobblemon.mod.common.block.entity.BerryBlockEntity
+import com.cobblemon.mod.common.block.entity.HealingMachineBlockEntity
+import com.cobblemon.mod.common.block.entity.PCBlockEntity
+import com.cobblemon.mod.common.block.entity.PokemonPastureBlockEntity
+import com.cobblemon.mod.common.block.entity.FossilAnalyzerBlockEntity
+import com.cobblemon.mod.common.block.entity.FossilMultiblockEntity
+import com.cobblemon.mod.common.block.entity.RestorationTankBlockEntity
+import com.cobblemon.mod.common.block.multiblock.FossilMultiblockBuilder
 import com.cobblemon.mod.common.block.entity.*
 import com.cobblemon.mod.common.block.entity.DisplayCaseBlockEntity
-import com.cobblemon.mod.common.block.habitat.HabitatBlockEntity
-import com.cobblemon.mod.common.block.multiblock.FossilMultiblockBuilder
 import com.cobblemon.mod.common.platform.PlatformRegistry
 import net.minecraft.core.Registry
 import net.minecraft.core.registries.BuiltInRegistries
 import net.minecraft.core.registries.Registries
-import net.minecraft.resources.ResourceKey
 import net.minecraft.world.level.block.entity.BlockEntityType
+import net.minecraft.resources.ResourceKey

 object CobblemonBlockEntities : PlatformRegistry<Registry<BlockEntityType<*>>, ResourceKey<Registry<BlockEntityType<*>>>, BlockEntityType<*>>() {

@@ -33,9 +39,6 @@ object CobblemonBlockEntities : PlatformRegistry<Registry<BlockEntityType<*>>, R
    @JvmField
    val LECTERN: BlockEntityType<LecternBlockEntity> = this.create("lectern", BlockEntityType.Builder.of(::LecternBlockEntity, CobblemonBlocks.LECTERN).build(null))

-    @JvmField
-    val DISC_SHELF: BlockEntityType<DiscShelfBlockEntity> = this.create("disc_shelf", BlockEntityType.Builder.of(::DiscShelfBlockEntity, CobblemonBlocks.DISC_SHELF).build(null))
-
    @JvmField
    val BERRY = this.create("berry", BlockEntityType.Builder.of(::BerryBlockEntity, *CobblemonBlocks.berries().values.toTypedArray()).build(null))

@@ -45,12 +48,7 @@ object CobblemonBlockEntities : PlatformRegistry<Registry<BlockEntityType<*>>, R
    val SIGN: BlockEntityType<CobblemonSignBlockEntity> = this.create("sign", BlockEntityType.Builder.of(::CobblemonSignBlockEntity, CobblemonBlocks.APRICORN_SIGN, CobblemonBlocks.APRICORN_WALL_SIGN, CobblemonBlocks.SACCHARINE_SIGN, CobblemonBlocks.SACCHARINE_WALL_SIGN).build(null))
    @JvmField
    val HANGING_SIGN: BlockEntityType<CobblemonHangingSignBlockEntity> = this.create("hanging_sign", BlockEntityType.Builder.of(::CobblemonHangingSignBlockEntity, CobblemonBlocks.APRICORN_HANGING_SIGN, CobblemonBlocks.APRICORN_WALL_HANGING_SIGN, CobblemonBlocks.SACCHARINE_HANGING_SIGN, CobblemonBlocks.SACCHARINE_WALL_HANGING_SIGN).build(null))
-    @JvmField
-    val TM_MACHINE: BlockEntityType<TMMachineBlockEntity> = this.create("tm_machine", BlockEntityType.Builder.of(::TMMachineBlockEntity, CobblemonBlocks.TM_MACHINE).build(null))
-    @JvmField
-    val HABITAT_BLOCK: BlockEntityType<HabitatBlockEntity> = this.create("habitat_block",
-            BlockEntityType.Builder.of(::HabitatBlockEntity, CobblemonBlocks.HABITAT_BLOCK).build(null)
-    )
+
    @JvmField
    val GILDED_CHEST: BlockEntityType<GildedChestBlockEntity> = this.create("chest", BlockEntityType.Builder.of(::GildedChestBlockEntity,
        CobblemonBlocks.GILDED_CHEST,
@@ -84,38 +82,6 @@ object CobblemonBlockEntities : PlatformRegistry<Registry<BlockEntityType<*>>, R
        ).build(null)
    )

-    val NEST: BlockEntityType<NestBlockEntity> = this.create("nest",
-        BlockEntityType.Builder.of(
-            ::NestBlockEntity,
-            CobblemonBlocks.NEST_FIERY,
-            CobblemonBlocks.NEST_GRASSY,
-            CobblemonBlocks.NEST_LEAFY,
-            CobblemonBlocks.NEST_ICY,
-            CobblemonBlocks.NEST_ROCKY,
-            CobblemonBlocks.NEST_SANDY,
-            CobblemonBlocks.NEST_SHROOMY,
-            CobblemonBlocks.NEST_TWIGGY,
-            CobblemonBlocks.NEST_HAY,
-            CobblemonBlocks.NEST_KELP,
-            CobblemonBlocks.NEST_WATERY
-        ).build(null))
-
-    val EGG: BlockEntityType<EggBlockEntity> = this.create("egg",
-            BlockEntityType.Builder.of(
-                ::EggBlockEntity,
-                CobblemonBlocks.EGG
-            ).build(null)
-        )
-
-    @JvmField
-    val INCUBATOR: BlockEntityType<IncubatorBlockEntity> = this.create("incubator",
-        BlockEntityType.Builder.of(
-            ::IncubatorBlockEntity,
-            CobblemonBlocks.INCUBATOR
-        ).build(null)
-    )
-
-
    @JvmField
    val DISPLAY_CASE: BlockEntityType<DisplayCaseBlockEntity> = this.create("display_case",
        BlockEntityType.Builder.of(::DisplayCaseBlockEntity, CobblemonBlocks.DISPLAY_CASE).build(null)
@@ -9,74 +9,22 @@
 package com.cobblemon.mod.common

 import com.cobblemon.mod.common.api.apricorn.Apricorn
-import com.cobblemon.mod.common.api.nest.WildNestType
-import com.cobblemon.mod.common.api.nest.WildNestVariant
 import com.cobblemon.mod.common.api.pokemon.stats.Stats
-import com.cobblemon.mod.common.block.ApricornBlock
-import com.cobblemon.mod.common.block.ApricornSaplingBlock
-import com.cobblemon.mod.common.block.BerryBlock
-import com.cobblemon.mod.common.block.BigRootBlock
-import com.cobblemon.mod.common.block.CoinPouchBlock
-import com.cobblemon.mod.common.block.DamagedMonitorBlock
-import com.cobblemon.mod.common.block.DecorativeItemBlock
-import com.cobblemon.mod.common.block.DiscShelfBlock
-import com.cobblemon.mod.common.block.DisplayCaseBlock
-import com.cobblemon.mod.common.block.EggBlock
-import com.cobblemon.mod.common.block.EjectButtonBlock
-import com.cobblemon.mod.common.block.EnergyRootBlock
-import com.cobblemon.mod.common.block.FossilAnalyzerBlock
-import com.cobblemon.mod.common.block.GalaricaWreathBlock
-import com.cobblemon.mod.common.block.HealingMachineBlock
-import com.cobblemon.mod.common.block.HeartyGrainsBlock
-import com.cobblemon.mod.common.block.IncubatorBlock
-import com.cobblemon.mod.common.block.LecternBlock
-import com.cobblemon.mod.common.block.MagnetBlock
-import com.cobblemon.mod.common.block.MedicinalLeekBlock
-import com.cobblemon.mod.common.block.MintBlock
-import com.cobblemon.mod.common.block.MintBlock.MintType
-import com.cobblemon.mod.common.block.MonitorBlock
-import com.cobblemon.mod.common.block.NestBlock
-import com.cobblemon.mod.common.block.NutBushBlock
-import com.cobblemon.mod.common.block.OrbBlock
-import com.cobblemon.mod.common.block.PCBlock
-import com.cobblemon.mod.common.block.PastureBlock
-import com.cobblemon.mod.common.block.PlaqueBlock
-import com.cobblemon.mod.common.block.PokeSnackBlock
-import com.cobblemon.mod.common.block.RestorationTankBlock
-import com.cobblemon.mod.common.block.RevivalHerbBlock
-import com.cobblemon.mod.common.block.SaccharineLeafBlock
-import com.cobblemon.mod.common.block.SaccharineLogBlock
-import com.cobblemon.mod.common.block.SaccharineLogSlatheredBlock
-import com.cobblemon.mod.common.block.ScarekrowBlock
-import com.cobblemon.mod.common.block.StackableItemBlock
-import com.cobblemon.mod.common.block.TumblestoneBlock
-import com.cobblemon.mod.common.block.TypeGemClusterBlock
-import com.cobblemon.mod.common.block.TypeGemCoreBlock
-import com.cobblemon.mod.common.block.VivichokeBlock
-import com.cobblemon.mod.common.block.WallAttachedDirectionalShapeBlock
-import com.cobblemon.mod.common.block.WallAttachedStackableItemBlock
-import com.cobblemon.mod.common.block.WildNestBlock
+import com.cobblemon.mod.common.block.*
 import com.cobblemon.mod.common.block.campfirepot.CampfireBlock
+import com.cobblemon.mod.common.block.LecternBlock
+import com.cobblemon.mod.common.block.MintBlock.MintType
 import com.cobblemon.mod.common.block.campfirepot.CampfirePotBlock
 import com.cobblemon.mod.common.block.chest.GildedChestBlock
-import com.cobblemon.mod.common.block.decor.ActivatableDecorationBlock
-import com.cobblemon.mod.common.block.decor.RingTargetBlock
 import com.cobblemon.mod.common.block.general.BaleBlock
-import com.cobblemon.mod.common.block.general.HorizontalRotationCarpetBlock
-import com.cobblemon.mod.common.block.general.HorizontalRotationalBlock
 import com.cobblemon.mod.common.block.grower.SaccharineTreeGrower
-import com.cobblemon.mod.common.block.habitat.HabitatBlock
 import com.cobblemon.mod.common.block.sign.CobblemonHangingSignBlock
 import com.cobblemon.mod.common.block.sign.CobblemonSignBlock
 import com.cobblemon.mod.common.block.sign.CobblemonWallHangingSignBlock
 import com.cobblemon.mod.common.block.sign.CobblemonWallSignBlock
-import com.cobblemon.mod.common.block.tmmachine.TMMachineBlock
-import com.cobblemon.mod.common.mixin.invoker.BlocksInvoker
-import com.cobblemon.mod.common.mixin.invoker.DoorBlockInvoker
-import com.cobblemon.mod.common.mixin.invoker.FireBlockInvoker
-import com.cobblemon.mod.common.mixin.invoker.PressurePlateBlockInvoker
-import com.cobblemon.mod.common.mixin.invoker.StairsBlockInvoker
-import com.cobblemon.mod.common.mixin.invoker.TrapdoorBlockInvoker
+import com.cobblemon.mod.common.block.general.HorizontalRotationCarpetBlock
+import com.cobblemon.mod.common.block.general.HorizontalRotationalBlock
+import com.cobblemon.mod.common.mixin.invoker.*
 import com.cobblemon.mod.common.platform.PlatformRegistry
 import com.cobblemon.mod.common.util.cobblemonResource
 import net.minecraft.core.BlockPos
@@ -98,6 +46,7 @@ import net.minecraft.world.level.block.state.properties.NoteBlockInstrument
 import net.minecraft.world.level.block.state.properties.WoodType
 import net.minecraft.world.level.material.MapColor
 import net.minecraft.world.level.material.PushReaction
+import net.minecraft.world.phys.shapes.Shapes

@Suppress("SameParameterValue", "HasPlatformType", "MemberVisibilityCanBePrivate", "unused")
 object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<Block>>, Block>() {
@@ -172,19 +121,19 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
    val APRICORN_PLANKS = this.create("apricorn_planks",
        Block(
            BlockBehaviour.Properties.of().mapColor(MapColor.DIRT).instrument(NoteBlockInstrument.BASS)
-                .strength(2.0F, 3.0F).sound(SoundType.WOOD)
+                .strength(2.0f, 3.0f).sound(SoundType.WOOD)
        )
    )
    @JvmField
    val APRICORN_LEAVES = leaves("apricorn_leaves")
    @JvmField
-    val APRICORN_FENCE = this.create("apricorn_fence", FenceBlock(BlockBehaviour.Properties.of().mapColor(APRICORN_PLANKS.defaultMapColor()).instrument(NoteBlockInstrument.BASS).strength(2.0F, 3.0F).sound(SoundType.WOOD)))
+    val APRICORN_FENCE = this.create("apricorn_fence", FenceBlock(BlockBehaviour.Properties.of().mapColor(APRICORN_PLANKS.defaultMapColor()).instrument(NoteBlockInstrument.BASS).strength(2.0f, 3.0f).sound(SoundType.WOOD)))
    @JvmField
-    val APRICORN_FENCE_GATE = this.create("apricorn_fence_gate", FenceGateBlock(APRICORN_WOOD_TYPE, BlockBehaviour.Properties.of().mapColor(APRICORN_PLANKS.defaultMapColor()).strength(2.0F, 3.0F).sound(SoundType.WOOD).ignitedByLava().forceSolidOn()))
+    val APRICORN_FENCE_GATE = this.create("apricorn_fence_gate", FenceGateBlock(APRICORN_WOOD_TYPE, BlockBehaviour.Properties.of().mapColor(APRICORN_PLANKS.defaultMapColor()).strength(2.0f, 3.0f).sound(SoundType.WOOD).ignitedByLava().forceSolidOn()))
    @JvmField
    val APRICORN_BUTTON = this.create("apricorn_button", BlocksInvoker.createWoodenButtonBlock(APRICORN_BLOCK_SET_TYPE))
    @JvmField
-    val APRICORN_PRESSURE_PLATE = this.create("apricorn_pressure_plate", PressurePlateBlockInvoker.`cobblemon$create`(APRICORN_BLOCK_SET_TYPE, BlockBehaviour.Properties.of().mapColor(APRICORN_PLANKS.defaultMapColor()).noCollission().strength(0.5F).sound(SoundType.WOOD)))
+    val APRICORN_PRESSURE_PLATE = this.create("apricorn_pressure_plate", PressurePlateBlockInvoker.`cobblemon$create`(APRICORN_BLOCK_SET_TYPE, BlockBehaviour.Properties.of().mapColor(APRICORN_PLANKS.defaultMapColor()).noCollission().strength(0.5f).sound(SoundType.WOOD)))
    @JvmField
    val APRICORN_SIGN = this.create("apricorn_sign", CobblemonSignBlock(BlockBehaviour.Properties.ofFullCopy(Blocks.OAK_SIGN), APRICORN_WOOD_TYPE))

@@ -201,7 +150,7 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
    @JvmField
    val APRICORN_WALL_HANGING_SIGN = this.create("apricorn_wall_hanging_sign", CobblemonWallHangingSignBlock(BlockBehaviour.Properties.ofFullCopy(Blocks.OAK_HANGING_SIGN), APRICORN_WOOD_TYPE))
    @JvmField
-    val APRICORN_SLAB = this.create("apricorn_slab", SlabBlock(BlockBehaviour.Properties.of().mapColor(MapColor.WOOD).instrument(NoteBlockInstrument.BASS).strength(2.0F, 3.0F).sound(SoundType.WOOD)))
+    val APRICORN_SLAB = this.create("apricorn_slab", SlabBlock(BlockBehaviour.Properties.of().mapColor(MapColor.WOOD).instrument(NoteBlockInstrument.BASS).strength(2.0f, 3.0f).sound(SoundType.WOOD)))
    @JvmField
    val APRICORN_STAIRS = this.create("apricorn_stairs", StairsBlockInvoker.`cobblemon$create`(APRICORN_PLANKS.defaultBlockState(), BlockBehaviour.Properties.ofFullCopy(APRICORN_PLANKS)))
    @JvmField
@@ -238,12 +187,12 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
    @JvmField
    val STRIPPED_SACCHARINE_WOOD = this.create("stripped_saccharine_wood", RotatedPillarBlock(BlockBehaviour.Properties.of().mapColor(MapColor.COLOR_LIGHT_BLUE).instrument(NoteBlockInstrument.BASS).strength(2.0F).sound(SoundType.WOOD).ignitedByLava())) //log("stripped_saccharine_log")
    @JvmField
-    val SACCHARINE_PLANKS = this.create("saccharine_planks", Block(BlockBehaviour.Properties.of().mapColor(MapColor.COLOR_LIGHT_BLUE).instrument(NoteBlockInstrument.BASS).strength(2.0F, 3.0F).sound(SoundType.WOOD)))
+    val SACCHARINE_PLANKS = this.create("saccharine_planks", Block(BlockBehaviour.Properties.of().mapColor(MapColor.COLOR_LIGHT_BLUE).instrument(NoteBlockInstrument.BASS).strength(2.0f, 3.0f).sound(SoundType.WOOD)))
    @JvmField
    val SACCHARINE_LEAVES = this.create("saccharine_leaves", SaccharineLeafBlock(
        BlockBehaviour.Properties.of().mapColor(
            MapColor.PLANT
-        ).strength(0.2F).randomTicks().sound(SoundType.GRASS).noOcclusion()
+        ).strength(0.2f).randomTicks().sound(SoundType.GRASS).noOcclusion()
            .isValidSpawn { _: BlockState?, _: BlockGetter?, _: BlockPos?, entity: EntityType<*>? ->
                entity === EntityType.OCELOT || entity === EntityType.PARROT
            }.isSuffocating { _: BlockState?, _: BlockGetter?, _: BlockPos? ->
@@ -255,13 +204,13 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
                false
            }))
    @JvmField
-    val SACCHARINE_FENCE = this.create("saccharine_fence", FenceBlock(BlockBehaviour.Properties.of().mapColor(SACCHARINE_PLANKS.defaultMapColor()).instrument(NoteBlockInstrument.BASS).strength(2.0F, 3.0F).sound(SoundType.WOOD)))
+    val SACCHARINE_FENCE = this.create("saccharine_fence", FenceBlock(BlockBehaviour.Properties.of().mapColor(SACCHARINE_PLANKS.defaultMapColor()).instrument(NoteBlockInstrument.BASS).strength(2.0f, 3.0f).sound(SoundType.WOOD)))
    @JvmField
-    val SACCHARINE_FENCE_GATE = this.create("saccharine_fence_gate", FenceGateBlock(SACCHARINE_WOOD_TYPE, BlockBehaviour.Properties.of().mapColor(SACCHARINE_PLANKS.defaultMapColor()).instrument(NoteBlockInstrument.BASS).strength(2.0F, 3.0F).sound(SoundType.WOOD).ignitedByLava().forceSolidOn()))
+    val SACCHARINE_FENCE_GATE = this.create("saccharine_fence_gate", FenceGateBlock(SACCHARINE_WOOD_TYPE, BlockBehaviour.Properties.of().mapColor(SACCHARINE_PLANKS.defaultMapColor()).instrument(NoteBlockInstrument.BASS).strength(2.0f, 3.0f).sound(SoundType.WOOD).ignitedByLava().forceSolidOn()))
    @JvmField
    val SACCHARINE_BUTTON = this.create("saccharine_button", BlocksInvoker.createWoodenButtonBlock(BlockSetType.OAK))
    @JvmField
-    val SACCHARINE_PRESSURE_PLATE = this.create("saccharine_pressure_plate", PressurePlateBlockInvoker.`cobblemon$create`(SACCHARINE_BLOCK_SET_TYPE, BlockBehaviour.Properties.of().mapColor(SACCHARINE_PLANKS.defaultMapColor()).instrument(NoteBlockInstrument.BASS).noCollission().strength(0.5F).sound(SoundType.WOOD)))
+    val SACCHARINE_PRESSURE_PLATE = this.create("saccharine_pressure_plate", PressurePlateBlockInvoker.`cobblemon$create`(SACCHARINE_BLOCK_SET_TYPE, BlockBehaviour.Properties.of().mapColor(SACCHARINE_PLANKS.defaultMapColor()).instrument(NoteBlockInstrument.BASS).noCollission().strength(0.5f).sound(SoundType.WOOD)))
    @JvmField
    val SACCHARINE_SIGN = this.create("saccharine_sign", CobblemonSignBlock(BlockBehaviour.Properties.ofFullCopy(Blocks.OAK_SIGN), SACCHARINE_WOOD_TYPE))
    @JvmField
@@ -271,7 +220,7 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
    @JvmField
    val SACCHARINE_WALL_HANGING_SIGN = this.create("saccharine_wall_hanging_sign", CobblemonWallHangingSignBlock(BlockBehaviour.Properties.ofFullCopy(Blocks.OAK_HANGING_SIGN), SACCHARINE_WOOD_TYPE))
    @JvmField
-    val SACCHARINE_SLAB = this.create("saccharine_slab", SlabBlock(BlockBehaviour.Properties.of().mapColor(MapColor.WOOD).instrument(NoteBlockInstrument.BASS).strength(2.0F, 3.0F).sound(SoundType.WOOD)))
+    val SACCHARINE_SLAB = this.create("saccharine_slab", SlabBlock(BlockBehaviour.Properties.of().mapColor(MapColor.WOOD).instrument(NoteBlockInstrument.BASS).strength(2.0f, 3.0f).sound(SoundType.WOOD)))
    @JvmField
    val SACCHARINE_STAIRS = this.create("saccharine_stairs", StairsBlockInvoker.`cobblemon$create`(SACCHARINE_PLANKS.defaultBlockState(), BlockBehaviour.Properties.ofFullCopy(SACCHARINE_PLANKS)))
    @JvmField
@@ -300,31 +249,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", GrowableStoneBlock.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", GrowableStoneBlock.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", GrowableStoneBlock.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", GrowableStoneBlock.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", GrowableStoneBlock.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", GrowableStoneBlock.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", GrowableStoneBlock.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", GrowableStoneBlock.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", GrowableStoneBlock.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", GrowableStoneBlock.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", GrowableStoneBlock.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", GrowableStoneBlock.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)))
@@ -333,87 +282,6 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
    @JvmField
    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)))
-
-    private val typeGemBlocks = mutableMapOf<ResourceLocation, Block>()
-
-    @JvmField
-    val TYPE_GEM_BLOCK_NORMAL = typeGemBlock("normal_gem_block", MapColor.QUARTZ)
-    @JvmField
-    val TYPE_GEM_BLOCK_FIRE = typeGemBlock("fire_gem_block", MapColor.FIRE)
-    @JvmField
-    val TYPE_GEM_BLOCK_WATER = typeGemBlock("water_gem_block", MapColor.WATER)
-    @JvmField
-    val TYPE_GEM_BLOCK_GRASS = typeGemBlock("grass_gem_block", MapColor.COLOR_LIGHT_GREEN)
-    @JvmField
-    val TYPE_GEM_BLOCK_ELECTRIC = typeGemBlock("electric_gem_block", MapColor.GOLD)
-    @JvmField
-    val TYPE_GEM_BLOCK_ICE = typeGemBlock("ice_gem_block", MapColor.ICE)
-    @JvmField
-    val TYPE_GEM_BLOCK_FIGHTING = typeGemBlock("fighting_gem_block", MapColor.COLOR_RED)
-    @JvmField
-    val TYPE_GEM_BLOCK_POISON = typeGemBlock("poison_gem_block", MapColor.COLOR_PURPLE)
-    @JvmField
-    val TYPE_GEM_BLOCK_GROUND = typeGemBlock("ground_gem_block", MapColor.PODZOL)
-    @JvmField
-    val TYPE_GEM_BLOCK_FLYING = typeGemBlock("flying_gem_block", MapColor.COLOR_LIGHT_BLUE)
-    @JvmField
-    val TYPE_GEM_BLOCK_PSYCHIC = typeGemBlock("psychic_gem_block", MapColor.COLOR_MAGENTA)
-    @JvmField
-    val TYPE_GEM_BLOCK_BUG = typeGemBlock("bug_gem_block", MapColor.TERRACOTTA_LIGHT_GREEN)
-    @JvmField
-    val TYPE_GEM_BLOCK_ROCK = typeGemBlock("rock_gem_block", MapColor.TERRACOTTA_LIGHT_GRAY)
-    @JvmField
-    val TYPE_GEM_BLOCK_GHOST = typeGemBlock("ghost_gem_block", MapColor.TERRACOTTA_MAGENTA)
-    @JvmField
-    val TYPE_GEM_BLOCK_DRAGON = typeGemBlock("dragon_gem_block", MapColor.COLOR_BLUE)
-    @JvmField
-    val TYPE_GEM_BLOCK_DARK = typeGemBlock("dark_gem_block", MapColor.TERRACOTTA_BLACK)
-    @JvmField
-    val TYPE_GEM_BLOCK_STEEL = typeGemBlock("steel_gem_block", MapColor.METAL)
-    @JvmField
-    val TYPE_GEM_BLOCK_FAIRY = typeGemBlock("fairy_gem_block", MapColor.COLOR_PINK)
-
-    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)
-    @JvmField
-    val TYPE_GEM_CLUSTER_FIRE = typeGemCluster("fire_gem_cluster", TYPE_GEM_BLOCK_FIRE, cobblemonResource("fire_gem"), MapColor.FIRE)
-    @JvmField
-    val TYPE_GEM_CLUSTER_WATER = typeGemCluster("water_gem_cluster", TYPE_GEM_BLOCK_WATER, cobblemonResource("water_gem"), MapColor.WATER)
-    @JvmField
-    val TYPE_GEM_CLUSTER_GRASS = typeGemCluster("grass_gem_cluster", TYPE_GEM_BLOCK_GRASS, cobblemonResource("grass_gem"), MapColor.COLOR_LIGHT_GREEN)
-    @JvmField
-    val TYPE_GEM_CLUSTER_ELECTRIC = typeGemCluster("electric_gem_cluster", TYPE_GEM_BLOCK_ELECTRIC, cobblemonResource("electric_gem"), MapColor.GOLD)
-    @JvmField
-    val TYPE_GEM_CLUSTER_ICE = typeGemCluster("ice_gem_cluster", TYPE_GEM_BLOCK_ICE, cobblemonResource("ice_gem"), MapColor.ICE)
-    @JvmField
-    val TYPE_GEM_CLUSTER_FIGHTING = typeGemCluster("fighting_gem_cluster", TYPE_GEM_BLOCK_FIGHTING, cobblemonResource("fighting_gem"), MapColor.COLOR_RED)
-    @JvmField
-    val TYPE_GEM_CLUSTER_POISON = typeGemCluster("poison_gem_cluster", TYPE_GEM_BLOCK_POISON, cobblemonResource("poison_gem"), MapColor.COLOR_PURPLE)
-    @JvmField
-    val TYPE_GEM_CLUSTER_GROUND = typeGemCluster("ground_gem_cluster", TYPE_GEM_BLOCK_GROUND, cobblemonResource("ground_gem"), MapColor.PODZOL)
-    @JvmField
-    val TYPE_GEM_CLUSTER_FLYING = typeGemCluster("flying_gem_cluster", TYPE_GEM_BLOCK_FLYING, cobblemonResource("flying_gem"), MapColor.COLOR_LIGHT_BLUE)
-    @JvmField
-    val TYPE_GEM_CLUSTER_PSYCHIC = typeGemCluster("psychic_gem_cluster", TYPE_GEM_BLOCK_PSYCHIC, cobblemonResource("psychic_gem"), MapColor.COLOR_MAGENTA)
-    @JvmField
-    val TYPE_GEM_CLUSTER_BUG = typeGemCluster("bug_gem_cluster", TYPE_GEM_BLOCK_BUG, cobblemonResource("bug_gem"), MapColor.TERRACOTTA_LIGHT_GREEN)
-    @JvmField
-    val TYPE_GEM_CLUSTER_ROCK = typeGemCluster("rock_gem_cluster", TYPE_GEM_BLOCK_ROCK, cobblemonResource("rock_gem"), MapColor.TERRACOTTA_LIGHT_GRAY)
-    @JvmField
-    val TYPE_GEM_CLUSTER_GHOST = typeGemCluster("ghost_gem_cluster", TYPE_GEM_BLOCK_GHOST, cobblemonResource("ghost_gem"), MapColor.TERRACOTTA_MAGENTA)
-    @JvmField
-    val TYPE_GEM_CLUSTER_DRAGON = typeGemCluster("dragon_gem_cluster", TYPE_GEM_BLOCK_DRAGON, cobblemonResource("dragon_gem"), MapColor.COLOR_BLUE)
-    @JvmField
-    val TYPE_GEM_CLUSTER_DARK = typeGemCluster("dark_gem_cluster", TYPE_GEM_BLOCK_DARK, cobblemonResource("dark_gem"), MapColor.TERRACOTTA_BLACK)
-    @JvmField
-    val TYPE_GEM_CLUSTER_STEEL = typeGemCluster("steel_gem_cluster", TYPE_GEM_BLOCK_STEEL, cobblemonResource("steel_gem"), MapColor.METAL)
-    @JvmField
-    val TYPE_GEM_CLUSTER_FAIRY = typeGemCluster("fairy_gem_cluster", TYPE_GEM_BLOCK_FAIRY, cobblemonResource("fairy_gem"), MapColor.COLOR_PINK)
-
    @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)))
    @JvmField
@@ -582,18 +450,6 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
        )
    )

-    @JvmField
-    val HABITAT_BLOCK = this.create(
-        name = "habitat_block",
-        entry = HabitatBlock(
-            properties = BlockBehaviour.Properties.of()
-                .mapColor(MapColor.STONE)
-                .strength(1.5F, Blocks.OBSIDIAN.explosionResistance)
-                .pushReaction(PushReaction.BLOCK)
-        )
-    )
-
-
    @JvmField
    val CAMPFIRE = create("campfire", CampfireBlock(BlockBehaviour.Properties.of().sound(SoundType.WOOD).noOcclusion().pushReaction(PushReaction.BLOCK).mapColor(MapColor.PODZOL).strength(2.0F).lightLevel{14}, false))

@@ -603,7 +459,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))
@@ -656,96 +512,14 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
    val PINK_PLAQUE = create("pink_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))

    @JvmField
-    val CLEANSE_TAG = create("cleanse_tag", WallAttachedStackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_PAPER_SMALL_SOUNDS).mapColor(MapColor.NONE).pushReaction(PushReaction.DESTROY).noOcclusion().noCollission(), WallAttachedStackableItemBlock.WallStackableItemBlockType.TAG))
+    val CLEANSE_TAG = create("cleanse_tag", WallAttachedStackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.WOOD).mapColor(MapColor.NONE).pushReaction(PushReaction.DESTROY).noOcclusion().noCollission(), WallAttachedStackableItemBlock.WallStackableItemBlockType.TAG))
    @JvmField
-    val SPELL_TAG = create("spell_tag", WallAttachedStackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_PAPER_SMALL_SOUNDS).mapColor(MapColor.NONE).pushReaction(PushReaction.DESTROY).noOcclusion().noCollission(), WallAttachedStackableItemBlock.WallStackableItemBlockType.TAG))
+    val SPELL_TAG = create("spell_tag", WallAttachedStackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.WOOD).mapColor(MapColor.NONE).pushReaction(PushReaction.DESTROY).noOcclusion().noCollission(), WallAttachedStackableItemBlock.WallStackableItemBlockType.TAG))

    @JvmField
-    val BLUNDER_POLICY = create("blunder_policy", WallAttachedDirectionalShapeBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_PAPER_LARGE_SOUNDS).mapColor(MapColor.NONE).noOcclusion().noCollission(), 14, 12, 1))
+    val BLUNDER_POLICY = create("blunder_policy", WallAttachedDirectionalShapeBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion().noCollission(), 14, 12, 1))
    @JvmField
-    val WEAKNESS_POLICY = create("weakness_policy", WallAttachedDirectionalShapeBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_PAPER_LARGE_SOUNDS).mapColor(MapColor.NONE).noOcclusion().noCollission(), 14, 12, 1))
-
-    @JvmField
-    val RING_TARGET = create("ring_target", RingTargetBlock(BlockBehaviour.Properties.of().sound(SoundType.WOOD).mapColor(MapColor.NONE).noOcclusion().strength(0.125f)))
-    @JvmField
-    val MAGNET = create("magnet", MagnetBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.NONE).noOcclusion().strength(0.075f)))
-    @JvmField
-    val GALARICA_WREATH = create("galarica_wreath", GalaricaWreathBlock(BlockBehaviour.Properties.of().sound(SoundType.AZALEA_LEAVES).mapColor(MapColor.NONE).noOcclusion().noCollission()))
-
-    @JvmField
-    val FLAME_ORB = create("flame_orb",OrbBlock(BlockBehaviour.Properties.of().sound(SoundType.GLASS).mapColor(MapColor.NONE).noOcclusion().lightLevel { 15 }))
-    @JvmField
-    val TOXIC_ORB = create("toxic_orb", OrbBlock(BlockBehaviour.Properties.of().sound(SoundType.GLASS).mapColor(MapColor.NONE).noOcclusion()))
-    @JvmField
-    val LIFE_ORB = create("life_orb", OrbBlock(BlockBehaviour.Properties.of().sound(SoundType.GLASS).mapColor(MapColor.NONE).noOcclusion().lightLevel{7}))
-    @JvmField
-    val LIGHT_BALL = create("light_ball", OrbBlock(BlockBehaviour.Properties.of().sound(SoundType.GLASS).mapColor(MapColor.NONE).noOcclusion().lightLevel{13}))
-    @JvmField
-    val SMOKE_BALL = create("smoke_ball", OrbBlock(BlockBehaviour.Properties.of().sound(SoundType.GLASS).mapColor(MapColor.NONE).noOcclusion()))
-
-    @JvmField
-    val KINGS_ROCK = create("kings_rock", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.TUMBLESTONE_BLOCK_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.CENTERED_6x))
-
-    @JvmField
-    val GALARICA_CUFF = create("galarica_cuff", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.AZALEA_LEAVES).mapColor(MapColor.NONE).noCollission().noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.FLATTENED_10x4))
-    @JvmField
-    val UNREMARKABLE_TEACUP = create("unremarkable_teacup", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.DECORATED_POT).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.TEACUP))
-    @JvmField
-    val MASTERPIECE_TEACUP = create("masterpiece_teacup", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.DECORATED_POT).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.TEACUP))
-    @JvmField
-    val CHIPPED_POT = create("chipped_pot", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.DECORATED_POT).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.TEAPOT))
-    @JvmField
-    val CRACKED_POT = create("cracked_pot", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.DECORATED_POT).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.TEAPOT))
-
-    @JvmField
-    val SACHET = create("sachet", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.WOOL).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.POUCH))
-    @JvmField
-    val METAL_POWDER = create("metal_powder", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.WOOL).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.POUCH))
-    @JvmField
-    val QUICK_POWDER = create("quick_powder", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.WOOL).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.POUCH))
-    @JvmField
-    val BRIGHT_POWDER = create("bright_powder", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.WOOL).mapColor(MapColor.NONE).noOcclusion().lightLevel{3}, DecorativeItemBlock.DecorativeItemBlockType.POUCH))
-
-    @JvmField
-    val NEVER_MELT_ICE = create("never_melt_ice", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.GLASS).mapColor(MapColor.NONE).noOcclusion().friction(0.989F), DecorativeItemBlock.DecorativeItemBlockType.NEVERMELT))
-    @JvmField
-    val SCOPE_LENS = create("scope_lens", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.COPPER).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.SCOPE))
-    @JvmField
-    val WIDE_LENS = create("wide_lens", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.COPPER).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.WIDE))
-    @JvmField
-    val ZOOM_LENS = create("zoom_lens", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.COPPER).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.ZOOM))
-
-    @JvmField
-    val ICY_ROCK = create("icy_rock", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.DEEPSLATE).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.FLATTENED_8x4))
-    @JvmField
-    val HEAT_ROCK = create("heat_rock", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.DEEPSLATE).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.FLATTENED_8x4))
-    @JvmField
-    val SMOOTH_ROCK = create("smooth_rock", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.DEEPSLATE).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.FLATTENED_8x4))
-    @JvmField
-    val DAMP_ROCK = create("damp_rock", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.DEEPSLATE).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.FLATTENED_8x6))
-    @JvmField
-    val DESTINY_KNOT = create("destiny_knot", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.WOOL).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.KNOT))
-    @JvmField
-    val LUMINOUS_MOSS = create("luminous_moss", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.MOSS).mapColor(MapColor.NONE).noOcclusion().lightLevel{5}, DecorativeItemBlock.DecorativeItemBlockType.CENTERED_8x))
-
-    @JvmField
-    val METRONOME = create("metronome", ActivatableDecorationBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.NONE).pushReaction(PushReaction.DESTROY).noOcclusion(), ActivatableDecorationBlock.ActivatableDecorationBlockType.METRONOME))
-    @JvmField
-    val EJECT_BUTTON = create("eject_button", EjectButtonBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.NONE).pushReaction(PushReaction.DESTROY).noOcclusion().strength(0.125f), 40))
-
-    @JvmField
-    val LOADED_DICE = create("loaded_dice", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.DICE))
-    @JvmField
-    val IRON_BALL = create("iron_ball", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.IRON_BALL))
-    @JvmField
-    val METAL_COAT = create("metal_coat", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.METAL_COAT))
-    @JvmField
-    val UPGRADE = create("upgrade", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.UPGRADE))
-    @JvmField
-    val DUBIOUS_DISC = create("dubious_disc", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.UPGRADE))
-
-    @JvmField
-    val THROAT_SPRAY = create("throat_spray", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.THROAT_SPRAY))
+    val WEAKNESS_POLICY = create("weakness_policy", WallAttachedDirectionalShapeBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion().noCollission(), 14, 12, 1))

    @JvmField
    val FULL_HEAL = create("full_heal", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
@@ -797,77 +571,32 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
    @JvmField
    val X_SPEED = create("x_${Stats.SPEED.identifier.path}", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.BATTLE_ITEM))

-    @JvmField
-    val HP_UP = create("hp_up", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
-    @JvmField
-    val PROTEIN = create("protein", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
-    @JvmField
-    val IRON = create("iron", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
-    @JvmField
-    val CARBOS = create("carbos", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
-    @JvmField
-    val CALCIUM = create("calcium", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
-    @JvmField
-    val ZINC = create("zinc", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
-    @JvmField
-    val PP_UP = create("pp_up", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
-    @JvmField
-    val PP_MAX = create("pp_max", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
-
    @JvmField
    val MONITOR = create("monitor", MonitorBlock(BlockBehaviour.Properties.of().mapColor(MapColor.METAL).sound(SoundType.METAL).pushReaction(PushReaction.BLOCK).requiresCorrectToolForDrops().strength(5.0F, 6.0F).lightLevel { if (it.getValue(MonitorBlock.SCREEN) != MonitorBlock.MonitorScreen.OFF) 13 else 0 }))
    @JvmField
-    val DAMAGED_MONITOR = create("damaged_monitor", DamagedMonitorBlock(BlockBehaviour.Properties.of().mapColor(MapColor.METAL).sound(SoundType.METAL).pushReaction(PushReaction.BLOCK).requiresCorrectToolForDrops().strength(5.0F, 6.0F).lightLevel { when (it.getValue(DamagedMonitorBlock.SCREEN)) { DamagedMonitorBlock.BrokenMonitorScreen.GLITCHING -> 10; else -> 0 } }))
-    @JvmField
    val FOSSIL_ANALYZER = create("fossil_analyzer", FossilAnalyzerBlock(BlockBehaviour.Properties.of().mapColor(MapColor.METAL).sound(SoundType.METAL).pushReaction(PushReaction.BLOCK).requiresCorrectToolForDrops().strength(5.0F, 6.0F).noOcclusion()))
    @JvmField
    val RESTORATION_TANK = create("restoration_tank", RestorationTankBlock(BlockBehaviour.Properties.of().mapColor(MapColor.METAL).sound(SoundType.GLASS).pushReaction(PushReaction.BLOCK).requiresCorrectToolForDrops().strength(5.0F, 6.0F).noOcclusion()))

    @JvmField
-    val HEALING_MACHINE = create("healing_machine", HealingMachineBlock(BlockBehaviour.Properties.of().mapColor(MapColor.METAL).sound(SoundType.METAL).pushReaction(PushReaction.BLOCK).strength(2F).noOcclusion().lightLevel { if (it.getValue(HealingMachineBlock.CHARGE_LEVEL) >= HealingMachineBlock.MAX_CHARGE_LEVEL) 12 else 5 }))
+    val HEALING_MACHINE = create("healing_machine", HealingMachineBlock(BlockBehaviour.Properties.of().mapColor(MapColor.METAL).sound(SoundType.METAL).pushReaction(PushReaction.BLOCK).strength(2f).noOcclusion().lightLevel { if (it.getValue(HealingMachineBlock.CHARGE_LEVEL) >= HealingMachineBlock.MAX_CHARGE_LEVEL) 12 else 5 }))

    @JvmField
    val PC = create("pc", PCBlock(BlockBehaviour.Properties.of().mapColor(MapColor.METAL).sound(SoundType.METAL).pushReaction(PushReaction.BLOCK).strength(2F).noOcclusion().lightLevel { if ((it.getValue(PCBlock.ON) as Boolean) && (it.getValue(PCBlock.PART) == PCBlock.PCPart.TOP)) 13 else 0 }))

    @JvmField
-    val TM_MACHINE = create(
-            "tm_machine",
-        TMMachineBlock(
-            BlockBehaviour.Properties.of()
-                .mapColor(MapColor.COLOR_GREEN)
-                .sound(SoundType.METAL)
-                .pushReaction(PushReaction.BLOCK)
-                .strength(2F)
-                .noOcclusion()
-        )
-    )
-
-
-    @JvmField
-    val LECTERN = create("lectern", LecternBlock(
-        BlockBehaviour.Properties
-            .of()
-            .mapColor(MapColor.WOOD)
-            .instrument(NoteBlockInstrument.BASS)
-            .sound(SoundType.WOOD)
-            .strength(2.5F)
-            .ignitedByLava()
-            .lightLevel { if (it.getValue(LecternBlock.EMIT_LIGHT) as Boolean) 13 else 0 }
-    ))
-
-    @JvmField
-    val DISC_SHELF = create("disc_shelf", DiscShelfBlock(BlockBehaviour.Properties.of().mapColor(MapColor.WOOD).instrument(NoteBlockInstrument.BASS).sound(SoundType.METAL).strength(2.5F)))
+    val LECTERN = create("lectern", LecternBlock(BlockBehaviour.Properties.of().mapColor(MapColor.WOOD).instrument(NoteBlockInstrument.BASS).sound(SoundType.WOOD).strength(2.5F).ignitedByLava().lightLevel { if (it.getValue(LecternBlock.EMIT_LIGHT) as Boolean) 13 else 0 }))

    @JvmField
    val DISPLAY_CASE = create("display_case", DisplayCaseBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.DISPLAY_CASE_SOUNDS).noOcclusion().pushReaction(PushReaction.BLOCK).mapColor(MapColor.STONE).strength(0.3F).requiresCorrectToolForDrops()))

    // TODO after 1.7
 //    @JvmField
-//    val INCENSE_SWEET = create("incense_sweet", SweetIncenseBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.DISPLAY_CASE_SOUNDS).noOcclusion().pushReaction(PushReaction.BLOCK).mapColor(MapColor.STONE).strength(0.3F)))
+//    val INCENSE_SWEET = create("incense_sweet", SweetIncenseBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.DISPLAY_CASE_SOUNDS).noOcclusion().pushReaction(PushReaction.BLOCK).mapColor(MapColor.STONE).strength(0.3f)))

    @JvmField
    val PASTURE = create("pasture", PastureBlock(BlockBehaviour.Properties.of().mapColor(MapColor.COLOR_BROWN).sound(SoundType.WOOD).strength(2F).noOcclusion().pushReaction(PushReaction.BLOCK).lightLevel { if ((it.getValue(PastureBlock.ON) as Boolean) && (it.getValue(PastureBlock.PART) == PastureBlock.PasturePart.TOP)) 13 else 0 }))
-    @JvmField
+
    val RED_MINT = create("red_mint", MintBlock(MintType.RED, BlockBehaviour.Properties.of().mapColor(MapColor.COLOR_RED).noCollission().randomTicks().instabreak().sound(CobblemonSounds.MINT_SOUNDS).pushReaction(PushReaction.DESTROY)))
    @JvmField
    val BLUE_MINT = create("blue_mint", MintBlock(MintType.BLUE, BlockBehaviour.Properties.of().mapColor(MapColor.COLOR_BLUE).noCollission().randomTicks().instabreak().sound(CobblemonSounds.MINT_SOUNDS).pushReaction(PushReaction.DESTROY)))
@@ -931,9 +660,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)
@@ -1085,91 +813,6 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
    val YACHE_BERRY = this.berryBlock("yache")
    //val BINDING_SOIL = this.create("binding_soil", BindingSoilBlock(BlockBehaviour.Properties.of()))

-    val NEST_FIERY = this.create(
-        "nest_fiery",
-        WildNestBlock.create(
-            WildNestType.FIERY,
-            BlockBehaviour.Properties.of()
-                .noOcclusion()
-                .pushReaction(PushReaction.DESTROY)
-                .lightLevel { state ->
-                    val variant = (state.block as? WildNestBlock)?.variantProperty?.let { state.getValue(it) }
-                    when (variant) {
-                        WildNestVariant.FIERY_NETHERRACK -> 15
-                        WildNestVariant.FIERY_SOUL_SAND -> 10
-                        else -> 3
-                    }
-                }
-        )
-    )
-    val NEST_GRASSY = this.create(
-        "nest_grassy",
-        WildNestBlock.create(WildNestType.GRASSY, BlockBehaviour.Properties.of().noOcclusion().pushReaction(PushReaction.DESTROY))
-    )
-    val NEST_LEAFY = this.create(
-        "nest_leafy",
-        WildNestBlock.create(WildNestType.LEAFY, BlockBehaviour.Properties.of().noOcclusion().pushReaction(PushReaction.DESTROY))
-    )
-    val NEST_ICY = this.create(
-        "nest_icy",
-        WildNestBlock.create(WildNestType.ICY, BlockBehaviour.Properties.of().noOcclusion().pushReaction(PushReaction.DESTROY))
-    )
-    val NEST_HAY = this.create(
-        "nest_hay",
-        WildNestBlock.create(WildNestType.PLAYER, BlockBehaviour.Properties.of().noOcclusion().pushReaction(PushReaction.DESTROY))
-    )
-    val NEST_KELP = this.create(
-        "nest_kelp",
-        WildNestBlock.create(WildNestType.KELP, BlockBehaviour.Properties.of().noOcclusion().pushReaction(PushReaction.DESTROY))
-    )
-    val NEST_ROCKY = this.create(
-        "nest_rocky",
-        WildNestBlock.create(WildNestType.ROCKY, BlockBehaviour.Properties.of().noOcclusion().pushReaction(PushReaction.DESTROY))
-    )
-    val NEST_SANDY = this.create(
-        "nest_sandy",
-        WildNestBlock.create(WildNestType.SANDY, BlockBehaviour.Properties.of().noOcclusion().pushReaction(PushReaction.DESTROY))
-    )
-    val NEST_SHROOMY = this.create(
-        "nest_shroomy",
-        WildNestBlock.create(WildNestType.SHROOMY, BlockBehaviour.Properties.of().noOcclusion().pushReaction(PushReaction.DESTROY))
-    )
-    val NEST_TWIGGY = this.create(
-        "nest_twiggy",
-        WildNestBlock.create(WildNestType.TWIGGY, BlockBehaviour.Properties.of().noOcclusion().pushReaction(PushReaction.DESTROY))
-    )
-    val NEST_WATERY = this.create(
-        "nest_watery",
-        WildNestBlock.create(WildNestType.WATERY, BlockBehaviour.Properties.of().noOcclusion().pushReaction(PushReaction.DESTROY))
-    )
-
-    val EGG = this.create("egg", EggBlock(BlockBehaviour.Properties
-        .ofFullCopy(Blocks.DRAGON_EGG)
-        .pushReaction(PushReaction.BLOCK)
-        .sound(SoundType.BONE_BLOCK)
-    ))
-
-    @JvmField
-    val INCUBATOR = this.create("incubator", IncubatorBlock(BlockBehaviour.Properties.of()
-        .mapColor(MapColor.COLOR_LIGHT_GRAY)
-        .sound(SoundType.METAL)
-        .strength(Blocks.COAL_BLOCK.defaultDestroyTime(), Blocks.DIAMOND_ORE.explosionResistance)
-        .noOcclusion()
-        .pushReaction(PushReaction.BLOCK)
-        .lightLevel { state ->
-            if (state.getValue(IncubatorBlock.HAS_EGG) && !state.getValue(IncubatorBlock.READY)) 8 else 0 // emit light only when warming the egg
-        }
-    ))
-
-    @JvmField
-    val SCAREKROW = this.create("scarekrow", ScarekrowBlock(
-        BlockBehaviour.Properties.of()
-            .pushReaction(PushReaction.DESTROY)
-            .sound(SoundType.GRASS)
-            .strength(0.1f)
-            .noOcclusion()
-    ))
-
    init {
        /**
         * Makes all blocks in array flammable by adding them to FireBlock's flammableRegistry.
@@ -1210,12 +853,6 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
        return block
    }

-    private fun nestBlock(variant: NestBlock.NestVariant): NestBlock {
-        val identifier = cobblemonResource(variant.serializedName)
-        val block = NestBlock(variant, BlockBehaviour.Properties.of().noOcclusion().pushReaction(PushReaction.DESTROY))
-        return this.create(identifier.path, block)
-    }
-
    /**
     * Calls helper method from Vanilla
     */
@@ -1253,28 +890,4 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
        val block = BlocksInvoker.createLeavesBlock(SoundType.GRASS)
        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)))
-
-        val identifier = cobblemonResource(name)
-        typeGemBlocks[identifier] = typeGemBlock
-
-        return typeGemBlock
-    }
-
-    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))
-
-        TypeGemClusterBlock.gemToClusterMap[gemBlock] = gemClusterBlock
-
-        val identifier = cobblemonResource(name)
-        typeGemClusters[identifier] = gemClusterBlock
-
-        return gemClusterBlock
-    }
-
-    fun typeGemClusters() = typeGemClusters.toMap()
-}
+}
@@ -61,8 +61,6 @@ object CobblemonCommands {
        ChangeBoxWallpaperCommand.register(dispatcher)
        RunMolangCommand.register(dispatcher)
        RunMolangScriptCommand.register(dispatcher)
-        GivePokemonEggCommand.register(dispatcher)
-        GiveAllPokemonEggCommand.register(dispatcher)
        SpectateBattleCommand.register(dispatcher)
        CobblemonConfigCommand.register(dispatcher)
        UnlockPCBoxWallpaperCommand.register(dispatcher)
@@ -73,13 +71,11 @@ object CobblemonCommands {
        MarkGiveAllCommand.register(dispatcher)
        PcSearchCommand.register(dispatcher)
        PcTakeCommand.register(dispatcher)
-        GiveTmCommand.register(dispatcher)
-        TmCommand.register(dispatcher)
-        BreedPokemonCommand.register(dispatcher)

        // Possibly lock down registration if and only if under dev environment or running in an environment
        // with a certain system environment variable set
        CobblemonInfoCommand.register(dispatcher)
+        CalculateSeatPositionCommand.register(dispatcher)
        DebugCobblemonAICommand.register(dispatcher)
    }
-}
+}
@@ -26,8 +26,6 @@ import net.minecraft.world.entity.LivingEntity
 import net.minecraft.resources.ResourceKey
 import net.minecraft.world.entity.MobCategory
 import net.minecraft.world.entity.ai.attributes.AttributeSupplier
-import com.cobblemon.mod.common.entity.RealtimeMoveProjectile
-import com.example.mod.entity.RealtimeMoveAreaEffect

 object CobblemonEntities : PlatformRegistry<Registry<EntityType<*>>, ResourceKey<Registry<EntityType<*>>>, EntityType<*>>() {

@@ -89,25 +87,6 @@ object CobblemonEntities : PlatformRegistry<Registry<EntityType<*>>, ResourceKey
            .build(GENERIC_BEDROCK_ENTITY_KEY.toString())
    )

-    @JvmField
-    val REALTIME_MOVE_PROJECTILE_ENTITY_KEY = cobblemonResource("realtime_move_projectile")
-    @JvmField
-    val REALTIME_MOVE_PROJECTILE_ENTITY: EntityType<RealtimeMoveProjectile> = this.create(
-        REALTIME_MOVE_PROJECTILE_ENTITY_KEY.path,
-        EntityType.Builder.of({ _, world -> RealtimeMoveProjectile(world) }, MobCategory.MISC)
-            .build(REALTIME_MOVE_PROJECTILE_ENTITY_KEY.toString())
-    )
-
-    @JvmField
-    val REALTIME_MOVE_PROJECTILE_AOE_KEY = cobblemonResource("realtime_move_aoe")
-    @JvmField
-    val REALTIME_MOVE_PROJECTILE_AOE: EntityType<RealtimeMoveAreaEffect> = this.create(
-        REALTIME_MOVE_PROJECTILE_AOE_KEY.path,
-        EntityType.Builder.of({ _, world -> RealtimeMoveAreaEffect(world) }, MobCategory.MISC)
-            .build(REALTIME_MOVE_PROJECTILE_AOE_KEY.toString())
-    )
-
-
    @JvmField
    val NPC_KEY = cobblemonResource("npc")
    @JvmField
@@ -12,7 +12,6 @@ import com.cobblemon.mod.common.api.net.NetworkPacket
 import com.mojang.brigadier.arguments.ArgumentType
 import kotlin.reflect.KClass
 import net.minecraft.commands.synchronization.ArgumentTypeInfo
-import net.minecraft.core.HolderLookup
 import net.minecraft.resources.ResourceKey
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.MinecraftServer
@@ -20,7 +19,6 @@ import net.minecraft.server.level.ServerPlayer
 import net.minecraft.server.packs.PackType
 import net.minecraft.server.packs.resources.PreparableReloadListener
 import net.minecraft.tags.TagKey
-import net.minecraft.world.inventory.MenuType
 import net.minecraft.world.level.GameRules
 import net.minecraft.world.level.ItemLike
 import net.minecraft.world.level.biome.Biome
@@ -169,16 +167,12 @@ interface CobblemonImplementation {
     * TODO
     *
     * @param identifier
-     * @param reloaderFactory
+     * @param reloader
     * @param type
     * @param dependencies
     */
-    fun registerResourceReloader(
-        identifier: ResourceLocation,
-        type: PackType,
-        dependencies: Collection<ResourceLocation>,
-        reloaderFactory: (HolderLookup.Provider) -> PreparableReloadListener
-    )
+    fun registerResourceReloader(identifier: ResourceLocation, reloader: PreparableReloadListener, type: PackType, dependencies: Collection<ResourceLocation>)
+
    /**
     * TODO
     *
@@ -18,7 +18,6 @@ import net.minecraft.core.registries.Registries
 import net.minecraft.network.codec.ByteBufCodecs
 import net.minecraft.resources.ResourceKey
 import net.minecraft.resources.ResourceLocation
-import net.minecraft.util.ExtraCodecs

 object CobblemonItemComponents : PlatformRegistry<Registry<DataComponentType<*>>, ResourceKey<Registry<DataComponentType<*>>>, DataComponentType<*>>() {

@@ -69,22 +68,6 @@ object CobblemonItemComponents : PlatformRegistry<Registry<DataComponentType<*>>
        .persistent(FoodColourComponent.CODEC)
        .networkSynchronized(FoodColourComponent.PACKET_CODEC)
        .build())
-    @JvmField
-    val EGG_DATA: DataComponentType<EggComponent> = create("egg", DataComponentType.builder<EggComponent>()
-            .persistent(EggComponent.CODEC) // For saving/loading
-            .networkSynchronized(EggComponent.PACKET_CODEC) // For network synchronization
-            .build())
-    @JvmField
-    val EGG_MODEL: DataComponentType<String> = create("egg_model", DataComponentType.builder<String>()
-        .persistent(ExtraCodecs.NON_EMPTY_STRING)
-        .networkSynchronized(ByteBufCodecs.STRING_UTF8)
-        .build())
-
-    @JvmField
-    val TM_MOVE: DataComponentType<TMMoveComponent> = create("tm_move", DataComponentType.builder<TMMoveComponent>()
-        .persistent(TMMoveComponent.CODEC)
-        .networkSynchronized(TMMoveComponent.PACKET_CODEC)
-        .build())

    @JvmField
    val INGREDIENT: DataComponentType<IngredientComponent> = create("ingredient", DataComponentType.builder<IngredientComponent>()
@@ -118,12 +101,9 @@ object CobblemonItemComponents : PlatformRegistry<Registry<DataComponentType<*>>
        Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.parse("cobblemon:flavour"), FLAVOUR)
        Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.parse("cobblemon:ride_boosts"), RIDE_BOOST)
        Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.parse("cobblemon:food_colour"), FOOD_COLOUR)
-        Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.parse("cobblemon:tm_move"), TM_MOVE)
        Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.parse("cobblemon:ingredient"), INGREDIENT)
        Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.parse("cobblemon:food"), FOOD)
        Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.parse("cobblemon:mob_effects"), MOB_EFFECTS)
-        Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.parse("cobblemon:egg_data"), EGG_DATA)
-        Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.parse("cobblemon:egg_model"), EGG_MODEL)
        Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.parse("cobblemon:held_item_effect"), HELD_ITEM_EFFECT)
    }

@@ -21,8 +21,8 @@ import com.cobblemon.mod.common.api.text.gray
 import com.cobblemon.mod.common.block.BerryBlock
 import com.cobblemon.mod.common.block.MintBlock
 import com.cobblemon.mod.common.block.MintBlock.MintType
-import com.cobblemon.mod.common.block.campfirepot.CampfirePotColor
 import com.cobblemon.mod.common.client.pokedex.PokedexType
+import com.cobblemon.mod.common.block.campfirepot.CampfirePotColor
 import com.cobblemon.mod.common.entity.boat.CobblemonBoatType
 import com.cobblemon.mod.common.item.*
 import com.cobblemon.mod.common.item.armor.CobblemonArmorTrims
@@ -35,6 +35,7 @@ import com.cobblemon.mod.common.item.berry.HealingBerryItem
 import com.cobblemon.mod.common.item.berry.PPRestoringBerryItem
 import com.cobblemon.mod.common.item.berry.PortionHealingBerryItem
 import com.cobblemon.mod.common.item.berry.StatusCuringBerryItem
+import com.cobblemon.mod.common.item.interactive.PonigiriItem
 import com.cobblemon.mod.common.item.food.SinisterTeaItem
 import com.cobblemon.mod.common.item.interactive.*
 import com.cobblemon.mod.common.item.interactive.ability.AbilityChangeItem
@@ -205,8 +206,6 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val CAMPFIRE_POT_WHITE = campfirePotItem(CobblemonBlocks.WHITE_CAMPFIRE_POT, CampfirePotColor.WHITE)

-    @JvmField
-    val SCAREKROW = blockItem("scarekrow", CobblemonBlocks.SCAREKROW)
    @JvmField
    val HEARTY_GRAINS = compostableItem("hearty_grains", ItemNameBlockItem(CobblemonBlocks.HEARTY_GRAINS, Properties().rarity(Rarity.COMMON)))
    @JvmField
@@ -407,7 +406,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
@@ -454,16 +453,10 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val MONITOR = blockItem("monitor", CobblemonBlocks.MONITOR)
    @JvmField
-    val DAMAGED_MONITOR = blockItem("damaged_monitor", CobblemonBlocks.DAMAGED_MONITOR)
-    @JvmField
    val HEALING_MACHINE = blockItem("healing_machine", CobblemonBlocks.HEALING_MACHINE, Rarity.UNCOMMON)
    @JvmField
    val PC = blockItem("pc", CobblemonBlocks.PC)
    @JvmField
-    val TM_MACHINE = blockItem("tm_machine", CobblemonBlocks.TM_MACHINE)
-    @JvmField
-    val DISC_SHELF = blockItem("disc_shelf", CobblemonBlocks.DISC_SHELF)
-    @JvmField
    val PASTURE = blockItem("pasture", CobblemonBlocks.PASTURE)
    @JvmField
    val DISPLAY_CASE = blockItem("display_case", CobblemonBlocks.DISPLAY_CASE)
@@ -474,9 +467,9 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    // Evolution items
    @JvmField val LINK_CABLE = create("link_cable", LinkCableItem())
    @JvmField val DRAGON_SCALE = noSettingsItem("dragon_scale")
-    @JvmField val METAL_COAT = itemNameBlockItem("metal_coat", CobblemonBlocks.METAL_COAT)
-    @JvmField val UPGRADE = itemNameBlockItem("upgrade", CobblemonBlocks.UPGRADE)
-    @JvmField val DUBIOUS_DISC = itemNameBlockItem("dubious_disc", CobblemonBlocks.DUBIOUS_DISC)
+    @JvmField val METAL_COAT = noSettingsItem("metal_coat")
+    @JvmField val UPGRADE = noSettingsItem("upgrade")
+    @JvmField val DUBIOUS_DISC = noSettingsItem("dubious_disc")
    @JvmField val DEEP_SEA_SCALE = noSettingsItem("deep_sea_scale")
    @JvmField val DEEP_SEA_TOOTH = noSettingsItem("deep_sea_tooth")
    @JvmField val ELECTIRIZER = noSettingsItem("electirizer")
@@ -485,7 +478,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField val PROTECTOR = noSettingsItem("protector")
    @JvmField val REAPER_CLOTH = noSettingsItem("reaper_cloth")
    @JvmField val PRISM_SCALE = noSettingsItem("prism_scale")
-    @JvmField val SACHET = itemNameBlockItem("sachet", CobblemonBlocks.SACHET)
+    @JvmField val SACHET = noSettingsItem("sachet")
    @JvmField val WHIPPED_DREAM = create("whipped_dream", foodItem(8, 0.3f))
    @JvmField val STRAWBERRY_SWEET = create("strawberry_sweet", foodItem(6, 0.125f))
    @JvmField val LOVE_SWEET = create("love_sweet", foodItem(6, 0.125f))
@@ -494,20 +487,22 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField val FLOWER_SWEET = create("flower_sweet", foodItem(6, 0.125f))
    @JvmField val STAR_SWEET = create("star_sweet", foodItem(6, 0.125f))
    @JvmField val RIBBON_SWEET = create("ribbon_sweet", foodItem(6, 0.125f))
-    @JvmField val CHIPPED_POT = itemNameBlockItem("chipped_pot", CobblemonBlocks.CHIPPED_POT)
-    @JvmField val CRACKED_POT = itemNameBlockItem("cracked_pot", CobblemonBlocks.CRACKED_POT)
-    @JvmField val MASTERPIECE_TEACUP = itemNameBlockItem("masterpiece_teacup", CobblemonBlocks.MASTERPIECE_TEACUP)
-    @JvmField val UNREMARKABLE_TEACUP = itemNameBlockItem("unremarkable_teacup", CobblemonBlocks.UNREMARKABLE_TEACUP)
+    @JvmField val CHIPPED_POT = noSettingsItem("chipped_pot")
+    @JvmField val CRACKED_POT = noSettingsItem("cracked_pot")
+    @JvmField val MASTERPIECE_TEACUP = noSettingsItem("masterpiece_teacup")
+    @JvmField val UNREMARKABLE_TEACUP = noSettingsItem("unremarkable_teacup")
    @JvmField val SWEET_APPLE = compostableItem("sweet_apple", foodItem(4, 0.3f), 0.65f)
    @JvmField val TART_APPLE = compostableItem("tart_apple", foodItem(4, 0.3f), 0.65f)
    @JvmField val SYRUPY_APPLE = compostableItem("syrupy_apple", foodItem(4, 0.3f), 0.65f)
-    @JvmField val GALARICA_CUFF = itemNameBlockItem("galarica_cuff", CobblemonBlocks.GALARICA_CUFF)
+    @JvmField val GALARICA_CUFF = noSettingsItem("galarica_cuff")
+    @JvmField val GALARICA_WREATH = noSettingsItem("galarica_wreath")
    @JvmField val BLACK_AUGURITE = noSettingsItem("black_augurite")
    @JvmField val PEAT_BLOCK = noSettingsItem("peat_block")
    @JvmField val RAZOR_CLAW = noSettingsItem("razor_claw")
    @JvmField val RAZOR_FANG = noSettingsItem("razor_fang")
    @JvmField val AUSPICIOUS_ARMOR = heldItem("auspicious_armor")
    @JvmField val MALICIOUS_ARMOR = heldItem("malicious_armor")
+    @JvmField val SHELL_HELMET = heldItem("shell_helmet")
    @JvmField val METAL_ALLOY = noSettingsItem("metal_alloy")
    @JvmField val SCROLL_OF_DARKNESS = noSettingsItem("scroll_of_darkness")
    @JvmField val SCROLL_OF_WATERS = noSettingsItem("scroll_of_waters")
@@ -604,25 +599,6 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It

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

-    val NEST_GRASSY = blockItem("nest_grassy", CobblemonBlocks.NEST_GRASSY)
-    val NEST_LEAFY = blockItem("nest_leafy", CobblemonBlocks.NEST_LEAFY)
-    val NEST_FIERY = blockItem("nest_fiery", CobblemonBlocks.NEST_FIERY)
-    val NEST_ICY = blockItem("nest_icy", CobblemonBlocks.NEST_ICY)
-    val NEST_HAY = blockItem("nest_hay", CobblemonBlocks.NEST_HAY)
-    val NEST_KELP = blockItem("nest_kelp", CobblemonBlocks.NEST_KELP)
-    val NEST_ROCKY = blockItem("nest_rocky", CobblemonBlocks.NEST_ROCKY)
-    val NEST_SANDY = blockItem("nest_sandy", CobblemonBlocks.NEST_SANDY)
-    val NEST_SHROOMY = blockItem("nest_shroomy", CobblemonBlocks.NEST_SHROOMY)
-    val NEST_TWIGGY = blockItem("nest_twiggy", CobblemonBlocks.NEST_TWIGGY)
-    val NEST_WATERY = blockItem("nest_watery", CobblemonBlocks.NEST_WATERY)
-
-
-    @JvmField
-    val INCUBATOR = blockItem("incubator", CobblemonBlocks.INCUBATOR)
-
-    @JvmField
-    val HABITAT_BLOCK = blockItem("habitat_block", CobblemonBlocks.HABITAT_BLOCK)
-
    @JvmField
    val GALARICA_NUTS = compostableItemNameBlockItem("galarica_nuts", CobblemonBlocks.GALARICA_NUT_BUSH)

@@ -667,17 +643,17 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val EXPERIENCE_CANDY_XL = candyItem("exp_candy_xl") { _, _ -> CandyItem.DEFAULT_XL_CANDY_YIELD }
    @JvmField
-    val CALCIUM = create("calcium", VitaminItem(Stats.SPECIAL_ATTACK, CobblemonBlocks.CALCIUM))
+    val CALCIUM = create("calcium", VitaminItem(Stats.SPECIAL_ATTACK))
    @JvmField
-    val CARBOS = create("carbos", VitaminItem(Stats.SPEED, CobblemonBlocks.CARBOS))
+    val CARBOS = create("carbos", VitaminItem(Stats.SPEED))
    @JvmField
-    val HP_UP = create("hp_up", VitaminItem(Stats.HP, CobblemonBlocks.HP_UP))
+    val HP_UP = create("hp_up", VitaminItem(Stats.HP))
    @JvmField
-    val IRON = create("iron", VitaminItem(Stats.DEFENCE, CobblemonBlocks.IRON))
+    val IRON = create("iron", VitaminItem(Stats.DEFENCE))
    @JvmField
-    val PROTEIN = create("protein", VitaminItem(Stats.ATTACK, CobblemonBlocks.PROTEIN))
+    val PROTEIN = create("protein", VitaminItem(Stats.ATTACK))
    @JvmField
-    val ZINC = create("zinc", VitaminItem(Stats.SPECIAL_DEFENCE, CobblemonBlocks.ZINC))
+    val ZINC = create("zinc", VitaminItem(Stats.SPECIAL_DEFENCE))
    @JvmField
    val HEALTH_MOCHI = create("health_mochi", MochiItem(Stats.HP))
    @JvmField
@@ -759,9 +735,9 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val MAX_REVIVE = create("max_revive", ReviveItem(max = true))
    @JvmField
-    val PP_UP = create("pp_up", PPUpItem(1, CobblemonBlocks.PP_UP))
+    val PP_UP = create("pp_up", PPUpItem(1))
    @JvmField
-    val PP_MAX = create("pp_max", PPUpItem(3, CobblemonBlocks.PP_MAX))
+    val PP_MAX = create("pp_max", PPUpItem(3))

    @JvmField
    val RED_MINT_SEEDS = mintSeed("red", MintType.RED.getCropBlock())
@@ -843,7 +819,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField val DIRE_HIT = create("dire_hit", DireHitItem(CobblemonBlocks.DIRE_HIT))
    @JvmField val GUARD_SPEC = create("guard_spec", GuardSpecItem(CobblemonBlocks.GUARD_SPEC))

-    @JvmField val FULL_HEAL = create("full_heal", StatusCureItem("item.cobblemon.full_heal", *Statuses.getPersistentStatuses().toTypedArray(), block = CobblemonBlocks.FULL_HEAL))
+    @JvmField val FULL_HEAL = create("full_heal", StatusCureItem("item.cobblemon.full_heal", block = CobblemonBlocks.FULL_HEAL))
    @JvmField val ANTIDOTE = create("antidote", StatusCureItem("item.cobblemon.antidote", Statuses.POISON, Statuses.POISON_BADLY, block = CobblemonBlocks.ANTIDOTE))
    @JvmField val AWAKENING = create("awakening", StatusCureItem("item.cobblemon.awakening", Statuses.SLEEP, block = CobblemonBlocks.AWAKENING))
    @JvmField val BURN_HEAL = create("burn_heal", StatusCureItem("item.cobblemon.burn_heal", Statuses.BURN, block = CobblemonBlocks.BURN_HEAL))
@@ -938,18 +914,11 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField val CHOICE_SPECS = wearableItem("choice_specs")
    @JvmField val EXP_SHARE = wearableItem("exp_share")
    @JvmField val FOCUS_BAND = wearableItem("focus_band")
-    @JvmField val KINGS_ROCK = wearableBlockItem("kings_rock", CobblemonBlocks.KINGS_ROCK)
-    @JvmField val NEVER_MELT_ICE = wearableBlockItem("never_melt_ice", CobblemonBlocks.NEVER_MELT_ICE)
+    @JvmField val KINGS_ROCK = wearableItem("kings_rock")
    @JvmField val MUSCLE_BAND = wearableItem("muscle_band")
    @JvmField val ROCKY_HELMET = wearableItem("rocky_helmet")
    @JvmField val SAFETY_GOGGLES = wearableItem("safety_goggles")
    @JvmField val WISE_GLASSES = wearableItem("wise_glasses")
-    @JvmField val SHARP_BEAK = wearableItem("sharp_beak")
-    @JvmField val COVERT_CLOAK = wearableItem("covert_cloak")
-    @JvmField val SHELL_HELMET = wearableItem("shell_helmet")
-    @JvmField val GALARICA_WREATH = wearableBlockItem("galarica_wreath", CobblemonBlocks.GALARICA_WREATH)
-    @JvmField val CLEANSE_TAG = wearableBlockItem("cleanse_tag", CobblemonBlocks.CLEANSE_TAG)
-    @JvmField val SPELL_TAG = wearableBlockItem("spell_tag", CobblemonBlocks.SPELL_TAG)

    // Held Items
    @JvmField
@@ -977,13 +946,17 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val CHOICE_SCARF = heldItem("choice_scarf")
    @JvmField
+    val CLEANSE_TAG = itemNameBlockItem("cleanse_tag", CobblemonBlocks.CLEANSE_TAG)
+    @JvmField
    val CLEAR_AMULET = heldItem("clear_amulet")
    @JvmField
-    val DESTINY_KNOT = create("destiny_knot", ItemNameBlockItem(CobblemonBlocks.DESTINY_KNOT, Item.Properties().durability(256)))
+    val COVERT_CLOAK = heldItem("covert_cloak")
+    @JvmField
+    val DESTINY_KNOT = heldItem("destiny_knot")
    @JvmField
    val DRAGON_FANG = heldItem("dragon_fang")
    @JvmField
-    val EJECT_BUTTON = itemNameBlockItem("eject_button", CobblemonBlocks.EJECT_BUTTON)
+    val EJECT_BUTTON = heldItem("eject_button")
    @JvmField
    val EJECT_PACK = heldItem("eject_pack")
    @JvmField
@@ -997,7 +970,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val FAIRY_FEATHER = heldItem("fairy_feather")
    @JvmField
-    val FLAME_ORB = itemNameBlockItem("flame_orb", CobblemonBlocks.FLAME_ORB)
+    val FLAME_ORB = heldItem("flame_orb")
    @JvmField
    val FLOAT_STONE = heldItem("float_stone")
    @JvmField
@@ -1011,32 +984,34 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val HEAVY_DUTY_BOOTS = heldItem("heavy_duty_boots")
    @JvmField
-    val IRON_BALL = itemNameBlockItem("iron_ball", CobblemonBlocks.IRON_BALL)
+    val IRON_BALL = heldItem("iron_ball")
    @JvmField
    val LAGGING_TAIL = heldItem("lagging_tail")
    @JvmField
    val LEFTOVERS = compostableHeldItem("leftovers", null, 0.50f)
    @JvmField
-    val LIFE_ORB = itemNameBlockItem("life_orb", CobblemonBlocks.LIFE_ORB)
+    val LIFE_ORB = heldItem("life_orb")
    @JvmField
-    val LIGHT_BALL = itemNameBlockItem("light_ball", CobblemonBlocks.LIGHT_BALL)
+    val LIGHT_BALL = heldItem("light_ball")
    @JvmField
    val LIGHT_CLAY = heldItem("light_clay")
    @JvmField
-    val LOADED_DICE = itemNameBlockItem("loaded_dice", CobblemonBlocks.LOADED_DICE)
+    val LOADED_DICE = heldItem("loaded_dice")
    @JvmField
    val LUCKY_EGG = heldItem("lucky_egg")
    @JvmField
-    val LUMINOUS_MOSS = itemNameBlockItem("luminous_moss", CobblemonBlocks.LUMINOUS_MOSS)
+    val LUMINOUS_MOSS = heldItem("luminous_moss")
    @JvmField
-    val MAGNET = itemNameBlockItem("magnet", CobblemonBlocks.MAGNET)
+    val MAGNET = heldItem("magnet")
    @JvmField
-    val METRONOME = itemNameBlockItem("metronome", CobblemonBlocks.METRONOME)
+    val METRONOME = heldItem("metronome")
    @JvmField
    val MIRACLE_SEED = heldItem("miracle_seed")
    @JvmField
    val MYSTIC_WATER = heldItem("mystic_water")
    @JvmField
+    val NEVER_MELT_ICE = heldItem("never_melt_ice")
+    @JvmField
    val POISON_BARB = heldItem("poison_barb")
    @JvmField
    val POWER_ANKLET = heldItem("power_anklet")
@@ -1061,11 +1036,13 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val RED_CARD = heldItem("red_card")
    @JvmField
-    val RING_TARGET = itemNameBlockItem("ring_target", CobblemonBlocks.RING_TARGET)
+    val RING_TARGET = heldItem("ring_target")
    @JvmField
    val ROOM_SERVICE = heldItem("room_service")
    @JvmField
-    val SCOPE_LENS = itemNameBlockItem("scope_lens", CobblemonBlocks.SCOPE_LENS)
+    val SCOPE_LENS = heldItem("scope_lens")
+    @JvmField
+    val SHARP_BEAK = heldItem("sharp_beak")
    @JvmField
    val SHED_SHELL = heldItem("shed_shell")
    @JvmField
@@ -1077,7 +1054,9 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val SOFT_SAND = heldItem("soft_sand")
    @JvmField
-    val SMOKE_BALL = itemNameBlockItem("smoke_ball", CobblemonBlocks.SMOKE_BALL)
+    val SPELL_TAG = itemNameBlockItem("spell_tag", CobblemonBlocks.SPELL_TAG)
+    @JvmField
+    val SMOKE_BALL = heldItem("smoke_ball")
    @JvmField
    val SOOTHE_BELL = heldItem("soothe_bell")
    @JvmField
@@ -1085,9 +1064,9 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val TERRAIN_EXTENDER = heldItem("terrain_extender")
    @JvmField
-    val THROAT_SPRAY = itemNameBlockItem("throat_spray", CobblemonBlocks.THROAT_SPRAY)
+    val THROAT_SPRAY = heldItem("throat_spray")
    @JvmField
-    val TOXIC_ORB = itemNameBlockItem("toxic_orb", CobblemonBlocks.TOXIC_ORB)
+    val TOXIC_ORB = heldItem("toxic_orb")
    @JvmField
    val TWISTED_SPOON = heldItem("twisted_spoon")
    @JvmField
@@ -1095,9 +1074,9 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val WEAKNESS_POLICY = itemNameBlockItem("weakness_policy", CobblemonBlocks.WEAKNESS_POLICY)
    @JvmField
-    val WIDE_LENS = itemNameBlockItem("wide_lens", CobblemonBlocks.WIDE_LENS)
+    val WIDE_LENS = heldItem("wide_lens")
    @JvmField
-    val ZOOM_LENS = itemNameBlockItem("zoom_lens", CobblemonBlocks.ZOOM_LENS)
+    val ZOOM_LENS = heldItem("zoom_lens")
    @JvmField
    val MENTAL_HERB = compostableHeldItem("mental_herb", null, 0.85F)
    @JvmField
@@ -1109,19 +1088,19 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val WHITE_HERB = compostableHeldItem("white_herb", null, 0.85F)
    @JvmField
-    val BRIGHT_POWDER = itemNameBlockItem("bright_powder", CobblemonBlocks.BRIGHT_POWDER)
+    val BRIGHT_POWDER = heldItem("bright_powder")
    @JvmField
-    val METAL_POWDER = itemNameBlockItem("metal_powder", CobblemonBlocks.METAL_POWDER)
+    val METAL_POWDER = heldItem("metal_powder")
    @JvmField
-    val QUICK_POWDER = itemNameBlockItem("quick_powder", CobblemonBlocks.QUICK_POWDER)
+    val QUICK_POWDER = heldItem("quick_powder")
    @JvmField
-    val DAMP_ROCK = itemNameBlockItem("damp_rock", CobblemonBlocks.DAMP_ROCK)
+    val DAMP_ROCK = heldItem("damp_rock")
    @JvmField
-    val HEAT_ROCK = itemNameBlockItem("heat_rock", CobblemonBlocks.HEAT_ROCK)
+    val HEAT_ROCK = heldItem("heat_rock")
    @JvmField
-    val SMOOTH_ROCK = itemNameBlockItem("smooth_rock", CobblemonBlocks.SMOOTH_ROCK)
+    val SMOOTH_ROCK = heldItem("smooth_rock")
    @JvmField
-    val ICY_ROCK = itemNameBlockItem("icy_rock", CobblemonBlocks.ICY_ROCK)
+    val ICY_ROCK = heldItem("icy_rock")

    // Mulch
    @JvmField
@@ -1229,83 +1208,6 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val BLACK_TUMBLESTONE_BLOCK = blockItem("black_tumblestone_block", CobblemonBlocks.BLACK_TUMBLESTONE_BLOCK)

-    @JvmField
-    val TYPE_GEM_CORE = blockItem("deepslate_crystal_core", CobblemonBlocks.TYPE_GEM_CORE)
-
-    @JvmField
-    val TYPE_GEM_CLUSTER_NORMAL = blockItem("normal_gem_cluster", CobblemonBlocks.TYPE_GEM_CLUSTER_NORMAL)
-    @JvmField
-    val TYPE_GEM_CLUSTER_FIRE = blockItem("fire_gem_cluster", CobblemonBlocks.TYPE_GEM_CLUSTER_FIRE)
-    @JvmField
-    val TYPE_GEM_CLUSTER_WATER = blockItem("water_gem_cluster", CobblemonBlocks.TYPE_GEM_CLUSTER_WATER)
-    @JvmField
-    val TYPE_GEM_CLUSTER_ELECTRIC = blockItem("electric_gem_cluster", CobblemonBlocks.TYPE_GEM_CLUSTER_ELECTRIC)
-    @JvmField
-    val TYPE_GEM_CLUSTER_GRASS = blockItem("grass_gem_cluster", CobblemonBlocks.TYPE_GEM_CLUSTER_GRASS)
-    @JvmField
-    val TYPE_GEM_CLUSTER_ICE = blockItem("ice_gem_cluster", CobblemonBlocks.TYPE_GEM_CLUSTER_ICE)
-    @JvmField
-    val TYPE_GEM_CLUSTER_FIGHTING = blockItem("fighting_gem_cluster", CobblemonBlocks.TYPE_GEM_CLUSTER_FIGHTING)
-    @JvmField
-    val TYPE_GEM_CLUSTER_POISON = blockItem("poison_gem_cluster", CobblemonBlocks.TYPE_GEM_CLUSTER_POISON)
-    @JvmField
-    val TYPE_GEM_CLUSTER_GROUND = blockItem("ground_gem_cluster", CobblemonBlocks.TYPE_GEM_CLUSTER_GROUND)
-    @JvmField
-    val TYPE_GEM_CLUSTER_FLYING = blockItem("flying_gem_cluster", CobblemonBlocks.TYPE_GEM_CLUSTER_FLYING)
-    @JvmField
-    val TYPE_GEM_CLUSTER_PSYCHIC = blockItem("psychic_gem_cluster", CobblemonBlocks.TYPE_GEM_CLUSTER_PSYCHIC)
-    @JvmField
-    val TYPE_GEM_CLUSTER_BUG = blockItem("bug_gem_cluster", CobblemonBlocks.TYPE_GEM_CLUSTER_BUG)
-    @JvmField
-    val TYPE_GEM_CLUSTER_ROCK = blockItem("rock_gem_cluster", CobblemonBlocks.TYPE_GEM_CLUSTER_ROCK)
-    @JvmField
-    val TYPE_GEM_CLUSTER_GHOST = blockItem("ghost_gem_cluster", CobblemonBlocks.TYPE_GEM_CLUSTER_GHOST)
-    @JvmField
-    val TYPE_GEM_CLUSTER_DRAGON = blockItem("dragon_gem_cluster", CobblemonBlocks.TYPE_GEM_CLUSTER_DRAGON)
-    @JvmField
-    val TYPE_GEM_CLUSTER_DARK = blockItem("dark_gem_cluster", CobblemonBlocks.TYPE_GEM_CLUSTER_DARK)
-    @JvmField
-    val TYPE_GEM_CLUSTER_STEEL = blockItem("steel_gem_cluster", CobblemonBlocks.TYPE_GEM_CLUSTER_STEEL)
-    @JvmField
-    val TYPE_GEM_CLUSTER_FAIRY = blockItem("fairy_gem_cluster", CobblemonBlocks.TYPE_GEM_CLUSTER_FAIRY)
-
-    @JvmField
-    val TYPE_GEM_BLOCK_NORMAL = blockItem("normal_gem_block", CobblemonBlocks.TYPE_GEM_BLOCK_NORMAL)
-    @JvmField
-    val TYPE_GEM_BLOCK_FIRE = blockItem("fire_gem_block", CobblemonBlocks.TYPE_GEM_BLOCK_FIRE)
-    @JvmField
-    val TYPE_GEM_BLOCK_WATER = blockItem("water_gem_block", CobblemonBlocks.TYPE_GEM_BLOCK_WATER)
-    @JvmField
-    val TYPE_GEM_BLOCK_ELECTRIC = blockItem("electric_gem_block", CobblemonBlocks.TYPE_GEM_BLOCK_ELECTRIC)
-    @JvmField
-    val TYPE_GEM_BLOCK_GRASS = blockItem("grass_gem_block", CobblemonBlocks.TYPE_GEM_BLOCK_GRASS)
-    @JvmField
-    val TYPE_GEM_BLOCK_ICE = blockItem("ice_gem_block", CobblemonBlocks.TYPE_GEM_BLOCK_ICE)
-    @JvmField
-    val TYPE_GEM_BLOCK_FIGHTING = blockItem("fighting_gem_block", CobblemonBlocks.TYPE_GEM_BLOCK_FIGHTING)
-    @JvmField
-    val TYPE_GEM_BLOCK_POISON = blockItem("poison_gem_block", CobblemonBlocks.TYPE_GEM_BLOCK_POISON)
-    @JvmField
-    val TYPE_GEM_BLOCK_GROUND = blockItem("ground_gem_block", CobblemonBlocks.TYPE_GEM_BLOCK_GROUND)
-    @JvmField
-    val TYPE_GEM_BLOCK_FLYING = blockItem("flying_gem_block", CobblemonBlocks.TYPE_GEM_BLOCK_FLYING)
-    @JvmField
-    val TYPE_GEM_BLOCK_PSYCHIC = blockItem("psychic_gem_block", CobblemonBlocks.TYPE_GEM_BLOCK_PSYCHIC)
-    @JvmField
-    val TYPE_GEM_BLOCK_BUG = blockItem("bug_gem_block", CobblemonBlocks.TYPE_GEM_BLOCK_BUG)
-    @JvmField
-    val TYPE_GEM_BLOCK_ROCK = blockItem("rock_gem_block", CobblemonBlocks.TYPE_GEM_BLOCK_ROCK)
-    @JvmField
-    val TYPE_GEM_BLOCK_GHOST = blockItem("ghost_gem_block", CobblemonBlocks.TYPE_GEM_BLOCK_GHOST)
-    @JvmField
-    val TYPE_GEM_BLOCK_DRAGON = blockItem("dragon_gem_block", CobblemonBlocks.TYPE_GEM_BLOCK_DRAGON)
-    @JvmField
-    val TYPE_GEM_BLOCK_DARK = blockItem("dark_gem_block", CobblemonBlocks.TYPE_GEM_BLOCK_DARK)
-    @JvmField
-    val TYPE_GEM_BLOCK_STEEL = blockItem("steel_gem_block", CobblemonBlocks.TYPE_GEM_BLOCK_STEEL)
-    @JvmField
-    val TYPE_GEM_BLOCK_FAIRY = blockItem("fairy_gem_block", CobblemonBlocks.TYPE_GEM_BLOCK_FAIRY)
-
    @JvmField
    val POKEROD_SMITHING_TEMPLATE = create("pokerod_smithing_template", SmithingTemplateItem(
        Component.translatable("item.minecraft.fishing_rod").blue(),
@@ -1530,55 +1432,46 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    val RELIC_COIN_POUCH = blockItem("relic_coin_pouch", CobblemonBlocks.RELIC_COIN_POUCH)
    @JvmField
    val RELIC_COIN_SACK = blockItem("relic_coin_sack", CobblemonBlocks.RELIC_COIN_SACK)
-    @JvmField
-    val TECHNICAL_MACHINE = this.create("technical_machine", TechnicalMachineItem(Properties()))
-    @JvmField
-    val BLANK_TM = this.create("blank_tm", CobblemonItem(Item.Properties()))

    // Type Gems
    @JvmField
-    val NORMAL_GEM = this.create("normal_gem", GemItem(Item.Properties(), CobblemonBlocks.TYPE_GEM_CLUSTER_NORMAL))
+    val NORMAL_GEM = noSettingsItem("normal_gem")
    @JvmField
-    val FIRE_GEM = this.create("fire_gem", GemItem(Item.Properties(), CobblemonBlocks.TYPE_GEM_CLUSTER_FIRE))
+    val FIRE_GEM = noSettingsItem("fire_gem")
    @JvmField
-    val WATER_GEM = this.create("water_gem", GemItem(Item.Properties(), CobblemonBlocks.TYPE_GEM_CLUSTER_WATER))
+    val WATER_GEM = noSettingsItem("water_gem")
    @JvmField
-    val GRASS_GEM = this.create("grass_gem", GemItem(Item.Properties(), CobblemonBlocks.TYPE_GEM_CLUSTER_GRASS))
+    val GRASS_GEM = noSettingsItem("grass_gem")
    @JvmField
-    val ELECTRIC_GEM = this.create("electric_gem", GemItem(Item.Properties(), CobblemonBlocks.TYPE_GEM_CLUSTER_ELECTRIC))
+    val ELECTRIC_GEM = noSettingsItem("electric_gem")
    @JvmField
-    val ICE_GEM = this.create("ice_gem", GemItem(Item.Properties(), CobblemonBlocks.TYPE_GEM_CLUSTER_ICE))
+    val ICE_GEM = noSettingsItem("ice_gem")
    @JvmField
-    val FIGHTING_GEM = this.create("fighting_gem", GemItem(Item.Properties(), CobblemonBlocks.TYPE_GEM_CLUSTER_FIGHTING))
+    val FIGHTING_GEM = noSettingsItem("fighting_gem")
    @JvmField
-    val POISON_GEM = this.create("poison_gem", GemItem(Item.Properties(), CobblemonBlocks.TYPE_GEM_CLUSTER_POISON))
+    val POISON_GEM = noSettingsItem("poison_gem")
    @JvmField
-    val GROUND_GEM = this.create("ground_gem", GemItem(Item.Properties(), CobblemonBlocks.TYPE_GEM_CLUSTER_GROUND))
+    val GROUND_GEM = noSettingsItem("ground_gem")
    @JvmField
-    val FLYING_GEM = this.create("flying_gem", GemItem(Item.Properties(), CobblemonBlocks.TYPE_GEM_CLUSTER_FLYING))
+    val FLYING_GEM = noSettingsItem("flying_gem")
    @JvmField
-    val PSYCHIC_GEM = this.create("psychic_gem", GemItem(Item.Properties(), CobblemonBlocks.TYPE_GEM_CLUSTER_PSYCHIC))
+    val PSYCHIC_GEM = noSettingsItem("psychic_gem")
    @JvmField
-    val BUG_GEM = this.create("bug_gem", GemItem(Item.Properties(), CobblemonBlocks.TYPE_GEM_CLUSTER_BUG))
+    val BUG_GEM = noSettingsItem("bug_gem")
    @JvmField
-    val ROCK_GEM = this.create("rock_gem", GemItem(Item.Properties(), CobblemonBlocks.TYPE_GEM_CLUSTER_ROCK))
+    val ROCK_GEM = noSettingsItem("rock_gem")
    @JvmField
-    val GHOST_GEM = this.create("ghost_gem", GemItem(Item.Properties(), CobblemonBlocks.TYPE_GEM_CLUSTER_GHOST))
+    val GHOST_GEM = noSettingsItem("ghost_gem")
    @JvmField
-    val DRAGON_GEM = this.create("dragon_gem", GemItem(Item.Properties(), CobblemonBlocks.TYPE_GEM_CLUSTER_DRAGON))
+    val DRAGON_GEM = noSettingsItem("dragon_gem")
    @JvmField
-    val DARK_GEM = this.create("dark_gem", GemItem(Item.Properties(), CobblemonBlocks.TYPE_GEM_CLUSTER_DARK))
+    val DARK_GEM = noSettingsItem("dark_gem")
    @JvmField
-    val STEEL_GEM = this.create("steel_gem", GemItem(Item.Properties(), CobblemonBlocks.TYPE_GEM_CLUSTER_STEEL))
+    val STEEL_GEM = noSettingsItem("steel_gem")
    @JvmField
-    val FAIRY_GEM = this.create("fairy_gem", GemItem(Item.Properties(), CobblemonBlocks.TYPE_GEM_CLUSTER_FAIRY))
-
+    val FAIRY_GEM = noSettingsItem("fairy_gem")
    //@JvmField
    //val BINDING_SOIL = blockItem("binding_soil", CobblemonBlocks.BINDING_SOIL)
-    @JvmField
-    val POKEMON_EGG = eggItem("egg", CobblemonBlocks.EGG, Item.Properties().stacksTo(1))
-
-    private fun eggItem(name: String, block: Block, settings: Item.Properties = Item.Properties()): BlockItem = this.create(name, BlockItem(block, settings))

    private fun blockItem(name: String, block: Block, rarity: Rarity = Rarity.COMMON): BlockItem = this.create(name, BlockItem(block, Item.Properties().rarity(rarity)))

@@ -1616,16 +1509,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It

    private fun wearableItem(name: String, heldItemRemappedName: String? = null): CobblemonItem = create(
        name,
-        WearableHatItem(name).also {
-            wearables.add(it)
-            if (heldItemRemappedName != null) {
-                CobblemonHeldItemManager.registerRemap(it, heldItemRemappedName)
-            }
-        }
-    )
-    private fun wearableBlockItem(name: String, block: Block, heldItemRemappedName: String? = null): WearableBlockItem = create(
-        name,
-        WearableBlockItem(name, block).also {
+        WearableItem(name).also {
            wearables.add(it)
            if (heldItemRemappedName != null) {
                CobblemonHeldItemManager.registerRemap(it, heldItemRemappedName)
@@ -1677,9 +1561,9 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
        return create(name, RegionalFoodItem(properties))
    }

-    private fun heldItem(name: String, remappedName: String? = null, settings:Item.Properties = Item.Properties()): CobblemonItem = create(
+    private fun heldItem(name: String, remappedName: String? = null): CobblemonItem = create(
        name,
-        CobblemonItem(settings).also {
+        CobblemonItem(Item.Properties()).also {
            if (remappedName != null) {
                CobblemonHeldItemManager.registerRemap(it, remappedName)
            }
@@ -12,7 +12,6 @@ import com.cobblemon.mod.common.api.ai.CobblemonAttackTargetData
 import com.cobblemon.mod.common.api.ai.CobblemonWanderControl
 import com.cobblemon.mod.common.api.dialogue.ActiveDialogue
 import com.cobblemon.mod.common.api.moves.animations.ActionEffectContext
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.mojang.serialization.Codec
 import com.mojang.serialization.codecs.ListCodec
 import com.mojang.serialization.codecs.PrimitiveCodec
@@ -22,7 +21,6 @@ import net.minecraft.core.BlockPos
 import net.minecraft.core.UUIDUtil
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.ai.memory.MemoryModuleType
-import net.minecraft.world.entity.player.Player

 object CobblemonMemories {
    val memories = mutableMapOf<String, MemoryModuleType<*>>()
@@ -41,14 +39,6 @@ object CobblemonMemories {
    @JvmField
    val ACTIVE_ACTION_EFFECT = register<ActionEffectContext>("active_action_effect")
    @JvmField
-    val POTENTIAL_MATE = register<PokemonEntity>("potential_mate")
-    @JvmField
-    val MATE_SCAN_COOLDOWN = register("mate_scan_cooldown", PrimitiveCodec.BOOL)
-    @JvmField
-    val NEST_LOCATION = register<BlockPos>("nest_location")
-    @JvmField
-    val PATERNAL_NEST_LOCATION = register<BlockPos>("paternal_nest", BlockPos.CODEC)
-    @JvmField
    val POKEMON_FLYING = register("pokemon_flying", PrimitiveCodec.BOOL)
    @JvmField
    val POKEMON_DROWSY = register("pokemon_drowsy", PrimitiveCodec.BOOL)
@@ -65,22 +55,6 @@ object CobblemonMemories {
    @JvmField
    val NEARBY_GROWABLE_CROPS = register<BlockPos>("nearby_growable_crops")
    @JvmField
-    val EGG_THIEF = register<Player>("egg_thief") // Stores the player stealing the egg
-    @JvmField
-    val EGG_THIEF_LAST_SEEN_TICK = register("egg_thief_last_seen_tick", PrimitiveCodec.LONG)
-    @JvmField
-    val EGG_LOCATION = register<BlockPos>("egg_location") // Stores the last known location of the egg
-    @JvmField
-    val EGG_IN_NEST = register("egg_in_nest", PrimitiveCodec.BOOL)
-    @JvmField
-    val HOLDING_EGG = register("holding_egg", PrimitiveCodec.BOOL)
-    @JvmField
-    val EGG_SEARCH_COUNTDOWN = register ("egg_search_countdown", PrimitiveCodec.BOOL)
-    @JvmField
-    val IDEAL_NEST_LOCATION = register<BlockPos>("ideal_nest_location")
-    @JvmField
-    val NEST_DESPAWN_IMMUNE_UNTIL_TICK = register("nest_despawn_immune_until_tick", PrimitiveCodec.LONG)
-    @JvmField
    val NEARBY_SWEET_BERRY_BUSH = register<BlockPos>("nearest_sweet_berry_bush")
    @JvmField
    val DISABLE_WALK_TO_BERRY_BUSH = register<Boolean>("disable_walk_to_berry_bush")
@@ -114,8 +88,6 @@ object CobblemonMemories {
    val DISABLE_WALK_TO_WANTED_ITEM = register<Boolean>("disable_walk_to_wanted_item")
    @JvmField
    val TIME_TRYING_TO_REACH_WANTED_ITEM = register<Int>("time_trying_to_wanted_item")
-    @JvmField
-    val NEARBY_SCAREKROW = register<BlockPos>("nearby_scarekrow", BlockPos.CODEC)

    @JvmStatic
    fun <U> register(id: String, codec: Codec<U>): MemoryModuleType<U> {
@@ -130,4 +102,4 @@ object CobblemonMemories {
        memories[id] = memoryModule
        return memoryModule
    }
-}
+}
@@ -10,7 +10,6 @@ package com.cobblemon.mod.common


 import com.cobblemon.mod.common.block.campfirepot.CookingPotMenu
-import com.cobblemon.mod.common.block.tmmachine.TMMachineMenu
 import com.cobblemon.mod.common.platform.PlatformRegistry
 import net.minecraft.core.Registry
 import net.minecraft.core.registries.BuiltInRegistries
@@ -20,8 +19,7 @@ import net.minecraft.world.inventory.MenuType

 object CobblemonMenuType : PlatformRegistry<Registry<MenuType<*>>, ResourceKey<Registry<MenuType<*>>>, MenuType<*>>() {

-    val COOKING_POT = MenuType.register("cooking_pot_menu", ::CookingPotMenu)
-    val TM_MACHINE = MenuType.register("tm_machine_menu", ::TMMachineMenu)
+    val COOKING_POT = MenuType.register("cooking_pot", ::CookingPotMenu)

    override val registry: Registry<MenuType<*>>
        get() = BuiltInRegistries.MENU
@@ -1,55 +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
-
-import com.cobblemon.mod.common.api.data.JsonDataRegistry
-import com.cobblemon.mod.common.api.moves.MoveSelector
-import com.cobblemon.mod.common.api.moves.MovesetBuilder
-import com.cobblemon.mod.common.api.reactive.SimpleObservable
-import com.cobblemon.mod.common.util.adapters.IdentifierAdapter
-import com.cobblemon.mod.common.util.adapters.MovesetBuilderAdapter
-import com.cobblemon.mod.common.util.adapters.StringToObjectAdapter
-import com.cobblemon.mod.common.util.cobblemonResource
-import com.google.gson.Gson
-import com.google.gson.GsonBuilder
-import com.google.gson.reflect.TypeToken
-import net.minecraft.resources.ResourceLocation
-import net.minecraft.server.level.ServerPlayer
-import net.minecraft.server.packs.PackType
-
-object CobblemonMovesetBuilders : JsonDataRegistry<MovesetBuilder> {
-    override val gson: Gson = GsonBuilder()
-        .setPrettyPrinting()
-        .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
-        .registerTypeAdapter(MovesetBuilder::class.java, MovesetBuilderAdapter)
-        .registerTypeAdapter(MoveSelector::class.java, StringToObjectAdapter(MoveSelector.selectors))
-        .create()
-
-    override val typeToken = TypeToken.get(MovesetBuilder::class.java)
-    override val resourcePath = "moveset_builders"
-    override val id: ResourceLocation = cobblemonResource("moveset_builders")
-    override val type = PackType.SERVER_DATA
-    override val observable = SimpleObservable<CobblemonMovesetBuilders>()
-
-    val movesetBuilders = mutableMapOf<ResourceLocation, MovesetBuilder>()
-
-    fun getOrThrow(id: ResourceLocation): MovesetBuilder {
-        return movesetBuilders[id]
-            ?: throw IllegalArgumentException("Unknown MovesetBuilder id: $id")
-    }
-
-    override fun sync(player: ServerPlayer) { /* These don't sync. But what if they did? Nah probably shouldn't sync. */ }
-
-    override fun reload(data: Map<ResourceLocation, MovesetBuilder>) {
-        movesetBuilders.clear()
-        data.forEach { (id, value) -> value.id = id }
-        movesetBuilders.putAll(data)
-        observable.emit(this)
-    }
-}
@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common

 import com.cobblemon.mod.common.api.net.NetworkPacket
+import com.cobblemon.mod.common.client.net.CalculateSeatPositionsHandler
 import com.cobblemon.mod.common.client.net.OpenBehaviourEditorHandler
 import com.cobblemon.mod.common.client.net.PlayerInteractOptionsHandler
 import com.cobblemon.mod.common.client.net.SetClientPlayerDataHandler
@@ -33,11 +34,7 @@ import com.cobblemon.mod.common.client.net.effect.SpawnSnowstormParticleHandler
 import com.cobblemon.mod.common.client.net.gui.ExpGainedDataPacketHandler
 import com.cobblemon.mod.common.client.net.gui.InteractPokemonUIPacketHandler
 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
 import com.cobblemon.mod.common.client.net.orientation.ClientboundUpdateOrientationHandler
@@ -47,7 +44,6 @@ import com.cobblemon.mod.common.client.net.pasture.PokemonPasturedHandler
 import com.cobblemon.mod.common.client.net.pasture.PokemonUnpasturedHandler
 import com.cobblemon.mod.common.client.net.pasture.UpdatePastureConflictFlagHandler
 import com.cobblemon.mod.common.client.net.pokedex.ServerConfirmedRegisterHandler
-import com.cobblemon.mod.common.client.net.pokemon.update.ClientboundSeatAssignmentPacketHandler
 import com.cobblemon.mod.common.client.net.pokemon.update.ClientboundUpdateRidingStateHandler
 import com.cobblemon.mod.common.client.net.pokemon.update.PokemonUpdatePacketHandler
 import com.cobblemon.mod.common.client.net.riding.ClientboundUpdateDriverInputHandler
@@ -73,6 +69,7 @@ import com.cobblemon.mod.common.client.net.trade.TradeProcessStartedHandler
 import com.cobblemon.mod.common.client.net.trade.TradeStartedHandler
 import com.cobblemon.mod.common.client.net.trade.TradeUpdatedHandler
 import com.cobblemon.mod.common.net.PacketRegisterInfo
+import com.cobblemon.mod.common.net.messages.client.CalculateSeatPositionsPacket
 import com.cobblemon.mod.common.net.messages.client.OpenBehaviourEditorPacket
 import com.cobblemon.mod.common.net.messages.client.PlayerInteractOptionsPacket
 import com.cobblemon.mod.common.net.messages.client.SetClientPlayerDataPacket
@@ -93,7 +90,6 @@ import com.cobblemon.mod.common.net.messages.client.effect.RunPosableMoLangPacke
 import com.cobblemon.mod.common.net.messages.client.effect.SaccharineLogBlockParticlesPacket
 import com.cobblemon.mod.common.net.messages.client.effect.SpawnSnowstormEntityParticlePacket
 import com.cobblemon.mod.common.net.messages.client.effect.SpawnSnowstormParticlePacket
-import com.cobblemon.mod.common.net.messages.client.habitat.OpenHabitatBlockEditorPacket
 import com.cobblemon.mod.common.net.messages.client.npc.CloseNPCEditorPacket
 import com.cobblemon.mod.common.net.messages.client.npc.OpenNPCEditorPacket
 import com.cobblemon.mod.common.net.messages.client.orientation.ClientboundUpdateDriverInputPacket
@@ -107,7 +103,6 @@ import com.cobblemon.mod.common.net.messages.client.pokedex.ServerConfirmedRegis
 import com.cobblemon.mod.common.net.messages.client.pokemon.update.*
 import com.cobblemon.mod.common.net.messages.client.pokemon.update.evolution.AddEvolutionPacket
 import com.cobblemon.mod.common.net.messages.client.pokemon.update.evolution.ClearEvolutionsPacket
-import com.cobblemon.mod.common.net.messages.client.pokemon.update.evolution.ClientboundSeatAssignmentPacket
 import com.cobblemon.mod.common.net.messages.client.pokemon.update.evolution.RemoveEvolutionPacket
 import com.cobblemon.mod.common.net.messages.client.settings.OpenCobblemonConfigScreenPacket
 import com.cobblemon.mod.common.net.messages.client.settings.ServerSettingsPacket
@@ -134,7 +129,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
@@ -147,10 +141,7 @@ import com.cobblemon.mod.common.net.messages.client.trade.TradeUpdatedPacket
 import com.cobblemon.mod.common.net.messages.client.ui.ExpGainedDataPacket
 import com.cobblemon.mod.common.net.messages.client.ui.InteractPokemonUIPacket
 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
@@ -167,8 +158,6 @@ import com.cobblemon.mod.common.net.messages.server.battle.SpectateBattlePacket
 import com.cobblemon.mod.common.net.messages.server.behaviour.DamageOnCollisionPacket
 import com.cobblemon.mod.common.net.messages.server.behaviour.SetEntityBehaviourPacket
 import com.cobblemon.mod.common.net.messages.server.block.AdjustBlockEntityViewerCountPacket
-import com.cobblemon.mod.common.net.messages.server.block.TMMachineTeachMovePacket
-import com.cobblemon.mod.common.net.messages.server.breeding.TriggerEggHatchPacket
 import com.cobblemon.mod.common.net.messages.server.callback.move.MoveSelectCancelledPacket
 import com.cobblemon.mod.common.net.messages.server.callback.move.MoveSelectedPacket
 import com.cobblemon.mod.common.net.messages.server.callback.party.PartyPokemonSelectedPacket
@@ -181,8 +170,10 @@ import com.cobblemon.mod.common.net.messages.server.debug.ServerboundUpdateRidin
 import com.cobblemon.mod.common.net.messages.server.debug.ServerboundUpdateRidingStatsPacket
 import com.cobblemon.mod.common.net.messages.server.dialogue.EscapeDialoguePacket
 import com.cobblemon.mod.common.net.messages.server.dialogue.InputToDialoguePacket
-import com.cobblemon.mod.common.net.messages.server.habitat.SaveHabitatBlockSettingsPacket
+import com.cobblemon.mod.common.net.messages.server.npc.ApplyPremadeNPCPacket
+import com.cobblemon.mod.common.net.messages.server.npc.DeletePremadePacket
 import com.cobblemon.mod.common.net.messages.server.npc.SaveNPCPacket
+import com.cobblemon.mod.common.net.messages.server.npc.SavePremadeFromNPCPacket
 import com.cobblemon.mod.common.net.messages.server.orientation.ServerboundUpdateOrientationPacket
 import com.cobblemon.mod.common.net.messages.server.pasture.PasturePokemonPacket
 import com.cobblemon.mod.common.net.messages.server.pasture.SetPastureConflictPacket
@@ -199,7 +190,6 @@ import com.cobblemon.mod.common.net.messages.server.pokemon.update.SetNicknamePa
 import com.cobblemon.mod.common.net.messages.server.pokemon.update.evolution.AcceptEvolutionPacket
 import com.cobblemon.mod.common.net.messages.server.riding.DismountPokemonPacket
 import com.cobblemon.mod.common.net.messages.server.riding.ServerboundUpdateDriverInputPacket
-import com.cobblemon.mod.common.net.messages.server.riding.ServerboundUpdatePassengerPositionPacket
 import com.cobblemon.mod.common.net.messages.server.riding.ServerboundUpdateRiderRotationPacket
 import com.cobblemon.mod.common.net.messages.server.starter.RequestStarterScreenPacket
 import com.cobblemon.mod.common.net.messages.server.storage.SwapPCPartyPokemonPacket
@@ -226,8 +216,6 @@ import com.cobblemon.mod.common.net.serverhandling.battle.TeamRequestResponseHan
 import com.cobblemon.mod.common.net.serverhandling.behaviour.DamageOnCollisionPacketHandler
 import com.cobblemon.mod.common.net.serverhandling.behaviour.SetEntityBehaviourHandler
 import com.cobblemon.mod.common.net.serverhandling.block.AdjustBlockEntityViewerCountHandler
-import com.cobblemon.mod.common.net.serverhandling.block.TMMachineTeachMoveHandler
-import com.cobblemon.mod.common.net.serverhandling.breeding.TriggerEggHatchHandler
 import com.cobblemon.mod.common.net.serverhandling.callback.move.MoveSelectCancelledHandler
 import com.cobblemon.mod.common.net.serverhandling.callback.move.MoveSelectedHandler
 import com.cobblemon.mod.common.net.serverhandling.callback.party.PartyPokemonSelectedHandler
@@ -241,8 +229,10 @@ import com.cobblemon.mod.common.net.serverhandling.debug.ServerboundUpdateRiding
 import com.cobblemon.mod.common.net.serverhandling.dialogue.EscapeDialogueHandler
 import com.cobblemon.mod.common.net.serverhandling.dialogue.InputToDialogueHandler
 import com.cobblemon.mod.common.net.serverhandling.evolution.AcceptEvolutionHandler
-import com.cobblemon.mod.common.net.serverhandling.habitat.SaveHabitatBlockSettingsHandler
+import com.cobblemon.mod.common.net.serverhandling.npc.ApplyPremadeNPCHandler
+import com.cobblemon.mod.common.net.serverhandling.npc.DeletePremadeHandler
 import com.cobblemon.mod.common.net.serverhandling.npc.SaveNPCHandler
+import com.cobblemon.mod.common.net.serverhandling.npc.SavePremadeFromNPCHandler
 import com.cobblemon.mod.common.net.serverhandling.orientation.ServerboundUpdateOrientationHandler
 import com.cobblemon.mod.common.net.serverhandling.pasture.PasturePokemonHandler
 import com.cobblemon.mod.common.net.serverhandling.pasture.SetPastureConflictHandler
@@ -258,7 +248,6 @@ import com.cobblemon.mod.common.net.serverhandling.pokemon.update.SetMarkingsHan
 import com.cobblemon.mod.common.net.serverhandling.pokemon.update.SetNicknameHandler
 import com.cobblemon.mod.common.net.serverhandling.riding.DismountPokemonPacketHandler
 import com.cobblemon.mod.common.net.serverhandling.riding.DriverInputPacketHandler
-import com.cobblemon.mod.common.net.serverhandling.riding.ServerboundUpdatePassengerPositionHandler
 import com.cobblemon.mod.common.net.serverhandling.riding.ServerboundUpdateRiderRotationHandler
 import com.cobblemon.mod.common.net.serverhandling.starter.RequestStarterScreenHandler
 import com.cobblemon.mod.common.net.serverhandling.starter.SelectStarterPacketHandler
@@ -346,8 +335,6 @@ object CobblemonNetwork {
        list.add(PacketRegisterInfo(MarkingsUpdatePacket.ID, MarkingsUpdatePacket::decode, PokemonUpdatePacketHandler()))
        list.add(PacketRegisterInfo(RideBoostsUpdatePacket.ID, RideBoostsUpdatePacket::decode, PokemonUpdatePacketHandler()))
        list.add(PacketRegisterInfo(RideStaminaUpdatePacket.ID, RideStaminaUpdatePacket::decode, PokemonUpdatePacketHandler()))
-        list.add(PacketRegisterInfo(AlphaUpdatePacket.ID, AlphaUpdatePacket::decode, PokemonUpdatePacketHandler()))
-        list.add(PacketRegisterInfo(ScaleModifierUpdatePacket.ID, ScaleModifierUpdatePacket::decode, PokemonUpdatePacketHandler()))

        // Evolution start
        list.add(PacketRegisterInfo(AddEvolutionPacket.ID, AddEvolutionPacket::decode, PokemonUpdatePacketHandler()))
@@ -381,7 +368,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))
@@ -447,7 +433,7 @@ 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()))
+        list.add(PacketRegisterInfo(PremadeNPCRegistrySyncPacket.ID, PremadeNPCRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))

        // Effects
        list.add(PacketRegisterInfo(SpawnSnowstormParticlePacket.ID, SpawnSnowstormParticlePacket::decode, SpawnSnowstormParticleHandler))
@@ -510,20 +496,17 @@ object CobblemonNetwork {
        // Pokédex scanning
        list.add(PacketRegisterInfo(ServerConfirmedRegisterPacket.ID, ServerConfirmedRegisterPacket::decode, ServerConfirmedRegisterHandler))

+        // Debug / cheats
+        list.add(PacketRegisterInfo(CalculateSeatPositionsPacket.ID, CalculateSeatPositionsPacket::decode, CalculateSeatPositionsHandler))
+
        // Riding
        list.add(PacketRegisterInfo(ClientboundUpdateRidingStatePacket.ID, ClientboundUpdateRidingStatePacket::decode, ClientboundUpdateRidingStateHandler))
        list.add(PacketRegisterInfo(ClientboundUpdateDriverInputPacket.ID, ClientboundUpdateDriverInputPacket::decode, ClientboundUpdateDriverInputHandler))
-        list.add(PacketRegisterInfo(ClientboundSeatAssignmentPacket.ID, ClientboundSeatAssignmentPacket::decode, ClientboundSeatAssignmentPacketHandler))
-
-        // Habitat blocks
-        list.add(PacketRegisterInfo(OpenHabitatBlockEditorPacket.ID, OpenHabitatBlockEditorPacket::decode, OpenHabitatBlockEditorHandler))

        // Debug
        list.add(PacketRegisterInfo(OpenRidingStatsDebugGUIPacket.ID, OpenRidingStatsDebugGUIPacket::decode, OpenRidingStatsDebugGUIHandler))
        list.add(PacketRegisterInfo(UpdateTrackedBrainDataPacket.ID, UpdateTrackedBrainDataPacket::decode, UpdateTrackedBrainDataHandler))

-
-
        return list
    }

@@ -603,7 +586,6 @@ object CobblemonNetwork {

        // Block entity
        list.add(PacketRegisterInfo(AdjustBlockEntityViewerCountPacket.ID, AdjustBlockEntityViewerCountPacket::decode, AdjustBlockEntityViewerCountHandler))
-        list.add(PacketRegisterInfo(TMMachineTeachMovePacket.ID, TMMachineTeachMovePacket::decode, TMMachineTeachMoveHandler))

        // Move select packets
        list.add(PacketRegisterInfo(MoveSelectedPacket.ID, MoveSelectedPacket::decode, MoveSelectedHandler))
@@ -626,6 +608,9 @@ object CobblemonNetwork {

        // NPC packets
        list.add(PacketRegisterInfo(SaveNPCPacket.ID, SaveNPCPacket::decode, SaveNPCHandler))
+        list.add(PacketRegisterInfo(SavePremadeFromNPCPacket.ID, SavePremadeFromNPCPacket::decode, SavePremadeFromNPCHandler))
+        list.add(PacketRegisterInfo(DeletePremadePacket.ID, DeletePremadePacket::decode, DeletePremadeHandler))
+        list.add(PacketRegisterInfo(ApplyPremadeNPCPacket.ID, ApplyPremadeNPCPacket::decode, ApplyPremadeNPCHandler))

        // Riding packet(s)
        list.add(PacketRegisterInfo(ServerboundUpdateOrientationPacket.ID, ServerboundUpdateOrientationPacket::decode, ServerboundUpdateOrientationHandler))
@@ -636,29 +621,17 @@ object CobblemonNetwork {
        list.add(PacketRegisterInfo(DismountPokemonPacket.ID, DismountPokemonPacket::decode, DismountPokemonPacketHandler))
        list.add(PacketRegisterInfo(ServerboundUpdateDriverInputPacket.ID, ServerboundUpdateDriverInputPacket::decode, DriverInputPacketHandler))
        list.add(PacketRegisterInfo(ServerboundUpdateRiderRotationPacket.ID, ServerboundUpdateRiderRotationPacket::decode, ServerboundUpdateRiderRotationHandler))
-        list.add(PacketRegisterInfo(ServerboundUpdatePassengerPositionPacket.ID, ServerboundUpdatePassengerPositionPacket::decode, ServerboundUpdatePassengerPositionHandler))

        // Cooking
        list.add(PacketRegisterInfo(ToggleCookingPotLidPacket.ID, ToggleCookingPotLidPacket::decode, ToggleCookingPotLidHandler))

-        // TM Machine
-        list.add(PacketRegisterInfo(SetActiveTMPacket.ID, SetActiveTMPacket::decode, SetActiveTMPacketHandler))
-        list.add(PacketRegisterInfo(SetTMMachineContainerDataPacket.ID, SetTMMachineContainerDataPacket::decode, SetTMMachineContainerDataPacketHandler))
-
-        // Breeding Packets
-        list.add(PacketRegisterInfo(TriggerEggHatchPacket.ID, TriggerEggHatchPacket::decode, TriggerEggHatchHandler))
-
        // Behaviour Packets
        list.add(PacketRegisterInfo(SetEntityBehaviourPacket.ID, SetEntityBehaviourPacket::decode, SetEntityBehaviourHandler))
        list.add(PacketRegisterInfo(DamageOnCollisionPacket.ID, DamageOnCollisionPacket::decode, DamageOnCollisionPacketHandler))

-        // Habitat blocks
-        list.add(PacketRegisterInfo(SaveHabitatBlockSettingsPacket.ID, SaveHabitatBlockSettingsPacket::decode, SaveHabitatBlockSettingsHandler))
-
-        // Debug / cheats
+        // Debug
        list.add(PacketRegisterInfo(RequestOpenRidingStatsDebugGUIPacket.ID, RequestOpenRidingStatsDebugGUIPacket::decode, RequestOpenRidingStatsDebugGUIHandler))

-
        return list
    }

@@ -1,47 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common
-
-import com.cobblemon.mod.common.api.data.JsonDataRegistry
-import com.cobblemon.mod.common.api.npc.PartyComposition
-import com.cobblemon.mod.common.api.reactive.SimpleObservable
-import com.cobblemon.mod.common.util.adapters.IdentifierAdapter
-import com.cobblemon.mod.common.util.cobblemonResource
-import com.google.gson.Gson
-import com.google.gson.GsonBuilder
-import com.google.gson.reflect.TypeToken
-import net.minecraft.resources.ResourceLocation
-import net.minecraft.server.level.ServerPlayer
-import net.minecraft.server.packs.PackType
-
-object CobblemonPartyCompositions : JsonDataRegistry<PartyComposition> {
-    override val id: ResourceLocation = cobblemonResource("party_compositions")
-    override val type = PackType.SERVER_DATA
-    override val typeToken: TypeToken<PartyComposition> = TypeToken.get(PartyComposition::class.java)
-    override val resourcePath: String = "party_compositions"
-    override val observable = SimpleObservable<CobblemonPartyCompositions>()
-    override val gson: Gson = GsonBuilder()
-        .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
-        .setPrettyPrinting()
-        .create()
-
-    val partyCompositions = mutableMapOf<ResourceLocation, PartyComposition>()
-
-    override fun sync(player: ServerPlayer) {
-        // probably worth syncing which exist, yeah. the deeper details probably not. I'll get to this eventually.
-    }
-
-    override fun reload(data: Map<ResourceLocation, PartyComposition>) {
-        data.entries.forEach { it.value.id = it.key }
-        partyCompositions.clear()
-        partyCompositions.putAll(data)
-        observable.emit(this)
-        Cobblemon.LOGGER.info("Loaded ${data.size} party compositions.")
-    }
-}
@@ -1,60 +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
-
-import com.cobblemon.mod.common.api.data.JsonDataRegistry
-import com.cobblemon.mod.common.api.molang.ExpressionLike
-import com.cobblemon.mod.common.api.moves.MovesetBuilder
-import com.cobblemon.mod.common.api.npc.PartyPool
-import com.cobblemon.mod.common.api.pokemon.PokemonProperties
-import com.cobblemon.mod.common.api.reactive.SimpleObservable
-import com.cobblemon.mod.common.util.ScriptableIntRange
-import com.cobblemon.mod.common.util.adapters.ExpressionLikeAdapter
-import com.cobblemon.mod.common.util.adapters.IdentifierAdapter
-import com.cobblemon.mod.common.util.adapters.IntRangeAdapter
-import com.cobblemon.mod.common.util.adapters.MovesetBuilderReferenceAdapter
-import com.cobblemon.mod.common.util.adapters.PokemonPropertiesAdapter
-import com.cobblemon.mod.common.util.adapters.ScriptableIntRangeAdapter
-import com.cobblemon.mod.common.util.cobblemonResource
-import com.google.gson.Gson
-import com.google.gson.GsonBuilder
-import com.google.gson.reflect.TypeToken
-import net.minecraft.resources.ResourceLocation
-import net.minecraft.server.level.ServerPlayer
-import net.minecraft.server.packs.PackType
-
-object CobblemonPartyPools : JsonDataRegistry<PartyPool> {
-    override val id: ResourceLocation = cobblemonResource("party_pools")
-    override val type = PackType.SERVER_DATA
-    override val typeToken: TypeToken<PartyPool> = TypeToken.get(PartyPool::class.java)
-    override val resourcePath: String = "party_pools"
-    override val observable = SimpleObservable<CobblemonPartyPools>()
-    override val gson: Gson = GsonBuilder()
-        .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
-        .registerTypeAdapter(PokemonProperties::class.java, PokemonPropertiesAdapter(saveLong = false))
-        .registerTypeAdapter(IntRange::class.java, IntRangeAdapter)
-        .registerTypeAdapter(ScriptableIntRange::class.java, ScriptableIntRangeAdapter)
-        .registerTypeAdapter(MovesetBuilder::class.java, MovesetBuilderReferenceAdapter)
-        .registerTypeAdapter(ExpressionLike::class.java, ExpressionLikeAdapter)
-        .setPrettyPrinting()
-        .create()
-
-    val partyPools = mutableMapOf<ResourceLocation, PartyPool>()
-
-    override fun sync(player: ServerPlayer) {
-        // probably worth syncing. Knowing the details might help exploit the server? lot of effort for little though.
-    }
-
-    override fun reload(data: Map<ResourceLocation, PartyPool>) {
-        data.entries.forEach { it.value.id = it.key }
-        partyPools.clear()
-        partyPools.putAll(data)
-        observable.emit(this)
-    }
-}
@@ -31,10 +31,6 @@ object CobblemonPoiTypes: PlatformRegistry<Registry<PoiType>, ResourceKey<Regist
    // TODO after 1.7
 //    @JvmField
 //    val INCENSE_SWEET_KEY = createKey("incense_sweet", CobblemonBlocks.INCENSE_SWEET, 0, 1)
-    @JvmField
-    val HABITAT_BLOCK_KEY: ResourceKey<PoiType> = createKey("habitat_block", CobblemonBlocks.HABITAT_BLOCK, 0, 1)
-    @JvmField
-    val HABITAT_BLOCK = create(HABITAT_BLOCK_KEY.location().path, PoiType(getBlockStates(CobblemonBlocks.HABITAT_BLOCK), 0, 1))
    @JvmField
    val JUKEBOX_KEY = createKey("vanilla_jukebox", Blocks.JUKEBOX, 0, 1)

@@ -1,59 +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
-
-import com.bedrockk.molang.Expression
-import com.cobblemon.mod.common.api.data.JsonDataRegistry
-import com.cobblemon.mod.common.api.molang.ExpressionLike
-import com.cobblemon.mod.common.api.reactive.SimpleObservable
-import com.cobblemon.mod.common.api.types.ElementalType
-import com.cobblemon.mod.common.api.types.adapters.ElementalTypeAdapter
-import com.cobblemon.mod.common.pokemon.ai.moves.RealTimeMove
-import com.cobblemon.mod.common.pokemon.ai.moves.events.MoveEventAction
-import com.cobblemon.mod.common.util.adapters.ExpressionAdapter
-import com.cobblemon.mod.common.util.adapters.ExpressionLikeAdapter
-import com.cobblemon.mod.common.util.adapters.IdentifierAdapter
-import com.cobblemon.mod.common.util.adapters.RealTimeMoveConfigAdapter
-import com.cobblemon.mod.common.util.adapters.RealTimeMoveEventActionConfigAdapter
-import com.cobblemon.mod.common.util.cobblemonResource
-import com.google.gson.Gson
-import com.google.gson.GsonBuilder
-import com.google.gson.reflect.TypeToken
-import net.minecraft.resources.ResourceLocation
-import net.minecraft.server.level.ServerPlayer
-import net.minecraft.server.packs.PackType
-
-object CobblemonRealTimeMoves : JsonDataRegistry<RealTimeMove> {
-    override val type = PackType.SERVER_DATA
-    override val observable = SimpleObservable<CobblemonRealTimeMoves>()
-    override val typeToken = TypeToken.get(RealTimeMove::class.java)
-    override val resourcePath: String = "real_time_moves"
-    override val id: ResourceLocation = cobblemonResource(resourcePath)
-    override val gson: Gson = GsonBuilder()
-        .setPrettyPrinting()
-        .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
-        .registerTypeAdapter(ExpressionLike::class.java, ExpressionLikeAdapter)
-        .registerTypeAdapter(Expression::class.java, ExpressionAdapter)
-        .registerTypeAdapter(RealTimeMove::class.java, RealTimeMoveConfigAdapter)
-        .registerTypeAdapter(MoveEventAction::class.java, RealTimeMoveEventActionConfigAdapter)
-        .registerTypeAdapter(ElementalType::class.java, ElementalTypeAdapter)
-        .create()
-
-    val realTimeMoves = mutableMapOf<ResourceLocation, RealTimeMove>()
-
-    override fun reload(data: Map<ResourceLocation, RealTimeMove>) {
-        realTimeMoves.clear()
-        data.forEach { location, move -> move.id = location }
-        realTimeMoves.putAll(data)
-    }
-
-    override fun sync(player: ServerPlayer) {
-        // nah
-    }
-}
@@ -9,13 +9,13 @@
 package com.cobblemon.mod.common

 import com.cobblemon.mod.common.entity.pokemon.ai.sensors.*
+import com.cobblemon.mod.common.pokemon.ai.PokemonDisturbancesSensor
 import com.cobblemon.mod.common.entity.sensor.BattlingPokemonSensor
 import com.cobblemon.mod.common.entity.sensor.NPCBattlingSensor
-import com.cobblemon.mod.common.pokemon.ai.PokemonDisturbancesSensor
+import java.util.function.Supplier
 import net.minecraft.world.entity.Entity
 import net.minecraft.world.entity.ai.sensing.Sensor
 import net.minecraft.world.entity.ai.sensing.SensorType
-import java.util.function.Supplier

 object CobblemonSensors {
    val sensors = mutableMapOf<String, SensorType<*>>()
@@ -37,9 +37,6 @@ object CobblemonSensors {
    @JvmField
    val POKEMON_DEFEND_OWNER = register("pokemon_owner_under_attack", ::DefendOwnerSensor)

-    @JvmField
-    val ALPHA_LEVEL_MATCHING = register("alpha_level_matching", ::AlphaLevelMatchingSensor)
-
    @JvmField
    val NEARBY_GROWABLE_CROPS = register("nearby_growable_crops", ::PokemonGrowableCropSensor)

@@ -61,4 +58,4 @@ object CobblemonSensors {
        sensors[id] = sensor
        return sensor
    }
-}
+}
@@ -94,9 +94,6 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
    @JvmField
    val POKEDEX_SCAN_ZOOM_INCREMENT = this.create("item.pokedex.scan_zoom_increment")

-    @JvmField
-    val BREEDING_EGG_HATCH = this.create("breeding.egg_hatch")
-
    @JvmField
    val ITEM_USE = this.create("item.use")
    @JvmField
@@ -111,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
@@ -142,15 +136,6 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
    @JvmField
    val MULCH_REMOVE = this.create("block.mulch.remove")

-    @JvmField
-    val MONITOR_BREAK = this.create("block.monitor.break")
-    @JvmField
-    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")
    @JvmField
@@ -215,28 +200,6 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
    @JvmField
    val TUMBLESTONE_STEP = this.create("block.tumblestone.step")

-    @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")
-    @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")
-
-
    @JvmField
    val EVOLUTION_STONE_BLOCK_BREAK = this.create("block.evolution_stone_block.break")
    @JvmField
@@ -275,9 +238,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
@@ -352,13 +312,9 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
    )

    @JvmField
-    val RIDE_LOOP_LEATHER_MONO = create("ride.loop.leather.mono")
+    val RIDE_LOOP_LEATHER = create("ride.loop.leather")
    @JvmField
-    val RIDE_LOOP_PLUMAGE_MONO = create("ride.loop.plumage.mono")
-    @JvmField
-    val RIDE_LOOP_LEATHER_STEREO = create("ride.loop.leather.stereo")
-    @JvmField
-    val RIDE_LOOP_PLUMAGE_STEREO = create("ride.loop.plumage.stereo")
+    val RIDE_LOOP_PLUMAGE = create("ride.loop.plumage")

    @JvmField
    val MOVE_QUICKATTACK_TARGET = this.create("move.quickattack.target")
@@ -424,35 +380,6 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
        TUMBLESTONE_STEP
    )

-    @JvmField
-    val TYPE_GEM_BLOCK_BREAK = this.create("block.type_gem_block.break")
-    @JvmField
-    val TYPE_GEM_CLUSTER_BREAK = this.create("block.type_gem_cluster.break")
-    @JvmField
-    val TYPE_GEM_BLOCK_HIT = this.create("block.type_gem_block.hit")
-    @JvmField
-    val TYPE_GEM_BLOCK_PLACE = this.create("block.type_gem_block.place")
-    @JvmField
-    val TYPE_GEM_BLOCK_STEP = this.create("block.type_gem_block.step")
-
-    @JvmField
-    val TYPE_GEM_CLUSTER_SOUNDS = SoundType(1f, 1.1f,
-        TYPE_GEM_CLUSTER_BREAK,
-        TYPE_GEM_BLOCK_STEP,
-        TYPE_GEM_BLOCK_PLACE,
-        TYPE_GEM_BLOCK_HIT,
-        TYPE_GEM_BLOCK_STEP
-    )
-
-    @JvmField
-    val TYPE_GEM_BLOCK_SOUNDS = SoundType(1f, 1.1f,
-        TYPE_GEM_BLOCK_BREAK,
-        TYPE_GEM_BLOCK_STEP,
-        TYPE_GEM_BLOCK_PLACE,
-        TYPE_GEM_BLOCK_HIT,
-        TYPE_GEM_BLOCK_STEP
-    )
-
    @JvmField
    val EVOLUTION_STONE_BLOCK_SOUNDS = SoundType(1f, 1.1f,
        EVOLUTION_STONE_BLOCK_BREAK,
@@ -634,31 +561,5 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
        CAMPFIRE_POT_STEP
    )

-    @JvmField
-    val ITEM_BLOCK_PAPER_SMALL_PLACE = this.create("block.item_block.paper_small.place")
-    @JvmField
-    val ITEM_BLOCK_PAPER_SMALL_BREAK = this.create("block.item_block.paper_small.break")
-    @JvmField
-    val ITEM_BLOCK_PAPER_SMALL_SOUNDS = SoundType(1f, 1.1f,
-        ITEM_BLOCK_PAPER_SMALL_BREAK,
-        SoundEvents.WOOL_STEP,
-        ITEM_BLOCK_PAPER_SMALL_PLACE,
-        SoundEvents.WOOL_HIT,
-        SoundEvents.WOOL_FALL
-    )
-
-    @JvmField
-    val ITEM_BLOCK_PAPER_LARGE_PLACE = this.create("block.item_block.paper_large.place")
-    @JvmField
-    val ITEM_BLOCK_PAPER_LARGE_BREAK = this.create("block.item_block.paper_large.break")
-    @JvmField
-    val ITEM_BLOCK_PAPER_LARGE_SOUNDS = SoundType(1f, 1.1f,
-        ITEM_BLOCK_PAPER_LARGE_BREAK,
-        SoundEvents.WOOL_STEP,
-        ITEM_BLOCK_PAPER_LARGE_PLACE,
-        SoundEvents.WOOL_HIT,
-        SoundEvents.WOOL_FALL
-    )
-
    private fun create(name: String): SoundEvent = this.create(name, SoundEvent.createVariableRangeEvent(cobblemonResource(name)))
 }
@@ -32,9 +32,6 @@ object CobblemonCriteria : PlatformRegistry<Registry<CriterionTrigger<*>>, Resou
    @JvmField
    val CATCH_SHINY_POKEMON = this.create("catch_shiny_pokemon", SimpleCriterionTrigger(CountableCriterion.CODEC))

-    @JvmField
-    val CATCH_ALPHA_POKEMON = this.create("catch_alpha_pokemon", SimpleCriterionTrigger(CountableCriterion.CODEC))
-
    @JvmField
    val EGG_COLLECT = this.create("eggs_collected", SimpleCriterionTrigger(CountableCriterion.CODEC))

@@ -81,20 +78,8 @@ object CobblemonCriteria : PlatformRegistry<Registry<CriterionTrigger<*>>, Resou
    @JvmField
    val PLANT_TUMBLESTONE = this.create("plant_tumblestone", SimpleCriterionTrigger(PlantTumblestoneCriterion.CODEC))

-    @JvmField
-    val PLANT_TYPE_GEM = this.create("plant_type_gem", SimpleCriterionTrigger(PlantTypeGemCriterion.CODEC))
-
    val RIDING_STAT_BOOST = this.create("riding_stat_boost", SimpleCriterionTrigger(RidingStatBoostCriterion.CODEC))

-    @JvmField
-    val LEARN_TM = this.create("has_learn_specific_tm", SimpleCriterionTrigger(LearnTMCriterion.CODEC))
-
-    @JvmField
-    val LEARN_ALL_TM = this.create("has_learn_all_tm", SimpleCriterionTrigger(LearnAllTMCriterion.CODEC))
-
-    @JvmField
-    val LEARN_TM_COUNT = this.create("tms_learned", SimpleCriterionTrigger(CountableCriterion.CODEC))
-
    override val registry = BuiltInRegistries.TRIGGER_TYPES
    override val resourceKey = Registries.TRIGGER_TYPE
 }
@@ -1,50 +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.advancement.criterion
-
-import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
-import com.mojang.serialization.Codec
-import com.mojang.serialization.codecs.RecordCodecBuilder
-import net.minecraft.advancements.critereon.ContextAwarePredicate
-import net.minecraft.advancements.critereon.EntityPredicate
-import net.minecraft.resources.ResourceLocation
-import net.minecraft.server.level.ServerPlayer
-import java.util.Optional
-
-class LearnTMContext(val tm: ResourceLocation)
-
-class LearnTMCriterion(
-    playerCtx: Optional<ContextAwarePredicate>,
-    val tm: String
-) : SimpleCriterionCondition<LearnTMContext>(playerCtx) {
-    companion object {
-        val CODEC: Codec<LearnTMCriterion> = RecordCodecBuilder.create { it.group(
-            EntityPredicate.ADVANCEMENT_CODEC.optionalFieldOf("player").forGetter(LearnTMCriterion::playerCtx),
-            Codec.STRING.optionalFieldOf("tm", "any").forGetter(LearnTMCriterion::tm)
-        ).apply(it, ::LearnTMCriterion) }
-    }
-
-    override fun matches(player: ServerPlayer, context: LearnTMContext): Boolean {
-        return tm == "any" || context.tm == tm.asIdentifierDefaultingNamespace()
-    }
-}
-
-class LearnAllTMContext
-
-class LearnAllTMCriterion(
-    playerCtx: Optional<ContextAwarePredicate>
-) : SimpleCriterionCondition<LearnAllTMContext>(playerCtx) {
-    companion object {
-        val CODEC: Codec<LearnAllTMCriterion> = RecordCodecBuilder.create { it.group(
-            EntityPredicate.ADVANCEMENT_CODEC.optionalFieldOf("player").forGetter(LearnAllTMCriterion::playerCtx)
-        ).apply(it, ::LearnAllTMCriterion) }
-    }
-
-    override fun matches(player: ServerPlayer, context: LearnAllTMContext) = true
-}
@@ -14,7 +14,7 @@ import com.mojang.serialization.codecs.RecordCodecBuilder
 import net.minecraft.advancements.critereon.ContextAwarePredicate
 import net.minecraft.core.BlockPos
 import net.minecraft.server.level.ServerPlayer
-import java.util.*
+import java.util.Optional

 class PlantTumblestoneContext(val pos: BlockPos, val block: TumblestoneBlock)

@@ -29,6 +29,42 @@ class PlantTumblestoneCriterion(
    }

    override fun matches(player: ServerPlayer, context: PlantTumblestoneContext): Boolean {
-        return context.block.canGrow(player.level().getBlockState(context.pos), context.pos, player.level())
+        return context.block.canGrow(context.pos, player.level())
    }
-}
+}
+
+///**
+// * A criterion condition for when a tumblestone block is planted
+// * @param id The identifier of the criterion
+// * @param predicate The predicate for the criterion
+// *
+// * @author Aethen
+// * @since 02/28/2024
+// */
+//class PlantTumblestoneCriterionCondition(id: Identifier, predicate: LootContextPredicate) :
+//    SimpleCriterionCondition<PlantTumblestoneContext>(id, predicate) {
+//    override fun toJson(json: JsonObject) {
+//        // Add properties to json if needed. None needed for this criterion
+//    }
+//
+//    override fun fromJson(json: JsonObject) {
+//        // Parse properties from json if needed. None needed for this criterion
+//    }
+//
+//    /**
+//     * Checks if the tumblestone block can grow at the given position
+//     * @param player The player that planted the tumblestone block
+//     * @param context The context of the criterion
+//     * @return True if the tumblestone block can grow at the given position, false otherwise
+//     */
+//    override fun matches(player: ServerPlayer, context: PlantTumblestoneContext): Boolean {
+//        return context.tumbleStoneBlock.canGrow(context.pos, player.level())
+//    }
+//}
+//
+///**
+// * The context of the [PlantTumblestoneCriterionCondition]
+// * @param pos The position of the tumblestone block
+// * @param tumbleStoneBlock The tumblestone block
+// */
+//open class PlantTumblestoneContext(var pos: BlockPos, var tumbleStoneBlock: TumblestoneBlock)
@@ -1,35 +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.advancement.criterion
-
-import com.cobblemon.mod.common.block.TypeGemClusterBlock
-import com.cobblemon.mod.common.block.TypeGemCoreBlock
-import com.mojang.serialization.Codec
-import com.mojang.serialization.codecs.RecordCodecBuilder
-import net.minecraft.advancements.critereon.ContextAwarePredicate
-import net.minecraft.core.BlockPos
-import net.minecraft.server.level.ServerPlayer
-import java.util.*
-
-class PlantTypeGemContext(val pos: BlockPos, val block: TypeGemClusterBlock)
-
-class PlantTypeGemCriterion(
-    playerCtx: Optional<ContextAwarePredicate>
-): SimpleCriterionCondition<PlantTypeGemContext>(playerCtx) {
-
-    companion object {
-        val CODEC: Codec<PlantTypeGemCriterion> = RecordCodecBuilder.create { it.group(
-            ContextAwarePredicate.CODEC.optionalFieldOf("player").forGetter(PlantTypeGemCriterion::playerCtx)
-        ).apply(it, ::PlantTypeGemCriterion) }
-    }
-
-    override fun matches(player: ServerPlayer, context: PlantTypeGemContext): Boolean {
-        return player.level().getBlockState(context.pos).block is TypeGemCoreBlock
-    }
-}
@@ -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") {
@@ -19,7 +19,6 @@ package com.cobblemon.mod.common.api
 open class PrioritizedList<T> : Iterable<T> {
    protected val priorityMap = mutableMapOf<Priority, MutableList<T>>()
    // Please don't change arraylist, we need insertion order
-    // MutableList doesn't necessarily preserve insertion order apparently
    protected val ordered = arrayListOf<T>()

    val mapping: Map<Priority, List<T>>
@@ -27,8 +26,8 @@ open class PrioritizedList<T> : Iterable<T> {

    private fun reorder() {
        ordered.clear()
-        Priority.entries.forEach {
-            priorityMap[it]?.let(ordered::addAll)
+        Priority.values().forEach {
+            priorityMap[it]?.let { ordered.addAll(it) }
        }
    }

@@ -11,51 +11,28 @@ package com.cobblemon.mod.common.api.abilities
 import com.cobblemon.mod.common.Cobblemon.LOGGER
 import com.cobblemon.mod.common.api.PrioritizedList
 import com.cobblemon.mod.common.api.Priority
-import com.cobblemon.mod.common.api.molang.MoLangFunctions.addAbilityPoolFunctions
-import com.cobblemon.mod.common.api.molang.ObjectValue
-import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.pokemon.Species

 /**
 * A pool of potential abilities, as a [PrioritizedList]. The added logic of this subclass
 * is that it has selection logic. Given a species and a set of aspects, it will go through
- * each priority group, and if it can then it will pick from that group and return it. It also
- * returns the index of that ability within the type band it is.
+ * each priority group, and if it can then it will pick from that group and return it.
 *
 * @author Hiroku
 * @since July 28th, 2022
 */
 open class AbilityPool : PrioritizedList<PotentialAbility>() {
-    val struct = ObjectValue(this)
-        .also { it.addAbilityPoolFunctions(this) }
-
-    fun getInheritedAbility(parent: Pokemon): Ability? {
-        if (parent.ability.forced) {
-            return null
-        }
-
-        val parentAbilityType = parent.form.abilities.find { it.template == parent.ability.template }?.type ?: return null // Should be impossible
-        val matchingTypes = ordered.filter { it.type == parentAbilityType }
-        val desiredIndex = parent.ability.index
-        val matchingPotentialAbility = matchingTypes.getOrNull(desiredIndex) ?: return null
-        return matchingPotentialAbility.template.create().also { it.index = desiredIndex }
-    }
-
-    fun select(species: Species, aspects: Set<String>): Ability {
-        val typeMap = ordered.groupBy { it.type }
+    fun select(species: Species, aspects: Set<String>): Pair<Ability, Priority> {
        for (priority in Priority.entries) {
            val potentialAbilities = priorityMap[priority]?.filter { it.isSatisfiedBy(aspects) } ?: continue
            if (potentialAbilities.isNotEmpty()) {
-                val selected = potentialAbilities.random()
-                val ability = selected.template.create(priority = selected.priority)
-                ability.index = typeMap[selected.type]!!.indexOf(selected)
-                return ability
+                return potentialAbilities.random().template.create() to priority
            }
        }

        LOGGER.error("Unable to select an ability from the pool for $species and aspects: ${aspects.joinToString()}")
        LOGGER.error("Please show this to the Cobblemon developers!")
        Exception().printStackTrace()
-        return Abilities.first().create()
+        return Abilities.first().create() to Priority.LOWEST
    }
 }
@@ -0,0 +1,25 @@
+package com.cobblemon.mod.common.api.ai
+
+/**
+ * A classification of what a behaviour is related to, used for organisational purposes. It doesn't have any technical
+ * implications beyond how they are displayed to players modifying an entity's Behaviours.
+ *
+ * @author Hiroku
+ * @since April 25th, 2026
+ */
+enum class BehaviourCategory {
+    /** Relates to movement, reactions, general entity behaviour. */
+    AI,
+    /** Relates to how the entity appears. */
+    APPEARANCE,
+    /** Relates to the entity's interactions with players or other entities. */
+    INTERACTION,
+    /** Relates to the entity's role in gameplay. */
+    ROLE,
+    /** Relates to the entity's ability to do Pokémon battles. */
+    BATTLE,
+    /** Relates to invisible, technical configuration. */
+    TECHNICAL,
+    /** Doesn't fit other categories. */
+    OTHER,
+}
@@ -12,7 +12,6 @@ import com.bedrockk.molang.runtime.MoLangRuntime
 import com.bedrockk.molang.runtime.struct.QueryStruct
 import com.bedrockk.molang.runtime.value.DoubleValue
 import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.CobblemonMemories
 import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
 import com.cobblemon.mod.common.api.ai.biggerbrain.objective.Objective
 import com.cobblemon.mod.common.api.ai.biggerbrain.sense.Sense
@@ -54,10 +53,6 @@ class BehaviourConfigurationContext {

    val onAdd = mutableListOf<ExpressionLike>()

-    init {
-        memories.add(CobblemonMemories.NEST_DESPAWN_IMMUNE_UNTIL_TICK)
-    }
-
    fun getOrCreateActivity(activity: Activity): ActivityConfigurationContext {
        return activities.firstOrNull { it.activity == activity } ?: ActivityConfigurationContext(activity).also(activities::add)
    }
@@ -177,4 +172,4 @@ class BehaviourConfigurationContext {
            }
        return struct
    }
-}
+}
@@ -42,8 +42,7 @@ class CobblemonAttackTargetData(
    /** An expression that returns false when the target is no longer worth attacking. */
    var shouldContinue: Expression = "true".asExpression(),
    var hitsUntilDisengage: Int = -1, // -1 means no limit
-    var disengageAction: (entity: Entity) -> Unit = {},
-    var hitsLanded : Int = 0
+    var disengageAction: (entity: Entity) -> Unit = {}
 ) {
    val struct = ObjectValue<CobblemonAttackTargetData>(this).also {
        it.addFunction("hits_until_disengage") { DoubleValue(hitsUntilDisengage.toDouble()) }
@@ -13,8 +13,8 @@ import com.cobblemon.mod.common.api.ai.config.BehaviourConfig
 import com.cobblemon.mod.common.api.molang.ExpressionLike
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.setup
-import com.cobblemon.mod.common.api.scripting.CobblemonScripts
 import com.cobblemon.mod.common.util.asTranslated
+import com.cobblemon.mod.common.util.cobblemonResource
 import com.cobblemon.mod.common.util.resolve
 import com.cobblemon.mod.common.util.withQueryValue
 import com.google.gson.annotations.SerializedName
@@ -23,14 +23,15 @@ import net.minecraft.resources.ResourceLocation
 import net.minecraft.world.entity.LivingEntity

 class CobblemonBehaviour(
+    @Transient
+    var id: ResourceLocation = cobblemonResource("a"),
    val name: Component = "".asTranslated(),
+    val category: BehaviourCategory = BehaviourCategory.OTHER,
    val description: Component = "".asTranslated(),
    /** Some behaviours aren't really worth showing on the client, namely ones that are simply conditional bundles of other behaviours. */
    val visible: Boolean = true,
    val entityType: ResourceLocation? = null,
    val configurations: List<BehaviourConfig> = mutableListOf(),
-    // I feel like the onAdd+onAddScript etc could be merged using some interface and a clever deserializer,
-    // detect if it's a ResourceLocation and failing that, Expression. The on[..]Script fields are kinda fringe though.
    @SerializedName("onRemove", alternate = ["undo"])
    val onRemove: ExpressionLike? = null,
    val onAdd: ExpressionLike? = null,
@@ -11,8 +11,6 @@ package com.cobblemon.mod.common.api.ai.biggerbrain
 import com.bedrockk.molang.runtime.MoLangRuntime
 import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.CobblemonNetwork.sendPacket
-import com.cobblemon.mod.common.api.PrioritizedList
-import com.cobblemon.mod.common.api.Priority
 import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.Distraction
 import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.EntityFixation
 import com.cobblemon.mod.common.api.ai.biggerbrain.objective.Objective
@@ -25,10 +23,11 @@ import com.cobblemon.mod.common.net.messages.client.debug.UpdateTrackedBrainData
 import com.cobblemon.mod.common.util.getMemorySafely
 import com.cobblemon.mod.common.util.getPlayer
 import com.cobblemon.mod.common.util.withQueryValue
+import java.util.UUID
+import kotlin.collections.mutableListOf
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.ai.memory.MemoryModuleType
 import net.minecraft.world.entity.ai.memory.MemoryStatus
-import java.util.UUID

 /**
 * A better* version of Minecraft's [net.minecraft.world.entity.ai.Brain] system that makes development more
@@ -66,22 +65,7 @@ class BiggerBrain(val entity: LivingEntity) {

    val senses = mutableListOf<Sense>()
    val objectives = mutableListOf<Objective>()
-    val subscriptions = mutableMapOf<MemoryModuleType<*>, PrioritizedList<MemorySubscription<*>>>()
-
-    class MemorySubscription<U>(
-        val subscription: (U?, labels: MutableSet<String>) -> Boolean
-    ) {
-        fun handle(value: Any?, labels: MutableSet<String>): Boolean {
-            val castValue = value as? U
-            return subscription(castValue, labels)
-        }
-    }
-
-    fun <U, M : MemoryModuleType<U>> subscribe(priority: Priority = Priority.NORMAL, memory: M, handler: (U?, labels: MutableSet<String>) -> Boolean) {
-        subscriptions
-            .getOrPut(memory, ::PrioritizedList)
-            .add(priority, MemorySubscription(handler))
-    }
+    val observedMemories = mutableMapOf<MemoryModuleType<*>, MutableList<Objective>>()

    var fixation: EntityFixation? = null

@@ -89,7 +73,10 @@ class BiggerBrain(val entity: LivingEntity) {

    fun registerObjective(objective: Objective) {
        objectives.add(objective)
-        objective.onRegister(entity, this)
+        for (memory in objective.observedMemories) {
+            val list = this.observedMemories.getOrPut(memory, ::ArrayList)
+            list.add(objective)
+        }
    }

    fun isFixation(fixation: EntityFixation?): Boolean {
@@ -161,8 +148,9 @@ class BiggerBrain(val entity: LivingEntity) {
        } else {
            entity.brain.setMemory(memory, value)
        }
-        val labels = mutableSetOf<String>()
-        subscriptions[memory]?.forEach { it.handle(value = value, labels = labels) }
+        observedMemories[memory]?.forEach { objective ->
+            objective.onMemoryChanged(entity, this, memory, value)
+        }
    }

    fun <T> setMemoryIfChanged(memory: MemoryModuleType<T>, value: T, expiry: Long? = null) {
@@ -173,8 +161,9 @@ class BiggerBrain(val entity: LivingEntity) {

    fun <T> eraseMemory(memory: MemoryModuleType<T>) {
        entity.brain.eraseMemory(memory)
-        val labels = mutableSetOf<String>()
-        subscriptions[memory]?.forEach { it.handle(value = null, labels = labels) }
+        observedMemories[memory]?.forEach { objective ->
+            objective.onMemoryChanged(entity, this, memory, null)
+        }
    }

    fun <T> eraseMemoryIfPresent(memory: MemoryModuleType<T>) {
@@ -1,161 +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.ai.biggerbrain.fixation
-
-import com.bedrockk.molang.Expression
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.biggerbrain.LookingTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.MovementStatus
-import com.cobblemon.mod.common.api.ai.biggerbrain.MovementTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.RegularMovementTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.Distraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.DistractionType
-import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.pokemon.ai.moves.RealTimeMove
-import com.cobblemon.mod.common.pokemon.ai.moves.RealTimeMoveInstance
-import com.cobblemon.mod.common.util.asExpression
-import com.cobblemon.mod.common.util.mainThreadRuntime
-import com.cobblemon.mod.common.util.resolveFloat
-import com.cobblemon.mod.common.util.withQueryValue
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.ai.behavior.EntityTracker
-import net.minecraft.world.entity.ai.memory.MemoryModuleType
-import net.minecraft.world.entity.ai.memory.WalkTarget
-import net.minecraft.world.entity.player.Player
-import kotlin.collections.set
-
-class AttackFixation(
-    val targetEntity: LivingEntity,
-    /** Distraction types that will be respected. */
-    private val speedMultiplier: Expression = "1.0".asExpression(),
-    private val availableMoves: List<RealTimeMove> = emptyList(),
-    val distractionTypes: Set<DistractionType>,
-) : EntityFixation {
-
-    private val globalAttackCooldownTicks: Int = 20 // TODO: pull from pokemon stats
-    var movementTracker: MovementTracker? = null
-    var lookingTracker: LookingTracker? = null
-    var activeMoveInstance: RealTimeMoveInstance? = null
-    override fun getDescription(entity: LivingEntity): String {
-        return "Attacking Target"
-    }
-
-    override fun canDistract(distraction: Distraction, entity: LivingEntity): Boolean {
-        return distraction.types.any(distractionTypes::contains)
-    }
-
-    override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
-        if (entity !is PokemonEntity || !entity.isAlive) return false
-        entity as PokemonEntity // Intellij and my brain says this is redundant but I'm not getting smart casting later on sooo
-        val targetedEntity = brain.getMemory(MemoryModuleType.ATTACK_TARGET)
-            ?: return false
-
-        if (targetedEntity.isRemoved || targetedEntity.isDeadOrDying || brain.getMemory(MemoryModuleType.AVOID_TARGET) != null) {
-            brain.eraseMemory(MemoryModuleType.ATTACK_TARGET)
-            brain.eraseMemory(MemoryModuleType.ANGRY_AT)
-            return false
-        }
-
-        if (targetedEntity is Player && (targetedEntity.isCreative || targetedEntity.isSpectator)) {
-            brain.eraseMemory(MemoryModuleType.ATTACK_TARGET)
-            brain.eraseMemory(MemoryModuleType.ANGRY_AT)
-            return false
-        }
-
-        // If we have a current target, check if it's still valid and within roam range (if tethered)
-        if (targetedEntity.isAlive) {
-            val tethering = (entity).tethering
-            if (tethering != null && !tethering.canRoamTo(targetedEntity.blockPosition())) {
-                // Target moved out of range let's kill the memory >:)
-                brain.distract(Distraction.FORCE)
-                entity.brain.eraseMemory(MemoryModuleType.ATTACK_TARGET)
-                return false
-            }
-        }
-
-        if (activeMoveInstance != null && activeMoveInstance!!.completed) {
-            activeMoveInstance = null
-        }
-
-        var runtime = mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
-        runtime = runtime.withQueryValue("target", targetedEntity.asMostSpecificMoLangValue())
-        val speed = runtime.resolveFloat(speedMultiplier)
-
-        var selectedMoveIndex = -1
-        var distanceToTarget = -1.0f
-
-        if (!(entity.biggerBrain.getMemory(MemoryModuleType.ATTACK_COOLING_DOWN) ?: false)) {
-            // Not blocked by global cooldown, check if any available moves can be performed
-            var highestPriority = Int.MAX_VALUE
-            distanceToTarget = entity.distanceTo(targetedEntity)
-            availableMoves.forEachIndexed { index, move ->
-                // check for cooldown ticks, priority, and range
-                // TODO: Account for hitbox sizes when doing range checks
-                if (move.id !in entity.pokemon.realTimeMoveCooldowns && move.priority < highestPriority
-                    && (distanceToTarget <= move.maxRange || entity.isWithinMeleeAttackRange(targetedEntity))
-                    && (distanceToTarget >= move.minRange)
-                ) {
-                    selectedMoveIndex = index
-                    highestPriority = move.priority
-                }
-            }
-            if (selectedMoveIndex != -1) {
-                val selectedMove = availableMoves[selectedMoveIndex]
-                activeMoveInstance = selectedMove.createInstance(entity, targetedEntity)
-                activeMoveInstance?.start()
-                // Reset cooldowns
-                entity.pokemon.realTimeMoveCooldowns[selectedMove.id] = selectedMove.cooldownTicks
-                brain.setMemory(MemoryModuleType.ATTACK_COOLING_DOWN, true, globalAttackCooldownTicks.toLong())
-            }
-
-          }
-
-        if (lookingTracker != null) {
-            lookingTracker!!.tick()
-        }
-
-        if (movementTracker != null) {
-            val movementStatus = movementTracker!!.tick()
-            if (movementStatus != MovementStatus.PENDING) {
-                movementTracker!!.stop()
-                movementTracker = null
-            }
-        } else {
-            // Not moving right now and we need to figure out to what distance to the enemy we want to move to
-            var idealDistanceToTarget = Float.MAX_VALUE
-            var highestPriority = Int.MAX_VALUE
-            availableMoves.forEachIndexed { index, move ->
-                // We want the highest priority move that's not on cooldown
-                if (move.id !in entity.pokemon.realTimeMoveCooldowns && move.priority < highestPriority) {
-                    highestPriority = move.priority
-                    idealDistanceToTarget = move.maxRange
-                }
-            }
-
-            // Get distance to target if we didn't initialize it in the earlier block
-            if (distanceToTarget < 0) {
-                distanceToTarget = entity.distanceTo(targetedEntity)
-            }
-            if (idealDistanceToTarget < distanceToTarget) {
-                val walkTarget = WalkTarget(EntityTracker(targetedEntity, true), speed, idealDistanceToTarget.toInt())
-                movementTracker = RegularMovementTracker.attempt(entity, walkTarget)
-                lookingTracker = LookingTracker.forTargetEntity(entity, targetedEntity, trackEyeHeight = true)
-            } else if (lookingTracker == null) {
-                // Fixate at looking at the target so we don't wander off
-                lookingTracker = LookingTracker.forTargetEntity(entity, targetedEntity, trackEyeHeight = true)
-
-            }
-        }
-        return true
-    }
-
-
-
-}
@@ -1,43 +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.ai.biggerbrain.fixation
-
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.biggerbrain.LookingTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.Distraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.DistractionType
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.PathfinderMob
-
-class LookAndLockFixation(
-    override val lookingTracker: LookingTracker?,
-    /** Distraction types that will be respected. */
-    val distractionTypes: Set<DistractionType>,
-    val condition: () -> Boolean
-) : EntityFixation, LookingTrackerFixation {
-
-
-    override fun getDescription(entity: LivingEntity): String {
-        return "Looking at a nearby entity (Locked)"
-    }
-
-    override fun canDistract(distraction: Distraction, entity: LivingEntity): Boolean {
-        return distraction.types.any(distractionTypes::contains)
-    }
-
-    override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
-        val targetEntity = lookingTracker?.entity ?: return false
-        if ((targetEntity.isRemoved) || entity !is PathfinderMob) {
-            return false
-        }
-        val lookingTracker = lookingTracker
-        lookingTracker.tick()
-        return condition()
-    }
-}
@@ -1,168 +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.ai.biggerbrain.objective
-
-import com.bedrockk.molang.Expression
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.Priority
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asSimplifiedExpression
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.Distraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.DistractionType
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.AttackFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.EntityFixation
-import com.cobblemon.mod.common.api.ai.config.objective.ObjectiveConfig
-import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
-import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.asExpression
-import com.cobblemon.mod.common.util.mainThreadRuntime
-import com.cobblemon.mod.common.util.resolveInt
-import com.cobblemon.mod.common.util.resolveString
-import com.cobblemon.mod.common.util.withQueryValue
-import com.mojang.datafixers.util.Either
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.ai.memory.MemoryModuleType
-
-class AggressiveBehaviour(
-    speedMultiplier: Expression = "0.5".asExpression(), // How do we transfer speed to the attack behaviour? Do we want to?
-    engageRange: Expression = "15.0".asExpression(),
-    disengageRange: Expression = "20.0".asExpression(),
-    condition: Expression = "true".asExpression(), // Self/environment condition check
-    targetCondition: Expression = "true".asExpression(), // target condition (will be checked on entity interaction)
-    description: Expression = "'Aggressive Behaviour'".asExpression(),
-    val maxAttackDuration: Expression = "300".asExpression(),
-) : EntityResponseObjective(
-    speedMultiplier = speedMultiplier, // How do we transfer speed to the attack behaviour? Do we want to?
-    engageRange = engageRange,
-    disengageRange = disengageRange,
-    condition = condition, // Self/environment condition check
-    targetCondition = targetCondition, // target condition (will be checked on entity interaction)
-    description = description,
-) {
-
-    private var remainingCooldownTicks = 0
-    private var attackFixation : EntityFixation? = null
-    override val observedMemories = listOf(MemoryModuleType.HURT_BY_ENTITY, CobblemonMemories.ATTACK_TARGET_DATA)
-
-
-    override fun perform(
-        entity: LivingEntity,
-        brain: BiggerBrain,
-        activeObjectiveTags: MutableSet<String>
-    ): ObjectiveStatus {
-        if (entity !is PokemonEntity || !entity.isAlive) return ObjectiveStatus.INVALID
-        if (brain.getMemory(MemoryModuleType.AVOID_TARGET) != null) {
-            return ObjectiveStatus.BLOCKED
-        }
-        val attackTarget = brain.getMemory(MemoryModuleType.ATTACK_TARGET)
-        if (trackedEntity != null) {
-            // has active target
-            if (attackTarget != null && trackedEntity?.uuid == attackTarget.uuid) {
-                // Check if we continue
-                if (shouldContinue(entity, brain)) {
-                    return ObjectiveStatus.ACTIVE
-                } else {
-                    brain.distract(Distraction.FORCE)
-                    attackFixation = null
-                    brain.eraseMemory(MemoryModuleType.ATTACK_TARGET)
-                    brain.eraseMemory(CobblemonMemories.ATTACK_TARGET_DATA)
-                    return ObjectiveStatus.INACTIVE
-                }
-            } else {
-                // Something has overridden us and independently set the attack target
-                trackedEntity = null
-                attackFixation = null
-                return ObjectiveStatus.BLOCKED
-            }
-        } else {
-            // No active target
-            if (remainingCooldownTicks > 0) {
-                remainingCooldownTicks--
-                return ObjectiveStatus.INACTIVE
-            } else {
-                remainingCooldownTicks = 20
-            }
-            val targetEntity = scanForValidTargets(entity, brain)
-            if (targetEntity != null && brain.distract(Distraction.FORCE)) {
-                val runtime = mainThreadRuntime
-                val attackDuration = runtime.resolveInt(maxAttackDuration)
-                trackedEntity = targetEntity
-                brain.setMemory(MemoryModuleType.ATTACK_TARGET, targetEntity, attackDuration.toLong())
-                attackFixation = brain.fixate(
-                    AttackFixation(
-                        targetEntity = trackedEntity!!,
-                        speedMultiplier = speedMultiplier,
-                        distractionTypes =  setOf(DistractionType.FORCE),
-                        availableMoves = getRealTimeMoves(entity)
-                    )
-                )
-            }
-        }
-        return if (trackedEntity != null) ObjectiveStatus.ACTIVE else ObjectiveStatus.INACTIVE
-    }
-
-    override fun onRegister(entity: LivingEntity, brain: BiggerBrain) {
-        brain.subscribe(
-            priority = Priority.LOW,
-            memory = CobblemonMemories.ATTACK_TARGET_DATA
-        ) { attackData, labels ->
-            val targetEntity = brain.getMemory(MemoryModuleType.ATTACK_TARGET) ?: return@subscribe true
-            if (trackedEntity?.uuid == targetEntity.uuid) {
-                // We smacked them, refresh our attack timer
-                val runtime = mainThreadRuntime.withQueryValue("entity", (targetEntity).asMostSpecificMoLangValue())
-                val attackDuration = runtime.resolveInt(maxAttackDuration)
-                brain.setMemory(MemoryModuleType.ATTACK_TARGET, targetEntity, attackDuration.toLong())
-            }
-            return@subscribe true
-        }
-    }
-
-    class Config : ObjectiveConfig {
-        val speedMultiplier: ExpressionOrEntityVariable = Either.left("0.5".asExpression())
-        val engageRange: ExpressionOrEntityVariable = Either.left("15.0".asExpression())
-        val disengageRange: ExpressionOrEntityVariable = Either.left("20.0".asExpression())
-        val condition: ExpressionOrEntityVariable = Either.left("true".asExpression())
-        val targetCondition: ExpressionOrEntityVariable = Either.left("false".asExpression())
-        val maxAttackDuration: ExpressionOrEntityVariable = Either.left("300".asExpression())
-        val description: ExpressionOrEntityVariable = Either.left("'Aggressive Behaviour'".asExpression())
-        override fun getVariables(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ): List<MoLangConfigVariable> {
-            return listOf(
-                condition,
-                targetCondition,
-                speedMultiplier,
-                engageRange,
-                disengageRange,
-                maxAttackDuration,
-                description
-            ).asVariables()
-        }
-
-        override fun create(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ): Objective {
-            return AggressiveBehaviour(
-                condition = condition.asSimplifiedExpression(entity),
-                targetCondition = targetCondition.asSimplifiedExpression(entity),
-                speedMultiplier = speedMultiplier.asSimplifiedExpression(entity),
-                engageRange = engageRange.asSimplifiedExpression(entity),
-                disengageRange = disengageRange.asSimplifiedExpression(entity),
-                maxAttackDuration = maxAttackDuration.asSimplifiedExpression(entity),
-                description = description.asSimplifiedExpression(entity)
-            )
-        }
-    }
-}
@@ -1,170 +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.ai.biggerbrain.objective
-
-import com.bedrockk.molang.Expression
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.Priority
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.CobblemonAttackTargetData
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asSimplifiedExpression
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.biggerbrain.LookingTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.RegularMovementTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.Distraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.DistractionType
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.EntityFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.LookAndMoveFixation
-import com.cobblemon.mod.common.api.ai.config.objective.ObjectiveConfig
-import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
-import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.asExpression
-import com.cobblemon.mod.common.util.mainThreadRuntime
-import com.cobblemon.mod.common.util.resolveFloat
-import com.cobblemon.mod.common.util.resolveInt
-import com.cobblemon.mod.common.util.withQueryValue
-import com.mojang.datafixers.util.Either
-import net.minecraft.world.InteractionHand
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.ai.behavior.EntityTracker
-import net.minecraft.world.entity.ai.memory.MemoryModuleType
-import net.minecraft.world.entity.ai.memory.WalkTarget
-import net.minecraft.world.entity.player.Player
-
-class AttackTargetMelee(
-    private val speedMultiplier: Expression = "1.0".asExpression(),
-    private val attackRange: Expression = "2.0".asExpression(),
-    private val attackCooldownTicks: Int = 20
-) : Objective {
-    private var movementTask: EntityFixation? = null
-    private var remainingCooldownTicks = 0
-
-    override val observedMemories = listOf(MemoryModuleType.ATTACK_TARGET)
-
-    override fun getDescription(entity: LivingEntity) = "Attack target melee"
-
-    override fun perform(
-        entity: LivingEntity,
-        brain: BiggerBrain,
-        activeObjectiveTags: MutableSet<String>
-    ): ObjectiveStatus {
-        if (entity !is PokemonEntity || !entity.isAlive) return ObjectiveStatus.INVALID
-
-        val target = brain.getMemory(MemoryModuleType.ATTACK_TARGET)
-            ?: return ObjectiveStatus.INACTIVE
-
-        if (target.isRemoved || target.isDeadOrDying) {
-            brain.eraseMemory(MemoryModuleType.ATTACK_TARGET)
-            brain.eraseMemory(MemoryModuleType.ANGRY_AT)
-            return ObjectiveStatus.INACTIVE
-        }
-
-        if (target is Player && (target.isCreative || target.isSpectator)) {
-            brain.eraseMemory(MemoryModuleType.ATTACK_TARGET)
-            brain.eraseMemory(MemoryModuleType.ANGRY_AT)
-            return ObjectiveStatus.INACTIVE
-        }
-
-        if (remainingCooldownTicks > 0) {
-            remainingCooldownTicks--
-        }
-
-        val runtime = mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
-        val range = runtime.resolveFloat(attackRange)
-        val speed = runtime.resolveFloat(speedMultiplier)
-
-        // This is melee thing, but not everything will do melee in the future
-        if (entity.distanceToSqr(target) <= range * range && entity.hasLineOfSight(target)) {
-            if (remainingCooldownTicks <= 0) {
-                if (entity.doHurtTarget(target)) {
-                    entity.swing(InteractionHand.MAIN_HAND)
-                    var attackTargetData = brain.getMemory(CobblemonMemories.ATTACK_TARGET_DATA)
-                    if (attackTargetData != null) {
-                        attackTargetData.hitsLanded += 1
-
-                    } else {
-                        attackTargetData = CobblemonAttackTargetData()
-                        attackTargetData.hitsLanded = 1
-                    }
-                    brain.setMemory(CobblemonMemories.ATTACK_TARGET_DATA, attackTargetData)
-                }
-                remainingCooldownTicks = attackCooldownTicks
-            }
-            return ObjectiveStatus.ACTIVE
-        }
-
-        // If we have a current target, check if it's still valid and within roam range (if tethered)
-        if (target.isAlive) {
-            val tethering = (entity).tethering
-            if (tethering != null && !tethering.canRoamTo(target.blockPosition())) {
-                // Target moved out of range let's kill the memory >:)
-                brain.distract(Distraction.FORCE)
-                entity.brain.eraseMemory(MemoryModuleType.ATTACK_TARGET)
-            }
-        }
-
-        if (brain.isFixation(movementTask)) {
-            return ObjectiveStatus.FIXATED
-        }
-
-        if (!brain.distract(Distraction.FORCE)) return ObjectiveStatus.BLOCKED
-        val walkTarget = WalkTarget(EntityTracker(target, true), speed, 1)
-        val movementTracker = RegularMovementTracker.attempt(entity, walkTarget) ?: return ObjectiveStatus.ACTIVE
-        movementTask = brain.fixate(LookAndMoveFixation(
-            distractionTypes = setOf(DistractionType.FORCE),
-            lookingTracker = LookingTracker.forTargetEntity(entity, target, trackEyeHeight = true),
-            movementTracker = movementTracker,
-            description = "Moving to attack target"))
-        return ObjectiveStatus.FIXATED
-    }
-
-    override fun onRegister(entity: LivingEntity, brain: BiggerBrain) {
-        brain.subscribe(
-            priority = Priority.LOW,
-            memory = MemoryModuleType.ATTACK_TARGET
-        ) { value, labels ->
-            if (value == null) {
-                if (brain.isFixation(movementTask)) {
-                    brain.distract(Distraction.FORCE)
-                    movementTask = null
-                }
-            }
-            return@subscribe true
-        }
-    }
-
-    class Config : ObjectiveConfig {
-        val speedMultiplier: ExpressionOrEntityVariable = Either.left("1.0".asExpression())
-        val attackRange: ExpressionOrEntityVariable = Either.left("2.0".asExpression())
-        val attackCooldownTicks: ExpressionOrEntityVariable = Either.left("20".asExpression())
-
-        override fun getVariables(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ): List<MoLangConfigVariable> {
-            return listOf(speedMultiplier, attackRange, attackCooldownTicks).asVariables()
-        }
-
-        override fun create(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ): Objective {
-            return AttackTargetMelee(
-                speedMultiplier = speedMultiplier.asSimplifiedExpression(entity),
-                attackRange = attackRange.asSimplifiedExpression(entity),
-                attackCooldownTicks = behaviourConfigurationContext.runtime.resolveInt(
-                    attackCooldownTicks.asSimplifiedExpression(entity)
-                )
-            )
-        }
-    }
-}
@@ -1,173 +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.ai.biggerbrain.objective
-
-import com.bedrockk.molang.Expression
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.Priority
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asSimplifiedExpression
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.biggerbrain.LookingTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.RegularMovementTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.Distraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.DistractionType
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.ConditionalLockFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.EntityFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.LookAndMoveFixation
-import com.cobblemon.mod.common.api.ai.config.objective.ObjectiveConfig
-import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
-import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
-import com.cobblemon.mod.common.api.tags.CobblemonBlockTags
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.asExpression
-import com.cobblemon.mod.common.util.mainThreadRuntime
-import com.cobblemon.mod.common.util.resolveFloat
-import com.cobblemon.mod.common.util.sendParticlesServer
-import com.cobblemon.mod.common.util.toVec3d
-import com.cobblemon.mod.common.util.withQueryValue
-import com.mojang.datafixers.util.Either
-import net.minecraft.core.BlockPos
-import net.minecraft.core.particles.ParticleTypes
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.ai.memory.MemoryModuleType
-import net.minecraft.world.entity.ai.memory.WalkTarget
-import net.minecraft.world.entity.ai.util.LandRandomPos
-import net.minecraft.world.phys.Vec3
-
-class AvoidScarekrow(
-    private val speedMultiplier: Expression = "0.5".asExpression(),
-) : Objective {
-    private var movementTask: EntityFixation? = null
-    private var remainingCooldownTicks = 0
-
-    override val observedMemories = listOf(CobblemonMemories.NEARBY_SCAREKROW)
-
-    override fun getDescription(entity: LivingEntity) = "Avoiding target block"
-
-    override fun perform(
-        entity: LivingEntity,
-        brain: BiggerBrain,
-        activeObjectiveTags: MutableSet<String>
-    ): ObjectiveStatus {
-        if (entity !is PokemonEntity || !entity.isAlive) return ObjectiveStatus.INVALID
-
-        val target = brain.getMemory(CobblemonMemories.NEARBY_SCAREKROW)
-            ?: return ObjectiveStatus.INACTIVE
-
-        // if the scarekrow is gone we dont need to be scared anymore
-        if (!entity.level().getBlockState(target).`is`(CobblemonBlockTags.SCAREKROWS)) {
-            brain.eraseMemory(CobblemonMemories.NEARBY_SCAREKROW)
-            return ObjectiveStatus.INACTIVE
-        }
-
-        // finish existing movement task
-        if (brain.isFixation(movementTask)) {
-            return ObjectiveStatus.FIXATED
-        }
-
-        // aggro against the player should take priority
-        if (brain.getMemory(MemoryModuleType.ATTACK_TARGET) != null) {
-            return ObjectiveStatus.BLOCKED
-        }
-
-        if (remainingCooldownTicks > 0) {
-            remainingCooldownTicks--
-        }
-        val runtime = mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
-        val speed = runtime.resolveFloat(speedMultiplier)
-
-        if (!brain.distract(Distraction.FORCE)) return ObjectiveStatus.BLOCKED
-        var targetPos : BlockPos? = null
-
-        // fixate on running from the scarekrow until it is out of range
-        brain.fixate(ConditionalLockFixation("Avoiding scarekrow") {
-            brain.getMemory(CobblemonMemories.NEARBY_SCAREKROW) != null
-        })
-
-        // find position
-        val direction = entity.position().subtract(target.toVec3d())
-        for (j in 0..9) {
-            val targetVec3 = LandRandomPos.getPosAway(entity, (Cobblemon.config.scarekrowRadius * 1.5).toInt(), 7, direction)
-            if (targetVec3 != null) {
-                targetPos = BlockPos.containing(targetVec3)
-                break
-            }
-        }
-
-        // Start a look-and-move fixation only when navigation accepts the selected position.
-        if (targetPos != null) {
-            val movementTracker = RegularMovementTracker.attempt(
-                entity = entity,
-                walkTarget = WalkTarget(
-                    targetPos,
-                    speed,
-                    0
-                )
-            )
-            entity.level().sendParticlesServer(ParticleTypes.HAPPY_VILLAGER, targetPos.above().toVec3d(), 5, Vec3(0.0, 0.0, 0.0), 5.0)
-            if (movementTracker != null) {
-                movementTask = brain.fixate(
-                    LookAndMoveFixation(
-                        distractionTypes = setOf(
-                            DistractionType.FORCE
-                        ),
-                        lookingTracker = LookingTracker.fromNavigationPathOrWalkTarget(
-                            entity,
-                            movementTracker.walkTarget
-                        ),
-                        movementTracker = movementTracker,
-                        description = "Moving away from target block",
-                    )
-                )
-                return ObjectiveStatus.FIXATED
-            }
-        }
-
-        return ObjectiveStatus.FIXATED
-    }
-
-    override fun onRegister(entity: LivingEntity, brain: BiggerBrain) {
-        brain.subscribe(
-            priority = Priority.LOW,
-            memory = CobblemonMemories.NEARBY_SCAREKROW,
-        ) { value, labels ->
-            if (value == null) {
-                if (brain.isFixation(movementTask)) {
-                    brain.distract(Distraction.FORCE)
-                    movementTask = null
-                }
-            }
-            return@subscribe true
-        }
-    }
-
-    class Config : ObjectiveConfig {
-        val speedMultiplier: ExpressionOrEntityVariable = Either.left("0.5".asExpression())
-
-        override fun getVariables(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ): List<MoLangConfigVariable> {
-            return listOf(speedMultiplier).asVariables()
-        }
-
-        override fun create(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ): Objective {
-            return AvoidScarekrow(
-                speedMultiplier = speedMultiplier.asSimplifiedExpression(entity),
-            )
-        }
-    }
-}
@@ -1,175 +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.ai.biggerbrain.objective
-
-import com.bedrockk.molang.Expression
-import com.cobblemon.mod.common.api.Priority
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asSimplifiedExpression
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.biggerbrain.LookingTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.RegularMovementTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.Distraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.DistractionType
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.EntityFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.LookAndMoveFixation
-import com.cobblemon.mod.common.api.ai.config.objective.ObjectiveConfig
-import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
-import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.asExpression
-import com.cobblemon.mod.common.util.mainThreadRuntime
-import com.cobblemon.mod.common.util.resolveFloat
-import com.cobblemon.mod.common.util.withQueryValue
-import com.mojang.datafixers.util.Either
-import net.minecraft.core.BlockPos
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.ai.memory.MemoryModuleType
-import net.minecraft.world.entity.ai.memory.WalkTarget
-import net.minecraft.world.entity.ai.util.LandRandomPos
-import net.minecraft.world.entity.player.Player
-
-class AvoidTarget(
-    private val speedMultiplier: Expression = "0.5".asExpression(),
-) : Objective {
-    private var movementTask: EntityFixation? = null
-    private var remainingCooldownTicks = 0
-
-    override val observedMemories = listOf(MemoryModuleType.AVOID_TARGET)
-
-    override fun getDescription(entity: LivingEntity) = "Avoiding target"
-
-    override fun perform(
-        entity: LivingEntity,
-        brain: BiggerBrain,
-        activeObjectiveTags: MutableSet<String>
-    ): ObjectiveStatus {
-        if (entity !is PokemonEntity || !entity.isAlive) return ObjectiveStatus.INVALID
-
-        val target = brain.getMemory(MemoryModuleType.AVOID_TARGET)
-            ?: return ObjectiveStatus.INACTIVE
-
-        if (target.isRemoved || target.isDeadOrDying) {
-            brain.eraseMemory(MemoryModuleType.AVOID_TARGET)
-            return ObjectiveStatus.INACTIVE
-        }
-
-        if (target is Player && (target.isCreative || target.isSpectator)) {
-            brain.eraseMemory(MemoryModuleType.AVOID_TARGET)
-            return ObjectiveStatus.INACTIVE
-        }
-
-        if (brain.isFixation(movementTask)) {
-            return ObjectiveStatus.FIXATED
-        }
-
-        if (remainingCooldownTicks > 0) {
-            remainingCooldownTicks--
-        }
-
-        val runtime = mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
-        val speed = runtime.resolveFloat(speedMultiplier)
-
-
-        // If we have a current target, check if it's still valid and within roam range (if tethered)
-        if (target.isAlive) {
-            val tethering = (entity).tethering
-            if (tethering != null && !tethering.canRoamTo(target.blockPosition())) {
-                // Target moved out of range let's kill the memory >:)
-                brain.distract(Distraction.FORCE)
-                entity.brain.eraseMemory(MemoryModuleType.AVOID_TARGET)
-            }
-        }
-
-        if (brain.isFixation(movementTask)) {
-            return ObjectiveStatus.FIXATED
-        }
-
-        if (!brain.distract(Distraction.FORCE)) return ObjectiveStatus.BLOCKED
-        var targetPos : BlockPos? = null
-
-        // TODO: utilize wander target rules to find a valid target position
-        val direction = entity.position().subtract(target.position())
-        for (j in 0..9) {
-            val targetVec3 = LandRandomPos.getPosAway(entity, 16, 7, direction)
-            if (targetVec3 != null) {
-                targetPos = BlockPos.containing(targetVec3)
-                break
-            }
-        }
-//        val walkTarget = WanderAround.generateWalkTarget(entity)
-        if (targetPos != null) {
-            val movementTracker = RegularMovementTracker.attempt(
-                entity = entity,
-                walkTarget = WalkTarget(
-                    targetPos,
-                    speed,
-                    0
-                )
-            )
-            if (movementTracker != null) {
-                movementTask = brain.fixate(
-                    LookAndMoveFixation(
-                        distractionTypes = setOf(
-                            DistractionType.FORCE
-                        ),
-                        lookingTracker = LookingTracker.fromNavigationPathOrWalkTarget(
-                            entity,
-                            movementTracker.walkTarget
-                        ),
-                        movementTracker = movementTracker,
-                        description = "Moving away from target entity",
-                    )
-                )
-                return ObjectiveStatus.FIXATED
-            }
-        }
-
-
-
-        return ObjectiveStatus.ACTIVE
-    }
-
-    override fun onRegister(entity: LivingEntity, brain: BiggerBrain) {
-        brain.subscribe(
-            priority = Priority.LOW,
-            memory = MemoryModuleType.AVOID_TARGET
-        ) { value, labels ->
-            if (value == null) {
-                if (brain.isFixation(movementTask)) {
-                    brain.distract(Distraction.FORCE)
-                    movementTask = null
-                }
-            }
-            return@subscribe true
-        }
-    }
-
-    class Config : ObjectiveConfig {
-        val speedMultiplier: ExpressionOrEntityVariable = Either.left("0.5".asExpression())
-
-        override fun getVariables(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ): List<MoLangConfigVariable> {
-            return listOf(speedMultiplier).asVariables()
-        }
-
-        override fun create(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ): Objective {
-            return AvoidTarget(
-                speedMultiplier = speedMultiplier.asSimplifiedExpression(entity),
-            )
-        }
-    }
-}
@@ -1,306 +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.ai.biggerbrain.objective
-
-import com.bedrockk.molang.Expression
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.CobblemonItems
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asSimplifiedExpression
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.biggerbrain.LookingTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.RegularMovementTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.Distraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.DistractionType
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.comfortDistraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.DurationLockFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.EntityFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.LookAndMoveFixation
-import com.cobblemon.mod.common.api.ai.config.objective.ObjectiveConfig
-import com.cobblemon.mod.common.api.ai.resolveInt as resolveVariableInt
-import com.cobblemon.mod.common.api.breeding.CobblemonBreeding
-import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
-import com.cobblemon.mod.common.api.nest.WildNestType
-import com.cobblemon.mod.common.api.nest.WildNestTypes
-import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
-import com.cobblemon.mod.common.block.WildNestBlock
-import com.cobblemon.mod.common.block.entity.NestBlockEntity
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.asExpression
-import com.cobblemon.mod.common.util.mainThreadRuntime
-import com.cobblemon.mod.common.util.resolveBoolean
-import com.cobblemon.mod.common.util.resolveFloat
-import com.cobblemon.mod.common.util.withQueryValue
-import com.mojang.datafixers.util.Either
-import net.minecraft.core.BlockPos
-import net.minecraft.core.particles.ParticleTypes
-import net.minecraft.server.level.ServerLevel
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.ai.memory.MemoryModuleType
-import net.minecraft.world.entity.ai.memory.WalkTarget
-import net.minecraft.world.level.block.state.properties.BlockStateProperties
-import net.minecraft.world.phys.Vec3
-
-class Breed(
-    private val speedMultiplier: Expression = "0.4".asExpression(),
-    private val condition: Expression = "true".asExpression(),
-    private val layDurationTicks: Int = 40
-) : Objective {
-    private var fixation: EntityFixation? = null
-    private var mateFixation: EntityFixation? = null
-
-    override fun getDescription(entity: LivingEntity) = "Breed"
-
-    override fun perform(entity: LivingEntity, brain: BiggerBrain, activeObjectiveTags: MutableSet<String>): ObjectiveStatus {
-        if (entity !is PokemonEntity || !entity.isAlive)
-            return ObjectiveStatus.INVALID
-        val world = entity.level() as? ServerLevel ?: return ObjectiveStatus.INVALID
-        val mate = brain.getMemory(CobblemonMemories.POTENTIAL_MATE) as? PokemonEntity ?: return ObjectiveStatus.INACTIVE
-        if (!mate.isAlive || mate.level() != world)
-            return ObjectiveStatus.INACTIVE
-        // ignore wild pokemon who are already parents of a nest
-        if (entity.pokemon.isWild() && brain.hasMemoryValue(CobblemonMemories.PATERNAL_NEST_LOCATION))
-            return ObjectiveStatus.INACTIVE
-        // make sure either parent doesn't have an active breeding cooldown (do we want to only do this for the females?)
-        if (entity.pokemon.breedingCooldown != 0 || mate.pokemon.breedingCooldown != 0)
-            return ObjectiveStatus.INACTIVE
-        // is breeding disabled from any preset conditions
-        if (!mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue()).resolveBoolean(condition))
-            return ObjectiveStatus.INACTIVE
-        // try to get one parent to lead the other one and have the other one not do this stuff
-        if (entity.uuid > mate.uuid)
-            return ObjectiveStatus.INACTIVE
-
-        val nestPos = brain.getMemory(CobblemonMemories.NEST_LOCATION)
-        if (nestPos != null)
-            return breedAtNest(entity, brain, mate, world, nestPos)
-        val idealNestPos = brain.getMemory(CobblemonMemories.IDEAL_NEST_LOCATION) ?: return ObjectiveStatus.INACTIVE
-        return buildNest(entity, brain, mate, world, idealNestPos)
-    }
-
-    // get both parents to go to the nest and breed once within range
-    private fun breedAtNest(entity: PokemonEntity, brain: BiggerBrain, mate: PokemonEntity, world: ServerLevel, nestPos: BlockPos): ObjectiveStatus {
-        val nest = world.getBlockEntity(nestPos) as? NestBlockEntity ?: return ObjectiveStatus.INACTIVE
-        if (!canUseNest(entity, mate, world, nest))
-            return ObjectiveStatus.INACTIVE
-        if (!nest.getItem().isEmpty)
-            return ObjectiveStatus.INACTIVE
-        // make sure these lovers claim the nest because others may try to at the same time
-        nest.nestClaimedBy = Pair(entity.uuid, mate.uuid)
-
-        val nestCenter = Vec3.atCenterOf(nestPos)
-        val speed = mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue()).resolveFloat(speedMultiplier)
-        // path to the nest site with mate until close enough (big bois had issues so we are also going to try to make it easier for them)
-        if (entity.position().distanceTo(nestCenter) > closeEnough(entity) || mate.position().distanceTo(nestCenter) > closeEnough(mate)) {
-            bringMate(mate, nestCenter, speed)
-            return walkToNest(entity, brain, nestCenter, speed, "in Breed fixation: going to nest")
-        }
-        return layEgg(entity, brain, mate, world, nest, nestPos)
-    }
-
-    // have both mates go to a ideal spot to make a nest
-    private fun buildNest(entity: PokemonEntity, brain: BiggerBrain, mate: PokemonEntity, world: ServerLevel, nestPos: BlockPos): ObjectiveStatus {
-        // probably should stop trying to build nest if there is an attack target
-        if (brain.hasMemoryValue(MemoryModuleType.ATTACK_TARGET))
-            return ObjectiveStatus.INACTIVE
-        // find out what kinds of nests this couple can make togethr
-        val types = WildNestTypes.combinedTypes(entity, mate)
-        if (types.isEmpty())
-            return ObjectiveStatus.INACTIVE
-
-        val nestCenter = Vec3.atCenterOf(nestPos)
-        val speed = mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue()).resolveFloat(speedMultiplier)
-        // keep going until both mates are not too far from the nest
-        if (entity.position().distanceTo(nestCenter) > closeEnough(entity) || mate.position().distanceTo(nestCenter) > closeEnough(mate)) {
-            bringMate(mate, nestCenter, speed)
-            return walkToNest(entity, brain, nestCenter, speed, "in Breed fixation: going to nest")
-        }
-
-        // get our nest they are about to build and place it
-        val nestToBuild = WildNestTypes.resolvePlacement(types, world.getBlockState(nestPos.below()), world.getFluidState(nestPos)) ?: return ObjectiveStatus.INACTIVE
-        val nestBlock = WildNestTypes.blockFor(nestToBuild.type) as? WildNestBlock ?: return ObjectiveStatus.INACTIVE
-        var nestState = nestBlock.defaultBlockState().setValue(BlockStateProperties.WATERLOGGED, nestToBuild.waterlogged)
-        nestBlock.variantProperty?.let { nestState = nestState.setValue(it, nestToBuild.variant) }
-        world.setBlock(nestPos, nestState, 3)
-
-        // set the parents of the nest (hope this isn't too early to do this, might need to be after egg laying instead..)
-        (world.getBlockEntity(nestPos) as? NestBlockEntity)?.nestClaimedBy = Pair(entity.uuid, mate.uuid)
-
-        for (parentBrain in listOf(brain, mate.biggerBrain)) {
-            parentBrain.eraseMemory(CobblemonMemories.IDEAL_NEST_LOCATION)
-            // give our newly made nest to the parents now taht it exists
-            parentBrain.setMemory(CobblemonMemories.NEST_LOCATION, nestPos)
-        }
-        return ObjectiveStatus.ACTIVE
-    }
-
-    // make da baby and tell the parents about their new responsibility in life
-    private fun layEgg(entity: PokemonEntity, brain: BiggerBrain, mate: PokemonEntity, world: ServerLevel, nest: NestBlockEntity, nestPos: BlockPos): ObjectiveStatus {
-        if (!brain.distract(Distraction.FORCE))
-            return ObjectiveStatus.BLOCKED
-        val egg = CobblemonBreeding.createEgg(entity.pokemon, mate.pokemon) ?: return ObjectiveStatus.INACTIVE
-        nest.setItem(egg)
-
-        // wild nests are probably the only ones where we need to record the parents onto the nest
-        if (nest.ownerUUID == null) {
-            nest.parents = Pair(entity.uuid, mate.uuid)
-            nest.nestClaimedBy = Pair(entity.uuid, mate.uuid)
-        }
-
-        for (parent in listOf(entity, mate)) {
-            // might want to do the destiny knot damaging here for each parent that has one
-            if (Cobblemon.config.canDestinyKnotBreak)
-                if (parent.pokemon.heldItem.item == CobblemonItems.DESTINY_KNOT.asItem()) {
-                    parent.pokemon.heldItemNoCopy().damageValue += 1
-                }
-
-            parent.pokemon.breedingCooldown = CobblemonBreeding.resetBreedingCooldown(parent.pokemon)
-            parent.biggerBrain.setMemory(CobblemonMemories.PATERNAL_NEST_LOCATION, nestPos)
-            parent.biggerBrain.setMemory(CobblemonMemories.EGG_IN_NEST, true)
-            parent.biggerBrain.eraseMemory(CobblemonMemories.IDEAL_NEST_LOCATION)
-
-            // todo do we want to use our own particles? look at this later
-            world.sendParticles(
-                ParticleTypes.HEART,
-                parent.getRandomX(1.0),
-                parent.getRandomY() + 0.5,
-                parent.getRandomZ(1.0),
-                4 + parent.random.nextInt(2),
-                0.2 * parent.random.nextGaussian(),
-                0.1 * parent.random.nextGaussian(),
-                0.2 * parent.random.nextGaussian(),
-                0.02
-            )
-        }
-        // try to keep them in one spot for a bit to give time for the magic to happen
-        fixation = brain.fixate(DurationLockFixation("Breed: laying egg", layDurationTicks))
-        if (mate.biggerBrain.distract(Distraction.FORCE)) {
-            mateFixation = mate.biggerBrain.fixate(DurationLockFixation("Breed: laying egg as the mate", layDurationTicks))
-        }
-        return ObjectiveStatus.FIXATED
-    }
-
-    // path to the nest location
-    private fun walkToNest(entity: PokemonEntity, brain: BiggerBrain, target: Vec3, speed: Float, description: String): ObjectiveStatus {
-        if (brain.isFixation(fixation))
-            return ObjectiveStatus.FIXATED
-        // wait for mate to get here
-        if (entity.position().distanceTo(target) <= closeEnough(entity))
-            return ObjectiveStatus.ACTIVE
-        if (!brain.distract(comfortDistraction))
-            return ObjectiveStatus.BLOCKED
-        val tracker = RegularMovementTracker.attempt(entity, WalkTarget(target, speed, closeEnough(entity).toInt())) ?: return ObjectiveStatus.ACTIVE
-        fixation = brain.fixate(
-            LookAndMoveFixation(
-                distractionTypes = setOf(DistractionType.DAMAGE, DistractionType.FORCE),
-                description = description,
-                lookingTracker = LookingTracker.fromNavigationPathOrWalkTarget(entity, tracker.walkTarget),
-                movementTracker = tracker
-            )
-        )
-        return ObjectiveStatus.FIXATED
-    }
-
-    // have the other mates be told where to go
-    private fun bringMate(mate: PokemonEntity, target: Vec3, speed: Float) {
-        val mateBrain = mate.biggerBrain
-        if (mate.position().distanceTo(target) <= closeEnough(mate) || mateBrain.isFixation(mateFixation))
-            return
-        if (!mateBrain.distract(comfortDistraction))
-            return
-        val tracker = RegularMovementTracker.attempt(mate, WalkTarget(target, speed, closeEnough(mate).toInt())) ?: return
-        mateFixation = mateBrain.fixate(
-            LookAndMoveFixation(
-                distractionTypes = setOf(DistractionType.DAMAGE, DistractionType.FORCE),
-                description = "Breed: folow mate",
-                lookingTracker = LookingTracker.fromNavigationPathOrWalkTarget(mate, tracker.walkTarget),
-                movementTracker = tracker
-            )
-        )
-    }
-
-    // checks for what nests are valid for the mates
-    private fun canUseNest(entity: PokemonEntity, mate: PokemonEntity, world: ServerLevel, nest: NestBlockEntity): Boolean {
-        val nestType = (nest.blockState.block as? WildNestBlock)?.type ?: return false
-        if (!isNestTypeAllowed(nestType, entity, mate))
-            return false
-        val waterlogged = nest.blockState.getOptionalValue(BlockStateProperties.WATERLOGGED).orElse(false)
-        if (!isWaterGroupCompatible(entity, mate, waterlogged))
-            return false
-
-        // check if the nest is claimed by other pokemon that exist and maybe on their way to it (CRAB NOTE: This helps prevent swarms of mons going to the same nest which looked weird)
-        val (existingParent1, existingParent2) = nest.nestClaimedBy
-        val claimedByMate1 = existingParent1 != null && existingParent1 != entity.uuid && world.getEntity(existingParent1) != null
-        val claimedByMate2 = existingParent2 != null && existingParent2 != entity.uuid && world.getEntity(existingParent2) != null
-        if (claimedByMate1 && claimedByMate2)
-            return false
-        return true
-    }
-
-    // make sure the nest type works for the mates and that wild use wild nests and owned pokemon use player placed nests
-    private fun isNestTypeAllowed(nestType: WildNestType, entity: PokemonEntity, mate: PokemonEntity): Boolean {
-        val allowed = WildNestTypes.combinedTypes(entity, mate).toMutableSet()
-        if (!entity.pokemon.isWild() && !mate.pokemon.isWild()) {
-            allowed.add(WildNestType.PLAYER)
-            allowed.add(WildNestType.KELP)
-        }
-        if (nestType == WildNestType.PLAYER || nestType == WildNestType.KELP)
-            return !entity.pokemon.isWild() && nestType in allowed
-        return nestType in allowed
-    }
-
-    // waterlogged nests only allow parents that both have a water egg group and land nests dont work for mates that only have water egg groups
-    private fun isWaterGroupCompatible(entity: PokemonEntity, mate: PokemonEntity, nestWaterlogged: Boolean): Boolean {
-        val mate1Groups = entity.pokemon.species.eggGroups.map { it.name.lowercase() }
-        val mate2Groups = mate.pokemon.species.eggGroups.map { it.name.lowercase() }
-        val mate1HasWaterGroup = mate1Groups.any { it in WATER_EGG_GROUPS || it == "ditto" }
-        val mate2HasWaterGroup = mate2Groups.any { it in WATER_EGG_GROUPS || it == "ditto" }
-        val mate1OnlyWaterGroup = mate1Groups.all { it in WATER_EGG_GROUPS }
-        val mate2OnlyWaterGroup = mate2Groups.all { it in WATER_EGG_GROUPS }
-
-        return if (nestWaterlogged) mate1HasWaterGroup && mate2HasWaterGroup else !(mate1OnlyWaterGroup || mate2OnlyWaterGroup)
-    }
-
-    class Config : ObjectiveConfig {
-        val speedMultiplier: ExpressionOrEntityVariable = Either.left("0.4".asExpression())
-        val condition: ExpressionOrEntityVariable = Either.left("true".asExpression())
-        val layDurationTicks: ExpressionOrEntityVariable = Either.left("40".asExpression())
-
-        override fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): List<MoLangConfigVariable> {
-            return listOf(speedMultiplier, condition, layDurationTicks).asVariables()
-        }
-
-        override fun create(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): Objective {
-            behaviourConfigurationContext.addMemories(
-                CobblemonMemories.POTENTIAL_MATE,
-                CobblemonMemories.NEST_LOCATION,
-                CobblemonMemories.PATERNAL_NEST_LOCATION,
-                CobblemonMemories.IDEAL_NEST_LOCATION,
-                CobblemonMemories.EGG_IN_NEST,
-                MemoryModuleType.ATTACK_TARGET
-            )
-            return Breed(
-                speedMultiplier = speedMultiplier.asSimplifiedExpression(entity),
-                condition = condition.asSimplifiedExpression(entity),
-                layDurationTicks = layDurationTicks.resolveVariableInt(behaviourConfigurationContext.runtime)
-            )
-        }
-    }
-
-    // lets help those with more cushion for the pushing reach those nests to breed
-    private fun closeEnough(entity: PokemonEntity) = CLOSE_ENOUGH_DISTANCE + entity.bbWidth / 2
-
-    companion object {
-        private const val CLOSE_ENOUGH_DISTANCE = 1.5 // we will have this be our baseline and then scale based on hitbox (like above) for the bigger mons
-        private val WATER_EGG_GROUPS = setOf("water_1", "water_2", "water_3")
-    }
-}
@@ -1,167 +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.ai.biggerbrain.objective
-
-
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.biggerbrain.MovementTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.Distraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.idleBoredomDistraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.EntityFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.MovementTrackerFixation
-import com.cobblemon.mod.common.api.ai.config.objective.ObjectiveConfig
-import com.cobblemon.mod.common.api.ai.resolveFloat
-import com.cobblemon.mod.common.api.ai.resolveInt
-import com.cobblemon.mod.common.entity.PoseType
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.entity.pokemon.ai.PokemonMoveControl
-import com.cobblemon.mod.common.util.asExpression
-import com.mojang.datafixers.util.Either
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.ai.memory.MemoryModuleType
-
-/**
- * Swim or fly in a circle objective
- */
-class CircleAround(
-    val poseTypes: Set<PoseType>,
-    val minTurnAngleDegrees: Float,
-    val maxTurnAngleDegrees: Float,
-    val verticalSpeed: Float,
-    val speed: Float,
-    val minDurationTicks: Int = 60,
-    val maxDurationTicks: Int = 180
-) : Objective {
-    var chosenTurnAngle = 0F
-    var chosenDuration = 0
-    var fixation: EntityFixation? = null
-    var moveControl: PokemonMoveControl? = null
-
-    override fun getDescription(entity: LivingEntity) = "Circling"
-    override fun perform(
-        entity: LivingEntity,
-        brain: BiggerBrain,
-        activeObjectiveTags: MutableSet<String>
-    ): ObjectiveStatus {
-        if (entity !is PokemonEntity) {
-            return ObjectiveStatus.INVALID
-        } else if (brain.isFixation(fixation)) {
-            return ObjectiveStatus.FIXATED
-        } else if (entity.getCurrentPoseType() !in poseTypes) {
-            return ObjectiveStatus.BLOCKED
-        } else if (brain.fixation != null) {
-            fixation = null
-            return ObjectiveStatus.BLOCKED // Since this doesn't distract anything then if the brain is fixated at all we are blocked
-        }
-
-        // TODO: should this not be able to distract anything? relates to the above fixation comment
-//        if (!brain.distract(idleBoredomDistraction)) {
-//            return ObjectiveStatus.BLOCKED
-//        }
-
-        entity.brain.eraseMemory(MemoryModuleType.WALK_TARGET)
-        entity.navigation.stop()
-
-        // Gather a random turn angle and random duration
-        this.chosenTurnAngle = entity.random.nextFloat() * (maxTurnAngleDegrees - minTurnAngleDegrees) + minTurnAngleDegrees
-        if (entity.random.nextBoolean()) {
-            chosenTurnAngle = -chosenTurnAngle
-        }
-        chosenDuration = entity.random.nextIntBetweenInclusive(minDurationTicks, maxDurationTicks)
-
-        // Grab moveControl off the entity to use during fixation
-        this.moveControl = entity.moveControl as PokemonMoveControl?
-
-
-        // Become fixated
-        fixation = brain.fixate(
-            CircleAroundFixation(
-                this,
-        null,
-                chosenDuration
-            )
-        )
-        return ObjectiveStatus.ACTIVE //TODO: should this have a cooldown? Currently just having it as the pure fallback and able to be distracted by anything. I guess fishes should always swim... probably not but I'll sort that later
-    }
-
-
-    class CircleAroundFixation(
-        val objective: CircleAround,
-        override val movementTracker: MovementTracker?,
-        var timer: Int
-    ) : EntityFixation, MovementTrackerFixation {
-        override fun getDescription(entity: LivingEntity) = "Circling around at ${this.objective.chosenTurnAngle} degrees for ${this.timer} more ticks"
-        override fun onDistract(distraction: Distraction, entity: LivingEntity) {
-            super.onDistract(distraction, entity)
-            objective.moveControl?.stopBanking()
-        }
-
-        // can be distracted by anything
-        override fun canDistract(distraction: Distraction, entity: LivingEntity): Boolean {
-            return true
-        }
-
-        override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
-            objective.moveControl?.startBanking(
-                forwardBlocksPerTick = objective.speed,
-                upwardsBlocksPerTick = objective.verticalSpeed,
-                rightDegreesPerTick = objective.chosenTurnAngle,
-                durationTicks = 2 //TODO: is it odd we have the check in multiple spots?
-            )
-            this.timer--
-            if (this.timer < 0 || (entity as PokemonEntity).getCurrentPoseType() !in objective.poseTypes) {
-                objective.moveControl?.stopBanking()
-                return false
-            }
-            return true
-        }
-    }
-
-    class Config : ObjectiveConfig {
-        val poseTypes: Set<PoseType> = setOf(PoseType.FLY, PoseType.HOVER)
-        val minAngularVelocityDegrees: ExpressionOrEntityVariable = Either.left("0.0".asExpression())
-        val maxAngularVelocityDegrees: ExpressionOrEntityVariable = Either.left("1.0".asExpression())
-        val speed: ExpressionOrEntityVariable = Either.left("0.6".asExpression())
-        val verticalSpeed: ExpressionOrEntityVariable = Either.left("0.0".asExpression())
-        val minDurationTicks: ExpressionOrEntityVariable = Either.left("60".asExpression())
-        val maxDurationTicks: ExpressionOrEntityVariable = Either.left("180".asExpression())
-
-
-        override fun getVariables(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ) = listOf(
-            minAngularVelocityDegrees,
-            maxAngularVelocityDegrees,
-            speed,
-            verticalSpeed,
-            minDurationTicks,
-            maxDurationTicks
-        ).asVariables()
-
-        override fun create(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ): Objective? {
-            if (entity !is PokemonEntity) return null
-            return CircleAround(
-                poseTypes = poseTypes,
-                minTurnAngleDegrees = minAngularVelocityDegrees.resolveFloat(behaviourConfigurationContext.runtime),
-                maxTurnAngleDegrees = maxAngularVelocityDegrees.resolveFloat(behaviourConfigurationContext.runtime),
-                speed = speed.resolveFloat(behaviourConfigurationContext.runtime),
-                verticalSpeed = verticalSpeed.resolveFloat(behaviourConfigurationContext.runtime),
-                minDurationTicks = minDurationTicks.resolveInt(behaviourConfigurationContext.runtime),
-                maxDurationTicks = maxDurationTicks.resolveInt(behaviourConfigurationContext.runtime)
-            )
-        }
-    }
-}
@@ -1,384 +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.ai.biggerbrain.objective
-
-import com.bedrockk.molang.Expression
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.Priority
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asSimplifiedExpression
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.biggerbrain.LookingTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.RegularMovementTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.Distraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.DistractionType
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.comfortDistraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.AttackFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.EntityFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.LookAndLockFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.LookAndMoveFixation
-import com.cobblemon.mod.common.api.ai.config.objective.ObjectiveConfig
-import com.cobblemon.mod.common.api.ai.resolveInt as resolveVariableInt
-import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
-import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.asExpression
-import com.cobblemon.mod.common.util.isInBattle
-import com.cobblemon.mod.common.util.mainThreadRuntime
-import com.cobblemon.mod.common.util.resolveBoolean
-import com.cobblemon.mod.common.util.resolveFloat
-import com.cobblemon.mod.common.util.resolveInt
-import com.cobblemon.mod.common.util.withQueryValue
-import com.mojang.datafixers.util.Either
-import net.minecraft.core.BlockPos
-import net.minecraft.core.particles.ParticleTypes
-import net.minecraft.server.level.ServerLevel
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.ai.memory.MemoryModuleType
-import net.minecraft.world.entity.ai.memory.WalkTarget
-import net.minecraft.server.level.ServerPlayer
-import net.minecraft.world.entity.player.Player
-import net.minecraft.world.phys.Vec3
-
-class DefendNest(
-    speedMultiplier: Expression = "0.5".asExpression(),
-    warnRange: Expression = "15.0".asExpression(),
-    private val attackRange: Expression = "8.0".asExpression(),
-    disengageRange: Expression = "20.0".asExpression(),
-    condition: Expression = "true".asExpression(),
-    targetCondition: Expression = "true".asExpression(),
-    description: Expression = "'Defend Nest'".asExpression(),
-    private val maxAttackDuration: Expression = "300".asExpression(),
-    private val patrolMinRadius: Int = 4,
-    private val patrolMaxRadius: Int = 8
-) : EntityResponseObjective(
-    speedMultiplier = speedMultiplier,
-    engageRange = warnRange,
-    disengageRange = disengageRange,
-    condition = condition,
-    targetCondition = targetCondition,
-    description = description
-) {
-    private var fixation: EntityFixation? = null
-    private var scanCooldownTicks = 0
-    private var cryCooldownTicks = 0
-    private var patrolCooldownTicks = 0
-
-    override fun perform(entity: LivingEntity, brain: BiggerBrain, activeObjectiveTags: MutableSet<String>): ObjectiveStatus {
-        if (entity !is PokemonEntity || !entity.isAlive)
-            return ObjectiveStatus.INVALID
-        // so only wild mons will guard the nest (unless we want them to later on..)
-        if (!entity.pokemon.isWild())
-            return ObjectiveStatus.INACTIVE
-        // if the mon is battling then don't worry about defending (this was causing crying and particle spam lol)
-        if (entity.isBattling)
-            return ObjectiveStatus.INACTIVE
-
-        val nestPos = brain.getMemory(CobblemonMemories.PATERNAL_NEST_LOCATION)
-        if (nestPos == null) {
-            // mates used to give up attacking players if the egg and nest was gone but we should have them chase them to the ends of the earth for their crimes
-            val thief = brain.getMemory(CobblemonMemories.EGG_THIEF)
-            if (thief != null && thief.isAlive && entity.hasLineOfSight(thief))
-                return attack(entity, brain, thief)
-            return stopDefending(brain)
-        }
-        val eggInNest = brain.getMemory(CobblemonMemories.EGG_IN_NEST) == true
-        val thief = brain.getMemory(CobblemonMemories.EGG_THIEF)
-        // if we have no egg to watch over and no thief then we should not defend the nest anymore and need to switch to a different task
-        if (!eggInNest && thief == null)
-            return stopDefending(brain)
-
-        if (scanCooldownTicks > 0)
-            scanCooldownTicks--
-        if (cryCooldownTicks > 0)
-            cryCooldownTicks--
-        val nestCenter = Vec3.atCenterOf(nestPos)
-
-        val attackTarget = brain.getMemory(MemoryModuleType.ATTACK_TARGET)
-        if (attackTarget != null && attackTarget.uuid != trackedEntity?.uuid) {
-            trackedEntity = null
-            return ObjectiveStatus.BLOCKED
-        }
-
-        val tracked = trackedEntity
-        if (tracked != null) {
-            if (!keepTrackingPlayer(entity, brain, tracked, nestCenter)) {
-                brain.eraseMemory(MemoryModuleType.ATTACK_TARGET)
-                brain.eraseMemory(MemoryModuleType.ANGRY_AT)
-                trackedEntity = null
-                fixation = null
-                return ObjectiveStatus.ACTIVE
-            }
-            return respondToIntruder(entity, brain, tracked, nestCenter)
-        }
-
-        if (scanCooldownTicks <= 0) {
-            scanCooldownTicks = SCAN_INTERVAL_TICKS
-            trackedEntity = findIntruder(entity, brain, nestCenter)
-            if (trackedEntity != null) {
-                cryCooldownTicks = 0
-                return ObjectiveStatus.ACTIVE
-            }
-        }
-        return patrol(entity, brain, nestCenter, activeObjectiveTags)
-    }
-
-    override fun onRegister(entity: LivingEntity, brain: BiggerBrain) {
-        // Go after any known egg thieves
-        brain.subscribe(Priority.HIGH, CobblemonMemories.EGG_THIEF) { thief, _ ->
-            if (entity is PokemonEntity && thief != null) {
-                if (brain.fixation !is AttackFixation) {
-                    trackedEntity = thief
-                    attack(entity, brain, thief)
-                }
-            } else if (thief == null && fixation is AttackFixation && brain.isFixation(fixation)) {
-                brain.distract(Distraction.FORCE)
-                brain.eraseMemory(MemoryModuleType.ATTACK_TARGET)
-                brain.eraseMemory(MemoryModuleType.ANGRY_AT)
-                trackedEntity = null
-                fixation = null
-            }
-            true
-        }
-    }
-
-    // stop defending the nest and remove the fixation
-    private fun stopDefending(brain: BiggerBrain): ObjectiveStatus {
-        if (trackedEntity != null) {
-            brain.eraseMemory(MemoryModuleType.ATTACK_TARGET)
-            brain.eraseMemory(MemoryModuleType.ANGRY_AT)
-            trackedEntity = null
-            fixation = null
-        }
-        if (fixation is LookAndLockFixation && brain.isFixation(fixation))
-            brain.distract(Distraction.FORCE)
-        return ObjectiveStatus.INACTIVE
-    }
-
-    // various checks on if a player should be tracked still
-    private fun keepTrackingPlayer(entity: PokemonEntity, brain: BiggerBrain, tracked: LivingEntity, nestCenter: Vec3): Boolean {
-        if (tracked.isRemoved || !tracked.isAlive)
-            return false
-        if (tracked is Player && (tracked.isCreative || tracked.isSpectator))
-            return false
-        if (tracked is ServerPlayer && tracked.isInBattle())
-            return false
-        if (brain.getMemory(CobblemonMemories.EGG_THIEF)?.uuid == tracked.uuid)
-            return true
-        val runtime = mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
-        return tracked.position().distanceTo(nestCenter) <= runtime.resolveFloat(disengageRange)
-    }
-
-    // warn players that get too close or that steal an egg
-    private fun respondToIntruder(entity: PokemonEntity, brain: BiggerBrain, tracked: LivingEntity, nestCenter: Vec3): ObjectiveStatus {
-        val runtime = mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
-        val distanceToNest = tracked.position().distanceTo(nestCenter)
-        val isThief = brain.getMemory(CobblemonMemories.EGG_THIEF)?.uuid == tracked.uuid
-        return when {
-            isThief || distanceToNest <= runtime.resolveFloat(attackRange) -> attack(entity, brain, tracked) // stop you have violated the law!
-            distanceToNest <= runtime.resolveFloat(engageRange) -> warn(entity, brain, tracked, nestCenter) // almost too close!
-            else -> ObjectiveStatus.ACTIVE
-        }
-    }
-
-    // force an attack fixation
-    private fun attack(entity: PokemonEntity, brain: BiggerBrain, target: LivingEntity): ObjectiveStatus {
-        if (fixation is AttackFixation && brain.isFixation(fixation))
-            return ObjectiveStatus.FIXATED
-        if (!brain.distract(Distraction.FORCE))
-            return ObjectiveStatus.BLOCKED
-        val runtime = mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
-        entity.cry()
-        // todo we can use our own particles later
-        (entity.level() as? ServerLevel)?.sendParticles(
-            ParticleTypes.ANGRY_VILLAGER,
-            entity.getRandomX(1.0),
-            entity.getRandomY() + 0.5,
-            entity.getRandomZ(1.0),
-            4 + entity.random.nextInt(2),
-            0.2 * entity.random.nextGaussian(),
-            0.1 * entity.random.nextGaussian(),
-            0.2 * entity.random.nextGaussian(),
-            0.02
-        )
-
-        brain.setMemory(MemoryModuleType.ATTACK_TARGET, target, runtime.resolveInt(maxAttackDuration).toLong())
-        brain.setMemory(MemoryModuleType.ANGRY_AT, target.uuid)
-        brain.eraseMemory(CobblemonMemories.EGG_SEARCH_COUNTDOWN)
-        fixation = brain.fixate(
-            AttackFixation(
-                targetEntity = target,
-                speedMultiplier = speedMultiplier,
-                availableMoves = getRealTimeMoves(entity), // idk how this works but looks like Jazz lets us do this now
-                distractionTypes = setOf(DistractionType.FORCE)
-            )
-        )
-        return ObjectiveStatus.FIXATED
-    }
-
-    // cry at players that get too close to the nest
-    private fun warn(entity: PokemonEntity, brain: BiggerBrain, target: LivingEntity, nestCenter: Vec3): ObjectiveStatus {
-        if (cryCooldownTicks <= 0) {
-            entity.cry()
-            // todo replace these particles later here too
-            (entity.level() as? ServerLevel)?.sendParticles(
-                ParticleTypes.ANGRY_VILLAGER,
-                entity.getRandomX(1.0),
-                entity.getRandomY() + 0.5,
-                entity.getRandomZ(1.0),
-                4 + entity.random.nextInt(2),
-                0.2 * entity.random.nextGaussian(),
-                0.1 * entity.random.nextGaussian(),
-                0.2 * entity.random.nextGaussian(),
-                0.02
-            )
-            cryCooldownTicks = CRY_COOLDOWN_TICKS + entity.random.nextInt(CRY_COOLDOWN_RANDOM_TICKS)
-        }
-        if (fixation is LookAndLockFixation && brain.isFixation(fixation))
-            return ObjectiveStatus.FIXATED
-        if (!brain.distract(Distraction.FORCE))
-            return ObjectiveStatus.BLOCKED
-        val runtime = mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
-        val warnRange = runtime.resolveFloat(engageRange)
-        val attackRange = runtime.resolveFloat(attackRange)
-        fixation = brain.fixate(
-            LookAndLockFixation(
-                lookingTracker = LookingTracker.forTargetEntity(entity, target),
-                distractionTypes = setOf(DistractionType.DAMAGE, DistractionType.FORCE),
-                condition = {
-                    val distance = target.position().distanceTo(nestCenter)
-                    trackedEntity?.uuid == target.uuid && distance <= warnRange && distance > attackRange
-                }
-            )
-        )
-        return ObjectiveStatus.FIXATED
-    }
-
-    // looks for player within the warn range and too close to the nest
-    private fun findIntruder(entity: PokemonEntity, brain: BiggerBrain, nestCenter: Vec3): LivingEntity? {
-        val runtime = mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
-        if (!runtime.resolveBoolean(condition))
-            return null
-        val warnRange = runtime.resolveFloat(engageRange)
-        val visible = brain.getMemory(MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES) ?: return null
-
-        // todo how should we handle creative players?
-        return visible.findAll { candidate ->
-            candidate is Player &&
-                !(candidate is ServerPlayer && candidate.isInBattle()) &&
-                candidate.position().distanceTo(nestCenter) <= warnRange &&
-                runtime.withQueryValue("target", candidate.asMostSpecificMoLangValue()).resolveBoolean(targetCondition)
-        }.minByOrNull { it.position().distanceToSqr(nestCenter) }
-    }
-
-    // pathfind around various spots around the nest
-    private fun patrol(entity: PokemonEntity, brain: BiggerBrain, nestCenter: Vec3, activeObjectiveTags: MutableSet<String>): ObjectiveStatus {
-        activeObjectiveTags.add(Objective.OBJECTIVE_TAG_WANDERING)
-        if (fixation is LookAndMoveFixation && brain.isFixation(fixation))
-            return ObjectiveStatus.FIXATED
-        if (patrolCooldownTicks > 0) {
-            patrolCooldownTicks--
-            return ObjectiveStatus.ACTIVE
-        }
-        val world = entity.level() as? ServerLevel ?: return ObjectiveStatus.INVALID
-        val target = findPatrolPosition(world, nestCenter, entity) ?: return ObjectiveStatus.ACTIVE
-        if (!brain.distract(comfortDistraction))
-            return ObjectiveStatus.BLOCKED
-        val speed = mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue()).resolveFloat(speedMultiplier)
-        val tracker = RegularMovementTracker.attempt(entity, WalkTarget(target, speed, 1)) ?: return ObjectiveStatus.ACTIVE
-        fixation = brain.fixate(
-            LookAndMoveFixation(
-                distractionTypes = setOf(DistractionType.DAMAGE, DistractionType.FORCE, DistractionType.COMFORT),
-                description = "patrol method in DefendNest objective",
-                lookingTracker = LookingTracker.fromNavigationPathOrWalkTarget(entity, tracker.walkTarget),
-                movementTracker = tracker,
-                onMovementComplete = { _, _ -> patrolCooldownTicks = PATROL_PAUSE_TICKS + entity.random.nextInt(PATROL_PAUSE_RANDOM_TICKS) }
-            )
-        )
-        return ObjectiveStatus.FIXATED
-    }
-
-    // find pathfindable spot to patrol to
-    private fun findPatrolPosition(world: ServerLevel, center: Vec3, entity: PokemonEntity): Vec3? {
-        repeat(PATROL_ATTEMPTS) {
-            val angle = world.random.nextDouble() * Math.PI * 2
-            val radius = patrolMinRadius + world.random.nextInt(patrolMaxRadius - patrolMinRadius + 1)
-            val candidate = center.add(Math.cos(angle) * radius, world.random.nextDouble() * 2 - 1, Math.sin(angle) * radius)
-            val blockPos = BlockPos.containing(candidate)
-            if (!world.getBlockState(blockPos).isSolidRender(world, blockPos) && entity.navigation.isStableDestination(blockPos)) {
-                return Vec3.atCenterOf(blockPos)
-            }
-        }
-        return null
-    }
-
-    class Config : ObjectiveConfig {
-        val speedMultiplier: ExpressionOrEntityVariable = Either.left("0.5".asExpression())
-        val warnRange: ExpressionOrEntityVariable = Either.left("15.0".asExpression())
-        val attackRange: ExpressionOrEntityVariable = Either.left("8.0".asExpression())
-        val disengageRange: ExpressionOrEntityVariable = Either.left("20.0".asExpression())
-        val condition: ExpressionOrEntityVariable = Either.left("true".asExpression())
-        val targetCondition: ExpressionOrEntityVariable = Either.left("true".asExpression())
-        val maxAttackDuration: ExpressionOrEntityVariable = Either.left("300".asExpression())
-        val description: ExpressionOrEntityVariable = Either.left("'Defend Nest'".asExpression())
-        val patrolMinRadius: ExpressionOrEntityVariable = Either.left("4".asExpression())
-        val patrolMaxRadius: ExpressionOrEntityVariable = Either.left("8".asExpression())
-
-        override fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): List<MoLangConfigVariable> {
-            return listOf(
-                speedMultiplier,
-                warnRange,
-                attackRange,
-                disengageRange,
-                condition,
-                targetCondition,
-                maxAttackDuration,
-                description,
-                patrolMinRadius,
-                patrolMaxRadius
-            ).asVariables()
-        }
-
-        override fun create(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): Objective {
-            // I don't think we need any other memory than these
-            behaviourConfigurationContext.addMemories(
-                CobblemonMemories.PATERNAL_NEST_LOCATION,
-                CobblemonMemories.EGG_IN_NEST,
-                CobblemonMemories.EGG_THIEF,
-                CobblemonMemories.EGG_SEARCH_COUNTDOWN,
-                MemoryModuleType.ANGRY_AT,
-                MemoryModuleType.ATTACK_TARGET,
-                MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES
-            )
-            return DefendNest(
-                speedMultiplier = speedMultiplier.asSimplifiedExpression(entity),
-                warnRange = warnRange.asSimplifiedExpression(entity),
-                attackRange = attackRange.asSimplifiedExpression(entity),
-                disengageRange = disengageRange.asSimplifiedExpression(entity),
-                condition = condition.asSimplifiedExpression(entity),
-                targetCondition = targetCondition.asSimplifiedExpression(entity),
-                description = description.asSimplifiedExpression(entity),
-                maxAttackDuration = maxAttackDuration.asSimplifiedExpression(entity),
-                patrolMinRadius = patrolMinRadius.resolveVariableInt(behaviourConfigurationContext.runtime),
-                patrolMaxRadius = patrolMaxRadius.resolveVariableInt(behaviourConfigurationContext.runtime)
-            )
-        }
-    }
-
-    companion object {
-        private const val SCAN_INTERVAL_TICKS = 20
-        private const val CRY_COOLDOWN_TICKS = 75
-        private const val CRY_COOLDOWN_RANDOM_TICKS = 50
-        private const val PATROL_PAUSE_TICKS = 40
-        private const val PATROL_PAUSE_RANDOM_TICKS = 40
-        private const val PATROL_ATTEMPTS = 20
-    }
-}
@@ -1,76 +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.ai.biggerbrain.objective
-
-
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.biggerbrain.LookingTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.MovementTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.RegularMovementTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.Distraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.DistractionType
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.comfortDistraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.idleBoredomDistraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.EntityFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.LookAndMoveFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.MovementTrackerFixation
-import com.cobblemon.mod.common.api.ai.config.objective.ObjectiveConfig
-import com.cobblemon.mod.common.api.ai.resolveFloat
-import com.cobblemon.mod.common.api.ai.resolveInt
-import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
-import com.cobblemon.mod.common.entity.PoseType
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.entity.pokemon.ai.PokemonMoveControl
-import com.cobblemon.mod.common.util.asExpression
-import com.mojang.datafixers.util.Either
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.PathfinderMob
-import net.minecraft.world.entity.ai.behavior.EntityTracker
-import net.minecraft.world.entity.ai.memory.MemoryModuleType
-import net.minecraft.world.entity.ai.memory.WalkTarget
-
-/**
- * Defend owner objective
- * Handles transition of nearest visible attacker to a valid attack target when wanting to defend owner.
- * Could possibly be more configurable in the future
- */
-class DefendOwner() : Objective {
-    var cooldownTicks = 0
-
-    override fun getDescription(entity: LivingEntity) = "Following parent species"
-
-    override fun perform(
-        entity: LivingEntity,
-        brain: BiggerBrain,
-        activeObjectiveTags: MutableSet<String>
-    ): ObjectiveStatus {
-        if (entity !is PokemonEntity) return ObjectiveStatus.INVALID
-        if (brain.hasMemoryValue(MemoryModuleType.ATTACK_TARGET)) return ObjectiveStatus.INACTIVE
-
-        val attacker = brain.getMemory(CobblemonMemories.NEAREST_VISIBLE_ATTACKER)
-            ?: return ObjectiveStatus.INACTIVE
-
-        brain.setMemory(MemoryModuleType.ATTACK_TARGET, attacker)
-        return ObjectiveStatus.ACTIVE
-    }
-
-    class Config : ObjectiveConfig {
-        override fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext) =
-            emptyList<MoLangConfigVariable>()
-
-        override fun create(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): Objective? {
-            if (entity !is PokemonEntity) return null
-            return DefendOwner()
-        }
-    }
-}
@@ -1,171 +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.ai.biggerbrain.objective
-
-import com.bedrockk.molang.Expression
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.Priority
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.CobblemonAttackTargetData
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asSimplifiedExpression
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.config.objective.ObjectiveConfig
-import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
-import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.asExpression
-import com.cobblemon.mod.common.util.mainThreadRuntime
-import com.cobblemon.mod.common.util.resolveBoolean
-import com.cobblemon.mod.common.util.resolveFloat
-import com.cobblemon.mod.common.util.resolveInt
-import com.cobblemon.mod.common.util.withQueryValue
-import com.mojang.datafixers.util.Either
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.ai.memory.MemoryModuleType
-import net.minecraft.world.entity.ai.memory.NearestVisibleLivingEntities
-
-
-class Defensive(
-    private val speedMultiplier: Expression = "0.5".asExpression(), // How do we transfer speed to the attack behaviour? Do we want to?
-    private val engageRange: Expression = "5.0".asExpression(),
-    private val disengageRange: Expression = "20.0".asExpression(),
-    private val condition: Expression = "true".asExpression(),
-    private val maxAttackDuration: Expression = "300".asExpression(),
-    private val retaliationHitCount: Expression = "1".asExpression()
-) : Objective {
-    private var remainingCooldownTicks = 0
-    private var trackedEntity: LivingEntity? = null
-    override val observedMemories = listOf(MemoryModuleType.HURT_BY_ENTITY, CobblemonMemories.ATTACK_TARGET_DATA)
-
-    override fun getDescription(entity: LivingEntity) = "Defensive Behavior"
-
-    override fun perform(
-        entity: LivingEntity,
-        brain: BiggerBrain,
-        activeObjectiveTags: MutableSet<String>
-    ): ObjectiveStatus {
-        if (entity !is PokemonEntity || !entity.isAlive) return ObjectiveStatus.INVALID
-
-        val attackTarget = brain.getMemory(MemoryModuleType.ATTACK_TARGET)
-        val avoidTarget = brain.getMemory(MemoryModuleType.AVOID_TARGET)
-
-        if (trackedEntity != null) {
-            if (attackTarget != null && trackedEntity?.uuid == attackTarget.uuid) {
-                // Check if we continue
-                return ObjectiveStatus.ACTIVE
-            } else if (avoidTarget != null && trackedEntity?.uuid === avoidTarget.uuid) {
-                // Check if we continue
-                val runtime = mainThreadRuntime.withQueryValue("entity", (trackedEntity!!).asMostSpecificMoLangValue())
-                val disengageDistance = runtime.resolveFloat(disengageRange)
-                if (disengageDistance < entity.distanceTo(trackedEntity!!)) {
-                    brain.eraseMemory(MemoryModuleType.AVOID_TARGET)
-                    trackedEntity = null
-                }
-            } else {
-                // Something has overrided us
-                trackedEntity = null
-            }
-        } else {
-            // Scan visible livingEntities
-            val entities: NearestVisibleLivingEntities =
-                brain.getMemory(MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES) ?: return ObjectiveStatus.INACTIVE
-
-            val entity = entities.findClosest { it ->
-                val runtime = mainThreadRuntime.withQueryValue("entity", (it).asMostSpecificMoLangValue())
-                runtime.resolveBoolean(condition) && runtime.resolveFloat(engageRange) > entity.distanceTo(it)
-            }.orElse(null)
-            if (entity != null) {
-                trackedEntity = entity
-                brain.setMemory(MemoryModuleType.AVOID_TARGET, entity)
-            }
-        }
-
-
-        if (remainingCooldownTicks > 0) {
-            remainingCooldownTicks--
-        }
-
-        return if (trackedEntity != null) ObjectiveStatus.ACTIVE else ObjectiveStatus.INACTIVE
-    }
-
-    override fun onRegister(entity: LivingEntity, brain: BiggerBrain) {
-        brain.subscribe(
-            priority = Priority.LOW,
-            memory = MemoryModuleType.HURT_BY_ENTITY
-        ) { value, labels -> onHurtByEntityChanged(brain, value, labels) }
-
-        brain.subscribe(
-            priority = Priority.LOW,
-            memory = CobblemonMemories.ATTACK_TARGET_DATA
-        ) { value, labels -> onAttackTargetDataChanged(brain, value, labels) }
-    }
-
-    fun onHurtByEntityChanged(brain: BiggerBrain, livingEntity: LivingEntity?, labels: MutableSet<String>): Boolean {
-        if (livingEntity != null) {
-            // Something just smacked us, see if we should get mad about it.
-            val livingEntity = livingEntity as LivingEntity
-            val runtime = mainThreadRuntime.withQueryValue("entity", (livingEntity).asMostSpecificMoLangValue())
-            val shouldTarget = runtime.resolveBoolean(condition)
-            if (shouldTarget) {
-                brain.setMemory(MemoryModuleType.ATTACK_TARGET, livingEntity,
-                    runtime.resolveInt(maxAttackDuration).toLong()
-                )
-                brain.eraseMemory(MemoryModuleType.AVOID_TARGET)
-                trackedEntity = livingEntity
-            }
-        }
-        return true
-    }
-
-    fun onAttackTargetDataChanged(brain: BiggerBrain, attackData: CobblemonAttackTargetData?, labels: MutableSet<String>): Boolean {
-        if (attackData != null) {
-            // We smacked them, check if it's time for tactical retreat
-            val livingEntity = brain.getMemory(MemoryModuleType.ATTACK_TARGET) ?: return true
-            val runtime = mainThreadRuntime.withQueryValue("entity", (livingEntity).asMostSpecificMoLangValue())
-            if (attackData.hitsLanded >= runtime.resolveInt(retaliationHitCount)) {
-                // Justice served, carry on
-                brain.eraseMemory(MemoryModuleType.ATTACK_TARGET)
-                brain.eraseMemory(CobblemonMemories.ATTACK_TARGET_DATA)
-                brain.setMemory(MemoryModuleType.AVOID_TARGET, trackedEntity)
-            }
-        }
-        return true // Other listeners can handle it that's fine
-    }
-
-    class Config : ObjectiveConfig {
-        val speedMultiplier: ExpressionOrEntityVariable = Either.left("0.5".asExpression())
-        val engageRange: ExpressionOrEntityVariable = Either.left("10.0".asExpression())
-        val disengageRange: ExpressionOrEntityVariable = Either.left("10.0".asExpression())
-        val condition: ExpressionOrEntityVariable = Either.left("10.0".asExpression())
-        val maxAttackDuration: ExpressionOrEntityVariable = Either.left("300".asExpression())
-        val retaliationHitCount: ExpressionOrEntityVariable = Either.left("1".asExpression())
-        override fun getVariables(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ): List<MoLangConfigVariable> {
-            return listOf(condition, speedMultiplier, engageRange, disengageRange, maxAttackDuration, retaliationHitCount).asVariables()
-        }
-
-        override fun create(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ): Objective {
-            return Defensive(
-                condition = condition.asSimplifiedExpression(entity),
-                speedMultiplier = speedMultiplier.asSimplifiedExpression(entity),
-                engageRange = engageRange.asSimplifiedExpression(entity),
-                disengageRange = disengageRange.asSimplifiedExpression(entity),
-                maxAttackDuration = maxAttackDuration.asSimplifiedExpression(entity),
-                retaliationHitCount = retaliationHitCount.asSimplifiedExpression(entity),
-                )
-        }
-    }
-}
@@ -13,7 +13,6 @@ import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
 import com.cobblemon.mod.common.api.ai.asVariables
 import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
 import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.Distraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.comfortDistraction
 import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.EntityFixation
 import com.cobblemon.mod.common.api.ai.config.objective.ObjectiveConfig
 import com.cobblemon.mod.common.api.ai.resolveFloat
@@ -53,10 +52,10 @@ class EatGrass(
    ): ObjectiveStatus {
        if (brain.isFixation(fixation)) {
            return ObjectiveStatus.FIXATED
+        } else if (brain.fixation != null) {
+            return ObjectiveStatus.BLOCKED
        } else if (entity !is PokemonEntity) {
            return ObjectiveStatus.INVALID
-        } else if (!brain.canDistract(comfortDistraction)) {
-            return ObjectiveStatus.BLOCKED
        } else if (remainingCooldownTicks > 0) {
            remainingCooldownTicks--
            return ObjectiveStatus.ACTIVE
@@ -1,349 +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.ai.biggerbrain.objective
-
-import com.bedrockk.molang.Expression
-import com.cobblemon.mod.common.CobblemonItemComponents
-import com.cobblemon.mod.common.CobblemonItems
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.Priority
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asSimplifiedExpression
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.biggerbrain.LookingTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.MovementStatus
-import com.cobblemon.mod.common.api.ai.biggerbrain.MovementTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.RegularMovementTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.Distraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.DistractionType
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.comfortDistraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.EntityFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.LockFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.LookAndMoveFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.LookingTrackerFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.MovementTrackerFixation
-import com.cobblemon.mod.common.api.ai.config.objective.ObjectiveConfig
-import com.cobblemon.mod.common.api.ai.resolveInt as resolveVariableInt
-import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
-import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
-import com.cobblemon.mod.common.block.entity.NestBlockEntity
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.asExpression
-import com.cobblemon.mod.common.util.mainThreadRuntime
-import com.cobblemon.mod.common.util.resolveFloat
-import com.cobblemon.mod.common.util.withQueryValue
-import com.mojang.datafixers.util.Either
-import net.minecraft.core.BlockPos
-import net.minecraft.server.level.ServerLevel
-import net.minecraft.world.InteractionHand
-import net.minecraft.world.entity.Entity
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.ai.memory.WalkTarget
-import net.minecraft.world.entity.item.ItemEntity
-import net.minecraft.world.item.ItemStack
-import net.minecraft.world.phys.Vec3
-
-class EggRecovery(
-    private val speedMultiplier: Expression = "0.4".asExpression(),
-    private val searchRadius: Int = 20,
-    private val searchIntervalTicks: Int = 20
-) : Objective {
-    private var fixation: EntityFixation? = null
-    private var searchCooldownTicks = 0
-
-    override fun getDescription(entity: LivingEntity) = "Egg Recovery"
-
-    override fun perform(entity: LivingEntity, brain: BiggerBrain, activeObjectiveTags: MutableSet<String>): ObjectiveStatus {
-        if (entity !is PokemonEntity || !entity.isAlive)
-            return ObjectiveStatus.INVALID
-        // so only wild mons recover their eggs
-        if (!entity.pokemon.isWild())
-            return ObjectiveStatus.INACTIVE
-
-        val world = entity.level() as? ServerLevel ?: return ObjectiveStatus.INVALID
-        // get the nest in memory if it exists and check to see if it has an egg
-        val nestPos = brain.getMemory(CobblemonMemories.PATERNAL_NEST_LOCATION) ?: return ObjectiveStatus.INACTIVE
-        if (brain.getMemory(CobblemonMemories.EGG_IN_NEST) != false)
-            return ObjectiveStatus.INACTIVE
-        // if there is a theif they are probably being chased so nothing to do about recovery yet
-        if (brain.hasMemoryValue(CobblemonMemories.EGG_THIEF))
-            return ObjectiveStatus.INACTIVE
-
-        if (brain.isFixation(fixation))
-            return ObjectiveStatus.FIXATED
-        // if egg is held it needs to go back to the nest
-        if (brain.getMemory(CobblemonMemories.HOLDING_EGG) == true)
-            return returnEgg(entity, brain, world, nestPos)
-        // if we have a known egg position then go get it
-        val eggPos = brain.getMemory(CobblemonMemories.EGG_LOCATION)
-        if (eggPos != null)
-            return fetchEgg(entity, brain, world, eggPos)
-        // if any of the above isnt needed then we probably have searching for the egg left
-        return searchForEgg(entity, brain, world, nestPos, activeObjectiveTags)
-    }
-
-    override fun onRegister(entity: LivingEntity, brain: BiggerBrain) {
-        // start with finding the egg if the location is known when we start.
-        // should we have an if statement above this to check if we should search for the egg first or go to the egg? idk
-        brain.subscribe(Priority.LOW, CobblemonMemories.EGG_LOCATION) { eggPos, _ ->
-            if (eggPos != null && fixation is LookAndMoveFixation && brain.isFixation(fixation)) {
-                brain.distract(Distraction.FORCE)
-                fixation = null
-            }
-            true
-        }
-    }
-
-    // look for the egg a while in an area until giving up
-    private fun searchForEgg(entity: PokemonEntity, brain: BiggerBrain, world: ServerLevel, nestPos: BlockPos, activeObjectiveTags: MutableSet<String>): ObjectiveStatus {
-        activeObjectiveTags.add(Objective.OBJECTIVE_TAG_WANDERING)
-        // if the countdown is up then clear objective
-        if (shouldGiveUpSearch(entity, brain, world, nestPos))
-            return ObjectiveStatus.INACTIVE
-        // if our cooldown is active then tick it down
-        if (searchCooldownTicks > 0) {
-            searchCooldownTicks--
-            return ObjectiveStatus.ACTIVE
-        }
-
-        // set the cooldown so it can begin
-        searchCooldownTicks = searchIntervalTicks
-
-        // choose a random spot around the nest to check for the egg todo should we have it also consider last seen egg position? or reincorporate player disturbances?
-        val searchPos = chooseRandomPos(entity, Vec3.atCenterOf(nestPos)) ?: return ObjectiveStatus.ACTIVE
-        if (!brain.distract(comfortDistraction))
-            return ObjectiveStatus.BLOCKED
-        val tracker = RegularMovementTracker.attempt(entity, WalkTarget(searchPos, mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue()).resolveFloat(speedMultiplier), 1)) ?: return ObjectiveStatus.ACTIVE
-        fixation = brain.fixate(
-            LookAndMoveFixation(
-                distractionTypes = setOf(DistractionType.DAMAGE, DistractionType.FORCE, DistractionType.COMFORT),
-                description = "Egg Recovery: searching for the egg",
-                lookingTracker = LookingTracker.fromNavigationPathOrWalkTarget(entity, tracker.walkTarget),
-                movementTracker = tracker
-            )
-        )
-        return ObjectiveStatus.FIXATED
-    }
-
-    // has the search countdown ended and should the nest be abandoned?
-    private fun shouldGiveUpSearch(entity: PokemonEntity, brain: BiggerBrain, world: ServerLevel, nestPos: BlockPos): Boolean {
-        // if there is an active countdown and it isnt at the give up timeframe then don't wipe memories yet
-        if (brain.getMemory(CobblemonMemories.EGG_SEARCH_COUNTDOWN) != true)
-            return false
-        if (entity.brain.getTimeUntilExpiry(CobblemonMemories.EGG_SEARCH_COUNTDOWN) > GIVE_UP_SEARCH_TIME)
-            return false
-        brain.eraseMemory(CobblemonMemories.EGG_SEARCH_COUNTDOWN)
-        brain.eraseMemory(CobblemonMemories.EGG_LOCATION)
-        brain.eraseMemory(CobblemonMemories.PATERNAL_NEST_LOCATION)
-        brain.eraseMemory(CobblemonMemories.EGG_IN_NEST)
-        brain.eraseMemory(CobblemonMemories.POTENTIAL_MATE)
-        val nest = world.getBlockEntity(nestPos) as? NestBlockEntity
-        // clear the parent info on the nest itself if it is still around
-        if (nest != null) {
-            nest.parents = Pair(null, null)
-            nest.nestClaimedBy = Pair(null, null)
-        }
-        return true
-    }
-
-    // path to the egg and pick it up
-    private fun fetchEgg(entity: PokemonEntity, brain: BiggerBrain, world: ServerLevel, eggPos: BlockPos): ObjectiveStatus {
-        val eggCenter = Vec3.atCenterOf(eggPos)
-        if (entity.position().distanceTo(eggCenter) <= CLOSE_ENOUGH_DISTANCE) {
-            pickUpEgg(entity, brain, world)
-            return ObjectiveStatus.ACTIVE
-        }
-        if (!brain.distract(comfortDistraction))
-            return ObjectiveStatus.BLOCKED
-        val tracker = RegularMovementTracker.attempt(entity, WalkTarget(eggCenter, mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue()).resolveFloat(speedMultiplier), 1)) ?: return ObjectiveStatus.ACTIVE
-        fixation = brain.fixate(FetchEggFixation(this, tracker, LookingTracker.fromNavigationPathOrWalkTarget(entity, tracker.walkTarget)))
-        return ObjectiveStatus.FIXATED
-    }
-
-    // pickup egg and put it in "hand" of the mon
-    private fun pickUpEgg(entity: PokemonEntity, brain: BiggerBrain, world: ServerLevel): Boolean {
-        // get any egg item entities that are from the parent and within their pickup radius
-        val eggItem = world.getEntitiesOfClass(ItemEntity::class.java, entity.boundingBox.inflate(PICKUP_REACH)) { item ->
-            item.item.item == CobblemonItems.POKEMON_EGG && item.item.get(CobblemonItemComponents.EGG_DATA)?.isParent(entity.pokemon.uuid) == true
-        }.minByOrNull { it.distanceToSqr(entity) }
-
-        if (eggItem == null) {
-            // the egg isn't where it was last seen so clear location memory
-            brain.eraseMemory(CobblemonMemories.EGG_LOCATION)
-            return false
-        }
-        entity.setItemInHand(InteractionHand.MAIN_HAND, eggItem.item.copy())
-        eggItem.remove(Entity.RemovalReason.DISCARDED)
-        brain.setMemory(CobblemonMemories.HOLDING_EGG, true)
-        brain.eraseMemory(CobblemonMemories.EGG_LOCATION)
-        brain.eraseMemory(CobblemonMemories.EGG_SEARCH_COUNTDOWN)
-        return true
-    }
-
-    // carry the egg back to the nest
-    private fun returnEgg(entity: PokemonEntity, brain: BiggerBrain, world: ServerLevel, nestPos: BlockPos): ObjectiveStatus {
-        // if the nest is gone when trying to bring it back we should maybe drop the egg and stop the objective.... todo or should they just hold the egg forever? build a new nest?
-        if (world.getBlockEntity(nestPos) !is NestBlockEntity) {
-            val heldEgg = entity.getItemInHand(InteractionHand.MAIN_HAND)
-            if (!heldEgg.isEmpty)
-                entity.spawnAtLocation(heldEgg.copy())
-            entity.setItemInHand(InteractionHand.MAIN_HAND, ItemStack.EMPTY)
-            brain.eraseMemory(CobblemonMemories.HOLDING_EGG)
-
-            return ObjectiveStatus.INACTIVE
-        }
-        val nestCenter = Vec3.atCenterOf(nestPos)
-        if (entity.position().distanceTo(nestCenter) <= CLOSE_ENOUGH_DISTANCE) {
-            placeEgg(entity, brain, world, nestPos)
-            return ObjectiveStatus.ACTIVE
-        }
-        // make sure only forced distactions stop the parent from bringing the egg back
-        if (!brain.distract(Distraction.FORCE))
-            return ObjectiveStatus.BLOCKED
-        val tracker = RegularMovementTracker.attempt(entity, WalkTarget(nestCenter, mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue()).resolveFloat(speedMultiplier), 1)) ?: return ObjectiveStatus.ACTIVE
-        fixation = brain.fixate(ReturnEggFixation(this, nestPos, tracker, LookingTracker.fromNavigationPathOrWalkTarget(entity, tracker.walkTarget)))
-        return ObjectiveStatus.FIXATED
-    }
-
-    // place egg in the nest
-    private fun placeEgg(entity: PokemonEntity, brain: BiggerBrain, world: ServerLevel, nestPos: BlockPos): Boolean {
-        val nest = world.getBlockEntity(nestPos) as? NestBlockEntity ?: return false
-        val heldEgg = entity.getItemInHand(InteractionHand.MAIN_HAND)
-
-        // if for some reason the parent is not holding the egg anymore
-        if (heldEgg.isEmpty || heldEgg.item != CobblemonItems.POKEMON_EGG) {
-            brain.eraseMemory(CobblemonMemories.HOLDING_EGG)
-            return false
-        }
-
-        // don't place the egg if the nest is not empty
-        if (!nest.getItem().isEmpty)
-            return false
-
-        nest.setItem(heldEgg.copy())
-        entity.setItemInHand(InteractionHand.MAIN_HAND, ItemStack.EMPTY)
-        brain.eraseMemory(CobblemonMemories.HOLDING_EGG)
-        brain.setMemory(CobblemonMemories.EGG_IN_NEST, true)
-        return true
-    }
-
-    private fun chooseRandomPos(entity: PokemonEntity, center: Vec3): Vec3? {
-        // is this bad for performance? At low numbers I assume it won't be too bad but will need to be tested
-        repeat(SEARCH_ATTEMPTS) {
-            val offsetX = entity.random.nextDouble() * 2 * searchRadius - searchRadius
-            val offsetZ = entity.random.nextDouble() * 2 * searchRadius - searchRadius
-            val blockPos = BlockPos.containing(center.add(offsetX, 0.0, offsetZ))
-            if (entity.navigation.createPath(blockPos, 0) != null)
-                return Vec3.atCenterOf(blockPos)
-        }
-        return null
-    }
-
-    // fixation for walking to the egg and picking it up
-    class FetchEggFixation(
-        private val objective: EggRecovery,
-        override val movementTracker: MovementTracker,
-        override val lookingTracker: LookingTracker
-    ) : EntityFixation, MovementTrackerFixation, LookingTrackerFixation {
-        override fun getDescription(entity: LivingEntity) = "Egg Recovery: going to get egg"
-
-        // if they are hurt or forced they should stop being fixated
-        override fun canDistract(distraction: Distraction, entity: LivingEntity) = distraction.isDamage || distraction.isForce
-
-        // we should stop the moving tracker when distracted (do we need to stop anything else?)
-        override fun onDistract(distraction: Distraction, entity: LivingEntity) {
-            movementTracker.stop()
-        }
-
-        override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
-            if (entity !is PokemonEntity)
-                return false
-
-            val world = entity.level() as? ServerLevel ?: return false
-
-            lookingTracker.tick()
-            when (movementTracker.tick()) {
-                MovementStatus.PENDING -> return true
-                // movement is done (hopefully at the right spot) so try to pickup the egg
-                MovementStatus.COMPLETED -> objective.pickUpEgg(entity, brain, world)
-                // if anything happens try to get a new egg location
-                MovementStatus.FAILED -> brain.eraseMemory(CobblemonMemories.EGG_LOCATION)
-            }
-            return false
-        }
-    }
-
-    // path back to nest and place the egg
-    class ReturnEggFixation(
-        private val objective: EggRecovery,
-        private val nestPos: BlockPos,
-        override val movementTracker: MovementTracker,
-        override val lookingTracker: LookingTracker
-    ) : EntityFixation, MovementTrackerFixation, LookingTrackerFixation, LockFixation {
-        override fun getDescription(entity: LivingEntity) = "Egg Recovery: taking egg back to nest"
-
-        // only force for now but we might want to distract if damaged later
-        override fun canDistract(distraction: Distraction, entity: LivingEntity) = distraction.isForce
-
-        // same as above stop movement if distracted
-        override fun onDistract(distraction: Distraction, entity: LivingEntity) {
-            movementTracker.stop()
-        }
-
-        override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
-            if (entity !is PokemonEntity)
-                return false
-
-            val world = entity.level() as? ServerLevel ?: return false
-
-            lookingTracker.tick()
-            if (movementTracker.tick() == MovementStatus.PENDING)
-                return true
-            if (movementTracker.lastStatus == MovementStatus.COMPLETED)
-                objective.placeEgg(entity, brain, world, nestPos)
-            return false
-        }
-    }
-
-    class Config : ObjectiveConfig {
-        val speedMultiplier: ExpressionOrEntityVariable = Either.left("0.4".asExpression())
-        val searchRadius: ExpressionOrEntityVariable = Either.left("20".asExpression())
-        val searchIntervalTicks: ExpressionOrEntityVariable = Either.left("20".asExpression())
-
-        override fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): List<MoLangConfigVariable> {
-            return listOf(speedMultiplier, searchRadius, searchIntervalTicks).asVariables()
-        }
-
-        override fun create(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): Objective {
-            behaviourConfigurationContext.addMemories(
-                CobblemonMemories.PATERNAL_NEST_LOCATION,
-                CobblemonMemories.EGG_IN_NEST,
-                CobblemonMemories.EGG_LOCATION,
-                CobblemonMemories.EGG_THIEF,
-                CobblemonMemories.EGG_SEARCH_COUNTDOWN,
-                CobblemonMemories.HOLDING_EGG,
-                CobblemonMemories.POTENTIAL_MATE
-            )
-            return EggRecovery(
-                speedMultiplier = speedMultiplier.asSimplifiedExpression(entity),
-                searchRadius = searchRadius.resolveVariableInt(behaviourConfigurationContext.runtime),
-                searchIntervalTicks = searchIntervalTicks.resolveVariableInt(behaviourConfigurationContext.runtime)
-            )
-        }
-    }
-
-    companion object {
-        private const val CLOSE_ENOUGH_DISTANCE = 1.5 // should this be bigger for the bigger mons or be based off of hitbox?
-        private const val PICKUP_REACH = 1.5 // slight radius around the mon so they don't have to physically be on top of the egg
-        private const val SEARCH_ATTEMPTS = 10
-        private const val GIVE_UP_SEARCH_TIME = 20L // is this enough time for search? Needs playtesting
-    }
-}
@@ -1,88 +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.ai.biggerbrain.objective
-
-import com.bedrockk.molang.Expression
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
-import com.cobblemon.mod.common.api.pokemon.status.Statuses
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.pokemon.ai.moves.RealTimeMove
-import com.cobblemon.mod.common.util.asExpression
-import com.cobblemon.mod.common.util.mainThreadRuntime
-import com.cobblemon.mod.common.util.resolveBoolean
-import com.cobblemon.mod.common.util.resolveFloat
-import com.cobblemon.mod.common.util.resolveString
-import com.cobblemon.mod.common.util.withQueryValue
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.ai.memory.MemoryModuleType
-import net.minecraft.world.entity.ai.memory.NearestVisibleLivingEntities
-
-
-abstract class EntityResponseObjective(
-    val speedMultiplier: Expression = "0.5".asExpression(), // How do we transfer speed to the attack behaviour? Do we want to?
-    val engageRange: Expression = "15.0".asExpression(),
-    val disengageRange: Expression = "20.0".asExpression(),
-    val condition: Expression = "true".asExpression(), // Self/environment condition check
-    val targetCondition: Expression = "true".asExpression(), // target condition (will be checked on entity interaction)
-    description: Expression = "'EntityResponseObjective'".asExpression(),
-) : Objective {
-    var trackedEntity: LivingEntity? = null
-    private val objectiveDescription: String = mainThreadRuntime.resolveString(description)
-
-    override fun getDescription(entity: LivingEntity) = objectiveDescription
-
-
-    open fun scanForValidTargets(entity: LivingEntity, brain: BiggerBrain): LivingEntity? {
-
-        //TODO: need to apply some sort of awareness modifier
-        // Sleep obviously should dramatically affect this but it's not hard to imagine other things that could do this
-        if (entity.isSleeping || (entity is PokemonEntity && entity.pokemon.status?.status == Statuses.SLEEP)) {
-            // Also why doesn't entity.isSleeping for PokemonEntities return true if the sleep status is applied?
-            return null
-        }
-
-        // Check if we're in the mood to fight
-        if (mainThreadRuntime.withQueryValue("entity", (entity).asMostSpecificMoLangValue())
-                .resolveBoolean(condition)
-        ) {
-            // Scan visible livingEntities
-            val entities: NearestVisibleLivingEntities =
-                brain.getMemory(MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES) ?: return null
-            val targetEntity = entities.findClosest { it ->
-                val runtime = mainThreadRuntime.withQueryValue("target", (it).asMostSpecificMoLangValue())
-                val isValidTarget =
-                    runtime.resolveBoolean(targetCondition) && runtime.resolveFloat(engageRange) > entity.distanceTo(it)
-                isValidTarget
-            }.orElse(null)
-            if (targetEntity != null) return targetEntity
-        }
-        return null
-    }
-
-    open fun shouldContinue(entity: LivingEntity, brain: BiggerBrain): Boolean {
-        trackedEntity ?: return false
-        if (trackedEntity!!.isDeadOrDying) return false
-        val runtime = mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
-            .withQueryValue("target", (trackedEntity!!).asMostSpecificMoLangValue())
-        return (runtime.resolveBoolean(condition) // self condition
-                && runtime.resolveBoolean(targetCondition) // target condition
-                && (runtime.resolveFloat(disengageRange) > entity.distanceTo(trackedEntity!!)))
-    }
-
-    open fun getRealTimeMoves(entity: LivingEntity) : List<RealTimeMove> {
-        var moves = if (entity is PokemonEntity) entity.pokemon.species.behaviour.combat.moves else emptyList()
-        if (moves.isEmpty() && entity is PokemonEntity) {
-            moves = listOf(
-                if (entity.pokemon.attack > entity.pokemon.specialAttack) RealTimeMove.defaultMelee else RealTimeMove.defaultRange
-            )
-        }
-        return moves
-    }
-}
@@ -9,7 +9,6 @@
 package com.cobblemon.mod.common.api.ai.biggerbrain.objective

 import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.Priority
 import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
 import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
 import com.cobblemon.mod.common.api.ai.asVariables
@@ -32,6 +31,7 @@ import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.asExpression
 import com.mojang.datafixers.util.Either
 import net.minecraft.server.level.ServerLevel
+import net.minecraft.world.damagesource.DamageSource
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.ai.behavior.EntityTracker
 import net.minecraft.world.entity.ai.memory.MemoryModuleType
@@ -109,15 +109,9 @@ class FocusDuringBattle(
        }
    }

-    override fun onRegister(entity: LivingEntity, brain: BiggerBrain) {
-        brain.subscribe(
-            priority = Priority.LOW,
-            memory = MemoryModuleType.HURT_BY
-        ) { value, labels ->
-            if (brain.isFixation(fixation) && value != null && stopBattleIfHurt) {
-                brain.distract(HurtDistraction(value))
-            }
-            return@subscribe true
+    override fun <T> onMemoryChanged(entity: LivingEntity, brain: BiggerBrain, memory: MemoryModuleType<T>, value: T?) {
+        if (brain.isFixation(fixation) && memory == MemoryModuleType.HURT_BY && value != null && stopBattleIfHurt) {
+            brain.distract(HurtDistraction(value as DamageSource))
        }
    }

@@ -1,258 +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.ai.biggerbrain.objective
-
-import com.bedrockk.molang.Expression
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.Priority
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asSimplifiedExpression
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.*
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.Distraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.DistractionType
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.comfortDistraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.idleBoredomDistraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.EntityFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.LookAndMoveFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.LookingTrackerFixation
-import com.cobblemon.mod.common.api.ai.config.objective.ObjectiveConfig
-import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
-import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.*
-import com.mojang.datafixers.util.Either
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.PathfinderMob
-import net.minecraft.world.entity.ai.behavior.EntityTracker
-import net.minecraft.world.entity.ai.memory.MemoryModuleType
-import net.minecraft.world.entity.ai.memory.NearestVisibleLivingEntities
-import net.minecraft.world.entity.ai.memory.WalkTarget
-
-
-class FriendlyBehaviour(
-    speedMultiplier: Expression = "0.5".asExpression(), // How do we transfer speed to the attack behaviour? Do we want to?
-     engageRange: Expression = "10.0".asExpression(),
-    disengageRange: Expression = "20.0".asExpression(),
-    condition: Expression = "true".asExpression(),
-    targetCondition: Expression = "false".asExpression(),
-    private val maxDuration: Expression = "300".asExpression(),
-    private val description: Expression = "Friendly Behaviour".asExpression(),
-) : EntityResponseObjective(
-    speedMultiplier = speedMultiplier, // How do we transfer speed to the attack behaviour? Do we want to?
-    engageRange = engageRange,
-    disengageRange = disengageRange,
-    condition = condition, // Self/environment condition check
-    targetCondition = targetCondition, // target condition (will be checked on entity interaction)
-    description = description,
-) {
-    private var remainingCooldownTicks = 0
-    private var fixation: EntityFixation? = null
-    override val observedMemories = listOf(MemoryModuleType.HURT_BY_ENTITY)
-    private val closeEnoughDistance = 1.5
-    private var remainingTicks = 0
-
-
-    override fun perform(
-        entity: LivingEntity,
-        brain: BiggerBrain,
-        activeObjectiveTags: MutableSet<String>
-    ): ObjectiveStatus {
-        if (entity !is PokemonEntity || !entity.isAlive) return ObjectiveStatus.INVALID
-
-        if (remainingCooldownTicks > 0) {
-            remainingCooldownTicks--
-            return if (brain.isFixation(fixation)) ObjectiveStatus.FIXATED else ObjectiveStatus.INACTIVE
-        } else {
-            remainingCooldownTicks = 5
-        }
-
-        if (brain.isFixation(fixation)) {
-            if (remainingTicks > 0) {
-                remainingTicks--
-            } else {
-                // Got bored, move on
-                brain.distract(Distraction.FORCE)
-                trackedEntity = null
-                fixation = null
-            }
-            if (trackedEntity != null) {
-                // Check if we continue
-                return attemptFixation(entity, brain)
-
-            } else {
-                trackedEntity = null
-                fixation = null
-                brain.distract(comfortDistraction)
-            }
-            return ObjectiveStatus.FIXATED
-        } else {
-            // Scan visible livingEntities
-            val targetEntity = scanForValidTargets(entity, brain)
-
-            if (targetEntity != null) {
-                trackedEntity = targetEntity
-                val status = attemptFixation(entity, brain)
-                if (status == ObjectiveStatus.FIXATED) {
-                    remainingTicks = mainThreadRuntime.resolveInt(maxDuration)
-                }
-                return status
-            }
-
-            return if (trackedEntity != null) ObjectiveStatus.ACTIVE else ObjectiveStatus.INACTIVE
-        }
-    }
-
-    fun attemptFixation(entity: PathfinderMob, brain: BiggerBrain) : ObjectiveStatus {
-        if (trackedEntity != null) {
-            // Check if we continue
-            val runtime = mainThreadRuntime.withQueryValue("entity", (entity).asMostSpecificMoLangValue())
-                .withQueryValue("target", trackedEntity!!.asMostSpecificMoLangValue())
-            val distance = entity.distanceTo(trackedEntity!!)
-            if (runtime.resolveFloat(disengageRange) < distance || !shouldContinue(entity, brain)) {
-                brain.distract(comfortDistraction)
-                trackedEntity = null
-                fixation = null
-                return ObjectiveStatus.INACTIVE
-            } else if (distance <= closeEnoughDistance && !(brain.isFixation(fixation) && fixation is IdleLookFixation)) {
-                // transition to look
-                val distraction = if(brain.isFixation(fixation)) Distraction.FORCE else idleBoredomDistraction
-                if (brain.distract(distraction)) {
-                    this.fixation = brain.fixate(
-                        IdleLookFixation(
-                            LookingTracker(
-                                entity,
-                                EntityTracker(trackedEntity!!, true)
-                            ),
-                            remainingTicks
-                        )
-                    )
-                    return ObjectiveStatus.FIXATED
-                } else {
-                    // could not distract
-                    return ObjectiveStatus.BLOCKED
-                }
-            } else if (distance > closeEnoughDistance && !(brain.isFixation(fixation) && fixation is LookAndMoveFixation)) {
-                // transition to walk
-                val distraction = if(brain.isFixation(fixation)) Distraction.FORCE else idleBoredomDistraction
-                if (brain.distract(distraction)) {
-                    val walkTarget =
-                        WalkTarget(EntityTracker(trackedEntity!!, true), runtime.resolveFloat(speedMultiplier), 0)
-                    val movementTracker = RegularMovementTracker.attempt(entity, walkTarget)
-                        ?: return ObjectiveStatus.INACTIVE
-                    this.fixation = brain.fixate(
-                        LookAndMoveFixation(
-                            description = "Following targeted entity",
-                            distractionTypes = setOf(
-                                DistractionType.COMFORT,
-                                DistractionType.DAMAGE,
-                                DistractionType.FORCE
-                            ),
-                            lookingTracker = LookingTracker.forTargetEntity(entity, trackedEntity!!),
-                            movementTracker = movementTracker,
-                            onMovementComplete = { _, _ -> attemptFixation(entity, brain) } // maintains fixation between moving and looking
-                        )
-                    )
-                    return ObjectiveStatus.FIXATED
-                } else {
-                    return ObjectiveStatus.BLOCKED
-                }
-
-            } else {
-                return ObjectiveStatus.FIXATED
-            }
-        }
-        return ObjectiveStatus.INACTIVE
-    }
-
-    class IdleLookFixation(
-        override val lookingTracker: LookingTracker?,
-        var remainingTicks: Int,
-    ) : EntityFixation, LookingTrackerFixation {
-
-
-        override fun getDescription(entity: LivingEntity): String {
-            return "Looking at a nearby entity ($remainingTicks ticks left)"
-        }
-
-        override fun canDistract(distraction: Distraction, entity: LivingEntity): Boolean {
-            return !distraction.isIdleBoredom
-        }
-
-        override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
-            val targetEntity = lookingTracker?.entity ?: return false
-            if ((targetEntity.isRemoved) || entity !is PathfinderMob) {
-                return false
-            }
-            val lookingTracker = lookingTracker
-            remainingTicks--
-            lookingTracker.tick()
-            return remainingTicks > 0
-        }
-    }
-
-    override fun onRegister(entity: LivingEntity, brain: BiggerBrain) {
-        brain.subscribe(
-            priority = Priority.LOW,
-            memory = CobblemonMemories.ATTACK_TARGET_DATA
-        ) { value, labels ->
-            if (value != null) {
-                val livingEntity = brain.getMemory(MemoryModuleType.ATTACK_TARGET) ?: return@subscribe true
-                if (trackedEntity?.uuid == livingEntity.uuid) {
-                    // We smacked them, refresh our attack timer
-                    val runtime = mainThreadRuntime.withQueryValue("entity", (livingEntity).asMostSpecificMoLangValue())
-                    val attackDuration = runtime.resolveInt(maxDuration)
-                    brain.setMemory(MemoryModuleType.ATTACK_TARGET, livingEntity, attackDuration.toLong())
-                }
-            }
-            return@subscribe true
-        }
-    }
-
-    class Config : ObjectiveConfig {
-        val speedMultiplier: ExpressionOrEntityVariable = Either.left("0.5".asExpression())
-        val engageRange: ExpressionOrEntityVariable = Either.left("10.0".asExpression())
-        val disengageRange: ExpressionOrEntityVariable = Either.left("20.0".asExpression())
-        val condition: ExpressionOrEntityVariable = Either.left("true".asExpression())
-        val targetCondition: ExpressionOrEntityVariable = Either.left("true".asExpression())
-        val maxDuration: ExpressionOrEntityVariable = Either.left("300".asExpression())
-        val description: ExpressionOrEntityVariable = Either.left("Test".asExpression())
-
-        override fun getVariables(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ): List<MoLangConfigVariable> {
-            return listOf(
-                condition,
-                targetCondition,
-                speedMultiplier,
-                engageRange,
-                disengageRange,
-                maxDuration,
-                description,
-            ).asVariables()
-        }
-
-        override fun create(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ): Objective {
-            return FriendlyBehaviour(
-                condition = condition.asSimplifiedExpression(entity),
-                targetCondition = targetCondition.asSimplifiedExpression(entity),
-                speedMultiplier = speedMultiplier.asSimplifiedExpression(entity),
-                engageRange = engageRange.asSimplifiedExpression(entity),
-                disengageRange = disengageRange.asSimplifiedExpression(entity),
-                maxDuration = maxDuration.asSimplifiedExpression(entity),
-                description = description.asSimplifiedExpression(entity)
-            )
-        }
-    }
-}
@@ -35,7 +35,7 @@ import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.ai.memory.MemoryModuleType

 /**
- * Sleeps the entity.
+ * Randomly looks at nearby entities out of curiosity. Very easily distracted once doing so.
 *
 * @author Hiroku
 * @since December 29th, 2025
@@ -1,177 +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.ai.biggerbrain.objective
-
-import com.bedrockk.molang.Expression
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.Priority
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asSimplifiedExpression
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.DistractionType
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.AttackFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.EntityFixation
-import com.cobblemon.mod.common.api.ai.config.objective.ObjectiveConfig
-import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
-import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.asExpression
-import com.cobblemon.mod.common.util.mainThreadRuntime
-import com.cobblemon.mod.common.util.resolveBoolean
-import com.cobblemon.mod.common.util.resolveFloat
-import com.cobblemon.mod.common.util.resolveInt
-import com.cobblemon.mod.common.util.withQueryValue
-import com.mojang.datafixers.util.Either
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.ai.memory.MemoryModuleType
-
-
-class NeutralBehaviour(
-    speedMultiplier: Expression = "0.5".asExpression(), // How do we transfer speed to the attack behaviour? Do we want to?
-    engageRange: Expression = "5.0".asExpression(),
-    disengageRange: Expression = "20.0".asExpression(),
-    condition: Expression = "true".asExpression(),
-    targetCondition: Expression = "true".asExpression(), // target condition (will be checked on entity interaction)
-    description: Expression = "'Neutral Behaviour'".asExpression(),
-    private val maxAttackDuration: Expression = "300".asExpression(),
-    private val retaliationHitCount: Expression = "1".asExpression()
-) : EntityResponseObjective(
-    speedMultiplier = speedMultiplier, // How do we transfer speed to the attack behaviour? Do we want to?
-    engageRange = engageRange,
-    disengageRange = disengageRange,
-    condition = condition, // Self/environment condition check
-    targetCondition = targetCondition, // target condition (will be checked on entity interaction)
-    description = description,
-) {
-    override val observedMemories = listOf(MemoryModuleType.HURT_BY_ENTITY, CobblemonMemories.ATTACK_TARGET_DATA)
-    private var fixation: EntityFixation? = null
-
-    override fun perform(
-        entity: LivingEntity,
-        brain: BiggerBrain,
-        activeObjectiveTags: MutableSet<String>
-    ): ObjectiveStatus {
-        if (entity !is PokemonEntity || !entity.isAlive) return ObjectiveStatus.INVALID
-
-        if (trackedEntity != null) {
-            val attackTarget = brain.getMemory(MemoryModuleType.ATTACK_TARGET)
-            val avoidTarget = brain.getMemory(MemoryModuleType.AVOID_TARGET)
-            if (attackTarget != null && trackedEntity?.uuid == attackTarget.uuid) {
-                // Check if we continue
-                return ObjectiveStatus.ACTIVE
-            } else if (avoidTarget != null && trackedEntity?.uuid === avoidTarget.uuid) {
-                // Check if we continue
-                val runtime = mainThreadRuntime.withQueryValue("entity", (trackedEntity!!).asMostSpecificMoLangValue())
-                val disengageDistance = runtime.resolveFloat(disengageRange)
-                if (disengageDistance < entity.distanceTo(trackedEntity!!)) {
-                    brain.eraseMemory(MemoryModuleType.AVOID_TARGET)
-                    trackedEntity = null
-                }
-            } else {
-                // Something has overridden us
-                trackedEntity = null
-            }
-        }
-
-
-        return if (trackedEntity != null) ObjectiveStatus.ACTIVE else ObjectiveStatus.INACTIVE
-    }
-
-    override fun onRegister(entity: LivingEntity, brain: BiggerBrain) {
-        brain.subscribe(
-            priority = Priority.LOW,
-            memory = MemoryModuleType.HURT_BY_ENTITY
-        ) { value, labels ->
-            if (value != null) {
-                // Something just smacked us, see if we should get mad about it.
-                val livingEntity = value
-                val runtime = mainThreadRuntime.withQueryValue("entity", (livingEntity).asMostSpecificMoLangValue())
-                val shouldTarget = runtime.resolveBoolean(condition)
-                if (shouldTarget && brain.fixation !is AttackFixation) {
-                    brain.setMemory(
-                        MemoryModuleType.ATTACK_TARGET, livingEntity,
-                        runtime.resolveInt(maxAttackDuration).toLong()
-                    )
-                    brain.eraseMemory(MemoryModuleType.AVOID_TARGET)
-                    trackedEntity = livingEntity
-                    fixation = brain.fixate(
-                        AttackFixation(
-                            targetEntity = trackedEntity!!,
-                            speedMultiplier = speedMultiplier,
-                            distractionTypes =  setOf(DistractionType.FORCE),
-                            availableMoves = getRealTimeMoves(entity)
-                        )
-                    )
-                }
-            }
-            return@subscribe true
-        }
-
-        brain.subscribe(
-            priority = Priority.LOW,
-            memory = CobblemonMemories.ATTACK_TARGET_DATA
-        ) { value, labels ->
-            if (value != null) {
-                // We smacked them, check if it's time for tactical retreat
-                val attackData = value
-                val livingEntity = brain.getMemory(MemoryModuleType.ATTACK_TARGET) ?: return@subscribe true
-                val runtime = mainThreadRuntime.withQueryValue("entity", (livingEntity).asMostSpecificMoLangValue())
-                if (attackData.hitsLanded >= runtime.resolveInt(retaliationHitCount)) {
-                    // Justice served, carry on
-                    brain.eraseMemory(MemoryModuleType.ATTACK_TARGET)
-                    brain.eraseMemory(CobblemonMemories.ATTACK_TARGET_DATA)
-                    brain.setMemory(MemoryModuleType.AVOID_TARGET, trackedEntity)
-                }
-            }
-            return@subscribe true
-        }
-    }
-
-    class Config : ObjectiveConfig {
-        val speedMultiplier: ExpressionOrEntityVariable = Either.left("0.5".asExpression())
-        val engageRange: ExpressionOrEntityVariable = Either.left("10.0".asExpression())
-        val disengageRange: ExpressionOrEntityVariable = Either.left("10.0".asExpression())
-        val condition: ExpressionOrEntityVariable = Either.left("true".asExpression())
-        val targetCondition: ExpressionOrEntityVariable = Either.left("false".asExpression())
-        val maxAttackDuration: ExpressionOrEntityVariable = Either.left("300".asExpression())
-        val retaliationHitCount: ExpressionOrEntityVariable = Either.left("1".asExpression())
-        val description: ExpressionOrEntityVariable = Either.left("'Neutral Behaviour'".asExpression())
-        override fun getVariables(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ): List<MoLangConfigVariable> {
-            return listOf(
-                condition,
-                targetCondition,
-                engageRange,
-                disengageRange,
-                retaliationHitCount,
-                description
-            ).asVariables()
-        }
-
-        override fun create(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ): Objective {
-            return NeutralBehaviour(
-                condition = condition.asSimplifiedExpression(entity),
-                targetCondition = condition.asSimplifiedExpression(entity),
-                speedMultiplier = speedMultiplier.asSimplifiedExpression(entity),
-                engageRange = engageRange.asSimplifiedExpression(entity),
-                disengageRange = disengageRange.asSimplifiedExpression(entity),
-                maxAttackDuration = maxAttackDuration.asSimplifiedExpression(entity),
-                description = description.asSimplifiedExpression(entity),
-                retaliationHitCount = retaliationHitCount.asSimplifiedExpression(entity),
-            )
-        }
-    }
-}
@@ -37,6 +37,12 @@ interface Objective {
    fun getDescription(entity: LivingEntity): String
    /** Performs this objective's logic for a tick. */
    fun perform(entity: LivingEntity, brain: BiggerBrain, activeObjectiveTags: MutableSet<String>): ObjectiveStatus
-    /** Runs when an objective is added to a [BiggerBrain]. Prime opportunity to register memory subscriptions. */
-    fun onRegister(entity: LivingEntity, brain: BiggerBrain) {}
+
+    /**
+     * A subscription handler called for when a memory is set or removed (not expired). For a memory to trigger this
+     * function, it must be in [observedMemories].
+     */
+    fun <T> onMemoryChanged(entity: LivingEntity, brain: BiggerBrain, memory: MemoryModuleType<T>, value: T?) {
+        // Default implementation does nothing
+    }
 }
@@ -1,113 +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.ai.biggerbrain.objective
-
-import com.bedrockk.molang.Expression
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asSimplifiedExpression
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.config.objective.ObjectiveConfig
-import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.asExpression
-import com.mojang.datafixers.util.Either
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.ai.memory.MemoryModuleType
-
-class SkittishBehaviour(
-    engageRange: Expression = "5.0".asExpression(),
-    disengageRange: Expression = "20.0".asExpression(),
-    condition: Expression = "true".asExpression(),
-    targetCondition: Expression = "false".asExpression(),
-    description: Expression = "'Skittish Behaviour'".asExpression(),
-    ) : EntityResponseObjective(
-//    speedMultiplier = speedMultiplier, // How do we transfer speed to the attack behaviour? Do we want to?
-    engageRange = engageRange,
-    disengageRange = disengageRange,
-    condition = condition, // Self/environment condition check
-    targetCondition = targetCondition, // target condition (will be checked on entity interaction)
-    description = description,
-) {
-    private var remainingCooldownTicks = 0
-    override val observedMemories = listOf(MemoryModuleType.HURT_BY_ENTITY, CobblemonMemories.ATTACK_TARGET_DATA)
-
-    override fun perform(
-        entity: LivingEntity,
-        brain: BiggerBrain,
-        activeObjectiveTags: MutableSet<String>
-    ): ObjectiveStatus {
-        if (entity !is PokemonEntity || !entity.isAlive) return ObjectiveStatus.INVALID
-
-        val avoidTarget = brain.getMemory(MemoryModuleType.AVOID_TARGET)
-
-        if (trackedEntity != null) {
-            if (avoidTarget != null && trackedEntity?.uuid === avoidTarget.uuid) {
-                // Check if we continue
-                if(!shouldContinue(entity, brain)) {
-                    brain.eraseMemory(MemoryModuleType.AVOID_TARGET)
-                    trackedEntity = null
-                }
-            } else {
-                // Something has overridden us
-                trackedEntity = null
-            }
-        } else {
-            // Scan visible livingEntities
-            val targetedEntity = scanForValidTargets(entity, brain)
-            if (targetedEntity != null) {
-                trackedEntity = targetedEntity
-                brain.setMemory(MemoryModuleType.AVOID_TARGET, trackedEntity)
-            }
-        }
-
-
-        if (remainingCooldownTicks > 0) {
-            remainingCooldownTicks--
-        }
-
-        return if (trackedEntity != null) ObjectiveStatus.ACTIVE else ObjectiveStatus.INACTIVE
-    }
-
-
-    class Config : ObjectiveConfig {
-        val engageRange: ExpressionOrEntityVariable = Either.left("10.0".asExpression())
-        val disengageRange: ExpressionOrEntityVariable = Either.left("10.0".asExpression())
-        val condition: ExpressionOrEntityVariable = Either.left("true".asExpression())
-        val targetCondition: ExpressionOrEntityVariable = Either.left("false".asExpression())
-        val description: ExpressionOrEntityVariable = Either.left("'Skittish Behaviour'".asExpression())
-        override fun getVariables(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ): List<MoLangConfigVariable> {
-            return listOf(
-                condition,
-                targetCondition,
-                engageRange,
-                disengageRange,
-                description,
-            ).asVariables()
-        }
-
-        override fun create(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ): Objective {
-            return SkittishBehaviour(
-                condition = condition.asSimplifiedExpression(entity),
-                targetCondition = targetCondition.asSimplifiedExpression(entity),
-                engageRange = engageRange.asSimplifiedExpression(entity),
-                disengageRange = disengageRange.asSimplifiedExpression(entity),
-                description = description.asSimplifiedExpression(entity)
-            )
-        }
-    }
-}
@@ -1,258 +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.ai.biggerbrain.objective
-
-import com.bedrockk.molang.Expression
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.Priority
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asSimplifiedExpression
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.biggerbrain.LookingTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.Distraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.DistractionType
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.AttackFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.EntityFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.LookAndLockFixation
-import com.cobblemon.mod.common.api.ai.config.objective.ObjectiveConfig
-import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
-import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.asExpression
-import com.cobblemon.mod.common.util.mainThreadRuntime
-import com.cobblemon.mod.common.util.resolveBoolean
-import com.cobblemon.mod.common.util.resolveFloat
-import com.cobblemon.mod.common.util.resolveInt
-import com.cobblemon.mod.common.util.resolveString
-import com.cobblemon.mod.common.util.withQueryValue
-import com.mojang.datafixers.util.Either
-import com.sun.jna.Memory
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.ai.memory.MemoryModuleType
-
-class TerritorialBehaviour(
-    speedMultiplier: Expression = "0.5".asExpression(), // How do we transfer speed to the attack behaviour? Do we want to?
-    val attackRange: Expression = "3.0".asExpression(),
-    engageRange: Expression = "10.0".asExpression(),
-    disengageRange: Expression = "15.0".asExpression(),
-    condition: Expression = "true".asExpression(), // Self/environment condition check
-    targetCondition: Expression = "true".asExpression(), // target condition (will be checked on entity interaction)
-    description: Expression = "'Territorial Behaviour'".asExpression(),
-    val maxAttackDuration: Expression = "300".asExpression(),
-) : EntityResponseObjective(
-    speedMultiplier = speedMultiplier, // How do we transfer speed to the attack behaviour? Do we want to?
-    engageRange = engageRange,
-    disengageRange = disengageRange,
-    condition = condition, // Self/environment condition check
-    targetCondition = targetCondition, // target condition (will be checked on entity interaction)
-    description = description,
-) {
-
-    private var remainingCooldownTicks = 0
-    private val objectiveDescription: String = mainThreadRuntime.resolveString(description)
-    override val observedMemories = listOf(MemoryModuleType.HURT_BY_ENTITY, CobblemonMemories.ATTACK_TARGET_DATA)
-    private var cryCooldownTicks = 0
-    private var proximityAttackCooldown = 0
-    private var satiationHitCount = 999
-    private var fixation : EntityFixation? = null
-
-    override fun getDescription(entity: LivingEntity) = objectiveDescription
-
-    override fun perform(
-        entity: LivingEntity,
-        brain: BiggerBrain,
-        activeObjectiveTags: MutableSet<String>
-    ): ObjectiveStatus {
-        if (entity !is PokemonEntity || entity.isDeadOrDying) return ObjectiveStatus.INVALID
-        if (brain.getMemory(MemoryModuleType.AVOID_TARGET) != null) {
-            return ObjectiveStatus.BLOCKED
-        }
-
-        val attackTarget = brain.getMemory(MemoryModuleType.ATTACK_TARGET)
-        if (trackedEntity != null) {
-            if (shouldContinue(entity, brain)) {
-
-                // tick behaviour cooldowns
-                if (proximityAttackCooldown > 0) proximityAttackCooldown--
-                if (cryCooldownTicks > 0) cryCooldownTicks--
-
-                if (attackTarget == null) {
-                    // approach, cry, or fight
-                    val runtime = mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
-                        .withQueryValue("target", trackedEntity!!.asMostSpecificMoLangValue())
-                    val distanceToTarget = entity.distanceTo(trackedEntity!!)
-                    val _attackRange = runtime.resolveFloat(attackRange)
-                    if (_attackRange > distanceToTarget && proximityAttackCooldown <= 0) {
-                        // give em a warning shot
-                        val attackDuration = runtime.resolveInt(maxAttackDuration)
-                        satiationHitCount = 1
-                        brain.setMemory(MemoryModuleType.ATTACK_TARGET, trackedEntity, attackDuration.toLong())
-                        fixation = brain.fixate(
-                            AttackFixation(
-                                targetEntity = trackedEntity!!,
-                                speedMultiplier = speedMultiplier,
-                                distractionTypes =  setOf(DistractionType.FORCE),
-                                availableMoves = getRealTimeMoves(entity)
-                            )
-                        )
-                    } else {
-                        // be unhappy about it.
-                        if (cryCooldownTicks <= 0) {
-                            entity.cry()
-                            cryCooldownTicks = CRY_COOLDOWN_TICKS + entity.level().random.nextInt(CRY_COOLDOWN_RANDOM_TICKS)
-                        }
-                        if (!brain.isFixation(fixation) && brain.fixation !is LookAndLockFixation) {
-                            if (brain.distract(Distraction.FORCE)) {
-                                fixation = brain.fixate(
-                                    LookAndLockFixation(
-                                        distractionTypes = setOf(DistractionType.FORCE, DistractionType.DAMAGE),
-                                        lookingTracker = LookingTracker.forTargetEntity(entity, trackedEntity!!, trackEyeHeight = true),
-                                        condition = { true }
-                                    )
-                                )
-                            }
-                        }
-                    }
-                } else {
-                    if (attackTarget.uuid != trackedEntity?.uuid) {
-                        // Something has overridden us and independently set the attack target
-                        trackedEntity = null
-                        return ObjectiveStatus.BLOCKED
-                    }
-                }
-            } else {
-                trackedEntity = null
-            }
-        } else {
-            // No active target
-            if (remainingCooldownTicks > 0) {
-                remainingCooldownTicks--
-                return ObjectiveStatus.INACTIVE
-            } else {
-                remainingCooldownTicks = 20
-            }
-            val targetEntity = scanForValidTargets(entity, brain)
-            if (targetEntity != null) {
-                cryCooldownTicks = 0
-                proximityAttackCooldown = 0
-                trackedEntity = targetEntity
-            }
-
-        }
-        return if (trackedEntity != null) ObjectiveStatus.ACTIVE else ObjectiveStatus.INACTIVE
-    }
-
-    override fun onRegister(entity: LivingEntity, brain: BiggerBrain) {
-        // TODO: handle conflicts between different behaviours
-        brain.subscribe(
-            priority = Priority.LOW,
-            memory = CobblemonMemories.ATTACK_TARGET_DATA
-        ) { value, labels ->
-            if (value != null) {
-                val livingEntity = brain.getMemory(MemoryModuleType.ATTACK_TARGET) ?: return@subscribe true
-                if (trackedEntity?.uuid == livingEntity.uuid) {
-                    val attackData = value
-                    if (attackData.hitsLanded >= satiationHitCount) {
-                        // Justice served, give the fool a chance to back off
-                        proximityAttackCooldown = PROXIMITY_AGGRO_COOLDOWN_TICKS
-                        brain.eraseMemory(CobblemonMemories.ATTACK_TARGET_DATA)
-                        brain.eraseMemory(MemoryModuleType.ATTACK_TARGET)
-                    } else {
-                        // We smacked them, refresh our attack timer
-                        val runtime = mainThreadRuntime.withQueryValue("entity", (livingEntity).asMostSpecificMoLangValue())
-                        val attackDuration = runtime.resolveInt(maxAttackDuration)
-                        brain.setMemory(MemoryModuleType.ATTACK_TARGET, livingEntity, attackDuration.toLong())
-                    }
-                }
-            }
-            return@subscribe true
-        }
-
-        brain.subscribe(
-            priority = Priority.LOW,
-            memory = MemoryModuleType.HURT_BY_ENTITY
-        ) { value, labels ->
-            // Of course you know this means war.
-            if (value != null) {
-                // Something just smacked us, see if we should get mad about it.
-                val livingEntity = value
-                val runtime = mainThreadRuntime.withQueryValue("entity", (entity).asMostSpecificMoLangValue())
-                    .withQueryValue("target", livingEntity.asMostSpecificMoLangValue())
-                val shouldTarget = runtime.resolveBoolean(condition) && runtime.resolveBoolean(targetCondition)
-                if (shouldTarget && brain.distract(Distraction.FORCE)) {
-                    brain.setMemory(
-                        MemoryModuleType.ATTACK_TARGET, livingEntity,
-                        runtime.resolveInt(maxAttackDuration).toLong()
-                    )
-                    satiationHitCount = 999
-                    trackedEntity = livingEntity
-                    fixation = brain.fixate(
-                        AttackFixation(
-                            targetEntity = trackedEntity!!,
-                            speedMultiplier = speedMultiplier,
-                            distractionTypes =  setOf(DistractionType.FORCE),
-                            availableMoves = getRealTimeMoves(entity)
-                        )
-                    )
-                }
-            }
-            return@subscribe true
-        }
-    }
-
-    companion object {
-        val CRY_COOLDOWN_TICKS = 75
-        val CRY_COOLDOWN_RANDOM_TICKS = 50
-        val PROXIMITY_AGGRO_COOLDOWN_TICKS = 75
-    }
-
-    class Config : ObjectiveConfig {
-        val speedMultiplier: ExpressionOrEntityVariable = Either.left("0.5".asExpression())
-        val attackRange: ExpressionOrEntityVariable = Either.left("7.0".asExpression())
-        val engageRange: ExpressionOrEntityVariable = Either.left("13.0".asExpression())
-        val disengageRange: ExpressionOrEntityVariable = Either.left("15.0".asExpression())
-        val condition: ExpressionOrEntityVariable = Either.left("true".asExpression())
-        val targetCondition: ExpressionOrEntityVariable = Either.left("false".asExpression())
-        val maxAttackDuration: ExpressionOrEntityVariable = Either.left("300".asExpression())
-        val description: ExpressionOrEntityVariable = Either.left("'Territorial Behaviour'".asExpression())
-        override fun getVariables(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ): List<MoLangConfigVariable> {
-            return listOf(
-                condition,
-                targetCondition,
-                speedMultiplier,
-                attackRange,
-                engageRange,
-                disengageRange,
-                maxAttackDuration,
-                description
-            ).asVariables()
-        }
-
-        override fun create(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ): Objective {
-            return TerritorialBehaviour(
-                condition = condition.asSimplifiedExpression(entity),
-                targetCondition = targetCondition.asSimplifiedExpression(entity),
-                speedMultiplier = speedMultiplier.asSimplifiedExpression(entity),
-                attackRange = attackRange.asSimplifiedExpression(entity),
-                engageRange = engageRange.asSimplifiedExpression(entity),
-                disengageRange = disengageRange.asSimplifiedExpression(entity),
-                maxAttackDuration = maxAttackDuration.asSimplifiedExpression(entity),
-                description = description.asSimplifiedExpression(entity)
-            )
-        }
-    }
-}
@@ -1,127 +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.ai.biggerbrain.objective
-
-
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.biggerbrain.LookingTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.MovementTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.RegularMovementTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.Distraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.DistractionType
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.comfortDistraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.idleBoredomDistraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.EntityFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.LookAndMoveFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.MovementTrackerFixation
-import com.cobblemon.mod.common.api.ai.config.objective.ObjectiveConfig
-import com.cobblemon.mod.common.api.ai.resolveFloat
-import com.cobblemon.mod.common.api.ai.resolveInt
-import com.cobblemon.mod.common.entity.PoseType
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.entity.pokemon.ai.PokemonMoveControl
-import com.cobblemon.mod.common.util.asExpression
-import com.mojang.datafixers.util.Either
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.PathfinderMob
-import net.minecraft.world.entity.ai.behavior.EntityTracker
-import net.minecraft.world.entity.ai.memory.MemoryModuleType
-import net.minecraft.world.entity.ai.memory.WalkTarget
-
-/**
- * Walk towards parent of same species objective
- */
-class WalkTowardsParent(
-    val minRange: Int,
-    val maxRange: Int,
-    val speed: Float
-) : Objective {
-    var fixation: EntityFixation? = null
-    var cooldownTicks = 0
-
-    override fun getDescription(entity: LivingEntity) = "Following parent species"
-
-    override fun perform(
-        entity: LivingEntity,
-        brain: BiggerBrain,
-        activeObjectiveTags: MutableSet<String>
-    ): ObjectiveStatus {
-        if (entity !is PokemonEntity) {
-            return ObjectiveStatus.INVALID // its gotta be a pokemon to have a parent species
-        } else if (brain.isFixation(fixation)) {
-            return ObjectiveStatus.FIXATED // we are already fixated on this objectives fixation
-        } else if (brain.fixation != null) {
-            fixation = null // our brain has chosen another fixation
-        }
-
-        // Check to see if the cooldown has been completed
-        // TODO: should cooldown checks happen first? Do we only want them ticked down
-        if (cooldownTicks > 0) {
-            cooldownTicks--
-            return ObjectiveStatus.INACTIVE
-        }
-
-        // if no trusted adult is around then the objective is inactive
-        val adult = brain.getMemory(MemoryModuleType.NEAREST_VISIBLE_ADULT) ?: return ObjectiveStatus.INACTIVE
-
-        // If we are too close or too far then don't follow
-        // TODO: the too far doesn't make that much sense to me. We don't want it treating it as a herd?
-        val dist = entity.distanceTo(adult)
-        if (dist > maxRange + 1 || dist < minRange) return ObjectiveStatus.INACTIVE
-
-        // Can we comfort ourselves?
-        if (!brain.distract(comfortDistraction)) return ObjectiveStatus.BLOCKED
-
-        // Get our walk target and movement tracker
-        val walkTarget = WalkTarget(EntityTracker(adult, false), speed, minRange - 1)
-        val movementTracker = RegularMovementTracker.attempt(entity as PathfinderMob, walkTarget)
-            ?: return ObjectiveStatus.INACTIVE
-
-        this.fixation = brain.fixate(
-            LookAndMoveFixation(
-                description = "Following parent",
-                distractionTypes = setOf(DistractionType.DAMAGE, DistractionType.FORCE), // We are very fine to ignore this movement if forced or hurt
-                lookingTracker = LookingTracker.forTargetEntity(entity, adult),
-                movementTracker = movementTracker,
-                onMovementComplete = { _, _ -> cooldownTicks = 60 }
-            )
-        )
-        return ObjectiveStatus.FIXATED // We are now fixated on
-    }
-
-    class Config : ObjectiveConfig {
-        val minRange: ExpressionOrEntityVariable = Either.left("5".asExpression())
-        val maxRange: ExpressionOrEntityVariable = Either.left("16".asExpression())
-        val speed: ExpressionOrEntityVariable = Either.left("0.4".asExpression())
-
-        override fun getVariables(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ) = listOf(
-            minRange,
-            maxRange,
-            speed
-        ).asVariables()
-
-        override fun create(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ): Objective? {
-            if (entity !is PokemonEntity) return null
-            return WalkTowardsParent(
-                minRange = minRange.resolveInt(behaviourConfigurationContext.runtime),
-                maxRange = maxRange.resolveInt(behaviourConfigurationContext.runtime),
-                speed = speed.resolveFloat(behaviourConfigurationContext.runtime)
-            )
-        }
-    }
-}
@@ -36,7 +36,6 @@ import com.cobblemon.mod.common.util.withQueryValue
 import com.mojang.datafixers.util.Either
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.PathfinderMob
-import net.minecraft.world.entity.ai.memory.WalkTarget

 /*
 * I've scuffed the hell out of this thing. The logic for what types of wandering to do is unclear, and I haven't
@@ -55,9 +54,9 @@ class WanderAround(
    val horizontalRange: Expression = "10".asExpression(),
    val verticalRange: Expression = "5".asExpression(),
    val speedMultiplier: Expression = "0.35".asExpression(),
-    val avoidTargetingAir: Expression = "false".asExpression(),
+    val avoidTargetingAir: Expression = "true".asExpression(),
    val minimumHeight: Expression = "0".asExpression(),
-    val maximumHeight: Expression = "6".asExpression()
+    val maximumHeight: Expression = "999".asExpression()
 ) : Objective {
    var fixation: EntityFixation? = null
    var remainingCooldownTicks = 10
@@ -164,9 +163,9 @@ class WanderAround(
        val horizontalRange: ExpressionOrEntityVariable = Either.left("10".asExpression())
        val verticalRange: ExpressionOrEntityVariable = Either.left("5".asExpression())
        val speedMultiplier: ExpressionOrEntityVariable = Either.left("0.35".asExpression())
-        val avoidTargetingAir: ExpressionOrEntityVariable = Either.left("false".asExpression())
+        val avoidTargetingAir: ExpressionOrEntityVariable = Either.left("true".asExpression())
        val minimumHeight: ExpressionOrEntityVariable = Either.left("0".asExpression())
-        val maximumHeight: ExpressionOrEntityVariable = Either.left("6".asExpression())
+        val maximumHeight: ExpressionOrEntityVariable = Either.left("999".asExpression())

        override fun getVariables(
            entity: LivingEntity,
@@ -208,44 +207,4 @@ class WanderAround(
            )
        }
    }
-
-    companion object {
-        fun generateWalkTarget(entity: LivingEntity) : WalkTarget? {
-            if (entity !is PathfinderMob) return null
-            val runtime = mainThreadRuntime
-
-            val wanderControl = entity.brain.getMemorySafely(CobblemonMemories.WANDER_CONTROL).orElse(null)
-            runtime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
-
-            val allowLand = wanderControl?.allowLand ?: runtime.resolveBoolean("(q.entity.behaviour.moving.walk.can_walk && !q.entity.behaviour.moving.walk.avoids_land) || q.entity.behaviour.moving.fly.can_fly".asExpression())
-            val allowWater = wanderControl?.allowWater ?: runtime.resolveBoolean("q.entity.behaviour.moving.swim.can_swim_in_water && !q.entity.behaviour.moving.swim.avoids_water".asExpression())
-            val allowAir = wanderControl?.allowAir ?: runtime.resolveBoolean("q.entity.behaviour.moving.fly.can_fly && !q.entity.behaviour.moving.walk.can_walk".asExpression())
-
-            val types = mutableSetOf<WanderType>()
-            if ((allowLand || allowAir) && WanderType.LAND.isValid(entity)) {
-                types.add(WanderType.LAND)
-            }
-            if (allowWater && WanderType.WATER.isValid(entity)) {
-                types.add(WanderType.WATER)
-            }
-
-            if (types.isEmpty()) {
-                return null
-            }
-
-            return types.firstNotNullOfOrNull {
-                it.generateWalkTarget(
-                    entity = entity,
-                    horizontalRange = 10,
-                    verticalRange = 5,
-                    minimumHeight = 0,
-                    maximumHeight = 6,
-                    avoidTargetingAir = false, // runtime.resolveBoolean(avoidTargetingAir),
-                    speedMultiplier = 0.50f,
-                    center = wanderControl?.center,
-                    maxAttempts = wanderControl?.maxAttempts ?: 4
-                )
-            }
-        }
-    }
 }
@@ -1,84 +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.ai.biggerbrain.sense
-
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.config.sense.SenseConfig
-import com.cobblemon.mod.common.api.ai.resolveInt
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.asExpression
-import com.cobblemon.mod.common.util.getMemorySafely
-import com.mojang.datafixers.util.Either
-import net.minecraft.server.level.ServerPlayer
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.Mob
-import net.minecraft.world.entity.ai.memory.MemoryModuleType
-import net.minecraft.world.entity.ai.memory.NearestVisibleLivingEntities
-
-/**
- * Senses if there is an entity this enties owner needs defending from
- *
- * @author Jack
- * @since April 12th, 2026
- */
-class DefendOwnerSense(
-    var cooldownTicks: Int = 10
-) : Sense {
-    override var ticksUntilNextExecution = cooldownTicks
-    override val memories = setOf(CobblemonMemories.NEAREST_VISIBLE_ATTACKER, MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES)
-
-    override fun merge(other: Sense): Boolean {
-        if (other is DefendOwnerSense) {
-            this.cooldownTicks = minOf(this.cooldownTicks, other.cooldownTicks)
-            return true
-        } else {
-            return false
-        }
-    }
-
-    override fun tick(entity: LivingEntity, brain: BiggerBrain) {
-        ticksUntilNextExecution = cooldownTicks
-        if (entity !is PokemonEntity) return
-        val owner = entity.owner ?: return
-        brain.getMemory(MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES)?.let { visibleMobs ->
-            setNearestAttacker(entity, visibleMobs, owner, brain)
-        }
-    }
-
-    private fun setNearestAttacker(entity: PokemonEntity, visibleMobs: NearestVisibleLivingEntities, owner: LivingEntity, brain: BiggerBrain) {
-        val nearestAttacker = visibleMobs.findClosest { livingEntity ->
-            if (livingEntity is ServerPlayer) return@findClosest false
-            if (livingEntity.lastHurtMob == owner) return@findClosest true
-            if (livingEntity is Mob && livingEntity.target == owner) return@findClosest true
-            val mobAttackTarget = livingEntity.brain.getMemorySafely(MemoryModuleType.ATTACK_TARGET)
-            if (mobAttackTarget.isPresent && mobAttackTarget.get() == owner) return@findClosest true
-            false
-        }.orElse(null)
-
-        if (nearestAttacker != null) {
-            brain.setMemory(CobblemonMemories.NEAREST_VISIBLE_ATTACKER, nearestAttacker)
-        } else {
-            brain.eraseMemoryIfPresent(CobblemonMemories.NEAREST_VISIBLE_ATTACKER)
-        }
-    }
-
-    class Config : SenseConfig {
-        var cooldownTicks: ExpressionOrEntityVariable = Either.left("10".asExpression())
-
-        override fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext) =
-            listOf(cooldownTicks).asVariables()
-
-        override fun create(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext) =
-            DefendOwnerSense(cooldownTicks.resolveInt(behaviourConfigurationContext.runtime))
-    }
-}
@@ -1,190 +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.ai.biggerbrain.sense
-
-import com.cobblemon.mod.common.CobblemonItemComponents
-import com.cobblemon.mod.common.CobblemonItems
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.config.sense.SenseConfig
-import com.cobblemon.mod.common.api.ai.resolveDouble
-import com.cobblemon.mod.common.api.ai.resolveInt
-import com.cobblemon.mod.common.block.entity.NestBlockEntity
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.asExpression
-import com.mojang.datafixers.util.Either
-import net.minecraft.server.level.ServerLevel
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.InteractionHand
-import net.minecraft.world.entity.ai.memory.MemoryModuleType
-import net.minecraft.world.entity.item.ItemEntity
-import net.minecraft.world.entity.player.Player
-
-class EggSense(
-    private var cooldownTicks: Int = 100,
-    private var scanRadius: Double = 20.0
-) : Sense {
-    override var ticksUntilNextExecution: Int = 100
-    override val memories = setOf(
-        CobblemonMemories.PATERNAL_NEST_LOCATION,
-        CobblemonMemories.EGG_IN_NEST,
-        CobblemonMemories.EGG_LOCATION,
-        CobblemonMemories.EGG_THIEF,
-        CobblemonMemories.EGG_THIEF_LAST_SEEN_TICK,
-        CobblemonMemories.EGG_SEARCH_COUNTDOWN,
-        MemoryModuleType.ATTACK_TARGET,
-        MemoryModuleType.ANGRY_AT,
-        MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES
-    )
-
-    override fun merge(other: Sense): Boolean {
-        if (other is EggSense) {
-            this.cooldownTicks = minOf(this.cooldownTicks, other.cooldownTicks)
-            this.scanRadius = maxOf(this.scanRadius, other.scanRadius)
-            return true
-        }
-        return false
-    }
-
-    override fun tick(entity: LivingEntity, brain: BiggerBrain) {
-        ticksUntilNextExecution = cooldownTicks
-        if (entity !is PokemonEntity) return
-
-        val level = entity.level() as? ServerLevel ?: return
-        val nestPos = brain.getMemory(CobblemonMemories.PATERNAL_NEST_LOCATION) ?: return
-
-        val blockEntity = level.getBlockEntity(nestPos)
-        if (blockEntity is NestBlockEntity) {
-            val nestItem = blockEntity.getItem()
-            // Egg is in nest
-            if (!nestItem.isEmpty && nestItem.item.asItem() == CobblemonItems.POKEMON_EGG.asItem()) {
-                brain.setMemory(CobblemonMemories.EGG_LOCATION, nestPos)
-                brain.setMemory(CobblemonMemories.EGG_IN_NEST, true)
-                brain.eraseMemory(CobblemonMemories.EGG_SEARCH_COUNTDOWN)
-                return
-            }
-        }
-
-        // Egg is gone from nest
-        brain.setMemory(CobblemonMemories.EGG_IN_NEST, false)
-        brain.eraseMemory(CobblemonMemories.EGG_LOCATION)
-
-        // get item entities nearby that are Eggs
-        val nearbyEggItems = level.getEntitiesOfClass(ItemEntity::class.java, entity.boundingBox.inflate(scanRadius)) { itemEntity ->
-            val itemStack = itemEntity.item
-            if (itemStack.item.asItem() != CobblemonItems.POKEMON_EGG.asItem()) return@getEntitiesOfClass false
-            val eggComponent = itemStack.get(CobblemonItemComponents.EGG_DATA) ?: return@getEntitiesOfClass false
-            eggComponent.isParent(entity.pokemon.uuid)
-        }
-
-        if (nearbyEggItems.isNotEmpty()) {
-            // if the egg is on the ground lets stop being angry and grab it
-            if (brain.hasMemoryValue(MemoryModuleType.ATTACK_TARGET))
-                brain.eraseMemory(MemoryModuleType.ATTACK_TARGET)
-            if (brain.hasMemoryValue(MemoryModuleType.ANGRY_AT))
-                brain.eraseMemory(MemoryModuleType.ANGRY_AT)
-
-            brain.eraseMemory(CobblemonMemories.EGG_SEARCH_COUNTDOWN)
-            brain.setMemory(CobblemonMemories.EGG_LOCATION, nearbyEggItems[0].blockPosition())
-            brain.eraseMemory(CobblemonMemories.EGG_THIEF)
-            return
-        }
-
-        // see if we have any stored egg thieves in memory
-        val existingEggThief = brain.getMemory(CobblemonMemories.EGG_THIEF) as? Player
-        val lastSeenTick = brain.getMemory(CobblemonMemories.EGG_THIEF_LAST_SEEN_TICK)
-        val currentTick = level.gameTime
-
-        // we got a thief here!
-        if (existingEggThief != null) {
-            // there the thief is!
-            if (isPlayerVisible(entity, existingEggThief)) {
-                brain.setMemory(CobblemonMemories.EGG_THIEF_LAST_SEEN_TICK, currentTick)
-                brain.eraseMemory(CobblemonMemories.EGG_LOCATION)
-                brain.eraseMemory(CobblemonMemories.EGG_SEARCH_COUNTDOWN)
-                return
-            }
-
-            val lastSeen = lastSeenTick ?: currentTick
-            // lost track of thief for too long, giving up
-            if (currentTick - lastSeen > THIEF_LOST_SIGHT_TICKS) {
-                brain.eraseMemory(CobblemonMemories.EGG_THIEF)
-                brain.eraseMemory(CobblemonMemories.EGG_THIEF_LAST_SEEN_TICK)
-            } else {
-                // dont see the thief
-                brain.eraseMemory(CobblemonMemories.EGG_LOCATION)
-                return
-            }
-        }
-
-        // when looking for the egg and it is seen in the hand of a nearby player mark them as the thief
-        val heldEggThief = findVisiblePlayerHoldingEgg(entity, brain)
-        if (heldEggThief != null) {
-            brain.setMemory(CobblemonMemories.EGG_THIEF, heldEggThief)
-            brain.setMemory(CobblemonMemories.EGG_THIEF_LAST_SEEN_TICK, currentTick)
-            brain.eraseMemory(CobblemonMemories.EGG_LOCATION)
-            brain.eraseMemory(CobblemonMemories.EGG_SEARCH_COUNTDOWN)
-        } else {
-            // start search timer with no egg or player holding the egg in sight
-            brain.eraseMemory(CobblemonMemories.EGG_LOCATION)
-            brain.eraseMemory(CobblemonMemories.EGG_THIEF)
-            brain.eraseMemory(CobblemonMemories.EGG_THIEF_LAST_SEEN_TICK)
-
-            if (!brain.hasMemoryValue(CobblemonMemories.EGG_SEARCH_COUNTDOWN)) {
-                brain.setMemory(CobblemonMemories.EGG_SEARCH_COUNTDOWN, true, EGG_SEARCH_TIME)
-            }
-        }
-    }
-
-    // todo we might want to have each mate report to the other if a thief is found
-    private fun isPlayerVisible(entity: LivingEntity, player: Player): Boolean {
-        return entity.hasLineOfSight(player) && !player.isInvisible
-    }
-
-    private fun findVisiblePlayerHoldingEgg(entity: PokemonEntity, brain: BiggerBrain): Player? {
-        val visible = brain.getMemory(MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES) ?: return null
-        return visible.findAll { it is Player && !it.isSpectator && !it.isCreative && isHoldingEggOf(it, entity) }
-            .filterIsInstance<Player>()
-            .firstOrNull()
-    }
-
-    // todo if we have pokemon that can steal eggs from nests we may want to make this work on PokemonEntity too not just players
-    private fun isHoldingEggOf(player: Player, entity: PokemonEntity): Boolean {
-        return listOf(InteractionHand.MAIN_HAND, InteractionHand.OFF_HAND).any { hand ->
-            val stack = player.getItemInHand(hand)
-            stack.item.asItem() == CobblemonItems.POKEMON_EGG.asItem() &&
-                stack.get(CobblemonItemComponents.EGG_DATA)?.isParent(entity.pokemon.uuid) == true
-        }
-    }
-
-    class Config : SenseConfig {
-        var cooldownTicks: ExpressionOrEntityVariable = Either.left("100".asExpression())
-        var scanRadius: ExpressionOrEntityVariable = Either.left("20.0".asExpression())
-
-        override fun getVariables(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ) = listOf(cooldownTicks, scanRadius).asVariables()
-
-        override fun create(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): Sense {
-            return EggSense(
-                cooldownTicks = cooldownTicks.resolveInt(behaviourConfigurationContext.runtime),
-                scanRadius = scanRadius.resolveDouble(behaviourConfigurationContext.runtime)
-            )
-        }
-    }
-
-    companion object {
-        private const val EGG_SEARCH_TIME = 2400L
-        private const val THIEF_LOST_SIGHT_TICKS = 1200L
-    }
-}
@@ -1,206 +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.ai.biggerbrain.sense
-
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.resolveInt
-import com.cobblemon.mod.common.api.ai.config.sense.SenseConfig
-import com.cobblemon.mod.common.api.nest.WildNestType
-import com.cobblemon.mod.common.api.nest.WildNestTypes
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.asExpression
-import com.mojang.datafixers.util.Either
-import net.minecraft.core.BlockPos
-import net.minecraft.server.level.ServerLevel
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.PathfinderMob
-import net.minecraft.world.entity.ai.memory.MemoryModuleType
-import net.minecraft.world.level.block.Blocks
-import kotlin.jvm.optionals.getOrNull
-
-class IdealNestPlacementSense(
-    private var cooldownTicks: Int = 100,
-    private var detectionRadius: Int = 10,
-    private var minNestDistance: Int = 10,
-    private var playerClearance: Int = 24
-) : Sense {
-    override var ticksUntilNextExecution: Int = 100
-    override val memories = setOf(
-        CobblemonMemories.IDEAL_NEST_LOCATION,
-        CobblemonMemories.POTENTIAL_MATE
-    )
-
-    override fun merge(other: Sense): Boolean {
-        if (other is IdealNestPlacementSense) {
-            this.cooldownTicks = minOf(this.cooldownTicks, other.cooldownTicks)
-            this.detectionRadius = maxOf(this.detectionRadius, other.detectionRadius)
-            this.minNestDistance = maxOf(this.minNestDistance, other.minNestDistance)
-            this.playerClearance = maxOf(this.playerClearance, other.playerClearance)
-            return true
-        }
-        return false
-    }
-
-    override fun tick(entity: LivingEntity, brain: BiggerBrain) {
-        ticksUntilNextExecution = cooldownTicks
-        if (entity !is PokemonEntity) return
-        // wild mons should be the only ones able to build nests
-        if (!entity.pokemon.isWild()) return
-        val world = entity.level() as? ServerLevel ?: return
-
-        val mate = brain.getMemory(CobblemonMemories.POTENTIAL_MATE) as? PokemonEntity
-        val combinedTypes = mate?.let { WildNestTypes.combinedTypes(entity, it) } ?: emptyList()
-        if (mate == null || combinedTypes.isEmpty()) {
-            debug(brain, "No mate or no combined nest types; clearing ideal nest memories.")
-            brain.eraseMemory(CobblemonMemories.IDEAL_NEST_LOCATION)
-            mate?.biggerBrain?.eraseMemory(CobblemonMemories.IDEAL_NEST_LOCATION)
-            return
-        }
-
-        val storedNestPos = brain.getMemory(CobblemonMemories.IDEAL_NEST_LOCATION)
-        if (storedNestPos != null) {
-            if (isValidNestPlacement(world, entity, mate, storedNestPos, combinedTypes)) {
-                debug(brain, "Stored ideal nest still valid at $storedNestPos.")
-                mate.biggerBrain.setMemory(CobblemonMemories.IDEAL_NEST_LOCATION, storedNestPos)
-                return
-            } else {
-                debug(brain, "Stored ideal nest invalid at $storedNestPos; clearing.")
-                brain.eraseMemory(CobblemonMemories.IDEAL_NEST_LOCATION)
-                mate.biggerBrain.eraseMemory(CobblemonMemories.IDEAL_NEST_LOCATION)
-            }
-        }
-
-        val entityPos = entity.blockPosition()
-        val validNestPosition = findValidNestPlacement(world, entity, mate, entityPos, combinedTypes)
-
-        if (validNestPosition != null) {
-            debug(brain, "Found ideal nest position at $validNestPosition.")
-            brain.setMemory(CobblemonMemories.IDEAL_NEST_LOCATION, validNestPosition)
-            mate.biggerBrain.setMemory(CobblemonMemories.IDEAL_NEST_LOCATION, validNestPosition)
-        } else {
-            debug(brain, "No valid ideal nest position found.")
-            brain.eraseMemory(CobblemonMemories.IDEAL_NEST_LOCATION)
-            mate.biggerBrain.eraseMemory(CobblemonMemories.IDEAL_NEST_LOCATION)
-        }
-    }
-
-    private fun findValidNestPlacement(world: ServerLevel, entity: PokemonEntity, mate: PokemonEntity?, entityPos: BlockPos, sharedTypes: List<WildNestType>): BlockPos? {
-        return BlockPos.betweenClosed(
-            entityPos.offset(-detectionRadius, -5, -detectionRadius),
-            entityPos.offset(detectionRadius, 5, detectionRadius)
-        ).map { it.immutable() }.shuffled().firstOrNull { pos ->
-            val blockBelowState = world.getBlockState(pos)
-            val nestPos = pos.above()
-            val blockAbove = world.getBlockState(nestPos).block
-            val blockAbove2 = world.getBlockState(nestPos.above()).block
-            val placement = WildNestTypes.resolvePlacement(sharedTypes, blockBelowState, world.getFluidState(nestPos)) ?: return@firstOrNull false
-
-            if (!isWaterGroupCompatible(entity, mate, placement.waterlogged)) return@firstOrNull false
-
-            if (placement.waterlogged) {
-                if (!(blockAbove == Blocks.WATER && blockAbove2 == Blocks.WATER)) return@firstOrNull false
-            } else {
-                if (!(blockAbove == Blocks.AIR && blockAbove2 == Blocks.AIR)) return@firstOrNull false
-            }
-
-            if (isNearExistingNest(world, nestPos)) return@firstOrNull false
-            // wild mons kept making nests near players so we should make sure there are no players nearby lol
-            if (world.getNearestPlayer(nestPos.x + 0.5, nestPos.y.toDouble(), nestPos.z + 0.5, playerClearance.toDouble(), true) != null) return@firstOrNull false
-            if (!canPathfindToTarget(entity, nestPos)) return@firstOrNull false
-
-            return@firstOrNull true
-        }?.above()
-    }
-
-    private fun isValidNestPlacement(world: ServerLevel, entity: PokemonEntity, mate: PokemonEntity?, pos: BlockPos, sharedTypes: List<WildNestType>): Boolean {
-        val blockBelowState = world.getBlockState(pos.below())
-        val blockAbove = world.getBlockState(pos.above()).block
-        val blockAbove2 = world.getBlockState(pos.above(2)).block
-        val placement = WildNestTypes.resolvePlacement(sharedTypes, blockBelowState, world.getFluidState(pos)) ?: return false
-
-        if (!isWaterGroupCompatible(entity, mate, placement.waterlogged)) return false
-
-        if (placement.waterlogged) {
-            if (!(blockAbove == Blocks.WATER && blockAbove2 == Blocks.WATER)) return false
-        } else {
-            if (!(blockAbove == Blocks.AIR && blockAbove2 == Blocks.AIR)) return false
-        }
-
-        if (isNearExistingNest(world, pos)) return false
-        // not a valid spot if it is near a player
-        if (world.getNearestPlayer(pos.x + 0.5, pos.y.toDouble(), pos.z + 0.5, playerClearance.toDouble(), true) != null) return false
-        if (!canPathfindToTarget(entity, pos)) return false
-
-        return true
-    }
-
-    private fun canPathfindToTarget(entity: PathfinderMob, targetPos: BlockPos): Boolean {
-        val path = entity.navigation.createPath(targetPos, 0)
-        return path != null && path.distToTarget < 1.75f
-    }
-
-    private fun isNearExistingNest(world: ServerLevel, pos: BlockPos): Boolean {
-        return BlockPos.betweenClosed(
-            pos.offset(-minNestDistance, -minNestDistance, -minNestDistance),
-            pos.offset(minNestDistance, minNestDistance, minNestDistance)
-        ).any { checkPos ->
-            world.getBlockEntity(checkPos) is com.cobblemon.mod.common.block.entity.NestBlockEntity
-        }
-    }
-
-    private fun isWaterGroupCompatible(
-        entity: PokemonEntity,
-        mate: PokemonEntity?,
-        isNestWaterlogged: Boolean
-    ): Boolean {
-        val waterEggGroups = setOf("water_1", "water_2", "water_3")
-        val entityEggGroups = entity.pokemon.species.eggGroups.map { it.name.lowercase() }
-        val entityHasWater = entityEggGroups.any { it in waterEggGroups || it == "ditto" }
-        val entityOnlyWater = entityEggGroups.all { it in waterEggGroups }
-
-        val mateEggGroups = mate?.pokemon?.species?.eggGroups?.map { it.name.lowercase() } ?: emptyList()
-        val mateHasWater = mateEggGroups.any { it in waterEggGroups || it == "ditto" }
-        val mateOnlyWater = mateEggGroups.isNotEmpty() && mateEggGroups.all { it in waterEggGroups }
-
-        return if (isNestWaterlogged) {
-            entityHasWater && mateHasWater
-        } else {
-            !(entityOnlyWater || mateOnlyWater)
-        }
-    }
-
-    private fun debug(brain: BiggerBrain, message: String) {
-        brain.sendDebugMessage("[IdealNestPlacementSense] $message")
-    }
-
-    class Config : SenseConfig {
-        var cooldownTicks: ExpressionOrEntityVariable = Either.left("100".asExpression())
-        var detectionRadius: ExpressionOrEntityVariable = Either.left("10".asExpression())
-        var minNestDistance: ExpressionOrEntityVariable = Either.left("10".asExpression())
-        var playerClearance: ExpressionOrEntityVariable = Either.left("24".asExpression())
-
-        override fun getVariables(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ) = listOf(cooldownTicks, detectionRadius, minNestDistance, playerClearance).asVariables()
-
-        override fun create(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): Sense {
-            return IdealNestPlacementSense(
-                cooldownTicks = cooldownTicks.resolveInt(behaviourConfigurationContext.runtime),
-                detectionRadius = detectionRadius.resolveInt(behaviourConfigurationContext.runtime),
-                minNestDistance = minNestDistance.resolveInt(behaviourConfigurationContext.runtime),
-                playerClearance = playerClearance.resolveInt(behaviourConfigurationContext.runtime)
-            )
-        }
-    }
-}
@@ -1,126 +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.ai.biggerbrain.sense
-
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.config.sense.SenseConfig
-import com.cobblemon.mod.common.api.ai.resolveDouble
-import com.cobblemon.mod.common.api.ai.resolveInt
-import com.cobblemon.mod.common.api.breeding.CobblemonBreeding
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.asExpression
-import com.mojang.datafixers.util.Either
-import net.minecraft.server.level.ServerLevel
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.phys.AABB
-
-class MateSense(
-    private var cooldownTicks: Int = 1200,
-    private var detectionRadius: Double = 10.0
-) : Sense {
-    override var ticksUntilNextExecution: Int = 1200
-    override val memories = setOf(
-        CobblemonMemories.POTENTIAL_MATE,
-        CobblemonMemories.MATE_SCAN_COOLDOWN,
-        CobblemonMemories.PATERNAL_NEST_LOCATION
-    )
-
-    override fun merge(other: Sense): Boolean {
-        if (other is MateSense) {
-            this.cooldownTicks = minOf(this.cooldownTicks, other.cooldownTicks)
-            this.detectionRadius = maxOf(this.detectionRadius, other.detectionRadius)
-            return true
-        }
-        return false
-    }
-
-    override fun tick(entity: LivingEntity, brain: BiggerBrain) {
-        ticksUntilNextExecution = cooldownTicks
-        if (entity !is PokemonEntity) return
-
-        if (brain.getMemory(CobblemonMemories.PATERNAL_NEST_LOCATION) != null) {
-            return
-        }
-
-        if (brain.getMemory(CobblemonMemories.MATE_SCAN_COOLDOWN) == true) {
-            return
-        }
-
-        brain.eraseMemory(CobblemonMemories.POTENTIAL_MATE)
-
-        if (entity.pokemon.breedingCooldown != 0) return
-
-        val world = entity.level() as? ServerLevel ?: return
-
-        // it has been an issue that wild mons breed so much and pasture mons not enough so we should have a config for tweaking rates of both
-        val chance = if (entity.pokemon.isWild()) Cobblemon.config.wildBreedingChance else Cobblemon.config.pastureBreedingChance
-        if (entity.random.nextDouble() >= chance) {
-            brain.setMemory(CobblemonMemories.MATE_SCAN_COOLDOWN, true, MATE_SCAN_COOLDOWN)
-            return
-        }
-
-        val potentialMate = world.getEntitiesOfClass(
-            PokemonEntity::class.java,
-            AABB(entity.blockPosition()).inflate(detectionRadius)
-        ) { nearbyEntity ->
-            nearbyEntity != entity && isValidMate(entity, nearbyEntity)
-        }.firstOrNull()
-
-        brain.setMemory(CobblemonMemories.MATE_SCAN_COOLDOWN, true, MATE_SCAN_COOLDOWN)
-
-        if (potentialMate != null) {
-            brain.setMemory(CobblemonMemories.POTENTIAL_MATE, potentialMate)
-            potentialMate.biggerBrain.setMemory(CobblemonMemories.POTENTIAL_MATE, entity)
-            potentialMate.biggerBrain.setMemory(CobblemonMemories.MATE_SCAN_COOLDOWN, true, MATE_SCAN_COOLDOWN)
-        } else {
-            brain.eraseMemory(CobblemonMemories.POTENTIAL_MATE)
-        }
-    }
-
-    private fun isValidMate(entity: PokemonEntity, mate: PokemonEntity): Boolean {
-        if (entity.isBattling || entity.isBattleClone() || (!entity.pokemon.isWild() && entity.tethering?.tetheringId == null)) return false
-        if (mate.pokemon.breedingCooldown != 0) return false
-
-        val canBreed = CobblemonBreeding.getMother(entity.pokemon, mate.pokemon, isSimulated = true) != null
-        if (!canBreed) return false
-
-        val isCompatible = CobblemonBreeding.checkCompatibility(entity.pokemon, mate.pokemon)
-        val bothWild = (entity.pokemon.isWild() && mate.pokemon.isWild())
-        val bothOwned = (!entity.pokemon.isWild() && !mate.pokemon.isWild())
-        val mateHasMate = mate.biggerBrain.getMemory(CobblemonMemories.POTENTIAL_MATE) != null
-
-        return !mateHasMate && isCompatible && (bothWild || bothOwned)
-    }
-
-    class Config : SenseConfig {
-        var cooldownTicks: ExpressionOrEntityVariable = Either.left("1200".asExpression())
-        var detectionRadius: ExpressionOrEntityVariable = Either.left("10.0".asExpression())
-
-        override fun getVariables(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ) = listOf(cooldownTicks, detectionRadius).asVariables()
-
-        override fun create(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): Sense {
-            return MateSense(
-                cooldownTicks = cooldownTicks.resolveInt(behaviourConfigurationContext.runtime),
-                detectionRadius = detectionRadius.resolveDouble(behaviourConfigurationContext.runtime)
-            )
-        }
-    }
-
-    companion object {
-        private const val MATE_SCAN_COOLDOWN = 1200L
-    }
-}
@@ -1,229 +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.ai.biggerbrain.sense
-
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.config.sense.SenseConfig
-import com.cobblemon.mod.common.api.ai.resolveInt
-import com.cobblemon.mod.common.api.nest.WildNestType
-import com.cobblemon.mod.common.api.nest.WildNestTypes
-import com.cobblemon.mod.common.block.WildNestBlock
-import com.cobblemon.mod.common.block.entity.NestBlockEntity
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.asExpression
-import com.mojang.datafixers.util.Either
-import net.minecraft.core.BlockPos
-import net.minecraft.server.level.ServerLevel
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.PathfinderMob
-import net.minecraft.world.level.block.entity.BlockEntity
-
-class NestSense(
-    private var cooldownTicks: Int = 200,
-    private var radiusXZ: Int = 20,
-    private var radiusY: Int = 5
-) : Sense {
-    override var ticksUntilNextExecution: Int = 200
-    override val memories = setOf(
-        CobblemonMemories.NEST_LOCATION,
-        CobblemonMemories.PATERNAL_NEST_LOCATION,
-        CobblemonMemories.EGG_IN_NEST,
-        CobblemonMemories.EGG_LOCATION,
-        CobblemonMemories.NEST_DESPAWN_IMMUNE_UNTIL_TICK
-    )
-
-    override fun merge(other: Sense): Boolean {
-        if (other is NestSense) {
-            this.cooldownTicks = minOf(this.cooldownTicks, other.cooldownTicks)
-            this.radiusXZ = maxOf(this.radiusXZ, other.radiusXZ)
-            this.radiusY = maxOf(this.radiusY, other.radiusY)
-            return true
-        }
-        return false
-    }
-
-    override fun tick(entity: LivingEntity, brain: BiggerBrain) {
-        ticksUntilNextExecution = cooldownTicks
-        if (entity !is PokemonEntity) return
-        val world = entity.level() as? ServerLevel ?: return
-
-        val paternalNestLocation = brain.getMemory(CobblemonMemories.PATERNAL_NEST_LOCATION)
-
-        // early memory check so we can end early
-        if (paternalNestLocation != null) {
-            // end early if the nest itself isnt loaded in
-            if (!world.isLoaded(paternalNestLocation)) {
-                return
-            }
-            // check to make sure there is a nest still at that spot
-            val blockAtLocation = world.getBlockEntity(paternalNestLocation)
-            if (blockAtLocation !is NestBlockEntity) { // nest is gone so we kill all nest and egg memories
-                brain.eraseMemory(CobblemonMemories.PATERNAL_NEST_LOCATION)
-                brain.eraseMemory(CobblemonMemories.EGG_IN_NEST)
-                brain.eraseMemory(CobblemonMemories.EGG_LOCATION)
-            } else if (blockAtLocation.parents.first == entity.uuid || blockAtLocation.parents.second == entity.uuid) {
-                // is the pokemon one of the parents of this nest? Yes? Sick let's remember that. We might want to check memories beforehand though so we don't need to set memories each time? idk todo look into
-                brain.setMemory(CobblemonMemories.PATERNAL_NEST_LOCATION, paternalNestLocation)
-                brain.setMemory(CobblemonMemories.NEST_LOCATION, paternalNestLocation)
-
-                // does our nest have an egg todo we should maybe also check that not just any egg is in the nest but if it is trhe egg of the parents (check uuid of the egg components later)
-                if (blockAtLocation.getItem().isEmpty) {
-                    brain.setMemory(CobblemonMemories.EGG_IN_NEST, false)
-                } else {
-                    brain.setMemory(CobblemonMemories.EGG_IN_NEST, true)
-                }
-                return
-            } else { // no longer parents of the nest clear
-                brain.eraseMemory(CobblemonMemories.PATERNAL_NEST_LOCATION)
-                brain.setMemory(CobblemonMemories.EGG_IN_NEST, false)
-                brain.eraseMemory(CobblemonMemories.EGG_LOCATION)
-            }
-        }
-
-        val nearbyNest = findNearbyNest(entity, brain, world, entity.blockPosition())
-        if (nearbyNest != null) {
-            brain.setMemory(CobblemonMemories.NEST_LOCATION, nearbyNest)
-        } else {
-            brain.eraseMemory(CobblemonMemories.NEST_LOCATION)
-        }
-    }
-
-    private fun findNearbyNest(pokemonEntity: PokemonEntity, brain: BiggerBrain, world: ServerLevel, entityPos: BlockPos): BlockPos? {
-        return BlockPos.betweenClosed(
-            entityPos.offset(-radiusXZ, -radiusY, -radiusXZ),
-            entityPos.offset(radiusXZ, radiusY, radiusXZ)
-        ).firstOrNull { pos ->
-            val blockEntity: BlockEntity? = world.getBlockEntity(pos)
-            if (blockEntity !is NestBlockEntity) return@firstOrNull false
-
-            if (pokemonEntity.isBattling || pokemonEntity.isBattleClone() || (!pokemonEntity.pokemon.isWild() && pokemonEntity.tethering?.tetheringId == null)) return@firstOrNull false
-
-            // we might need to check if a nest nearby was forgotten about
-            if (blockEntity.parents.first == pokemonEntity.uuid || blockEntity.parents.second == pokemonEntity.uuid) {
-                brain.setMemory(CobblemonMemories.PATERNAL_NEST_LOCATION, pos)
-                return@firstOrNull true
-            }
-
-            val nestBlockEntity = blockEntity
-            val allowedTypes = allowedNestTypes(pokemonEntity, brain)
-            val nestType = (nestBlockEntity.blockState.block as? WildNestBlock)?.type
-
-            // is the nest a valid type allowed by the mates
-            if (nestType == null || !isNestTypeAllowed(nestType, pokemonEntity, allowedTypes))
-                return@firstOrNull false
-
-            // can the mates get to the nest?
-            if (!canPathfindToTarget(pokemonEntity, nestBlockEntity.blockPos)) return@firstOrNull false
-
-            val isWildNest = nestBlockEntity.ownerUUID == null
-            val isPlayerNest = nestBlockEntity.ownerUUID != null
-            val isClaimed = nestBlockEntity.nestClaimedBy.first != null || nestBlockEntity.nestClaimedBy.second != null
-            val isEggless = nestBlockEntity.getItem(0).isEmpty
-            val isNestWaterlogged = nestBlockEntity.blockState.getOptionalValue(net.minecraft.world.level.block.state.properties.BlockStateProperties.WATERLOGGED).orElse(false)
-            val mate = brain.getMemory(CobblemonMemories.POTENTIAL_MATE) as? PokemonEntity
-            val nestClaimerOne = nestBlockEntity.nestClaimedBy.first?.let { world.getEntity(it) }
-            val nestClaimerTwo = nestBlockEntity.nestClaimedBy.second?.let { world.getEntity(it) }
-            val isClaimerOne = pokemonEntity.uuid == nestClaimerOne?.uuid
-            val isClaimerTwo = pokemonEntity.uuid == nestClaimerTwo?.uuid
-            val nestParentOneActive = nestBlockEntity.parents.first?.let { world.getEntity(it) }
-            val nestParentTwoActive = nestBlockEntity.parents.second?.let { world.getEntity(it) }
-
-            // skip any empty wild nests that are claimed
-            if (isWildNest && isEggless && ((nestParentOneActive != null || nestParentTwoActive != null) || (isClaimed && (nestClaimerOne != null && !isClaimerOne && nestClaimerTwo != null && !isClaimerTwo)))) {
-                return@firstOrNull false
-            }
-
-            // is this nest water group compatible? some of our nests can only be used by water egg grouup mons if they are water logged. reverse for land nests and water egg groups
-            if (!isWaterGroupCompatible(pokemonEntity, mate, isNestWaterlogged)) {
-                return@firstOrNull false
-            }
-
-            // pastured mons to only use free player nests and wild mons to use naturally made nests
-            return@firstOrNull when {
-                pokemonEntity.tethering?.tetheringId != null -> isPlayerNest && isEggless
-                else -> isWildNest && isEggless
-            }
-        }
-    }
-
-    private fun canPathfindToTarget(entity: PathfinderMob, targetPos: BlockPos): Boolean {
-        val path = entity.navigation.createPath(targetPos, 0)
-        return path != null && path.distToTarget < 1.75f
-    }
-
-    private fun isWaterGroupCompatible(
-        entity: PokemonEntity,
-        mate: PokemonEntity?,
-        isNestWaterlogged: Boolean
-    ): Boolean {
-        val waterEggGroups = setOf("water_1", "water_2", "water_3")
-        val entityEggGroups = entity.pokemon.species.eggGroups.map { it.name.lowercase() }
-        val entityHasWater = entityEggGroups.any { it in waterEggGroups || it == "ditto" }
-        val entityOnlyWater = entityEggGroups.all { it in waterEggGroups }
-
-        val mateEggGroups = mate?.pokemon?.species?.eggGroups?.map { it.name.lowercase() } ?: emptyList()
-        val mateHasWater = mateEggGroups.any { it in waterEggGroups || it == "ditto" }
-        val mateOnlyWater = mateEggGroups.isNotEmpty() && mateEggGroups.all { it in waterEggGroups }
-
-        return if (isNestWaterlogged) {
-            entityHasWater && mateHasWater
-        } else {
-            !(entityOnlyWater || mateOnlyWater)
-        }
-    }
-
-    private fun allowedNestTypes(entity: PokemonEntity, brain: BiggerBrain): Set<WildNestType> {
-        val mate = brain.getMemory(CobblemonMemories.POTENTIAL_MATE) as? PokemonEntity
-        val types = if (mate != null) {
-            WildNestTypes.combinedTypes(entity, mate)
-        } else {
-            WildNestTypes.typesFor(entity.pokemon.species)
-        }
-        val mutable = types.toMutableSet()
-        if (!entity.pokemon.isWild() && mate != null && !mate.pokemon.isWild()) {
-            mutable.add(WildNestType.PLAYER)
-            mutable.add(WildNestType.KELP)
-        }
-        return mutable
-    }
-
-    private fun isNestTypeAllowed(
-        nestType: WildNestType,
-        entity: PokemonEntity,
-        allowedTypes: Set<WildNestType>
-    ): Boolean {
-        if (nestType == WildNestType.PLAYER || nestType == WildNestType.KELP) {
-            return !entity.pokemon.isWild() && allowedTypes.contains(nestType)
-        }
-        return allowedTypes.contains(nestType)
-    }
-
-    class Config : SenseConfig {
-        var cooldownTicks: ExpressionOrEntityVariable = Either.left("200".asExpression())
-        var radiusXZ: ExpressionOrEntityVariable = Either.left("20".asExpression())
-        var radiusY: ExpressionOrEntityVariable = Either.left("5".asExpression())
-
-        override fun getVariables(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ) = listOf(cooldownTicks, radiusXZ, radiusY).asVariables()
-
-        override fun create(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): Sense {
-            return NestSense(
-                cooldownTicks = cooldownTicks.resolveInt(behaviourConfigurationContext.runtime),
-                radiusXZ = radiusXZ.resolveInt(behaviourConfigurationContext.runtime),
-                radiusY = radiusY.resolveInt(behaviourConfigurationContext.runtime)
-            )
-        }
-    }
-}
@@ -1,105 +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.ai.biggerbrain.sense
-
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.config.sense.SenseConfig
-import com.cobblemon.mod.common.api.ai.resolveInt
-import com.cobblemon.mod.common.api.tags.CobblemonBlockTags
-import com.cobblemon.mod.common.util.asExpression
-import com.cobblemon.mod.common.util.distanceTo
-import com.cobblemon.mod.common.util.getMemorySafely
-import com.mojang.datafixers.util.Either
-import net.minecraft.core.BlockPos
-import net.minecraft.core.Vec3i
-import net.minecraft.world.entity.LivingEntity
-
-class ScarekrowSense(
-    private var cooldownTicks: Int = SCAN_INTERVAL
-) : Sense {
-    override var ticksUntilNextExecution: Int = cooldownTicks
-    override val memories = setOf(
-        CobblemonMemories.NEARBY_SCAREKROW,
-    )
-
-    override fun merge(other: Sense): Boolean {
-        if (other is ScarekrowSense) {
-            this.cooldownTicks = minOf(this.cooldownTicks, other.cooldownTicks)
-            return true
-        }
-        return false
-    }
-
-    override fun tick(entity: LivingEntity, brain: BiggerBrain) {
-        ticksUntilNextExecution = cooldownTicks
-        val brain = entity.brain
-
-        val searchRadius = Cobblemon.config.scarekrowRadius
-        val currPos: BlockPos? = brain.getMemorySafely(CobblemonMemories.NEARBY_SCAREKROW).orElse(null)
-
-        if (currPos != null && entity.level().getBlockState(currPos).`is`(CobblemonBlockTags.SCAREKROWS)) {
-            val distance = entity.distanceTo(currPos)
-            if (distance > searchRadius) {
-                brain.eraseMemory(CobblemonMemories.NEARBY_SCAREKROW)
-            }
-        }
-
-        val centerPos = entity.blockPosition()
-        var scarekrowPos: BlockPos? = null
-        var shortestDist = Double.MAX_VALUE
-        val world = entity.level()
-        BlockPos.betweenClosedStream(
-            centerPos.offset(-searchRadius, -searchRadius, -searchRadius),
-            centerPos.offset(searchRadius, searchRadius, searchRadius)
-        ).forEach { pos ->
-            val state = world.getBlockState(pos)
-            if (state.`is`(CobblemonBlockTags.SCAREKROWS)) {
-                val distance = pos.distSqr(Vec3i(centerPos.x, centerPos.y, centerPos.z))
-                if (distance < shortestDist) {
-                    scarekrowPos = BlockPos(pos)
-                    shortestDist = distance
-                }
-            }
-        }
-
-        if (scarekrowPos != null) {
-            brain.setMemory(CobblemonMemories.NEARBY_SCAREKROW, scarekrowPos)
-        } else {
-            brain.eraseMemory(CobblemonMemories.NEARBY_SCAREKROW)
-        }
-    }
-
-    class Config : SenseConfig {
-        var condition: ExpressionOrEntityVariable = Either.left("true".asExpression())
-        var cooldownTicks: ExpressionOrEntityVariable = Either.left("3".asExpression())
-
-        override fun getVariables(
-            entity: LivingEntity,
-            behaviourConfigurationContext: BehaviourConfigurationContext
-        ) = listOf(cooldownTicks).asVariables()
-
-        override fun create(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): Sense {
-            val cooldownTicks = cooldownTicks.resolveInt(behaviourConfigurationContext.runtime)
-            return ScarekrowSense(
-                cooldownTicks = cooldownTicks
-            )
-        }
-    }
-
-    companion object {
-        const val SCAN_INTERVAL = 3
-    }
-
-
-}
@@ -31,19 +31,12 @@ interface Sense {
            cobblemonResource("npc_battling") to NPCBattlingSense::class.java,
            cobblemonResource("pokemon_adult") to PokemonAdultSense::class.java,
            cobblemonResource("hurt_by") to HurtBySense::class.java,
-            cobblemonResource("mate_sensor") to MateSense::class.java,
-            cobblemonResource("nest_sensor") to NestSense::class.java,
-            cobblemonResource("egg_sensor") to EggSense::class.java,
-            cobblemonResource("ideal_nest_location_sensor") to IdealNestPlacementSense::class.java,
-            cobblemonResource("hurt_by") to HurtBySense::class.java,
-            cobblemonResource("nearby_sweet_berry_bush") to SweetBerryBushSense::class.java,
            cobblemonResource("jukebox_playing") to JukeboxSense::class.java,
            cobblemonResource("nearby_sweet_berry_bush") to SweetBerryBushSense::class.java,
            cobblemonResource("pokemon_nearby_wanted_item") to PokemonItemSense.Config::class.java,
            cobblemonResource("flower_sense") to FlowerSense.Config::class.java,
            cobblemonResource("beehive_sense") to BeeHiveSense.Config::class.java,
            cobblemonResource("sacc_leaf_sense") to SaccLeafSense.Config::class.java,
-            cobblemonResource("scarekrow_sense") to ScarekrowSense.Config::class.java
            )
    }

@@ -38,7 +38,7 @@ class ApplyBehaviours : BehaviourConfig {
    override fun preconfigure(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext) {
        if (!checkCondition(behaviourConfigurationContext, condition)) return

-        val configurations = behaviours.map { CobblemonBehaviours.behaviours[it]?.takeIf { it.canBeApplied(entity) } ?: return }
+        val configurations = behaviours.mapNotNull { CobblemonBehaviours.behaviours[it]?.takeIf { it.canBeApplied(entity) } }
        configurations.forEach {
            it.configurations.forEach { it.preconfigure(entity, behaviourConfigurationContext) }
        }
@@ -50,9 +50,9 @@ class ApplyBehaviours : BehaviourConfig {
        val applicableBehaviours = behaviours.mapNotNull {
            val resolvedBehaviour = CobblemonBehaviours.behaviours[it]
            if (resolvedBehaviour == null) {
-                Cobblemon.LOGGER.warn("Behaviour $it not found while configuring entity of type ${entity.type}")
+                Cobblemon.LOGGER.warn("Behaviour $it not found while configuring entity of type ${entity.type} at location ${entity.blockPosition()}")
            } else if (!resolvedBehaviour.canBeApplied(entity)) {
-                Cobblemon.LOGGER.warn("Behaviour $it cannot be applied to entity ${entity.id}")
+                Cobblemon.LOGGER.warn("Behaviour $it is not compatible with entity ${entity.id} at location ${entity.blockPosition()}")
            } else {
                return@mapNotNull resolvedBehaviour
            }
@@ -9,19 +9,10 @@
 package com.cobblemon.mod.common.api.ai.config.objective

 import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.biggerbrain.objective.AggressiveBehaviour
-import com.cobblemon.mod.common.api.ai.biggerbrain.objective.CircleAround
-import com.cobblemon.mod.common.api.ai.biggerbrain.objective.AvoidTarget
 import com.cobblemon.mod.common.api.ai.biggerbrain.objective.Dance
-import com.cobblemon.mod.common.api.ai.biggerbrain.objective.DefendOwner
-import com.cobblemon.mod.common.api.ai.biggerbrain.objective.Breed
-import com.cobblemon.mod.common.api.ai.biggerbrain.objective.DefendNest
-import com.cobblemon.mod.common.api.ai.biggerbrain.objective.EggRecovery
-import com.cobblemon.mod.common.api.ai.biggerbrain.objective.Defensive
 import com.cobblemon.mod.common.api.ai.biggerbrain.objective.EatGrass
 import com.cobblemon.mod.common.api.ai.biggerbrain.objective.EatHeldItem
 import com.cobblemon.mod.common.api.ai.biggerbrain.objective.FocusDuringBattle
-import com.cobblemon.mod.common.api.ai.biggerbrain.objective.FriendlyBehaviour
 import com.cobblemon.mod.common.api.ai.biggerbrain.objective.GatherNectar
 import com.cobblemon.mod.common.api.ai.biggerbrain.objective.GoToSleep
 import com.cobblemon.mod.common.api.ai.biggerbrain.objective.HarvestSweetBerryBush
@@ -37,12 +28,7 @@ import com.cobblemon.mod.common.api.ai.biggerbrain.objective.MoveToRestingPlace
 import com.cobblemon.mod.common.api.ai.biggerbrain.objective.PickupItem
 import com.cobblemon.mod.common.api.ai.biggerbrain.objective.WanderAround
 import com.cobblemon.mod.common.api.ai.biggerbrain.objective.JumpOutOfWater
-import com.cobblemon.mod.common.api.ai.biggerbrain.objective.NeutralBehaviour
 import com.cobblemon.mod.common.api.ai.biggerbrain.objective.PointToSpawn
-import com.cobblemon.mod.common.api.ai.biggerbrain.objective.AvoidScarekrow
-import com.cobblemon.mod.common.api.ai.biggerbrain.objective.SkittishBehaviour
-import com.cobblemon.mod.common.api.ai.biggerbrain.objective.TerritorialBehaviour
-import com.cobblemon.mod.common.api.ai.biggerbrain.objective.WalkTowardsParent
 import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
 import com.cobblemon.mod.common.util.cobblemonResource
 import net.minecraft.resources.ResourceLocation
@@ -64,26 +50,12 @@ interface ObjectiveConfig {
            cobblemonResource("jump_out_of_water") to JumpOutOfWater.Config::class.java,
            cobblemonResource("move_to_resting_place") to MoveToRestingPlace.Config::class.java,
            cobblemonResource("go_to_sleep") to GoToSleep.Config::class.java,
-            cobblemonResource("defend_nest") to DefendNest.Config::class.java,
-            cobblemonResource("breed") to Breed.Config::class.java,
-            cobblemonResource("egg_recovery") to EggRecovery.Config::class.java,
            cobblemonResource("harvest_sweet_berry_bush") to HarvestSweetBerryBush.Config::class.java,
            cobblemonResource("pickup_item") to PickupItem.Config::class.java,
            cobblemonResource("eat_held_item") to EatHeldItem.Config::class.java,
            cobblemonResource("gather_nectar") to GatherNectar.Config::class.java,
            cobblemonResource("dance") to Dance.Config::class.java,
-            cobblemonResource("defend_owner") to DefendOwner.Config::class.java,
            cobblemonResource("point_to_spawn") to PointToSpawn.Config::class.java,
-            cobblemonResource("circle_around") to CircleAround.Config::class.java,
-            cobblemonResource("walk_to_parent") to WalkTowardsParent.Config::class.java,
-            cobblemonResource("avoid_target") to AvoidTarget.Config::class.java,
-            cobblemonResource("combat_defensive") to Defensive.Config::class.java,
-            cobblemonResource("combat_aggressive") to AggressiveBehaviour.Config::class.java,
-            cobblemonResource("combat_territorial") to TerritorialBehaviour.Config::class.java,
-            cobblemonResource("combat_neutral") to NeutralBehaviour.Config::class.java,
-            cobblemonResource("combat_skittish") to SkittishBehaviour.Config::class.java,
-            cobblemonResource("behaviour_friendly") to FriendlyBehaviour.Config::class.java,
-            cobblemonResource("avoid_scarekrow") to AvoidScarekrow.Config::class.java,

            )
    }
@@ -91,4 +63,4 @@ interface ObjectiveConfig {
    /** The variables that this objective config uses. These are used to declare variables on the entity cleanly. */
    fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): List<MoLangConfigVariable>
    fun create(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): Objective?
-}
+}
@@ -11,21 +11,15 @@ package com.cobblemon.mod.common.api.ai.config.sense
 import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
 import com.cobblemon.mod.common.api.ai.biggerbrain.sense.BattlingPokemonSense
 import com.cobblemon.mod.common.api.ai.biggerbrain.sense.BeeHiveSense
-import com.cobblemon.mod.common.api.ai.biggerbrain.sense.DefendOwnerSense
 import com.cobblemon.mod.common.api.ai.biggerbrain.sense.DrowsySense
-import com.cobblemon.mod.common.api.ai.biggerbrain.sense.EggSense
 import com.cobblemon.mod.common.api.ai.biggerbrain.sense.FlowerSense
 import com.cobblemon.mod.common.api.ai.biggerbrain.sense.HurtBySense
-import com.cobblemon.mod.common.api.ai.biggerbrain.sense.IdealNestPlacementSense
-import com.cobblemon.mod.common.api.ai.biggerbrain.sense.MateSense
 import com.cobblemon.mod.common.api.ai.biggerbrain.sense.JukeboxSense
 import com.cobblemon.mod.common.api.ai.biggerbrain.sense.NPCBattlingSense
-import com.cobblemon.mod.common.api.ai.biggerbrain.sense.NestSense
 import com.cobblemon.mod.common.api.ai.biggerbrain.sense.NearbyEntitiesSense
 import com.cobblemon.mod.common.api.ai.biggerbrain.sense.PokemonAdultSense
 import com.cobblemon.mod.common.api.ai.biggerbrain.sense.PokemonItemSense
 import com.cobblemon.mod.common.api.ai.biggerbrain.sense.SaccLeafSense
-import com.cobblemon.mod.common.api.ai.biggerbrain.sense.ScarekrowSense
 import com.cobblemon.mod.common.api.ai.biggerbrain.sense.Sense
 import com.cobblemon.mod.common.api.ai.biggerbrain.sense.SweetBerryBushSense
 import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
@@ -42,28 +36,21 @@ interface SenseConfig {
    companion object {
        val types = mutableMapOf(
            cobblemonResource("nearby_entities") to NearbyEntitiesSense.Config::class.java,
-            cobblemonResource("defend_owner") to DefendOwnerSense.Config::class.java,
            cobblemonResource("drowsy") to DrowsySense.Config::class.java,
            cobblemonResource("hurt_by") to HurtBySense.Config::class.java,
            cobblemonResource("jukebox_playing") to JukeboxSense.Config::class.java,
            cobblemonResource("battling_pokemon") to BattlingPokemonSense.Config::class.java,
            cobblemonResource("npc_battling") to NPCBattlingSense.Config::class.java,
            cobblemonResource("pokemon_adult") to PokemonAdultSense.Config::class.java,
-            cobblemonResource("mate_sensor") to MateSense.Config::class.java,
-            cobblemonResource("nest_sensor") to NestSense.Config::class.java,
-            cobblemonResource("egg_sensor") to EggSense.Config::class.java,
-            cobblemonResource("ideal_nest_location_sensor") to IdealNestPlacementSense.Config::class.java,
-            cobblemonResource("pokemon_adult") to PokemonAdultSense.Config::class.java,
            cobblemonResource("nearby_sweet_berry_bush") to SweetBerryBushSense.Config::class.java,
            cobblemonResource("pokemon_nearby_wanted_item") to PokemonItemSense.Config::class.java,
            cobblemonResource("flower_sense") to FlowerSense.Config::class.java,
            cobblemonResource("beehive_sense") to BeeHiveSense.Config::class.java,
            cobblemonResource("sacc_leaf_sense") to SaccLeafSense.Config::class.java,
-            cobblemonResource("scarekrow_sense") to ScarekrowSense.Config::class.java,
            )
    }

    /** The variables that this sense config uses. These are used to declare variables on the entity cleanly. */
    fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): List<MoLangConfigVariable> = emptyList()
    fun create(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): Sense?
-}
+}
@@ -1,149 +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.ai.config.task
-
-/*
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.CobblemonFlows.runtime
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
-import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.withQueryValue
-import com.mojang.datafixers.kinds.IdF
-import net.minecraft.core.BlockPos
-import net.minecraft.server.level.ServerLevel
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.PathfinderMob
-import net.minecraft.world.entity.ai.behavior.BehaviorControl
-import net.minecraft.world.entity.ai.behavior.BlockPosTracker
-import net.minecraft.world.entity.ai.behavior.declarative.BehaviorBuilder
-import net.minecraft.world.entity.ai.behavior.declarative.Trigger
-import net.minecraft.world.entity.ai.memory.MemoryModuleType
-import net.minecraft.world.entity.ai.memory.WalkTarget
-import net.minecraft.world.entity.player.Player
-import net.minecraft.world.phys.Vec3
-import java.util.UUID
-
-class HuntPlayerTaskConfig : SingleTaskConfig {
-    // todo make new variables
-    companion object {
-        const val BREED = "breed"
-    }
-
-    val condition = booleanVariable(BREED, "breeds", true).asExpressible()
-    val speedMultiplier = numberVariable(BREED, "speed_multiplier", 0.6).asExpressible()
-
-    override fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext) = listOf(
-        condition,
-        speedMultiplier
-    ).asVariables()
-
-    override fun createTask(
-        entity: LivingEntity,
-        brainConfigurationContext: BehaviourConfigurationContext
-    ): BehaviorControl<in LivingEntity>? {
-        runtime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
-        if (!condition.resolveBoolean() || entity !is PokemonEntity) return null
-
-        return BehaviorBuilder.create {
-            it.group(
-                it.present(MemoryModuleType.LOOK_TARGET),
-                it.absent(MemoryModuleType.WALK_TARGET),
-                it.present(MemoryModuleType.NEAREST_PLAYERS), // this will be null most of the time
-                it.present(MemoryModuleType.ANGRY_AT),
-                it.registered(MemoryModuleType.ATTACK_TARGET),
-                it.registered(MemoryModuleType.DISTURBANCE_LOCATION),
-            ).apply(it) { lookTarget, walkTarget, nearestPlayers, angryAt, attackTarget, disturbanceLocation ->
-                Trigger { world, entity, time ->
-                    if (entity !is PathfinderMob || !entity.isAlive || entity !is PokemonEntity) return@Trigger false
-
-                    runtime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
-
-                    val angryAtUuid = (angryAt.value() as? IdF<UUID?>)?.value() ?: return@Trigger false
-                    val disturbancePos = (disturbanceLocation.value() as? IdF<BlockPos>)?.value()
-
-                    val players = (nearestPlayers.value() as? IdF<List<Player?>?>)?.value()
-                    val targetPlayer = players?.find { it?.uuid == angryAtUuid }
-
-                    if (targetPlayer != null) {
-                        // If the angry player is nearby, set them as the attack target
-                        entity.cry()
-                        attackTarget.set(targetPlayer)
-                        return@Trigger true
-                    }
-
-                    // If the angry player is not nearby, search around the Pokémon
-                    val maxTicksToSearch = 200L
-                    if (time > maxTicksToSearch) {
-                        // Timeout after 200 ticks
-                        return@Trigger false
-                    }
-
-                    // If no disturbance location or it is caused by a nearby player, skip
-                    if (disturbancePos != null) {
-                        val disturberCausingDisturbance = players?.any {
-                            it?.position()?.distanceToSqr(Vec3.atCenterOf(disturbancePos))!! <= 4.0 * 4.0
-                        }
-                        disturberCausingDisturbance?.let { it1 ->
-                            if (!it1) {
-                                // Pathfind toward disturbance location
-                                walkTarget.set(WalkTarget(Vec3.atCenterOf(disturbancePos), speedMultiplier.resolveFloat(), 1))
-                                lookTarget.set(BlockPosTracker(Vec3.atCenterOf(disturbancePos)))
-                                return@Trigger true
-                            }
-                        }
-                    }
-
-                    // If no valid disturbance location, pathfind randomly within proximity
-                    val validPosition = findValidWalkablePosition(world, entity.position(), entity, 8)
-                    if (validPosition == null) {
-                        return@Trigger false // No valid position found
-                    }
-
-                    walkTarget.set(WalkTarget(validPosition, speedMultiplier.resolveFloat(), 1))
-                    lookTarget.set(BlockPosTracker(validPosition.add(0.0, entity.eyeHeight.toDouble(), 0.0)))
-
-                    return@Trigger true
-                }
-            }
-        }
-    }
-
-    private fun findValidWalkablePosition(
-        world: ServerLevel,
-        center: Vec3,
-        entity: PathfinderMob,
-        radius: Int
-    ): Vec3? {
-        val random = world.random
-
-        // Try a number of random positions within the radius
-        repeat(20) { // Attempt up to 20 random positions
-            val offsetX = random.nextDouble() * 2 * radius - radius
-            val offsetY = random.nextDouble() * 2 * radius - radius
-            val offsetZ = random.nextDouble() * 2 * radius - radius
-            val candidate = center.add(offsetX, offsetY, offsetZ)
-
-            // Convert to block position
-            val blockPos = BlockPos(candidate.x.toInt(), candidate.y.toInt(), candidate.z.toInt())
-
-            // Check if the position is walkable and not inside a solid block
-            if (world.getBlockState(blockPos).isSolidRender(world, blockPos).not() &&
-                entity.navigation.isStableDestination(blockPos)
-            ) {
-                return Vec3.atCenterOf(blockPos) // Return the valid position
-            }
-        }
-
-        return null // No valid position found
-    }
-}*/
@@ -82,7 +82,7 @@ interface TaskConfig {
            cobblemonResource("walk_away_from_avoid_target") to WalkAwayFromAvoidTargetTaskConfig::class.java,
            cobblemonResource("flee_nearest_hostile") to FleeNearestHostileTaskConfig::class.java,
            cobblemonResource("flee_attacker") to FleeAttackerTaskConfig::class.java,
-//            cobblemonResource("fly_in_circles") to FlyInCirclesTaskConfig::class.java,
+            cobblemonResource("fly_in_circles") to FlyInCirclesTaskConfig::class.java,
            cobblemonResource("run_script") to RunScript::class.java,
            cobblemonResource("look_in_direction") to LookInDirectionTaskConfig::class.java,
            cobblemonResource("wake_up") to WakeUpTaskConfig::class.java,
@@ -93,12 +93,9 @@ interface TaskConfig {
            cobblemonResource("switch_from_sleep_on_trainer_bed") to SwitchFromSleepOnTrainerBedTaskConfig::class.java,
            cobblemonResource("sleep_if_on_trainer_bed") to SleepIfOnTrainerBedTaskConfig::class.java,
            cobblemonResource("point_to_spawn") to PointToSpawnTaskConfig::class.java,
-//            cobblemonResource("eat_grass") to EatGrassTaskConfig::class.java,
+            cobblemonResource("eat_grass") to EatGrassTaskConfig::class.java,
            cobblemonResource("find_air") to FindAirTaskConfig::class.java,
            cobblemonResource("go_to_land") to GoToLandTaskConfig::class.java,
-            cobblemonResource("go_to_land") to GoToLandTaskConfig::class.java,
-            /*cobblemonResource("hunt_player") to HuntPlayerTaskConfig::class.java,*/
-            cobblemonResource("go_to_land") to GoToLandTaskConfig::class.java,
            cobblemonResource("path_to_hive") to PathToBeeHiveTaskConfig::class.java,
            cobblemonResource("place_honey_in_hive") to PlaceHoneyInHiveTaskConfig::class.java,
            cobblemonResource("place_honey_in_sacc_leaves") to PlaceHoneyInSaccLeavesTaskConfig::class.java,
@@ -174,4 +171,4 @@ interface TaskConfig {
    fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): List<MoLangConfigVariable>
    /** Given the entity in construction, returns a list of tasks. */
    fun createTasks(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): List<BehaviorControl<in LivingEntity>>
-}
+}
@@ -133,10 +133,11 @@ 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>()
+    val afterDispatches = mutableListOf<() -> Unit>()

    val captureActions = mutableListOf<BattleCaptureAction>()

@@ -404,10 +405,12 @@ open class PokemonBattle(

    fun dispatch(dispatcher: () -> DispatchResult) {
        dispatches.add(BattleDispatch { dispatcher() })
+
    }

    fun dispatchToFront(dispatcher: () -> DispatchResult) {
        dispatches.addFirst(BattleDispatch { dispatcher() })
+
    }

    fun dispatchWaitingToFront(delaySeconds: Float = 1F, dispatcher: () -> Unit) {
@@ -458,12 +461,21 @@ open class PokemonBattle(
        dispatches.addFirst(dispatcher)
    }

+    fun doWhenClear(action: () -> Unit) {
+        afterDispatches.add(action)
+    }
+
    fun tick() {
        try {
            while (dispatchResult.canProceed()) {
                val dispatch = dispatches.poll() ?: break
                dispatchResult = dispatch(this)
            }
+
+            if (dispatches.isEmpty()) {
+                afterDispatches.toList().forEach { it() }
+                afterDispatches.clear()
+            }
        } catch (e: Exception) {
            LOGGER.error("Exception while ticking a battle. Saving battle log.", e)
            val message = battleLang("crash").red()
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Paul	64e0c91e73	Added category to Behaviours backend	2026-04-25 11:21:47 +10:00
Paul	fd443785ad	Added majority of functionality for premade NPCs	2026-04-20 09:43:00 +10:00
Paul	810ce8b759	Outline work for premade NPCs as a logical replacement for NPC presets	2026-04-18 11:35:40 +10:00
Paul	aad115e43a	Merge remote-tracking branch 'origin/main' into npc-upgrades # Conflicts: # common/src/main/kotlin/com/cobblemon/mod/common/entity/ai/OmniPathNavigation.kt # common/src/main/kotlin/com/cobblemon/mod/common/entity/pokemon/PokemonEntity.kt	2026-04-13 13:35:52 +10:00