Added category to Behaviours backend

# 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

CHANGELOG-AI-2.md

@@ -0,0 +1,11 @@
+### Additions
+
+### Changes
+- Replaced the entity AI for Pokémon and NPCs with an entirely custom one. Yeah we changed the entity AI in 1.7 too, you're remembering right.
+- Improved performance of entity AI.
+
+### Fixes
+
+### Developer
+
+### Molang & Datapacks

CHANGELOG.md

@@ -1,57 +1,58 @@
 # Changelog
-## [1.7.1 (MONTH xth, 2025)](#1-7-1)
+## [1.7.4 (MONTH Xth, 2026)](#1-7-4)
 
 ### Additions
-- Added trades for Saccharine Saplings, Hearty Grains, Chipped Pot, and Masterpiece Teacup to the Wandering Trader.
-- Added brewing recipe for Throat Spray.
+- 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
+
+### Model updates for the following Pokémon
+
+### Animation updates for the following Pokémon
 
 ### Changes
-- Converted the riding freelook button to a configurable keybinding.
-- Reduced the cost of the Vivichoke Seed trade with the Wandering Trader.
+- 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
-- Prevent displaying ride controls overlay to passengers.
-- Fixed player suffocation on vanilla mounts experienced on some worlds.
-- Fixed Poké Snack spawning sounds not coming from the block.
-- Fix player suffocation on vanilla mounts experienced on some worlds.
-- Stop passengers from hearing the shiny noise of a ridden shiny Pokémon.
-- Fixed incorrect camera pivot on Bird, Jet, and Dolphin mounts.
-- Fixed Poké Snack spawning sound positioning.
-- Ponigiri can no longer be eaten at full hunger.
-- Medicinal Brew's Campfire Pot recipe now correctly displays that it can be made using an empty glass bottle or a filled bottle.
-- Fixed a crash when you place a block in the way of hearty grains 2nd block
-- Fixed a graphics crash that could occur on some machines when campfires were nearby.
-- Fixed glass bottle not being returned when honey-ing a saccharine leaf block
-- Fixed Combees not depositing honey upon leaving a hive if they entered with nectar.
-- Fixed pastured Combees not moving in night or rain.
-- Fixed a case in which a Combee might try to path to a flower that no longer exists.
-- Fixed Combees attempting to enter a full hive.
-- Fixed a crash involving Combees and hives.
-- Fixed crashing and rendering issues when opening a PC box with certain wallpapers.
-- Fixed a crash when opening a PC box with certain wallpapers while using *VulkanMod*.
-- Fixed a glitch where friendship would reset to the default value when evolving a Pokémon.
-- Fixed a crashed related to NPC navigation.
-- Fix player suffocation on vanilla mounts experienced on some worlds.
-- Stop passengers from hearing the shiny noise of a ridden shiny Pokémon.
-- Fixed friendship resetting to the default value when evolving a Pokémon.
-- Fixed a bunch of incompatibilities with NeoForge mods
-- Fixed a bug where wind charges hitting pasture blocks would recall all pokémon in it.
-- Home on the Range advancement shouldn't trigger when opening the Pokemon Menu (shift interact one, mr changelog guy)
-- Recipes using concrete should now work on NeoForge
-- Fixed saccharine hanging signs sometimes dropping their oak wood counterpart when being broken
+- 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
+- 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
-- Removed automatic generation of PC wallpaper screen glow if no asset is provided; it is now optional.
-
-### Particles
+- 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:
-  - French
-  - Japanese
-  - Korean
-  - Brazilian Portuguese
-  - Simplified Chinese
-  - Traditional Chinese

changelogs/CHANGELOG-1.7.1.md

@@ -0,0 +1,61 @@
+# Changelog
+## [1.7.1 (November 29th, 2025)](#1-7-1)
+
+### Additions
+- Added trades for Saccharine Saplings, Hearty Grains, Chipped Pot, and Masterpiece Teacup to the Wandering Trader.
+- Added brewing recipe for Throat Spray.
+- Added vanilla sprinting's field of view change to Pokémon land mounts.
+- Added a customizable keybind for the riding freelook button.
+- Added double tap to sprint on land mounts.
+
+### Changes
+- Made Jet pitch turning 1.5x faster across all Pokémon.
+- Party Pokémon now attack only mobs that are attacking their owner, instead of randomly targeting unrelated mobs and getting themselves hurt.
+- Reduced the cost of the Vivichoke Seed trade with the Wandering Trader.
+
+### Fixes
+- Fixed incorrect camera pivot on Bird, Jet, and Dolphin mounts, leading to some disorienting riding.
+- Fixed players suffocating while on vanilla mounts.
+- Fixed a graphics crash that could occur on some machines when campfire pots were nearby.
+- Fixed ride controls overlay being displayed to passengers. The passengers probably don't need to know about those.
+- Fixed mount jumping so that it doesn't switch back to ground animations.
+- Fixed ridden Pokémon land collision and some issues around stepping up blocks. Land mounts are smoother overall now.
+- Fixed Furfrou's pink and magenta trims being swapped. Only a man could make that mistake.
+- Fixed friendship being reset to the default value when evolving a Pokémon.
+- Fixed Combees not depositing honey upon leaving a hive if they entered it with nectar.
+- Fixed pastured Combees not moving during the night or in rain.
+- Fixed a case in which a Combee might try to path to a flower that no longer exists.
+- Fixed Combees attempting to enter a full hive.
+- Fixed a crash involving Combees and hives. 500 bee bugs. Bugged bees? We can be bees. Mark, this is good news.
+- Fixed a crash related to NPC navigation.
+- Fixed a crash when opening a PC box with certain wallpapers while using *VulkanMod*.
+- Fixed a crash when you place a block in the way of hearty grains 2nd block.
+- Fixed passengers hearing the shiny noise of a ridden shiny Pokémon.
+- Ponigiri can no longer be eaten at full hunger.
+- Fixed Poké Snack spawning sounds not coming from the block.
+- Medicinal Brew's Campfire Pot recipe now correctly displays that it can be made using an empty glass bottle or a filled bottle.
+- Fixed glass bottle not being returned when slathering honey on a saccharine leaf block.
+- Fixed saccharine hanging signs sometimes dropping their oak wood counterpart when being broken.
+- Fixed a bunch of incompatibilities with NeoForge mods.
+- Fixed a bug where wind charges hitting pasture blocks would recall all Pokémon in it.
+- Fixed the Home on the Range advancement triggering when opening the Pokémon interaction wheel.
+- Fixed recipes that use concrete not working on NeoForge.
+- Fixed Boltund's model.
+- Fixed Cyclizar's textures.
+
+### Developer
+
+### Molang & Datapacks
+- Removed automatic generation of PC wallpaper screen glow if no asset is provided; it is now optional.
+    - This is because there's no practical way to do this without blowing up things like *VulkanMod*.
+
+### Particles
+
+### Localization
+- Updated translations for:
+    - French
+    - Japanese
+    - Korean
+    - Brazilian Portuguese
+    - Simplified Chinese
+    - Traditional Chinese

changelogs/CHANGELOG-1.7.2.md

@@ -0,0 +1,137 @@
+# Changelog
+## [1.7.2 (January 25th, 2026)](#1-7-2)
+
+### Additions
+- Added Saccharine wood furniture for Adorn.
+- Added the Partner Mark, which party Pokémon have a very small chance to earn as the player walks, provided they have enough friendship.
+- Added decorative block models for existing items: Potion, Super Potion, Hyper Potion, Max Potion, Full Restore, Antidote, Awakening, Burn Heal, Ice Heal, Paralyze Heal, Full Heal, Ether, Elixir, Max Ether, Max Elixir, X Accuracy, X Attack, X Defence, X Special Attack, X Special Defence, X Speed, Dire Hit, Guard Spec, Weakness Policy, Blunder Policy, Cleanse Tag, and Spell Tag.
+- Added decorative sign blocks called Plaques.
+- Added ride style labels to ride stats in Pokédex, as well as ride style icons in the summary GUI.
+- Added more seasonings for sinister tea:
+  - Mental Herb - Mental Restoration I for 10 seconds, which staves off Insomnia.
+  - White Herb - Removes negative effects.
+  - Milk, Moomoo Milk - Removes effects.
+- Added dispenser support for:
+  - Applying a Honey Bottle to Saccharine Logs.
+  - Washing honey off of Saccharine Slathered Logs.
+  - Applying and removing honey on Saccharine Leaves.
+- Added riding statistics: `Distance by Pokémon on Land`, `Distance by Pokémon in Air` and `Distance by Pokémon in Liquid`.
+
+### New rideable Pokémon
+- Honchkrow 
+- Mantine
+
+### Pokémon Added
+
+#### Gen 5
+- Throh
+- Sawk
+
+#### Gen 6
+- Litleo
+- Pyroar
+- Spritzee
+- Aromatisse
+- Swirlix
+- Slurpuff
+
+### Model updates for the following Pokémon
+- Falinks
+- Cottonee
+- Whimsicott
+- Ferroseed
+- Ferrothorn
+- Chingling
+- Chimecho
+
+### Animation updates for the following Pokémon
+- Mantine (ride animations)
+- Flygon (ride jump animation)
+- Honchkrow (ride animations)
+- Croagunk
+- Toxicroak
+
+### Changes
+- Added a new config option, `Enable In-Flight Dismounting` (default: off), which lets you dismount while riding a Pokémon in the air. This is the textbook definition of caveat emptor.
+- Ride sounds have been separated into stereo for passengers and mono for other players. Riding will now sound more spacious.
+- Battle AI now uses a smarter threshold for switching, reducing unnecessary switches.
+- AI will always use the most damaging move when at low HP and when it is not switching, improving endgame decision-making.
+- Items given from interacting with Saccharine Leaves are placed in the active hotbar slot if possible.
+- Added `label` as an alternate key to the `tag` property.
+
+### Fixes
+- Fixed crashing when viewing another player in spectator mode. Some said this was reason to release this update a month ago. They were probably right.
+- Fixed crashing when sending a Pokémon out after editing its form.
+- Fixed all Pokémon being saved to chunks and never despawning even when they should be.
+- Fixed Poké Snacks crashing if there was no available spawn.
+- Fixed Poké Snack / Bait effects so that EV Yield, Type, and Egg Group filters now all apply together when weighting spawns. And you thought you were going crazy.
+- Fixed Furfrou not being trimmable on NeoForge specifically.
+- Fixed honey from Saccharine Leaves being harvestable at less than the max age.
+- Fixed possible error on world generation when Combee are placed in naturally generated bee nests.
+- Fixed Galarian Weezing crashing the world if it decides to blink the wrong way. The same could happen to you!
+- Fixed Galarian Mr. Mime incorrectly being rideable. Some would argue that regular Mr. Mime shouldn't be rideable, but that would make them wrong.
+- Fixed missing apricorn textures for Adorn blocks.
+- Fixed Apricorn block model rotation for counters/sinks/cupboards/drawers to match that of most recent version of Adorn.
+- Fixed item interaction sometimes not working properly when playing on servers.
+- Fixed Mint Leaves not being usable for filling the Resurrection Machine.
+- Fixed Super Potion recipes incorrectly using Hondew Berry instead of Aguav Berry. They look similar, to be fair.
+- Fixed Wishiwashi not schooling properly.
+- Fixed battle item duplication issue. How did it work? Wouldn't you like to know, weather boy.
+- Fixed the ordering of Aprijuice's riding stat boosts so they always have the same order.
+- Fixed the movesets of certain Pokémon being incorrectly sanitized upon reload, causing some forms to keep losing moves.
+- Fixed selected leading Pokémon in battle not being used when levels are set.
+- Fixed the bottom half of pasture blocks having an incorrect hit-box when facing north or south.
+- Fixed gimmicks not being usable in double and triple battles.
+- Fixed gimmick buttons showing when already used in the same turn in double and triple battles.
+- Fixed mochi items consuming two items at a time.
+- Fixed Fresh Start Mochi's EV reset not syncing health changes properly.
+- Fixed Pokémon spawn influences not being specific to regional forms.
+- Fixed memory leak from battles not being cleaned up after ending.
+- Fixed orientation not getting reset after crashing while flying and getting back on the Pokémon.
+- Fixed shiny Pokémon not respecting the `silent` flag on spawn.
+- Fixed 'Plain' prefix not being applied to all low-quality Aprijuice.
+- Fixed Pokémon interactions not playing sound effects when the volume was not specified.
+- Fixed Pokémon interaction cooldowns taking longer than intended when the Pokémon was in the player’s party.
+- Fixed Pokémon interactions occasionally crashing the game when spamming an interaction with a 0 cooldown.
+- Fixed Pokémon fullness decreasing more than intended when the Pokémon was pastured.
+- Fixed Scraggy line, Milcery line, and Morpeko spawning on unnatural blocks. 
+- Fixed invulnerability-bypassed damage being resisted by invulnerable NPC entities.
+- Fixed Fabric network packets not being handled immediately, fixing incompatibilities with Supplementaries, Prometheus, Sleep Tight, and others.
+- Fixed killer not being set early enough on a wild Pokémon entity from `WinInstruction`.
+- Fixed requirements such as `biomeCondition` crashing the game when used to define Pokémon interactions.
+- Fixed an issue that prevented registering custom dispenser behaviours (no longer overrides vanilla behaviour).
+- Fixed an issue navigation that prevented Combee from pathing into and out of Saccharine Leaves.
+- Added Saccharine Boats and Saccharine Boat with Chests to relevant boat tags.
+- Fixed Soothe Bell not being properly tagged as a held item.
+- Fixed `/calculateseatpositions` expecting a locator format that even we don't use. It needs an underscore after "seat".
+- Fixed the `run_script` Molang function to not fail if the environment's context is null.
+- Fixed the Molang functions `date_local_time`, `date_of`, `date_is_after` to use the correct date format.
+
+### Developer
+- Changed the `owner` parameter in the `OwnerQueryRequirement` interface from `ServerPlayer` to `Player`. This method is now also called on the client to verify whether a Pokémon interaction succeeded, so make sure to update your implementations to handle both server and client contexts.
+- Added the `pnx` to the `BattleFaintedEvent` and `FormeChangeEvent`.
+- Added register methods for custom instructions to `ShowdownInterpreter`.
+- Changed callback operations in `BattlePokemon` to allow multiple callbacks and be mutable.
+- Added `display_name`, `description`, and `max_pp` functions to the `MoveTemplate` struct.
+- Changed the implementations of `AIBattleActor` to be open classes to allow extension.
+- Changed the resource location of Poké Ball icons in the GUI to use the balls namespace instead of Cobblemon's, allowing mods to properly use their own namespace for these textures.
+
+### Molang & Datapacks
+- Ride sounds can now be set as exclusive to passengers.
+- Ride sounds no longer play when submerged unless specified with a new setting.
+- Exception handling has been added to `run_molang`, resolving some crashes caused by malformed MoLang expressions.
+- Added the `create_itemstack`, `has_inventory_space`, `set_inventory_slot`, and `give_item` MoLang functions for item and inventory utility.
+- Added the `get_move_from_id` MoLang function for general move info queries without requiring a Moveset object to access.
+- Added support for optional message variants in battle activate instructions for more context-specific battle text.
+  - Example: `this.add('-activate', pokemon, 'ability: example', '[msg]message1');` will parse to lang key `cobblemon.battle.activate.example.message1`.
+
+### Localization
+- Updated translations for:
+  - French
+  - Canadian French
+  - Simplified Chinese
+  - Ukrainian
+  - Brazilian Portuguese
+  - Spanish
+  - Korean
+  - Japanese

changelogs/CHANGELOG-1.7.3.md

@@ -0,0 +1,22 @@
+# Changelog
+## [1.7.3 (January 31st, 2026)](#1-7-3)
+
+### Fixes
+- Fixed mounted Pokémon not playing sounds.
+- Fixed players failing to join servers randomly.
+- Fixed some Pokémon having no stamina for flying.
+- Fixed `/pctake` not respecting the actual size of the PC.
+### Developer
+- Poké Ball GUI textures now respect the ball's namespace, enabling proper texture loading for custom balls from other mods.
+
+### Molang & Datapacks
+- Added a `chance` requirement type for Pokémon interactions.
+
+### Localization
+- Updated translations for:
+  - French
+  - Canadian French
+  - Korean
+  - Portuguese
+  - Simplified Chinese
+  - Spanish

common/build.gradle.kts

@@ -55,7 +55,7 @@ dependencies {
     // modCompileOnly(libs.flywheelFabric)
 
     // Showdown
-    modCompileOnly(libs.graal)
+    modCompileOnly(libs.graal.core)
 
     // Data Storage
     modCompileOnly(libs.bundles.mongo)

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

@@ -11,7 +11,9 @@ package com.cobblemon.mod.common.mixin;
 
 import com.cobblemon.mod.common.CobblemonMemories;
 import com.cobblemon.mod.common.api.ai.config.task.PathToBeeHiveTaskConfig;
+import com.cobblemon.mod.common.api.pokemon.PokemonProperties;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import com.cobblemon.mod.common.world.feature.SaccharineTreeFeature;
 import net.minecraft.core.BlockPos;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.tags.BlockTags;
@@ -42,7 +44,21 @@ public abstract class BeeOccupantMixin {
         if (cir.getReturnValue() == null) {
             final BeehiveBlockEntity.Occupant occupant = (BeehiveBlockEntity.Occupant) (Object) this;
             CompoundTag compoundTag = occupant.entityData().copyTag();
-            Entity entity = EntityType.loadEntityRecursive(compoundTag, level, (entityx) -> entityx);
+            String id = compoundTag.getString("id");
+            Entity entity = null;
+            if (id.equals(SaccharineTreeFeature.Companion.getPOKEMON_PLACEHOLD_ID())) {
+                // Special case for Pokemon stuffed into a beenest upon world gen.
+                // For technical reasons we cannot create them as full entities during world gen.
+                // So we look for this special id tag and complete the entity when it attempts to exit a hive.
+                if (compoundTag.contains("pokemonProperties")) {
+                    String properties = compoundTag.getString("pokemonProperties");
+                    PokemonProperties pokemon = PokemonProperties.Companion.parse(properties);
+                    entity = pokemon.createEntity(level);
+                }
+            } else {
+                entity = EntityType.loadEntityRecursive(compoundTag, level, (entityx) -> entityx);
+            }
+
             if (entity instanceof PokemonEntity pokemonEntity) {
                 var state = level.getBlockState(pos);
                 var newPos = Vec3.ZERO;
@@ -51,14 +67,14 @@ public abstract class BeeOccupantMixin {
                 if (state.is(BlockTags.BEEHIVES)) {
                     // position in front of the entrance, face away from the block
                     var facing = state.getValue(HorizontalDirectionalBlock.FACING);
-                    newPos = pos.relative(facing).getCenter();
+                    newPos = pos.relative(facing).getBottomCenter();
                     newYaw = facing.toYRot();
                     if (brain.checkMemory(CobblemonMemories.HIVE_LOCATION, MemoryStatus.REGISTERED)) {
                         brain.setMemory(CobblemonMemories.HIVE_LOCATION, pos); // This needs to be set in the case that the hive was picked up and moved.
                     }
                 } else {
                     // Block has likely been destroyed
-                    var center = pos.getCenter();
+                    var center = pos.getBottomCenter();
                     newPos = new Vec3(
                             center.x + level.random.nextFloat() * 0.6 - 0.3,
                             center.y + level.random.nextFloat() * 0.6 - 0.3,

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

@@ -15,6 +15,8 @@ import com.cobblemon.mod.common.api.events.CobblemonEvents;
 import com.cobblemon.mod.common.api.events.item.LeftoversCreatedEvent;
 import com.cobblemon.mod.common.api.orientation.OrientationController;
 import com.cobblemon.mod.common.api.pokemon.PokemonSpecies;
+import com.cobblemon.mod.common.api.riding.RidingStyle;
+import com.cobblemon.mod.common.api.riding.behaviour.types.air.HoverBehaviour;
 import com.cobblemon.mod.common.api.storage.party.PartyStore;
 import com.cobblemon.mod.common.api.storage.party.PlayerPartyStore;
 import com.cobblemon.mod.common.api.tags.CobblemonItemTags;
@@ -59,6 +61,7 @@ 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.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
@@ -169,6 +172,32 @@ public abstract class PlayerMixin extends LivingEntity implements ScannableEntit
         }
     }
 
+    @Redirect(
+            method = "getDestroySpeed",
+            at = @At(
+                    value = "INVOKE",
+                    target = "Lnet/minecraft/world/entity/player/Player;onGround()Z"
+            )
+    )
+    private boolean cobblemon$considerHoverOnGround(Player player) {
+        // If riding a Hover Mount, return true to bypass the 5x slowdown
+        if (player.getVehicle() instanceof PokemonEntity vehicle) {
+
+            var ridingController = vehicle.getRidingController();
+            if (ridingController == null) player.onGround();
+
+            var activeContext = ridingController.getContext();
+            if (activeContext == null) player.onGround();
+
+            if (activeContext.getStyle() == RidingStyle.AIR &&
+                activeContext.getBehaviour().equals(HoverBehaviour.Companion.getKEY())) {
+                return true;
+            }
+        }
+        // Otherwise, return the actual value
+        return player.onGround();
+    }
+
     @Inject(
         method = "eat",
         at = @At(

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

@@ -11,11 +11,15 @@ package com.cobblemon.mod.common.mixin;
 import com.cobblemon.mod.common.Cobblemon;
 import com.cobblemon.mod.common.OrientationControllable;
 import com.cobblemon.mod.common.PlayerSpawnerAccessor;
+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.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.level.ServerLevel;
 import net.minecraft.server.level.ServerPlayer;
@@ -89,4 +93,32 @@ public abstract class ServerPlayerMixin implements PlayerSpawnerAccessor {
     private boolean cobblemon$cancelSavingPokemonMounts(boolean original, @Local(ordinal=0) Entity entity) {
         return original && !(entity instanceof PokemonEntity);
     }
+
+    @WrapOperation(method = "checkRidingStatistics", at = @At(value = "INVOKE", target = "Lnet/minecraft/server/level/ServerPlayer;getVehicle()Lnet/minecraft/world/entity/Entity;"))
+    public Entity cobblemon$checkRidingStatistics(ServerPlayer player, Operation<Entity> original, @Local int distance) {
+        var entity = original.call(player);
+        if (!(entity instanceof PokemonEntity pokemonEntity)) {
+            return entity;
+        }
+
+        var ridingController = pokemonEntity.getRidingController();
+        if (ridingController == null) return entity;
+
+        var activeContext = ridingController.getContext();
+        if (activeContext == null) return entity;
+
+        var ridingStyle = activeContext.getStyle();
+        CobblemonStats.CobblemonStat stat = switch (ridingStyle) {
+            case RidingStyle.LAND -> CobblemonStats.RIDING_LAND;
+            case RidingStyle.AIR -> CobblemonStats.RIDING_AIR;
+            case RidingStyle.LIQUID -> CobblemonStats.RIDING_LIQUID;
+            default -> null;
+        };
+
+        if (stat != null) {
+            player.awardStat(CobblemonStats.getStat(stat), distance);
+        }
+
+        return entity;
+    }
 }

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

@@ -0,0 +1,26 @@
+/*
+ * 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.world.item.Item;
+import net.minecraft.core.dispenser.DispenseItemBehavior;
+import net.minecraft.world.level.block.DispenserBlock;
+
+import java.util.Map;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(DispenserBlock.class)
+public interface DispenserBlockAccessor {
+	@Accessor("DISPENSER_REGISTRY")
+	static Map<Item, DispenseItemBehavior> getItemBehaviors() {
+		throw new AssertionError();
+	}
+}

common/src/main/java/com/cobblemon/mod/common/mixin/client/AbstractClientPlayerMixin.java

@@ -33,7 +33,7 @@ public class AbstractClientPlayerMixin {
             cir.setReturnValue(usageContext.getFovMultiplier());
         } else {
             // Only modify fov through riding if the pokedex is not open
-            LocalPlayer player = (LocalPlayer) (Object) this;
+            AbstractClientPlayer player = (AbstractClientPlayer) (Object) this;
             // Only modify fov for the driver and not the passengers
             if (player != null && player.isPassenger() && player.getVehicle() instanceof PokemonEntity && player.getVehicle().getControllingPassenger() == player) {
                 PokemonEntity ride = (PokemonEntity) player.getVehicle();

common/src/main/java/com/cobblemon/mod/common/mixin/client/MouseHandlerMixin.java

@@ -35,6 +35,7 @@ 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 com.cobblemon.mod.common.client.gui.party.PartyTutorialToasts;
 
 import static com.google.common.primitives.Floats.min;
 import static net.minecraft.util.Mth.lerp;
@@ -85,11 +86,13 @@ public abstract class MouseHandlerMixin {
                 CobblemonClient.INSTANCE.getStorage().shiftSelected(false);
                 ci.cancel();
                 PartySendBinding.INSTANCE.actioned();
+                PartyTutorialToasts.INSTANCE.onHoldKeyScrollSwitchedSlot();
             } else if (i < 0) {
                 accumulatedScrollY -= i;
                 CobblemonClient.INSTANCE.getStorage().shiftSelected(true);
                 ci.cancel();
                 PartySendBinding.INSTANCE.actioned();
+                PartyTutorialToasts.INSTANCE.onHoldKeyScrollSwitchedSlot();
             }
         }
     }
@@ -310,7 +313,7 @@ public abstract class MouseHandlerMixin {
         var playerRotater = (RidePassenger)player;
         playerRotater.cobblemon$setRideXRot(playerRotater.cobblemon$getRideXRot() + f);
         playerRotater.cobblemon$setRideYRot(playerRotater.cobblemon$getRideYRot() + g);
-        playerRotater.cobblemon$setRideXRot(Mth.clamp(playerRotater.cobblemon$getRideXRot(), -90.0F, 90.0F));
+        playerRotater.cobblemon$setRideXRot(Mth.clamp(playerRotater.cobblemon$getRideXRot(), -89.0F, 89.0F));
         playerRotater.cobblemon$setRideYRot(Mth.clamp(playerRotater.cobblemon$getRideYRot(), -105.0F, 105.0F));
         if (player.getVehicle() != null) {
             player.getVehicle().onPassengerTurned(player);

common/src/main/java/com/cobblemon/mod/common/mixin/entity/EntityMixin.java

@@ -14,9 +14,14 @@ import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
 import com.cobblemon.mod.common.pokemon.Pokemon;
 import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import com.llamalad7.mixinextras.sugar.Local;
+import com.llamalad7.mixinextras.sugar.Share;
+import com.llamalad7.mixinextras.sugar.ref.LocalBooleanRef;
+import com.llamalad7.mixinextras.sugar.ref.LocalFloatRef;
 import net.minecraft.client.player.LocalPlayer;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
+import net.minecraft.util.Mth;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.level.Level;
@@ -50,16 +55,8 @@ public abstract class EntityMixin {
             )
     )
     public boolean cobblemon$forceOnGroundForStepUp(Entity entity, Operation<Boolean> original) {
-        if (entity instanceof PokemonEntity && entity.hasControllingPassenger()) {
-            BlockPos below = entity.blockPosition().below();
-            Level level = entity.level();
-            var blockStateBelow = level.getBlockState(below);
-            boolean isAirOrLiquid = blockStateBelow.isAir() || !blockStateBelow.getFluidState().isEmpty();
-            boolean canSupportEntity = blockStateBelow.isFaceSturdy(level, below, Direction.UP);
-            boolean standingOnSolid = canSupportEntity && !isAirOrLiquid;
-            if (standingOnSolid) {
-                return true;
-            }
+        if (entity instanceof PokemonEntity vehicle && entity.hasControllingPassenger()) {
+            return true;
         }
         return original.call(entity);
     }
@@ -97,4 +94,61 @@ public abstract class EntityMixin {
         cir.setReturnValue(customEyePos);
     }
 
+
+    @WrapOperation(
+            method = "push(Lnet/minecraft/world/entity/Entity;)V",
+            at = @At(value = "INVOKE", target = "Lnet/minecraft/world/entity/Entity;push(DDD)V", ordinal = 0)
+    )
+    public void cobblemon$customPusherLogic(Entity pusher, double x, double y, double z,
+                                            Operation<Void> original,
+                                            @Local(argsOnly = true) Entity pushee,
+                                            @Local(name = "e") double e, @Local(name = "d") double d,
+                                            @Share("pusherIsPlayerOrPokemon") LocalBooleanRef pusherIsPlayerOrPokemon,
+                                            @Share("pusheeIsPlayerOrPokemon") LocalBooleanRef pusheeIsPlayerOrPokemon,
+                                            @Share("pusheeReceivedForce")LocalFloatRef pusheeReceivedForce) {
+        pusherIsPlayerOrPokemon.set(pusher instanceof PokemonEntity || pusher instanceof Player);
+        pusheeIsPlayerOrPokemon.set(pushee instanceof PokemonEntity || pushee instanceof Player);
+
+        if (!pusheeIsPlayerOrPokemon.get() || !pusherIsPlayerOrPokemon.get()) {
+            original.call(pusher, x, y, z);
+            return;
+        }
+
+        /**********************************************
+         * Custom portion of the code:
+         * Handle collisions with weight in mind. Use
+         * the weight value of pokemon to determine
+         * which side gets what portion of the total
+         * force.
+         *********************************************/
+        // Weights in hectograms
+        // Check to see if the pusher or pushee is a player. 200ish pounds. Steve's like a 6'6 miner
+        var pusherWeight = pusher instanceof PokemonEntity pusherPokemon ? pusherPokemon.getPokemon().getSpecies().getWeight() : 900F;
+        var pusheeWeight = pushee instanceof PokemonEntity pusheePokemon ? pusheePokemon.getPokemon().getSpecies().getWeight() : 900F;
+
+        // Calculate the portion of force received for both entities. Bigger receives less from the
+        // collision than the smaller one.
+        var totalWeight = pusherWeight + pusheeWeight;
+        var pusherReceivedForce = pusheeWeight / totalWeight * 2F;
+        pusheeReceivedForce.set((pusherWeight / totalWeight) * 2F);
+
+        original.call(pusher, -d * pusherReceivedForce, 0.0, -e * pusherReceivedForce);
+    }
+
+    @WrapOperation(
+            method = "push(Lnet/minecraft/world/entity/Entity;)V",
+            at = @At(value = "INVOKE", target = "Lnet/minecraft/world/entity/Entity;push(DDD)V", ordinal = 1)
+    )
+    public void cobblemon$customPusheeLogic(Entity pusher, double x, double y, double z, Operation<Void> original,
+                                            @Local(name = "e") double e, @Local(name = "d") double d,
+                                            @Share("pusherIsPlayerOrPokemon") LocalBooleanRef pusherIsPlayerOrPokemon,
+                                            @Share("pusheeIsPlayerOrPokemon") LocalBooleanRef pusheeIsPlayerOrPokemon,
+                                            @Share("pusheeReceivedForce")LocalFloatRef pusheeReceivedForce) {
+        if (!pusheeIsPlayerOrPokemon.get() || !pusherIsPlayerOrPokemon.get()) {
+            original.call(pusher, x, y, z);
+            return;
+        }
+
+        original.call(pusher, d * pusheeReceivedForce.get(), 0.0, e * pusheeReceivedForce.get());
+    }
 }

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

@@ -21,6 +21,7 @@ import com.cobblemon.mod.common.api.events.CobblemonEvents.DATA_SYNCHRONIZED
 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
@@ -42,8 +43,8 @@ import com.cobblemon.mod.common.api.scheduling.ServerRealTimeTaskTracker
 import com.cobblemon.mod.common.api.scheduling.ServerTaskTracker
 import com.cobblemon.mod.common.api.spawning.BestSpawner
 import com.cobblemon.mod.common.api.spawning.CobblemonSpawningZoneGenerator
-import com.cobblemon.mod.common.api.spawning.position.AreaSpawnablePositionResolver
 import com.cobblemon.mod.common.api.spawning.SpawningZoneGenerator
+import com.cobblemon.mod.common.api.spawning.position.AreaSpawnablePositionResolver
 import com.cobblemon.mod.common.api.starter.StarterHandler
 import com.cobblemon.mod.common.api.stats.CobblemonStats
 import com.cobblemon.mod.common.api.storage.PokemonStoreManager
@@ -65,10 +66,14 @@ import com.cobblemon.mod.common.api.storage.player.adapter.PlayerDataMongoBacken
 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
-import com.cobblemon.mod.common.battles.*
+import com.cobblemon.mod.common.battles.BagItems
+import com.cobblemon.mod.common.battles.BattleFormat
+import com.cobblemon.mod.common.battles.BattleRegistry
+import com.cobblemon.mod.common.battles.BattleSide
+import com.cobblemon.mod.common.battles.ShowdownThread
 import com.cobblemon.mod.common.battles.actor.PokemonBattleActor
 import com.cobblemon.mod.common.battles.pokemon.BattlePokemon
-import com.cobblemon.mod.common.block.DispenserBehaviorRegistry
+import com.cobblemon.mod.common.block.dispenser.DispenserBehaviorRegistry
 import com.cobblemon.mod.common.client.CobblemonPack
 import com.cobblemon.mod.common.command.argument.*
 import com.cobblemon.mod.common.config.CobblemonConfig
@@ -77,8 +82,8 @@ import com.cobblemon.mod.common.config.constraint.IntConstraint
 import com.cobblemon.mod.common.config.starter.StarterConfig
 import com.cobblemon.mod.common.data.CobblemonDataProvider
 import com.cobblemon.mod.common.events.AdvancementHandler
-import com.cobblemon.mod.common.events.EntityCallbackHandler
 import com.cobblemon.mod.common.events.CallbackHandler
+import com.cobblemon.mod.common.events.EntityCallbackHandler
 import com.cobblemon.mod.common.events.PokedexHandler
 import com.cobblemon.mod.common.events.ServerTickHandler
 import com.cobblemon.mod.common.events.StatHandler
@@ -95,11 +100,23 @@ import com.cobblemon.mod.common.pokemon.feature.SlowpokeTailRegrowthSpeciesFeatu
 import com.cobblemon.mod.common.pokemon.feature.SlowpokeTailRegrowthSpeciesFeatureProvider
 import com.cobblemon.mod.common.pokemon.feature.TagSeasonResolver
 import com.cobblemon.mod.common.pokemon.helditem.CobblemonHeldItemManager
-import com.cobblemon.mod.common.pokemon.properties.*
-import com.cobblemon.mod.common.pokemon.properties.tags.PokemonFlagProperty
+import com.cobblemon.mod.common.pokemon.properties.AspectPropertyType
+import com.cobblemon.mod.common.pokemon.properties.BattleCloneProperty
+import com.cobblemon.mod.common.pokemon.properties.FreezeFrameProperty
+import com.cobblemon.mod.common.pokemon.properties.HiddenAbilityPropertyType
+import com.cobblemon.mod.common.pokemon.properties.LabelProperty
+import com.cobblemon.mod.common.pokemon.properties.NoAIProperty
+import com.cobblemon.mod.common.pokemon.properties.UnaspectPropertyType
+import com.cobblemon.mod.common.pokemon.properties.UncatchableProperty
 import com.cobblemon.mod.common.pokemon.stat.CobblemonStatProvider
 import com.cobblemon.mod.common.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
@@ -107,6 +124,17 @@ import com.mongodb.ConnectionString
 import com.mongodb.MongoClientSettings
 import com.mongodb.client.MongoClient
 import com.mongodb.client.MongoClients
+import java.io.File
+import java.io.FileReader
+import java.io.FileWriter
+import java.io.PrintWriter
+import java.util.UUID
+import java.util.concurrent.TimeUnit
+import kotlin.math.roundToInt
+import kotlin.properties.Delegates
+import kotlin.reflect.full.memberProperties
+import kotlin.reflect.jvm.isAccessible
+import kotlin.reflect.jvm.javaField
 import net.minecraft.client.Minecraft
 import net.minecraft.commands.synchronization.SingletonArgumentInfo
 import net.minecraft.resources.ResourceKey
@@ -119,17 +147,6 @@ import net.minecraft.world.level.Level
 import net.minecraft.world.level.storage.LevelResource
 import org.apache.logging.log4j.LogManager
 import org.apache.logging.log4j.Logger
-import java.io.File
-import java.io.FileReader
-import java.io.FileWriter
-import java.io.PrintWriter
-import java.util.*
-import java.util.concurrent.TimeUnit
-import kotlin.math.roundToInt
-import kotlin.properties.Delegates
-import kotlin.reflect.full.memberProperties
-import kotlin.reflect.jvm.isAccessible
-import kotlin.reflect.jvm.javaField
 
 object Cobblemon {
     const val MODID = CobblemonBuildDetails.MOD_ID
@@ -166,11 +183,13 @@ object Cobblemon {
     var wallpapers = mutableMapOf<UUID, Set<ResourceLocation>>()
 
     val serverPlayerStructs = mutableMapOf<UUID, ObjectValue<Player>>()
+    /** Player UUID to entity UUID that they're brain debuggin' */
+    val serverPlayerDebuggingPokemonBrainEntities = mutableMapOf<UUID, UUID>()
 
     val statistics: CobblemonStats = CobblemonStats
 
     @JvmStatic
-    val builtinPacks = listOf<CobblemonPack>(
+    val builtinPacks = listOf(
         CobblemonPack(id = "adorncompatibility", name = "Adorn Compatibility", packType = PackType.CLIENT_RESOURCES, activationBehaviour = ResourcePackActivationBehaviour.ALWAYS_ENABLED, neededMods = setOf("adorn")),
         CobblemonPack(id = "gyaradosjump", name = "Gyarados Jump Patterns", packType = PackType.CLIENT_RESOURCES, activationBehaviour = ResourcePackActivationBehaviour.DEFAULT_ENABLED),
         CobblemonPack(id = "regionbiasforms", name = "Region Bias Forms", packType = PackType.CLIENT_RESOURCES, activationBehaviour = ResourcePackActivationBehaviour.DEFAULT_ENABLED),
@@ -206,6 +225,7 @@ object Cobblemon {
         implementation.registerEntityDataSerializers()
         implementation.registerCriteria()
         implementation.registerEntitySubPredicates()
+        implementation.registerMobEffects()
         DispenserBehaviorRegistry.registerDispenserBehaviors()
 
         DropEntry.register("command", CommandDropEntry::class.java)
@@ -239,6 +259,7 @@ object Cobblemon {
             playerDataManager.onPlayerDisconnect(it.player)
             RequestManager.onLogoff(it.player)
             serverPlayerStructs.remove(it.player.uuid)
+            serverPlayerDebuggingPokemonBrainEntities.remove(it.player.uuid)
         }
         PlatformEvents.PLAYER_DEATH.subscribe {
             PCLinkManager.removeLink(it.player.uuid)
@@ -319,7 +340,7 @@ object Cobblemon {
 
         CustomPokemonProperty.register(UncatchableProperty)
         CustomPokemonProperty.register(BattleCloneProperty)
-        CustomPokemonProperty.register(PokemonFlagProperty)
+        CustomPokemonProperty.register(LabelProperty)
         CustomPokemonProperty.register(HiddenAbilityPropertyType)
         CustomPokemonProperty.register(AspectPropertyType)
         CustomPokemonProperty.register(UnaspectPropertyType)
@@ -344,6 +365,7 @@ object Cobblemon {
         }
         PlatformEvents.SERVER_STARTING.subscribe { event ->
             val server = event.server
+            PremadeNPCs.onServerLoading(server)
             MoLangLoadedFilesCache.initialize(server)
             playerDataManager = PlayerInstancedDataStoreManager().also { it.setup(server) }
 
@@ -455,7 +477,7 @@ object Cobblemon {
             server()?.getLevel(dimension)
         } else {
             val mc = Minecraft.getInstance()
-            return mc.singleplayerServer?.getLevel(dimension) ?: mc.level
+            mc.singleplayerServer?.getLevel(dimension) ?: mc.level
         }
     }
 

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

@@ -9,9 +9,12 @@
 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
+import com.cobblemon.mod.common.api.ai.config.objective.ObjectiveConfig
+import com.cobblemon.mod.common.api.ai.config.sense.SenseConfig
 import com.cobblemon.mod.common.api.ai.config.task.TaskConfig
 import com.cobblemon.mod.common.api.data.JsonDataRegistry
 import com.cobblemon.mod.common.api.data.JsonDataRegistry.Companion.JSON_EXTENSION
@@ -19,16 +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.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
@@ -55,6 +49,8 @@ object CobblemonBehaviours : JsonDataRegistry<CobblemonBehaviour> {
         .registerTypeAdapter(SensorType::class.java, SensorTypeAdapter)
         .registerTypeAdapter(BehaviourConfig::class.java, BehaviourConfigAdapter)
         .registerTypeAdapter(TaskConfig::class.java, TaskConfigAdapter)
+        .registerTypeAdapter(ObjectiveConfig::class.java, ObjectiveConfigAdapter)
+        .registerTypeAdapter(SenseConfig::class.java, SenseConfigAdapter)
         .registerTypeAdapter(
             TypeToken.getParameterized(Either::class.java, Expression::class.java, MoLangConfigVariable::class.java).type,
             ExpressionOrEntityVariableAdapter
@@ -102,6 +98,7 @@ object CobblemonBehaviours : JsonDataRegistry<CobblemonBehaviour> {
                         autoNPCBehaviours.add(behaviour)
                     }
                     data[resolvedIdentifier] = behaviour
+                    behaviour.id = resolvedIdentifier
                 }
             }
         }

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

@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common
 
 import com.cobblemon.mod.common.api.apricorn.Apricorn
+import com.cobblemon.mod.common.api.pokemon.stats.Stats
 import com.cobblemon.mod.common.block.*
 import com.cobblemon.mod.common.block.campfirepot.CampfireBlock
 import com.cobblemon.mod.common.block.LecternBlock
@@ -41,11 +42,11 @@ import net.minecraft.world.level.block.state.BlockBehaviour
 import net.minecraft.world.level.block.state.BlockState
 import net.minecraft.world.level.block.state.properties.BlockSetType
 import net.minecraft.world.level.block.state.properties.BlockStateProperties
-import net.minecraft.world.level.block.state.properties.BlockStateProperties.LIT
 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>() {
@@ -243,9 +244,9 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     val REVIVAL_HERB = this.create("revival_herb", RevivalHerbBlock(BlockBehaviour.Properties.of().pushReaction(PushReaction.DESTROY).mapColor(MapColor.PLANT).ignitedByLava().noCollission().instabreak().sound(CobblemonSounds.REVIVAL_HERB_SOUNDS)))
 
     @JvmField
-    val POKE_CAKE = this.create("poke_cake", PokeSnackBlock(BlockBehaviour.Properties.of().forceSolidOn().strength(0.5F).sound(SoundType.WOOL).pushReaction(PushReaction.DESTROY).lightLevel { if (it.getValue(LIT)) 3 else 0 }, false))
+    val POKE_CAKE = this.create("poke_cake", PokeSnackBlock(BlockBehaviour.Properties.of().forceSolidOn().strength(0.5F).sound(SoundType.WOOL).pushReaction(PushReaction.DESTROY).lightLevel { if (it.getValue(BlockStateProperties.LIT)) 3 else 0 }, false))
     @JvmField
-    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(LIT)) 3 else 0 }, true))
+    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", GrowableStoneBlock.STAGE_3, 7, 3, null)
@@ -477,6 +478,99 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     @JvmField
     val GIMMIGHOUL_CHEST = create("gimmighoul_chest", GildedChestBlock(BlockBehaviour.Properties.ofFullCopy(Blocks.CHEST).noOcclusion().sound(CobblemonSounds.GILDED_CHEST_SOUNDS), GildedChestBlock.Type.FAKE))
 
+    @JvmField
+    val WHITE_PLAQUE = create("white_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
+    @JvmField
+    val LIGHT_GRAY_PLAQUE = create("light_gray_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
+    @JvmField
+    val GRAY_PLAQUE = create("gray_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
+    @JvmField
+    val BLACK_PLAQUE = create("black_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
+    @JvmField
+    val BROWN_PLAQUE = create("brown_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
+    @JvmField
+    val RED_PLAQUE = create("red_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
+    @JvmField
+    val ORANGE_PLAQUE = create("orange_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
+    @JvmField
+    val YELLOW_PLAQUE = create("yellow_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
+    @JvmField
+    val LIME_PLAQUE = create("lime_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
+    @JvmField
+    val GREEN_PLAQUE = create("green_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
+    @JvmField
+    val CYAN_PLAQUE = create("cyan_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
+    @JvmField
+    val LIGHT_BLUE_PLAQUE = create("light_blue_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
+    @JvmField
+    val BLUE_PLAQUE = create("blue_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
+    @JvmField
+    val PURPLE_PLAQUE = create("purple_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
+    @JvmField
+    val MAGENTA_PLAQUE = create("magenta_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
+    @JvmField
+    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(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(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(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion().noCollission(), 14, 12, 1))
+    @JvmField
+    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))
+    @JvmField
+    val ANTIDOTE = create("antidote", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
+    @JvmField
+    val AWAKENING = create("awakening", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
+    @JvmField
+    val BURN_HEAL = create("burn_heal", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
+    @JvmField
+    val ICE_HEAL = create("ice_heal", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
+    @JvmField
+    val PARALYZE_HEAL = create("paralyze_heal", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
+
+    @JvmField
+    val ETHER = create("ether", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.ETHER))
+    @JvmField
+    val MAX_ETHER = create("max_ether", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.ETHER))
+    @JvmField
+    val ELIXIR = create("elixir", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.ETHER))
+    @JvmField
+    val MAX_ELIXIR = create("max_elixir", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.ETHER))
+
+    @JvmField
+    val POTION = create("potion", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.POTION))
+    @JvmField
+    val SUPER_POTION = create("super_potion", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.POTION))
+    @JvmField
+    val HYPER_POTION = create("hyper_potion", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.POTION))
+    @JvmField
+    val MAX_POTION = create("max_potion", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.MAX_POTION))
+    @JvmField
+    val FULL_RESTORE = create("full_restore", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.MAX_POTION))
+
+    @JvmField
+    val DIRE_HIT = create("dire_hit", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.BATTLE_ITEM))
+    @JvmField
+    val GUARD_SPEC = create("guard_spec", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.BATTLE_ITEM))
+    @JvmField
+    val X_ACCURACY = create("x_${Stats.ACCURACY.identifier.path}", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.BATTLE_ITEM))
+    @JvmField
+    val X_ATTACK = create("x_${Stats.ATTACK.identifier.path}", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.BATTLE_ITEM))
+    @JvmField
+    val X_DEFENSE = create("x_${Stats.DEFENCE.identifier.path}", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.BATTLE_ITEM))
+    @JvmField
+    val X_SP_ATK = create("x_${Stats.SPECIAL_ATTACK.identifier.path}", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.BATTLE_ITEM))
+    @JvmField
+    val X_SP_DEF = create("x_${Stats.SPECIAL_DEFENCE.identifier.path}", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.BATTLE_ITEM))
+    @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 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

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

@@ -76,5 +76,6 @@ object CobblemonCommands {
         // with a certain system environment variable set
         CobblemonInfoCommand.register(dispatcher)
         CalculateSeatPositionCommand.register(dispatcher)
+        DebugCobblemonAICommand.register(dispatcher)
     }
 }

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

@@ -117,6 +117,11 @@ interface CobblemonImplementation {
 
     fun registerEntitySubPredicates()
 
+    /**
+     * TODO
+     */
+    fun registerMobEffects()
+
 
     /**
      * Add a feature to the current platform implementation.

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

@@ -23,7 +23,6 @@ import com.cobblemon.mod.common.block.MintBlock
 import com.cobblemon.mod.common.block.MintBlock.MintType
 import com.cobblemon.mod.common.client.pokedex.PokedexType
 import com.cobblemon.mod.common.block.campfirepot.CampfirePotColor
-import com.cobblemon.mod.common.config.CobblemonConfig
 import com.cobblemon.mod.common.entity.boat.CobblemonBoatType
 import com.cobblemon.mod.common.item.*
 import com.cobblemon.mod.common.item.armor.CobblemonArmorTrims
@@ -43,7 +42,6 @@ import com.cobblemon.mod.common.item.interactive.ability.AbilityChangeItem
 import com.cobblemon.mod.common.platform.PlatformRegistry
 import com.cobblemon.mod.common.pokeball.PokeBall
 import com.cobblemon.mod.common.pokemon.IVs
-import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.pokemon.helditem.CobblemonHeldItemManager
 import com.cobblemon.mod.common.util.cobblemonResource
 import net.minecraft.core.Registry
@@ -52,7 +50,6 @@ import net.minecraft.core.registries.Registries
 import net.minecraft.network.chat.Component
 import net.minecraft.resources.ResourceKey
 import net.minecraft.resources.ResourceLocation
-import net.minecraft.server.level.ServerPlayer
 import net.minecraft.world.effect.MobEffectInstance
 import net.minecraft.world.effect.MobEffects
 import net.minecraft.world.entity.LivingEntity
@@ -69,7 +66,6 @@ import net.minecraft.world.item.SignItem
 import net.minecraft.world.item.SmithingTemplateItem
 import net.minecraft.world.level.Level
 import net.minecraft.world.level.block.Block
-import kotlin.math.ceil
 
 @Suppress("unused", "SameParameterValue")
 object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<Item>>, Item>() {
@@ -511,6 +507,23 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField val SCROLL_OF_DARKNESS = noSettingsItem("scroll_of_darkness")
     @JvmField val SCROLL_OF_WATERS = noSettingsItem("scroll_of_waters")
 
+    @JvmField val WHITE_PLAQUE = blockItem("white_plaque", CobblemonBlocks.WHITE_PLAQUE)
+    @JvmField val LIGHT_GRAY_PLAQUE = blockItem("light_gray_plaque", CobblemonBlocks.LIGHT_GRAY_PLAQUE)
+    @JvmField val GRAY_PLAQUE = blockItem("gray_plaque", CobblemonBlocks.GRAY_PLAQUE)
+    @JvmField val BLACK_PLAQUE = blockItem("black_plaque", CobblemonBlocks.BLACK_PLAQUE)
+    @JvmField val BROWN_PLAQUE = blockItem("brown_plaque", CobblemonBlocks.BROWN_PLAQUE)
+    @JvmField val RED_PLAQUE = blockItem("red_plaque", CobblemonBlocks.RED_PLAQUE)
+    @JvmField val ORANGE_PLAQUE = blockItem("orange_plaque", CobblemonBlocks.ORANGE_PLAQUE)
+    @JvmField val YELLOW_PLAQUE = blockItem("yellow_plaque", CobblemonBlocks.YELLOW_PLAQUE)
+    @JvmField val LIME_PLAQUE = blockItem("lime_plaque", CobblemonBlocks.LIME_PLAQUE)
+    @JvmField val GREEN_PLAQUE = blockItem("green_plaque", CobblemonBlocks.GREEN_PLAQUE)
+    @JvmField val CYAN_PLAQUE = blockItem("cyan_plaque", CobblemonBlocks.CYAN_PLAQUE)
+    @JvmField val LIGHT_BLUE_PLAQUE = blockItem("light_blue_plaque", CobblemonBlocks.LIGHT_BLUE_PLAQUE)
+    @JvmField val BLUE_PLAQUE = blockItem("blue_plaque", CobblemonBlocks.BLUE_PLAQUE)
+    @JvmField val PURPLE_PLAQUE = blockItem("purple_plaque", CobblemonBlocks.PURPLE_PLAQUE)
+    @JvmField val MAGENTA_PLAQUE = blockItem("magenta_plaque", CobblemonBlocks.MAGENTA_PLAQUE)
+    @JvmField val PINK_PLAQUE = blockItem("pink_plaque", CobblemonBlocks.PINK_PLAQUE)
+
     private val berries = mutableMapOf<ResourceLocation, BerryItem>()
     // Plants
     @JvmField val CHERI_BERRY = berryItem("cheri", StatusCuringBerryItem(CobblemonBlocks.CHERI_BERRY, Statuses.PARALYSIS))
@@ -618,11 +631,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
 
     // Medicine
     @JvmField
-    val RARE_CANDY = candyItem("rare_candy", Rarity.RARE) { player, pokemon ->
-        if (pokemon != null) return@candyItem pokemon.getExperienceToNextLevel()
-        return@candyItem -1
-    }
-
+    val RARE_CANDY = candyItem("rare_candy", Rarity.RARE) { _, pokemon -> pokemon.getExperienceToNextLevel() }
     @JvmField
     val EXPERIENCE_CANDY_XS = candyItem("exp_candy_xs") { _, _ -> CandyItem.DEFAULT_XS_CANDY_YIELD }
     @JvmField
@@ -707,15 +716,15 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     val MOOMOO_MILK = create("moomoo_milk", MoomooMilk(Item.Properties().craftRemainder(Items.GLASS_BOTTLE).stacksTo((16))))
 
     @JvmField
-    val POTION = create("potion", PotionItem(PotionType.POTION))
+    val POTION = create("potion", PotionItem(PotionType.POTION, CobblemonBlocks.POTION))
     @JvmField
-    val SUPER_POTION = create("super_potion", PotionItem(PotionType.SUPER_POTION))
+    val SUPER_POTION = create("super_potion", PotionItem(PotionType.SUPER_POTION, CobblemonBlocks.SUPER_POTION))
     @JvmField
-    val HYPER_POTION = create("hyper_potion", PotionItem(PotionType.HYPER_POTION))
+    val HYPER_POTION = create("hyper_potion", PotionItem(PotionType.HYPER_POTION, CobblemonBlocks.HYPER_POTION))
     @JvmField
-    val MAX_POTION = create("max_potion", PotionItem(PotionType.MAX_POTION))
+    val MAX_POTION = create("max_potion", PotionItem(PotionType.MAX_POTION, CobblemonBlocks.MAX_POTION))
     @JvmField
-    val FULL_RESTORE = create("full_restore", PotionItem(PotionType.FULL_RESTORE))
+    val FULL_RESTORE = create("full_restore", PotionItem(PotionType.FULL_RESTORE, CobblemonBlocks.FULL_RESTORE))
 
     @JvmField
     val HEAL_POWDER = create("heal_powder", HealPowderItem())
@@ -800,28 +809,27 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val SERIOUS_MINT = mintItem("serious_mint", MintItem(Natures.SERIOUS))
 
-    @JvmField val X_ACCURACY = create("x_${Stats.ACCURACY.identifier.path}", XStatItem(Stats.ACCURACY))
-    @JvmField val X_ATTACK = create("x_${Stats.ATTACK.identifier.path}", XStatItem(Stats.ATTACK))
-    @JvmField val X_DEFENSE = create("x_${Stats.DEFENCE.identifier.path}", XStatItem(Stats.DEFENCE))
-    @JvmField val X_SP_ATK = create("x_${Stats.SPECIAL_ATTACK.identifier.path}", XStatItem(Stats.SPECIAL_ATTACK))
-    @JvmField val X_SP_DEF = create("x_${Stats.SPECIAL_DEFENCE.identifier.path}", XStatItem(Stats.SPECIAL_DEFENCE))
-    @JvmField val X_SPEED = create("x_${Stats.SPEED.identifier.path}", XStatItem(Stats.SPEED))
+    @JvmField val X_ACCURACY = create("x_${Stats.ACCURACY.identifier.path}", XStatItem(Stats.ACCURACY, block = CobblemonBlocks.X_ACCURACY))
+    @JvmField val X_ATTACK = create("x_${Stats.ATTACK.identifier.path}", XStatItem(Stats.ATTACK, block = CobblemonBlocks.X_ATTACK))
+    @JvmField val X_DEFENSE = create("x_${Stats.DEFENCE.identifier.path}", XStatItem(Stats.DEFENCE, block = CobblemonBlocks.X_DEFENSE))
+    @JvmField val X_SP_ATK = create("x_${Stats.SPECIAL_ATTACK.identifier.path}", XStatItem(Stats.SPECIAL_ATTACK, block = CobblemonBlocks.X_SP_ATK))
+    @JvmField val X_SP_DEF = create("x_${Stats.SPECIAL_DEFENCE.identifier.path}", XStatItem(Stats.SPECIAL_DEFENCE, block = CobblemonBlocks.X_SP_DEF))
+    @JvmField val X_SPEED = create("x_${Stats.SPEED.identifier.path}", XStatItem(Stats.SPEED, block = CobblemonBlocks.X_SPEED))
 
-    @JvmField val DIRE_HIT = create("dire_hit", DireHitItem())
-    @JvmField val GUARD_SPEC = create("guard_spec", GuardSpecItem())
+    @JvmField val DIRE_HIT = create("dire_hit", DireHitItem(CobblemonBlocks.DIRE_HIT))
+    @JvmField val GUARD_SPEC = create("guard_spec", GuardSpecItem(CobblemonBlocks.GUARD_SPEC))
 
-    @JvmField val BURN_HEAL = create("burn_heal", StatusCureItem("item.cobblemon.burn_heal", Statuses.BURN))
-    @JvmField val PARALYZE_HEAL = create("paralyze_heal", StatusCureItem("item.cobblemon.paralyze_heal", Statuses.PARALYSIS))
-    @JvmField val ICE_HEAL = create("ice_heal", StatusCureItem("item.cobblemon.ice_heal", Statuses.FROZEN))
-    @JvmField val ANTIDOTE = create("antidote", StatusCureItem("item.cobblemon.antidote", Statuses.POISON, Statuses.POISON_BADLY))
-    @JvmField val AWAKENING = create("awakening", StatusCureItem("item.cobblemon.awakening", Statuses.SLEEP))
+    @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))
+    @JvmField val ICE_HEAL = create("ice_heal", StatusCureItem("item.cobblemon.ice_heal", Statuses.FROZEN, block = CobblemonBlocks.ICE_HEAL))
+    @JvmField val PARALYZE_HEAL = create("paralyze_heal", StatusCureItem("item.cobblemon.paralyze_heal", Statuses.PARALYSIS, block = CobblemonBlocks.PARALYZE_HEAL))
 
-    @JvmField val FULL_HEAL = create("full_heal", StatusCureItem("item.cobblemon.full_heal"))
-
-    @JvmField val ETHER = create("ether", EtherItem(max = false))
-    @JvmField val MAX_ETHER = create("max_ether", EtherItem(max = true))
-    @JvmField val ELIXIR = create("elixir", ElixirItem(max = false))
-    @JvmField val MAX_ELIXIR = create("max_elixir", ElixirItem(max = true))
+    @JvmField val ETHER = create("ether", EtherItem(max = false, CobblemonBlocks.ETHER))
+    @JvmField val MAX_ETHER = create("max_ether", EtherItem(max = true, CobblemonBlocks.MAX_ETHER))
+    @JvmField val ELIXIR = create("elixir", ElixirItem(max = false, CobblemonBlocks.ELIXIR))
+    @JvmField val MAX_ELIXIR = create("max_elixir", ElixirItem(max = true, CobblemonBlocks.MAX_ELIXIR))
 
     @JvmField
     val ABILITY_CAPSULE = this.create("ability_capsule", AbilityChangeItem(AbilityChanger.COMMON_ABILITY))
@@ -930,7 +938,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val BLACK_SLUDGE = heldItem("black_sludge")
     @JvmField
-    val BLUNDER_POLICY = heldItem("blunder_policy")
+    val BLUNDER_POLICY = itemNameBlockItem("blunder_policy", CobblemonBlocks.BLUNDER_POLICY)
     @JvmField
     val CELL_BATTERY = heldItem("cell_battery")
     @JvmField
@@ -938,7 +946,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val CHOICE_SCARF = heldItem("choice_scarf")
     @JvmField
-    val CLEANSE_TAG = heldItem("cleanse_tag")
+    val CLEANSE_TAG = itemNameBlockItem("cleanse_tag", CobblemonBlocks.CLEANSE_TAG)
     @JvmField
     val CLEAR_AMULET = heldItem("clear_amulet")
     @JvmField
@@ -1046,7 +1054,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val SOFT_SAND = heldItem("soft_sand")
     @JvmField
-    val SPELL_TAG = heldItem("spell_tag")
+    val SPELL_TAG = itemNameBlockItem("spell_tag", CobblemonBlocks.SPELL_TAG)
     @JvmField
     val SMOKE_BALL = heldItem("smoke_ball")
     @JvmField
@@ -1064,7 +1072,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val UTILITY_UMBRELLA = heldItem("utility_umbrella")
     @JvmField
-    val WEAKNESS_POLICY = heldItem("weakness_policy")
+    val WEAKNESS_POLICY = itemNameBlockItem("weakness_policy", CobblemonBlocks.WEAKNESS_POLICY)
     @JvmField
     val WIDE_LENS = heldItem("wide_lens")
     @JvmField
@@ -1484,7 +1492,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
         return item
     }
 
-    private fun candyItem(name: String, rarity: Rarity = Rarity.COMMON, calculator: (ServerPlayer, Pokemon?) -> Int): CandyItem  = this.create(name, CandyItem(rarity, calculator))
+    private fun candyItem(name: String, rarity: Rarity = Rarity.COMMON, calculator: CandyItem.Calculator): CandyItem  = this.create(name, CandyItem(rarity, calculator))
 
     private fun pokerodItem(pokeRodId: ResourceLocation, rarity: Rarity = Rarity.COMMON): PokerodItem {
         val settings = Item.Properties().stacksTo(1).durability(256).rarity(rarity)
@@ -1561,6 +1569,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
             }
         }
     )
+
     private fun heldItem(name: String, item: Item, remappedName: String? = null) = create(
         name = name,
         entry = item.also {

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

@@ -15,12 +15,12 @@ import com.cobblemon.mod.common.api.moves.animations.ActionEffectContext
 import com.mojang.serialization.Codec
 import com.mojang.serialization.codecs.ListCodec
 import com.mojang.serialization.codecs.PrimitiveCodec
+import java.util.Optional
+import java.util.UUID
 import net.minecraft.core.BlockPos
-import net.minecraft.core.GlobalPos
 import net.minecraft.core.UUIDUtil
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.ai.memory.MemoryModuleType
-import java.util.*
 
 object CobblemonMemories {
     val memories = mutableMapOf<String, MemoryModuleType<*>>()
@@ -59,12 +59,8 @@ object CobblemonMemories {
     @JvmField
     val DISABLE_WALK_TO_BERRY_BUSH = register<Boolean>("disable_walk_to_berry_bush")
     @JvmField
-    val TIME_TRYING_TO_REACH_BERRY_BUSH = register<Int>("time_trying_to_reach_berry_bush")
-    @JvmField
     val IS_CONSUMING_ITEM = register<Boolean>("is_consuming_item")
     @JvmField
-    val RECENTLY_ATE_GRASS = register<Boolean>("recently_ate_grass")
-    @JvmField
     val HIVE_LOCATION = register<BlockPos>("hive_location", BlockPos.CODEC)
     @JvmField
     val HIVE_BLACKLIST = register<List<BlockPos>>("hive_blacklist")

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

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common
+
+import com.cobblemon.mod.common.api.cooking.effects.CleanseAllEffect
+import com.cobblemon.mod.common.api.cooking.effects.CleanseNegativeEffect
+import com.cobblemon.mod.common.api.cooking.effects.MentalRestorationEffect
+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.effect.MobEffect
+
+object CobblemonMobEffects : PlatformRegistry<Registry<MobEffect>, ResourceKey<Registry<MobEffect>>, MobEffect>() {
+    override val registry: Registry<MobEffect> = BuiltInRegistries.MOB_EFFECT
+    override val resourceKey: ResourceKey<Registry<MobEffect>> = Registries.MOB_EFFECT
+
+    @JvmField
+    val CLEANSE_NEGATIVE = create("cleanse_negative", CleanseNegativeEffect())
+
+    @JvmField
+    val MENTAL_RESTORATION = create("mental_restoration", MentalRestorationEffect())
+
+    @JvmField
+    val CLEANSE_ALL = create("cleanse_all", CleanseAllEffect())
+}

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

@@ -23,6 +23,7 @@ import com.cobblemon.mod.common.client.net.data.CobblemonMechanicsSyncHandler
 import com.cobblemon.mod.common.client.net.data.DataRegistrySyncPacketHandler
 import com.cobblemon.mod.common.client.net.data.RideSettingsSyncHandler
 import com.cobblemon.mod.common.client.net.debug.OpenRidingStatsDebugGUIHandler
+import com.cobblemon.mod.common.client.net.debug.UpdateTrackedBrainDataHandler
 import com.cobblemon.mod.common.client.net.dialogue.DialogueClosedHandler
 import com.cobblemon.mod.common.client.net.dialogue.DialogueOpenedHandler
 import com.cobblemon.mod.common.client.net.effect.PokeSnackBlockParticlesHandler
@@ -81,6 +82,7 @@ import com.cobblemon.mod.common.net.messages.client.cooking.SeasoningRegistrySyn
 import com.cobblemon.mod.common.net.messages.client.cooking.ToggleCookingPotLidPacket
 import com.cobblemon.mod.common.net.messages.client.data.*
 import com.cobblemon.mod.common.net.messages.client.debug.RequestOpenRidingStatsDebugGUIPacket
+import com.cobblemon.mod.common.net.messages.client.debug.UpdateTrackedBrainDataPacket
 import com.cobblemon.mod.common.net.messages.client.dialogue.DialogueClosedPacket
 import com.cobblemon.mod.common.net.messages.client.dialogue.DialogueOpenedPacket
 import com.cobblemon.mod.common.net.messages.client.effect.PokeSnackBlockParticlesPacket
@@ -168,7 +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.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
@@ -189,6 +194,7 @@ import com.cobblemon.mod.common.net.messages.server.riding.ServerboundUpdateRide
 import com.cobblemon.mod.common.net.messages.server.starter.RequestStarterScreenPacket
 import com.cobblemon.mod.common.net.messages.server.storage.SwapPCPartyPokemonPacket
 import com.cobblemon.mod.common.net.messages.server.storage.party.MovePartyPokemonPacket
+import com.cobblemon.mod.common.net.messages.server.storage.party.PartyTutorialPacket
 import com.cobblemon.mod.common.net.messages.server.storage.party.ReleasePartyPokemonPacket
 import com.cobblemon.mod.common.net.messages.server.storage.party.SwapPartyPokemonPacket
 import com.cobblemon.mod.common.net.messages.server.storage.pc.*
@@ -223,7 +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.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
@@ -247,6 +256,7 @@ import com.cobblemon.mod.common.net.serverhandling.storage.RequestMoveSwapHandle
 import com.cobblemon.mod.common.net.serverhandling.storage.SendOutPokemonHandler
 import com.cobblemon.mod.common.net.serverhandling.storage.SwapPCPartyPokemonHandler
 import com.cobblemon.mod.common.net.serverhandling.storage.party.MovePartyPokemonHandler
+import com.cobblemon.mod.common.net.serverhandling.storage.party.PartyTutorialPacketHandler
 import com.cobblemon.mod.common.net.serverhandling.storage.party.ReleasePCPokemonHandler
 import com.cobblemon.mod.common.net.serverhandling.storage.party.SwapPartyPokemonHandler
 import com.cobblemon.mod.common.net.serverhandling.storage.pc.*
@@ -401,6 +411,7 @@ object CobblemonNetwork {
         // Data registries
         list.add(PacketRegisterInfo(AbilityRegistrySyncPacket.ID, AbilityRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(CobblemonMechanicsSyncPacket.ID, CobblemonMechanicsSyncPacket::decode, CobblemonMechanicsSyncHandler))
+        list.add(PacketRegisterInfo(PokemonInteractionsSyncPacket.ID, PokemonInteractionsSyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(MovesRegistrySyncPacket.ID, MovesRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(BerryRegistrySyncPacket.ID, BerryRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(SpeciesRegistrySyncPacket.ID, SpeciesRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
@@ -422,6 +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(PremadeNPCRegistrySyncPacket.ID, PremadeNPCRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
 
         // Effects
         list.add(PacketRegisterInfo(SpawnSnowstormParticlePacket.ID, SpawnSnowstormParticlePacket::decode, SpawnSnowstormParticleHandler))
@@ -493,6 +505,7 @@ object CobblemonNetwork {
 
         // Debug
         list.add(PacketRegisterInfo(OpenRidingStatsDebugGUIPacket.ID, OpenRidingStatsDebugGUIPacket::decode, OpenRidingStatsDebugGUIHandler))
+        list.add(PacketRegisterInfo(UpdateTrackedBrainDataPacket.ID, UpdateTrackedBrainDataPacket::decode, UpdateTrackedBrainDataHandler))
 
         return list
     }
@@ -528,7 +541,7 @@ object CobblemonNetwork {
         list.add(PacketRegisterInfo(ReleasePCPokemonPacket.ID, ReleasePCPokemonPacket::decode, ReleasePCPokemonHandler))
         list.add(PacketRegisterInfo(UnlinkPlayerFromPCPacket.ID, UnlinkPlayerFromPCPacket::decode, UnlinkPlayerFromPCHandler))
 
-        list.add(PacketRegisterInfo(RequestRenamePCBoxPacket.Companion.ID, RequestRenamePCBoxPacket.Companion::decode, RequestRenamePCBoxHandler))
+        list.add(PacketRegisterInfo(RequestRenamePCBoxPacket.ID, RequestRenamePCBoxPacket::decode, RequestRenamePCBoxHandler))
         list.add(PacketRegisterInfo(PCBoxWallpapersPacket.ID, PCBoxWallpapersPacket::decode, PCBoxWallpapersHandler))
         list.add(PacketRegisterInfo(RequestChangePCBoxWallpaperPacket.ID, RequestChangePCBoxWallpaperPacket::decode, RequestChangePCBoxWallpaperHandler))
         list.add(PacketRegisterInfo(MarkPCBoxWallpapersSeenPacket.ID, MarkPCBoxWallpapersSeenPacket::decode, MarkPCBoxWallpapersSeenHandler))
@@ -586,12 +599,18 @@ object CobblemonNetwork {
         list.add(PacketRegisterInfo(PartyPokemonMoveSelectedPacket.ID, PartyPokemonMoveSelectedPacket::decode, PartyPokemonMoveSelectedHandler))
         list.add(PacketRegisterInfo(PartyMoveSelectCancelledPacket.ID, PartyMoveSelectCancelledPacket::decode, PartyMoveSelectCancelledHandler))
 
+        //Party move tutorial toasts packets
+        list.add(PacketRegisterInfo(PartyTutorialPacket.ID, PartyTutorialPacket::decode, PartyTutorialPacketHandler))
+
         // Dialogue packets
         list.add(PacketRegisterInfo(EscapeDialoguePacket.ID, EscapeDialoguePacket::decode, EscapeDialogueHandler))
         list.add(PacketRegisterInfo(InputToDialoguePacket.ID, InputToDialoguePacket::decode, InputToDialogueHandler))
 
         // 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))

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

@@ -18,6 +18,7 @@ import net.minecraft.resources.ResourceKey
 import net.minecraft.world.entity.ai.village.poi.PoiType
 import net.minecraft.world.level.block.Block
 import net.minecraft.world.level.block.state.BlockState
+import net.minecraft.world.level.block.Blocks
 
 object CobblemonPoiTypes: PlatformRegistry<Registry<PoiType>, ResourceKey<Registry<PoiType>>, PoiType>() {
     override val registry: Registry<PoiType> = BuiltInRegistries.POINT_OF_INTEREST_TYPE
@@ -30,6 +31,8 @@ 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 JUKEBOX_KEY = createKey("vanilla_jukebox", Blocks.JUKEBOX, 0, 1)
 
     private fun createKey(string: String, block: Block, maxTickets: Int, validRange: Int ): ResourceKey<PoiType> =
         ResourceKey.create(Registries.POINT_OF_INTEREST_TYPE, cobblemonResource(string)).also { resourceKey ->

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

@@ -46,9 +46,6 @@ object CobblemonSensors {
     @JvmField
     val NEARBY_FLOWER = register("nearby_flower", ::FlowerSensor)
 
-    @JvmField
-    val NEARBY_SWEET_BERRY_BUSH = register("nearby_sweet_berry_bush", ::SweetBerryBushSensor)
-
     @JvmField
     val POKEMON_NEARBY_WANTED_ITEM = register("pokemon_nearby_wanted_item", ::PokemonItemSensor)
 

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/BehaviourCategory.kt

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

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/BehaviourConfigurationContext.kt

@@ -12,13 +12,15 @@ 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.api.ai.biggerbrain.BiggerBrain
+import com.cobblemon.mod.common.api.ai.biggerbrain.objective.Objective
+import com.cobblemon.mod.common.api.ai.biggerbrain.sense.Sense
 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.addStandardFunctions
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.setup
 import com.cobblemon.mod.common.api.molang.ObjectValue
-import com.cobblemon.mod.common.api.scripting.CobblemonScripts
 import com.cobblemon.mod.common.entity.MoLangScriptingEntity
 import com.cobblemon.mod.common.util.activityRegistry
 import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
@@ -46,6 +48,9 @@ class BehaviourConfigurationContext {
     val memories = mutableSetOf<MemoryModuleType<*>>()
     val sensors = mutableSetOf<SensorType<*>>()
 
+    val objectives = mutableMapOf<Int, MutableList<Objective>>()
+    val senses = mutableSetOf<Sense>()
+
     val onAdd = mutableListOf<ExpressionLike>()
 
     fun getOrCreateActivity(activity: Activity): ActivityConfigurationContext {
@@ -68,6 +73,22 @@ class BehaviourConfigurationContext {
         this.sensors.addAll(sensors)
     }
 
+    fun addSenses(vararg senses: Sense) {
+        addSenses(senses.toList())
+    }
+
+    fun addSenses(senses: Collection<Sense>) {
+        outer@for (sense in senses) {
+            for (existingSense in this.senses) {
+                if (existingSense.merge(sense)) {
+                    continue@outer
+                }
+            }
+            this.senses.add(sense)
+            this.addMemories(sense.memories)
+        }
+    }
+
     fun addOnAddScript(script: ExpressionLike) {
         onAdd.add(script)
     }
@@ -88,8 +109,23 @@ class BehaviourConfigurationContext {
         var brain = entity.brain
         // Apply the brain config
         if (entity is MoLangScriptingEntity) {
-            brain = entity.assignNewBrainWithMemoriesAndSensors(dynamic, memories, sensors)
+            val useBiggerBrain = objectives.isNotEmpty() || senses.isNotEmpty()
+            brain = entity.assignNewBrainWithMemoriesAndSensors(dynamic, memories, if (useBiggerBrain) emptySet() else sensors)
             onAdd.forEach { runtime.resolve(it) }
+            if (useBiggerBrain) {
+                val wereDebugging = entity.biggerBrain.debuggingPlayers ?: emptySet()
+                val biggerBrain = BiggerBrain(entity)
+                entity.biggerBrain = biggerBrain
+                addSenses(biggerBrain.senses)
+                val orderedObjectives = objectives.entries.sortedBy { it.key }.flatMap { it.value }
+                orderedObjectives.forEach(biggerBrain::registerObjective)
+                biggerBrain.senses.addAll(senses)
+                biggerBrain.debuggingPlayers.addAll(wereDebugging)
+                return
+            } else {
+                val biggerBrain = BiggerBrain(entity)
+                entity.biggerBrain = biggerBrain
+            }
         }
         activities.forEach { it.apply(entity) }
         brain.setCoreActivities(coreActivities)

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/CobblemonBehaviour.kt

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

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/CobblemonWanderControl.kt

@@ -9,44 +9,40 @@
 package com.cobblemon.mod.common.api.ai
 
 import com.bedrockk.molang.runtime.struct.QueryStruct
+import com.bedrockk.molang.runtime.value.DoubleValue
 import com.cobblemon.mod.common.util.getBooleanOrNull
 import com.cobblemon.mod.common.util.getDoubleOrNull
-import kotlin.math.sqrt
-import net.minecraft.core.BlockPos
-import net.minecraft.world.entity.PathfinderMob
 
 /**
- * Used to maintain some settings around how the entity should wander this tick. The idea is you
- * reset this with some script task at priority 0 then some number of steps before it gets to the wander
- * tasks you can have other conditional tasks jump in to configure parts of this.
+ * Used to maintain some settings around how the entity should wander this tick. Anything left null
+ * will fall back to defaults specified by the logic of the WanderAround objective.
  *
  * @author Hiroku
  * @since July 18, 2025
  */
 class CobblemonWanderControl(
     var center: WanderCenter? = null,
-    var maxAttempts: Int = 4, // How many times to try to find a suitable point before giving up on that tick.
-    var allowLand: Boolean = true,
-    var allowWater: Boolean = false,
-    var allowAir: Boolean = false,
-    var pathCooldownTicks: Int = 20 * 5, // Used to mitigate the cost of pathfinding.
-    var wanderSpeed: Float = 0.35F,
+    var maxAttempts: Int? = null, // How many times to try to find a suitable point before giving up on that tick.
+    var allowLand: Boolean? = null,
+    var allowWater: Boolean? = null,
+    var allowAir: Boolean? = null,
+    var wanderSpeed: Float? = null,
+    var wanderChanceMultiplier: Float? = null
 ) {
     class WanderCenter(val x: Number, val y: Number, val z: Number, val minRange: Float, val maxRange: Float)
 
     @Transient
     val struct: QueryStruct = QueryStruct(hashMapOf())
-        .addFunction("center_x") { center?.x ?: 0.0 }
-        .addFunction("center_y") { center?.y ?: 0.0 }
-        .addFunction("center_z") { center?.z ?: 0.0 }
-        .addFunction("max_attempts") { maxAttempts.toDouble() }
-        .addFunction("min_range") { center?.minRange ?: 0.0 }
-        .addFunction("max_range") { center?.maxRange ?: 0.0 }
-        .addFunction("allow_land") { if (allowLand) 1.0 else 0.0 }
-        .addFunction("allow_water") { if (allowWater) 1.0 else 0.0 }
-        .addFunction("allow_air") { if (allowAir) 1.0 else 0.0 }
-        .addFunction("path_cooldown_ticks") { pathCooldownTicks.toDouble() }
-        .addFunction("wander_speed") { wanderSpeed }
+        .addFunction("center_x") { DoubleValue(center?.x ?: 0.0) }
+        .addFunction("center_y") { DoubleValue(center?.y ?: 0.0) }
+        .addFunction("center_z") { DoubleValue(center?.z ?: 0.0) }
+        .addFunction("max_attempts") { DoubleValue(maxAttempts?.toDouble() ?: 0.0) }
+        .addFunction("min_range") { DoubleValue(center?.minRange ?: 0.0) }
+        .addFunction("max_range") { DoubleValue(center?.maxRange ?: 0.0) }
+        .addFunction("allow_land") { DoubleValue(if (allowLand == true) 1.0 else 0.0) }
+        .addFunction("allow_water") { DoubleValue(if (allowWater == true) 1.0 else 0.0) }
+        .addFunction("allow_air") { DoubleValue(if (allowAir == true) 1.0 else 0.0) }
+        .addFunction("wander_speed") { DoubleValue(wanderSpeed ?: 0.0) }
         .addFunction("set_center") { params ->
             if (params.params.size < 3) {
                 throw IllegalArgumentException("set_center requires at least 3 parameters: x, y, z")
@@ -68,26 +64,6 @@ class CobblemonWanderControl(
         .addFunction("set_allow_land") { params -> allowLand = params.getBooleanOrNull(0) ?: true }
         .addFunction("set_allow_water") { params -> allowWater = params.getBooleanOrNull(0) ?: false }
         .addFunction("set_allow_air") { params -> allowAir = params.getBooleanOrNull(0) ?: false }
-        .addFunction("set_path_cooldown_ticks") { params -> pathCooldownTicks = params.getDoubleOrNull(0)?.toInt() ?: (20 * 5) }
         .addFunction("set_wander_speed") { params -> wanderSpeed = params.getDoubleOrNull(0)?.toFloat() ?: 0.35F }
-        .addFunction("reset") { reset() }
-
-    fun isSuitable(position: BlockPos): Boolean {
-        val center = center ?: return true
-        val centerPos = BlockPos(center.x.toInt(), center.y.toInt(), center.z.toInt())
-        val distance = sqrt(centerPos.distSqr(position))
-        val suitable = distance >= center.minRange && distance <= center.maxRange
-        return suitable
-    }
-
-    fun reset() {
-        center = null
-        allowLand = false
-        allowWater = false
-        allowAir = false
-        pathCooldownTicks = 20 * 5
-        wanderSpeed = 0.35F
-        maxAttempts = 4
-    }
 }
 

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/ExpressionOrEntityVariable.kt

@@ -9,9 +9,23 @@
 package com.cobblemon.mod.common.api.ai
 
 import com.bedrockk.molang.Expression
+import com.bedrockk.molang.ast.NumberExpression
+import com.bedrockk.molang.ast.StringExpression
+import com.bedrockk.molang.runtime.MoLangRuntime
+import com.bedrockk.molang.runtime.value.DoubleValue
+import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
+import com.cobblemon.mod.common.entity.MoLangScriptingEntity
+import com.cobblemon.mod.common.util.asExpression
+import com.cobblemon.mod.common.util.lang
+import com.cobblemon.mod.common.util.resolveBoolean
+import com.cobblemon.mod.common.util.resolveDouble
+import com.cobblemon.mod.common.util.resolveFloat
+import com.cobblemon.mod.common.util.resolveInt
+import com.cobblemon.mod.common.util.resolveString
 import com.mojang.datafixers.util.Either
 import kotlin.jvm.optionals.getOrNull
+import net.minecraft.world.entity.LivingEntity
 
 /**
  * The issue in a lot of the behaviour datapacking is that there are times when a property should be exposed to
@@ -31,6 +45,50 @@ import kotlin.jvm.optionals.getOrNull
  */
 typealias ExpressionOrEntityVariable = Either<Expression, MoLangConfigVariable>
 
+fun ExpressionOrEntityVariable.asExpression() = map({ it }, { "q.entity.config.${it.variableName}".asExpression() })
+fun ExpressionOrEntityVariable.resolveString(runtime: MoLangRuntime) = runtime.resolveString(asExpression())
+fun ExpressionOrEntityVariable.resolveBoolean(runtime: MoLangRuntime) = runtime.resolveBoolean(asExpression())
+fun ExpressionOrEntityVariable.resolveInt(runtime: MoLangRuntime) = runtime.resolveInt(asExpression())
+fun ExpressionOrEntityVariable.resolveDouble(runtime: MoLangRuntime) = runtime.resolveDouble(asExpression())
+fun ExpressionOrEntityVariable.resolveFloat(runtime: MoLangRuntime) = runtime.resolveFloat(asExpression())
+
+private fun variable(category: String, name: String, type: MoLangConfigVariable.MoLangVariableType, default: String) = MoLangConfigVariable(
+    variableName = name,
+    category = lang("entity.variable.category.$category"),
+    displayName = lang("entity.variable.$name.name"),
+    description = lang("entity.variable.$name.desc"),
+    type = type,
+    defaultValue = default
+)
+
+fun stringVariable(category: String, name: String, default: String) = variable(category = category, name = name, type = MoLangConfigVariable.MoLangVariableType.TEXT, default = default)
+fun numberVariable(category: String, name: String, default: Number) = variable(category = category, name = name, type = MoLangConfigVariable.MoLangVariableType.NUMBER, default = default.toString())
+fun booleanVariable(category: String, name: String, default: Boolean) = variable(category = category, name = name, type = MoLangConfigVariable.MoLangVariableType.BOOLEAN, default = default.toString())
+
+fun getVariableExpression(name: String) = "q.entity.config.$name".asExpression()
+fun resolveBooleanVariable(name: String, runtime: MoLangRuntime) = runtime.resolveBoolean(getVariableExpression(name))
+
+fun checkCondition(runtime: MoLangRuntime, expressionOrEntityVariable: ExpressionOrEntityVariable): Boolean {
+    return expressionOrEntityVariable.resolveBoolean(runtime)
+}
+
+fun ExpressionOrEntityVariable.asSimplifiedExpression(entity: LivingEntity): Expression {
+    return map(
+        { it },
+        {
+            if (entity is MoLangScriptingEntity) {
+                val variable = entity.config.map[it.variableName]
+                if (variable is DoubleValue) {
+                    return@map NumberExpression(variable.value)
+                } else if (variable is StringValue) {
+                    return@map StringExpression(variable)
+                }
+            }
+            return@map "q.entity.config.${it.variableName}".asExpression()
+        }
+    )
+}
+
 /**
  * In the case of [ExpressionOrEntityVariable] the right side is the only one that requires visibility for a user,
  * this function is a shorthand for finding all of the values in the list that have something to show the user to

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/BiggerBrain.kt

@@ -0,0 +1,182 @@
+/*
+ * 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
+
+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.ai.biggerbrain.distraction.Distraction
+import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.EntityFixation
+import com.cobblemon.mod.common.api.ai.biggerbrain.objective.Objective
+import com.cobblemon.mod.common.api.ai.biggerbrain.objective.ObjectiveStatus
+import com.cobblemon.mod.common.api.ai.biggerbrain.sense.Sense
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.setup
+import com.cobblemon.mod.common.api.text.text
+import com.cobblemon.mod.common.net.messages.client.debug.UpdateTrackedBrainDataPacket
+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
+
+/**
+ * A better* version of Minecraft's [net.minecraft.world.entity.ai.Brain] system that makes development more
+ * straightforward and allows easier debugging.
+ *
+ * We could name this thing better.
+ *
+ * There are three main principles inside this system:
+ *
+ * 1: Senses
+ *
+ * Senses are simple ticking objects that are instantiated per entity and are expected to just update memories based
+ * on properties about the entity or its surroundings. This is an analogue of SensorType from Brains.
+ *
+ * 2: Objectives
+ *
+ * Objectives are also ticking objects that are instantiated per entity. They represent a goal for the entity and
+ * run in a fixed order.
+ *
+ * 3: Fixations
+ *
+ * Fixations are a task that can be set on the brain that represents a more total commitment to a certain task. Only
+ * a single fixation can be active at a time, and they can be 'distracted' by other objectives or potentially external
+ * factors.
+ *
+ * These can also be debugged using the /debugcobblemonai command while looking at a Pokémon or NPC entity.
+ *
+ * *that remains to be seen
+ *
+ * @author Hiroku
+ * @since December 29th, 2025
+ */
+class BiggerBrain(val entity: LivingEntity) {
+    val runtime = MoLangRuntime().setup().withQueryValue("entity", entity.asMostSpecificMoLangValue())
+
+    val senses = mutableListOf<Sense>()
+    val objectives = mutableListOf<Objective>()
+    val observedMemories = mutableMapOf<MemoryModuleType<*>, MutableList<Objective>>()
+
+    var fixation: EntityFixation? = null
+
+    var debuggingPlayers = mutableSetOf<UUID>()
+
+    fun registerObjective(objective: Objective) {
+        objectives.add(objective)
+        for (memory in objective.observedMemories) {
+            val list = this.observedMemories.getOrPut(memory, ::ArrayList)
+            list.add(objective)
+        }
+    }
+
+    fun isFixation(fixation: EntityFixation?): Boolean {
+        return fixation != null && this.fixation == fixation
+    }
+
+    fun sendDebugMessage(message: String) {
+        debuggingPlayers.forEach {
+            it.getPlayer()?.sendSystemMessage(message.text())
+        }
+    }
+
+    fun tick() {
+        senses.forEach {
+            it.ticksUntilNextExecution--
+            if (it.ticksUntilNextExecution <= 0) {
+                it.tick(entity, this)
+            }
+        }
+
+        if (fixation?.tick(entity, this) == false) {
+            fixation = null
+        }
+
+        val objectiveStatuses = mutableMapOf<Objective, ObjectiveStatus>()
+
+        val activeObjectiveTags = mutableSetOf<String>()
+        for (objective in objectives) {
+            val status = objective.perform(entity, this, activeObjectiveTags)
+            objectiveStatuses[objective] = status
+        }
+
+        if (debuggingPlayers.isNotEmpty()) {
+            val state = BiggerBrainState(entity = entity, brain = this, objectiveStatuses = objectiveStatuses)
+            val packet = UpdateTrackedBrainDataPacket(entity.id, state)
+            debuggingPlayers.removeIf { uuid ->
+                val player = uuid.getPlayer()
+                if (player != null && Cobblemon.serverPlayerDebuggingPokemonBrainEntities[player.uuid] != entity.uuid) {
+                    return@removeIf true
+                } else {
+                    player?.sendPacket(packet)
+                }
+                return@removeIf player == null
+            }
+        }
+    }
+
+    fun fixate(fixation: EntityFixation): EntityFixation {
+        this.fixation = fixation
+        return fixation
+    }
+
+    fun distract(distraction: Distraction): Boolean {
+        if (fixation?.canDistract(distraction, entity) != false) {
+            fixation?.onDistract(distraction, entity)
+            this.fixation = null
+            return true
+        }
+        return false
+    }
+
+    fun canDistract(distraction: Distraction): Boolean {
+        return fixation?.canDistract(distraction, entity) != false
+    }
+
+    fun <T> setMemory(memory: MemoryModuleType<T>, value: T, expiry: Long? = null) {
+        if (expiry != null) {
+            entity.brain.setMemoryWithExpiry(memory, value, expiry)
+        } else {
+            entity.brain.setMemory(memory, value)
+        }
+        observedMemories[memory]?.forEach { objective ->
+            objective.onMemoryChanged(entity, this, memory, value)
+        }
+    }
+
+    fun <T> setMemoryIfChanged(memory: MemoryModuleType<T>, value: T, expiry: Long? = null) {
+        if (entity.brain.getMemorySafely(memory).orElse(null) != value) {
+            setMemory(memory, value, expiry)
+        }
+    }
+
+    fun <T> eraseMemory(memory: MemoryModuleType<T>) {
+        entity.brain.eraseMemory(memory)
+        observedMemories[memory]?.forEach { objective ->
+            objective.onMemoryChanged(entity, this, memory, null)
+        }
+    }
+
+    fun <T> eraseMemoryIfPresent(memory: MemoryModuleType<T>) {
+        if (entity.brain.hasMemoryValue(memory)) {
+            eraseMemory(memory)
+        }
+    }
+
+    fun hasMemoryValue(memory: MemoryModuleType<*>): Boolean {
+        return entity.brain.checkMemory(memory, MemoryStatus.VALUE_PRESENT)
+    }
+
+    fun <T> getMemory(memory: MemoryModuleType<T>): T? {
+        return entity.brain.getMemorySafely(memory).orElse(null)
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/BiggerBrainState.kt

@@ -0,0 +1,74 @@
+/*
+ * 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
+
+import com.cobblemon.mod.common.api.ai.biggerbrain.objective.Objective
+import com.cobblemon.mod.common.api.ai.biggerbrain.objective.ObjectiveStatus
+import kotlin.reflect.jvm.jvmName
+import net.minecraft.network.FriendlyByteBuf
+import net.minecraft.world.entity.LivingEntity
+
+/**
+ * A DTO of sorts that is sent to debugging players to keep them informed about the state of an entity's Cobblemon AI.
+ *
+ * @author Hiroku
+ * @since December 29th, 2025
+ */
+class BiggerBrainState(
+    val senses: List<SenseState>,
+    val objectives: List<ObjectiveState>,
+    val fixation: String? = null
+) {
+    class SenseState(val className: String, val ticksUntilNextExecution: Int) {
+        fun encode(buffer: FriendlyByteBuf) {
+            buffer.writeUtf(className)
+            buffer.writeInt(ticksUntilNextExecution)
+        }
+
+        companion object {
+            fun decode(buffer: FriendlyByteBuf): SenseState {
+                return SenseState(buffer.readUtf(), buffer.readInt())
+            }
+        }
+    }
+
+    class ObjectiveState(val description: String, val status: ObjectiveStatus) {
+        fun encode(buffer: FriendlyByteBuf) {
+            buffer.writeUtf(description)
+            buffer.writeEnum(status)
+        }
+
+        companion object {
+            fun decode(buffer: FriendlyByteBuf): ObjectiveState {
+                return ObjectiveState(buffer.readUtf(), buffer.readEnum(ObjectiveStatus::class.java))
+            }
+        }
+    }
+
+    constructor(entity: LivingEntity, brain: BiggerBrain, objectiveStatuses: Map<Objective, ObjectiveStatus>): this(
+        senses = brain.senses.map { SenseState(className = it::class.simpleName ?: it::class.jvmName, it.ticksUntilNextExecution) },
+        objectives = objectiveStatuses.entries.map { ObjectiveState(it.key.getDescription(entity), it.value) },
+        fixation = brain.fixation?.getDescription(entity)
+    )
+
+    fun encode(buffer: FriendlyByteBuf) {
+        buffer.writeCollection(senses) { _, sense -> sense.encode(buffer) }
+        buffer.writeCollection(objectives) { _, objective -> objective.encode(buffer) }
+        buffer.writeNullable(fixation) { _, fixation -> buffer.writeUtf(fixation) }
+    }
+
+    companion object {
+        fun decode(buffer: FriendlyByteBuf): BiggerBrainState {
+            val senses = buffer.readList { SenseState.decode(it) }
+            val objectives = buffer.readList { ObjectiveState.decode(it) }
+            val fixation = buffer.readNullable { buffer.readUtf() }
+            return BiggerBrainState(senses, objectives, fixation)
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/LookingTracker.kt

@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.ai.biggerbrain
+
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.PathfinderMob
+import net.minecraft.world.entity.ai.behavior.BlockPosTracker
+import net.minecraft.world.entity.ai.behavior.EntityTracker
+import net.minecraft.world.entity.ai.behavior.PositionTracker
+import net.minecraft.world.entity.ai.memory.WalkTarget
+
+/**
+ * A trivial wrapper around an entity and a position tracker to make the entity look at the position each tick.
+ *
+ * @author Hiroku
+ * @since December 29th, 2025
+ */
+class LookingTracker(val entity: PathfinderMob, val lookTarget: PositionTracker) {
+    companion object {
+        fun forTargetEntity(entity: PathfinderMob, target: LivingEntity, trackEyeHeight: Boolean = true): LookingTracker {
+            return LookingTracker(entity, EntityTracker(target, trackEyeHeight))
+        }
+
+        fun fromNavigationPathOrWalkTarget(entity: PathfinderMob, walkTarget: WalkTarget): LookingTracker {
+            val destinationPoint = entity.navigation.path?.endNode?.asVec3() ?: walkTarget.target.currentPosition()
+            return LookingTracker(entity, BlockPosTracker(destinationPoint.add(0.0, entity.eyeHeight.toDouble(), 0.0)))
+        }
+    }
+    fun tick() {
+        entity.lookControl.setLookAt(lookTarget.currentPosition())
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/MovementStatus.kt

@@ -0,0 +1,27 @@
+/*
+ * 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
+
+/**
+ * A simple enum representing the status of a movement action.
+ *
+ * @author Hiroku
+ * @since December 29th, 2025
+ */
+enum class MovementStatus {
+    /** Represents when the entity is still en route to the destination. */
+    PENDING,
+    /** Represents when the entity has successfully reached the destination. */
+    COMPLETED,
+    /**
+     * Represents when the entity has failed to reach the destination. This can be due to
+     * a change in surroundings or taking too long or all sorts of things.
+     */
+    FAILED
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/MovementTracker.kt

@@ -0,0 +1,30 @@
+/*
+ * 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
+
+import net.minecraft.world.entity.ai.memory.WalkTarget
+
+/**
+ * A wrapping around logic that maintains an entity's journey towards a specific destination. Mainly used by fixations
+ * to keep track of when pathing is done, and whether it failed or succeeded. Can also be told to stop to do any
+ * necessary clean up. Implemented only by [RegularMovementTracker] which has me questioning if it should be an interface
+ * or just a simple class like the [LookingTracker].
+ *
+ * @author Hiroku
+ * @since December 29th, 2025
+ */
+interface MovementTracker {
+    val walkTarget: WalkTarget
+    /** The last known status of this movement tracker. */
+    var lastStatus: MovementStatus
+    /** Performs a tick of movement tracking logic. Returns the current [MovementStatus]. */
+    fun tick(): MovementStatus
+    /** Stops the movement and does any necessary clean up. */
+    fun stop()
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/RegularMovementTracker.kt

@@ -0,0 +1,209 @@
+/*
+ * 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
+
+import com.cobblemon.mod.common.entity.ai.CobblemonWalkTarget
+import com.cobblemon.mod.common.pokemon.ai.OmniPathNodeMaker
+import com.cobblemon.mod.common.util.deleteNode
+import java.util.function.Predicate
+import net.minecraft.core.BlockPos
+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
+import net.minecraft.world.entity.ai.util.DefaultRandomPos
+import net.minecraft.world.level.pathfinder.Path
+import net.minecraft.world.level.pathfinder.PathType
+import net.minecraft.world.phys.Vec3
+
+/**
+ * The default movement tracker used for tracking movement towards a [WalkTarget]. This is pretty much entirely
+ * just the code for FollowWalkTargetTask from Minecraft brain stuff.
+ *
+ * @author Hiroku
+ * @since December 29th, 2025
+ */
+class RegularMovementTracker(
+    val entity: PathfinderMob,
+    override val walkTarget: WalkTarget
+) : MovementTracker {
+    companion object {
+        /**
+         * Attempts to create a tracker for the given entity and target. Returns null if the path
+         * couldn't be created.
+         */
+        fun attempt(entity: PathfinderMob, walkTarget: WalkTarget): RegularMovementTracker? {
+            return RegularMovementTracker(entity, walkTarget).takeIf { it.isValid }
+        }
+    }
+
+    var isValid = false
+        private set
+    var started = false
+
+    override var lastStatus: MovementStatus = MovementStatus.PENDING
+    private var path: Path? = null
+    private var lastKnownTargetPos: BlockPos? = null
+
+    init {
+        val hasReached = hasReached(entity, walkTarget)
+        if (!hasReached && hasFinishedPath(entity, walkTarget)) {
+            this.lastKnownTargetPos = walkTarget.target.currentBlockPosition()
+            isValid = true
+        } else {
+            lastStatus = MovementStatus.FAILED
+        }
+    }
+
+    override fun tick(): MovementStatus {
+        val path = path
+        val status = if (path == null || isTargetSpectator(walkTarget)) {
+            stop(entity)
+            MovementStatus.FAILED
+        } else if (hasReached(entity, walkTarget)) {
+            stop(entity)
+            MovementStatus.COMPLETED
+        } else if (started && entity.navigation.isDone) {
+            stop(entity)
+            MovementStatus.FAILED
+        } else {
+            if (!started) {
+                startOnPath(entity)
+                started = true
+            }
+
+            tick(entity)
+            MovementStatus.PENDING
+        }
+        this.lastStatus = status
+        return status
+    }
+
+    fun startOnPath(entity: PathfinderMob) {
+        entity.brain.setMemory(MemoryModuleType.PATH, this.path)
+        entity.navigation.moveTo(this.path, walkTarget.speedModifier.toDouble())
+    }
+
+    override fun stop() {
+        stop(entity)
+    }
+
+    fun stop(entity: PathfinderMob) {
+        entity.navigation.stop()
+        entity.brain.eraseMemory(MemoryModuleType.WALK_TARGET)
+        entity.brain.eraseMemory(MemoryModuleType.PATH)
+    }
+
+    private fun tick(entity: PathfinderMob) {
+        val path = entity.navigation.path
+        if (this.path !== path) {
+            this.path = path
+            this.startOnPath(entity)
+        }
+
+        if (path != null && lastKnownTargetPos != null) {
+            if (walkTarget.target.currentBlockPosition().distSqr(lastKnownTargetPos!!) > 4.0) {
+                // The target has moved away from where we are pathing, try pathing to its new location
+                if (hasFinishedPath(entity, walkTarget)) {
+                    lastKnownTargetPos = walkTarget.target.currentBlockPosition()
+                    startOnPath(entity)
+                } else {
+                    // Uh oh, we can't get closer? Maybe next tick will be better?
+                }
+            }
+        }
+    }
+
+    private fun withNodeFilter(
+        entity: PathfinderMob,
+        nodeFilter: Predicate<PathType>,
+        block: () -> Unit) {
+        val nodeEvaluator = entity.navigation.nodeEvaluator
+        if (nodeEvaluator is OmniPathNodeMaker) {
+            nodeEvaluator.nodeFilter = nodeFilter
+            block()
+            nodeEvaluator.nodeFilter = Predicate { true }
+        } else {
+            block()
+        }
+    }
+
+    private fun hasFinishedPath(entity: PathfinderMob, walkTarget: WalkTarget): Boolean {
+        val blockPos = walkTarget.target.currentBlockPosition()
+        this.path = generatePath(entity, walkTarget, blockPos)
+        val hasReached = hasReached(entity, walkTarget)
+        if (!hasReached && path == null) {
+            // Desperate attempt to still path to the destination by going somewhere in the vicinity
+            val vec3d = DefaultRandomPos.getPosTowards(
+                entity,
+                10,
+                7,
+                Vec3.atBottomCenterOf(blockPos),
+                Math.PI / 2F
+            )
+            if (vec3d != null) {
+                this.path = generatePath(entity, walkTarget, BlockPos.containing(vec3d))
+                return this.path != null
+            }
+        } else if (!hasReached) {
+            return true
+        }
+
+        return false
+    }
+
+    private fun generatePath(
+        entity: PathfinderMob,
+        walkTarget: WalkTarget,
+        target: BlockPos
+    ): Path? {
+        var path: Path? = null
+        if (walkTarget is CobblemonWalkTarget) {
+            withNodeFilter(
+                entity = entity,
+                nodeFilter = walkTarget.nodeTypeFilter,
+            ) {
+                var resolvedPath = entity.navigation.createPath(
+                    walkTarget.target.currentBlockPosition(),
+                    0
+                )
+                if (resolvedPath != null) {
+                    // A CobblemonWalkTarget may have a destinationNodeTypeFilter, which is used to filter the end node of the path.
+                    // Mainly useful for when the thing setting the target did it a bit crudely or didn't know how far the navigator
+                    // was going to get, and might land on something that is technically traversable by the entity but it doesn't
+                    // fit the intention of the task. Example, a little bird wandering might end up finishing on a flight node,
+                    // but it doesn't really want to fly in place so it'd prefer not ending there.
+                    while (resolvedPath.endNode?.type?.let { walkTarget.destinationNodeTypeFilter(it) } == false) {
+                        resolvedPath.deleteNode(resolvedPath.nodeCount - 1)
+                    }
+                    if (resolvedPath.nodeCount == 0) {
+                        resolvedPath = null
+                    }
+                }
+                path = resolvedPath
+            }
+        } else {
+            path = entity.navigation.createPath(target, 0)
+        }
+        return path
+    }
+
+    private fun hasReached(entity: PathfinderMob, walkTarget: WalkTarget): Boolean {
+        return walkTarget.target.currentBlockPosition().distManhattan(entity.blockPosition()) <= walkTarget.closeEnoughDist
+    }
+
+    fun isTargetSpectator(target: WalkTarget): Boolean {
+        val lookTarget = target.target
+        return if (lookTarget is EntityTracker) {
+            lookTarget.entity.isSpectator
+        } else {
+            false
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/WanderType.kt

@@ -0,0 +1,223 @@
+/*
+ * 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
+
+import com.cobblemon.mod.common.api.ai.CobblemonWanderControl.WanderCenter
+import com.cobblemon.mod.common.api.ai.config.task.WanderTaskConfig.Companion.MAX_LOOK_DOWN_DISTANCE
+import com.cobblemon.mod.common.entity.OmniPathingEntity
+import com.cobblemon.mod.common.entity.ai.CobblemonRandomSurfacePos
+import com.cobblemon.mod.common.entity.ai.CobblemonWalkTarget
+import kotlin.math.ceil
+import kotlin.math.sqrt
+import net.minecraft.core.BlockPos
+import net.minecraft.server.level.ServerLevel
+import net.minecraft.world.entity.PathfinderMob
+import net.minecraft.world.entity.ai.behavior.BehaviorUtils
+import net.minecraft.world.entity.ai.memory.WalkTarget
+import net.minecraft.world.entity.ai.util.HoverRandomPos
+import net.minecraft.world.entity.ai.util.LandRandomPos
+import net.minecraft.world.level.material.Fluids
+import net.minecraft.world.level.pathfinder.PathType
+
+/**
+ * A type of wandering behaviour for an entity. I'm not sure if we keep this.
+ *
+ * @author Hiroku
+ * @since December 29th, 2025
+ */
+enum class WanderType(
+    val isValid: (PathfinderMob) -> Boolean,
+    val choosePosition: (PathfinderMob, minimumHeight: Int, maximumHeight: Int, horizontalRange: Int, verticalRange: Int) -> BlockPos?,
+    val createWalkTarget: (PathfinderMob, position: BlockPos, avoidsTargetingAir: Boolean, speedMultiplier: Float) -> WalkTarget?,
+) {
+
+    WATER(
+        isValid = { it.isInWater },
+        choosePosition = choosePosition@{ entity, _, _, horizontalRange, verticalRange ->
+            var pos = BehaviorUtils.getRandomSwimmablePos(entity, horizontalRange, verticalRange)?.let(BlockPos::containing)
+                ?: return@choosePosition null
+
+            // Move target pos down so that we don't move out of water too much
+            val requiredDepth = ceil(0.5 + entity.eyeHeight)
+            // Get the current depth of the block
+            var depth = 1
+            var testPos = pos.above()
+            var blockState = entity.level().getBlockState(testPos)
+            while (blockState.fluidState.type == Fluids.WATER) {
+                depth++
+                testPos = testPos!!.above()
+                blockState = entity.level().getBlockState(testPos)
+            }
+
+            if (depth < requiredDepth) {
+                // Iterate down until we reach the desired min depth or we reach a non water block
+                pos = pos.below()
+                blockState = entity.level().getBlockState(pos)
+                while (blockState.fluidState.type == Fluids.WATER && depth < requiredDepth && pos.y > entity.level().minBuildHeight) {
+                    depth++
+                    pos = pos.below()
+                    blockState = entity.level().getBlockState(pos)
+                }
+            }
+
+            return@choosePosition if (depth < requiredDepth) null else pos
+        },
+        createWalkTarget = { _, pos, _, speedMultiplier ->
+            CobblemonWalkTarget(
+                pos = pos,
+                nodeTypeFilter = { it == PathType.WATER || it == PathType.WATER_BORDER },
+                speedModifier = speedMultiplier,
+                completionRange = 0
+            )
+        }
+    ),
+    LAND(
+        isValid = { entity -> !entity.isInWater && !entity.isInLava },
+        choosePosition = choosePosition@{ entity, minimumHeight, maximumHeight, horizontalRange, verticalRange ->
+            val targetVec = when {
+                maximumHeight != -1 -> {
+                    HoverRandomPos.getPos(
+                        entity,
+                        horizontalRange,
+                        verticalRange,
+                        entity.random.nextFloat() - 0.5,
+                        entity.random.nextFloat() - 0.5,
+                        Math.PI.toFloat(),
+                        maximumHeight,
+                        minimumHeight
+                    )
+                }
+                entity.isUnderWater && entity.canBreatheUnderwater() && !((entity as OmniPathingEntity).canSwimInWater()) -> {
+                    BehaviorUtils.getRandomSwimmablePos(
+                        entity,
+                        horizontalRange,
+                        verticalRange
+                    )
+                }
+                entity is OmniPathingEntity && (entity.canWalkOnWater() || entity.canWalkOnLava()) -> {
+                    CobblemonRandomSurfacePos.getPos(
+                        entity,
+                        horizontalRange,
+                        verticalRange
+                    )
+                }
+                else -> {
+                    LandRandomPos.getPos(
+                        entity,
+                        horizontalRange,
+                        verticalRange
+                    )
+                }
+            }
+
+            val pos = targetVec?.let(BlockPos::containing) ?: return@choosePosition null
+            LAND.applyHeightConstraints(pos, minimumHeight, maximumHeight, entity.level() as ServerLevel)
+        },
+        createWalkTarget = { entity, pos, avoidsTargetingAir, speedMultiplier ->
+            CobblemonWalkTarget(
+                pos = pos,
+                speedModifier = speedMultiplier,
+                completionRange = 0,
+                nodeTypeFilter = { nodeType ->
+                    entity.canBreatheUnderwater() || nodeType !in listOf(
+                        PathType.WATER,
+                        PathType.WATER_BORDER
+                    )
+                },
+                destinationNodeTypeFilter = { nodeType ->
+                    !avoidsTargetingAir || nodeType !in listOf(
+                        PathType.OPEN
+                    )
+                }
+            )
+        }
+    )
+
+    ;
+
+    fun generateWalkTarget(
+        entity: PathfinderMob,
+        maxAttempts: Int,
+        center: WanderCenter?,
+        minimumHeight: Int,
+        maximumHeight: Int,
+        horizontalRange: Int,
+        verticalRange: Int,
+        avoidTargetingAir: Boolean,
+        speedMultiplier: Float
+    ): WalkTarget? {
+        var attempts = 0
+        var pos: BlockPos? = null
+
+        while (attempts++ < maxAttempts && pos == null) {
+            pos = choosePosition(entity, minimumHeight, maximumHeight, horizontalRange, verticalRange)
+                ?: return null
+            if (!isSuitable(center, pos)) {
+                pos = null
+            }
+        }
+
+        if (pos == null) {
+            return null
+        }
+
+        return createWalkTarget(entity, pos, avoidTargetingAir, speedMultiplier)
+    }
+
+    private fun isSuitable(center: WanderCenter?, position: BlockPos): Boolean {
+        val center = center ?: return true
+        val centerPos = BlockPos(center.x.toInt(), center.y.toInt(), center.z.toInt())
+        val distance = sqrt(centerPos.distSqr(position))
+        val suitable = distance >= center.minRange && distance <= center.maxRange
+        return suitable
+    }
+
+    private fun applyHeightConstraints(
+        pos: BlockPos,
+        minimumHeight: Int,
+        maximumHeight: Int,
+        world: ServerLevel
+    ): BlockPos {
+        if (minimumHeight <= 0 && maximumHeight == -1) {
+            return pos // It ain't a hoverer
+        }
+
+        val block = world.getBlockState(pos)
+        val altitude = if (!block.isAir) {
+            0
+        } else {
+            (1..MAX_LOOK_DOWN_DISTANCE).firstOrNull {
+                val newPos = pos.below(it)
+                if (!world.getBlockState(newPos).isAir) {
+                    return@firstOrNull true
+                } else if (newPos.y <= world.minBuildHeight) {
+                    // Don't adjust downward into the void (Mostly if we're in the end)
+                    // This doesn't stop fliers from wandering off end islands,
+                    // but it does stop them from diving directly into the void.
+                    return pos
+                }
+                return@firstOrNull false
+            } ?: MAX_LOOK_DOWN_DISTANCE
+        }
+
+        if (altitude > maximumHeight && maximumHeight >= 0) {
+            val excess = altitude - maximumHeight
+            val excessFromMinimum = altitude - minimumHeight
+            val correction = world.random.nextIntBetweenInclusive(excess, excessFromMinimum)
+            return pos.atY(pos.y - correction)
+        } else if (altitude < minimumHeight && minimumHeight >= 0) {
+            val deficit = minimumHeight - altitude
+            val deficitFromMaximum = maximumHeight - altitude
+            val correction = world.random.nextIntBetweenInclusive(deficit, deficitFromMaximum)
+            return pos.atY(pos.y + correction)
+        } else {
+            return pos
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/distraction/Distraction.kt

@@ -0,0 +1,42 @@
+/*
+ * 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.distraction
+
+import net.minecraft.world.damagesource.DamageSource
+
+/**
+ * Something that may distract an entity from its current fixation. The majority of fixations
+ * will rely on the types of distraction to determine if they should be distracted.
+ *
+ * @author Hiroku
+ * @since December 29th, 2025
+ */
+open class Distraction(val types: Set<DistractionType>) {
+    constructor(vararg types: DistractionType) : this(types.toSet())
+
+    val isIdleBoredom = DistractionType.IDLE_BOREDOM in types
+    val isForce = DistractionType.FORCE in types
+    val isComfort = DistractionType.COMFORT in types
+    val isDamage = DistractionType.DAMAGE in types
+
+    fun hasAnyOf(vararg distractionTypes: DistractionType): Boolean {
+        return distractionTypes.any { it in types }
+    }
+
+    companion object {
+        val FORCE = Distraction(DistractionType.FORCE)
+    }
+}
+
+/** Reusable basic distraction for a COMFORT type of distraction. */
+val comfortDistraction = Distraction(DistractionType.COMFORT)
+/** Reusable basic distraction for an IDLE_BOREDOM type of distraction. */
+val idleBoredomDistraction = Distraction(DistractionType.IDLE_BOREDOM)
+
+open class HurtDistraction(val damageSource: DamageSource) : Distraction(DistractionType.DAMAGE)

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/distraction/DistractionType.kt

@@ -0,0 +1,28 @@
+/*
+ * 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.distraction
+
+import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.EntityFixation
+
+/**
+ * A categorisation of distractions that can be attempted on an [EntityFixation].
+ *
+ * @author Hiroku
+ * @since December 29th, 2025
+ */
+enum class DistractionType {
+    /** Represents a distraction that the entity is not particularly motivated by but would consider doing out of boredom. */
+    IDLE_BOREDOM,
+    /** Represents a distraction that is for the sake of the entity's comfort because it isn't comfortable where it is. */
+    COMFORT,
+    /** Represents a distraction motivated by being hurt. */
+    DAMAGE,
+    /** A forceful distraction. Just about everything should respect this but it's conceivable that something not. */
+    FORCE,
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/fixation/ConditionalLockFixation.kt

@@ -0,0 +1,29 @@
+/*
+ * 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.distraction.Distraction
+import net.minecraft.world.entity.LivingEntity
+
+/**
+ * A fixation that rejects all non-force distractions and does nothing, lasting until
+ * the provided [condition] is no longer true.
+ *
+ * @author Hiroku
+ * @since January 16th, 2026
+ */
+open class ConditionalLockFixation(
+    val description: String,
+    val condition: () -> Boolean
+): EntityFixation, LockFixation {
+    override fun canDistract(distraction: Distraction, entity: LivingEntity) = distraction.isForce
+    override fun getDescription(entity: LivingEntity) = description
+    override fun tick(entity: LivingEntity, brain: BiggerBrain) = condition()
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/fixation/DurationLockFixation.kt

@@ -0,0 +1,31 @@
+/*
+ * 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.distraction.Distraction
+import net.minecraft.world.entity.LivingEntity
+
+/**
+ * A fixation that rejects all non-force distractions and does nothing for some
+ * number of ticks.
+ *
+ * @author Hiroku
+ * @since January 16th, 2026
+ */
+open class DurationLockFixation(
+    val description: String,
+    var durationTicks: Int
+) : EntityFixation, LockFixation {
+    override fun canDistract(distraction: Distraction, entity: LivingEntity) = distraction.isForce
+    override fun getDescription(entity: LivingEntity) = description.replace("{ticks}", durationTicks.toString())
+    override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
+        return --durationTicks > 0
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/fixation/EntityFixation.kt

@@ -0,0 +1,39 @@
+/*
+ * 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.distraction.Distraction
+import net.minecraft.world.entity.LivingEntity
+
+/**
+ * An entity's fixation, representing a task that takes a central role in the entity's behaviour
+ * and excludes all other possible fixations.
+ *
+ * The role of the fixation is to do an action which is the primary focus of the entity at that time,
+ * and which may be distracted from under some circumstances. An entity may be fixated on moving from
+ * A to B, and then be distracted upon being hurt. Or maybe it's an attack fixation, in which case
+ * damage doesn't distract it at all.
+ *
+ * The difference between a fixation and an objective is that objectives are capable of running in parallel,
+ * and a fixation may even be in the pursuit of an objective, but the fixation is central.
+ *
+ * @author Hiroku
+ * @since December 28th, 2025
+ */
+interface EntityFixation {
+    /** Returns true if the given distraction can stop this fixation. */
+    fun canDistract(distraction: Distraction, entity: LivingEntity): Boolean
+    /** Notifies the fixation that it has been distracted by the given distraction so it can do clean up. */
+    fun onDistract(distraction: Distraction, entity: LivingEntity) {}
+    /** Continues doing whatever the fixation does. Returns true if the fixation should continue. */
+    fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean
+    /** Gets a current description of the fixation for the debug screen. */
+    fun getDescription(entity: LivingEntity): String
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/fixation/LockFixation.kt

@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.ai.biggerbrain.fixation
+
+/**
+ * Represents a fixation that blocks battling, capture, etc. for Pokémon. This is
+ * used to control the isBusy property on Pokémon.
+ *
+ * @author Hiroku
+ * @since January 16th, 2026
+ */
+interface LockFixation

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/fixation/LookAndMoveFixation.kt

@@ -0,0 +1,52 @@
+/*
+ * 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.MovementStatus
+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.DistractionType
+import net.minecraft.world.entity.LivingEntity
+
+/**
+ * A simple fixation that uses both a looking tracker and a movement tracker.
+ *
+ * @author Hiroku
+ * @since December 29th, 2025
+ */
+open class LookAndMoveFixation(
+    /** Distraction types that will be respected. */
+    val distractionTypes: Set<DistractionType>,
+    /** How to describe the fixation in the debug overlay. */
+    val description: String,
+    override val lookingTracker: LookingTracker,
+    override val movementTracker: MovementTracker,
+    val onMovementComplete: ((entity: LivingEntity, brain: BiggerBrain) -> Unit)? = null
+): EntityFixation, LookingTrackerFixation, MovementTrackerFixation {
+    override fun getDescription(entity: LivingEntity) = description
+
+    override fun canDistract(distraction: Distraction, entity: LivingEntity): Boolean {
+        return distraction.types.any(distractionTypes::contains)
+    }
+
+    override fun onDistract(distraction: Distraction, entity: LivingEntity) {
+        movementTracker.stop()
+    }
+
+    override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
+        lookingTracker.tick()
+        val continueFixation = tickMovementFixation() == MovementStatus.PENDING
+        if (!continueFixation && onMovementComplete != null) {
+            onMovementComplete.invoke(entity, brain)
+        }
+        return continueFixation
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/fixation/LookingTrackerFixation.kt

@@ -0,0 +1,27 @@
+/*
+ * 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.LookingTracker
+
+/**
+ * Applied to fixations which may have looking associated with them. This is useful
+ * in the case that an objective needs to know if the current fixation intends on (or is)
+ * controlling their looking direction.
+ *
+ * Example: An objective that makes Pokémon bob their heads up and down while music is playing.
+ * Said objective would not warrant a full fixation, but would still like to ensure that the
+ * current fixation does not intend on using a looking tracker.
+ *
+ * @author Hiroku
+ * @since December 29th, 2025
+ */
+interface LookingTrackerFixation {
+    val lookingTracker: LookingTracker?
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/fixation/MovementTrackerFixation.kt

@@ -0,0 +1,35 @@
+/*
+ * 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.MovementStatus
+import com.cobblemon.mod.common.api.ai.biggerbrain.MovementTracker
+
+/**
+ * Applied to fixations which may have movement associated with them. This is useful
+ * in the case that an objective needs to know if the current fixation intends on (or is)
+ * controlling their movement.
+ *
+ * @author Hiroku
+ * @since December 29th, 2025
+ */
+interface MovementTrackerFixation {
+    /** The movement tracker at the moment. */
+    val movementTracker: MovementTracker?
+
+    /** Ticks the movement tracker in a way that skips finalized movement trackers. */
+    fun tickMovementFixation(): MovementStatus? {
+        val movementTracker = this.movementTracker ?: return null
+        return if (movementTracker.lastStatus != MovementStatus.PENDING) {
+            movementTracker.lastStatus
+        } else {
+            movementTracker.tick()
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/objective/Dance.kt

@@ -0,0 +1,158 @@
+/*
+ * 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.MovementStatus
+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.pokemon.PokemonBehaviourFlag
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.net.messages.client.effect.RunPosableMoLangPacket
+import com.cobblemon.mod.common.util.asExpression
+import com.cobblemon.mod.common.util.getMemorySafely
+import com.mojang.datafixers.util.Either
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.ai.memory.MemoryModuleType
+
+/**
+ * Stops movement and plays a Pokemon's dance animation, if available.
+ *
+ */
+class Dance(
+    val minDuration: Int,
+    val danceChance: Float
+) : Objective {
+    var fixation: EntityFixation? = null
+    var remainingCooldownTicks = 0
+    override fun getDescription(entity: LivingEntity) = "Dancing"
+    override fun perform(
+        entity: LivingEntity,
+        brain: BiggerBrain,
+        activeObjectiveTags: MutableSet<String>
+    ): ObjectiveStatus {
+        if (entity !is PokemonEntity) {
+            return ObjectiveStatus.INVALID
+        } else if (brain.isFixation(fixation)) {
+            remainingCooldownTicks = ticksBetweenAttempts
+            return ObjectiveStatus.FIXATED
+        } else if (brain.fixation != null) {
+            fixation = null
+        }
+
+        if (remainingCooldownTicks > 0) {
+            remainingCooldownTicks--
+            return ObjectiveStatus.INACTIVE
+        }
+
+        // Only dance if we feel like it
+        val danceMemory = brain.getMemory(MemoryModuleType.DANCING) ?: false
+        if (!danceMemory || entity.random.nextFloat() > danceChance || entity.ticksLived < 4 * 20) {
+            return ObjectiveStatus.INACTIVE
+        }
+
+        if (!brain.distract(idleBoredomDistraction)) {
+            return ObjectiveStatus.BLOCKED
+        }
+
+        entity.brain.eraseMemory(MemoryModuleType.WALK_TARGET)
+        entity.navigation.stop()
+
+
+        // Become fixated
+        fixation = brain.fixate(
+            DanceFixation(
+                this,
+                null,
+                minDuration
+            )
+        )
+        return ObjectiveStatus.ACTIVE
+    }
+
+
+    class DanceFixation(
+        val objective: Dance,
+        override val movementTracker: MovementTracker?,
+        val minDuration: Int
+    ) : EntityFixation, MovementTrackerFixation {
+        var ticksSinceStarted = 0
+        override fun getDescription(entity: LivingEntity) = "Dancing"
+        override fun tickMovementFixation() = MovementStatus.PENDING
+
+        override fun onDistract(distraction: Distraction, entity: LivingEntity) {
+            super.onDistract(distraction, entity)
+            stopDancing(entity)
+        }
+
+        override fun canDistract(distraction: Distraction, entity: LivingEntity): Boolean {
+            if (distraction.isIdleBoredom) {
+                return false
+            }
+            return true
+        }
+
+        fun stopDancing(entity: LivingEntity) {
+            val pokemon = entity as? PokemonEntity ?: return
+            pokemon.setBehaviourFlag(PokemonBehaviourFlag.DANCING, false)
+        }
+
+        override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
+            if (ticksSinceStarted == 0) { // Makes make me want a Start() for fixations
+                val pokemon = entity as? PokemonEntity ?: return false
+                RunPosableMoLangPacket(entity.id, setOf("v.bpm = 100;")).sendToPlayersAround(entity, 64.0)
+                pokemon.setBehaviourFlag(PokemonBehaviourFlag.DANCING, true)
+            }
+            ticksSinceStarted++
+            if (ticksSinceStarted > minDuration && !entity.brain.getMemorySafely(MemoryModuleType.DANCING).orElse(false)) {
+                stopDancing(entity)
+                return false
+            }
+            return true
+        }
+    }
+
+    class Config : ObjectiveConfig {
+        var danceChance: ExpressionOrEntityVariable = Either.left("1/2".asExpression())
+        var minDuration: ExpressionOrEntityVariable = Either.left("60".asExpression())
+
+        override fun getVariables(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ) = listOf(
+            minDuration,
+            danceChance
+        ).asVariables()
+
+        override fun create(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ): Objective {
+            val minDuration = minDuration.resolveInt(behaviourConfigurationContext.runtime)
+            val danceChance = danceChance.resolveFloat(behaviourConfigurationContext.runtime)
+            return Dance(
+                minDuration,
+                danceChance)
+        }
+    }
+
+    companion object {
+        private const val ticksBetweenAttempts = 20
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/objective/EatGrass.kt

@@ -0,0 +1,146 @@
+/*
+ * 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.distraction.Distraction
+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
+import com.cobblemon.mod.common.api.ai.resolveInt
+import com.cobblemon.mod.common.api.pokemon.feature.FlagSpeciesFeature
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.util.DataKeys
+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.level.GameRules
+import net.minecraft.world.level.block.Block
+import net.minecraft.world.level.block.Blocks
+import net.minecraft.world.level.block.state.predicate.BlockStatePredicate
+
+/**
+ * The baa's eat the graa's
+ *
+ * @author Hiroku
+ * @since January 9th, 2025
+ */
+class EatGrass(
+    val cooldownTicks: Int,
+    val eatGrassChance: Float
+) : Objective {
+    var fixation: EntityFixation? = null
+    val grassPredicate = BlockStatePredicate.forBlock(Blocks.GRASS_BLOCK)
+    var remainingCooldownTicks = cooldownTicks
+
+    override fun getDescription(entity: LivingEntity) = "Eat grass"
+
+    override fun perform(
+        entity: LivingEntity,
+        brain: BiggerBrain,
+        activeObjectiveTags: MutableSet<String>
+    ): 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 (remainingCooldownTicks > 0) {
+            remainingCooldownTicks--
+            return ObjectiveStatus.ACTIVE
+        }
+
+        val world = entity.level() as ServerLevel
+
+        entity.pokemon.getFeature<FlagSpeciesFeature>(DataKeys.HAS_BEEN_SHEARED)?.enabled?.takeIf { it } ?: run {
+            return ObjectiveStatus.INACTIVE
+        }
+
+        if (world.random.nextFloat() > eatGrassChance) {
+            return ObjectiveStatus.ACTIVE
+        } else {
+            val blockPos = entity.blockPosition()
+
+            // Are we not even on a grass block? Alright don't bother
+            if (!grassPredicate.test(world.getBlockState(blockPos)) && !world.getBlockState(blockPos.below()).`is`(Blocks.GRASS_BLOCK)) {
+                return ObjectiveStatus.ACTIVE
+            }
+
+            fixation = brain.fixate(EatGrassFixation(this))
+            entity.playAnimation("eat")
+            world.broadcastEntityEvent(entity, 10.toByte())
+            return ObjectiveStatus.FIXATED
+        }
+    }
+
+    class EatGrassFixation(val objective: EatGrass) : EntityFixation {
+        var timer = 40
+        override fun getDescription(entity: LivingEntity) = "Eating grass"
+        override fun canDistract(distraction: Distraction, entity: LivingEntity) = distraction.isComfort || distraction.isDamage || distraction.isForce
+        override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
+            timer--
+            if (timer <= 0) {
+                entity as PokemonEntity
+                val world = entity.level() as ServerLevel
+                val blockPos = entity.blockPosition()
+                if (objective.grassPredicate.test(world.getBlockState(blockPos)) ) {
+                    if (world.gameRules.getBoolean(GameRules.RULE_MOBGRIEFING)) {
+                        world.destroyBlock(blockPos, false)
+                    }
+                    entity.ate()
+                    objective.remainingCooldownTicks = objective.cooldownTicks
+                } else if (world.getBlockState(blockPos.below()).`is`(Blocks.GRASS_BLOCK)) {
+                    val below = blockPos.below()
+                    if (world.gameRules.getBoolean(GameRules.RULE_MOBGRIEFING)) {
+                        world.levelEvent(2001, below, Block.getId(Blocks.GRASS_BLOCK.defaultBlockState()))
+                        world.setBlock(below, Blocks.DIRT.defaultBlockState(), 2)
+                    }
+
+                    entity.ate()
+                    objective.remainingCooldownTicks = objective.cooldownTicks
+                }
+            }
+            return timer > 0
+        }
+    }
+
+    class Config : ObjectiveConfig {
+        var cooldownTicks: ExpressionOrEntityVariable = Either.left("400".asExpression())
+        var eatGrassChance: ExpressionOrEntityVariable = Either.left("1/400".asExpression())
+
+        override fun getVariables(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ) = listOf(
+            cooldownTicks,
+            eatGrassChance
+        ).asVariables()
+
+        override fun create(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ): Objective? {
+            val cooldownTicks = cooldownTicks.resolveInt(behaviourConfigurationContext.runtime)
+            val eatGrassChance = eatGrassChance.resolveFloat(behaviourConfigurationContext.runtime)
+            return if (eatGrassChance == 0F) {
+                null
+            } else {
+                EatGrass(
+                    cooldownTicks = cooldownTicks,
+                    eatGrassChance = eatGrassChance
+                )
+            }
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/objective/EatHeldItem.kt

@@ -0,0 +1,170 @@
+/*
+ * 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.distraction.Distraction
+import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.EntityFixation
+import com.cobblemon.mod.common.api.ai.biggerbrain.objective.PickupItem.Companion.dropItem
+import com.cobblemon.mod.common.api.ai.biggerbrain.sense.PokemonItemSense.Companion.PICKUP_ITEMS
+import com.cobblemon.mod.common.api.ai.config.objective.ObjectiveConfig
+import com.cobblemon.mod.common.api.ai.resolveInt
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.pokemon.ai.ObtainableItem
+import com.cobblemon.mod.common.util.asExpression
+import com.cobblemon.mod.common.util.findMatchingEntry
+import com.cobblemon.mod.common.util.getObjectList
+import com.cobblemon.mod.common.util.mainThreadRuntime
+import com.cobblemon.mod.common.util.resolve
+import com.cobblemon.mod.common.util.withQueryValue
+import com.mojang.datafixers.util.Either
+import net.minecraft.core.component.DataComponents
+import net.minecraft.core.particles.ItemParticleOption
+import net.minecraft.core.particles.ParticleTypes
+import net.minecraft.core.registries.BuiltInRegistries
+import net.minecraft.server.level.ServerLevel
+import net.minecraft.sounds.SoundEvents
+import net.minecraft.world.entity.Entity
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.item.ItemEntity
+import net.minecraft.world.item.ItemStack
+
+/**
+ * Eat the currently held item, apply the effect, and drop if it's an undesired item
+ *
+ * @author JazzMcNade
+ * @since February 16th, 2026
+ */
+class EatHeldItem(
+    val cooldownTicks: Int,
+    val pickupItems: List<ObtainableItem>
+) : Objective {
+    var fixation: EntityFixation? = null
+    var remainingCooldownTicks = cooldownTicks
+
+    override fun getDescription(entity: LivingEntity) = "Eat Held Item"
+
+    override fun perform(
+        entity: LivingEntity,
+        brain: BiggerBrain,
+        activeObjectiveTags: MutableSet<String>
+    ): ObjectiveStatus {
+        if (brain.isFixation(fixation)) {
+            return ObjectiveStatus.FIXATED
+        } else if (entity !is PokemonEntity) {
+            return ObjectiveStatus.INVALID
+        } else if (remainingCooldownTicks > 0) {
+            remainingCooldownTicks--
+            return ObjectiveStatus.INACTIVE
+        }
+        val itemStack: ItemStack = entity.pokemon.heldItem()
+        if (canEat(itemStack, entity)) {
+            fixation = brain.fixate(EatHeldItemFixation(this))
+            remainingCooldownTicks = 120
+            return ObjectiveStatus.FIXATED
+        }
+        return ObjectiveStatus.INACTIVE
+    }
+
+    fun canEat(item: ItemStack, entity: PokemonEntity): Boolean {
+        return item.has(DataComponents.FOOD) || pickupItems.findMatchingEntry(entity.registryAccess(), item)?.onUseEffect != null
+    }
+
+    class EatHeldItemFixation(val objective: EatHeldItem) : EntityFixation {
+        var ticksRemaining = 40
+        override fun getDescription(entity: LivingEntity) = "Eating held item"
+        override fun canDistract(distraction: Distraction, entity: LivingEntity) = distraction.isComfort || distraction.isDamage || distraction.isForce
+        override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
+            val world = entity.level()
+            if (entity is PokemonEntity && entity.isAlive) {
+                val itemStack: ItemStack = entity.pokemon.heldItem()
+                val itemConfig = objective.pickupItems.findMatchingEntry(entity.registryAccess(), itemStack)
+                if (objective.canEat(itemStack, entity)) {
+                    if (ticksRemaining < 0) {
+                        var resultItemStack = itemStack.finishUsingItem(world, entity)
+                        val configuredReturnItem = itemConfig?.returnItem
+                        resultItemStack = if (configuredReturnItem != ItemStack.EMPTY) ItemStack(BuiltInRegistries.ITEM.get(configuredReturnItem))
+                        else if (resultItemStack.item == itemStack.item)
+                            ItemStack.EMPTY // Items that aren't normally edible return themselves
+                        else
+                            resultItemStack
+                        entity.pokemon.swapHeldItem(resultItemStack)
+                        val onUseEffect = itemConfig?.onUseEffect
+                        if (onUseEffect != null) {
+                            mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
+                            mainThreadRuntime.resolve(onUseEffect)
+                        }
+                        if (itemConfig != null && itemConfig.fullnessValue > 0) {
+                            entity.pokemon.feedPokemon(itemConfig.fullnessValue, false)
+                        }
+                        // Check if the result item is something that should be dropped
+                        resultItemStack = entity.pokemon.heldItem()
+                        if ((objective.pickupItems.findMatchingEntry(entity.registryAccess(), resultItemStack)?.pickupPriority ?: 0) < 0) {
+                            // Drop item
+                            resultItemStack = entity.pokemon.swapHeldItem(resultItemStack)
+                            if (!resultItemStack.isEmpty && !entity.level().isClientSide) {
+                                dropItem(entity, resultItemStack)
+                            }
+                        }
+                        return false
+                    } else if ((itemConfig?.fullnessValue ?: 0) > 0 && entity.random.nextFloat() < 0.4f) {
+                        ticksRemaining--
+                        entity.playSound(entity.getEatingSound(itemStack), 1.0f, 1.0f)
+                        world.broadcastEntityEvent(entity, 45.toByte())
+                        spawnFoodParticles(entity, itemStack)
+                    }
+                }
+                return true
+            }
+            return false
+        }
+
+        private fun spawnFoodParticles(entity: LivingEntity, itemStack: ItemStack) {
+            val serverLevel = entity.level() as ServerLevel
+            //TODO: Figure out how to this with snowstorm so we can use mouth/face/head locators
+            // The issue as of this writing is we don't have a clean way to utilize the item texture for the particle in snowstorm
+            serverLevel.sendParticles(
+                ItemParticleOption(ParticleTypes.ITEM, itemStack),
+                entity.x, entity.y + 0.5, entity.z, // particle position (centered on entity)
+                5, // count
+                0.1, 0.1, 0.1, // x, y, z offset spread
+                0.05 // speed
+            )
+        }
+    }
+
+    class Config : ObjectiveConfig {
+        var cooldownTicks: ExpressionOrEntityVariable = Either.left("120".asExpression())
+        override fun getVariables(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ) = listOf(
+            cooldownTicks
+        ).asVariables()
+
+        override fun create(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ): Objective? {
+            var pickupItems = emptyList<ObtainableItem>()
+            if (entity is PokemonEntity) {
+                 pickupItems = entity.config.getObjectList<ObtainableItem>(PICKUP_ITEMS)
+            }
+            val cooldownTicks = cooldownTicks.resolveInt(behaviourConfigurationContext.runtime)
+            return EatHeldItem(
+                    cooldownTicks = cooldownTicks,
+                    pickupItems = pickupItems
+                )
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/objective/FocusDuringBattle.kt

@@ -0,0 +1,244 @@
+/*
+ * 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.fixation.EntityFixation
+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.distraction.HurtDistraction
+import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.LockFixation
+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.ai.resolveBoolean
+import com.cobblemon.mod.common.api.ai.resolveInt
+import com.cobblemon.mod.common.api.scheduling.afterOnServer
+import com.cobblemon.mod.common.battles.BattleRegistry
+import com.cobblemon.mod.common.entity.npc.NPCEntity
+import com.cobblemon.mod.common.entity.pokemon.PokemonBehaviourFlag
+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
+
+/**
+ * An objective that ensures the entity, whether it's a PokemonEntity or an NPCEntity, will pay attention to its
+ * opponents in battle. They will not move, and will look at its opponents. For Pokémon, they will focus on the
+ * targeted opponent if one exists; otherwise, they will randomly look at one of their opponent Pokémon. For NPCs,
+ * they will randomly look at one of their opponent Pokémon.
+ *
+ * If the entity gets hurt and [stopBattleIfHurt] is true, this objective stops the battle.
+ *
+ * @author Hiroku
+ * @since December 29th, 2025
+ */
+class FocusDuringBattle(
+    var stopBattleIfHurt: Boolean = true,
+    var minDurationTicks: Int = 40,
+    var maxDurationTicks: Int = 80
+) : Objective {
+    var fixation: EntityFixation? = null
+
+    override fun getDescription(entity: LivingEntity) = "Look at battle opponents"
+    override fun perform(entity: LivingEntity, brain: BiggerBrain, activeObjectiveTags: MutableSet<String>): ObjectiveStatus {
+        if (entity !is NPCEntity && entity !is PokemonEntity) {
+            return ObjectiveStatus.INVALID
+        }
+
+        if (stopBattleIfHurt && brain.hasMemoryValue(MemoryModuleType.HURT_BY)) {
+            if (brain.isFixation(fixation)) {
+                if (entity is PokemonEntity) {
+                    entity.battle?.stop()
+                } else if (entity is NPCEntity) {
+                    entity.battleIds.mapNotNull { BattleRegistry.getBattle(it) }.forEach { it.stop() }
+                }
+                brain.distract(Distraction.FORCE)
+            }
+            return ObjectiveStatus.INACTIVE
+        }
+
+        val isInBattle = isInBattle(entity)
+        if (brain.isFixation(fixation)) {
+            if (isInBattle) {
+                // Ok this is fine
+                return ObjectiveStatus.FIXATED
+            } else {
+                // Alright my work here is done, going back to inactive.
+                fixation = null
+                brain.fixation = null
+                return ObjectiveStatus.INACTIVE
+            }
+        } else if (!isInBattle) {
+            // Ok we don't need to do anything
+            fixation = null
+            return ObjectiveStatus.INACTIVE
+        } else {
+            // We need to start focusing
+            if (brain.distract(Distraction.FORCE)) {
+                fixation = if (entity is NPCEntity) NPCFocusFixation(this) else PokemonFocusFixation(this)
+                // Handle kick starting flight for flying pokemon over water
+                if (entity is PokemonEntity && entity.exposedForm.behaviour.moving.fly.canFly) {
+                    if (entity.ticksLived >= 0 && entity.navigation.isAirborne(entity.level(), entity.blockPosition())) {
+                        // Let flyers fly in battle if they're in the air
+                        entity.setBehaviourFlag(PokemonBehaviourFlag.FLYING, true)
+                        afterOnServer(0.1F) {
+                            entity.navigation.moveTo(entity.x, entity.y + 0.2, entity.z, 1.0)
+                        }
+                    }
+                }
+                brain.fixation = fixation
+                return ObjectiveStatus.FIXATED
+            } else {
+                return ObjectiveStatus.BLOCKED
+            }
+        }
+    }
+
+    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))
+        }
+    }
+
+    fun isInBattle(entity: LivingEntity): Boolean {
+        return when (entity) {
+            is PokemonEntity -> entity.isBattling
+            is NPCEntity -> entity.isInBattle()
+            else -> false
+        }
+    }
+
+    class NPCFocusFixation(val objective: FocusDuringBattle) : EntityFixation, LookingTrackerFixation {
+        override var lookingTracker: LookingTracker? = null
+        var ticksUntilReacquireTarget: Int = 0
+
+        override fun getDescription(entity: LivingEntity): String {
+            return if (lookingTracker == null) {
+                "Looking for an opponent Pokémon to look at"
+            } else {
+                "Looking at targeted or opponent Pokémon"
+            }
+        }
+
+        override fun canDistract(distraction: Distraction, entity: LivingEntity) = distraction.isForce
+
+        fun acquireLookTarget(entity: NPCEntity, brain: BiggerBrain) {
+            val battlingPokemon = brain.getMemory(CobblemonMemories.BATTLING_POKEMON) ?: return
+            val randomBattlingPokemon = battlingPokemon.randomOrNull()?.let { (entity.level() as ServerLevel).getEntity(it) }
+            if (randomBattlingPokemon != null) {
+                lookingTracker = LookingTracker(entity, EntityTracker(randomBattlingPokemon, true))
+            }
+        }
+
+        override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
+            if (entity !is NPCEntity) {
+                return false
+            }
+
+            val battlingPokemon = brain.getMemory(CobblemonMemories.BATTLING_POKEMON) ?: return false
+
+            val lookingTracker = lookingTracker
+            if (lookingTracker != null && lookingTracker.entity.uuid !in battlingPokemon) {
+                this.lookingTracker = null
+                ticksUntilReacquireTarget = 0
+            }
+
+            if (ticksUntilReacquireTarget <= 0) {
+                acquireLookTarget(entity, brain)
+                ticksUntilReacquireTarget = (objective.minDurationTicks..objective.maxDurationTicks).random()
+            } else {
+                ticksUntilReacquireTarget--
+            }
+
+            lookingTracker?.tick()
+
+            return true
+        }
+    }
+
+    class PokemonFocusFixation(val objective: FocusDuringBattle) : EntityFixation, LookingTrackerFixation, LockFixation {
+        var ticksUntilReacquireTarget: Int = 0
+        override var lookingTracker: LookingTracker? = null
+
+        override fun getDescription(entity: LivingEntity): String {
+            return if (lookingTracker == null) {
+                "Looking for an opponent Pokémon to look at"
+            } else {
+                "Looking at targeted or opponent Pokémon"
+            }
+        }
+
+        override fun canDistract(distraction: Distraction, entity: LivingEntity) = distraction.isForce
+
+        override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
+            if (entity !is PokemonEntity) {
+                return false
+            }
+
+            val battlingPokemon = brain.getMemory(CobblemonMemories.BATTLING_POKEMON) ?: return false
+            val targetedBattlePokemon = brain.getMemory(CobblemonMemories.TARGETED_BATTLE_POKEMON)
+
+            val lookingTracker = lookingTracker
+            // If there is a targetedBattlePokemon then that is the highest priority, and we should not look away
+            // Otherwise, look at one of the entities for a while and occasionally reacquire the target.
+            if (targetedBattlePokemon != null && (lookingTracker == null || lookingTracker.entity.uuid != targetedBattlePokemon)) {
+                // We should be targeting the targetedBattlePokemon
+                val targetedPokemon = (entity.level() as ServerLevel).getEntity(targetedBattlePokemon) ?: return false
+                this.lookingTracker = LookingTracker(entity, EntityTracker(targetedPokemon, true))
+                ticksUntilReacquireTarget = (objective.minDurationTicks..objective.maxDurationTicks).random()
+            } else if (targetedBattlePokemon == null && ticksUntilReacquireTarget <= 0) {
+                // Choose someone to look at
+                val randomBattlingPokemon = battlingPokemon.randomOrNull()?.let { (entity.level() as ServerLevel).getEntity(it) }
+                if (randomBattlingPokemon != null) {
+                    this.lookingTracker = LookingTracker(entity, EntityTracker(randomBattlingPokemon, true))
+                    ticksUntilReacquireTarget = (objective.minDurationTicks..objective.maxDurationTicks).random()
+                }
+            }
+
+            ticksUntilReacquireTarget--
+            this.lookingTracker?.tick()
+            return true
+        }
+    }
+
+    class Config : ObjectiveConfig {
+        var stopBattleIfHurt: ExpressionOrEntityVariable = Either.left("true".asExpression())
+        var minDurationTicks: ExpressionOrEntityVariable = Either.left("40".asExpression())
+        var maxDurationTicks: ExpressionOrEntityVariable = Either.left("80".asExpression())
+
+        override fun getVariables(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ) = listOf(
+            stopBattleIfHurt,
+            minDurationTicks,
+            maxDurationTicks
+        ).asVariables()
+
+        override fun create(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): Objective {
+            val stopBattleIfHurt = stopBattleIfHurt.resolveBoolean(behaviourConfigurationContext.runtime)
+            val minDurationTicks = minDurationTicks.resolveInt(behaviourConfigurationContext.runtime)
+            val maxDurationTicks = maxDurationTicks.resolveInt(behaviourConfigurationContext.runtime)
+            return FocusDuringBattle(
+                stopBattleIfHurt = stopBattleIfHurt,
+                minDurationTicks = minDurationTicks,
+                maxDurationTicks = maxDurationTicks
+            )
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/objective/GatherNectar.kt

@@ -0,0 +1,508 @@
+/*
+ * 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.CobblemonBlocks
+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.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.config.objective.ObjectiveConfig
+import com.cobblemon.mod.common.api.ai.config.task.PollinateFlowerTaskConfig
+import com.cobblemon.mod.common.api.ai.resolveInt
+import com.cobblemon.mod.common.block.SaccharineLeafBlock
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.util.asExpression
+import com.cobblemon.mod.common.util.distanceTo
+import com.cobblemon.mod.common.util.getMemorySafely
+import com.cobblemon.mod.common.util.mainThreadRuntime
+import com.cobblemon.mod.common.util.resolveFloat
+import com.mojang.datafixers.util.Either
+import net.minecraft.core.BlockPos
+import net.minecraft.sounds.SoundEvents
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.PathfinderMob
+import net.minecraft.world.entity.ai.memory.MemoryStatus
+import net.minecraft.world.entity.ai.memory.WalkTarget
+import net.minecraft.world.level.block.BeehiveBlock
+import net.minecraft.world.level.block.entity.BeehiveBlockEntity
+import net.minecraft.world.phys.Vec3
+
+/**
+ * Mimics the vanilla bee behavior, with added interactions with Saccharine leaves.
+ * Only wild bees are allowed to enter hives because of dupe risks with pasture blocks.
+ *
+ * @author JazzMcNade
+ * @since February 23th, 2026
+ */
+class GatherNectar(
+    val ticksBetweenAttempts: Int = 60,
+    val maxDistance: Expression = "14.0".asExpression(),
+    val speedMultiplier: Expression = "0.2".asExpression()
+) : Objective {
+    var workerFixation: EntityFixation? = null
+    var shelterFixation: EntityFixation? = null
+    var remainingCooldownTicks = ticksBetweenAttempts
+
+    override fun getDescription(entity: LivingEntity) = "Worker Bee"
+    override fun perform(
+        entity: LivingEntity,
+        brain: BiggerBrain,
+        activeObjectiveTags: MutableSet<String>
+    ): ObjectiveStatus {
+        if (entity !is PokemonEntity) {
+            return ObjectiveStatus.INVALID
+        } else if (brain.isFixation(shelterFixation)) {
+            // Never preempt the shelter fixation
+            remainingCooldownTicks = ticksBetweenAttempts
+            return ObjectiveStatus.FIXATED
+        } else if (!entity.biggerBrain.hasMemoryValue(CobblemonMemories.HIVE_LOCATION) && !entity.biggerBrain.hasMemoryValue(CobblemonMemories.NEARBY_SACC_LEAVES)) {
+            return ObjectiveStatus.INACTIVE
+        }
+
+        val world = entity.level()
+
+        if ((world.isRaining || world.isNight) ) {
+            if (!brain.distract(comfortDistraction)) {
+                return ObjectiveStatus.BLOCKED
+            }
+            // Return to hive or do nothing
+            if (entity.pokemon.isWild()) {
+                // Only wilds can path to hives
+                val hivePos = entity.biggerBrain.getMemory(CobblemonMemories.HIVE_LOCATION)
+                if (hivePos != null && wantsToEnterHive(entity)) {
+                    // Deliver to hive
+                    if (!tryEnterHive(entity)) { // Attempt to enter the hive, if we fail, probably too far away
+                        val hiveEntrance = getHiveEntrance(hivePos, entity)
+                        if (hiveEntrance != null) {
+                            // Move to hive
+                            shelterFixation = tryMovementFixation(entity, hiveEntrance, "Sheltering in Hive", ::onHiveMovementComplete)
+                        } else {
+                            // Blacklist the hive
+                            dropAndBlackListHive(entity)
+                        }
+
+                    } // no else the entity is gone and is stored in the hive
+                }
+            } else {
+                return ObjectiveStatus.INACTIVE
+            }
+
+        } else if (brain.isFixation(workerFixation)) {
+            // Already fixated on the work
+            remainingCooldownTicks = ticksBetweenAttempts
+            return ObjectiveStatus.FIXATED
+        } else {
+            // Perform nectar gathering/delivery
+            if (!brain.distract(idleBoredomDistraction)) {
+                return ObjectiveStatus.BLOCKED
+            }
+            if (entity.biggerBrain.hasMemoryValue(CobblemonMemories.HAS_NECTAR) ) {
+                // Deliver nectar to hive or Sacc leaves
+                val hivePos = entity.biggerBrain.getMemory(CobblemonMemories.HIVE_LOCATION)
+                if (hivePos != null && wantsToEnterHive(entity) && entity.pokemon.isWild()) {
+                    // Deliver to hive
+                    if (!tryEnterHive(entity)) { // Attempt to enter the hive, if we fail, probably too far away
+                        val hiveEntrance = getHiveEntrance(hivePos, entity)
+                        if (hiveEntrance != null) {
+                            // Move to hive
+                            workerFixation = tryMovementFixation(entity, hiveEntrance, "Delivering nectar to hive", ::onHiveMovementComplete)
+                        } else {
+                            // Blacklist the hive
+                            dropAndBlackListHive(entity)
+                        }
+
+                    } // no else the entity is gone and is stored in the hive
+                } else {
+                    // Deliver to Saccharine Leaves
+                    val sacLeafPos : BlockPos = entity.biggerBrain.getMemory(CobblemonMemories.NEARBY_SACC_LEAVES)
+                        ?: return ObjectiveStatus.INACTIVE
+                    if (entity.blockPosition() != sacLeafPos) {
+                        workerFixation = tryMovementFixation(entity, sacLeafPos, "Delivering nectar to Saccharine Leaves")
+                        return ObjectiveStatus.ACTIVE
+                    } else {
+                        // Do nectar deposit fixation
+                        workerFixation = brain.fixate(DepositNectarInSaccharineLeavesFixation())
+                        return ObjectiveStatus.ACTIVE
+                    }
+                }
+
+            } else {
+                // Gather Nectar
+                val flowerPos =
+                    entity.biggerBrain.getMemory(CobblemonMemories.NEARBY_FLOWER) ?: return ObjectiveStatus.INACTIVE
+                val distance = entity.distanceTo(flowerPos)
+                val maxDistance = mainThreadRuntime.resolveFloat(maxDistance)
+                if (distance < 1.0) {
+                    // Pollinate/Gather nectar from the flower
+                    if (workerFixation !is PollinateFlowerFixation && brain.distract(idleBoredomDistraction)) {
+                        workerFixation = brain.fixate(PollinateFlowerFixation())
+                        return ObjectiveStatus.FIXATED
+                    }
+
+                } else if (distance < maxDistance) {
+                    // Move to the flower
+                    if (remainingCooldownTicks <= 0 && brain.distract(idleBoredomDistraction) && !brain.hasMemoryValue(
+                            CobblemonMemories.PATH_TO_NEARBY_FLOWER_COOLDOWN
+                        )
+                    ) {
+                        remainingCooldownTicks = ticksBetweenAttempts
+                        workerFixation = tryMovementFixation(entity, flowerPos, "Moving to flower")
+                    }
+                }
+            }
+        }
+
+        if (remainingCooldownTicks > 0) {
+            remainingCooldownTicks--
+        }
+
+        return ObjectiveStatus.ACTIVE
+    }
+
+
+
+    /*
+     * This Fixation has movement, but it doesn't utilize pathfinding, and it's more about flavor than accomplishing a goal
+     *
+     *
+     */
+    class PollinateFlowerFixation(
+    ) : EntityFixation {
+        var successfulPollinationTicks = 0
+        var lastSoundPlayedTick = 0
+        var hoverPos: Vec3? = null
+        override fun getDescription(entity: LivingEntity) = "Pollinating Flower"
+        override fun canDistract(distraction: Distraction, entity: LivingEntity): Boolean {
+            return distraction.isDamage || distraction.isForce || distraction.isComfort || entity.brain.hasMemoryValue(
+                CobblemonMemories.HAS_NECTAR
+            )
+        }
+
+        override fun onDistract(distraction: Distraction, entity: LivingEntity) {
+            hoverPos = null
+            if (successfulPollinationTicks > REQUIRED_SUCCESSFUL_POLLINATION_TICKS) {
+                entity.brain.setMemory(CobblemonMemories.HAS_NECTAR, true)
+            }
+            successfulPollinationTicks = 0
+            entity.brain.setMemoryWithExpiry(
+                CobblemonMemories.PATH_TO_NEARBY_FLOWER_COOLDOWN, true,
+                PollinateFlowerTaskConfig.Companion.PATH_TO_FLOWER_COOLDOWN_TICKS
+            )
+
+        }
+
+        override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
+            if (entity !is PokemonEntity) return false
+            val flowerPos = entity.brain.getMemorySafely(CobblemonMemories.NEARBY_FLOWER).orElse(null)
+
+            if (!(flowerPos != null && Vec3.atCenterOf(flowerPos).distanceTo(entity.position()) <= 1.0)) {
+                onStop(entity)
+                return false
+            }
+            ++successfulPollinationTicks
+
+            if (successfulPollinationTicks > REQUIRED_SUCCESSFUL_POLLINATION_TICKS) {
+                onStop(entity)
+                return false
+            }
+
+            if (entity.random.nextFloat() < 0.05f && successfulPollinationTicks > this.lastSoundPlayedTick + 60) {
+                this.lastSoundPlayedTick = successfulPollinationTicks
+                entity.playSound(SoundEvents.BEE_POLLINATE, 1.0f, 1.0f)
+            }
+
+
+            val bl = hoverPos == null || entity.position().distanceTo(hoverPos!!) <= 0.1
+            val bl3 = entity.random.nextInt(40) == 0
+            if (bl && bl3) {
+                // mimics the wriggling over a flower the vanilla bees do
+                if (hoverPos == null) {
+                    hoverPos = flowerPos.bottomCenter.add(0.0, 0.4, 0.0)
+                }
+
+                hoverPos = flowerPos.bottomCenter.add(
+                    Vec3(
+                        (entity.random.nextDouble() * 2.0 - 1.0) * (1.0 / 5.0),
+                        0.3 + (entity.random.nextDouble() * 2.0 - 1.0) * (1.0 / 7.0),
+                        (entity.random.nextDouble() * 2.0 - 1.0) * (1.0 / 5.0)
+                    )
+                )
+                entity.getMoveControl()
+                    .setWantedPosition(hoverPos!!.x(), hoverPos!!.y(), hoverPos!!.z(), 0.35)
+                entity.lookControl.setLookAt(flowerPos.bottomCenter.add(0.0, 0.5, 0.0))
+            } else if (!bl) {
+                entity.getMoveControl()
+                    .setWantedPosition(hoverPos!!.x(), hoverPos!!.y(), hoverPos!!.z(), 0.35)
+            }
+            entity.lookControl.setLookAt(flowerPos.bottomCenter.add(0.0, 0.5, 0.0))
+            return true
+        }
+
+        fun onStop(entity: LivingEntity) {
+            hoverPos = null
+            if (successfulPollinationTicks > REQUIRED_SUCCESSFUL_POLLINATION_TICKS) {
+                entity.brain.setMemory(CobblemonMemories.HAS_NECTAR, true)
+            }
+            successfulPollinationTicks = 0
+            entity.brain.setMemoryWithExpiry(
+                CobblemonMemories.PATH_TO_NEARBY_FLOWER_COOLDOWN, true,
+                PATH_TO_FLOWER_COOLDOWN_TICKS
+            )
+
+        }
+    }
+
+    class DepositNectarInSaccharineLeavesFixation() : EntityFixation {
+        var successfulPollinationTicks = 0
+        var lastSoundPlayedTick = 0
+        var hoverPos: Vec3? = null
+        override fun getDescription(entity: LivingEntity) = "Depositing nectar in Saccharine Leaves"
+        override fun canDistract(distraction: Distraction, entity: LivingEntity): Boolean {
+            return distraction.isDamage || distraction.isForce || distraction.isComfort || entity.brain.hasMemoryValue(
+                CobblemonMemories.HAS_NECTAR
+            )
+        }
+
+        override fun onDistract(distraction: Distraction, entity: LivingEntity) {
+            hoverPos = null
+            if (successfulPollinationTicks > REQUIRED_SUCCESSFUL_POLLINATION_TICKS) {
+                entity.brain.setMemory(CobblemonMemories.HAS_NECTAR, true)
+            }
+            successfulPollinationTicks = 0
+            entity.brain.setMemoryWithExpiry(
+                CobblemonMemories.PATH_TO_NEARBY_FLOWER_COOLDOWN, true,
+                PollinateFlowerTaskConfig.Companion.PATH_TO_FLOWER_COOLDOWN_TICKS
+            )
+
+        }
+
+        override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
+            if (entity !is PokemonEntity) return false
+            ++successfulPollinationTicks
+
+            if (successfulPollinationTicks > REQUIRED_SUCCESSFUL_POLLINATION_TICKS) {
+                val blockPos = brain.getMemory(CobblemonMemories.NEARBY_SACC_LEAVES)
+                blockPos?.let {
+                    val world = entity.level()
+                    val blockState = world.getBlockState(blockPos)
+                    if (blockState.block == CobblemonBlocks.SACCHARINE_LEAVES) {
+                        val saccAge = blockState.getValue( SaccharineLeafBlock.AGE)
+                        if (saccAge < SaccharineLeafBlock.MAX_AGE) {
+                            brain.eraseMemory(CobblemonMemories.HAS_NECTAR)
+                            val newBlockState = blockState.setValue(SaccharineLeafBlock.AGE,  saccAge + 1)
+                            world.setBlock(blockPos, newBlockState, 3)
+                        }
+                    }
+                }
+                return false
+            }
+
+            if (entity.random.nextFloat() < 0.05f && successfulPollinationTicks > this.lastSoundPlayedTick + 60) {
+                this.lastSoundPlayedTick = successfulPollinationTicks
+                entity.playSound(SoundEvents.BEEHIVE_DRIP, 1.0f, 1.0f)
+            }
+            val leavesPos = brain.getMemory(CobblemonMemories.NEARBY_SACC_LEAVES) ?: return false
+
+            val bl = hoverPos == null || entity.position().distanceTo(hoverPos!!) <= 0.1
+            val bl3 = entity.random.nextInt(40) == 0
+            if (bl && bl3) {
+                // mimics the wriggling over a flower the vanilla bees do
+                if (hoverPos == null) {
+                    hoverPos = leavesPos.bottomCenter.add(0.0, 0.4, 0.0)
+                }
+                hoverPos = leavesPos.bottomCenter.add(Vec3((entity.random.nextDouble() * 2.0 - 1.0) * (1.0/5.0), 0.3 + (entity.random.nextDouble() * 2.0 - 1.0) * (1.0/7.0), (entity.random.nextDouble() * 2.0 - 1.0) * (1.0/5.0)))
+                entity.getMoveControl()
+                    .setWantedPosition(hoverPos!!.x(), hoverPos!!.y(), hoverPos!!.z(), 0.35)
+                entity.lookControl.setLookAt(leavesPos.bottomCenter.add(0.0,0.5,0.0))
+            } else if (!bl) {
+                entity.getMoveControl()
+                    .setWantedPosition(hoverPos!!.x(), hoverPos!!.y(), hoverPos!!.z(), 0.35)
+            }
+            return true
+        }
+    }
+
+    class Config : ObjectiveConfig {
+        val ticksBetweenAttempts: ExpressionOrEntityVariable = Either.left("60".asExpression())
+        val maxDistance: ExpressionOrEntityVariable = Either.left("10.0".asExpression())
+        val speedMultiplier: ExpressionOrEntityVariable = Either.left("0.4".asExpression())
+
+        override fun getVariables(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ) = listOf(
+            ticksBetweenAttempts,
+            maxDistance,
+            speedMultiplier
+        ).asVariables()
+
+        override fun create(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ): Objective {
+            val ticksBetweenAttempts = ticksBetweenAttempts.resolveInt(behaviourConfigurationContext.runtime)
+            return GatherNectar(
+                ticksBetweenAttempts = ticksBetweenAttempts,
+                maxDistance = maxDistance.asSimplifiedExpression(entity),
+                speedMultiplier = speedMultiplier.asSimplifiedExpression(entity)
+            )
+        }
+    }
+
+    fun onHiveMovementComplete(entity: LivingEntity, brain: BiggerBrain) {
+        if (entity !is PokemonEntity) return
+        if(!tryEnterHive(entity)) {
+            dropAndBlackListHive(entity)
+        }
+    }
+
+    fun tryMovementFixation(
+        entity: PokemonEntity,
+        blockPos: BlockPos,
+        description : String,
+        onMovementComplete : ((entity: LivingEntity, brain: BiggerBrain) -> Unit)? = null,
+    ) : EntityFixation? {
+        val speedMultiplier = mainThreadRuntime.resolveFloat(speedMultiplier)
+
+        val movementTracker = RegularMovementTracker.attempt(
+            entity = entity,
+            walkTarget = WalkTarget(
+                blockPos,
+                speedMultiplier,
+                0
+            )
+        )
+        if (movementTracker != null) {
+            val fixation = entity.biggerBrain.fixate(
+                LookAndMoveFixation(
+                    distractionTypes = setOf(
+                        DistractionType.DAMAGE,
+                        DistractionType.COMFORT,
+                        DistractionType.FORCE
+                    ),
+                    lookingTracker = LookingTracker.fromNavigationPathOrWalkTarget(
+                        entity,
+                        movementTracker.walkTarget
+                    ),
+                    movementTracker = movementTracker,
+                    description = description,
+                    onMovementComplete = onMovementComplete
+                )
+            )
+            return fixation
+        }
+        return null
+    }
+
+    fun getHiveEntrance(hiveLocation: BlockPos, entity: LivingEntity) : BlockPos? {
+        val sidesByClosest = listOf(
+            hiveLocation.north(),
+            hiveLocation.south(),
+            hiveLocation.east(),
+            hiveLocation.west()
+        ).sortedBy { it.distSqr(entity.blockPosition()) }
+
+        val world = entity.level()
+        var openSide = BlockPos.ZERO
+        for (side in sidesByClosest) {
+            if (world.getBlockState(side).isAir) {
+                openSide = side
+                break
+            }
+        }
+        if (openSide == BlockPos.ZERO) {
+            if (world.getBlockState(hiveLocation.above()).isAir) {
+                // If the above position is also air, we can use it
+                openSide = hiveLocation.above() // Fallback to above if no open sides found
+            } else if (world.getBlockState(hiveLocation.below()).isAir) {
+                // If the below position is also air, we can use it
+                openSide = hiveLocation.below() // Fallback to below if no open sides found
+            } else {
+                // If no open sides or above/below positions are found, we cannot proceed
+                return null
+            }
+        }
+        return openSide
+    }
+
+    fun tryEnterHive(entity: LivingEntity): Boolean {
+        if (entity !is PokemonEntity || !wantsToEnterHive(entity)) {
+            return false
+        }
+
+        val hiveLocation = entity.biggerBrain.getMemory(CobblemonMemories.HIVE_LOCATION) ?: return false
+        val targetVec = Vec3.atCenterOf(hiveLocation)
+
+        // if we are not close to it then end early
+        if (entity.distanceToSqr(targetVec) > 1.6 * 1.6) {
+            return false
+        }
+
+        val state = entity.level().getBlockState(hiveLocation)
+        val block = state.block
+        if (block is BeehiveBlock) {
+            val blockEntity = entity.level().getBlockEntity(hiveLocation)
+            if (blockEntity !is BeehiveBlockEntity) return false
+            if (blockEntity.isFull) {
+                // Erase Hive memory and give the bee a moment to locate a new hive
+                dropAndBlackListHive(entity)
+            } else {
+                blockEntity.addOccupant(entity)
+                return true
+            }
+        }
+        return false
+    }
+
+    fun wantsToEnterHive(entity: LivingEntity): Boolean {
+        val result = !entity.brain.checkMemory(CobblemonMemories.HIVE_COOLDOWN, MemoryStatus.VALUE_PRESENT)
+                && (entity.level().isRaining || entity.level().isNight || entity.brain.getMemory(CobblemonMemories.HAS_NECTAR)
+            .orElse(false))
+        if (result) {
+            val blockPos = entity.brain.getMemorySafely(CobblemonMemories.HIVE_LOCATION).orElse(null)
+            val blockEntity = entity.level().getBlockEntity(blockPos)
+            return blockEntity is BeehiveBlockEntity && !blockEntity.isFireNearby
+        }
+        return false
+    }
+
+    fun dropAndBlackListHive(entity: PokemonEntity) {
+        val hivePos = entity.biggerBrain.getMemory(CobblemonMemories.HIVE_LOCATION)
+        if (hivePos == null) return
+        val blackList : MutableList<BlockPos> = entity.biggerBrain.getMemory(CobblemonMemories.HIVE_BLACKLIST)?.toMutableList() ?: emptyList<BlockPos>().toMutableList()
+
+        blackList.add(hivePos)
+        if (blackList.count() > 3) {
+            blackList.removeFirst()
+        }
+        entity.brain.eraseMemory(CobblemonMemories.HIVE_LOCATION)
+        entity.brain.setMemory(CobblemonMemories.HIVE_BLACKLIST, blackList)
+
+    }
+
+    companion object {
+        const val PATH_TO_FLOWER_COOLDOWN_TICKS: Long = 200
+        const val HAS_NECTAR_ASPECT = "has_nectar"
+        const val MIN_DURATION: Int = 300
+        const val MAX_DURATION: Int = 400
+        const val REQUIRED_SUCCESSFUL_POLLINATION_TICKS = 250
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/objective/GoToSleep.kt

@@ -0,0 +1,155 @@
+/*
+ * 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.CobblemonActivities
+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.MovementStatus
+import com.cobblemon.mod.common.api.ai.biggerbrain.MovementTracker
+import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.EntityFixation
+import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.Distraction
+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.pokemon.status.Statuses
+import com.cobblemon.mod.common.api.storage.party.PartyStore
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.pokemon.status.PersistentStatusContainer
+import com.cobblemon.mod.common.util.asExpression
+import com.cobblemon.mod.common.util.getMemorySafely
+import com.cobblemon.mod.common.util.mainThreadRuntime
+import com.cobblemon.mod.common.util.resolveBoolean
+import com.mojang.datafixers.util.Either
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.ai.memory.MemoryModuleType
+
+/**
+ * Randomly looks at nearby entities out of curiosity. Very easily distracted once doing so.
+ *
+ * @author Hiroku
+ * @since December 29th, 2025
+ */
+class GoToSleep(
+    val onlyFromStatus: Expression = "false".asExpression(),
+) : Objective {
+    var fixation: EntityFixation? = null
+
+    override fun getDescription(entity: LivingEntity) = "Sleeping"
+    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 (brain.fixation != null) {
+            fixation = null
+            return ObjectiveStatus.BLOCKED
+        }
+
+        // Don't sleep if we're not tired
+        brain.getMemory(CobblemonMemories.POKEMON_DROWSY)
+            ?: return ObjectiveStatus.INACTIVE
+
+        val hasSleepStatus = entity.pokemon.status?.status === Statuses.SLEEP
+        if (entity.behaviour.resting.canSleep && entity.canSleepAt(entity.blockPosition().below()) || hasSleepStatus) {
+            if (!hasSleepStatus) {
+                if (mainThreadRuntime.resolveBoolean(onlyFromStatus)) {
+                    return ObjectiveStatus.BLOCKED
+                }
+                entity.pokemon.status = PersistentStatusContainer(Statuses.SLEEP)
+            }
+            entity.brain.eraseMemory(MemoryModuleType.WALK_TARGET)
+            entity.navigation.stop()
+            entity.brain.setActiveActivityToFirstValid(listOf(CobblemonActivities.POKEMON_SLEEPING_ACTIVITY))
+            entity.brain.setMemory(CobblemonMemories.POKEMON_SLEEPING, true)
+
+            // Become fixated
+            fixation = brain.fixate(
+                SleepFixation(
+                    this,
+                    null
+                )
+            )
+            return ObjectiveStatus.FIXATED
+        }
+        return ObjectiveStatus.BLOCKED
+    }
+
+
+
+    class SleepFixation(
+        val objective: GoToSleep,
+        override val movementTracker: MovementTracker?,
+    ) : EntityFixation, MovementTrackerFixation {
+
+        override fun getDescription(entity: LivingEntity): String {
+            return "Sleeping"
+        }
+        override fun tickMovementFixation(): MovementStatus? {
+            return MovementStatus.PENDING
+        }
+
+        override fun canDistract(distraction: Distraction, entity: LivingEntity): Boolean {
+            if (distraction.isIdleBoredom) {
+                return false
+            }
+            wakeUp(entity)
+            return true
+        }
+
+        override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
+            if (!entity.brain.getMemorySafely(CobblemonMemories.POKEMON_DROWSY).orElse(false)) {
+                wakeUp(entity)
+                return false
+            }
+            return true
+        }
+        fun wakeUp(entity: LivingEntity) {
+            if (entity !is PokemonEntity) return
+            val hasSleepStatus = entity.pokemon.status?.status == Statuses.SLEEP
+            if (hasSleepStatus && entity.pokemon.storeCoordinates.get()?.store is PartyStore) {
+                return // You can't wake up if you're in the party with the sleep status.
+            }
+            if (hasSleepStatus) {
+                entity.pokemon.status = null
+            }
+            entity.brain.eraseMemory(CobblemonMemories.POKEMON_SLEEPING)
+            entity.brain.useDefaultActivity()
+
+        }
+    }
+
+    class Config : ObjectiveConfig {
+
+        val onlyFromStatus: ExpressionOrEntityVariable = Either.left("false".asExpression())
+        override fun getVariables(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ) = listOf(
+            onlyFromStatus
+        ).asVariables()
+
+        override fun create(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ): Objective {
+            return GoToSleep(
+                onlyFromStatus = onlyFromStatus.asSimplifiedExpression(entity)
+            )
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/objective/HarvestSweetBerryBush.kt

@@ -0,0 +1,204 @@
+/*
+ * 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.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.idleBoredomDistraction
+import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.EntityFixation
+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
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.util.asExpression
+import com.cobblemon.mod.common.util.distanceTo
+import com.cobblemon.mod.common.util.getMemorySafely
+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.sounds.SoundEvents
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.PathfinderMob
+import net.minecraft.world.entity.ai.memory.WalkTarget
+import net.minecraft.world.item.ItemStack
+import net.minecraft.world.item.Items
+import net.minecraft.world.level.GameRules
+import net.minecraft.world.level.block.Block
+import net.minecraft.world.level.block.Blocks
+import net.minecraft.world.level.block.CaveVines
+import net.minecraft.world.level.block.SweetBerryBushBlock
+import net.minecraft.world.level.block.state.BlockState
+import net.minecraft.world.level.gameevent.GameEvent
+
+/**
+ * Paths to ripened sweet berry bushes AND glowberry vines with berries.
+ * Upon reaching the target harvests the berries and stashes one in its
+ * held item slot if possible.
+ * Requires NEARBY_SWEET_BERRY_BUSH memory
+ *
+ * @author JazzMcNade
+ * @since February 8th, 2026
+ */
+class HarvestSweetBerryBush(
+    val ticksBetweenAttempts: Int = 60,
+    val maxDistance: Expression = "14.0".asExpression(),
+    val speedMultiplier: Expression = "0.4".asExpression()
+) : Objective {
+    var harvestTask: EntityFixation? = null
+    var remainingCooldownTicks = ticksBetweenAttempts
+
+    override fun getDescription(entity: LivingEntity) = "Harvesting sweet/glow berry"
+    override fun perform(
+        entity: LivingEntity,
+        brain: BiggerBrain,
+        activeObjectiveTags: MutableSet<String>
+    ): ObjectiveStatus {
+        if (entity !is PokemonEntity) {
+            return ObjectiveStatus.INVALID
+        } else if (brain.isFixation(harvestTask)) {
+            remainingCooldownTicks = ticksBetweenAttempts
+            return ObjectiveStatus.FIXATED
+        }
+
+        val berryPosition = entity.biggerBrain.getMemory(CobblemonMemories.NEARBY_SWEET_BERRY_BUSH) ?: return ObjectiveStatus.INACTIVE
+
+        if (remainingCooldownTicks > 0) {
+            remainingCooldownTicks--
+            return ObjectiveStatus.ACTIVE
+        }
+
+        mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
+        val maxDistance = mainThreadRuntime.resolveFloat(maxDistance)
+        val speedMultiplier = mainThreadRuntime.resolveFloat(speedMultiplier)
+
+        val distance = entity.distanceTo(berryPosition)
+        if (distance < maxDistance) {
+            if (remainingCooldownTicks <= 0 && brain.distract(idleBoredomDistraction)) {
+                remainingCooldownTicks = ticksBetweenAttempts
+                val movementTracker = RegularMovementTracker.attempt(
+                    entity = entity,
+                    walkTarget = WalkTarget(
+                        berryPosition,
+                        speedMultiplier,
+                        1
+                    )
+                )
+                if (movementTracker != null) {
+                    harvestTask = brain.fixate(
+                        fixation = HarvestSweetBerryBushFixation(
+                            entity = entity,
+                            movementTracker = movementTracker
+                        )
+                    )
+                }
+            }
+        }
+        return ObjectiveStatus.ACTIVE
+    }
+
+
+    class HarvestSweetBerryBushFixation(
+        entity: PathfinderMob,
+        override val movementTracker: MovementTracker,
+    ): EntityFixation, LookingTrackerFixation, MovementTrackerFixation {
+
+
+        override val lookingTracker: LookingTracker = LookingTracker(entity = entity, lookTarget = movementTracker.walkTarget.target)
+        override fun getDescription(entity: LivingEntity) = "Harvesting sweet/glow berry"
+        override fun canDistract(distraction: Distraction, entity: LivingEntity): Boolean {
+            return distraction.isDamage || distraction.isForce || (movementTracker.lastStatus == MovementStatus.COMPLETED && entity.brain.getMemorySafely(
+                CobblemonMemories.NEARBY_SWEET_BERRY_BUSH).orElse(null) != null)
+        }
+
+        override fun onDistract(distraction: Distraction, entity: LivingEntity) {
+            movementTracker.stop()
+        }
+
+        override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
+            lookingTracker.tick()
+            movementTracker.tick()
+
+            if (movementTracker.lastStatus == MovementStatus.COMPLETED) {
+                val world = entity.level()
+
+                if (entity !is PokemonEntity) return false
+
+                if (!world.gameRules.getRule(GameRules.RULE_MOBGRIEFING).get()) {
+                    // Not allowed to alter the world
+                    return false
+                }
+                val blockPos = entity.brain.getMemory(CobblemonMemories.NEARBY_SWEET_BERRY_BUSH).orElse(null) ?: return false
+                val blockState = world.getBlockState(blockPos)
+                if (CaveVines.hasGlowBerries(blockState)) { // Glow Berries Case
+                    CaveVines.use(entity, blockState, world, blockPos)
+                } else if (blockState.`is`(Blocks.SWEET_BERRY_BUSH)) { // Sweet Berries Case
+                    blockState.setValue(SweetBerryBushBlock.AGE, 1)
+                    var j: Int = 1 + entity.level().random.nextInt(2) + if (blockState.getValue<Int>(SweetBerryBushBlock.AGE) == 3) 1 else 0
+                    val itemStack: ItemStack = entity.pokemon.heldItem
+                    if (itemStack.isEmpty) {
+                        entity.pokemon.swapHeldItem(ItemStack(Items.SWEET_BERRIES))
+                        --j
+                    }
+                    if (j > 0) {
+                        Block.popResource(entity.level(), blockPos, ItemStack(Items.SWEET_BERRIES, j))
+                    }
+                    entity.playSound(SoundEvents.SWEET_BERRY_BUSH_PICK_BERRIES, 1.0f, 1.0f)
+                    entity.level().setBlock(blockPos, blockState.setValue(SweetBerryBushBlock.AGE, 1) as BlockState, 2)
+                    entity.level().gameEvent(GameEvent.BLOCK_CHANGE, blockPos, GameEvent.Context.of(entity))
+                }
+                entity.brain.eraseMemory(CobblemonMemories.NEARBY_SWEET_BERRY_BUSH)
+                return false
+            } else if (movementTracker.lastStatus == MovementStatus.FAILED) {
+                // Cannot reach, give up for a awhile
+                entity.brain.setMemoryWithExpiry(CobblemonMemories.DISABLE_WALK_TO_BERRY_BUSH, true, 200)
+                entity.brain.eraseMemory(CobblemonMemories.NEARBY_SWEET_BERRY_BUSH)
+                return false
+            }
+
+            return true
+        }
+    }
+
+    class Config : ObjectiveConfig {
+        val ticksBetweenAttempts: ExpressionOrEntityVariable = Either.left("60".asExpression())
+        val maxDistance: ExpressionOrEntityVariable = Either.left("10.0".asExpression())
+        val speedMultiplier: ExpressionOrEntityVariable = Either.left("0.4".asExpression())
+
+        override fun getVariables(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ) = listOf(
+            ticksBetweenAttempts,
+            maxDistance,
+            speedMultiplier
+        ).asVariables()
+
+        override fun create(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): Objective {
+            val ticksBetweenAttempts = ticksBetweenAttempts.resolveInt(behaviourConfigurationContext.runtime)
+            return HarvestSweetBerryBush(
+                ticksBetweenAttempts = ticksBetweenAttempts,
+                maxDistance = maxDistance.asSimplifiedExpression(entity),
+                speedMultiplier = speedMultiplier.asSimplifiedExpression(entity)
+            )
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/objective/Herd.kt

@@ -0,0 +1,409 @@
+/*
+ * 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.CobblemonWanderControl
+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.MovementStatus
+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.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.pokemon.status.Statuses
+import com.cobblemon.mod.common.api.storage.party.PartyStore
+import com.cobblemon.mod.common.entity.PoseType
+import com.cobblemon.mod.common.entity.ai.CobblemonWalkTarget
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.entity.pokemon.ai.PokemonMoveControl
+import com.cobblemon.mod.common.pokemon.ai.ToleratedHerdLeader
+import com.cobblemon.mod.common.pokemon.status.PersistentStatusContainer
+import com.cobblemon.mod.common.util.asExpression
+import com.cobblemon.mod.common.util.toBlockPos
+import com.mojang.datafixers.util.Either
+import java.util.UUID
+import kotlin.math.cos
+import kotlin.math.sin
+import net.minecraft.server.level.ServerLevel
+import net.minecraft.util.Mth
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.ai.memory.MemoryModuleType
+import net.minecraft.world.entity.ai.memory.NearestVisibleLivingEntities
+import net.minecraft.world.entity.ai.memory.WalkTarget
+import net.minecraft.world.phys.Vec3
+
+class Herd(
+    var checkTicks: Int = 60,
+    var tooFar: Float = 8F,
+    var closeEnough: Float = 4F,
+    /** Chance per tick of following the herd leader. */
+    val chance: Float = 1 / 60F,
+    val pathingCooldownTicks: Int = 80
+) : Objective {
+    var wanderCenter: CobblemonWanderControl.WanderCenter? = null
+
+    var fixation: EntityFixation? = null
+    var leader: PokemonEntity? = null
+    var ticksUntilMaintainLeader: Int = checkTicks
+    var remainingPathingCooldownTicks = 0
+
+    override fun getDescription(entity: LivingEntity) = "Herd"
+    override fun perform(
+        entity: LivingEntity,
+        brain: BiggerBrain,
+        activeObjectiveTags: MutableSet<String>
+    ): ObjectiveStatus {
+        entity as PokemonEntity
+        val moveControl = entity.moveControl as? PokemonMoveControl ?: return ObjectiveStatus.INVALID
+
+        if (remainingPathingCooldownTicks > 0) {
+            remainingPathingCooldownTicks--
+        }
+
+        val level = entity.level() as ServerLevel
+        if (leader == null && brain.hasMemoryValue(CobblemonMemories.HERD_LEADER)) {
+            leader = level.getEntity(brain.getMemory(CobblemonMemories.HERD_LEADER).let(UUID::fromString)) as? PokemonEntity
+            if (leader == null) {
+                brain.eraseMemory(CobblemonMemories.HERD_LEADER)
+            }
+        }
+
+        if (ticksUntilMaintainLeader > 0) {
+            ticksUntilMaintainLeader--
+        } else if (ticksUntilMaintainLeader == 0) {
+            if (brain.fixation == null || brain.isFixation(fixation)) {
+                // Don't maintain the herd leader if we're busy with something else
+                maintainHerdLeader(entity, brain)
+            }
+            ticksUntilMaintainLeader = checkTicks
+        }
+
+        if (leader?.level() != level) {
+            this.leader = null
+        }
+
+        val leader = leader
+        if (leader == null && brain.isFixation(fixation)) {
+            brain.distract(Distraction.FORCE)
+        }
+
+        val wanderControl = brain.getMemory(CobblemonMemories.WANDER_CONTROL)
+            ?: CobblemonWanderControl()
+
+        if (this.wanderCenter != null && leader == null) {
+            if (wanderControl.center == this.wanderCenter) {
+                wanderControl.center = null
+                wanderControl.wanderChanceMultiplier = null
+                brain.setMemory(CobblemonMemories.WANDER_CONTROL, wanderControl)
+            }
+            this.wanderCenter = null
+        } else if (leader != null) {
+            wanderControl.center = CobblemonWanderControl.WanderCenter(
+                x = leader.x,
+                y = leader.y,
+                z = leader.z,
+                minRange = 1F,
+                maxRange = tooFar
+            )
+            this.wanderCenter = wanderControl.center
+            wanderControl.wanderChanceMultiplier = 0.25F
+            brain.setMemory(CobblemonMemories.WANDER_CONTROL, wanderControl)
+        }
+
+        leader ?: return ObjectiveStatus.INACTIVE
+
+        if (brain.isFixation(fixation) && fixation is MovementTrackerFixation) {
+            return ObjectiveStatus.FIXATED
+        }
+
+        val leaderFixation = leader.biggerBrain.fixation
+
+        val canMove = brain.canDistract(comfortDistraction) || brain.isFixation(fixation)
+        val isMovingCloser = brain.isFixation(fixation) && fixation is LookAndMoveFixation
+
+        val leaderMoveControl = leader.moveControl as? PokemonMoveControl ?: return ObjectiveStatus.INVALID
+        if (leader.distanceTo(entity) > tooFar) {
+            return when {
+                isMovingCloser -> ObjectiveStatus.FIXATED // Already have the fixation to move closer
+                remainingPathingCooldownTicks > 0 -> manageFixation(brain) // Still cooling down from last pathing attempt
+                !canMove -> ObjectiveStatus.BLOCKED // I'm not able to distract the brain and move closer
+                else -> tryMovingCloser(entity, brain, level, leader) // let's give it a fair shake then
+            }
+        } else if (leader.isFlying() && !entity.isFlying() && !isMovingCloser) {
+            if (!entity.canFly()) {
+                entity.brain.eraseMemory(CobblemonMemories.HERD_LEADER) // We can't go where this guy's going
+                this.leader = null
+                return ObjectiveStatus.INACTIVE
+            } else if (!canMove) {
+                return ObjectiveStatus.BLOCKED
+            }
+
+            return tryMovingCloser(entity, brain, level, leader)
+        } else if (leaderMoveControl.banking && !isMovingCloser) {
+            if (!canMove) {
+                return ObjectiveStatus.BLOCKED
+            }
+
+            if (leader.isInLiquid && !entity.isInLiquid) {
+                if (remainingPathingCooldownTicks > 0) {
+                    return manageFixation(brain) // Still cooling down from last pathing attempt
+                }
+
+                // We should get into water asap so we can mimic the banking
+                return tryMovingCloser(entity, brain, level, leader, completionRange = 1)
+            } else {
+                removeSleep(entity, brain)
+                entity.yRot = leader.yRot
+                moveControl.startBanking(
+                    forwardBlocksPerTick = leaderMoveControl.bankForwardBlocksPerTick,
+                    upwardsBlocksPerTick = leaderMoveControl.bankUpwardsBlocksPerTick,
+                    durationTicks = 2,
+                    rightDegreesPerTick = 0F // Relying on the above yRot = leader.yRot because we dunno when we first started mimicking the banking
+                )
+                return ObjectiveStatus.FIXATED
+            }
+        } else if (leaderFixation is MovementTrackerFixation && leaderFixation.movementTracker?.lastStatus == MovementStatus.PENDING) {
+
+            if (entity.random.nextFloat() > chance) {
+                return manageFixation(brain) // Not this tick
+            } else if (!canMove) {
+                return ObjectiveStatus.BLOCKED
+            } else if (isMovingCloser) {
+                return ObjectiveStatus.FIXATED // Already moving
+            }
+
+            val leaderWalkTarget = leaderFixation.movementTracker?.walkTarget ?: return manageFixation(brain)
+
+
+            // We're already closer to the walk target than the leader is, so no need to move. If anything we should get out of the way
+            if (entity.distanceToSqr(leaderWalkTarget.target.currentPosition()) + closeEnough < leader.distanceToSqr(leaderWalkTarget.target.currentPosition())) {
+                return manageFixation(brain)
+            }
+
+            // Go to the leader's walk target, roughly.
+            val walkTarget = CobblemonWalkTarget(
+                pos = leaderWalkTarget.target.currentPosition().add(getRandomOffset(entity, level)).toBlockPos(),
+                speedModifier = leaderWalkTarget.speedModifier,
+                nodeTypeFilter = (leaderWalkTarget as? CobblemonWalkTarget)?.nodeTypeFilter ?: { true },
+                completionRange = closeEnough.toInt()
+            )
+
+            return tryMovingCloser(entity, brain, level, leader, walkTarget = walkTarget)
+        } else if (leader.getCurrentPoseType() == PoseType.SLEEP) {
+            // Leader is sleeping, if I'm drowsy and can sleep here then I will sleep too.
+            if (entity.canSleepAt(entity.blockPosition().offset(0, -1, 0)) && brain.getMemory(CobblemonMemories.POKEMON_DROWSY) == true) {
+                if (entity.random.nextFloat() < 1 / 40F) {
+                    applySleep(entity, brain)
+                }
+            }
+        } else if (brain.getMemory(CobblemonMemories.POKEMON_SLEEPING) == true) {
+            // Leader is awake, so we should be awake too. Maybe.
+            if (entity.random.nextFloat() < 1 / 15F) {
+                removeSleep(entity, brain)
+            }
+        }
+
+        return manageFixation(brain)
+    }
+
+    fun manageFixation(brain: BiggerBrain): ObjectiveStatus {
+        if (brain.isFixation(fixation)) {
+            return ObjectiveStatus.FIXATED
+        } else if (leader != null) {
+            return ObjectiveStatus.ACTIVE
+        } else {
+            return ObjectiveStatus.INACTIVE
+        }
+    }
+
+    fun tryMovingCloser(
+        entity: PokemonEntity,
+        brain: BiggerBrain,
+        level: ServerLevel,
+        leader: PokemonEntity,
+        walkTarget: WalkTarget? = null,
+        completionRange: Int = closeEnough.toInt()
+    ): ObjectiveStatus {
+        val walkTarget = walkTarget ?: CobblemonWalkTarget(
+            pos = leader.position().add(getRandomOffset(entity, level)).toBlockPos(),
+            speedModifier = 0.4F,
+            completionRange = completionRange
+        )
+
+        val movementTracker = RegularMovementTracker.attempt(entity, walkTarget)
+
+        remainingPathingCooldownTicks = pathingCooldownTicks
+        if (movementTracker == null) {
+            // Couldn't find a path, wait a bit before trying again
+            return manageFixation(brain)
+        } else if (!(brain.isFixation(fixation) && brain.distract(Distraction.FORCE)) && !brain.distract(comfortDistraction)) {
+            return manageFixation(brain) // Not likely based on checks run on callers to this function.
+        }
+
+        brain.sendDebugMessage("Moving closer, to ${movementTracker.walkTarget.target.currentBlockPosition()}")
+
+        removeSleep(entity, brain)
+        fixation = brain.fixate(
+            LookAndMoveFixation(
+                distractionTypes = setOf(DistractionType.DAMAGE, DistractionType.COMFORT, DistractionType.FORCE),
+                lookingTracker = LookingTracker.forTargetEntity(entity, leader, trackEyeHeight = true),
+                movementTracker = movementTracker,
+                description = "Moving towards herd leader"
+            )
+        )
+
+        return ObjectiveStatus.FIXATED
+    }
+
+    fun maintainHerdLeader(entity: PokemonEntity, brain: BiggerBrain) {
+        val world = entity.level() as ServerLevel
+        val leader = brain.getMemory(CobblemonMemories.HERD_LEADER)?.let(UUID::fromString).let(world::getEntity) as? PokemonEntity
+        val currentLeaderDefinition = leader?.let { leader ->
+            entity.behaviour.herd.toleratedLeaders.find { it.pokemon.matches(leader) }
+        }
+        if (leader == null || currentLeaderDefinition == null) {
+            entity.brain.eraseMemory(CobblemonMemories.HERD_LEADER)
+            this.leader = null
+        }
+
+        val bestLeader = getBestHerdLeader(
+            currentLeader = if (leader == null || currentLeaderDefinition == null) null else (leader to currentLeaderDefinition),
+            nearbyEntities = brain.getMemory(MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES) ?: return,
+            entity = entity
+        )
+
+        if (bestLeader != null && bestLeader != leader) {
+            bestLeader.brain.eraseMemory(CobblemonMemories.HERD_LEADER)
+            entity.brain.setMemory(CobblemonMemories.HERD_LEADER, bestLeader.uuid.toString())
+            bestLeader.adjustHerdSize(1)
+            leader?.adjustHerdSize(-1)
+            this.leader = bestLeader
+        }
+    }
+
+    fun getRandomOffset(entity: PokemonEntity, level: ServerLevel): Vec3 {
+        val leader = leader ?: return Vec3.ZERO
+
+        val minRange = closeEnough.toDouble()
+        val maxRange = (tooFar - closeEnough / 2).toDouble()
+        val randomDistance = Mth.nextDouble(level.random, minRange, maxRange)
+        val randomAngle = Mth.nextDouble(level.random, 0.0, 2 * Math.PI)
+
+        var offset = Vec3(cos(randomAngle) * randomDistance, 0.0, sin(randomAngle) * randomDistance)
+
+        if ((entity.isInLiquid && leader.isInLiquid) || (entity.isFlying() && leader.isFlying())) {
+            val verticalRange = randomDistance * 0.5
+            val randomY = Mth.nextDouble(level.random, -verticalRange, verticalRange)
+            offset = offset.add(0.0, randomY, 0.0)
+        }
+
+        return offset
+    }
+
+
+    fun applySleep(entity: PokemonEntity, brain: BiggerBrain) {
+        brain.setMemory(CobblemonMemories.POKEMON_SLEEPING, true)
+        entity.pokemon.status = PersistentStatusContainer(Statuses.SLEEP)
+    }
+
+    fun removeSleep(entity: PokemonEntity, brain: BiggerBrain) {
+        if (brain.hasMemoryValue(CobblemonMemories.POKEMON_SLEEPING)) {
+            brain.eraseMemory(CobblemonMemories.POKEMON_SLEEPING)
+            val status = entity.pokemon.status
+            if (status != null && status.status == Statuses.SLEEP) {
+                entity.pokemon.status = null
+            }
+        }
+    }
+
+    /**
+     * Logic used to choose the best herd leader from nearby visible entities.
+     *
+     * - Higher tier leaders are always preferred.
+     * - Same-tier leaders that are closer are preferred except for when they're the same tier as the current leader.
+     * - We don't want to exceed the target's herd size limit.
+     * - We don't want to choose a leader that is themselves following a leader.
+     * - Some leader definitions allow lower-level Pokémon to lead them.
+     * - Leaders just have to not be in a party - pastured and wild Pokémon can mingle.
+     */
+    fun getBestHerdLeader(
+        currentLeader: Pair<PokemonEntity, ToleratedHerdLeader>?,
+        nearbyEntities: NearestVisibleLivingEntities,
+        entity: PokemonEntity,
+    ): PokemonEntity? {
+        var bestLeader: PokemonEntity? = null
+        val (currentLeaderEntity, currentLeaderDefinition) = currentLeader ?: Pair(null, null)
+        var bestTier = currentLeaderDefinition?.tier?.let { it + 1 } ?: 0 // Only upgrade to a higher tier leader
+        var bestDistance = Float.MAX_VALUE
+        nearbyEntities.findAll {
+            it is PokemonEntity &&
+                    it != currentLeader &&
+                    it.pokemon.storeCoordinates.get()?.store !is PartyStore &&
+                    it.getHerdSize() < it.behaviour.herd.maxSize &&
+                    !it.brain.hasMemoryValue(CobblemonMemories.POKEMON_DROWSY)
+        }.forEach { possibleLeader ->
+            possibleLeader as PokemonEntity
+            val bestMatchingHerdLeader = entity.behaviour.herd.bestMatchLeader(entity, possibleLeader) ?: return@forEach
+            val possibleLeaderIsAlreadyALeader = possibleLeader.brain.hasMemoryValue(CobblemonMemories.HERD_SIZE)
+            val currentLeaderHerdTier = currentLeaderEntity?.getHerdTier() ?: entity.getHerdTier()
+            if (currentLeaderHerdTier >= bestMatchingHerdLeader.tier) {
+                return@forEach // This leader is following a leader of a higher tier, we can't replace them
+            }
+            val distance = entity.distanceTo(possibleLeader)
+            if (bestMatchingHerdLeader.tier < bestTier) {
+                return@forEach // No need to check further if this leader is worse than the best found so far
+            } else if ((distance > bestDistance && !possibleLeaderIsAlreadyALeader) && bestMatchingHerdLeader.tier == bestTier) {
+                return@forEach // No need to check further if this leader is farther than the best found so far, unless they are already a leader - I'd prefer to join a pack
+            } else {
+                bestLeader = possibleLeader
+                bestDistance = distance
+                bestTier = bestMatchingHerdLeader.tier
+            }
+        }
+        return bestLeader ?: currentLeaderEntity
+    }
+
+    class Config : ObjectiveConfig {
+        // How frequently to check for whether it should herd. Probably isn't that expensive but might use this for chance.
+        val checkTicks: ExpressionOrEntityVariable = Either.left("60".asExpression())
+        val tooFar: ExpressionOrEntityVariable = Either.left("8".asExpression())
+        val closeEnough: ExpressionOrEntityVariable = Either.left("4".asExpression())
+        val chance: ExpressionOrEntityVariable = Either.left("1 / 60".asExpression())
+
+        override fun getVariables(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ) = listOf(checkTicks, tooFar, closeEnough, chance).asVariables()
+
+        override fun create(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ): Objective {
+            behaviourConfigurationContext.addMemories(MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES)
+            behaviourConfigurationContext.addMemories(CobblemonMemories.HERD_LEADER)
+            behaviourConfigurationContext.addMemories(CobblemonMemories.HERD_SIZE)
+            return Herd(
+                checkTicks = checkTicks.resolveInt(behaviourConfigurationContext.runtime),
+                tooFar = tooFar.resolveFloat(behaviourConfigurationContext.runtime),
+                closeEnough = closeEnough.resolveFloat(behaviourConfigurationContext.runtime),
+                chance = chance.resolveFloat(behaviourConfigurationContext.runtime)
+            )
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/objective/JumpOutOfWater.kt

@@ -0,0 +1,166 @@
+/*
+ * 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.resolveInt
+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.sounds.SoundEvents
+import net.minecraft.tags.FluidTags
+import net.minecraft.util.Mth
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.level.material.FluidState
+import kotlin.math.atan2
+
+/**
+ * Swimming Pokemon perform a cool little jump out of the water if they're near the surface
+ *
+ */
+class JumpOutOfWater(
+    val ticksBetweenAttempts: Int = 60,
+) : Objective {
+    var inWater = false
+    var remainingCooldownTicks = ticksBetweenAttempts
+    var fixation: EntityFixation? = null
+    override fun getDescription(entity: LivingEntity) = "Jump out of water"
+    override fun perform(
+        entity: LivingEntity,
+        brain: BiggerBrain,
+        activeObjectiveTags: MutableSet<String>
+    ): ObjectiveStatus {
+        if (entity !is PokemonEntity) {
+            return ObjectiveStatus.INVALID
+        } else if (brain.isFixation(fixation)) {
+            remainingCooldownTicks = ticksBetweenAttempts
+            return ObjectiveStatus.FIXATED
+        }
+
+        if (remainingCooldownTicks > 0) {
+            remainingCooldownTicks--
+            return ObjectiveStatus.ACTIVE
+        }
+
+        if (entity.random.nextInt(CHANCE) != 0) {
+            return ObjectiveStatus.INACTIVE
+        } else {
+            if (!brain.distract(idleBoredomDistraction)) return ObjectiveStatus.BLOCKED
+            val direction = entity.motionDirection
+            val x = direction.stepX
+            val z = direction.stepZ
+            val blockPos = entity.blockPosition()
+            val offsets = OFFSET_MULTIPLIERS
+            for (offset in offsets) {
+                if (!this.isWater(entity, blockPos, x, z, offset) || !this.isAirAbove(entity, blockPos, x, z, offset)) {
+                    return ObjectiveStatus.ACTIVE
+                }
+            }
+
+            val newVelocity = entity.deltaMovement.add(direction.stepX.toDouble() * 0.6, 0.7, direction.stepZ.toDouble() * 0.6)
+            entity.deltaMovement = newVelocity
+            entity.getNavigation().stop()
+            fixation = brain.fixate(
+                fixation = JumpOutOfWaterFixation(
+                    this,
+                    movementTracker = null
+                )
+            )
+        }
+        return ObjectiveStatus.ACTIVE
+    }
+
+
+    class JumpOutOfWaterFixation(
+        val objective: JumpOutOfWater,
+        override val movementTracker: MovementTracker?,
+    ) : EntityFixation, MovementTrackerFixation {
+
+        override fun getDescription(entity: LivingEntity) = "Jumping out of water"
+        override fun canDistract(distraction: Distraction, entity: LivingEntity): Boolean {
+            return distraction.isDamage || distraction.isForce
+        }
+
+        override fun onDistract(distraction: Distraction, entity: LivingEntity) {}
+
+        override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
+            val bl: Boolean = objective.inWater
+            if (!bl) {
+                val fluidState: FluidState = entity.level().getFluidState(entity.blockPosition())
+                objective.inWater = fluidState.`is`(FluidTags.WATER)
+            }
+
+            if (objective.inWater && !bl) {
+                // Transition tick from in water to out of water
+                entity.playSound(SoundEvents.DOLPHIN_JUMP, 1.0f, 1.0f)
+            }
+
+            val vec3d = entity.deltaMovement
+            if (vec3d.y * vec3d.y < 0.029999999329447746 && entity.xRot != 0.0f) {
+                entity.xRot = Mth.rotLerp(0.2f, entity.xRot, 0.0f)
+            } else if (vec3d.length() > 9.999999747378752E-6) {
+                val d = vec3d.horizontalDistance()
+                val e = atan2(-vec3d.y, d) * 57.2957763671875
+                entity.xRot = e.toFloat()
+            }
+
+            val d: Double = vec3d.y
+            return (!(d * d < 0.029999999329447746) || entity.xRot == 0.0f || !(Math.abs(entity.xRot) < 10.0f) || !entity.isInWater) && !entity.onGround()
+
+        }
+    }
+
+    class Config : ObjectiveConfig {
+        val ticksBetweenAttempts: ExpressionOrEntityVariable = Either.left("60".asExpression())
+
+        override fun getVariables(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ) = listOf(
+            ticksBetweenAttempts,
+        ).asVariables()
+
+        override fun create(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ): Objective {
+            val ticksBetweenAttempts = ticksBetweenAttempts.resolveInt(behaviourConfigurationContext.runtime)
+            return JumpOutOfWater(
+                ticksBetweenAttempts = ticksBetweenAttempts,
+            )
+        }
+    }
+
+    private fun isWater(entity: PokemonEntity, pos: BlockPos, offsetX: Int, offsetZ: Int, multiplier: Int): Boolean {
+        val blockPos = pos.offset(offsetX * multiplier, 0, offsetZ * multiplier)
+        return entity.level().getFluidState(blockPos).`is`(FluidTags.WATER) && !entity.level().getBlockState(blockPos)
+            .blocksMotion()
+    }
+
+    private fun isAirAbove(entity: PokemonEntity, pos: BlockPos, offsetX: Int, offsetZ: Int, multiplier: Int): Boolean {
+        return entity.level().getBlockState(pos.offset(offsetX * multiplier, 1, offsetZ * multiplier))
+            .isAir && entity.level().getBlockState(pos.offset(offsetX * multiplier, 2, offsetZ * multiplier))
+            .isAir
+    }
+
+    companion object {
+        private const val CHANCE = 10
+        private val OFFSET_MULTIPLIERS = intArrayOf(0, 1, 4, 5, 6, 7)
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/objective/LookAtNearbyEntities.kt

@@ -0,0 +1,136 @@
+/*
+ * 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.fixation.EntityFixation
+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.fixation.LookingTrackerFixation
+import com.cobblemon.mod.common.api.ai.config.objective.ObjectiveConfig
+import com.cobblemon.mod.common.api.ai.resolveDouble
+import com.cobblemon.mod.common.api.ai.resolveInt
+import com.cobblemon.mod.common.util.asExpression
+import com.mojang.datafixers.util.Either
+import kotlin.math.pow
+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
+
+/**
+ * Randomly looks at nearby entities out of curiosity. Very easily distracted once doing so.
+ *
+ * @author Hiroku
+ * @since December 29th, 2025
+ */
+class LookAtNearbyEntities(
+    val maxDistance: Double = 10.0,
+    val minDuration: Int = 20,
+    val maxDuration: Int = 80
+) : Objective {
+    var fixation: EntityFixation? = null
+
+    override fun getDescription(entity: LivingEntity) = "Look at nearby entities"
+    override fun perform(
+        entity: LivingEntity,
+        brain: BiggerBrain,
+        activeObjectiveTags: MutableSet<String>
+    ): ObjectiveStatus {
+        if (brain.isFixation(fixation)) {
+            return ObjectiveStatus.FIXATED
+        } else if (brain.fixation != null) {
+            fixation = null
+            return ObjectiveStatus.BLOCKED
+        }
+
+        val nearestVisibleLivingEntities = brain.getMemory(MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES)
+            ?: return ObjectiveStatus.INVALID
+
+        val closest = nearestVisibleLivingEntities.findClosest(
+            { otherEntity -> otherEntity.distanceToSqr(entity) <= maxDistance.pow(2) && !entity.hasPassenger(otherEntity) }
+        ).orElse(null)
+
+        if (closest == null) {
+            return ObjectiveStatus.INACTIVE
+        } else {
+            // Become fixated
+            fixation = brain.fixate(
+                IdleLookFixation(
+                    this,
+                    closest,
+                    (minDuration..maxDuration).random()
+                )
+            )
+            return ObjectiveStatus.FIXATED
+        }
+    }
+
+    class IdleLookFixation(
+        val objective: LookAtNearbyEntities,
+        val targetEntity: LivingEntity,
+        var remainingTicks: Int
+    ) : EntityFixation, LookingTrackerFixation {
+        override var lookingTracker: LookingTracker? = null
+
+        override fun getDescription(entity: LivingEntity): String {
+            return "Looking at a nearby entity ($remainingTicks ticks left)"
+        }
+
+        override fun canDistract(distraction: Distraction, entity: LivingEntity): Boolean {
+            // Bro literally anything will distract me
+            return true
+        }
+
+        override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
+            if (targetEntity.isRemoved || entity !is PathfinderMob) {
+                return false
+            }
+            if (lookingTracker == null) {
+                lookingTracker = LookingTracker(entity, EntityTracker(targetEntity, true))
+            }
+            val lookingTracker = lookingTracker!!
+            remainingTicks--
+            lookingTracker.tick()
+            return remainingTicks > 0
+        }
+    }
+
+    class Config : ObjectiveConfig {
+        val maxDistance: ExpressionOrEntityVariable = Either.left("10.0".asExpression())
+        val minDuration: ExpressionOrEntityVariable = Either.left("20".asExpression())
+        val maxDuration: ExpressionOrEntityVariable = Either.left("80".asExpression())
+
+        override fun getVariables(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ) = listOf(
+            maxDistance,
+            minDuration,
+            maxDuration
+        ).asVariables()
+
+        override fun create(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ): Objective {
+            val maxDistance = maxDistance.resolveDouble(behaviourConfigurationContext.runtime)
+            val minDuration = minDuration.resolveInt(behaviourConfigurationContext.runtime)
+            val maxDuration = maxDuration.resolveInt(behaviourConfigurationContext.runtime)
+            return LookAtNearbyEntities(
+                maxDistance = maxDistance,
+                minDuration = minDuration,
+                maxDuration = maxDuration
+            )
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/objective/MaintainFluidY.kt

@@ -0,0 +1,65 @@
+/*
+ * 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.biggerbrain.BiggerBrain
+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.npc.configuration.MoLangConfigVariable
+import com.cobblemon.mod.common.entity.OmniPathingEntity
+import net.minecraft.world.entity.LivingEntity
+
+class MaintainFluidY : Objective {
+    override fun getDescription(entity: LivingEntity) = "Maintain Y in fluids"
+    override fun perform(
+        entity: LivingEntity,
+        brain: BiggerBrain,
+        activeObjectiveTags: MutableSet<String>
+    ): ObjectiveStatus {
+        if (entity !is OmniPathingEntity) {
+            return ObjectiveStatus.INVALID
+        }
+
+        val fixation = brain.fixation
+        if (fixation is MovementTrackerFixation) {
+            return ObjectiveStatus.BLOCKED
+        }
+
+        if (entity.isFlying()) {
+            return ObjectiveStatus.INACTIVE
+        }
+
+        if (entity.canSwimInWater() && entity.isUnderWater) {
+            entity.isNoGravity = true
+        } else if (entity.canSwimInLava() && entity.isInLava) {
+            entity.isNoGravity = true
+        } else {
+            entity.isNoGravity = false
+        }
+
+        return if (entity.isNoGravity) ObjectiveStatus.ACTIVE else ObjectiveStatus.INACTIVE
+    }
+
+    class Config : ObjectiveConfig {
+        override fun getVariables(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ): List<MoLangConfigVariable> {
+            return emptyList()
+        }
+
+        override fun create(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ): Objective {
+            return MaintainFluidY()
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/objective/MoveIntoWater.kt

@@ -0,0 +1,251 @@
+/*
+ * 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.*
+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.comfortDistraction
+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.entity.ai.CobblemonWalkTarget
+import com.cobblemon.mod.common.util.*
+import com.mojang.datafixers.util.Either
+import net.minecraft.core.BlockPos
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.PathfinderMob
+import net.minecraft.world.entity.TamableAnimal
+import net.minecraft.world.entity.ai.behavior.BehaviorUtils
+import net.minecraft.world.entity.ai.util.RandomPos
+import net.minecraft.world.level.pathfinder.PathType
+import net.minecraft.world.phys.Vec3
+
+
+/**
+ * Tries to path into water if the entity usually avoids land.
+ * Will pathfind through land even if the entity usually filters out land nodes.
+ * If water cannot be found in the entity's wander range it'll wander randomly in a spiral-ish pattern
+ *
+ * @author JazzMcNade
+ * @since January 25th, 2026
+ */
+class MoveIntoWater(
+    val ticksBetweenAttempts: Int = 60,
+    val maxDistance: Expression = "14.0".asExpression(),
+    val speedMultiplier: Expression = "0.4".asExpression()
+) : Objective {
+    var movementTask: EntityFixation? = null
+    var remainingCooldownTicks = ticksBetweenAttempts
+    var wanderDirection: Vec3? = null
+    var isWanderTurnDirectionClockwise = true
+    var wanderTurnChance = BASE_TURN_CHANCE
+    var failCount = 0
+    override fun getDescription(entity: LivingEntity) = "Move into water if currently out of water"
+    override fun perform(
+        entity: LivingEntity,
+        brain: BiggerBrain,
+        activeObjectiveTags: MutableSet<String>
+    ): ObjectiveStatus {
+        if (entity !is TamableAnimal) {
+            return ObjectiveStatus.INVALID
+        }
+
+        if (entity.isInWater) {
+            // All good, nothing to do here
+            return ObjectiveStatus.INACTIVE
+        }
+
+        if (brain.isFixation(movementTask)) {
+            remainingCooldownTicks = ticksBetweenAttempts
+            return ObjectiveStatus.FIXATED
+        }
+
+        if (remainingCooldownTicks > 0) {
+            remainingCooldownTicks--
+            return ObjectiveStatus.INACTIVE
+        } else {
+            remainingCooldownTicks = ticksBetweenAttempts
+        }
+
+        if (brain.distract(comfortDistraction)) {
+
+            val maxDistance = mainThreadRuntime.resolveInt(maxDistance)
+            val speedMultiplier = mainThreadRuntime.resolveFloat(speedMultiplier)
+
+            val runtime = mainThreadRuntime
+            val wanderControl = entity.brain.getMemorySafely(CobblemonMemories.WANDER_CONTROL).orElse(null)
+            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 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)) {
+                types.add(WanderType.WATER)
+            }
+
+            if (types.isEmpty()) {
+                return ObjectiveStatus.INACTIVE
+            }
+            var walkTarget: CobblemonWalkTarget? = null
+
+            val targetVec3 = BehaviorUtils.getRandomSwimmablePos(entity, 10, 7)
+
+            if (targetVec3 != null) {
+                walkTarget = CobblemonWalkTarget(
+                    BlockPos.containing(targetVec3.x, targetVec3.y, targetVec3.z),
+                    speedMultiplier,
+                    0,
+                    nodeTypeFilter = { nodeType ->
+                        true
+                    }
+                )
+            }
+
+            if (walkTarget == null) {
+                if (failCount >= 5) {
+                    // No out of water target could be found.
+                    // Need to choose a direction and move as far as possible, hoping we randomly find water
+                    // Totally possible that a shoreline is *just* outside the entity's wander range and
+                    // we choose a direction that's opposite of the shoreline
+                    // To counteract this, the pokemon moves in a (very roughly) spiral pattern outward from the origin
+                    var wanderPosition: BlockPos? = null
+                    if (wanderDirection == null) {
+                        val wanderOffset = RandomPos.generateRandomDirection(entity.level().random, maxDistance / 2, 0)
+                        wanderDirection = wanderOffset.toVec3d().normalize()
+                        isWanderTurnDirectionClockwise = entity.random.nextInt(2) > 0
+                        wanderTurnChance = BASE_TURN_CHANCE
+                        wanderPosition = entity.blockPosition().offset(wanderOffset.x, wanderOffset.y, wanderOffset.z)
+                    } else {
+
+                        if (entity.level().random.nextFloat() < wanderTurnChance) {
+                            // Turn 30 degrees
+                            wanderDirection =
+                                wanderDirection!!.yRot(Math.PI.toFloat() / 3.0f * if (isWanderTurnDirectionClockwise) -1f else 1f)
+                            wanderTurnChance *= 0.7
+                        }
+                        val wanderVec = entity.position().add(wanderDirection!!.scale(maxDistance.toDouble()))
+                        wanderPosition = BlockPos.containing(wanderVec)
+
+                    }
+                    val wanderTarget = generateWaterSafePosToward(entity, maxDistance, wanderPosition)
+
+                    if (wanderTarget != null) {
+                        walkTarget = CobblemonWalkTarget(
+                            wanderPosition,
+                            speedMultiplier,
+                            0,
+                            nodeTypeFilter = { nodeType ->
+                                true
+                            }
+                        )
+                    } else {
+                        return ObjectiveStatus.ACTIVE
+                    }
+                } else {
+                    failCount++
+                }
+
+            }
+            if (walkTarget != null) {
+                failCount = 0
+                val movementTracker = RegularMovementTracker.attempt(entity, walkTarget)
+                    ?: return ObjectiveStatus.ACTIVE
+                brain.distract(comfortDistraction)
+                movementTask = brain.fixate(
+                    fixation = MoveIntoWaterFixation(
+                        movementTracker = movementTracker
+                    )
+                )
+            }
+        }
+        return ObjectiveStatus.ACTIVE
+    }
+
+    fun generateWaterSafePosToward(
+        mob: PathfinderMob,
+        range: Int,
+        targetPos: BlockPos
+    ): BlockPos? {
+
+        for (i in 0..4) {
+            val candidate: BlockPos? = RandomPos.generateRandomPosTowardDirection(
+                mob,
+                range,
+                mob.level().random,
+                targetPos
+            )
+
+            if (candidate == null) continue
+
+            val pathType = mob.navigation.nodeEvaluator.getPathType(mob, candidate)
+            // Don't actually care if it can be reached, only if it's not hazardous
+            if (pathType == PathType.WALKABLE || mob.getPathfindingMalus(pathType) <= 0)
+                return candidate
+
+        }
+        return null
+    }
+
+    companion object {
+        val BASE_TURN_CHANCE = 0.8
+    }
+
+    class MoveIntoWaterFixation(
+        override val movementTracker: MovementTracker,
+    ) : EntityFixation, MovementTrackerFixation {
+        override fun getDescription(entity: LivingEntity) = "Moving into water"
+        override fun canDistract(distraction: Distraction, entity: LivingEntity): Boolean {
+            return distraction.isDamage || distraction.isForce || movementTracker.lastStatus == MovementStatus.COMPLETED
+        }
+
+        override fun onDistract(distraction: Distraction, entity: LivingEntity) {
+            movementTracker.stop()
+        }
+
+        override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
+            val movementStatus = tickMovementFixation()
+            if (movementStatus == MovementStatus.COMPLETED) return false
+            if (!entity.isInWater) {
+                return false
+            }
+            return movementStatus != MovementStatus.FAILED
+        }
+    }
+
+    class Config : ObjectiveConfig {
+        val ticksBetweenAttempts: ExpressionOrEntityVariable = Either.left("60".asExpression())
+        val maxDistance: ExpressionOrEntityVariable = Either.left("10.0".asExpression())
+        val speedMultiplier: ExpressionOrEntityVariable = Either.left("0.4".asExpression())
+
+        override fun getVariables(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ) = listOf(
+            ticksBetweenAttempts,
+            maxDistance,
+            speedMultiplier
+        ).asVariables()
+
+        override fun create(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ): Objective {
+            val ticksBetweenAttempts = ticksBetweenAttempts.resolveInt(behaviourConfigurationContext.runtime)
+            return MoveIntoWater(
+                ticksBetweenAttempts = ticksBetweenAttempts,
+                maxDistance = maxDistance.asSimplifiedExpression(entity),
+                speedMultiplier = speedMultiplier.asSimplifiedExpression(entity)
+            )
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/objective/MoveOutOfWater.kt

@@ -0,0 +1,258 @@
+/*
+ * 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.*
+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.comfortDistraction
+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.entity.ai.CobblemonWalkTarget
+import com.cobblemon.mod.common.util.*
+import com.mojang.datafixers.util.Either
+import net.minecraft.core.BlockPos
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.PathfinderMob
+import net.minecraft.world.entity.TamableAnimal
+import net.minecraft.world.entity.ai.util.LandRandomPos
+import net.minecraft.world.entity.ai.util.RandomPos
+import net.minecraft.world.level.pathfinder.PathType
+import net.minecraft.world.phys.Vec3
+
+
+/**
+ * Tries to path out of water if the entity usually water to avoid water.
+ * Will pathfind through water even if the entity usually filters out water path nodes.
+ * If land cannot be found in the entity's wander range it'll wander randomly in a spiral-ish pattern
+ *
+ * @author JazzMcNade
+ * @since January 17th, 2026
+ */
+class MoveOutOfWater(
+    val ticksBetweenAttempts: Int = 60,
+    val maxDistance: Expression = "14.0".asExpression(),
+    val speedMultiplier: Expression = "0.4".asExpression()
+) : Objective {
+    var movementTask: EntityFixation? = null
+    var remainingCooldownTicks = ticksBetweenAttempts
+    var wanderDirection: Vec3? = null
+    var isWanderTurnDirectionClockwise = true
+    var wanderTurnChance = BASE_TURN_CHANCE
+    var failCount = 0
+    override fun getDescription(entity: LivingEntity) = "Move out of water"
+    override fun perform(
+        entity: LivingEntity,
+        brain: BiggerBrain,
+        activeObjectiveTags: MutableSet<String>
+    ): ObjectiveStatus {
+        if (entity !is TamableAnimal) {
+            return ObjectiveStatus.INVALID
+        }
+
+        if (brain.isFixation(movementTask)) {
+            remainingCooldownTicks = ticksBetweenAttempts
+            return ObjectiveStatus.FIXATED
+        }
+        if (!entity.isInWater || entity.isUnderWater) {
+            // Focus on not drowning first
+            // TODO: 100% boned if in an underwater cave
+            return ObjectiveStatus.INACTIVE
+        }
+
+
+        if (remainingCooldownTicks > 0) {
+            remainingCooldownTicks--
+            return ObjectiveStatus.INACTIVE
+        } else {
+            remainingCooldownTicks = ticksBetweenAttempts
+        }
+
+        val maxDistance = mainThreadRuntime.resolveInt(maxDistance)
+        val speedMultiplier = mainThreadRuntime.resolveFloat(speedMultiplier)
+
+        val runtime = mainThreadRuntime
+        val wanderControl = entity.brain.getMemorySafely(CobblemonMemories.WANDER_CONTROL).orElse(null)
+        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 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)) {
+            types.add(WanderType.LAND)
+        }
+
+
+        if (types.isEmpty()) {
+            return ObjectiveStatus.INACTIVE
+        }
+
+        if (brain.distract(comfortDistraction)) {
+            var walkTarget: CobblemonWalkTarget? = null
+            val targetVec3 = LandRandomPos.getPos(entity, maxDistance, maxDistance)
+            if (targetVec3 != null) {
+                walkTarget = CobblemonWalkTarget(
+                    BlockPos.containing(targetVec3.x, targetVec3.y, targetVec3.z),
+                    speedMultiplier,
+                    0,
+                    nodeTypeFilter = { nodeType ->
+                        true
+                    }
+                )
+            }
+
+            if (walkTarget == null) {
+                if (failCount >= 5) {
+                    // No out of water target black with a malus of 0 could be found.
+                    // Need to choose a direction and move as far as possible, hoping we randomly find land
+                    // Totally possible that a shoreline is *just* outside of the entity's wander range and
+                    // we choose a direction that's opposite of the shoreline
+                    // To counteract this, the pokemon moves in a (very roughly) spiral pattern outward from the origin
+                    var wanderPosition: BlockPos? = null
+                    if (wanderDirection == null) {
+                        val wanderOffset = RandomPos.generateRandomDirection(entity.level().random, maxDistance / 2, 0)
+                        wanderDirection = wanderOffset.toVec3d().normalize()
+                        isWanderTurnDirectionClockwise = entity.random.nextInt(2) > 0
+                        wanderTurnChance = BASE_TURN_CHANCE
+                        wanderPosition = entity.blockPosition().offset(wanderOffset.x, wanderOffset.y, wanderOffset.z)
+                    } else {
+
+                        if (entity.level().random.nextFloat() < wanderTurnChance) {
+                            // Turn 30 degrees
+                            wanderDirection =
+                                wanderDirection!!.yRot(Math.PI.toFloat() / 3.0f * if (isWanderTurnDirectionClockwise) -1f else 1f)
+                            wanderTurnChance *= 0.7
+                        }
+                        val wanderVec = entity.position().add(wanderDirection!!.scale(maxDistance.toDouble()))
+                        wanderPosition = BlockPos.containing(wanderVec)
+
+                    }
+                    val wanderTarget = generateWaterSafePosToward(entity, maxDistance, wanderPosition)
+
+                    if (wanderTarget != null) {
+                        walkTarget = CobblemonWalkTarget(
+                            wanderPosition,
+                            speedMultiplier,
+                            0,
+                            nodeTypeFilter = { nodeType ->
+                                true
+                            }
+                        )
+                    } else {
+                        return ObjectiveStatus.ACTIVE
+                    }
+                } else {
+                    failCount++
+                }
+
+            }
+            if (walkTarget != null) {
+                failCount = 0
+                val movementTracker = RegularMovementTracker.attempt(entity, walkTarget)
+                    ?: return ObjectiveStatus.ACTIVE
+                movementTask = brain.fixate(
+                    fixation = StayOutOfWaterFixation(
+                        movementTracker = movementTracker
+                    )
+                )
+            }
+        }
+        return ObjectiveStatus.ACTIVE
+    }
+
+    fun generateWaterSafePosToward(
+        mob: PathfinderMob,
+        range: Int,
+        targetPos: BlockPos
+    ): BlockPos? {
+
+        for (i in 0..4) {
+            val candidate: BlockPos? = RandomPos.generateRandomPosTowardDirection(
+                mob,
+                range,
+                mob.level().random,
+                targetPos
+            )
+
+            if (candidate == null) continue
+
+            val pathType = mob.navigation.nodeEvaluator.getPathType(mob, candidate)
+            // Don't actually care if it can be reached, only if it's not hazardous
+            if (pathType == PathType.WATER || mob.getPathfindingMalus(pathType) <= 0)
+                return candidate
+
+        }
+        return null
+    }
+
+    companion object {
+        const val BASE_TURN_CHANCE = 0.8
+    }
+
+    class StayOutOfWaterFixation(
+        override val movementTracker: MovementTracker,
+    ) : EntityFixation, MovementTrackerFixation {
+        var ticksOutOfWater = 0
+        override fun getDescription(entity: LivingEntity) = "Moving out of water"
+        override fun canDistract(distraction: Distraction, entity: LivingEntity): Boolean {
+            // Easily distracted once we are no longer touching water.
+            return distraction.isDamage || distraction.isForce || movementTracker.lastStatus == MovementStatus.COMPLETED
+        }
+
+        override fun onDistract(distraction: Distraction, entity: LivingEntity) {
+            movementTracker.stop()
+        }
+
+        override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
+            val movementStatus = tickMovementFixation()
+            if (movementStatus == MovementStatus.COMPLETED) return false
+            if (entity.isInWater) {
+                ticksOutOfWater = 0
+            } else {
+                ticksOutOfWater++
+                if (ticksOutOfWater > 20) {
+                    // Made it out of water, job done
+                    return false
+                }
+            }
+            return movementStatus != MovementStatus.FAILED
+        }
+    }
+
+    class Config : ObjectiveConfig {
+        val ticksBetweenAttempts: ExpressionOrEntityVariable = Either.left("60".asExpression())
+        val maxDistance: ExpressionOrEntityVariable = Either.left("10.0".asExpression())
+        val speedMultiplier: ExpressionOrEntityVariable = Either.left("0.4".asExpression())
+
+        override fun getVariables(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ) = listOf(
+            ticksBetweenAttempts,
+            maxDistance,
+            speedMultiplier
+        ).asVariables()
+
+        override fun create(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ): Objective {
+            val ticksBetweenAttempts = ticksBetweenAttempts.resolveInt(behaviourConfigurationContext.runtime)
+            return MoveOutOfWater(
+                ticksBetweenAttempts = ticksBetweenAttempts,
+                maxDistance = maxDistance.asSimplifiedExpression(entity),
+                speedMultiplier = speedMultiplier.asSimplifiedExpression(entity)
+            )
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/objective/MoveToRestingPlace.kt

@@ -0,0 +1,166 @@
+/*
+ * 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.*
+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.comfortDistraction
+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.pokemon.status.Statuses
+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.ai.memory.WalkTarget
+import net.minecraft.world.phys.AABB
+
+
+/**
+ * Looks for a resting place if the Pokemon is drowsy, and if available paths to it.
+ *
+ * @author JazzMcNade
+ * @since February 3rd, 2026
+ */
+class MoveToRestingPlace(
+    val ticksBetweenAttempts: Int = 80,
+    val horizontalSearchDistance: Expression = "14.0".asExpression(),
+    val verticalSearchDistance: Expression = "6.0".asExpression(),
+    val onlyFromStatus: Expression = "false".asExpression(),
+    val speedMultiplier: Expression = "0.4".asExpression()
+) : Objective {
+    var movementTask: EntityFixation? = null
+    var remainingCooldownTicks = ticksBetweenAttempts
+    override fun getDescription(entity: LivingEntity) = "Moving to a resting place"
+    override fun perform(
+        entity: LivingEntity,
+        brain: BiggerBrain,
+        activeObjectiveTags: MutableSet<String>
+    ): ObjectiveStatus {
+        if (entity !is PokemonEntity) {
+            return ObjectiveStatus.INVALID
+        }
+        brain.getMemory(CobblemonMemories.POKEMON_DROWSY)
+            ?: return ObjectiveStatus.INACTIVE
+
+
+        if (brain.isFixation(movementTask)) {
+            remainingCooldownTicks = ticksBetweenAttempts
+            return ObjectiveStatus.FIXATED
+        }
+
+        if (remainingCooldownTicks > 0) {
+            remainingCooldownTicks--
+        }
+
+        val hasSleepStatus = entity.pokemon.status?.status === Statuses.SLEEP
+        if (hasSleepStatus) return ObjectiveStatus.INACTIVE // Already sleeping
+
+        if (entity.behaviour.resting.canSleep) {
+            if (mainThreadRuntime.resolveBoolean(onlyFromStatus)) {
+                return ObjectiveStatus.BLOCKED
+            }
+
+            if (remainingCooldownTicks > 0 || entity.canSleepAt(entity.blockPosition().below())) {
+                // Can sleep where we're at, no need to go anywhere
+                return ObjectiveStatus.INACTIVE
+            }
+
+            val hSearchDistance = mainThreadRuntime.resolveDouble(horizontalSearchDistance)
+            val vSearchDistance = mainThreadRuntime.resolveDouble(verticalSearchDistance)
+
+            val positionList = entity.level()
+                .getBlockPositions(AABB.ofSize(entity.position(), hSearchDistance, vSearchDistance, hSearchDistance))
+                .filter(entity::canSleepAt)
+            val position = if (positionList.isEmpty()) null else positionList.random(1).firstOrNull()
+
+            if (position != null && brain.distract(comfortDistraction)) {
+                val speedMultiplier = mainThreadRuntime.resolveFloat(speedMultiplier)
+                val movementTracker = RegularMovementTracker.attempt(
+                    entity = entity,
+                    walkTarget = WalkTarget(
+                        position,
+                        speedMultiplier,
+                        0
+                    )
+                )
+                if (movementTracker != null) {
+                    // Become fixated
+                    movementTask = brain.fixate(
+                        fixation = MoveToRestingPlaceFixation(
+                            movementTracker = movementTracker,
+                        )
+                    )
+                }
+
+            } else {
+                return ObjectiveStatus.INACTIVE
+            }
+            return ObjectiveStatus.ACTIVE
+        }
+        return ObjectiveStatus.INACTIVE
+    }
+
+
+    class MoveToRestingPlaceFixation(
+        override val movementTracker: MovementTracker,
+    ) : EntityFixation, MovementTrackerFixation {
+        override fun getDescription(entity: LivingEntity) = "Moving to a resting place"
+        override fun canDistract(distraction: Distraction, entity: LivingEntity): Boolean {
+            return distraction.isDamage || distraction.isForce || movementTracker.lastStatus == MovementStatus.COMPLETED
+        }
+
+        override fun onDistract(distraction: Distraction, entity: LivingEntity) {
+            movementTracker.stop()
+        }
+
+        override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
+            val movementStatus = tickMovementFixation()
+            if (movementStatus == MovementStatus.COMPLETED) return false
+            return movementStatus != MovementStatus.FAILED
+        }
+    }
+
+    class Config : ObjectiveConfig {
+        val ticksBetweenAttempts: ExpressionOrEntityVariable = Either.left("60".asExpression())
+        val horizontalSearchDistance: ExpressionOrEntityVariable = Either.left("10.0".asExpression())
+        val verticalSearchDistance: ExpressionOrEntityVariable = Either.left("10.0".asExpression())
+        val speedMultiplier: ExpressionOrEntityVariable = Either.left("0.4".asExpression())
+        val onlyFromStatus: ExpressionOrEntityVariable = Either.left("false".asExpression())
+
+        override fun getVariables(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ) = listOf(
+            ticksBetweenAttempts,
+            horizontalSearchDistance,
+            verticalSearchDistance,
+            speedMultiplier,
+            onlyFromStatus
+        ).asVariables()
+
+        override fun create(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ): Objective {
+            val ticksBetweenAttempts = ticksBetweenAttempts.resolveInt(behaviourConfigurationContext.runtime)
+            return MoveToRestingPlace(
+                ticksBetweenAttempts = ticksBetweenAttempts,
+                horizontalSearchDistance = horizontalSearchDistance.asSimplifiedExpression(entity),
+                verticalSearchDistance = verticalSearchDistance.asSimplifiedExpression(entity),
+                speedMultiplier = speedMultiplier.asSimplifiedExpression(entity),
+                onlyFromStatus = onlyFromStatus.asSimplifiedExpression(entity)
+            )
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/objective/Objective.kt

@@ -0,0 +1,48 @@
+/*
+ * 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.biggerbrain.BiggerBrain
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.ai.memory.MemoryModuleType
+
+/**
+ * An ongoing priority for an entity. Objectives are managed by the [BiggerBrain] system. Objectives can act out
+ * entirely within their own logic, or they can alter memories or create fixations for the entity to take up its
+ * entire attention.
+ *
+ * @author Hiroku
+ * @since December 29th, 2025
+ */
+interface Objective {
+    companion object {
+        /**
+         * The idea behind this is that later objectives may like to know or respect that something impacting wandering
+         * has taken place.
+         */
+        val OBJECTIVE_TAG_WANDERING = "WANDERING"
+    }
+
+    /** The memory types that, upon being changed, should trigger [onMemoryChanged]. */
+    val observedMemories: List<MemoryModuleType<*>>
+        get() = emptyList()
+
+    /** Gets a current description for this objective. This is purely used for the debug overlay. */
+    fun getDescription(entity: LivingEntity): String
+    /** Performs this objective's logic for a tick. */
+    fun perform(entity: LivingEntity, brain: BiggerBrain, activeObjectiveTags: MutableSet<String>): ObjectiveStatus
+
+    /**
+     * 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
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/objective/ObjectiveStatus.kt

@@ -0,0 +1,28 @@
+/*
+ * 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
+
+/**
+ * The current status of an [Objective]. Used for the debug overlay.
+ *
+ * @author Hiroku
+ * @since December 29th, 2025
+ */
+enum class ObjectiveStatus {
+    /** States that this objective owns the current fixation. */
+    FIXATED,
+    /** States that the objective's logic is ongoing and not impeded. */
+    ACTIVE,
+    /** States that the objective is not performing any meaningful logic right now but isn't actively blocked. */
+    INACTIVE,
+    /** States that there are other objectives, fixations, etc. in play which prevents the objective from being performed. */
+    BLOCKED,
+    /** States that the objective is not valid and shouldn't have been registered on the entity in the first place, such as when placed on the wrong entity type. */
+    INVALID
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/objective/PickupItem.kt

@@ -0,0 +1,234 @@
+/*
+ * 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.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.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.biggerbrain.fixation.MovementTrackerFixation
+import com.cobblemon.mod.common.api.ai.config.objective.ObjectiveConfig
+import com.cobblemon.mod.common.api.ai.resolveInt
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.util.asExpression
+import com.cobblemon.mod.common.util.getMemorySafely
+import com.cobblemon.mod.common.util.mainThreadRuntime
+import com.cobblemon.mod.common.util.resolveDouble
+import com.cobblemon.mod.common.util.resolveFloat
+import com.cobblemon.mod.common.util.withQueryValue
+import com.mojang.datafixers.util.Either
+import net.minecraft.sounds.SoundEvents
+import net.minecraft.world.entity.Entity
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.PathfinderMob
+import net.minecraft.world.entity.ai.memory.MemoryModuleType
+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.level.GameRules
+import kotlin.math.ceil
+import kotlin.math.min
+
+/**
+ * Paths to whatever item entity is marked by NEAREST_VISIBLE_WANTED_ITEM
+ * Upon reaching the target attempts to place it in held item slot
+ * held item slot if possible.
+ * Requires NEARBY_SWEET_BERRY_BUSH memory
+ *
+ * @author JazzMcNade
+ * @since February 8th, 2026
+ */
+class PickupItem(
+    val ticksBetweenAttempts: Int = 60,
+    val maxDistance: Expression = "14.0".asExpression(),
+    val speedMultiplier: Expression = "0.4".asExpression(),
+    val maxReach: Expression = "1.0".asExpression(),
+) : Objective {
+    var collectItemTask: EntityFixation? = null
+    var remainingCooldownTicks = ticksBetweenAttempts
+
+    override fun getDescription(entity: LivingEntity) = "Pickup item"
+    override fun perform(
+        entity: LivingEntity,
+        brain: BiggerBrain,
+        activeObjectiveTags: MutableSet<String>
+    ): ObjectiveStatus {
+        if (entity !is PokemonEntity) {
+            return ObjectiveStatus.INVALID
+        } else if (brain.isFixation(collectItemTask)) {
+            remainingCooldownTicks = ticksBetweenAttempts
+            return ObjectiveStatus.FIXATED
+        }
+
+        val itemEntity = entity.biggerBrain.getMemory(MemoryModuleType.NEAREST_VISIBLE_WANTED_ITEM) ?: return ObjectiveStatus.INACTIVE
+
+        if (remainingCooldownTicks > 0) {
+            remainingCooldownTicks--
+            return ObjectiveStatus.ACTIVE
+        }
+
+        mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
+        val speedMultiplier = mainThreadRuntime.resolveFloat(speedMultiplier)
+
+        // See if the item can be picked up without needing to path to it
+        val success = tryPickupItem(entity, itemEntity)
+
+        if (!success) {
+            // Item is too far away, need to path to it
+            if (remainingCooldownTicks <= 0 && brain.distract(idleBoredomDistraction)) {
+                remainingCooldownTicks = ticksBetweenAttempts
+                val horizontalHitboxRadius = maxOf(entity.boundingBox.xsize, entity.boundingBox.zsize) / 2
+                val movementTracker = RegularMovementTracker.attempt(
+                    entity = entity,
+                    walkTarget = WalkTarget(
+                        itemEntity,
+                        speedMultiplier,
+                        min(ceil(horizontalHitboxRadius).toInt() - 1, 1),
+                    )
+                )
+
+                if (movementTracker != null) {
+                    val lookingTracker = LookingTracker(entity = entity, lookTarget = movementTracker.walkTarget.target)
+                    collectItemTask = brain.fixate(
+                        fixation = PickupItemFixation(
+                            objective = this,
+                            itemEntity = itemEntity,
+                            movementTracker = movementTracker,
+                            lookingTracker = lookingTracker,
+                        )
+                    )
+                }
+            }
+        } else {
+            remainingCooldownTicks = ticksBetweenAttempts
+        }
+        return ObjectiveStatus.ACTIVE
+    }
+
+    fun tryPickupItem(entity: PokemonEntity, itemEntity: ItemEntity) : Boolean {
+        val maxReach = mainThreadRuntime.resolveDouble(maxReach) + maxOf(entity.boundingBox.xsize, entity.boundingBox.zsize) / 2
+        if (itemEntity.distanceTo(entity) > maxReach || !entity.hasLineOfSight(itemEntity)) {
+            return false
+        }
+
+        entity.brain.eraseMemory(MemoryModuleType.NEAREST_VISIBLE_WANTED_ITEM)
+        entity.take(itemEntity, 1) // This creates the effect of the item going into the entity along with the item pickup sound
+        val stack = entity.pokemon.swapHeldItem(itemEntity.item)
+        if (!stack.isEmpty && !entity.level().isClientSide) {
+            dropItem(entity, stack)
+        }
+        return true
+    }
+
+    class PickupItemFixation(
+        val objective: PickupItem,
+        val itemEntity: ItemEntity,
+        override val movementTracker: MovementTracker,
+        override val lookingTracker : LookingTracker,
+    ): EntityFixation, MovementTrackerFixation, LookingTrackerFixation {
+
+        override fun getDescription(entity: LivingEntity) = "Moving to desired item"
+        override fun canDistract(distraction: Distraction, entity: LivingEntity): Boolean {
+            return distraction.isDamage || distraction.isForce || (movementTracker.lastStatus == MovementStatus.COMPLETED && entity.brain.getMemorySafely(
+                CobblemonMemories.NEARBY_SWEET_BERRY_BUSH).orElse(null) != null)
+        }
+
+        override fun onDistract(distraction: Distraction, entity: LivingEntity) {
+            movementTracker.stop()
+        }
+
+        override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
+            lookingTracker.tick()
+            movementTracker.tick()
+
+            if (movementTracker.lastStatus == MovementStatus.COMPLETED || movementTracker.lastStatus == MovementStatus.FAILED) {
+                // May have failed but let's check if we're still close enoug to grab it
+                val world = entity.level()
+
+                if (entity !is PokemonEntity) return false
+
+                if (!world.gameRules.getRule(GameRules.RULE_MOBGRIEFING).get()) {
+                    // Not allowed to alter the world
+                    return false
+                }
+                if (!itemEntity.isAlive || !entity.pokemon.canDropHeldItem) {
+                    return false
+                }
+
+                val succeeded = objective.tryPickupItem(entity, itemEntity)
+
+                if (!succeeded && movementTracker.lastStatus == MovementStatus.FAILED) {
+                    // Cannot reach, give up for a while
+                    entity.brain.setMemoryWithExpiry(CobblemonMemories.DISABLE_WALK_TO_WANTED_ITEM, true, 200)
+                    entity.brain.eraseMemory(MemoryModuleType.NEAREST_VISIBLE_WANTED_ITEM)
+                }
+                return false
+            }
+            return true
+        }
+
+    }
+
+
+    class Config : ObjectiveConfig {
+        val ticksBetweenAttempts: ExpressionOrEntityVariable = Either.left("60".asExpression())
+        val maxDistance: ExpressionOrEntityVariable = Either.left("10.0".asExpression())
+        val speedMultiplier: ExpressionOrEntityVariable = Either.left("0.4".asExpression())
+
+        override fun getVariables(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ) = listOf(
+            ticksBetweenAttempts,
+            maxDistance,
+            speedMultiplier
+        ).asVariables()
+
+        override fun create(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): Objective {
+            val ticksBetweenAttempts = ticksBetweenAttempts.resolveInt(behaviourConfigurationContext.runtime)
+            return PickupItem(
+                ticksBetweenAttempts = ticksBetweenAttempts,
+                maxDistance = maxDistance.asSimplifiedExpression(entity),
+                speedMultiplier = speedMultiplier.asSimplifiedExpression(entity)
+            )
+        }
+    }
+
+    companion object {
+        fun dropItem(entity: Entity, stack: ItemStack) {
+            val itemEntity = ItemEntity(
+                entity.level(),
+                entity.x + entity.lookAngle.x,
+                entity.y + 1.0,
+                entity.z + entity.lookAngle.z,
+                stack
+            )
+            itemEntity.setPickUpDelay(40)
+            itemEntity.setThrower(entity)
+            entity.playSound(SoundEvents.FOX_SPIT, 1.0f, 1.0f) // TODO: customize this sound?
+            entity.level().addFreshEntity(itemEntity)
+        }
+    }
+
+
+
+    }

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/objective/PointToSpawn.kt

@@ -0,0 +1,134 @@
+/*
+ * 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.fixation.EntityFixation
+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.fixation.LookingTrackerFixation
+import com.cobblemon.mod.common.api.ai.config.objective.ObjectiveConfig
+import com.cobblemon.mod.common.api.ai.resolveDouble
+import com.cobblemon.mod.common.api.ai.resolveInt
+import com.cobblemon.mod.common.util.asExpression
+import com.mojang.datafixers.util.Either
+import net.minecraft.core.BlockPos
+import net.minecraft.core.Direction
+import kotlin.math.pow
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.PathfinderMob
+import net.minecraft.world.entity.ai.behavior.BlockPosTracker
+import net.minecraft.world.entity.ai.behavior.EntityTracker
+import net.minecraft.world.entity.ai.behavior.PositionTracker
+import net.minecraft.world.entity.ai.memory.MemoryModuleType
+import net.minecraft.world.entity.ai.memory.MemoryStatus
+import net.minecraft.world.phys.Vec3
+
+/**
+ * Randomly points toward spawn. Very easily distracted once doing so.
+ *
+ */
+class PointToSpawn(
+    val minDuration: Int = 20,
+    val maxDuration: Int = 200
+) : Objective {
+    var fixation: EntityFixation? = null
+
+    override fun getDescription(entity: LivingEntity) = "Point towards spawn"
+    override fun perform(
+        entity: LivingEntity,
+        brain: BiggerBrain,
+        activeObjectiveTags: MutableSet<String>
+    ): ObjectiveStatus {
+        if (brain.isFixation(fixation)) {
+            return ObjectiveStatus.FIXATED
+        } else if (brain.fixation != null) {
+            fixation = null
+            return ObjectiveStatus.BLOCKED
+        } else if (!entity.brain.checkMemory(MemoryModuleType.LOOK_TARGET, MemoryStatus.REGISTERED)
+            || !entity.brain.checkMemory(MemoryModuleType.WALK_TARGET, MemoryStatus.VALUE_ABSENT)
+        ) {
+            return ObjectiveStatus.BLOCKED
+        }
+
+        val blockPos = Vec3.atCenterOf(entity.level().sharedSpawnPos).with(Direction.Axis.Y, entity.eyeY)
+        brain.setMemory(
+            MemoryModuleType.LOOK_TARGET,
+            BlockPosTracker(blockPos)
+        )
+
+
+        // Become fixated
+        fixation = brain.fixate(
+            IdleLookFixation(
+                this,
+                blockPos,
+                (minDuration..maxDuration).random()
+            )
+        )
+        return ObjectiveStatus.FIXATED
+    }
+
+    class IdleLookFixation(
+        val objective: PointToSpawn,
+        val targetPosition: Vec3,
+        var remainingTicks: Int
+    ) : EntityFixation, LookingTrackerFixation {
+        override var lookingTracker: LookingTracker? = null
+
+        override fun getDescription(entity: LivingEntity): String {
+            return "Looking at spawn position ($remainingTicks ticks left)"
+        }
+
+        override fun canDistract(distraction: Distraction, entity: LivingEntity): Boolean {
+            return true
+        }
+
+        override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
+            if (entity !is PathfinderMob) {
+                return false
+            }
+            if (lookingTracker == null) {
+                lookingTracker = LookingTracker(entity, BlockPosTracker(targetPosition))
+            }
+            val lookingTracker = lookingTracker!!
+            remainingTicks--
+            lookingTracker.tick()
+            return remainingTicks > 0
+        }
+    }
+
+    class Config : ObjectiveConfig {
+        val minDuration: ExpressionOrEntityVariable = Either.left("20".asExpression())
+        val maxDuration: ExpressionOrEntityVariable = Either.left("80".asExpression())
+
+        override fun getVariables(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ) = listOf(
+            minDuration,
+            maxDuration
+        ).asVariables()
+
+        override fun create(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ): Objective {
+            val minDuration = minDuration.resolveInt(behaviourConfigurationContext.runtime)
+            val maxDuration = maxDuration.resolveInt(behaviourConfigurationContext.runtime)
+            return PointToSpawn(
+                minDuration = minDuration,
+                maxDuration = maxDuration
+            )
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/objective/StayAfloat.kt

@@ -0,0 +1,79 @@
+/*
+ * 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.asVariables
+import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
+import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.MovementTrackerFixation
+import com.cobblemon.mod.common.api.ai.booleanVariable
+import com.cobblemon.mod.common.api.ai.config.objective.ObjectiveConfig
+import com.cobblemon.mod.common.api.ai.config.task.SharedEntityVariables
+import com.cobblemon.mod.common.api.ai.numberVariable
+import com.cobblemon.mod.common.api.ai.resolveBoolean
+import com.cobblemon.mod.common.api.ai.resolveFloat
+import net.minecraft.tags.FluidTags
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.PathfinderMob
+
+class StayAfloat(
+    val chance: Float = 0.8F
+) : Objective {
+    override fun getDescription(entity: LivingEntity) = "Stay Afloat"
+
+    override fun perform(
+        entity: LivingEntity,
+        brain: BiggerBrain,
+        activeObjectiveTags: MutableSet<String>
+    ): ObjectiveStatus {
+        if (entity !is PathfinderMob) {
+            return ObjectiveStatus.INVALID
+        }
+
+        val fixation = brain.fixation
+        if (fixation is MovementTrackerFixation) {
+            // Ok if movement is in progress then we don't try staying afloat
+            return ObjectiveStatus.BLOCKED
+        }
+
+        if (entity.isInWater && (entity.getFluidHeight(FluidTags.WATER) > entity.fluidJumpThreshold) ||
+            (entity.isInLava && !entity.fireImmune())) {
+            // Cool do something
+            if (entity.random.nextFloat() < this.chance) {
+                entity.jumpControl.jump()
+            }
+            return ObjectiveStatus.ACTIVE
+        } else {
+            return ObjectiveStatus.INACTIVE
+        }
+    }
+
+    class Config : ObjectiveConfig {
+        val condition = booleanVariable(SharedEntityVariables.MOVEMENT_CATEGORY, "can_float", true).asExpressible()
+        val chance = numberVariable(SharedEntityVariables.MOVEMENT_CATEGORY, "float_chance", 0.8F).asExpressible()
+
+        override fun getVariables(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ) = listOf(
+            condition,
+            chance
+        ).asVariables()
+
+        override fun create(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ): StayAfloat? {
+            return when {
+                condition.resolveBoolean(behaviourConfigurationContext.runtime) -> StayAfloat(chance.resolveFloat(behaviourConfigurationContext.runtime))
+                else -> null
+            }
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/objective/StayNearOwner.kt

@@ -0,0 +1,240 @@
+/*
+ * 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.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.comfortDistraction
+import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.EntityFixation
+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
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
+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 kotlin.math.abs
+import kotlin.math.ceil
+import net.minecraft.core.BlockPos
+import net.minecraft.util.RandomSource
+import net.minecraft.world.entity.Entity
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.PathfinderMob
+import net.minecraft.world.entity.TamableAnimal
+import net.minecraft.world.entity.ai.behavior.EntityTracker
+import net.minecraft.world.entity.ai.memory.WalkTarget
+import net.minecraft.world.level.pathfinder.PathType
+import net.minecraft.world.level.pathfinder.WalkNodeEvaluator
+
+/**
+ * Keeps track of the owner entity, and if they are in the same world but are too far away, fixates on getting closer.
+ * If they are extremely far away, will attempt to teleport to them. When walking to the owner, it pauses for a short
+ * duration after reaching them to look at them. It's cute.
+ *
+ * @author Hiroku
+ * @since December 29th, 2025
+ */
+class StayNearOwner(
+    val ticksBetweenAttempts: Int = 60,
+    val completionRange: Expression = "4.0".asExpression(),
+    val maxDistance: Expression = "14.0".asExpression(),
+    val teleportDistance: Expression = "24.0".asExpression(),
+    val speedMultiplier: Expression = "0.4".asExpression()
+) : Objective {
+    var followTask: EntityFixation? = null
+    var remainingCooldownTicks = ticksBetweenAttempts
+
+    override fun getDescription(entity: LivingEntity) = "Stay near owner"
+    override fun perform(
+        entity: LivingEntity,
+        brain: BiggerBrain,
+        activeObjectiveTags: MutableSet<String>
+    ): ObjectiveStatus {
+        if (entity !is TamableAnimal) {
+            return ObjectiveStatus.INVALID
+        } else if (brain.isFixation(followTask)) {
+            remainingCooldownTicks = ticksBetweenAttempts
+            return ObjectiveStatus.FIXATED
+        }
+
+        val owner = entity.owner ?: return ObjectiveStatus.INVALID
+        if (owner.level() != entity.level()) {
+            return ObjectiveStatus.INVALID
+        }
+
+        if (remainingCooldownTicks > 0) {
+            remainingCooldownTicks--
+        }
+
+        mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
+
+        val teleportDistance = mainThreadRuntime.resolveFloat(teleportDistance)
+        val maxDistance = mainThreadRuntime.resolveFloat(maxDistance)
+        val speedMultiplier = mainThreadRuntime.resolveFloat(speedMultiplier)
+        val completionRange = mainThreadRuntime.resolveInt(completionRange)
+
+        val horizontalHitboxRadius = maxOf(entity.boundingBox.xsize, entity.boundingBox.zsize) / 2
+
+        val distance = entity.distanceTo(owner) - horizontalHitboxRadius
+        if (distance > teleportDistance) {
+            if (remainingCooldownTicks <= 0 && brain.distract(Distraction.FORCE)) {
+                remainingCooldownTicks = ticksBetweenAttempts
+                tryTeleport(entity, owner)
+                return ObjectiveStatus.ACTIVE
+            }
+            return if (remainingCooldownTicks <= 0) ObjectiveStatus.BLOCKED else ObjectiveStatus.ACTIVE
+        } else if (distance > maxDistance) {
+            if (remainingCooldownTicks <= 0 && brain.distract(comfortDistraction)) {
+                remainingCooldownTicks = ticksBetweenAttempts
+                val movementTracker = RegularMovementTracker.attempt(
+                    entity = entity,
+                    walkTarget = WalkTarget(
+                        owner,
+                        speedMultiplier,
+                        maxOf(completionRange, ceil(horizontalHitboxRadius).toInt()) - 1
+                    )
+                )
+                if (movementTracker != null) {
+                    followTask = brain.fixate(
+                        fixation = FollowOwnerFixation(
+                            entity = entity,
+                            owner = owner,
+                            teleportDistance = teleportDistance,
+                            movementTracker = movementTracker
+                        )
+                    )
+                }
+            }
+        }
+        return ObjectiveStatus.ACTIVE
+    }
+
+    private fun tryTeleport(entity: TamableAnimal, owner: Entity): Boolean {
+        val blockPos = owner.blockPosition()
+        for (i in 0..9) {
+            val j = this.getRandomInt(entity.random, -3, 3)
+            val k = this.getRandomInt(entity.random, -1, 1)
+            val l = this.getRandomInt(entity.random, -3, 3)
+            val succeeded = this.tryTeleportTo(entity, owner, blockPos.x + j, blockPos.y + k, blockPos.z + l)
+            if (succeeded) {
+                return true
+            }
+        }
+        return false
+    }
+
+    private fun tryTeleportTo(entity: TamableAnimal, owner: Entity, x: Int, y: Int, z: Int): Boolean {
+        if (abs(x.toDouble() - owner.x) < 2.0 && abs(z - owner.z) < 2.0) {
+            return false
+        } else if (!this.canTeleportTo(entity, BlockPos(x, y, z))) {
+            return false
+        } else {
+            entity.moveTo(
+                x.toDouble() + 0.5, y.toDouble(), z.toDouble() + 0.5,
+                entity.yRot,
+                entity.xRot
+            )
+            entity.navigation.stop()
+            return true
+        }
+    }
+
+    private fun canTeleportTo(entity: TamableAnimal, pos: BlockPos): Boolean {
+        val pathNodeType = WalkNodeEvaluator.getPathTypeStatic(entity, pos.mutable())
+        if (pathNodeType != PathType.WALKABLE) {
+            return false // Could be more complex to support fliers and swimmers
+        } else {
+            val blockPos = pos.subtract(entity.blockPosition())
+            return entity.level().noCollision(entity, entity.boundingBox.move(blockPos))
+        }
+    }
+
+    private fun getRandomInt(random: RandomSource, min: Int, max: Int) = random.nextInt(max - min + 1) + min
+
+    class FollowOwnerFixation(
+        entity: PathfinderMob,
+        val owner: LivingEntity,
+        val teleportDistance: Float,
+        override val movementTracker: MovementTracker,
+    ): EntityFixation, LookingTrackerFixation, MovementTrackerFixation {
+
+        // Look at the owner for some amount of time after reaching them. For cuteness!
+        var lingeringStareTicks = (20..40).random()
+
+        override val lookingTracker: LookingTracker = LookingTracker(entity = entity, lookTarget = EntityTracker(owner, true))
+        override fun getDescription(entity: LivingEntity) = "Moving to owner"
+        override fun canDistract(distraction: Distraction, entity: LivingEntity): Boolean {
+            // Easily distracted once we've reached the player.
+            return distraction.isDamage || distraction.isForce || movementTracker.lastStatus == MovementStatus.COMPLETED
+        }
+
+        override fun onDistract(distraction: Distraction, entity: LivingEntity) {
+            movementTracker.stop()
+        }
+
+        override fun tick(entity: LivingEntity, brain: BiggerBrain): Boolean {
+            lookingTracker.tick()
+
+            if (entity.distanceTo(owner) > teleportDistance) {
+                // Too far away, give up, the teleport will handle it
+                return false
+            }
+
+            if (movementTracker.lastStatus == MovementStatus.COMPLETED) {
+                lingeringStareTicks--
+                return lingeringStareTicks > 0
+            }
+
+            return tickMovementFixation() != MovementStatus.FAILED
+        }
+    }
+
+    class Config : ObjectiveConfig {
+        val ticksBetweenAttempts: ExpressionOrEntityVariable = Either.left("60".asExpression())
+        val completionRange: ExpressionOrEntityVariable = Either.left("4.0".asExpression())
+        val maxDistance: ExpressionOrEntityVariable = Either.left("10.0".asExpression())
+        val teleportDistance: ExpressionOrEntityVariable = Either.left("24.0".asExpression())
+        val speedMultiplier: ExpressionOrEntityVariable = Either.left("0.4".asExpression())
+
+        override fun getVariables(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ) = listOf(
+            ticksBetweenAttempts,
+            completionRange,
+            maxDistance,
+            teleportDistance,
+            speedMultiplier
+        ).asVariables()
+
+        override fun create(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): Objective {
+            val ticksBetweenAttempts = ticksBetweenAttempts.resolveInt(behaviourConfigurationContext.runtime)
+            return StayNearOwner(
+                ticksBetweenAttempts = ticksBetweenAttempts,
+                completionRange = completionRange.asSimplifiedExpression(entity),
+                maxDistance = maxDistance.asSimplifiedExpression(entity),
+                teleportDistance = teleportDistance.asSimplifiedExpression(entity),
+                speedMultiplier = speedMultiplier.asSimplifiedExpression(entity)
+            )
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/objective/WanderAround.kt

@@ -0,0 +1,210 @@
+/*
+ * 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.biggerbrain.LookingTracker
+import com.cobblemon.mod.common.api.ai.biggerbrain.RegularMovementTracker
+import com.cobblemon.mod.common.api.ai.biggerbrain.WanderType
+import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.DistractionType
+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.config.objective.ObjectiveConfig
+import com.cobblemon.mod.common.api.ai.resolveInt
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
+import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
+import com.cobblemon.mod.common.util.asExpression
+import com.cobblemon.mod.common.util.getMemorySafely
+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.PathfinderMob
+
+/*
+ * I've scuffed the hell out of this thing. The logic for what types of wandering to do is unclear, and I haven't
+ * really decided whether it should be one mega function for finding a wander target and figuring out the type of
+ * goal in the process or if it should be cleanly separated for each type of wander target. I've done a bit of both
+ * and it's not pretty.
+ */
+
+class WanderAround(
+    val condition: Expression = "true".asExpression(),
+    val cooldownTicks: Int = 80,
+    val allowLand: Expression = "(q.entity.behaviour.moving.walk.can_walk && !q.entity.behaviour.moving.walk.avoids_land) || q.entity.behaviour.moving.fly.can_fly".asExpression(),
+    val allowWater: Expression = "q.entity.behaviour.moving.swim.can_swim_in_water && !q.entity.behaviour.moving.swim.avoids_water".asExpression(),
+    val allowAir: Expression = "q.entity.behaviour.moving.fly.can_fly && !q.entity.behaviour.moving.walk.can_walk".asExpression(),
+    val wanderChance: Expression = "1/(20*6)".asExpression(),
+    val horizontalRange: Expression = "10".asExpression(),
+    val verticalRange: Expression = "5".asExpression(),
+    val speedMultiplier: Expression = "0.35".asExpression(),
+    val avoidTargetingAir: Expression = "true".asExpression(),
+    val minimumHeight: Expression = "0".asExpression(),
+    val maximumHeight: Expression = "999".asExpression()
+) : Objective {
+    var fixation: EntityFixation? = null
+    var remainingCooldownTicks = 10
+    
+    override fun getDescription(entity: LivingEntity) = "Wander around"
+
+    override fun perform(
+        entity: LivingEntity,
+        brain: BiggerBrain,
+        activeObjectiveTags: MutableSet<String>
+    ): ObjectiveStatus {
+        if (brain.isFixation(fixation)) {
+            activeObjectiveTags.add(Objective.OBJECTIVE_TAG_WANDERING)
+            return ObjectiveStatus.FIXATED
+        } else if (entity !is PathfinderMob) {
+            return ObjectiveStatus.INVALID
+        } else if (Objective.OBJECTIVE_TAG_WANDERING in activeObjectiveTags) {
+            return ObjectiveStatus.BLOCKED
+        } else if (!brain.canDistract(idleBoredomDistraction)) {
+            return ObjectiveStatus.BLOCKED
+        }
+
+        fixation = null
+
+        val runtime = mainThreadRuntime
+        runtime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
+
+        if (!runtime.resolveBoolean(condition)) {
+            return ObjectiveStatus.INACTIVE
+        } else if (Objective.OBJECTIVE_TAG_WANDERING in activeObjectiveTags) {
+            return ObjectiveStatus.BLOCKED
+        }
+
+        if (remainingCooldownTicks > 0) {
+            remainingCooldownTicks--
+            return ObjectiveStatus.INACTIVE
+        }
+
+        val wanderControl = entity.brain.getMemorySafely(CobblemonMemories.WANDER_CONTROL).orElse(null)
+        val wanderChance = runtime.resolveFloat(this.wanderChance) * (wanderControl?.wanderChanceMultiplier ?: 1.0F)
+        if (wanderChance <= 1.0F && entity.level().random.nextFloat() > wanderChance) {
+            return ObjectiveStatus.ACTIVE
+        }
+
+        val allowLand = wanderControl?.allowLand ?: runtime.resolveBoolean(allowLand)
+        val allowWater = wanderControl?.allowWater ?: runtime.resolveBoolean(allowWater)
+        val allowAir = wanderControl?.allowAir ?: runtime.resolveBoolean(allowAir)
+
+        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 ObjectiveStatus.INVALID
+        }
+
+        remainingCooldownTicks = cooldownTicks
+        val walkTarget = types.firstNotNullOfOrNull {
+            it.generateWalkTarget(
+                entity = entity,
+                horizontalRange = runtime.resolveInt(horizontalRange),
+                verticalRange = runtime.resolveInt(verticalRange),
+                minimumHeight = runtime.resolveInt(minimumHeight),
+                maximumHeight = runtime.resolveInt(maximumHeight),
+                avoidTargetingAir = runtime.resolveBoolean(avoidTargetingAir),
+                speedMultiplier = runtime.resolveFloat(speedMultiplier),
+                center = wanderControl?.center,
+                maxAttempts = wanderControl?.maxAttempts ?: 4
+            )
+        } ?: return ObjectiveStatus.ACTIVE
+
+        val movementTracker = RegularMovementTracker.attempt(entity, walkTarget)
+            ?: return ObjectiveStatus.ACTIVE
+
+
+        if (brain.distract(idleBoredomDistraction)) {
+            movementTracker.tick()
+            fixation = brain.fixate(
+                LookAndMoveFixation(
+                    description = "Wandering",
+                    distractionTypes = setOf(DistractionType.DAMAGE, DistractionType.FORCE),
+                    lookingTracker = LookingTracker.fromNavigationPathOrWalkTarget(entity, walkTarget),
+                    movementTracker = movementTracker
+                )
+            )
+            activeObjectiveTags.add(Objective.OBJECTIVE_TAG_WANDERING) // unsure if we need this
+            return ObjectiveStatus.FIXATED
+        }
+        
+        return ObjectiveStatus.BLOCKED
+    }
+
+    class Config : ObjectiveConfig {
+        val condition: ExpressionOrEntityVariable = Either.left("true".asExpression())
+        val cooldownTicks: ExpressionOrEntityVariable = Either.left("80".asExpression())
+        val allowLand: ExpressionOrEntityVariable = Either.left("(q.entity.behaviour.moving.walk.can_walk && !q.entity.behaviour.moving.walk.avoids_land) || q.entity.behaviour.moving.fly.can_fly".asExpression())
+        val allowWater: ExpressionOrEntityVariable = Either.left("q.entity.behaviour.moving.swim.can_swim_in_water && !q.entity.behaviour.moving.swim.avoids_water".asExpression())
+        val allowAir: ExpressionOrEntityVariable = Either.left("q.entity.behaviour.moving.fly.can_fly && !q.entity.behaviour.moving.walk.can_walk".asExpression())
+        val wanderChance: ExpressionOrEntityVariable = Either.left("1/(20*6)".asExpression())
+        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("true".asExpression())
+        val minimumHeight: ExpressionOrEntityVariable = Either.left("0".asExpression())
+        val maximumHeight: ExpressionOrEntityVariable = Either.left("999".asExpression())
+
+        override fun getVariables(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ): List<MoLangConfigVariable> {
+            return listOf(
+                condition,
+                cooldownTicks,
+                allowLand,
+                allowWater,
+                allowAir,
+                wanderChance,
+                horizontalRange,
+                verticalRange,
+                speedMultiplier,
+                avoidTargetingAir,
+                minimumHeight,
+                maximumHeight
+            ).asVariables()
+        }
+
+        override fun create(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ): Objective {
+            return WanderAround(
+                condition = condition.asSimplifiedExpression(entity),
+                cooldownTicks = cooldownTicks.resolveInt(behaviourConfigurationContext.runtime),
+                allowLand = allowLand.asSimplifiedExpression(entity),
+                allowWater = allowWater.asSimplifiedExpression(entity),
+                allowAir = allowAir.asSimplifiedExpression(entity),
+                wanderChance = wanderChance.asSimplifiedExpression(entity),
+                horizontalRange = horizontalRange.asSimplifiedExpression(entity),
+                verticalRange = verticalRange.asSimplifiedExpression(entity),
+                speedMultiplier = speedMultiplier.asSimplifiedExpression(entity),
+                avoidTargetingAir = avoidTargetingAir.asSimplifiedExpression(entity),
+                minimumHeight = minimumHeight.asSimplifiedExpression(entity),
+                maximumHeight = maximumHeight.asSimplifiedExpression(entity)
+            )
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/sense/BattlingPokemonSense.kt

@@ -0,0 +1,90 @@
+/*
+ * 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.battles.BattleRegistry
+import com.cobblemon.mod.common.entity.npc.NPCEntity
+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
+
+/**
+ * Senses whether the entity is battling or not. Maintains the BATTLING_POKEMON memory.
+ *
+ * @author Hiroku
+ * @since December 29th, 2025
+ */
+class BattlingPokemonSense(
+    var cooldownTicks: Int = 2
+) : Sense {
+    override var ticksUntilNextExecution: Int = 10
+    override val memories: Set<MemoryModuleType<*>> = setOf(CobblemonMemories.BATTLING_POKEMON)
+
+    override fun merge(other: Sense): Boolean {
+        if (other is BattlingPokemonSense) {
+            this.cooldownTicks = minOf(this.cooldownTicks, other.cooldownTicks)
+            return true
+        } else {
+            return false
+        }
+    }
+
+    override fun tick(entity: LivingEntity, brain: BiggerBrain) {
+        val battles = when (entity) {
+            is PokemonEntity -> entity.battleId?.let { BattleRegistry.getBattle(it) }?.let { listOf(it) } ?: emptyList()
+            is NPCEntity -> entity.battleIds.mapNotNull(BattleRegistry::getBattle)
+            else -> emptyList()
+        }
+
+        val entityUUIDs = if (entity is PokemonEntity) { // Pokemon can look at opponents, never allies
+            battles.flatMap { battle ->
+                val actor = battle.getActor(entity)
+                if (actor != null) {
+                    actor.getSide().getOppositeSide().activePokemon.mapNotNull { it.battlePokemon?.entity?.uuid }
+                } else {
+                    emptyList()
+                }
+            }
+        } else if (entity is NPCEntity) { // NPCs can look at any of the pokemon in play
+            battles.flatMap { it.activePokemon }.mapNotNull { it.battlePokemon?.entity?.uuid }
+        } else {
+            emptyList()
+        }
+
+        brain.setMemory(CobblemonMemories.BATTLING_POKEMON, entityUUIDs)
+        if (entityUUIDs.isEmpty() && entity is PokemonEntity) {
+            brain.eraseMemoryIfPresent(CobblemonMemories.TARGETED_BATTLE_POKEMON)
+        }
+
+        ticksUntilNextExecution = cooldownTicks
+    }
+
+    class Config : SenseConfig {
+        var cooldownTicks: ExpressionOrEntityVariable = Either.left("2".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 BattlingPokemonSense(cooldownTicks = cooldownTicks)
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/sense/BeeHiveSense.kt

@@ -0,0 +1,159 @@
+/*
+ * 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.mojang.datafixers.util.Either
+import net.minecraft.core.BlockPos
+import net.minecraft.core.Direction
+import net.minecraft.server.level.ServerLevel
+import net.minecraft.tags.PoiTypeTags
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.ai.village.poi.PoiManager
+import net.minecraft.world.entity.ai.village.poi.PoiRecord
+import net.minecraft.world.level.Level
+import net.minecraft.world.level.block.Blocks
+import net.minecraft.world.level.block.entity.BeehiveBlockEntity
+import net.minecraft.world.level.block.entity.BlockEntity
+import net.minecraft.world.level.block.state.BlockState
+
+class BeeHiveSense(
+    private var cooldownTicks: Int = SCAN_INTERVAL
+) : Sense {
+    override var ticksUntilNextExecution: Int = cooldownTicks
+    override val memories = setOf(
+        CobblemonMemories.HIVE_LOCATION,
+        CobblemonMemories.HIVE_BLACKLIST,
+    )
+
+    override fun merge(other: Sense): Boolean {
+        if (other is BeeHiveSense) {
+            this.cooldownTicks = minOf(this.cooldownTicks, other.cooldownTicks)
+            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 brain = entity.brain
+        val currentHive = brain.getMemory(CobblemonMemories.HIVE_LOCATION).orElse(null)
+
+        if (currentHive != null) {
+            val state = world.getBlockState(currentHive)
+
+            if (!isValidHive(state) || !hasReachableAdjacentSide(world, currentHive)) {
+                brain.eraseMemory(CobblemonMemories.HIVE_LOCATION)
+            } else {
+                return // We already have a valid hive, no need to search for another
+            }
+        }
+
+        var closestHivePos: BlockPos? = null
+
+        val list = findNearbyHivesWithSpace(entity)
+
+        if (!list.isEmpty()) {
+            val blackList = brain.getMemory(CobblemonMemories.HIVE_BLACKLIST).orElse(emptyList())
+            for (blockPos in list) {
+                if (blackList.contains(blockPos)) continue
+                if (hasReachableAdjacentSide(world, blockPos)) {
+                    closestHivePos = blockPos
+                    break
+                }
+            }
+            if (closestHivePos == null) {
+                brain.eraseMemory(CobblemonMemories.HIVE_BLACKLIST)
+                closestHivePos = list.first()
+            }
+        }
+
+        if (closestHivePos != null) {
+            brain.setMemory(CobblemonMemories.HIVE_LOCATION, closestHivePos)
+        }
+    }
+
+    private fun isValidHive(state: BlockState): Boolean {
+        return isHiveBlock(state)
+    }
+
+
+    private fun isHiveBlock(state: BlockState): Boolean {
+        return state.`is`(Blocks.BEEHIVE) || state.`is`(Blocks.BEE_NEST)
+    }
+
+    private fun hasReachableAdjacentSide(world: ServerLevel, pos: BlockPos): Boolean {
+        for (dir in Direction.entries) {
+            val adjacentPos = pos.relative(dir)
+            if (world.isEmptyBlock(adjacentPos)) {
+                return true
+            }
+        }
+        return false
+    }
+
+    private fun findNearbyHivesWithSpace(entity: PokemonEntity): List<BlockPos> {
+        val blockPos = entity.blockPosition()
+        val poiManager = (entity.level() as ServerLevel).poiManager
+        val stream = poiManager.getInRange(
+            { holder -> holder.`is`(PoiTypeTags.BEE_HOME) },
+            blockPos,
+            20,
+            PoiManager.Occupancy.ANY
+        )
+        return stream
+            .map(PoiRecord::getPos)
+            .filter { pos -> doesHiveHaveSpace(pos, entity.level()) }
+            .sorted { pos1, pos2 -> pos1.distSqr(blockPos).toInt() - pos2.distSqr(blockPos).toInt() }
+            .toList()
+    }
+
+    private fun doesHiveHaveSpace(hivePos: BlockPos, world: Level): Boolean {
+        val blockEntity: BlockEntity? = world.getBlockEntity(hivePos)
+        if (blockEntity is BeehiveBlockEntity) {
+            return !blockEntity.isFull
+        } else {
+            return false
+        }
+    }
+
+    class Config : SenseConfig {
+        var condition: ExpressionOrEntityVariable = Either.left("true".asExpression())
+        var cooldownTicks: ExpressionOrEntityVariable = Either.left("40".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 BeeHiveSense(
+                cooldownTicks = cooldownTicks
+            )
+        }
+    }
+
+    companion object {
+        const val SCAN_INTERVAL = 40
+    }
+
+
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/sense/DrowsySense.kt

@@ -0,0 +1,91 @@
+/*
+ * 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.pokemon.status.Statuses
+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
+
+/**
+ * Senses when the Pokémon is in a situation that would make it ready to sleep.
+ * Either by choice (nighttime) or by force (battle/spawning with sleep status)
+ *
+ * @author Hiroku
+ * @since March 23rd, 2024
+ */
+class DrowsySense(
+    var cooldownTicks: Int = 20
+) : Sense {
+    override var ticksUntilNextExecution: Int = 20
+    override val memories = setOf(CobblemonMemories.POKEMON_DROWSY)
+
+    override fun merge(other: Sense): Boolean {
+        if (other is DrowsySense) {
+            this.cooldownTicks = minOf(this.cooldownTicks, other.cooldownTicks)
+            return true
+        } else {
+            return false
+        }
+    }
+
+    override fun tick(entity: LivingEntity, brain: BiggerBrain) {
+        if (entity !is PokemonEntity) {
+            return
+        }
+
+        val world = entity.level()
+        val rest = entity.behaviour.resting
+        val isDrowsy = brain.getMemory(CobblemonMemories.POKEMON_DROWSY) ?: false
+        val hurtLately = brain.hasMemoryValue(MemoryModuleType.HURT_BY)
+        val shouldBeDrowsy = rest.canSleep && !hurtLately && (world.dayTime.toInt() % 24000) in rest.times && !brain.hasMemoryValue(MemoryModuleType.ANGRY_AT)
+        val forcedAsleep = entity.pokemon.status?.status == Statuses.SLEEP
+
+        if (entity.isBattling) {
+            if (!isDrowsy && forcedAsleep) {
+                brain.setMemory(CobblemonMemories.POKEMON_DROWSY, true)
+            } else if (isDrowsy && !forcedAsleep) {
+                brain.eraseMemory(CobblemonMemories.POKEMON_DROWSY)
+            }
+        } else {
+            if (!isDrowsy && shouldBeDrowsy && entity.random.nextFloat() < rest.drowsyChance) {
+                brain.setMemory(CobblemonMemories.POKEMON_DROWSY, true)
+            } else if (isDrowsy && !shouldBeDrowsy) {
+                brain.eraseMemory(CobblemonMemories.POKEMON_DROWSY)
+            } else if (isDrowsy && entity.random.nextFloat() < rest.rouseChance) {
+                brain.eraseMemory(CobblemonMemories.POKEMON_DROWSY)
+            }
+        }
+
+        ticksUntilNextExecution = cooldownTicks
+    }
+
+    class Config : SenseConfig {
+        var cooldownTicks: ExpressionOrEntityVariable = Either.left("20".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 DrowsySense(cooldownTicks = cooldownTicks)
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/sense/FlowerSense.kt

@@ -0,0 +1,134 @@
+/*
+ * 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.distanceTo
+import com.cobblemon.mod.common.util.getMemorySafely
+import com.mojang.datafixers.util.Either
+import net.minecraft.core.BlockPos
+import net.minecraft.core.Direction
+import net.minecraft.core.Vec3i
+import net.minecraft.server.level.ServerLevel
+import net.minecraft.tags.BlockTags
+import net.minecraft.tags.PoiTypeTags
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.ai.village.poi.PoiManager
+import net.minecraft.world.entity.ai.village.poi.PoiRecord
+import net.minecraft.world.level.Level
+import net.minecraft.world.level.block.Blocks
+import net.minecraft.world.level.block.DoublePlantBlock
+import net.minecraft.world.level.block.entity.BeehiveBlockEntity
+import net.minecraft.world.level.block.entity.BlockEntity
+import net.minecraft.world.level.block.state.BlockState
+import net.minecraft.world.level.block.state.properties.BlockStateProperties
+import net.minecraft.world.level.block.state.properties.DoubleBlockHalf
+
+class FlowerSense(
+    private var cooldownTicks: Int = SCAN_INTERVAL
+) : Sense {
+    override var ticksUntilNextExecution: Int = cooldownTicks
+    override val memories = setOf(
+        CobblemonMemories.NEARBY_FLOWER,
+        CobblemonMemories.HAS_NECTAR,
+        )
+
+    override fun merge(other: Sense): Boolean {
+        if (other is FlowerSense) {
+            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 world = entity.level()
+        // Check curr memory
+        val currPos = brain.getMemorySafely(CobblemonMemories.NEARBY_FLOWER).orElse(null)
+        if (currPos != null && isFlower(entity.level().getBlockState(currPos)) && entity.distanceTo(currPos) <= 32) {
+            return
+        }
+
+        val searchRadius = 5
+        val centerPos = entity.blockPosition()
+        var flowerPos: BlockPos? = null
+        var shortestDist = Double.MAX_VALUE
+        BlockPos.betweenClosedStream(
+            centerPos.offset(-searchRadius, -2, -searchRadius),
+            centerPos.offset(searchRadius, 2, searchRadius)
+        ).forEach { pos ->
+            val state = world.getBlockState(pos)
+            if (isFlower(state)) {
+                val distance = pos.distSqr(Vec3i(centerPos.x, centerPos.y, centerPos.z))
+                if (distance < shortestDist) {
+                    flowerPos = BlockPos(pos)
+                    shortestDist = distance
+                }
+            }
+        }
+
+
+        if (flowerPos != null) {
+            brain.setMemory(CobblemonMemories.NEARBY_FLOWER, flowerPos)
+        } else {
+            brain.eraseMemory(CobblemonMemories.NEARBY_FLOWER)
+        }
+    }
+
+    private fun isFlower(state: BlockState): Boolean {
+        // Borrowed from Bee.class
+        if (state.hasProperty(BlockStateProperties.WATERLOGGED) && state.getValue(
+                BlockStateProperties.WATERLOGGED
+            ) as Boolean
+        ) {
+            return false
+        } else if (state.`is`(BlockTags.FLOWERS)) {
+            if (state.`is`(Blocks.SUNFLOWER)) {
+                return state.getValue(DoublePlantBlock.HALF) == DoubleBlockHalf.UPPER
+            } else {
+                return true
+            }
+        } else {
+            return false
+        }
+    }
+
+    class Config : SenseConfig {
+        var condition: ExpressionOrEntityVariable = Either.left("true".asExpression())
+        var cooldownTicks: ExpressionOrEntityVariable = Either.left("40".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 FlowerSense(
+                cooldownTicks = cooldownTicks
+            )
+        }
+    }
+
+    companion object {
+        const val SCAN_INTERVAL = 40
+    }
+
+
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/sense/HurtBySense.kt

@@ -0,0 +1,92 @@
+/*
+ * 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.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.distraction.HurtDistraction
+import com.cobblemon.mod.common.api.ai.config.sense.SenseConfig
+import com.cobblemon.mod.common.api.ai.resolveInt
+import com.cobblemon.mod.common.util.asExpression
+import com.mojang.datafixers.util.Either
+import net.minecraft.world.damagesource.DamageSource
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.ai.memory.MemoryModuleType
+
+/**
+ * Maintains memory of the last entity that hurt this entity.
+ *
+ * @author Hiroku
+ * @since December 29th, 2025
+ */
+class HurtBySense(
+    var cooldownTicks: Int = 2
+) : Sense {
+    var lastDamageSource: DamageSource? = null
+
+    override var ticksUntilNextExecution: Int = 1
+    override val memories = setOf(MemoryModuleType.HURT_BY, MemoryModuleType.HURT_BY_ENTITY)
+
+    override fun merge(other: Sense): Boolean {
+        if (other is HurtBySense) {
+            this.cooldownTicks = minOf(this.cooldownTicks, other.cooldownTicks)
+            return true
+        } else {
+            return false
+        }
+    }
+
+    override fun tick(entity: LivingEntity, brain: BiggerBrain) {
+        val damageSource = entity.lastDamageSource
+        if (damageSource === lastDamageSource) {
+            ticksUntilNextExecution = cooldownTicks
+            return
+        }
+
+        if (damageSource != null) {
+            brain.setMemory(MemoryModuleType.HURT_BY, entity.lastDamageSource)
+            val attacker = damageSource.entity
+            if (attacker is LivingEntity) {
+                brain.setMemory(MemoryModuleType.HURT_BY_ENTITY, attacker)
+            }
+        } else {
+            brain.eraseMemoryIfPresent(MemoryModuleType.HURT_BY)
+        }
+
+        // so apparently it remembers the entity that hurt them even if it was forever ago? fair enough I guess. that's vanilla for you.
+        brain.getMemory(MemoryModuleType.HURT_BY_ENTITY)?.let { livingEntity ->
+            if (!livingEntity.isAlive || livingEntity.level() != entity.level()) {
+                brain.eraseMemory(MemoryModuleType.HURT_BY_ENTITY)
+            }
+        }
+
+        if (damageSource != null && lastDamageSource !== damageSource) {
+            lastDamageSource = damageSource
+            brain.distract(HurtDistraction(damageSource))
+        }
+
+        ticksUntilNextExecution = cooldownTicks
+    }
+
+    class Config : SenseConfig {
+        var cooldownTicks: ExpressionOrEntityVariable = Either.left("2".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 HurtBySense(cooldownTicks = cooldownTicks)
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/sense/JukeboxSense.kt

@@ -0,0 +1,109 @@
+/*
+ * 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.bedrockk.molang.Expression
+import com.cobblemon.mod.common.CobblemonPoiTypes
+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.sense.SenseConfig
+import com.cobblemon.mod.common.api.ai.resolveDouble
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.net.messages.client.animation.PlayPosableAnimationPacket
+import com.cobblemon.mod.common.util.asExpression
+import com.cobblemon.mod.common.util.resolveBoolean
+import com.mojang.datafixers.util.Either
+import net.minecraft.core.Holder
+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.village.poi.PoiManager
+import net.minecraft.world.entity.ai.village.poi.PoiType
+import net.minecraft.world.level.block.Blocks
+import net.minecraft.world.level.block.entity.JukeboxBlockEntity
+
+/**
+ * Senses nearby jukeboxes that are currently playing music.
+ *
+ */
+class JukeboxSense(
+    var condition: Expression,
+    var radiusXZ: Double = 16.0,
+    var radiusY: Double = 16.0,
+    var cooldownTicks: Int = 20 * 5
+) : Sense {
+    override var ticksUntilNextExecution: Int = 50
+    override val memories = setOf(MemoryModuleType.DANCING)
+
+    override fun merge(other: Sense): Boolean {
+        if (other is JukeboxSense) {
+            this.condition = other.condition
+            this.cooldownTicks = minOf(this.cooldownTicks, other.cooldownTicks)
+            this.radiusXZ = other.radiusXZ
+            this.radiusY = other.radiusY
+            return true
+        } else {
+            return false
+        }
+    }
+
+    override fun tick(entity: LivingEntity, brain: BiggerBrain) {
+
+        ticksUntilNextExecution = cooldownTicks
+        if (!brain.runtime.resolveBoolean(condition)) {
+            return
+        }
+        val world = entity.level()
+        val poiManager = (entity.level() as ServerLevel).poiManager
+        val jukeboxPositions = poiManager.findAll(
+            { holder: Holder<PoiType> -> holder.`is`(CobblemonPoiTypes.JUKEBOX_KEY) },
+            { true },
+            entity.blockPosition(),
+            10,
+            PoiManager.Occupancy.ANY
+        ).toList()
+
+        val jukeboxPos = jukeboxPositions.firstOrNull() { blockPos ->
+            if (world.getBlockState(blockPos).block != Blocks.JUKEBOX) return@firstOrNull false
+            val blockEntity =  world.getBlockEntity(blockPos)
+            if (blockEntity !is JukeboxBlockEntity) return@firstOrNull false
+            !blockEntity.theItem.isEmpty
+        }
+        brain.setMemory(MemoryModuleType.DANCING, jukeboxPos != null)
+    }
+
+    class Config : SenseConfig {
+        var condition: ExpressionOrEntityVariable = Either.left("true".asExpression())
+        var radiusXZ: ExpressionOrEntityVariable = Either.left("16.0".asExpression())
+        var radiusY: ExpressionOrEntityVariable = Either.left("16.0".asExpression())
+        var cooldownTicks: ExpressionOrEntityVariable = Either.left("60".asExpression())
+
+        override fun getVariables(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ) = listOf(
+            condition,
+            radiusXZ,
+            radiusY,
+            cooldownTicks
+        ).asVariables()
+
+        override fun create(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): Sense {
+            return JukeboxSense(
+                condition = condition.asSimplifiedExpression(entity),
+                radiusXZ = radiusXZ.resolveDouble(behaviourConfigurationContext.runtime),
+                radiusY = radiusY.resolveDouble(behaviourConfigurationContext.runtime),
+                cooldownTicks = cooldownTicks.resolveDouble(behaviourConfigurationContext.runtime).toInt()
+            )
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/sense/NPCBattlingSense.kt

@@ -0,0 +1,72 @@
+/*
+ * 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.npc.NPCEntity
+import com.cobblemon.mod.common.util.asExpression
+import com.mojang.datafixers.util.Either
+import net.minecraft.world.entity.LivingEntity
+
+/**
+ * A sense that checks if an NPC is currently in a battle. Maintains the NPC_BATTLING memory.
+ *
+ * @author Hiroku
+ * @since December 29th, 2025
+ */
+class NPCBattlingSense(
+    var cooldownTicks: Int = 10
+) : Sense {
+    override var ticksUntilNextExecution: Int = 20
+    override val memories = setOf(CobblemonMemories.NPC_BATTLING)
+
+    override fun merge(other: Sense): Boolean {
+        if (other is NPCBattlingSense) {
+            this.cooldownTicks = minOf(this.cooldownTicks, other.cooldownTicks)
+            return true
+        } else {
+            return false
+        }
+    }
+
+    override fun tick(entity: LivingEntity, brain: BiggerBrain) {
+        if (entity !is NPCEntity) {
+            return // Surely they didn't put this on a non-NPC
+        }
+
+        val isBattling = entity.isInBattle()
+        if (isBattling) {
+            brain.setMemoryIfChanged(CobblemonMemories.NPC_BATTLING, value = true)
+        } else {
+            brain.eraseMemoryIfPresent(CobblemonMemories.NPC_BATTLING)
+        }
+
+        ticksUntilNextExecution = cooldownTicks
+    }
+
+    class Config : SenseConfig {
+        var cooldownTicks: ExpressionOrEntityVariable = Either.left("2".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 NPCBattlingSense(cooldownTicks = cooldownTicks)
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/sense/NearbyEntitiesSense.kt

@@ -0,0 +1,93 @@
+/*
+ * 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.bedrockk.molang.Expression
+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.sense.SenseConfig
+import com.cobblemon.mod.common.api.ai.resolveDouble
+import com.cobblemon.mod.common.util.asExpression
+import com.cobblemon.mod.common.util.resolveBoolean
+import com.mojang.datafixers.util.Either
+import java.util.function.Predicate
+import java.util.function.ToDoubleFunction
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.ai.memory.MemoryModuleType
+import net.minecraft.world.entity.ai.memory.NearestVisibleLivingEntities
+
+/**
+ * Senses nearby entities. Maintains the NEAREST_LIVING_ENTITIES and NEAREST_VISIBLE_LIVING_ENTITIES memories.
+ *
+ * @author Hiroku
+ * @since December 29th, 2025
+ */
+class NearbyEntitiesSense(
+    var condition: Expression,
+    var radiusXZ: Double = 16.0,
+    var radiusY: Double = 16.0,
+    var cooldownTicks: Int = 20 * 5
+) : Sense {
+    override var ticksUntilNextExecution: Int = 50
+    override val memories = setOf(MemoryModuleType.NEAREST_LIVING_ENTITIES, MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES)
+
+    override fun merge(other: Sense): Boolean {
+        if (other is NearbyEntitiesSense) {
+            this.condition = other.condition
+            this.cooldownTicks = minOf(this.cooldownTicks, other.cooldownTicks)
+            this.radiusXZ = other.radiusXZ
+            this.radiusY = other.radiusY
+            return true
+        } else {
+            return false
+        }
+    }
+
+    override fun tick(entity: LivingEntity, brain: BiggerBrain) {
+        ticksUntilNextExecution = cooldownTicks
+        if (!brain.runtime.resolveBoolean(condition)) {
+            return
+        }
+        val level = entity.level()
+        val aABB = entity.boundingBox.inflate(radiusXZ, radiusY, radiusXZ)
+        val list = level.getEntitiesOfClass(LivingEntity::class.java, aABB, Predicate { it !== entity && it!!.isAlive })
+        list.sortWith(Comparator.comparingDouble(ToDoubleFunction { it.distanceToSqr(entity) }))
+        brain.setMemory(MemoryModuleType.NEAREST_LIVING_ENTITIES, list)
+        brain.setMemory(MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES, NearestVisibleLivingEntities(entity, list))
+    }
+
+    class Config : SenseConfig {
+        var condition: ExpressionOrEntityVariable = Either.left("true".asExpression())
+        var radiusXZ: ExpressionOrEntityVariable = Either.left("16.0".asExpression())
+        var radiusY: ExpressionOrEntityVariable = Either.left("16.0".asExpression())
+        var cooldownTicks: ExpressionOrEntityVariable = Either.left("60".asExpression())
+
+        override fun getVariables(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ) = listOf(
+            condition,
+            radiusXZ,
+            radiusY,
+            cooldownTicks
+        ).asVariables()
+
+        override fun create(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): Sense {
+            return NearbyEntitiesSense(
+                condition = condition.asSimplifiedExpression(entity),
+                radiusXZ = radiusXZ.resolveDouble(behaviourConfigurationContext.runtime),
+                radiusY = radiusY.resolveDouble(behaviourConfigurationContext.runtime),
+                cooldownTicks = cooldownTicks.resolveDouble(behaviourConfigurationContext.runtime).toInt()
+            )
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/sense/PokemonAdultSense.kt

@@ -0,0 +1,107 @@
+/*
+ * 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.bedrockk.molang.Expression
+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.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.resolveBoolean
+import com.mojang.datafixers.util.Either
+import net.minecraft.world.entity.AgeableMob
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.ai.memory.MemoryModuleType
+import net.minecraft.world.entity.ai.memory.NearestVisibleLivingEntities
+
+/**
+ * Senses when the Pokémon is near an adult of the same species. Maintains the NEAREST_VISIBLE_ADULT memory.
+ *
+ * @author broccoli
+ * @since May 15th, 2024
+ */
+class PokemonAdultSense(
+    var condition: Expression,
+    var cooldownTicks: Int = 100
+) : Sense {
+    override var ticksUntilNextExecution: Int = 100
+    override val memories = setOf(MemoryModuleType.NEAREST_VISIBLE_ADULT, MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES)
+
+    override fun merge(other: Sense): Boolean {
+        if (other is PokemonAdultSense) {
+            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 || !brain.runtime.resolveBoolean(condition)) {
+            return
+        }
+
+        brain.getMemory(MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES)?.let { visibleMobs ->
+            setNearestPokemonAdult(entity, visibleMobs, brain)
+        }
+    }
+
+    private fun setNearestPokemonAdult(entity: PokemonEntity, visibleMobs: NearestVisibleLivingEntities, brain: BiggerBrain) {
+        val nearestAdult = visibleMobs.findClosest { mob ->
+            targetIsValidForChild(entity, mob)
+        }.map { mob -> mob as AgeableMob }.orElse(null)
+
+        if (nearestAdult == null && brain.hasMemoryValue(MemoryModuleType.NEAREST_VISIBLE_ADULT)) {
+            brain.eraseMemory(MemoryModuleType.NEAREST_VISIBLE_ADULT)
+        } else if (nearestAdult != null && brain.getMemory(MemoryModuleType.NEAREST_VISIBLE_ADULT) != nearestAdult) {
+            brain.setMemory(MemoryModuleType.NEAREST_VISIBLE_ADULT, nearestAdult)
+        }
+    }
+
+    private fun targetIsValidForChild(child: PokemonEntity, entity: LivingEntity): Boolean {
+        val potentialParent = entity as? PokemonEntity ?: return false
+        val childSpecies = child.pokemon.species.resourceIdentifier
+
+        var preEvolution = potentialParent.pokemon.preEvolution
+
+        while (preEvolution != null) {
+            if (childSpecies == preEvolution.species.resourceIdentifier) {
+                return true
+            }
+
+            preEvolution = preEvolution.species.preEvolution
+        }
+
+        return false
+    }
+
+    class Config : SenseConfig {
+        var condition: ExpressionOrEntityVariable = Either.left("true".asExpression())
+        var cooldownTicks: ExpressionOrEntityVariable = Either.left("40".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 PokemonAdultSense(
+                condition = condition.asSimplifiedExpression(entity),
+                cooldownTicks = cooldownTicks
+            )
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/sense/PokemonItemSense.kt

@@ -0,0 +1,130 @@
+/*
+ * 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.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.sense.SenseConfig
+import com.cobblemon.mod.common.api.ai.resolveDouble
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.pokemon.ai.ObtainableItem
+import com.cobblemon.mod.common.util.asExpression
+import com.cobblemon.mod.common.util.findMatchingEntry
+import com.cobblemon.mod.common.util.getMemorySafely
+import com.cobblemon.mod.common.util.getObjectList
+import com.cobblemon.mod.common.util.resolveBoolean
+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.item.ItemEntity
+import net.minecraft.world.level.GameRules
+import java.util.Optional
+
+/**
+ * Senses nearby item entities. Returns the closest item that the Pokemon would desire to pickup.
+ *
+ * @author JazzMcNade
+ * @since February 15th, 2026
+ */
+class PokemonItemSense(
+    var condition: Expression,
+    var radiusXZ: Double = 16.0,
+    var radiusY: Double = 16.0,
+    var cooldownTicks: Int = 20 * 5
+) : Sense {
+    override var ticksUntilNextExecution: Int = 50
+    override val memories =
+        setOf(MemoryModuleType.NEAREST_VISIBLE_WANTED_ITEM, CobblemonMemories.DISABLE_WALK_TO_WANTED_ITEM)
+
+    override fun merge(other: Sense): Boolean {
+        if (other is PokemonItemSense) {
+            this.condition = other.condition
+            this.cooldownTicks = minOf(this.cooldownTicks, other.cooldownTicks)
+            this.radiusXZ = other.radiusXZ
+            this.radiusY = other.radiusY
+            return true
+        } else {
+            return false
+        }
+    }
+
+    override fun tick(entity: LivingEntity, brain: BiggerBrain) {
+        ticksUntilNextExecution = cooldownTicks
+        if (entity !is PokemonEntity || !brain.runtime.resolveBoolean(condition)) {
+            return
+        }
+        val world = entity.level()
+        if (!world.gameRules.getBoolean(GameRules.RULE_MOBGRIEFING) || !entity.pokemon.canDropHeldItem || entity.brain.getMemorySafely(
+                CobblemonMemories.DISABLE_WALK_TO_WANTED_ITEM
+            ).orElse(false)
+        ) {
+            // Mob griefing is disabled, the Pokemon cannot swap out its item, or it's exhausted from attempting to go to an unreachable item
+            // so don't bother to search
+            return
+        }
+
+        val pickupItems = entity.config.getObjectList<ObtainableItem>(PICKUP_ITEMS)
+        val heldItemValue =
+            pickupItems.findMatchingEntry(entity.registryAccess(), entity.pokemon.heldItem())?.pickupPriority ?: 0
+        if (heldItemValue >= (pickupItems.maxOfOrNull { it.pickupPriority } ?: 0)) {
+            // It's already holding the highest value item it can have, no need to look for better.
+            return
+        }
+
+        val list = world.getEntitiesOfClass(
+            ItemEntity::class.java,
+            entity.boundingBox.inflate(radiusXZ, radiusY, radiusXZ)
+        ) {
+            (pickupItems.findMatchingEntry(entity.registryAccess(), it.item)?.pickupPriority ?: 0) > heldItemValue
+                    && entity.hasLineOfSight(it)
+        }
+
+        // Find the closest item to the entity
+        val nearestItemEntity = list.minByOrNull { it.distanceTo(entity) }
+        entity.getBrain()
+            .setMemory(MemoryModuleType.NEAREST_VISIBLE_WANTED_ITEM, Optional.ofNullable(nearestItemEntity))
+    }
+
+
+    class Config : SenseConfig {
+        var condition: ExpressionOrEntityVariable = Either.left("true".asExpression())
+        var radiusXZ: ExpressionOrEntityVariable = Either.left("16.0".asExpression())
+        var radiusY: ExpressionOrEntityVariable = Either.left("16.0".asExpression())
+        var cooldownTicks: ExpressionOrEntityVariable = Either.left("60".asExpression())
+
+        override fun getVariables(
+            entity: LivingEntity,
+            behaviourConfigurationContext: BehaviourConfigurationContext
+        ) = listOf(
+            condition,
+            radiusXZ,
+            radiusY,
+            cooldownTicks
+        ).asVariables()
+
+        override fun create(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext): Sense {
+            return PokemonItemSense(
+                condition = condition.asSimplifiedExpression(entity),
+                radiusXZ = radiusXZ.resolveDouble(behaviourConfigurationContext.runtime),
+                radiusY = radiusY.resolveDouble(behaviourConfigurationContext.runtime),
+                cooldownTicks = cooldownTicks.resolveDouble(behaviourConfigurationContext.runtime).toInt()
+            )
+        }
+    }
+
+    companion object {
+        const val PICKUP_ITEMS = "pickup_items"
+    }
+
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/sense/SaccLeafSense.kt

@@ -0,0 +1,131 @@
+/*
+ * 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.block.SaccharineLeafBlock
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+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.Direction
+import net.minecraft.core.Vec3i
+import net.minecraft.server.level.ServerLevel
+import net.minecraft.tags.PoiTypeTags
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.ai.village.poi.PoiManager
+import net.minecraft.world.entity.ai.village.poi.PoiRecord
+import net.minecraft.world.level.Level
+import net.minecraft.world.level.block.Blocks
+import net.minecraft.world.level.block.entity.BeehiveBlockEntity
+import net.minecraft.world.level.block.entity.BlockEntity
+import net.minecraft.world.level.block.state.BlockState
+import net.minecraft.world.level.block.state.properties.BlockStateProperties
+
+class SaccLeafSense(
+    private var cooldownTicks: Int = SCAN_INTERVAL
+) : Sense {
+    override var ticksUntilNextExecution: Int = cooldownTicks
+    override val memories = setOf(
+        CobblemonMemories.NEARBY_SACC_LEAVES,
+    )
+
+    override fun merge(other: Sense): Boolean {
+        if (other is SaccLeafSense) {
+            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 = 7
+        val tooFarDistance = 30
+        val wayTooFarDistance = 64
+        val currPos: BlockPos? = brain.getMemorySafely(CobblemonMemories.NEARBY_SACC_LEAVES).orElse(null)
+
+        if (currPos != null && isValidLeafBlock(entity.level().getBlockState(currPos))) {
+            val distance = entity.distanceTo(currPos)
+            if (distance <= tooFarDistance) {
+                return
+            } else if (distance > wayTooFarDistance) {
+                brain.eraseMemory(CobblemonMemories.NEARBY_SACC_LEAVES)
+            }
+        }
+
+        val centerPos = entity.blockPosition()
+        var leavesPos: BlockPos? = null
+        var shortestDist = Double.MAX_VALUE
+        val world = entity.level()
+        BlockPos.betweenClosedStream(
+            centerPos.offset(-searchRadius, -2, -searchRadius),
+            centerPos.offset(searchRadius, searchRadius, searchRadius)
+        ).forEach { pos ->
+            val state = world.getBlockState(pos)
+            if (isValidLeafBlock(state)) {
+                val distance = pos.distSqr(Vec3i(centerPos.x, centerPos.y, centerPos.z))
+                if (distance < shortestDist) {
+                    leavesPos = BlockPos(pos)
+                    shortestDist = distance
+                }
+            }
+        }
+
+        if (leavesPos != null) {
+            brain.setMemory(CobblemonMemories.NEARBY_SACC_LEAVES, leavesPos)
+        } else {
+            brain.eraseMemory(CobblemonMemories.NEARBY_SACC_LEAVES)
+        }
+    }
+
+    private fun isValidLeafBlock(state: BlockState): Boolean {
+        if (state.block !is SaccharineLeafBlock) return false
+        if (state.hasProperty(BlockStateProperties.WATERLOGGED) && state.getValue(
+                BlockStateProperties.WATERLOGGED
+            ) as Boolean
+        ) {
+            return false
+        }
+        return state.getValue(SaccharineLeafBlock.AGE) != SaccharineLeafBlock.MAX_AGE
+    }
+
+    class Config : SenseConfig {
+        var condition: ExpressionOrEntityVariable = Either.left("true".asExpression())
+        var cooldownTicks: ExpressionOrEntityVariable = Either.left("40".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 SaccLeafSense(
+                cooldownTicks = cooldownTicks
+            )
+        }
+    }
+
+    companion object {
+        const val SCAN_INTERVAL = 40
+    }
+
+
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/sense/Sense.kt

@@ -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.api.ai.biggerbrain.sense
+
+import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
+import com.cobblemon.mod.common.util.cobblemonResource
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.ai.memory.MemoryModuleType
+
+/**
+ * A sense that an entity can use to gather information and store it in its brain's memory. This is an analog to a
+ * Minecraft SensorType. Unlike SensorTypes, Senses are instantiated per entity and can handle cooldowns in a more
+ * bespoke way. The remaining cooldown time is something that is set by the sense itself rather than it being forced,
+ * so the cooldown can differ.
+ *
+ * @author Hiroku
+ * @since December 29th, 2025
+ */
+interface Sense {
+    companion object {
+        val types = mutableMapOf(
+            cobblemonResource("battling_pokemon") to BattlingPokemonSense::class.java,
+            cobblemonResource("drowsy") to DrowsySense::class.java,
+            cobblemonResource("nearby_entities") to NearbyEntitiesSense::class.java,
+            cobblemonResource("npc_battling") to NPCBattlingSense::class.java,
+            cobblemonResource("pokemon_adult") to PokemonAdultSense::class.java,
+            cobblemonResource("hurt_by") to HurtBySense::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,
+            )
+    }
+
+    /** The ticks until it will next be ticked. This is also displayed in the debug overlay. */
+    var ticksUntilNextExecution: Int
+
+    /** The set of memories that this sense may write to or read from. This ensures they are registered in the brain. */
+    val memories: Set<MemoryModuleType<*>>
+
+    /** Performs the sensing logic. Alter [ticksUntilNextExecution] to apply a cooldown if necessary. */
+    fun tick(entity: LivingEntity, brain: BiggerBrain)
+
+    /** Attempts to merge the [other] Sense into this one. Returns true if it was merged and therefore should not be added to the brain separately. */
+    fun merge(other: Sense): Boolean
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/biggerbrain/sense/SweetBerryBushSense.kt

@@ -0,0 +1,109 @@
+/*
+ * 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.core.BlockPos
+import net.minecraft.server.level.ServerLevel
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.level.block.Blocks
+import net.minecraft.world.level.block.CaveVines
+import net.minecraft.world.level.block.SweetBerryBushBlock
+import net.minecraft.world.level.block.state.BlockState
+import java.util.Optional
+
+class SweetBerryBushSense(
+    private var cooldownTicks: Int = SCAN_INTERVAL
+) : Sense {
+    override var ticksUntilNextExecution: Int = SCAN_INTERVAL
+    override val memories = setOf(
+        CobblemonMemories.NEARBY_SWEET_BERRY_BUSH,
+        CobblemonMemories.DISABLE_WALK_TO_BERRY_BUSH,
+    )
+
+    override fun merge(other: Sense): Boolean {
+        if (other is SweetBerryBushSense) {
+            this.cooldownTicks = minOf(this.cooldownTicks, other.cooldownTicks)
+            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
+
+        entity.brain.getMemorySafely(CobblemonMemories.DISABLE_WALK_TO_BERRY_BUSH).orElse(false) ?: return
+
+        val nearestBush = findNearestBush(world, entity.blockPosition())
+
+        if (!nearestBush.isEmpty) {
+            entity.brain.setMemory(CobblemonMemories.NEARBY_SWEET_BERRY_BUSH, nearestBush)
+        } else {
+            entity.brain.eraseMemory(CobblemonMemories.NEARBY_SWEET_BERRY_BUSH)
+        }
+    }
+
+    private fun findNearestBush(level: ServerLevel, origin: BlockPos): Optional<BlockPos> {
+        var closest: BlockPos? = null
+        var closestDistSq = Double.MAX_VALUE
+
+        for (pos in BlockPos.betweenClosed(origin.offset(-SCAN_RADIUS_HORIZONTAL, 1 - SCAN_RADIUS_VERTICAL, -SCAN_RADIUS_HORIZONTAL),
+            origin.offset(SCAN_RADIUS_HORIZONTAL, SCAN_RADIUS_VERTICAL - 1, SCAN_RADIUS_HORIZONTAL))) {
+            val state: BlockState = level.getBlockState(pos)
+            if ((state.`is`(Blocks.SWEET_BERRY_BUSH) && state.getValue(SweetBerryBushBlock.AGE) >= 2)
+                || (CaveVines.hasGlowBerries(state))) {
+                val distSq = pos.distSqr(origin)
+                if (distSq < closestDistSq) {
+                    closest = pos.immutable()
+                    closestDistSq = distSq
+                }
+            }
+        }
+
+        return Optional.ofNullable(closest)
+    }
+
+    class Config : SenseConfig {
+        var condition: ExpressionOrEntityVariable = Either.left("true".asExpression())
+        var cooldownTicks: ExpressionOrEntityVariable = Either.left("40".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 SweetBerryBushSense(
+//                condition = condition.asSimplifiedExpression(entity),
+                cooldownTicks = cooldownTicks
+            )
+        }
+    }
+
+    companion object {
+        const val SCAN_RADIUS_HORIZONTAL = 10
+        const val SCAN_RADIUS_VERTICAL = 1
+        const val SCAN_INTERVAL = 40
+    }
+
+
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/config/AddObjectivesConfig.kt

@@ -0,0 +1,43 @@
+/*
+ * 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
+
+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.config.objective.ObjectiveConfig
+import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
+import com.cobblemon.mod.common.util.asExpression
+import com.mojang.datafixers.util.Either
+import net.minecraft.world.entity.LivingEntity
+
+class AddObjectivesConfig : BehaviourConfig {
+    val condition: ExpressionOrEntityVariable = Either.left("true".asExpression())
+    val objectivesByPriority: Map<Int, List<ObjectiveConfig>> = mapOf()
+
+    override fun getVariables(
+        entity: LivingEntity,
+        behaviourConfigurationContext: BehaviourConfigurationContext
+    ): List<MoLangConfigVariable> {
+       return listOf(condition).asVariables() + objectivesByPriority
+           .values
+           .flatten()
+           .flatMap { it.getVariables(entity, behaviourConfigurationContext) }
+    }
+
+    override fun configure(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext){
+        if (!checkCondition(behaviourConfigurationContext, condition)) return
+
+        for ((priority, objectiveConfigs) in objectivesByPriority) {
+            val objectives = objectiveConfigs.mapNotNull { it.create(entity, behaviourConfigurationContext) }
+            val priorityObjectives = behaviourConfigurationContext.objectives.getOrPut(priority) { mutableListOf() }
+            priorityObjectives.addAll(objectives)
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/config/AddSensesConfig.kt

@@ -0,0 +1,40 @@
+/*
+ * 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
+
+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.config.sense.SenseConfig
+import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
+import com.cobblemon.mod.common.util.asExpression
+import com.mojang.datafixers.util.Either
+import net.minecraft.world.entity.LivingEntity
+
+class AddSensesConfig : BehaviourConfig {
+    val condition: ExpressionOrEntityVariable = Either.left("true".asExpression())
+    val senses: List<SenseConfig> = listOf()
+
+    override fun getVariables(
+        entity: LivingEntity,
+        behaviourConfigurationContext: BehaviourConfigurationContext
+    ): List<MoLangConfigVariable> {
+        return listOf(condition).asVariables() + senses.flatMap { it.getVariables(entity, behaviourConfigurationContext) }
+    }
+
+    override fun configure(
+        entity: LivingEntity,
+        behaviourConfigurationContext: BehaviourConfigurationContext
+    ) {
+        if (!checkCondition(behaviourConfigurationContext, condition)) {
+            return
+        }
+        behaviourConfigurationContext.addSenses(senses.mapNotNull { it.create(entity, behaviourConfigurationContext) })
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/config/ApplyBehaviours.kt

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

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/config/BehaviourConfig.kt

@@ -35,9 +35,11 @@ import net.minecraft.world.entity.LivingEntity
  */
 interface BehaviourConfig {
     companion object {
-        val types = mutableMapOf<ResourceLocation, Class<out BehaviourConfig>>(
+        val types = mutableMapOf(
             cobblemonResource("script") to ScriptBehaviourConfig::class.java,
             cobblemonResource("add_tasks_to_activity") to AddTasksToActivity::class.java,
+            cobblemonResource("add_objectives") to AddObjectivesConfig::class.java,
+            cobblemonResource("add_senses") to AddSensesConfig::class.java,
             cobblemonResource("apply_behaviours") to ApplyBehaviours::class.java,
             cobblemonResource("set_default_activity") to SetDefaultActivity::class.java,
             cobblemonResource("set_core_activities") to SetCoreActivities::class.java,

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/config/objective/ObjectiveConfig.kt

@@ -0,0 +1,66 @@
+/*
+ * 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.objective
+
+import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
+import com.cobblemon.mod.common.api.ai.biggerbrain.objective.Dance
+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.GatherNectar
+import com.cobblemon.mod.common.api.ai.biggerbrain.objective.GoToSleep
+import com.cobblemon.mod.common.api.ai.biggerbrain.objective.HarvestSweetBerryBush
+import com.cobblemon.mod.common.api.ai.biggerbrain.objective.Herd
+import com.cobblemon.mod.common.api.ai.biggerbrain.objective.LookAtNearbyEntities
+import com.cobblemon.mod.common.api.ai.biggerbrain.objective.MaintainFluidY
+import com.cobblemon.mod.common.api.ai.biggerbrain.objective.MoveIntoWater
+import com.cobblemon.mod.common.api.ai.biggerbrain.objective.Objective
+import com.cobblemon.mod.common.api.ai.biggerbrain.objective.StayAfloat
+import com.cobblemon.mod.common.api.ai.biggerbrain.objective.StayNearOwner
+import com.cobblemon.mod.common.api.ai.biggerbrain.objective.MoveOutOfWater
+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.PointToSpawn
+import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
+import com.cobblemon.mod.common.util.cobblemonResource
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.world.entity.LivingEntity
+
+interface ObjectiveConfig {
+    companion object {
+        val types: MutableMap<ResourceLocation, Class<out ObjectiveConfig>> = mutableMapOf(
+            cobblemonResource("focus_during_battle") to FocusDuringBattle.Config::class.java,
+            cobblemonResource("look_at_nearby_entities") to LookAtNearbyEntities.Config::class.java,
+            cobblemonResource("stay_near_owner") to StayNearOwner.Config::class.java,
+            cobblemonResource("wander_around") to WanderAround.Config::class.java,
+            cobblemonResource("eat_grass") to EatGrass.Config::class.java,
+            cobblemonResource("herd") to Herd.Config::class.java,
+            cobblemonResource("stay_afloat") to StayAfloat.Config::class.java,
+            cobblemonResource("maintain_fluid_y") to MaintainFluidY.Config::class.java,
+            cobblemonResource("move_out_of_water") to MoveOutOfWater.Config::class.java,
+            cobblemonResource("move_into_water") to MoveIntoWater.Config::class.java,
+            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("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("point_to_spawn") to PointToSpawn.Config::class.java,
+
+            )
+    }
+
+    /** 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?
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/config/sense/SenseConfig.kt

@@ -0,0 +1,56 @@
+/*
+ * 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.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.DrowsySense
+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.JukeboxSense
+import com.cobblemon.mod.common.api.ai.biggerbrain.sense.NPCBattlingSense
+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.Sense
+import com.cobblemon.mod.common.api.ai.biggerbrain.sense.SweetBerryBushSense
+import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
+import com.cobblemon.mod.common.util.cobblemonResource
+import net.minecraft.world.entity.LivingEntity
+
+/**
+ * Creates a [Sense] for an entity.
+ *
+ * @author Hiroku
+ * @since December 29th, 2025
+ */
+interface SenseConfig {
+    companion object {
+        val types = mutableMapOf(
+            cobblemonResource("nearby_entities") to NearbyEntitiesSense.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("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,
+            )
+    }
+
+    /** 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?
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/config/task/DefendOwnerTaskConfig.kt

@@ -9,31 +9,36 @@
 package com.cobblemon.mod.common.api.ai.config.task
 
 import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.CobblemonSensors
 import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
+import com.cobblemon.mod.common.api.ai.WrapperLivingEntityTask
 import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.entity.pokemon.ai.tasks.HarvestSweetBerryBushTask
+import com.cobblemon.mod.common.entity.pokemon.ai.tasks.DefendOwnerTask
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.ai.behavior.BehaviorControl
 import net.minecraft.world.entity.ai.memory.MemoryModuleType
 
-class HarvestSweetBerryBushTaskConfig : SingleTaskConfig {
-    override fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext) = emptyList<MoLangConfigVariable>()
+class DefendOwnerTaskConfig : SingleTaskConfig {
+
+    override fun getVariables(
+        entity: LivingEntity,
+        behaviourConfigurationContext: BehaviourConfigurationContext
+    ): List<MoLangConfigVariable> {
+        return emptyList()
+    }
+
     override fun createTask(
         entity: LivingEntity,
         behaviourConfigurationContext: BehaviourConfigurationContext
     ): BehaviorControl<in LivingEntity>? {
-        if (entity !is PokemonEntity) {
-            return null
-        }
         behaviourConfigurationContext.addMemories(
-            CobblemonMemories.NEARBY_SWEET_BERRY_BUSH,
-            CobblemonMemories.DISABLE_WALK_TO_BERRY_BUSH,
-            CobblemonMemories.TIME_TRYING_TO_REACH_BERRY_BUSH,
-            MemoryModuleType.WALK_TARGET,
-            MemoryModuleType.LOOK_TARGET)
-        behaviourConfigurationContext.addSensors(CobblemonSensors.NEARBY_SWEET_BERRY_BUSH)
-        return HarvestSweetBerryBushTask()
+            MemoryModuleType.ATTACK_TARGET,
+            CobblemonMemories.NEAREST_VISIBLE_ATTACKER,
+        )
+
+        return WrapperLivingEntityTask(
+            DefendOwnerTask.create(),
+            PokemonEntity::class.java
+        )
     }
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/config/task/EatGrassTaskConfig.kt

@@ -49,7 +49,7 @@ class EatGrassTaskConfig : SingleTaskConfig {
             return null
         }
 
-        behaviourConfigurationContext.addMemories(MemoryModuleType.WALK_TARGET, CobblemonMemories.RECENTLY_ATE_GRASS)
+//        behaviourConfigurationContext.addMemories(MemoryModuleType.WALK_TARGET, CobblemonMemories.RECENTLY_ATE_GRASS)
 
         return WrapperLivingEntityTask(
             EatGrassTask(

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/config/task/FindHerdLeaderTaskConfig.kt

@@ -8,7 +8,6 @@
 
 package com.cobblemon.mod.common.api.ai.config.task
 
-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

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/config/task/LookAtBattlingPokemonTaskConfig.kt

@@ -8,7 +8,6 @@
 
 package com.cobblemon.mod.common.api.ai.config.task
 
-import com.bedrockk.molang.runtime.MoLangRuntime
 import com.cobblemon.mod.common.CobblemonMemories
 import com.cobblemon.mod.common.CobblemonSensors
 import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/config/task/MoveToSweetBerryBushTaskConfig.kt

@@ -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.api.ai.config.task
-
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.CobblemonSensors
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.entity.pokemon.ai.tasks.MoveToSweetBerryBushTask
-import net.minecraft.util.valueproviders.UniformInt
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.ai.behavior.BehaviorControl
-import net.minecraft.world.entity.ai.memory.MemoryModuleType
-
-class MoveToSweetBerryBushTaskConfig : SingleTaskConfig {
-    override fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext) = emptyList<MoLangConfigVariable>()
-    override fun createTask(
-        entity: LivingEntity,
-        behaviourConfigurationContext: BehaviourConfigurationContext
-    ): BehaviorControl<in LivingEntity>? {
-        if (entity !is PokemonEntity) {
-            return null
-        }
-        behaviourConfigurationContext.addMemories(CobblemonMemories.NEARBY_SWEET_BERRY_BUSH, CobblemonMemories.DISABLE_WALK_TO_BERRY_BUSH,
-            CobblemonMemories.TIME_TRYING_TO_REACH_BERRY_BUSH, MemoryModuleType.WALK_TARGET, MemoryModuleType.LOOK_TARGET)
-        behaviourConfigurationContext.addSensors(CobblemonSensors.NEARBY_SWEET_BERRY_BUSH)
-        return MoveToSweetBerryBushTask.create(UniformInt.of(0, 10), 0.6f)
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/config/task/PokemonWanderControlTaskConfig.kt

@@ -43,8 +43,6 @@ class PokemonWanderControlTaskConfig : SingleTaskConfig {
                 val wanderControl = entity.brain.getMemorySafely(CobblemonMemories.WANDER_CONTROL).orElse(null)
                     ?: CobblemonWanderControl()
 
-                wanderControl.reset()
-
                 wanderControl.allowLand = (entity.behaviour.moving.walk.canWalk && !entity.behaviour.moving.walk.avoidsLand) || entity.behaviour.moving.fly.canFly
                 wanderControl.allowWater = entity.behaviour.moving.swim.canSwimInWater && !entity.behaviour.moving.swim.avoidsWater
                 wanderControl.allowAir = entity.behaviour.moving.fly.canFly && !entity.behaviour.moving.walk.canWalk

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/config/task/StopTryingToReachSweetBerryBushTaskConfig.kt

@@ -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.api.ai.config.task
-
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.CobblemonSensors
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.entity.pokemon.ai.tasks.StopTryingToReachSweetBerryBushTask
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.ai.behavior.BehaviorControl
-import net.minecraft.world.entity.ai.memory.MemoryModuleType
-
-class StopTryingToReachSweetBerryBushTaskConfig : SingleTaskConfig {
-    override fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext) = emptyList<MoLangConfigVariable>()
-    override fun createTask(
-        entity: LivingEntity,
-        behaviourConfigurationContext: BehaviourConfigurationContext
-    ): BehaviorControl<in LivingEntity>? {
-        if (entity !is PokemonEntity) {
-            return null
-        }
-        behaviourConfigurationContext.addMemories(CobblemonMemories.NEARBY_SWEET_BERRY_BUSH, CobblemonMemories.DISABLE_WALK_TO_BERRY_BUSH,
-            CobblemonMemories.TIME_TRYING_TO_REACH_BERRY_BUSH, MemoryModuleType.WALK_TARGET, MemoryModuleType.LOOK_TARGET)
-        behaviourConfigurationContext.addSensors(CobblemonSensors.NEARBY_SWEET_BERRY_BUSH)
-        return StopTryingToReachSweetBerryBushTask.create(100, 20*15)
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/config/task/StopTryingToReachWantedItemTaskConfig.kt

@@ -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.api.ai.config.task
-
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.CobblemonSensors
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.entity.pokemon.ai.tasks.StopTryingToReachItemTask
-import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.ai.behavior.BehaviorControl
-import net.minecraft.world.entity.ai.memory.MemoryModuleType
-
-class StopTryingToReachWantedItemTaskConfig : SingleTaskConfig {
-    override fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext) = emptyList<MoLangConfigVariable>()
-    override fun createTask(
-        entity: LivingEntity,
-        behaviourConfigurationContext: BehaviourConfigurationContext
-    ): BehaviorControl<in LivingEntity>? {
-        if (entity !is PokemonEntity) {
-            return null
-        }
-        behaviourConfigurationContext.addMemories(MemoryModuleType.NEAREST_VISIBLE_WANTED_ITEM, CobblemonMemories.DISABLE_WALK_TO_WANTED_ITEM,
-            CobblemonMemories.TIME_TRYING_TO_REACH_WANTED_ITEM, MemoryModuleType.WALK_TARGET, MemoryModuleType.LOOK_TARGET)
-        behaviourConfigurationContext.addSensors(CobblemonSensors.POKEMON_NEARBY_WANTED_ITEM)
-        return StopTryingToReachItemTask.create(120, 20*15)
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/config/task/TaskConfig.kt

@@ -105,12 +105,9 @@ interface TaskConfig {
             cobblemonResource("go_to_land") to GoToLandTaskConfig::class.java,
             cobblemonResource("manage_flight_in_battle") to ManageFlightInBattleTaskConfig::class.java,
             cobblemonResource("attack_hostile_mobs") to AttackHostileMobsTaskConfig::class.java,
-            cobblemonResource("move_to_sweet_berry_bush") to MoveToSweetBerryBushTaskConfig::class.java,
-            cobblemonResource("stop_moving_to_sweet_berry_bush") to StopTryingToReachSweetBerryBushTaskConfig::class.java,
-            cobblemonResource("harvest_sweet_berry_bush") to HarvestSweetBerryBushTaskConfig::class.java,
-            cobblemonResource("eat_held_item") to EatHeldItemTaskConfig::class.java,
+            cobblemonResource("defend_owner") to DefendOwnerTaskConfig::class.java,
+//            cobblemonResource("eat_held_item") to EatHeldItemTaskConfig::class.java,
             cobblemonResource("move_to_item") to MoveToItemTaskConfig::class.java,
-            cobblemonResource("stop_moving_to_item") to StopTryingToReachWantedItemTaskConfig::class.java,
             cobblemonResource("pickup_item") to PickUpItemTaskConfig::class.java,
             cobblemonResource("move_into_fluid") to MoveIntoFluidTaskConfig::class.java,
             cobblemonResource("find_herd_leader") to FindHerdLeaderTaskConfig::class.java,

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/config/task/WanderTaskConfig.kt

@@ -17,6 +17,7 @@ import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangV
 import com.cobblemon.mod.common.entity.OmniPathingEntity
 import com.cobblemon.mod.common.entity.ai.CobblemonRandomSurfacePos
 import com.cobblemon.mod.common.entity.ai.CobblemonWalkTarget
+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
@@ -143,13 +144,13 @@ class WanderTaskConfig : SingleTaskConfig {
                     if (wanderChance <= 0 || world.random.nextFloat() > wanderChance) {
                         return@Trigger false
                     }
-                    pathCooldown.setWithExpiry(true, wanderControl.pathCooldownTicks.toLong())
+                    pathCooldown.setWithExpiry(true, 40L)
                     val minimumHeight = minimumHeight.resolveInt(mainThreadRuntime)
                     val maximumHeight = maximumHeight.resolveInt(mainThreadRuntime)
 
                     var attempts = 0
                     var pos: BlockPos? = null
-                    while (attempts++ < wanderControl.maxAttempts && pos == null) {
+                    while (attempts++ < (wanderControl.maxAttempts ?: 4) && pos == null) {
 //                    val targetVec = getLandTarget(entity) ?: return@Trigger true
                         val targetVec = if (maximumHeight != -1) {
                             HoverRandomPos.getPos(
@@ -184,12 +185,18 @@ class WanderTaskConfig : SingleTaskConfig {
 
                         if (targetVec == null) continue
 
+                        // Ignore pathing targets outside of the pasture zone if the pokemon is pastured.
+                        val tethering = (entity as? PokemonEntity)?.tethering
+                        if (tethering?.canRoamTo(BlockPos.containing(targetVec)) == false) {
+                            continue
+                        }
+
                         pos = applyHeightConstraints(
                             pos = BlockPos.containing(targetVec),
                             minimumHeight = minimumHeight,
                             maximumHeight = maximumHeight,
                             world = world
-                        ).takeIf(wanderControl::isSuitable)
+                        )//.takeIf(wanderControl::isSuitable)
                     }
 
                     if (pos == null) {
@@ -201,17 +208,8 @@ class WanderTaskConfig : SingleTaskConfig {
                             pos = pos,
                             speedModifier = speedMultiplier.resolveFloat(mainThreadRuntime),
                             completionRange = 0,
-                            nodeTypeFilter = { nodeType ->
-                                entity.canBreatheUnderwater() || nodeType !in listOf(
-                                    PathType.WATER,
-                                    PathType.WATER_BORDER
-                                )
-                            },
-                            destinationNodeTypeFilter = { nodeType ->
-                                !avoidsTargetingAir || nodeType !in listOf(
-                                    PathType.OPEN
-                                )
-                            }
+                            nodeTypeFilter = { nodeType -> entity.canBreatheUnderwater() || nodeType !in listOf(PathType.WATER, PathType.WATER_BORDER) },
+                            destinationNodeTypeFilter = { nodeType -> !avoidsTargetingAir || nodeType !in listOf(PathType.OPEN) }
                         )
                     )
                     lookTarget.set(BlockPosTracker(pos.toVec3d().add(0.0, entity.eyeHeight.toDouble(), 0.0)))

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/config/task/WaterWanderTaskConfig.kt

@@ -75,7 +75,7 @@ class WaterWanderTaskConfig : SingleTaskConfig {
                     }
 
                     val wanderControl = it.tryGet(wanderControlData).orElse(null) ?: CobblemonWanderControl()
-                    if (!wanderControl.allowWater) {
+                    if (wanderControl.allowWater != true) {
                         return@Trigger false
                     }
 
@@ -85,17 +85,17 @@ class WaterWanderTaskConfig : SingleTaskConfig {
                         return@Trigger false
                     }
 
-                    pathCooldown.setWithExpiry(true, wanderControl.pathCooldownTicks.toLong())
+                    pathCooldown.setWithExpiry(true, 40L)
 
                     var pos: BlockPos? = null
                     var target: Vec3? = null
                     var attempts = 0
 
-                    while (attempts < wanderControl.maxAttempts && pos == null) {
+                    while (attempts < wanderControl.maxAttempts ?: 4 && pos == null) {
                         attempts++
                         target = BehaviorUtils.getRandomSwimmablePos(entity, horizontalRange.resolveInt(mainThreadRuntime), verticalRange.resolveInt(mainThreadRuntime))
                             ?: continue
-                        pos = BlockPos.containing(target).takeIf(wanderControl::isSuitable)
+//                        pos = BlockPos.containing(target).takeIf(wanderControl::isSuitable) im migrating shit
                     }
 
                     if (pos == null || target == null) {

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

@@ -22,18 +22,21 @@ import com.cobblemon.mod.common.api.battles.model.actor.EntityBackedBattleActor
 import com.cobblemon.mod.common.api.battles.model.actor.FleeableBattleActor
 import com.cobblemon.mod.common.api.events.CobblemonEvents
 import com.cobblemon.mod.common.api.events.battles.BattleFledEvent
+import com.cobblemon.mod.common.api.events.battles.BattleFleeAttemptEvent
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.api.net.NetworkPacket
 import com.cobblemon.mod.common.api.pokemon.stats.BattleEvSource
 import com.cobblemon.mod.common.api.storage.party.PlayerPartyStore
 import com.cobblemon.mod.common.api.tags.CobblemonItemTags
 import com.cobblemon.mod.common.api.text.red
+import com.cobblemon.mod.common.api.text.white
 import com.cobblemon.mod.common.api.text.yellow
 import com.cobblemon.mod.common.battles.ActiveBattlePokemon
 import com.cobblemon.mod.common.battles.BattleCaptureAction
 import com.cobblemon.mod.common.battles.BattleFormat
 import com.cobblemon.mod.common.battles.BattleRegistry
 import com.cobblemon.mod.common.battles.BattleSide
+import com.cobblemon.mod.common.battles.FleeAttemptActionResponse
 import com.cobblemon.mod.common.battles.ForfeitActionResponse
 import com.cobblemon.mod.common.battles.actor.PlayerBattleActor
 import com.cobblemon.mod.common.battles.dispatch.BattleDispatch
@@ -48,7 +51,9 @@ import com.cobblemon.mod.common.entity.npc.NPCBattleActor
 import com.cobblemon.mod.common.entity.npc.NPCEntity
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.net.messages.client.battle.BattleEndPacket
+import com.cobblemon.mod.common.net.messages.client.battle.BattleMakeChoicePacket
 import com.cobblemon.mod.common.net.messages.client.battle.BattleMessagePacket
+import com.cobblemon.mod.common.net.messages.client.battle.BattleQueueRequestPacket
 import com.cobblemon.mod.common.pokemon.evolution.progress.DefeatEvolutionProgress
 import com.cobblemon.mod.common.pokemon.evolution.progress.LastBattleCriticalHitsEvolutionProgress
 import com.cobblemon.mod.common.pokemon.requirements.DefeatRequirement
@@ -137,6 +142,9 @@ open class PokemonBattle(
     val captureActions = mutableListOf<BattleCaptureAction>()
 
     val majorBattleActions = hashMapOf<UUID, BattleMessage>()
+
+    /** Monotonically increasing counter to track faint ordering within this battle. */
+    var faintCounter = 0
     val minorBattleActions = hashMapOf<UUID, BattleMessage>()
     val contextManager = ContextManager()
 
@@ -192,6 +200,11 @@ open class PokemonBattle(
      */
     fun getActor(npc: NPCEntity) = actors.firstOrNull { it is NPCBattleActor && it.npc == npc }
 
+    /**
+     * Gets the first battle actor who has or is the given [PokemonEntity]
+     */
+    fun getActor(pokemonEntity: PokemonEntity) = actors.firstOrNull { it.uuid == pokemonEntity.uuid ||  it.activePokemon.any { it.battlePokemon?.entity == pokemonEntity } }
+
     /**
      * Gets a [BattleActor] and an [ActiveBattlePokemon] from a pnx key, e.g. p2a
      *
@@ -244,12 +257,23 @@ open class PokemonBattle(
 
     fun end() {
         ended = true
+        val awardToFainted = Cobblemon.config.awardExperienceToFaintedPokemon
+        val awardOnLoss = Cobblemon.config.awardExperienceOnBattleLoss
         this.actors.forEach { actor ->
             val faintedPokemons = actor.pokemonList.filter { it.health <= 0 }
             actor.getSide().getOppositeSide().actors.forEach { opponent ->
-                val opponentNonFaintedPokemons = opponent.pokemonList.filter { it.health > 0 }
+                val opponentPokemons = if (awardToFainted) opponent.pokemonList else opponent.pokemonList.filter { it.health > 0 }
                 faintedPokemons.forEach { faintedPokemon ->
-                    for (opponentPokemon in opponentNonFaintedPokemons) {
+                    for (opponentPokemon in opponentPokemons) {
+                        // Faint-order check: if awarding XP to fainted pokemon, only award for enemies that fainted before this pokemon did
+                        if (awardToFainted) {
+                            val enemyFaintedAt = faintedPokemon.faintedAt ?: continue
+                            val opponentFaintedAt = opponentPokemon.faintedAt
+                            if (opponentFaintedAt != null && opponentFaintedAt <= enemyFaintedAt) {
+                                continue
+                            }
+                        }
+
                         val facedFainted = opponentPokemon.facedOpponents.contains(faintedPokemon)
                         val pokemon = opponentPokemon.effectedPokemon
                         if (facedFainted) {
@@ -270,7 +294,8 @@ open class PokemonBattle(
                             else -> continue
                         }
                         val experience = Cobblemon.experienceCalculator.calculate(opponentPokemon, faintedPokemon, multiplier)
-                        if (experience > 0 && actor.pokemonList.all { it.health <= 0 }) {
+                        val enemyTeamWiped = actor.pokemonList.all { it.health <= 0 }
+                        if (experience > 0 && (enemyTeamWiped || awardOnLoss)) {
                             opponent.awardExperience(opponentPokemon, experience)
                         }
                         Cobblemon.evYieldCalculator.calculate(opponentPokemon, faintedPokemon).forEach { (stat, amount) ->
@@ -304,7 +329,8 @@ open class PokemonBattle(
             .forEach{it.pokemon.heal()}
         actors.forEach { actor ->
             actor.pokemonList.forEach { battlePokemon ->
-                battlePokemon.entity?.let { entity -> battlePokemon.postBattleEntityOperation(entity) }
+                battlePokemon.postBattlePokemonOperations.forEach { it(battlePokemon) }
+                battlePokemon.entity?.let { entity -> battlePokemon.postBattleEntityOperations.forEach { it(entity) } }
                 if (battlePokemon.effectedPokemon.entity != null
                         && battlePokemon.effectedPokemon.entity?.beamMode == 0
                         && battlePokemon.effectedPokemon.entity?.platform != PlatformType.NONE) {
@@ -498,12 +524,13 @@ open class PokemonBattle(
     }
 
     fun stop() {
-        end()
         writeShowdownAction(">forcetie") // This will terminate the Showdown connection
+        end()
     }
 
     fun checkForInputDispatch() {
         if (checkForfeit()) return  // ignore actors that are still choosing, their choices don't matter anymore
+        if (checkFleeAttempt()) return
         val readyToInput = (actors.any { !it.mustChoose && it.responses.isNotEmpty() } && actors.none { it.mustChoose })
         if (readyToInput && captureActions.isEmpty()) {
             actors.filter { it.responses.isNotEmpty() }.forEach { it.writeShowdownResponse() }
@@ -511,6 +538,20 @@ open class PokemonBattle(
         }
     }
 
+    private fun checkFleeAttempt(): Boolean {
+        val runner = actors.find { it.responses.any { it is FleeAttemptActionResponse }  } as? PlayerBattleActor ?: return false
+        CobblemonEvents.BATTLE_FLEE_ATTEMPT.post(BattleFleeAttemptEvent(this, runner))
+        runner.responses.clear()
+
+        runner.mustChoose = true
+        runner.request?.let { runner.sendUpdate(BattleQueueRequestPacket(it)) }
+        runner.sendUpdate(BattleMakeChoicePacket())
+
+        runner.entity?.sendSystemMessage(battleLang("run_prompt").white())
+
+        return true
+    }
+
     /** Forces Showdown to end the battle when a [BattleActor] chooses to forfeit. */
     private fun checkForfeit(): Boolean {
         val forfeit = actors.find { it.responses.any { it is ForfeitActionResponse } }

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

@@ -0,0 +1,22 @@
+/*
+ * 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.cooking.effects
+
+import net.minecraft.world.effect.MobEffect
+import net.minecraft.world.effect.MobEffectCategory
+import net.minecraft.world.entity.Entity
+import net.minecraft.world.entity.LivingEntity
+
+class CleanseAllEffect : MobEffect(MobEffectCategory.BENEFICIAL, 0xFFFFFF) {
+    override fun isInstantenous() = true
+    override fun applyInstantenousEffect(source: Entity?, indirect: Entity?, target: LivingEntity, amplifier: Int, proximity: Double) {
+        target.removeAllEffects()
+    }
+    override fun shouldApplyEffectTickThisTick(duration: Int, amplifier: Int) = false
+}

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

@@ -0,0 +1,27 @@
+/*
+ * 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.cooking.effects
+
+import net.minecraft.world.effect.MobEffect
+import net.minecraft.world.effect.MobEffectCategory
+import net.minecraft.world.entity.Entity
+import net.minecraft.world.entity.LivingEntity
+
+class CleanseNegativeEffect : MobEffect(MobEffectCategory.BENEFICIAL, 0xFFFFFF) {
+    override fun isInstantenous() = true
+    override fun applyInstantenousEffect(source: Entity?, indirect: Entity?, target: LivingEntity, amplifier: Int, proximity: Double) {
+        val snapshot = target.activeEffects.toList()
+        for (ei in snapshot) {
+            if (ei.effect.value().category == MobEffectCategory.HARMFUL) {
+                target.removeEffect(ei.effect)
+            }
+        }
+    }
+    override fun shouldApplyEffectTickThisTick(duration: Int, amplifier: Int) = false
+}

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

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.cooking.effects
+
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.stats.Stats
+import net.minecraft.world.effect.MobEffect
+import net.minecraft.world.effect.MobEffectCategory
+import net.minecraft.world.entity.LivingEntity
+
+class MentalRestorationEffect : MobEffect(MobEffectCategory.BENEFICIAL, 0xAA66FF) {
+    override fun applyEffectTick(entity: LivingEntity, amplifier: Int): Boolean {
+        if (entity is ServerPlayer) {
+            val stats = entity.stats
+            val statType = Stats.CUSTOM.get(Stats.TIME_SINCE_REST)
+            val current = stats.getValue(statType)
+            val reduction = 31 * (amplifier + 1)// reduce by half a minute every second per level (30 ticks removed per tick + 1 to account for the tick passing)
+            val newValue = Math.max(current - reduction, 0)
+            stats.setValue(entity, statType, newValue)
+        }
+        return true
+    }
+
+    override fun shouldApplyEffectTickThisTick(duration: Int, amplifier: Int): Boolean {
+        return true
+    }
+}