1,000 files later...

Merge TMs into 1.8 FINALLY

See merge request cable-mc/cobblemon!1853

.gitignore

@@ -36,6 +36,7 @@ common/src/main/resources/assets/cobblemon/showdown
 # Generated files
 */generated/resources/*
 /fabric/src/generated/resources/cobblemon-common.accesswidener
+/fabric/src/main/generated/*
 /.ignored/
 common/.fabric
 .kotlin/

CHANGELOG-1.8.md

@@ -0,0 +1,31 @@
+# Changelog
+## [1.8.0 (MONTH Xth, 2026)](#1-8-0)
+
+### Additions
+- Added a new `cobblemon:structure`, which is a feature without any restrictions allowing the Builders to place certain structures in much more specific manner.
+- Added Configs for Infinite Use TMs and Unlocking all TMs
+- Added Type Gem blocks
+- Added Type Gem Clusters
+- Added TMs
+- Added TM Machine
+- Added Deepslate Core Block
+- Added /givetm Command
+- Added Move Dex to Pokedex
+- Added Disk Rack for storing disks and being an audio sequencer for Noteblocks
+
+
+### Changes
+- Data Monitor can accept Disks (TMs, Music Disks, Upgrade, Dubious Disk, etc) to change look
+
+### Fixes
+- Fixed rare Pokémon being far too likely to spawn multiple times in a single spawn cycle. The dev told me that the exact bug is too complicated to explain.
+
+### Developer
+- Tweaked the spawning selector interface to take a bucket function rather than a bucket directly.
+
+### Molang & Datapacks
+
+### Particles
+
+### Localization
+- Updated translations for:

CHANGELOG-AI-2.md

@@ -1,11 +0,0 @@
-### 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-COMPLEX_MOVESETS.md

@@ -0,0 +1,16 @@
+### Additions
+
+### Changes
+- Wild Pokémon now reliably have at least one offensive move, if they can have offensive moves at that level.
+
+### Fixes
+
+### Developer
+
+### Molang & Datapacks
+- Added `moveset_builders` datapack folder for different styles of movesets.
+- Added `party_pools` datapack folder for defining groups of Pokémon for the purposes of complex NPC party definitions.
+- Added `party_compositions` datapack folder for arranging parties on NPCs that rely on party pools.
+- Added `composed_pool` NPC party provider type which combines a party pool with a party composition to create more complex NPC parties.
+
+### Particles

CHANGELOG.md

@@ -2,7 +2,6 @@
 ## [1.7.4 (MONTH Xth, 2026)](#1-7-4)
 
 ### Additions
-- Added config options to award experience to fainted Pokémon for opponents they helped defeat (`awardExperienceToFaintedPokemon`) and to still award experience for defeated enemies even after battle loss/forfeit (`awardExperienceOnBattleLoss`)
 - Party Overlay Exp Gained Animation will now display the amount of EXP the Pokémon gained
 - Added a toast to notify players of how they can scroll through their party. Did you know you can hold R and scroll instead of using arrow keys??!
 - Added new layer property that makes a layer scroll in a direction. "scrolling": {"speedU": 0.1, "speedV": 0.1}
@@ -39,14 +38,10 @@
 - 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
 - q.item.is_enchanted()

common/build.gradle.kts

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

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

@@ -67,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).getBottomCenter();
+                    newPos = pos.relative(facing).getCenter();
                     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.getBottomCenter();
+                    var center = pos.getCenter();
                     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/NoteBlockMixin.java

@@ -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.mixin;
+
+import com.cobblemon.mod.common.block.entity.TMShelfBlockEntity;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Holder;
+import net.minecraft.sounds.SoundEvent;
+import net.minecraft.sounds.SoundEvents;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.NoteBlock;
+import net.minecraft.world.level.block.state.properties.NoteBlockInstrument;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(NoteBlock.class)
+public abstract class NoteBlockMixin {
+    @Inject(method = "triggerEvent", at = @At("HEAD"), cancellable = true)
+    private void cobblemon$triggerTMShelfSequencer(BlockState state, Level level, BlockPos pos, int type, int data, CallbackInfoReturnable<Boolean> cir) {
+        final BlockPos shelfPos = pos.below();
+        final BlockEntity blockEntity = level.getBlockEntity(shelfPos);
+        if (!(blockEntity instanceof TMShelfBlockEntity tmShelfBlockEntity)) {
+            return;
+        }
+
+        if (!level.isClientSide) {
+            final BlockPos instrumentPos = shelfPos.below();
+            final SoundEvent soundEvent;
+            if (level.getBlockState(instrumentPos).isAir()) {
+                soundEvent = SoundEvents.NOTE_BLOCK_BIT.value();
+            } else {
+                final NoteBlockInstrument instrument = level.getBlockState(instrumentPos).instrument();
+                final Holder<SoundEvent> holder = instrument.getSoundEvent();
+                soundEvent = holder.value();
+            }
+            tmShelfBlockEntity.onNoteBlockPulse(level, pos, soundEvent);
+        }
+
+        // Suppress vanilla note-block playback while it is on top of a TM Shelf.
+        cir.setReturnValue(false);
+    }
+}

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

@@ -23,6 +23,7 @@ import net.minecraft.client.sounds.ChannelAccess;
 import net.minecraft.client.sounds.SoundEngine;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.sounds.SoundSource;
+import net.minecraft.util.Mth;
 import net.minecraft.world.phys.Vec3;
 import org.jetbrains.annotations.Nullable;
 import org.spongepowered.asm.mixin.Final;
@@ -32,6 +33,7 @@ import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
 
 import java.util.Iterator;
@@ -108,6 +110,17 @@ public abstract class SoundEngineMixin implements SoundEngineDuck {
         }
     }
 
+    /**
+     * TM Shelf can intentionally push note-block pitches above vanilla's 2.0f ceiling for octave-up playback.
+     * Keep vanilla clamping for all other sounds.
+     */
+    @Inject(method = "calculatePitch", at = @At("HEAD"), cancellable = true)
+    private void cobblemon$allowExtendedNoteblockPitch(SoundInstance sound, CallbackInfoReturnable<Float> cir) {
+        if (sound.getLocation().getPath().startsWith("block.note_block.")) {
+            cir.setReturnValue(Mth.clamp(sound.getPitch(), 0.5F, 4.0F));
+        }
+    }
+
     /** Different behavior for resuming SoundInstances while a BattleMusicInstance is being played. We do not want to resume filtered sounds. */
     @Inject(method = "resume()V", at = @At("HEAD"), cancellable = true)
     public void resume(CallbackInfo cb) {

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

@@ -21,7 +21,6 @@ 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
@@ -63,6 +62,8 @@ import com.cobblemon.mod.common.api.storage.player.adapter.DexDataMongoBackend
 import com.cobblemon.mod.common.api.storage.player.adapter.DexDataNbtBackend
 import com.cobblemon.mod.common.api.storage.player.adapter.PlayerDataJsonBackend
 import com.cobblemon.mod.common.api.storage.player.adapter.PlayerDataMongoBackend
+import com.cobblemon.mod.common.api.storage.player.adapter.TMMoveMongoBackend
+import com.cobblemon.mod.common.api.storage.player.adapter.TMMoveNbtBackend
 import com.cobblemon.mod.common.api.storage.player.factory.CachedPlayerDataStoreFactory
 import com.cobblemon.mod.common.api.tags.CobblemonEntityTypeTags
 import com.cobblemon.mod.common.api.tags.CobblemonItemTags
@@ -110,13 +111,7 @@ 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.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.util.*
 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
@@ -183,8 +178,6 @@ 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
 
@@ -247,6 +240,8 @@ object Cobblemon {
 
         DATA_SYNCHRONIZED.subscribe {
             storage.onPlayerDataSync(it)
+            it.tmList().scheduleFullSyncFromStores(it.party(), it.pc())
+            it.pokedex().scheduleFullSyncFromStores(it.party(), it.pc())
             playerDataManager.syncAllToPlayer(it)
             starterHandler.handleJoin(it)
             it.requestWallpapers()
@@ -259,7 +254,6 @@ 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)
@@ -310,6 +304,7 @@ object Cobblemon {
             this.config.maxPokemonLevel,
             this.config.maxPokemonFriendship,
             this.config.maxDynamaxLevel,
+            this.config.unlockAllMoveDexMovesByDefault
         ).sendToPlayer(player)
     }
 
@@ -365,7 +360,6 @@ object Cobblemon {
         }
         PlatformEvents.SERVER_STARTING.subscribe { event ->
             val server = event.server
-            PremadeNPCs.onServerLoading(server)
             MoLangLoadedFilesCache.initialize(server)
             playerDataManager = PlayerInstancedDataStoreManager().also { it.setup(server) }
 
@@ -380,8 +374,12 @@ object Cobblemon {
                     val pokedexNbtFactory = CachedPlayerDataStoreFactory(DexDataNbtBackend())
                     pokedexNbtFactory.setup(server)
 
+                    val tmMoveFactory = CachedPlayerDataStoreFactory(TMMoveNbtBackend())
+                    tmMoveFactory.setup(server)
+
                     playerDataManager.setFactory(generalJsonFactory, PlayerInstancedDataStoreTypes.GENERAL)
                     playerDataManager.setFactory(pokedexNbtFactory, PlayerInstancedDataStoreTypes.POKEDEX)
+                    playerDataManager.setFactory(tmMoveFactory, PlayerInstancedDataStoreTypes.TM_MOVES)
 
                     if (config.storageFormat == "nbt") {
                         NBTStoreAdapter(pokemonStoreRoot.absolutePath, useNestedFolders = true, folderPerClass = true)
@@ -408,8 +406,14 @@ object Cobblemon {
                         val pokedexMongoFactory = CachedPlayerDataStoreFactory(DexDataMongoBackend(mongoClient, config.mongoDBDatabaseName, "PokeDexCollection"))
                         pokedexMongoFactory.setup(server)
 
+                        val tmMovesMongoFactory = CachedPlayerDataStoreFactory(
+                                TMMoveMongoBackend(mongoClient, config.mongoDBDatabaseName, "TMMovesCollection")
+                        )
+                        tmMovesMongoFactory.setup(server)
+
                         playerDataManager.setFactory(generalMongoFactory, PlayerInstancedDataStoreTypes.GENERAL)
                         playerDataManager.setFactory(pokedexMongoFactory, PlayerInstancedDataStoreTypes.POKEDEX)
+                        playerDataManager.setFactory(tmMovesMongoFactory, PlayerInstancedDataStoreTypes.TM_MOVES)
                         MongoDBStoreAdapter(mongoClient, config.mongoDBDatabaseName)
                     } catch (e: ClassNotFoundException) {
                         LOGGER.error("MongoDB driver not found.")
@@ -593,6 +597,7 @@ object Cobblemon {
         this.implementation.registerCommandArgument(cobblemonResource("mark"), MarkArgumentType::class, SingletonArgumentInfo.contextFree(MarkArgumentType::mark))
         this.implementation.registerCommandArgument(cobblemonResource("transform_type"), TransformTypeArgumentType::class, SingletonArgumentInfo.contextFree(TransformTypeArgumentType::transformType))
         this.implementation.registerCommandArgument(cobblemonResource("model_part"), ModelPartArgumentType::class, SingletonArgumentInfo.contextFree(ModelPartArgumentType::modelPart))
+        this.implementation.registerCommandArgument(cobblemonResource("tm"), TmArgumentType::class, SingletonArgumentInfo.contextFree(TmArgumentType::tm))
     }
 
 }

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

@@ -9,12 +9,9 @@
 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
@@ -22,7 +19,16 @@ import com.cobblemon.mod.common.api.molang.ExpressionLike
 import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
 import com.cobblemon.mod.common.api.reactive.SimpleObservable
 import com.cobblemon.mod.common.net.messages.client.data.BehaviourSyncPacket
-import com.cobblemon.mod.common.util.adapters.*
+import com.cobblemon.mod.common.util.adapters.ActivityAdapter
+import com.cobblemon.mod.common.util.adapters.BehaviourConfigAdapter
+import com.cobblemon.mod.common.util.adapters.ExpressionAdapter
+import com.cobblemon.mod.common.util.adapters.ExpressionLikeAdapter
+import com.cobblemon.mod.common.util.adapters.ExpressionOrEntityVariableAdapter
+import com.cobblemon.mod.common.util.adapters.IdentifierAdapter
+import com.cobblemon.mod.common.util.adapters.MemoryModuleTypeAdapter
+import com.cobblemon.mod.common.util.adapters.SensorTypeAdapter
+import com.cobblemon.mod.common.util.adapters.TaskConfigAdapter
+import com.cobblemon.mod.common.util.adapters.TranslatedTextAdapter
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.cobblemon.mod.common.util.endsWith
 import com.google.gson.Gson
@@ -49,8 +55,6 @@ 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
@@ -98,7 +102,6 @@ object CobblemonBehaviours : JsonDataRegistry<CobblemonBehaviour> {
                         autoNPCBehaviours.add(behaviour)
                     }
                     data[resolvedIdentifier] = behaviour
-                    behaviour.id = resolvedIdentifier
                 }
             }
         }

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

@@ -39,6 +39,9 @@ object CobblemonBlockEntities : PlatformRegistry<Registry<BlockEntityType<*>>, R
     @JvmField
     val LECTERN: BlockEntityType<LecternBlockEntity> = this.create("lectern", BlockEntityType.Builder.of(::LecternBlockEntity, CobblemonBlocks.LECTERN).build(null))
 
+    @JvmField
+    val TM_SHELF: BlockEntityType<TMShelfBlockEntity> = this.create("tm_shelf", BlockEntityType.Builder.of(::TMShelfBlockEntity, CobblemonBlocks.TM_SHELF).build(null))
+
     @JvmField
     val BERRY = this.create("berry", BlockEntityType.Builder.of(::BerryBlockEntity, *CobblemonBlocks.berries().values.toTypedArray()).build(null))
 
@@ -48,6 +51,8 @@ object CobblemonBlockEntities : PlatformRegistry<Registry<BlockEntityType<*>>, R
     val SIGN: BlockEntityType<CobblemonSignBlockEntity> = this.create("sign", BlockEntityType.Builder.of(::CobblemonSignBlockEntity, CobblemonBlocks.APRICORN_SIGN, CobblemonBlocks.APRICORN_WALL_SIGN, CobblemonBlocks.SACCHARINE_SIGN, CobblemonBlocks.SACCHARINE_WALL_SIGN).build(null))
     @JvmField
     val HANGING_SIGN: BlockEntityType<CobblemonHangingSignBlockEntity> = this.create("hanging_sign", BlockEntityType.Builder.of(::CobblemonHangingSignBlockEntity, CobblemonBlocks.APRICORN_HANGING_SIGN, CobblemonBlocks.APRICORN_WALL_HANGING_SIGN, CobblemonBlocks.SACCHARINE_HANGING_SIGN, CobblemonBlocks.SACCHARINE_WALL_HANGING_SIGN).build(null))
+    @JvmField
+    val TM_MACHINE: BlockEntityType<TMMachineBlockEntity> = this.create("tm_machine", BlockEntityType.Builder.of(::TMMachineBlockEntity, CobblemonBlocks.TM_MACHINE).build(null))
 
     @JvmField
     val GILDED_CHEST: BlockEntityType<GildedChestBlockEntity> = this.create("chest", BlockEntityType.Builder.of(::GildedChestBlockEntity,

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

@@ -22,6 +22,7 @@ import com.cobblemon.mod.common.block.sign.CobblemonHangingSignBlock
 import com.cobblemon.mod.common.block.sign.CobblemonSignBlock
 import com.cobblemon.mod.common.block.sign.CobblemonWallHangingSignBlock
 import com.cobblemon.mod.common.block.sign.CobblemonWallSignBlock
+import com.cobblemon.mod.common.block.tmmachine.TMMachineBlock
 import com.cobblemon.mod.common.block.general.HorizontalRotationCarpetBlock
 import com.cobblemon.mod.common.block.general.HorizontalRotationalBlock
 import com.cobblemon.mod.common.mixin.invoker.*
@@ -249,31 +250,31 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     val POKE_SNACK = this.create("poke_snack", PokeSnackBlock(BlockBehaviour.Properties.of().forceSolidOn().strength(0.5F).sound(SoundType.WOOL).pushReaction(PushReaction.DESTROY).lightLevel { if (it.getValue(BlockStateProperties.LIT)) 3 else 0 }, true))
 
     @JvmField
-    val TUMBLESTONE_CLUSTER = tumblestoneBlock("tumblestone_cluster", GrowableStoneBlock.STAGE_3, 7, 3, null)
+    val TUMBLESTONE_CLUSTER = tumblestoneBlock("tumblestone_cluster", TumblestoneBlock.STAGE_3, 7, 3, null)
     @JvmField
-    val LARGE_BUDDING_TUMBLESTONE = tumblestoneBlock("large_budding_tumblestone", GrowableStoneBlock.STAGE_2, 5, 3, TUMBLESTONE_CLUSTER)
+    val LARGE_BUDDING_TUMBLESTONE = tumblestoneBlock("large_budding_tumblestone", TumblestoneBlock.STAGE_2, 5, 3, TUMBLESTONE_CLUSTER)
     @JvmField
-    val MEDIUM_BUDDING_TUMBLESTONE = tumblestoneBlock("medium_budding_tumblestone", GrowableStoneBlock.STAGE_1, 4, 3, LARGE_BUDDING_TUMBLESTONE)
+    val MEDIUM_BUDDING_TUMBLESTONE = tumblestoneBlock("medium_budding_tumblestone", TumblestoneBlock.STAGE_1, 4, 3, LARGE_BUDDING_TUMBLESTONE)
     @JvmField
-    val SMALL_BUDDING_TUMBLESTONE = tumblestoneBlock("small_budding_tumblestone", GrowableStoneBlock.STAGE_0, 3, 4, MEDIUM_BUDDING_TUMBLESTONE)
+    val SMALL_BUDDING_TUMBLESTONE = tumblestoneBlock("small_budding_tumblestone", TumblestoneBlock.STAGE_0, 3, 4, MEDIUM_BUDDING_TUMBLESTONE)
 
     @JvmField
-    val SKY_TUMBLESTONE_CLUSTER = tumblestoneBlock("sky_tumblestone_cluster", GrowableStoneBlock.STAGE_3, 7, 3, null)
+    val SKY_TUMBLESTONE_CLUSTER = tumblestoneBlock("sky_tumblestone_cluster", TumblestoneBlock.STAGE_3, 7, 3, null)
     @JvmField
-    val LARGE_BUDDING_SKY_TUMBLESTONE = tumblestoneBlock("large_budding_sky_tumblestone", GrowableStoneBlock.STAGE_2, 5, 3, SKY_TUMBLESTONE_CLUSTER)
+    val LARGE_BUDDING_SKY_TUMBLESTONE = tumblestoneBlock("large_budding_sky_tumblestone", TumblestoneBlock.STAGE_2, 5, 3, SKY_TUMBLESTONE_CLUSTER)
     @JvmField
-    val MEDIUM_BUDDING_SKY_TUMBLESTONE = tumblestoneBlock("medium_budding_sky_tumblestone", GrowableStoneBlock.STAGE_1, 4, 3, LARGE_BUDDING_SKY_TUMBLESTONE)
+    val MEDIUM_BUDDING_SKY_TUMBLESTONE = tumblestoneBlock("medium_budding_sky_tumblestone", TumblestoneBlock.STAGE_1, 4, 3, LARGE_BUDDING_SKY_TUMBLESTONE)
     @JvmField
-    val SMALL_BUDDING_SKY_TUMBLESTONE = tumblestoneBlock("small_budding_sky_tumblestone", GrowableStoneBlock.STAGE_0, 3, 4, MEDIUM_BUDDING_SKY_TUMBLESTONE)
+    val SMALL_BUDDING_SKY_TUMBLESTONE = tumblestoneBlock("small_budding_sky_tumblestone", TumblestoneBlock.STAGE_0, 3, 4, MEDIUM_BUDDING_SKY_TUMBLESTONE)
 
     @JvmField
-    val BLACK_TUMBLESTONE_CLUSTER = tumblestoneBlock("black_tumblestone_cluster", GrowableStoneBlock.STAGE_3, 7, 3, null)
+    val BLACK_TUMBLESTONE_CLUSTER = tumblestoneBlock("black_tumblestone_cluster", TumblestoneBlock.STAGE_3, 7, 3, null)
     @JvmField
-    val LARGE_BUDDING_BLACK_TUMBLESTONE = tumblestoneBlock("large_budding_black_tumblestone", GrowableStoneBlock.STAGE_2, 5, 3, BLACK_TUMBLESTONE_CLUSTER)
+    val LARGE_BUDDING_BLACK_TUMBLESTONE = tumblestoneBlock("large_budding_black_tumblestone", TumblestoneBlock.STAGE_2, 5, 3, BLACK_TUMBLESTONE_CLUSTER)
     @JvmField
-    val MEDIUM_BUDDING_BLACK_TUMBLESTONE = tumblestoneBlock("medium_budding_black_tumblestone", GrowableStoneBlock.STAGE_1, 4, 3, LARGE_BUDDING_BLACK_TUMBLESTONE)
+    val MEDIUM_BUDDING_BLACK_TUMBLESTONE = tumblestoneBlock("medium_budding_black_tumblestone", TumblestoneBlock.STAGE_1, 4, 3, LARGE_BUDDING_BLACK_TUMBLESTONE)
     @JvmField
-    val SMALL_BUDDING_BLACK_TUMBLESTONE = tumblestoneBlock("small_budding_black_tumblestone", GrowableStoneBlock.STAGE_0, 3, 4, MEDIUM_BUDDING_BLACK_TUMBLESTONE)
+    val SMALL_BUDDING_BLACK_TUMBLESTONE = tumblestoneBlock("small_budding_black_tumblestone", TumblestoneBlock.STAGE_0, 3, 4, MEDIUM_BUDDING_BLACK_TUMBLESTONE)
 
     @JvmField
     val TUMBLESTONE_BLOCK = this.create("tumblestone_block", Block(BlockBehaviour.Properties.of().mapColor(MapColor.TERRACOTTA_ORANGE).strength(1.0F).sound(CobblemonSounds.TUMBLESTONE_BLOCK_SOUNDS).requiresCorrectToolForDrops().instrument(NoteBlockInstrument.BASEDRUM)))
@@ -282,6 +283,87 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     @JvmField
     val BLACK_TUMBLESTONE_BLOCK = this.create("black_tumblestone_block", Block(BlockBehaviour.Properties.of().mapColor(MapColor.TERRACOTTA_BLACK).strength(1.0F).sound(CobblemonSounds.TUMBLESTONE_BLOCK_SOUNDS).requiresCorrectToolForDrops().instrument(NoteBlockInstrument.BASEDRUM)))
 
+    @JvmField
+    val TYPE_GEM_CORE = this.create("type_gem_core", TypeGemCoreBlock(BlockBehaviour.Properties.of().strength(4.0f, 10.0f).requiresCorrectToolForDrops()))
+
+    private val typeGemBlocks = mutableMapOf<ResourceLocation, TypeGemBlock>()
+
+    @JvmField
+    val TYPE_GEM_BLOCK_NORMAL = typeGemBlock("type_gem_block_normal")
+    @JvmField
+    val TYPE_GEM_BLOCK_FIRE = typeGemBlock("type_gem_block_fire")
+    @JvmField
+    val TYPE_GEM_BLOCK_WATER = typeGemBlock("type_gem_block_water")
+    @JvmField
+    val TYPE_GEM_BLOCK_ELECTRIC = typeGemBlock("type_gem_block_electric")
+    @JvmField
+    val TYPE_GEM_BLOCK_GRASS = typeGemBlock("type_gem_block_grass")
+    @JvmField
+    val TYPE_GEM_BLOCK_ICE = typeGemBlock("type_gem_block_ice")
+    @JvmField
+    val TYPE_GEM_BLOCK_FIGHTING = typeGemBlock("type_gem_block_fighting")
+    @JvmField
+    val TYPE_GEM_BLOCK_POISON = typeGemBlock("type_gem_block_poison")
+    @JvmField
+    val TYPE_GEM_BLOCK_GROUND = typeGemBlock("type_gem_block_ground")
+    @JvmField
+    val TYPE_GEM_BLOCK_FLYING = typeGemBlock("type_gem_block_flying")
+    @JvmField
+    val TYPE_GEM_BLOCK_PSYCHIC = typeGemBlock("type_gem_block_psychic")
+    @JvmField
+    val TYPE_GEM_BLOCK_BUG = typeGemBlock("type_gem_block_bug")
+    @JvmField
+    val TYPE_GEM_BLOCK_ROCK = typeGemBlock("type_gem_block_rock")
+    @JvmField
+    val TYPE_GEM_BLOCK_GHOST = typeGemBlock("type_gem_block_ghost")
+    @JvmField
+    val TYPE_GEM_BLOCK_DRAGON = typeGemBlock("type_gem_block_dragon")
+    @JvmField
+    val TYPE_GEM_BLOCK_DARK = typeGemBlock("type_gem_block_dark")
+    @JvmField
+    val TYPE_GEM_BLOCK_STEEL = typeGemBlock("type_gem_block_steel")
+    @JvmField
+    val TYPE_GEM_BLOCK_FAIRY = typeGemBlock("type_gem_block_fairy")
+
+    private val typeGemClusters = mutableMapOf<ResourceLocation, TypeGemClusterBlock>()
+
+    @JvmField
+    val TYPE_GEM_CLUSTER_NORMAL = typeGemCluster("type_gem_cluster_normal", TYPE_GEM_BLOCK_NORMAL, cobblemonResource("normal_gem"))
+    @JvmField
+    val TYPE_GEM_CLUSTER_FIRE = typeGemCluster("type_gem_cluster_fire", TYPE_GEM_BLOCK_FIRE, cobblemonResource("fire_gem"))
+    @JvmField
+    val TYPE_GEM_CLUSTER_WATER = typeGemCluster("type_gem_cluster_water", TYPE_GEM_BLOCK_WATER, cobblemonResource("water_gem"))
+    @JvmField
+    val TYPE_GEM_CLUSTER_ELECTRIC = typeGemCluster("type_gem_cluster_electric", TYPE_GEM_BLOCK_ELECTRIC, cobblemonResource("electric_gem"))
+    @JvmField
+    val TYPE_GEM_CLUSTER_GRASS = typeGemCluster("type_gem_cluster_grass", TYPE_GEM_BLOCK_GRASS, cobblemonResource("grass_gem"))
+    @JvmField
+    val TYPE_GEM_CLUSTER_ICE = typeGemCluster("type_gem_cluster_ice", TYPE_GEM_BLOCK_ICE, cobblemonResource("ice_gem"))
+    @JvmField
+    val TYPE_GEM_CLUSTER_FIGHTING = typeGemCluster("type_gem_cluster_fighting", TYPE_GEM_BLOCK_FIGHTING, cobblemonResource("fighting_gem"))
+    @JvmField
+    val TYPE_GEM_CLUSTER_POISON = typeGemCluster("type_gem_cluster_poison", TYPE_GEM_BLOCK_POISON, cobblemonResource("poison_gem"))
+    @JvmField
+    val TYPE_GEM_CLUSTER_GROUND = typeGemCluster("type_gem_cluster_ground", TYPE_GEM_BLOCK_GROUND, cobblemonResource("ground_gem"))
+    @JvmField
+    val TYPE_GEM_CLUSTER_FLYING = typeGemCluster("type_gem_cluster_flying", TYPE_GEM_BLOCK_FLYING, cobblemonResource("flying_gem"))
+    @JvmField
+    val TYPE_GEM_CLUSTER_PSYCHIC = typeGemCluster("type_gem_cluster_psychic", TYPE_GEM_BLOCK_PSYCHIC, cobblemonResource("psychic_gem"))
+    @JvmField
+    val TYPE_GEM_CLUSTER_BUG = typeGemCluster("type_gem_cluster_bug", TYPE_GEM_BLOCK_BUG, cobblemonResource("bug_gem"))
+    @JvmField
+    val TYPE_GEM_CLUSTER_ROCK = typeGemCluster("type_gem_cluster_rock", TYPE_GEM_BLOCK_ROCK, cobblemonResource("rock_gem"))
+    @JvmField
+    val TYPE_GEM_CLUSTER_GHOST = typeGemCluster("type_gem_cluster_ghost", TYPE_GEM_BLOCK_GHOST, cobblemonResource("ghost_gem"))
+    @JvmField
+    val TYPE_GEM_CLUSTER_DRAGON = typeGemCluster("type_gem_cluster_dragon", TYPE_GEM_BLOCK_DRAGON, cobblemonResource("dragon_gem"))
+    @JvmField
+    val TYPE_GEM_CLUSTER_DARK = typeGemCluster("type_gem_cluster_dark", TYPE_GEM_BLOCK_DARK, cobblemonResource("dark_gem"))
+    @JvmField
+    val TYPE_GEM_CLUSTER_STEEL = typeGemCluster("type_gem_cluster_steel", TYPE_GEM_BLOCK_STEEL, cobblemonResource("steel_gem"))
+    @JvmField
+    val TYPE_GEM_CLUSTER_FAIRY = typeGemCluster("type_gem_cluster_fairy", TYPE_GEM_BLOCK_FAIRY, cobblemonResource("fairy_gem"))
+
     @JvmField
     val POLISHED_TUMBLESTONE = this.create("polished_tumblestone", Block(BlockBehaviour.Properties.of().mapColor(MapColor.TERRACOTTA_ORANGE).strength(1.0F).sound(CobblemonSounds.TUMBLESTONE_BLOCK_SOUNDS).requiresCorrectToolForDrops().instrument(NoteBlockInstrument.BASEDRUM)))
     @JvmField
@@ -456,6 +538,7 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     @JvmField
     val SOUL_CAMPFIRE = create("soul_campfire", CampfireBlock(BlockBehaviour.Properties.of().sound(SoundType.WOOD).noOcclusion().pushReaction(PushReaction.BLOCK).mapColor(MapColor.PODZOL).strength(2.0F).lightLevel{9}, true))
 
+
     @JvmField
     val RELIC_COIN_POUCH = create("relic_coin_pouch", CoinPouchBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.RELIC_COIN_POUCH_SOUNDS).pushReaction(PushReaction.DESTROY).noOcclusion(), true))
     @JvmField
@@ -584,9 +667,25 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     @JvmField
     val PC = create("pc", PCBlock(BlockBehaviour.Properties.of().mapColor(MapColor.METAL).sound(SoundType.METAL).pushReaction(PushReaction.BLOCK).strength(2F).noOcclusion().lightLevel { if ((it.getValue(PCBlock.ON) as Boolean) && (it.getValue(PCBlock.PART) == PCBlock.PCPart.TOP)) 13 else 0 }))
 
+    val TM_MACHINE = create(
+            "tm_machine",
+        TMMachineBlock(
+            BlockBehaviour.Properties.of()
+                .mapColor(MapColor.COLOR_GREEN)
+                .sound(SoundType.METAL)
+                .pushReaction(PushReaction.BLOCK)
+                .strength(2F)
+                .noOcclusion()
+        )
+    )
+
+
     @JvmField
     val LECTERN = create("lectern", LecternBlock(BlockBehaviour.Properties.of().mapColor(MapColor.WOOD).instrument(NoteBlockInstrument.BASS).sound(SoundType.WOOD).strength(2.5F).ignitedByLava().lightLevel { if (it.getValue(LecternBlock.EMIT_LIGHT) as Boolean) 13 else 0 }))
 
+    @JvmField
+    val TM_SHELF = create("tm_shelf", TMShelfBlock(BlockBehaviour.Properties.of().mapColor(MapColor.WOOD).instrument(NoteBlockInstrument.BASS).sound(SoundType.METAL).strength(2.5F)))
+
     @JvmField
     val DISPLAY_CASE = create("display_case", DisplayCaseBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.DISPLAY_CASE_SOUNDS).noOcclusion().pushReaction(PushReaction.BLOCK).mapColor(MapColor.STONE).strength(0.3F).requiresCorrectToolForDrops()))
 
@@ -890,4 +989,28 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
         val block = BlocksInvoker.createLeavesBlock(SoundType.GRASS)
         return this.create(name, block)
     }
+
+    private fun typeGemBlock(name: String): TypeGemBlock {
+        val typeGemBlock = this.create(name, TypeGemBlock(BlockBehaviour.Properties.of().strength(3.0f, 6.0f)))
+
+        val identifier = cobblemonResource(name)
+        typeGemBlocks[identifier] = typeGemBlock
+
+        return typeGemBlock
+    }
+
+    fun typeGemBlocks() = typeGemBlocks.toMap()
+
+    private fun typeGemCluster(name: String, gemBlock: Block, dropItemId: ResourceLocation): Block {
+        val gemClusterBlock = this.create(name, TypeGemClusterBlock(BlockBehaviour.Properties.of().strength(2.0f, 3.0f).pushReaction(PushReaction.DESTROY), gemBlock, dropItemId))
+
+        TypeGemClusterBlock.gemToClusterMap[gemBlock] = gemClusterBlock
+
+        val identifier = cobblemonResource(name)
+        typeGemClusters[identifier] = gemClusterBlock
+
+        return gemClusterBlock
+    }
+
+    fun typeGemClusters() = typeGemClusters.toMap()
 }

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

@@ -71,11 +71,12 @@ object CobblemonCommands {
         MarkGiveAllCommand.register(dispatcher)
         PcSearchCommand.register(dispatcher)
         PcTakeCommand.register(dispatcher)
+        GiveTmCommand.register(dispatcher)
+        TmCommand.register(dispatcher)
 
         // Possibly lock down registration if and only if under dev environment or running in an environment
         // with a certain system environment variable set
         CobblemonInfoCommand.register(dispatcher)
         CalculateSeatPositionCommand.register(dispatcher)
-        DebugCobblemonAICommand.register(dispatcher)
     }
-}
+}

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

@@ -19,6 +19,7 @@ import net.minecraft.server.level.ServerPlayer
 import net.minecraft.server.packs.PackType
 import net.minecraft.server.packs.resources.PreparableReloadListener
 import net.minecraft.tags.TagKey
+import net.minecraft.world.inventory.MenuType
 import net.minecraft.world.level.GameRules
 import net.minecraft.world.level.ItemLike
 import net.minecraft.world.level.biome.Biome

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

@@ -69,6 +69,12 @@ object CobblemonItemComponents : PlatformRegistry<Registry<DataComponentType<*>>
         .networkSynchronized(FoodColourComponent.PACKET_CODEC)
         .build())
 
+    @JvmField
+    val TM_MOVE: DataComponentType<TMMoveComponent> = create("tm_move", DataComponentType.builder<TMMoveComponent>()
+        .persistent(TMMoveComponent.CODEC)
+        .networkSynchronized(TMMoveComponent.PACKET_CODEC)
+        .build())
+
     @JvmField
     val INGREDIENT: DataComponentType<IngredientComponent> = create("ingredient", DataComponentType.builder<IngredientComponent>()
             .persistent(IngredientComponent.CODEC)
@@ -101,6 +107,7 @@ object CobblemonItemComponents : PlatformRegistry<Registry<DataComponentType<*>>
         Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.parse("cobblemon:flavour"), FLAVOUR)
         Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.parse("cobblemon:ride_boosts"), RIDE_BOOST)
         Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.parse("cobblemon:food_colour"), FOOD_COLOUR)
+        Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.parse("cobblemon:tm_move"), TM_MOVE)
         Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.parse("cobblemon:ingredient"), INGREDIENT)
         Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.parse("cobblemon:food"), FOOD)
         Registry.register(BuiltInRegistries.DATA_COMPONENT_TYPE, ResourceLocation.parse("cobblemon:mob_effects"), MOB_EFFECTS)

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

@@ -457,6 +457,10 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val PC = blockItem("pc", CobblemonBlocks.PC)
     @JvmField
+    val TM_MACHINE = blockItem("tm_machine", CobblemonBlocks.TM_MACHINE)
+    @JvmField
+    val TM_SHELF = blockItem("tm_shelf", CobblemonBlocks.TM_SHELF)
+    @JvmField
     val PASTURE = blockItem("pasture", CobblemonBlocks.PASTURE)
     @JvmField
     val DISPLAY_CASE = blockItem("display_case", CobblemonBlocks.DISPLAY_CASE)
@@ -1208,6 +1212,83 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val BLACK_TUMBLESTONE_BLOCK = blockItem("black_tumblestone_block", CobblemonBlocks.BLACK_TUMBLESTONE_BLOCK)
 
+    @JvmField
+    val TYPE_GEM_CORE = blockItem("type_gem_core", CobblemonBlocks.TYPE_GEM_CORE)
+
+    @JvmField
+    val TYPE_GEM_CLUSTER_NORMAL = blockItem("type_gem_cluster_normal", CobblemonBlocks.TYPE_GEM_CLUSTER_NORMAL)
+    @JvmField
+    val TYPE_GEM_CLUSTER_FIRE = blockItem("type_gem_cluster_fire", CobblemonBlocks.TYPE_GEM_CLUSTER_FIRE)
+    @JvmField
+    val TYPE_GEM_CLUSTER_WATER = blockItem("type_gem_cluster_water", CobblemonBlocks.TYPE_GEM_CLUSTER_WATER)
+    @JvmField
+    val TYPE_GEM_CLUSTER_ELECTRIC = blockItem("type_gem_cluster_electric", CobblemonBlocks.TYPE_GEM_CLUSTER_ELECTRIC)
+    @JvmField
+    val TYPE_GEM_CLUSTER_GRASS = blockItem("type_gem_cluster_grass", CobblemonBlocks.TYPE_GEM_CLUSTER_GRASS)
+    @JvmField
+    val TYPE_GEM_CLUSTER_ICE = blockItem("type_gem_cluster_ice", CobblemonBlocks.TYPE_GEM_CLUSTER_ICE)
+    @JvmField
+    val TYPE_GEM_CLUSTER_FIGHTING = blockItem("type_gem_cluster_fighting", CobblemonBlocks.TYPE_GEM_CLUSTER_FIGHTING)
+    @JvmField
+    val TYPE_GEM_CLUSTER_POISON = blockItem("type_gem_cluster_poison", CobblemonBlocks.TYPE_GEM_CLUSTER_POISON)
+    @JvmField
+    val TYPE_GEM_CLUSTER_GROUND = blockItem("type_gem_cluster_ground", CobblemonBlocks.TYPE_GEM_CLUSTER_GROUND)
+    @JvmField
+    val TYPE_GEM_CLUSTER_FLYING = blockItem("type_gem_cluster_flying", CobblemonBlocks.TYPE_GEM_CLUSTER_FLYING)
+    @JvmField
+    val TYPE_GEM_CLUSTER_PSYCHIC = blockItem("type_gem_cluster_psychic", CobblemonBlocks.TYPE_GEM_CLUSTER_PSYCHIC)
+    @JvmField
+    val TYPE_GEM_CLUSTER_BUG = blockItem("type_gem_cluster_bug", CobblemonBlocks.TYPE_GEM_CLUSTER_BUG)
+    @JvmField
+    val TYPE_GEM_CLUSTER_ROCK = blockItem("type_gem_cluster_rock", CobblemonBlocks.TYPE_GEM_CLUSTER_ROCK)
+    @JvmField
+    val TYPE_GEM_CLUSTER_GHOST = blockItem("type_gem_cluster_ghost", CobblemonBlocks.TYPE_GEM_CLUSTER_GHOST)
+    @JvmField
+    val TYPE_GEM_CLUSTER_DRAGON = blockItem("type_gem_cluster_dragon", CobblemonBlocks.TYPE_GEM_CLUSTER_DRAGON)
+    @JvmField
+    val TYPE_GEM_CLUSTER_DARK = blockItem("type_gem_cluster_dark", CobblemonBlocks.TYPE_GEM_CLUSTER_DARK)
+    @JvmField
+    val TYPE_GEM_CLUSTER_STEEL = blockItem("type_gem_cluster_steel", CobblemonBlocks.TYPE_GEM_CLUSTER_STEEL)
+    @JvmField
+    val TYPE_GEM_CLUSTER_FAIRY = blockItem("type_gem_cluster_fairy", CobblemonBlocks.TYPE_GEM_CLUSTER_FAIRY)
+
+    @JvmField
+    val TYPE_GEM_BLOCK_NORMAL = blockItem("type_gem_block_normal", CobblemonBlocks.TYPE_GEM_BLOCK_NORMAL)
+    @JvmField
+    val TYPE_GEM_BLOCK_FIRE = blockItem("type_gem_block_fire", CobblemonBlocks.TYPE_GEM_BLOCK_FIRE)
+    @JvmField
+    val TYPE_GEM_BLOCK_WATER = blockItem("type_gem_block_water", CobblemonBlocks.TYPE_GEM_BLOCK_WATER)
+    @JvmField
+    val TYPE_GEM_BLOCK_ELECTRIC = blockItem("type_gem_block_electric", CobblemonBlocks.TYPE_GEM_BLOCK_ELECTRIC)
+    @JvmField
+    val TYPE_GEM_BLOCK_GRASS = blockItem("type_gem_block_grass", CobblemonBlocks.TYPE_GEM_BLOCK_GRASS)
+    @JvmField
+    val TYPE_GEM_BLOCK_ICE = blockItem("type_gem_block_ice", CobblemonBlocks.TYPE_GEM_BLOCK_ICE)
+    @JvmField
+    val TYPE_GEM_BLOCK_FIGHTING = blockItem("type_gem_block_fighting", CobblemonBlocks.TYPE_GEM_BLOCK_FIGHTING)
+    @JvmField
+    val TYPE_GEM_BLOCK_POISON = blockItem("type_gem_block_poison", CobblemonBlocks.TYPE_GEM_BLOCK_POISON)
+    @JvmField
+    val TYPE_GEM_BLOCK_GROUND = blockItem("type_gem_block_ground", CobblemonBlocks.TYPE_GEM_BLOCK_GROUND)
+    @JvmField
+    val TYPE_GEM_BLOCK_FLYING = blockItem("type_gem_block_flying", CobblemonBlocks.TYPE_GEM_BLOCK_FLYING)
+    @JvmField
+    val TYPE_GEM_BLOCK_PSYCHIC = blockItem("type_gem_block_psychic", CobblemonBlocks.TYPE_GEM_BLOCK_PSYCHIC)
+    @JvmField
+    val TYPE_GEM_BLOCK_BUG = blockItem("type_gem_block_bug", CobblemonBlocks.TYPE_GEM_BLOCK_BUG)
+    @JvmField
+    val TYPE_GEM_BLOCK_ROCK = blockItem("type_gem_block_rock", CobblemonBlocks.TYPE_GEM_BLOCK_ROCK)
+    @JvmField
+    val TYPE_GEM_BLOCK_GHOST = blockItem("type_gem_block_ghost", CobblemonBlocks.TYPE_GEM_BLOCK_GHOST)
+    @JvmField
+    val TYPE_GEM_BLOCK_DRAGON = blockItem("type_gem_block_dragon", CobblemonBlocks.TYPE_GEM_BLOCK_DRAGON)
+    @JvmField
+    val TYPE_GEM_BLOCK_DARK = blockItem("type_gem_block_dark", CobblemonBlocks.TYPE_GEM_BLOCK_DARK)
+    @JvmField
+    val TYPE_GEM_BLOCK_STEEL = blockItem("type_gem_block_steel", CobblemonBlocks.TYPE_GEM_BLOCK_STEEL)
+    @JvmField
+    val TYPE_GEM_BLOCK_FAIRY = blockItem("type_gem_block_fairy", CobblemonBlocks.TYPE_GEM_BLOCK_FAIRY)
+
     @JvmField
     val POKEROD_SMITHING_TEMPLATE = create("pokerod_smithing_template", SmithingTemplateItem(
         Component.translatable("item.minecraft.fishing_rod").blue(),
@@ -1432,44 +1513,49 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     val RELIC_COIN_POUCH = blockItem("relic_coin_pouch", CobblemonBlocks.RELIC_COIN_POUCH)
     @JvmField
     val RELIC_COIN_SACK = blockItem("relic_coin_sack", CobblemonBlocks.RELIC_COIN_SACK)
+    @JvmField
+    val TECHNICAL_MACHINE = this.create("technical_machine", TechnicalMachineItem(Properties()))
+    @JvmField
+    val BLANK_TM = this.create("blank_tm", CobblemonItem(Item.Properties()))
 
     // Type Gems
     @JvmField
-    val NORMAL_GEM = noSettingsItem("normal_gem")
+    val NORMAL_GEM = this.create("normal_gem", TypeGemItem(CobblemonBlocks.TYPE_GEM_CLUSTER_NORMAL, Item.Properties()))
     @JvmField
-    val FIRE_GEM = noSettingsItem("fire_gem")
+    val FIRE_GEM = this.create("fire_gem", TypeGemItem(CobblemonBlocks.TYPE_GEM_CLUSTER_FIRE, Item.Properties()))
     @JvmField
-    val WATER_GEM = noSettingsItem("water_gem")
+    val WATER_GEM = this.create("water_gem", TypeGemItem(CobblemonBlocks.TYPE_GEM_CLUSTER_WATER, Item.Properties()))
     @JvmField
-    val GRASS_GEM = noSettingsItem("grass_gem")
+    val GRASS_GEM = this.create("grass_gem", TypeGemItem(CobblemonBlocks.TYPE_GEM_CLUSTER_GRASS, Item.Properties()))
     @JvmField
-    val ELECTRIC_GEM = noSettingsItem("electric_gem")
+    val ELECTRIC_GEM = this.create("electric_gem", TypeGemItem(CobblemonBlocks.TYPE_GEM_CLUSTER_ELECTRIC, Item.Properties()))
     @JvmField
-    val ICE_GEM = noSettingsItem("ice_gem")
+    val ICE_GEM = this.create("ice_gem", TypeGemItem(CobblemonBlocks.TYPE_GEM_CLUSTER_ICE, Item.Properties()))
     @JvmField
-    val FIGHTING_GEM = noSettingsItem("fighting_gem")
+    val FIGHTING_GEM = this.create("fighting_gem", TypeGemItem(CobblemonBlocks.TYPE_GEM_CLUSTER_FIGHTING, Item.Properties()))
     @JvmField
-    val POISON_GEM = noSettingsItem("poison_gem")
+    val POISON_GEM = this.create("poison_gem", TypeGemItem(CobblemonBlocks.TYPE_GEM_CLUSTER_POISON, Item.Properties()))
     @JvmField
-    val GROUND_GEM = noSettingsItem("ground_gem")
+    val GROUND_GEM = this.create("ground_gem", TypeGemItem(CobblemonBlocks.TYPE_GEM_CLUSTER_GROUND, Item.Properties()))
     @JvmField
-    val FLYING_GEM = noSettingsItem("flying_gem")
+    val FLYING_GEM = this.create("flying_gem", TypeGemItem(CobblemonBlocks.TYPE_GEM_CLUSTER_FLYING, Item.Properties()))
     @JvmField
-    val PSYCHIC_GEM = noSettingsItem("psychic_gem")
+    val PSYCHIC_GEM = this.create("psychic_gem", TypeGemItem(CobblemonBlocks.TYPE_GEM_CLUSTER_PSYCHIC, Item.Properties()))
     @JvmField
-    val BUG_GEM = noSettingsItem("bug_gem")
+    val BUG_GEM = this.create("bug_gem", TypeGemItem(CobblemonBlocks.TYPE_GEM_CLUSTER_BUG, Item.Properties()))
     @JvmField
-    val ROCK_GEM = noSettingsItem("rock_gem")
+    val ROCK_GEM = this.create("rock_gem", TypeGemItem(CobblemonBlocks.TYPE_GEM_CLUSTER_ROCK, Item.Properties()))
     @JvmField
-    val GHOST_GEM = noSettingsItem("ghost_gem")
+    val GHOST_GEM = this.create("ghost_gem", TypeGemItem(CobblemonBlocks.TYPE_GEM_CLUSTER_GHOST, Item.Properties()))
     @JvmField
-    val DRAGON_GEM = noSettingsItem("dragon_gem")
+    val DRAGON_GEM = this.create("dragon_gem", TypeGemItem(CobblemonBlocks.TYPE_GEM_CLUSTER_DRAGON, Item.Properties()))
     @JvmField
-    val DARK_GEM = noSettingsItem("dark_gem")
+    val DARK_GEM = this.create("dark_gem", TypeGemItem(CobblemonBlocks.TYPE_GEM_CLUSTER_DARK, Item.Properties()))
     @JvmField
-    val STEEL_GEM = noSettingsItem("steel_gem")
+    val STEEL_GEM = this.create("steel_gem", TypeGemItem(CobblemonBlocks.TYPE_GEM_CLUSTER_STEEL, Item.Properties()))
     @JvmField
-    val FAIRY_GEM = noSettingsItem("fairy_gem")
+    val FAIRY_GEM = this.create("fairy_gem", TypeGemItem(CobblemonBlocks.TYPE_GEM_CLUSTER_FAIRY, Item.Properties()))
+
     //@JvmField
     //val BINDING_SOIL = blockItem("binding_soil", CobblemonBlocks.BINDING_SOIL)
 

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,8 +59,12 @@ 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/CobblemonMenuType.kt

@@ -10,6 +10,7 @@ package com.cobblemon.mod.common
 
 
 import com.cobblemon.mod.common.block.campfirepot.CookingPotMenu
+import com.cobblemon.mod.common.block.tmmachine.TMMachineMenu
 import com.cobblemon.mod.common.platform.PlatformRegistry
 import net.minecraft.core.Registry
 import net.minecraft.core.registries.BuiltInRegistries
@@ -19,7 +20,8 @@ import net.minecraft.world.inventory.MenuType
 
 object CobblemonMenuType : PlatformRegistry<Registry<MenuType<*>>, ResourceKey<Registry<MenuType<*>>>, MenuType<*>>() {
 
-    val COOKING_POT = MenuType.register("cooking_pot", ::CookingPotMenu)
+    val COOKING_POT = MenuType.register("cooking_pot_menu", ::CookingPotMenu)
+    val TM_MACHINE = MenuType.register("tm_machine_menu", ::TMMachineMenu)
 
     override val registry: Registry<MenuType<*>>
         get() = BuiltInRegistries.MENU

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

@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common
+
+import com.cobblemon.mod.common.api.data.JsonDataRegistry
+import com.cobblemon.mod.common.api.moves.MoveSelector
+import com.cobblemon.mod.common.api.moves.MovesetBuilder
+import com.cobblemon.mod.common.api.reactive.SimpleObservable
+import com.cobblemon.mod.common.util.adapters.IdentifierAdapter
+import com.cobblemon.mod.common.util.adapters.MovesetBuilderAdapter
+import com.cobblemon.mod.common.util.adapters.StringToObjectAdapter
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+import com.google.gson.reflect.TypeToken
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.server.packs.PackType
+
+object CobblemonMovesetBuilders : JsonDataRegistry<MovesetBuilder> {
+    override val gson: Gson = GsonBuilder()
+        .setPrettyPrinting()
+        .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
+        .registerTypeAdapter(MovesetBuilder::class.java, MovesetBuilderAdapter)
+        .registerTypeAdapter(MoveSelector::class.java, StringToObjectAdapter(MoveSelector.selectors))
+        .create()
+
+    override val typeToken = TypeToken.get(MovesetBuilder::class.java)
+    override val resourcePath = "moveset_builders"
+    override val id: ResourceLocation = cobblemonResource("moveset_builders")
+    override val type = PackType.SERVER_DATA
+    override val observable = SimpleObservable<CobblemonMovesetBuilders>()
+
+    val movesetBuilders = mutableMapOf<ResourceLocation, MovesetBuilder>()
+
+    fun getOrThrow(id: ResourceLocation): MovesetBuilder {
+        return movesetBuilders[id]
+            ?: throw IllegalArgumentException("Unknown MovesetBuilder id: $id")
+    }
+
+    override fun sync(player: ServerPlayer) { /* These don't sync. But what if they did? Nah probably shouldn't sync. */ }
+
+    override fun reload(data: Map<ResourceLocation, MovesetBuilder>) {
+        movesetBuilders.clear()
+        data.forEach { (id, value) -> value.id = id }
+        movesetBuilders.putAll(data)
+        observable.emit(this)
+    }
+}

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

@@ -23,18 +23,17 @@ 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.*
+import com.cobblemon.mod.common.client.net.gui.*
 import com.cobblemon.mod.common.client.net.effect.PokeSnackBlockParticlesHandler
 import com.cobblemon.mod.common.client.net.effect.RunPosableMoLangHandler
 import com.cobblemon.mod.common.client.net.effect.SaccharineLogBlockParticlesHandler
 import com.cobblemon.mod.common.client.net.effect.SpawnSnowstormEntityParticleHandler
 import com.cobblemon.mod.common.client.net.effect.SpawnSnowstormParticleHandler
 import com.cobblemon.mod.common.client.net.gui.ExpGainedDataPacketHandler
-import com.cobblemon.mod.common.client.net.gui.InteractPokemonUIPacketHandler
-import com.cobblemon.mod.common.client.net.gui.PokedexUIPacketHandler
-import com.cobblemon.mod.common.client.net.gui.SummaryUIPacketHandler
+import com.cobblemon.mod.common.client.net.gui.*
 import com.cobblemon.mod.common.client.net.npc.CloseNPCEditorHandler
 import com.cobblemon.mod.common.client.net.npc.OpenNPCEditorHandler
 import com.cobblemon.mod.common.client.net.orientation.ClientboundUpdateOrientationHandler
@@ -82,7 +81,6 @@ 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
@@ -139,16 +137,8 @@ import com.cobblemon.mod.common.net.messages.client.trade.TradeProcessStartedPac
 import com.cobblemon.mod.common.net.messages.client.trade.TradeStartedPacket
 import com.cobblemon.mod.common.net.messages.client.trade.TradeUpdatedPacket
 import com.cobblemon.mod.common.net.messages.client.ui.ExpGainedDataPacket
-import com.cobblemon.mod.common.net.messages.client.ui.InteractPokemonUIPacket
-import com.cobblemon.mod.common.net.messages.client.ui.PokedexUIPacket
-import com.cobblemon.mod.common.net.messages.client.ui.SummaryUIPacket
-import com.cobblemon.mod.common.net.messages.server.BattleChallengePacket
-import com.cobblemon.mod.common.net.messages.server.BattleChallengeResponsePacket
-import com.cobblemon.mod.common.net.messages.server.BenchMovePacket
-import com.cobblemon.mod.common.net.messages.server.RequestMoveSwapPacket
-import com.cobblemon.mod.common.net.messages.server.RequestPlayerInteractionsPacket
-import com.cobblemon.mod.common.net.messages.server.SelectStarterPacket
-import com.cobblemon.mod.common.net.messages.server.SendOutPokemonPacket
+import com.cobblemon.mod.common.net.messages.client.ui.*
+import com.cobblemon.mod.common.net.messages.server.*
 import com.cobblemon.mod.common.net.messages.server.battle.BattleSelectActionsPacket
 import com.cobblemon.mod.common.net.messages.server.battle.BattleTeamLeavePacket
 import com.cobblemon.mod.common.net.messages.server.battle.BattleTeamRequestPacket
@@ -158,6 +148,7 @@ import com.cobblemon.mod.common.net.messages.server.battle.SpectateBattlePacket
 import com.cobblemon.mod.common.net.messages.server.behaviour.DamageOnCollisionPacket
 import com.cobblemon.mod.common.net.messages.server.behaviour.SetEntityBehaviourPacket
 import com.cobblemon.mod.common.net.messages.server.block.AdjustBlockEntityViewerCountPacket
+import com.cobblemon.mod.common.net.messages.server.block.TMMachineTeachMovePacket
 import com.cobblemon.mod.common.net.messages.server.callback.move.MoveSelectCancelledPacket
 import com.cobblemon.mod.common.net.messages.server.callback.move.MoveSelectedPacket
 import com.cobblemon.mod.common.net.messages.server.callback.party.PartyPokemonSelectedPacket
@@ -170,10 +161,7 @@ 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
@@ -216,6 +204,7 @@ import com.cobblemon.mod.common.net.serverhandling.battle.TeamRequestResponseHan
 import com.cobblemon.mod.common.net.serverhandling.behaviour.DamageOnCollisionPacketHandler
 import com.cobblemon.mod.common.net.serverhandling.behaviour.SetEntityBehaviourHandler
 import com.cobblemon.mod.common.net.serverhandling.block.AdjustBlockEntityViewerCountHandler
+import com.cobblemon.mod.common.net.serverhandling.block.TMMachineTeachMoveHandler
 import com.cobblemon.mod.common.net.serverhandling.callback.move.MoveSelectCancelledHandler
 import com.cobblemon.mod.common.net.serverhandling.callback.move.MoveSelectedHandler
 import com.cobblemon.mod.common.net.serverhandling.callback.party.PartyPokemonSelectedHandler
@@ -229,11 +218,9 @@ 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.storage.party.PartyTutorialPacketHandler
 import com.cobblemon.mod.common.net.serverhandling.pasture.PasturePokemonHandler
 import com.cobblemon.mod.common.net.serverhandling.pasture.SetPastureConflictHandler
 import com.cobblemon.mod.common.net.serverhandling.pasture.UnpastureAllPokemonHandler
@@ -241,6 +228,8 @@ import com.cobblemon.mod.common.net.serverhandling.pasture.UnpasturePokemonHandl
 import com.cobblemon.mod.common.net.serverhandling.pokedex.scanner.FinishScanningHandler
 import com.cobblemon.mod.common.net.serverhandling.pokedex.scanner.StartScanningHandler
 import com.cobblemon.mod.common.net.serverhandling.pokemon.interact.InteractPokemonHandler
+import com.cobblemon.mod.common.net.serverhandling.pokemon.update.*
+import com.cobblemon.mod.common.net.serverhandling.pokemon.update.*
 import com.cobblemon.mod.common.net.serverhandling.pokemon.update.ServerboundUpdateRidingStateHandler
 import com.cobblemon.mod.common.net.serverhandling.pokemon.update.SetActiveMarkHandler
 import com.cobblemon.mod.common.net.serverhandling.pokemon.update.SetItemHiddenHandler
@@ -256,7 +245,6 @@ 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.*
@@ -433,7 +421,6 @@ object CobblemonNetwork {
         list.add(PacketRegisterInfo(BehaviourSyncPacket.ID, BehaviourSyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(MarkRegistrySyncPacket.ID, MarkRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(RideSettingsSyncPacket.ID, RideSettingsSyncPacket::decode, RideSettingsSyncHandler))
-        list.add(PacketRegisterInfo(PremadeNPCRegistrySyncPacket.ID, PremadeNPCRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
 
         // Effects
         list.add(PacketRegisterInfo(SpawnSnowstormParticlePacket.ID, SpawnSnowstormParticlePacket::decode, SpawnSnowstormParticleHandler))
@@ -505,7 +492,6 @@ object CobblemonNetwork {
 
         // Debug
         list.add(PacketRegisterInfo(OpenRidingStatsDebugGUIPacket.ID, OpenRidingStatsDebugGUIPacket::decode, OpenRidingStatsDebugGUIHandler))
-        list.add(PacketRegisterInfo(UpdateTrackedBrainDataPacket.ID, UpdateTrackedBrainDataPacket::decode, UpdateTrackedBrainDataHandler))
 
         return list
     }
@@ -586,6 +572,7 @@ object CobblemonNetwork {
 
         // Block entity
         list.add(PacketRegisterInfo(AdjustBlockEntityViewerCountPacket.ID, AdjustBlockEntityViewerCountPacket::decode, AdjustBlockEntityViewerCountHandler))
+        list.add(PacketRegisterInfo(TMMachineTeachMovePacket.ID, TMMachineTeachMovePacket::decode, TMMachineTeachMoveHandler))
 
         // Move select packets
         list.add(PacketRegisterInfo(MoveSelectedPacket.ID, MoveSelectedPacket::decode, MoveSelectedHandler))
@@ -608,9 +595,6 @@ object CobblemonNetwork {
 
         // NPC packets
         list.add(PacketRegisterInfo(SaveNPCPacket.ID, SaveNPCPacket::decode, SaveNPCHandler))
-        list.add(PacketRegisterInfo(SavePremadeFromNPCPacket.ID, SavePremadeFromNPCPacket::decode, SavePremadeFromNPCHandler))
-        list.add(PacketRegisterInfo(DeletePremadePacket.ID, DeletePremadePacket::decode, DeletePremadeHandler))
-        list.add(PacketRegisterInfo(ApplyPremadeNPCPacket.ID, ApplyPremadeNPCPacket::decode, ApplyPremadeNPCHandler))
 
         // Riding packet(s)
         list.add(PacketRegisterInfo(ServerboundUpdateOrientationPacket.ID, ServerboundUpdateOrientationPacket::decode, ServerboundUpdateOrientationHandler))
@@ -625,6 +609,10 @@ object CobblemonNetwork {
         // Cooking
         list.add(PacketRegisterInfo(ToggleCookingPotLidPacket.ID, ToggleCookingPotLidPacket::decode, ToggleCookingPotLidHandler))
 
+        // TM Machine
+        list.add(PacketRegisterInfo(SetActiveTMPacket.ID, SetActiveTMPacket::decode, SetActiveTMPacketHandler))
+        list.add(PacketRegisterInfo(SetTMMachineContainerDataPacket.ID, SetTMMachineContainerDataPacket::decode, SetTMMachineContainerDataPacketHandler))
+
         // Behaviour Packets
         list.add(PacketRegisterInfo(SetEntityBehaviourPacket.ID, SetEntityBehaviourPacket::decode, SetEntityBehaviourHandler))
         list.add(PacketRegisterInfo(DamageOnCollisionPacket.ID, DamageOnCollisionPacket::decode, DamageOnCollisionPacketHandler))

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

@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common
+
+import com.cobblemon.mod.common.api.data.JsonDataRegistry
+import com.cobblemon.mod.common.api.npc.PartyComposition
+import com.cobblemon.mod.common.api.reactive.SimpleObservable
+import com.cobblemon.mod.common.util.adapters.IdentifierAdapter
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+import com.google.gson.reflect.TypeToken
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.server.packs.PackType
+
+object CobblemonPartyCompositions : JsonDataRegistry<PartyComposition> {
+    override val id: ResourceLocation = cobblemonResource("party_compositions")
+    override val type = PackType.SERVER_DATA
+    override val typeToken: TypeToken<PartyComposition> = TypeToken.get(PartyComposition::class.java)
+    override val resourcePath: String = "party_compositions"
+    override val observable = SimpleObservable<CobblemonPartyCompositions>()
+    override val gson: Gson = GsonBuilder()
+        .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
+        .setPrettyPrinting()
+        .create()
+
+    val partyCompositions = mutableMapOf<ResourceLocation, PartyComposition>()
+
+    override fun sync(player: ServerPlayer) {
+        // probably worth syncing which exist, yeah. the deeper details probably not. I'll get to this eventually.
+    }
+
+    override fun reload(data: Map<ResourceLocation, PartyComposition>) {
+        data.entries.forEach { it.value.id = it.key }
+        partyCompositions.clear()
+        partyCompositions.putAll(data)
+        observable.emit(this)
+        Cobblemon.LOGGER.info("Loaded ${data.size} party compositions.")
+    }
+}

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

@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common
+
+import com.cobblemon.mod.common.api.data.JsonDataRegistry
+import com.cobblemon.mod.common.api.molang.ExpressionLike
+import com.cobblemon.mod.common.api.moves.MovesetBuilder
+import com.cobblemon.mod.common.api.npc.PartyPool
+import com.cobblemon.mod.common.api.pokemon.PokemonProperties
+import com.cobblemon.mod.common.api.reactive.SimpleObservable
+import com.cobblemon.mod.common.util.ScriptableIntRange
+import com.cobblemon.mod.common.util.adapters.ExpressionLikeAdapter
+import com.cobblemon.mod.common.util.adapters.IdentifierAdapter
+import com.cobblemon.mod.common.util.adapters.IntRangeAdapter
+import com.cobblemon.mod.common.util.adapters.MovesetBuilderReferenceAdapter
+import com.cobblemon.mod.common.util.adapters.PokemonPropertiesAdapter
+import com.cobblemon.mod.common.util.adapters.ScriptableIntRangeAdapter
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+import com.google.gson.reflect.TypeToken
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.server.packs.PackType
+
+object CobblemonPartyPools : JsonDataRegistry<PartyPool> {
+    override val id: ResourceLocation = cobblemonResource("party_pools")
+    override val type = PackType.SERVER_DATA
+    override val typeToken: TypeToken<PartyPool> = TypeToken.get(PartyPool::class.java)
+    override val resourcePath: String = "party_pools"
+    override val observable = SimpleObservable<CobblemonPartyPools>()
+    override val gson: Gson = GsonBuilder()
+        .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
+        .registerTypeAdapter(PokemonProperties::class.java, PokemonPropertiesAdapter(saveLong = false))
+        .registerTypeAdapter(IntRange::class.java, IntRangeAdapter)
+        .registerTypeAdapter(ScriptableIntRange::class.java, ScriptableIntRangeAdapter)
+        .registerTypeAdapter(MovesetBuilder::class.java, MovesetBuilderReferenceAdapter)
+        .registerTypeAdapter(ExpressionLike::class.java, ExpressionLikeAdapter)
+        .setPrettyPrinting()
+        .create()
+
+    val partyPools = mutableMapOf<ResourceLocation, PartyPool>()
+
+    override fun sync(player: ServerPlayer) {
+        // probably worth syncing. Knowing the details might help exploit the server? lot of effort for little though.
+    }
+
+    override fun reload(data: Map<ResourceLocation, PartyPool>) {
+        data.entries.forEach { it.value.id = it.key }
+        partyPools.clear()
+        partyPools.putAll(data)
+        observable.emit(this)
+    }
+}

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

@@ -18,7 +18,6 @@ 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
@@ -31,8 +30,6 @@ object CobblemonPoiTypes: PlatformRegistry<Registry<PoiType>, ResourceKey<Regist
     // TODO after 1.7
 //    @JvmField
 //    val INCENSE_SWEET_KEY = createKey("incense_sweet", CobblemonBlocks.INCENSE_SWEET, 0, 1)
-    @JvmField
-    val 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,6 +46,9 @@ 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/CobblemonSounds.kt

@@ -200,6 +200,22 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
     @JvmField
     val TUMBLESTONE_STEP = this.create("block.tumblestone.step")
 
+    @JvmField
+    val TM_USE = this.create("item.tm.use")
+    @JvmField
+    val TM_MACHINE_CRAFT = this.create("block.tm_machine.craft")
+    @JvmField
+    val TM_MACHINE_OFF = this.create("block.tm_machine.off")
+    @JvmField
+    val TM_MACHINE_ON = this.create("block.tm_machine.on")
+    @JvmField
+    val TM_MACHINE_OPEN = this.create("block.tm_machine.open")
+    @JvmField
+    val TM_MACHINE_CLOSE = this.create("block.tm_machine.close")
+    @JvmField
+    val TM_MACHINE_PLACE_DISC = this.create("block.tm_machine.place_disc")
+
+
     @JvmField
     val EVOLUTION_STONE_BLOCK_BREAK = this.create("block.evolution_stone_block.break")
     @JvmField

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

@@ -14,7 +14,7 @@ import com.mojang.serialization.codecs.RecordCodecBuilder
 import net.minecraft.advancements.critereon.ContextAwarePredicate
 import net.minecraft.core.BlockPos
 import net.minecraft.server.level.ServerPlayer
-import java.util.Optional
+import java.util.*
 
 class PlantTumblestoneContext(val pos: BlockPos, val block: TumblestoneBlock)
 
@@ -29,42 +29,6 @@ class PlantTumblestoneCriterion(
     }
 
     override fun matches(player: ServerPlayer, context: PlantTumblestoneContext): Boolean {
-        return context.block.canGrow(context.pos, player.level())
+        return context.block.canGrow(player.level().getBlockState(context.pos), context.pos, player.level())
     }
-}
-
-///**
-// * A criterion condition for when a tumblestone block is planted
-// * @param id The identifier of the criterion
-// * @param predicate The predicate for the criterion
-// *
-// * @author Aethen
-// * @since 02/28/2024
-// */
-//class PlantTumblestoneCriterionCondition(id: Identifier, predicate: LootContextPredicate) :
-//    SimpleCriterionCondition<PlantTumblestoneContext>(id, predicate) {
-//    override fun toJson(json: JsonObject) {
-//        // Add properties to json if needed. None needed for this criterion
-//    }
-//
-//    override fun fromJson(json: JsonObject) {
-//        // Parse properties from json if needed. None needed for this criterion
-//    }
-//
-//    /**
-//     * Checks if the tumblestone block can grow at the given position
-//     * @param player The player that planted the tumblestone block
-//     * @param context The context of the criterion
-//     * @return True if the tumblestone block can grow at the given position, false otherwise
-//     */
-//    override fun matches(player: ServerPlayer, context: PlantTumblestoneContext): Boolean {
-//        return context.tumbleStoneBlock.canGrow(context.pos, player.level())
-//    }
-//}
-//
-///**
-// * The context of the [PlantTumblestoneCriterionCondition]
-// * @param pos The position of the tumblestone block
-// * @param tumbleStoneBlock The tumblestone block
-// */
-//open class PlantTumblestoneContext(var pos: BlockPos, var tumbleStoneBlock: TumblestoneBlock)
+}

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

@@ -1,25 +0,0 @@
-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,15 +12,13 @@ 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
@@ -48,9 +46,6 @@ 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 {
@@ -73,22 +68,6 @@ 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)
     }
@@ -109,23 +88,8 @@ class BehaviourConfigurationContext {
         var brain = entity.brain
         // Apply the brain config
         if (entity is MoLangScriptingEntity) {
-            val useBiggerBrain = objectives.isNotEmpty() || senses.isNotEmpty()
-            brain = entity.assignNewBrainWithMemoriesAndSensors(dynamic, memories, if (useBiggerBrain) emptySet() else sensors)
+            brain = entity.assignNewBrainWithMemoriesAndSensors(dynamic, memories, 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,15 +23,14 @@ 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,40 +9,44 @@
 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. Anything left null
- * will fall back to defaults specified by the logic of the WanderAround objective.
+ * 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.
  *
  * @author Hiroku
  * @since July 18, 2025
  */
 class CobblemonWanderControl(
     var center: WanderCenter? = null,
-    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
+    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,
 ) {
     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") { 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("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("set_center") { params ->
             if (params.params.size < 3) {
                 throw IllegalArgumentException("set_center requires at least 3 parameters: x, y, z")
@@ -64,6 +68,26 @@ 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,23 +9,9 @@
 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
@@ -45,50 +31,6 @@ import net.minecraft.world.entity.LivingEntity
  */
 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,204 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.api.ai.biggerbrain.objective
-
-import com.bedrockk.molang.Expression
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asSimplifiedExpression
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.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

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

@@ -1,166 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.api.ai.biggerbrain.objective
-
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.biggerbrain.MovementTracker
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.Distraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.distraction.idleBoredomDistraction
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.EntityFixation
-import com.cobblemon.mod.common.api.ai.biggerbrain.fixation.MovementTrackerFixation
-import com.cobblemon.mod.common.api.ai.config.objective.ObjectiveConfig
-import com.cobblemon.mod.common.api.ai.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

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

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

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

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

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

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

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

@@ -1,234 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.api.ai.biggerbrain.objective
-
-import com.bedrockk.molang.Expression
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asSimplifiedExpression
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.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

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

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

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

@@ -1,210 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.api.ai.biggerbrain.objective
-
-import com.bedrockk.molang.Expression
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asSimplifiedExpression
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.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

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

@@ -1,159 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.api.ai.biggerbrain.sense
-
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.config.sense.SenseConfig
-import com.cobblemon.mod.common.api.ai.resolveInt
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.asExpression
-import com.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

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

@@ -1,134 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.api.ai.biggerbrain.sense
-
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.config.sense.SenseConfig
-import com.cobblemon.mod.common.api.ai.resolveInt
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.asExpression
-import com.cobblemon.mod.common.util.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

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

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

@@ -1,72 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.api.ai.biggerbrain.sense
-
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.config.sense.SenseConfig
-import com.cobblemon.mod.common.api.ai.resolveInt
-import com.cobblemon.mod.common.entity.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

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

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

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

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

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

@@ -1,109 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.api.ai.biggerbrain.sense
-
-import com.cobblemon.mod.common.CobblemonMemories
-import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
-import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
-import com.cobblemon.mod.common.api.ai.asVariables
-import com.cobblemon.mod.common.api.ai.biggerbrain.BiggerBrain
-import com.cobblemon.mod.common.api.ai.config.sense.SenseConfig
-import com.cobblemon.mod.common.api.ai.resolveInt
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.asExpression
-import com.cobblemon.mod.common.util.getMemorySafely
-import com.mojang.datafixers.util.Either
-import net.minecraft.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

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

@@ -1,40 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.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.mapNotNull { CobblemonBehaviours.behaviours[it]?.takeIf { it.canBeApplied(entity) } }
+        val configurations = behaviours.map { CobblemonBehaviours.behaviours[it]?.takeIf { it.canBeApplied(entity) } ?: return }
         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} at location ${entity.blockPosition()}")
+                Cobblemon.LOGGER.warn("Behaviour $it not found while configuring entity of type ${entity.type}")
             } else if (!resolvedBehaviour.canBeApplied(entity)) {
-                Cobblemon.LOGGER.warn("Behaviour $it is not compatible with entity ${entity.id} at location ${entity.blockPosition()}")
+                Cobblemon.LOGGER.warn("Behaviour $it cannot be applied to entity ${entity.id}")
             } else {
                 return@mapNotNull resolvedBehaviour
             }

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

@@ -35,11 +35,9 @@ import net.minecraft.world.entity.LivingEntity
  */
 interface BehaviourConfig {
     companion object {
-        val types = mutableMapOf(
+        val types = mutableMapOf<ResourceLocation, Class<out BehaviourConfig>>(
             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

@@ -1,66 +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.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

@@ -1,56 +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.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/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,6 +8,7 @@
 
 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/HarvestSweetBerryBushTaskConfig.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.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.HarvestSweetBerryBushTask
+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>()
+    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()
+    }
+}

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

@@ -8,6 +8,7 @@
 
 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

@@ -0,0 +1,36 @@
+/*
+ * 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,6 +43,8 @@ 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

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

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

@@ -106,8 +106,12 @@ interface TaskConfig {
             cobblemonResource("manage_flight_in_battle") to ManageFlightInBattleTaskConfig::class.java,
             cobblemonResource("attack_hostile_mobs") to AttackHostileMobsTaskConfig::class.java,
             cobblemonResource("defend_owner") to DefendOwnerTaskConfig::class.java,
-//            cobblemonResource("eat_held_item") to EatHeldItemTaskConfig::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("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

@@ -144,13 +144,13 @@ class WanderTaskConfig : SingleTaskConfig {
                     if (wanderChance <= 0 || world.random.nextFloat() > wanderChance) {
                         return@Trigger false
                     }
-                    pathCooldown.setWithExpiry(true, 40L)
+                    pathCooldown.setWithExpiry(true, wanderControl.pathCooldownTicks.toLong())
                     val minimumHeight = minimumHeight.resolveInt(mainThreadRuntime)
                     val maximumHeight = maximumHeight.resolveInt(mainThreadRuntime)
 
                     var attempts = 0
                     var pos: BlockPos? = null
-                    while (attempts++ < (wanderControl.maxAttempts ?: 4) && pos == null) {
+                    while (attempts++ < wanderControl.maxAttempts && pos == null) {
 //                    val targetVec = getLandTarget(entity) ?: return@Trigger true
                         val targetVec = if (maximumHeight != -1) {
                             HoverRandomPos.getPos(
@@ -196,7 +196,7 @@ class WanderTaskConfig : SingleTaskConfig {
                             minimumHeight = minimumHeight,
                             maximumHeight = maximumHeight,
                             world = world
-                        )//.takeIf(wanderControl::isSuitable)
+                        ).takeIf(wanderControl::isSuitable)
                     }
 
                     if (pos == null) {
@@ -208,8 +208,17 @@ 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 != true) {
+                    if (!wanderControl.allowWater) {
                         return@Trigger false
                     }
 
@@ -85,17 +85,17 @@ class WaterWanderTaskConfig : SingleTaskConfig {
                         return@Trigger false
                     }
 
-                    pathCooldown.setWithExpiry(true, 40L)
+                    pathCooldown.setWithExpiry(true, wanderControl.pathCooldownTicks.toLong())
 
                     var pos: BlockPos? = null
                     var target: Vec3? = null
                     var attempts = 0
 
-                    while (attempts < wanderControl.maxAttempts ?: 4 && pos == null) {
+                    while (attempts < wanderControl.maxAttempts && pos == null) {
                         attempts++
                         target = BehaviorUtils.getRandomSwimmablePos(entity, horizontalRange.resolveInt(mainThreadRuntime), verticalRange.resolveInt(mainThreadRuntime))
                             ?: continue
-//                        pos = BlockPos.containing(target).takeIf(wanderControl::isSuitable) im migrating shit
+                        pos = BlockPos.containing(target).takeIf(wanderControl::isSuitable)
                     }
 
                     if (pos == null || target == null) {

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

@@ -22,21 +22,18 @@ 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
@@ -51,9 +48,7 @@ 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
@@ -142,9 +137,6 @@ 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()
 
@@ -200,11 +192,6 @@ 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
      *
@@ -257,23 +244,12 @@ 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 opponentPokemons = if (awardToFainted) opponent.pokemonList else opponent.pokemonList.filter { it.health > 0 }
+                val opponentNonFaintedPokemons = opponent.pokemonList.filter { it.health > 0 }
                 faintedPokemons.forEach { faintedPokemon ->
-                    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
-                            }
-                        }
-
+                    for (opponentPokemon in opponentNonFaintedPokemons) {
                         val facedFainted = opponentPokemon.facedOpponents.contains(faintedPokemon)
                         val pokemon = opponentPokemon.effectedPokemon
                         if (facedFainted) {
@@ -294,8 +270,7 @@ open class PokemonBattle(
                             else -> continue
                         }
                         val experience = Cobblemon.experienceCalculator.calculate(opponentPokemon, faintedPokemon, multiplier)
-                        val enemyTeamWiped = actor.pokemonList.all { it.health <= 0 }
-                        if (experience > 0 && (enemyTeamWiped || awardOnLoss)) {
+                        if (experience > 0 && actor.pokemonList.all { it.health <= 0 }) {
                             opponent.awardExperience(opponentPokemon, experience)
                         }
                         Cobblemon.evYieldCalculator.calculate(opponentPokemon, faintedPokemon).forEach { (stat, amount) ->
@@ -530,7 +505,6 @@ open class PokemonBattle(
 
     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() }
@@ -538,20 +512,6 @@ 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 } }