Command and showdown service update for testing team validation.

Signed-off-by: Polymeta <40173118+Polymeta@users.noreply.github.com>

CHANGELOG-AI.md

@@ -12,9 +12,11 @@
 
 ### Developer
 - baseScale in NPCs has been removed from classes and presets, and in the entity it is replaced with hitboxScale and renderScale.
+- Added `EntityCallbacks` to `NPCEntity` and `PokemonEntity`. You can trigger custom callback types by using `[Entity].callbacks.process(...)`
 
 ### MoLang & Datapacks
 - Added a `behaviours` datapack folder which motivates the Behaviour Editor screen on NPCs and Pokémon.
+- Added "callback" support on PokemonEntity and NPCEntity that allows MoLang scripts to be executed in response to certain scenarios.
 - Added very many behaviours to choose from.
 - Removed many NPC presets that now exist as behaviours. This is a breaking change if you are using NPCs with these presets. 
   - NPCs with these presets should be modified to instead list under `"behaviours"` all the equivalent behaviours.

CHANGELOG-COOKING.md

@@ -8,7 +8,8 @@
   - Lure Cakes can be used to modify the spawn rate of Pokémon in the wild.
 - Added the Saccharine Tree, which can be found in the wild and is used to obtain Honey Bottles.
   - The leaves of the tree can be harvested to obtain honey, which can be used in the Campfire Pot to make Lure Cakes.
-  - The Log of the tree can be clicked on with honey to create a Honey Log, which increases the change of spawning a Pokemon with an Hidden Ability.
+  - The Log of the tree can be interacted with using a honey bottle to create a Honey-Slathered Saccharine Log, which increases the change of spawning a Pokémon with a Hidden Ability.
+- Added Hearty Grains
 - Clicking on the Progress Arrow will show the JEI Recipe Book for the Campfire Pot, which will show all recipes that can be made with it.
 - Added a Ton of Redstone Compatibility.
    - Dispenser can now Honey and Unhoney:

CHANGELOG.md

@@ -32,7 +32,19 @@
 - Added `/pctake <player> <box> <slot>` command that takes a specific Pokémon from a player's PC. Removes the pokemon if target is self or ran from the server.
 - Added Hyper Training items (IV Modification) as well as some additional candy items to do so (Health Candy, Sickly Candy)
 - Added Galarica Nut Bushes
+- Many Pokémon (mostly cats) are now feared by phantoms
+- Lightning is now affected by a Pokemon's ability/typing
+  - Pokémon with the ability Lightning Rod draw in lightning similar to a lightning rod block albeit with a lower priority and range, gain immunity to lightning damage, and receive a temporary damage buff.
+  - Pokémon with the ability Motor Drive are immune to lightning damage and receive a temporary speed buff when struck by lightning
+  - Pokémon with the ability Volt Absorb are immune to lightning damage and receive Regeneration II for a short duration
+  - Ground type Pokémon are immune to lightning damage
 - Added functionality to Everstone when held by a Pokémon; suppresses evolution notification and hides evolve button in summary interface.
+- Added new optional property `attachment_options` for most EmitterShapes to be attached to the locator/entities scale, rotation, and/or position. Position is true by default.
+- Galarica Nut bushes now generate on beaches.
+- Some Pokémon now pitch their bodies in the direction they're moving.
+- Added new advancements Didn't Stop To Think, We Need To Cook, and Pokémon Jockey!.
+- Berries can now be smelted into their respective dyes.
+- Added `/runmolang <molang> [<npc>|<player>|<pokemon>]` command that executes a MoLang expression with the provided options as environment variables, as well as the entity (as `q.entity`) that executed the command.
 
 ### Pokémon Added
 
@@ -226,6 +238,17 @@
 - Updated interaction interface to include 4 more option spaces
 - Made lecterns that hold a Pokédex emit light.
 - Updated light levels for active PC, Pasture, Healing Machine, and Data Monitor.
+- Vivichokes now always drop one seed when harvested, and converting a fully grown Vivichoke to seeds via crafting results in 1 seed.
+- Healing Machine recipe rebalanced.
+- Reorganised the `block` texture folder to be more organised, in line with the `item` texture folder.
+- Offset in EmitterShape now ignores scale to be more like Blockbench by default. You can get this behaviour back by adding `"scale": true` in the `attachment_options` property in most EmitterShapes.
+- Not specifying a dex in `/pokedex printcalculations {player} {dex}` will now print the National Dex statistics instead of showing all dexes. `/pokedex printcalculations {player} all` is how to view all dex statistics in one command.
+- Removed Braised Vivichoke
+- Updated Pokémon state icons shown in party interfaces
+- MoLang `face` function can now be run on any `PosableEntity` (Like Pokémon!) instead of just NPCs.
+- MoLang `run_action_effect` now works on Pokémon.
+- Changed MoLang entity function `is_standing_on` to allow for block tags in the list. 
+- Added entity (as `q.entity`) that executed the command to the `executemolangscript` command.
 
 ### Fixes
 - Fixed game crashing when removing national pokedex using datapacks
@@ -291,6 +314,10 @@
 - Fixed Pokédex Scanner not respecting the "Invert Mouse" option.
 - Fixed a crash due to a ConcurrentModificationException that could occur during world generation.
 - Fixed Moon Ball moon phase logic to actually work correctly
+- Fixed `/pokedex printcalculations` to now show the correct percentage completed of the Pokedex
+- Fixed mod incompatibility with the `Raised` mod
+- Fixed a vulnerability that could cause party and PC rollbacks under specific circumstances.
+- Fixed a rare edge case where sorting your PC could be rolled back later.
 
 ### Developer
 - A finished battle now has winners and losers set inside of `PokemonBattle` instead of them always being empty.
@@ -325,10 +352,15 @@
 - The IVs class has now been extended to include Hyper Trained values.
 - Added `Pokemon#hyperTrainIV()` and `IVs#setHyperTrainedIV(Stat, Int)`.
 - Added `HyperTrainedIvEvent.Pre` and `HyperTrainedIvEvent.Post`.
+- Added `Pokemon#validateMoveSet()` to validate an existing Pokemon's moveset, clearing illegal moves.
 - Added a `hoverText` option to PartySelectCallback, to display a tooltip on hovering over a Pokémon in the selection screen.
 - `PokemonEntity` instances spawned into the world now appropriately finalize the spawn for mod compatibility.
 - Added PokedexManager.obtain as a replacement for .catch which is not a friendly function name in Java.
 
+- Added `Pokemon#hyperTrainIV()` and `IVs#setHyperTrainedIV(Stat, Int)`
+- `ElementalType` now implements `ShowdownIdentifiable` to ensure the communcation with showdown stays consistent (also in regards to TeraTypes)
+- Pokemon no longer have a change observable
+  
 ### MoLang & Datapacks
 - The following usages for item predicates can now use item conditions like advancements do, you can learn about them in the [Minecraft wiki](https://minecraft.wiki/w/Advancement_definition#minecraft:filled_bucket)
   - The `requiredContext` for an item interaction evolution
@@ -358,9 +390,28 @@
 - The format of the `remedies.json` file has changed to allow for individual friendshipDrop amounts per remedy
 - Fixed `entity.find_nearby_block` causing crashes when attempting to use a block tag
 - Spawn Filters can now access `v.spawn.class` to get the identifier of an NPC class for when trying to influence NPC spawns
+- Added Molang functions for Party and PC: `set_pokemon`
+- Added Molang functions for Pokémon: `pokeball`, `held_item`, `remove_held_item`, `hyper_train_iv`, `validate_moveset`, `initialize_moveset`, and `add_exp`.
+- Added Molang functions for Pokémon: `aspects`, `form_aspects`, `unlearn_move`, `teach_learnable_moves`, `cosmetic_item`, and `remove_cosmetic_item`.
+- Added Molang functions for Pokémon: `ability`, `set_iv`, `set_ev`, `teach_move`, and `can_learn_move`.
+- Added Molang function `q.delete_variable(<struct>, <variable_name>)` to delete a value from a variable structure in MoLang data.
+- Added Molang function `q.delete_variables(<struct>)` to delete all values from a variable structure in MoLang data.
+- Adds Flows for `STARTER_CHOSEN`, `SHOULDER_MOUNTED`, `EV_GAINED`, `POKEMON_RELEASED`, `POKEMON_NICKNAMED`, `HELD_ITEM`, and `TRADE_COMPLETED` events
+- Adds Flows for `POKEMON_HEALED`, `POKEMON_SCANNED`, `BERRY_HARVEST`, `LOOT_DROPPED`, `POKEMON_SEEN`, `COLLECT_EGG`, `HATCH_EGG`, and `EXPERIENCE_GAINED`.
+- Adds Flows for `POKEMON_CATCH_RATE`, `BAIT_SET`, `BAIT_SET_PRE`, `BAIT_CONSUMED`, `POKEROD_CAST_PRE`, `POKEROD_CAST_POST`, `POKEROD_REEL`, and `BOBBER_SPAWN_POKEMON_PRE`.
+- Adds Flows for `POKEMON_ASPECTS_CHANGED`, `FRIENDSHIP_UPDATED`, `CHANGE_PC_BOX_WALLPAPER_EVENT_PRE`, `CHANGE_PC_BOX_WALLPAPER_EVENT_POST`, and `FULLNESS_UPDATED`.
+- MoLang triggered battles may now set the battle format, whether to clone the player's party, set level, or heal prior.
+- Added Molang function for Player: `inventory`
 - Adds Flows for `STARTER_CHOSEN`, `EV_GAINED`, `POKEMON_RELEASED`, `POKEMON_NICKNAMED`, `HELD_ITEM`, and `TRADE_COMPLETED` events
-- Adds Pokemon functions for `pokeball`, `held_item` and `remove_held_item`
+- Adds Pokemon functions for `pokeball`, `held_item`, `remove_held_item`, `add_aspects`, and `remove_aspects`
 - Added `pokemon.hyper_train_iv` as an available Molang function.
+- Added `prepare_{effect}` and `damage_{effect}` action effect hooks in battles for more battle particle effects.
+- Added `q.has_argument(<argument_name>, [argument_value])` MoLang function to several battle-related action effect contexts.
+- Added `q.has_argument_at(<index>, [argument_value])` MoLang function to several battle-related action effect contexts.
+- Added `q.hit_count` MoLang function to move action effect contexts.
+- Added `is_included`, `to_lower`, `to_upper`, and `string_length` as available Molang functions.
+- Fixed a crash that would occur during battles if the opponent wild Pokémon species comes from a namespace other than cobblemon
+- Fixed `clientActions` inside Dialogue pages being executed twice
 
 ## [1.6.1 (January 26th, 2025)](#1-6-1)
 

common/src/main/java/com/cobblemon/mod/common/DoubleJump.java

@@ -0,0 +1,13 @@
+/*
+ * 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;
+
+public interface DoubleJump {
+    boolean isDoubleJumping();
+}

common/src/main/java/com/cobblemon/mod/common/OrientationControllable.java

@@ -9,15 +9,6 @@
 package com.cobblemon.mod.common;
 
 import com.cobblemon.mod.common.api.orientation.OrientationController;
-import net.minecraft.util.Mth;
-import net.minecraft.util.SmoothDouble;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.phys.Vec3;
-import org.jetbrains.annotations.Nullable;
-import org.joml.Matrix3f;
-import org.joml.Vector3f;
-
-import java.util.function.Function;
 
 public interface OrientationControllable {
     OrientationController getOrientationController();

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

@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.duck;
+
+public interface ChannelDuck {
+    void cobblemon$applyLowPassFilter(float gain, float hfGain);
+    void cobblemon$inverseAttenuation(float rolloffFactor);
+    void cobblemon$clearFilters();
+
+//    void cobblemon$exponentialAttenuation(float rolloff, float refDistance, float maxDistance);
+}

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

@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.duck;
+
+import org.joml.Vector3f;
+
+public interface PlayerDuck {
+	void setDriverInput(Vector3f driverInput);
+	Vector3f getDriverInput();
+	void setLastSentDriverInput(Vector3f driverInput);
+	Vector3f getLastSentDriverInput();
+}

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

@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+import com.cobblemon.mod.common.duck.ChannelDuck;
+import com.mojang.blaze3d.audio.Channel;
+import org.lwjgl.openal.AL10;
+import org.lwjgl.openal.EXTEfx;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+
+@Mixin(Channel.class)
+public abstract class ChannelMixin implements ChannelDuck {
+
+    @Shadow
+    private int source;
+
+    // Id of filter applied when sound is obstructed
+    private int cobblemon$lowPassFilterId = 0;
+
+    @Override
+    public void cobblemon$applyLowPassFilter(float gain, float hfGain) {
+        // Delete old filter if it exists
+        if (cobblemon$lowPassFilterId != 0) {
+            AL10.alSourcei(source, EXTEfx.AL_DIRECT_FILTER, 0); // Detach filter from source
+            EXTEfx.alDeleteFilters(cobblemon$lowPassFilterId);  // Delete old filter
+            cobblemon$lowPassFilterId = 0;
+        }
+
+        // Generate a fresh filter
+        int filterId = EXTEfx.alGenFilters();
+        if (!EXTEfx.alIsFilter(filterId)) {
+            System.err.println("Failed to create OpenAL low-pass filter");
+            return;
+        }
+
+        EXTEfx.alFilteri(filterId, EXTEfx.AL_FILTER_TYPE, EXTEfx.AL_FILTER_LOWPASS);
+        EXTEfx.alFilterf(filterId, EXTEfx.AL_LOWPASS_GAIN, gain);
+        EXTEfx.alFilterf(filterId, EXTEfx.AL_LOWPASS_GAINHF, hfGain);
+
+        AL10.alSourcei(source, EXTEfx.AL_DIRECT_FILTER, filterId);
+
+        // Save the new filter ID
+        cobblemon$lowPassFilterId = filterId;
+    }
+
+    @Override
+    public void cobblemon$inverseAttenuation(float rolloffFactor) {
+        AL10.alSourcei(source, AL10.AL_DISTANCE_MODEL, AL10.AL_INVERSE_DISTANCE);
+        AL10.alSourcef(source, AL10.AL_ROLLOFF_FACTOR,    rolloffFactor);
+        AL10.alSourcef(source, AL10.AL_REFERENCE_DISTANCE, 1.0f);
+        AL10.alSourcef(source, AL10.AL_MAX_DISTANCE,       0.0f);
+    }
+
+    @Override
+    public void cobblemon$clearFilters() {
+        AL10.alSourcei(source, EXTEfx.AL_DIRECT_FILTER, 0);
+
+        if (EXTEfx.alIsFilter(cobblemon$lowPassFilterId)) {
+            EXTEfx.alDeleteFilters(cobblemon$lowPassFilterId);
+            cobblemon$lowPassFilterId = 0;
+        }
+    }
+}

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

@@ -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.mixin;
-
-import net.minecraft.world.entity.monster.Phantom;
-import org.spongepowered.asm.mixin.Mixin;
-
-@Mixin(targets = "net/minecraft/world/entity/monster/Phantom$PhantomSweepAttackGoal")
-public class EntityPhantomMixin {
-    // TODO: Figure out how to access the outer class that wraps SwoopMovementGoal
-    // Need to find the cat mons that are near the phantom
-
-//    @Inject(method = "shouldContinue", at = @At(value = "RETURN"), cancellable = true)
-//    public void cobblemon$shouldContinue(CallbackInfoReturnable<Boolean> ci) {
-////        var goalSelectorField = PhantomEntity.class.getClasses();// PhantomEntity.class.getFields();// .class.getDeclaredField("goalSelector");
-//
-////        goalSelectorField.setAccessible(true);
-////        GoalSelector goalSelector = (GoalSelector) goalSelectorField.get(mobEntity);
-////        final SwoopMovementGoal phantom = (SwoopMovementGoal) (Object) this;
-////        if(ci.getReturnValue() == false) {
-////            var result = this$0.getWorld().getEntitiesByClass(
-////                    PokemonEntity.class,
-////                    this$0.getBoundingBox().expand(16.0),
-////                    entity ->  {
-////                        return ((PokemonEntity) entity).getBehaviour().getEntityInteract().getAvoidedByPhantom();
-////                    }
-////            ).isEmpty();
-////
-////                ci.setReturnValue(result);
-////        }
-//    }
-}
-

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

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.LightningBolt;
+import net.minecraft.world.phys.AABB;
+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.CallbackInfo;
+
+import java.util.List;
+
+
+@Mixin(LightningBolt.class)
+public abstract class LightningBoltMixin {
+
+    @Inject(method = "spawnFire", at = @At(value = "Head"), cancellable = true)
+    private void cobblemon$spawnFire(int extraIgnitions, CallbackInfo ci) {
+        // This prevents fire from spawning around Pokemon who otherwise should be immune to lightning and effectively absorb the hit
+        final LightningBolt lightningBolt = (LightningBolt) (Object) this;
+        List<Entity> list = lightningBolt.level().getEntities(
+                lightningBolt,
+                new AABB(lightningBolt.getX() - 2.0, lightningBolt.getY() - 2.0, lightningBolt.getZ() - 2.0, lightningBolt.getX() + 2.0, lightningBolt.getY() + 2.0, lightningBolt.getZ() + 2.0),
+                it -> {
+                    if (!it.isAlive() || !(it instanceof PokemonEntity)) {
+                        return false;
+                    }
+                    String abilityName = ((PokemonEntity) it).getPokemon().getAbility().getName();
+                    return abilityName.equals("lightningrod") || abilityName.equals("voltabsorb") || abilityName.equals("motordrive");
+                });
+        if (!list.isEmpty()) {
+            ci.cancel();
+        }
+    }
+}

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

@@ -8,17 +8,44 @@
 
 package com.cobblemon.mod.common.mixin;
 
+import com.cobblemon.mod.common.OrientationControllable;
+import com.cobblemon.mod.common.api.orientation.OrientationController;
 import com.cobblemon.mod.common.api.pokemon.effect.ShoulderEffectRegistry;
+import com.cobblemon.mod.common.api.riding.Seat;
+import com.cobblemon.mod.common.client.entity.PokemonClientDelegate;
+import com.cobblemon.mod.common.client.render.MatrixWrapper;
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.effect.MobEffectInstance;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.EntityType;
 import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.level.ClipContext;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.phys.HitResult;
+import net.minecraft.world.phys.Vec3;
+import org.jetbrains.annotations.NotNull;
+import org.joml.Quaternionf;
+import org.joml.Vector3f;
 import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 @Mixin(LivingEntity.class)
-public abstract class LivingEntityMixin {
+public abstract class LivingEntityMixin extends Entity implements OrientationControllable {
+
+    public LivingEntityMixin(EntityType<?> entityType, Level level) {
+        super(entityType, level);
+    }
+
+    @Unique
+    private final OrientationController cobblemon$orientationController = new OrientationController((LivingEntity) (Object) this);
+
+    public OrientationController getOrientationController() {
+        return cobblemon$orientationController;
+    }
 
     @Inject(method = "onEffectRemoved", at = @At(value = "TAIL"))
     private void cobblemon$onEffectRemoved(MobEffectInstance effect, CallbackInfo ci) {
@@ -28,4 +55,67 @@ public abstract class LivingEntityMixin {
         }
     }
 
+    @Override
+    public @NotNull HitResult pick(double hitDistance, float partialTicks, boolean hitFluids) {
+        Entity vehicle = this.getVehicle();
+        if (vehicle instanceof PokemonEntity pokemonEntity) {
+            int seatIndex = pokemonEntity.getPassengers().indexOf(this);
+            Seat seat = pokemonEntity.getSeats().get(seatIndex);
+
+            PokemonClientDelegate delegate = (PokemonClientDelegate) pokemonEntity.getDelegate();
+            MatrixWrapper locator = delegate.getLocatorStates().get(seat.getLocator());
+
+            Vec3 locatorOffset = new Vec3(locator.getMatrix().getTranslation(new Vector3f()));
+
+            Vec3 eyePosition = cobblemon$getEyePosition(partialTicks, pokemonEntity, locatorOffset);
+
+            Vec3 viewVector = this.getViewVector(partialTicks);
+            Vec3 viewDistanceVector = eyePosition.add(viewVector.x * hitDistance, viewVector.y * hitDistance, viewVector.z * hitDistance);
+
+            return this.level()
+                    .clip(
+                            new ClipContext(
+                                    eyePosition, viewDistanceVector, ClipContext.Block.OUTLINE, hitFluids ? net.minecraft.world.level.ClipContext.Fluid.ANY : net.minecraft.world.level.ClipContext.Fluid.NONE, this
+                            )
+                    );
+        }
+
+        return super.pick(hitDistance, partialTicks, hitFluids);
+    }
+
+    @Unique
+    private Vec3 cobblemon$getEyePosition(float partialTicks, PokemonEntity pokemonEntity, Vec3 locatorOffset) {
+        OrientationController controller = this.getOrientationController();
+
+        float currEyeHeight = this.getEyeHeight();
+        Vec3 offset = locatorOffset.add(pokemonEntity.position());
+        if (controller.isActive() && controller.getOrientation() != null) {
+            Quaternionf orientation = controller.getRenderOrientation(partialTicks);
+            Vec3 rotatedEyeHeight = new Vec3(orientation.transform(new Vector3f(0f, currEyeHeight - (this.getBbHeight() / 2), 0f)));
+
+            offset.add(rotatedEyeHeight);
+        }
+
+        return offset;
+    }
+
+    @Inject(method = "tick", at = @At("HEAD"))
+    private void cobblemon$updateRenderOrientation(CallbackInfo ci) {
+        this.cobblemon$orientationController.tick();
+    }
+
+    @Override
+    public void absMoveTo(double x, double y, double z, float yaw, float pitch) {
+        if (cobblemon$orientationController.getActive()) {
+            this.absMoveTo(x, y, z);
+            this.setYRot(yaw % 360.0f);
+            this.setXRot(pitch % 360.0f);
+            this.yRotO = this.getYRot();
+            this.xRotO = this.getXRot();
+        } else {
+            this.absMoveTo(x, y, z);
+            this.absRotateTo(yaw, pitch);
+        }
+    }
+
 }

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

@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import com.cobblemon.mod.common.pokemon.ai.EntityBehaviour;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.ai.goal.Goal;
+import net.minecraft.world.entity.monster.Phantom;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+
+
+@Mixin(targets = "net.minecraft.world.entity.monster.Phantom$PhantomSweepAttackGoal")
+public abstract class PhantomSweepAttackGoalMixin extends Goal {
+
+    @Unique
+    private Phantom phantomSelf; // Allows access to the outer class
+
+    @Inject(method = "<init>", at = @At("TAIL"))
+    private void onInit(Phantom phantom, CallbackInfo ci) {
+        this.phantomSelf = phantom;
+    }
+
+    @Inject(method = "canContinueToUse", at = @At("RETURN"), cancellable = true)
+    private void modifyCanContinueToUse(CallbackInfoReturnable<Boolean> cir) {
+        Phantom phantom = this.phantomSelf; // Outer class instance
+        if(phantom == null) return;
+
+        if (cir.getReturnValue()) {
+            var nearbyFearedEntities = phantom.level().getEntities(phantom, phantom.getBoundingBox().inflate(16.0),
+                    (entity -> ((entity instanceof PokemonEntity && ((PokemonEntity) entity).getBeamMode() == 0 && ((PokemonEntity) entity).getBehaviour().getEntityInteract().getAvoidedByPhantom())
+                            || (entity instanceof ServerPlayer && EntityBehaviour.Companion.hasPhantomFearedShoulderMount((ServerPlayer)entity)))));
+            if (!nearbyFearedEntities.isEmpty()) {
+               nearbyFearedEntities.forEach(entity -> {
+                   if (entity instanceof PokemonEntity) {
+                       ((PokemonEntity) entity).cry();
+                   }
+                   //TODO: Find a way to make shoulder mounted Pokemon cry
+               });
+                cir.setReturnValue(false);
+            }
+        }
+    }
+}
+

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

@@ -18,6 +18,7 @@ import com.cobblemon.mod.common.api.pokemon.PokemonSpecies;
 import com.cobblemon.mod.common.api.storage.party.PartyStore;
 import com.cobblemon.mod.common.api.storage.party.PlayerPartyStore;
 import com.cobblemon.mod.common.api.tags.CobblemonItemTags;
+import com.cobblemon.mod.common.duck.PlayerDuck;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
 import com.cobblemon.mod.common.pokedex.scanner.PokedexEntityData;
 import com.cobblemon.mod.common.pokedex.scanner.ScannableEntity;
@@ -47,6 +48,7 @@ import net.minecraft.world.food.FoodProperties;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.level.Level;
 import org.jetbrains.annotations.Nullable;
+import org.joml.Vector3f;
 import org.objectweb.asm.Opcodes;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
@@ -61,7 +63,12 @@ import java.util.*;
 import java.util.stream.Collectors;
 
 @Mixin(Player.class)
-public abstract class PlayerMixin extends LivingEntity implements ScannableEntity, OrientationControllable {
+public abstract class PlayerMixin extends LivingEntity implements ScannableEntity, OrientationControllable, PlayerDuck {
+
+    @Unique
+    private Vector3f cobblemon$driverInput;
+    @Unique
+    private Vector3f cobblemon$lastSentDriverInput;
 
     @Shadow public abstract CompoundTag getShoulderEntityLeft();
 
@@ -81,8 +88,8 @@ public abstract class PlayerMixin extends LivingEntity implements ScannableEntit
 
     @Shadow @Final private static Map<Pose, EntityDimensions> POSES;
     @Shadow @Final public static EntityDimensions STANDING_DIMENSIONS;
-    @Unique
-    private final OrientationController cobblemon$orientationController = new OrientationController(this);
+    @Shadow protected int jumpTriggerTime;
+    @Unique private final OrientationController cobblemon$orientationController = new OrientationController(this);
 
     protected PlayerMixin(EntityType<? extends LivingEntity> p_20966_, Level p_20967_) {
         super(p_20966_, p_20967_);
@@ -279,4 +286,25 @@ public abstract class PlayerMixin extends LivingEntity implements ScannableEntit
     public OrientationController getOrientationController() {
         return cobblemon$orientationController;
     }
+
+    @Override
+    public void setDriverInput(Vector3f driverInput) {
+        cobblemon$driverInput = driverInput;
+    }
+
+    @Override
+    public Vector3f getDriverInput() {
+        return cobblemon$driverInput;
+    }
+
+    @Override
+    public void setLastSentDriverInput(Vector3f lastSentDriverInput) {
+        cobblemon$lastSentDriverInput = lastSentDriverInput;
+    }
+
+    @Override
+    public Vector3f getLastSentDriverInput() {
+        return cobblemon$lastSentDriverInput;
+    }
+
 }

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

@@ -12,9 +12,11 @@ import com.cobblemon.mod.common.CobblemonNetwork;
 import com.cobblemon.mod.common.OrientationControllable;
 import com.cobblemon.mod.common.api.net.NetworkPacket;
 import com.cobblemon.mod.common.api.orientation.OrientationController;
+import com.cobblemon.mod.common.duck.PlayerDuck;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
 import com.cobblemon.mod.common.mixin.accessor.ChunkMapAccessor;
 import com.cobblemon.mod.common.mixin.accessor.TrackedEntityAccessor;
+import com.cobblemon.mod.common.net.messages.client.orientation.ClientboundUpdateDriverInputPacket;
 import com.cobblemon.mod.common.net.messages.client.orientation.ClientboundUpdateOrientationPacket;
 import com.cobblemon.mod.common.net.messages.client.pokemon.update.ClientboundUpdateRidingStatePacket;
 import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
@@ -26,6 +28,7 @@ import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.server.network.ServerPlayerConnection;
 import net.minecraft.world.entity.Entity;
 import org.joml.Matrix3f;
+import org.joml.Vector3f;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
@@ -55,17 +58,20 @@ public abstract class ServerEntityMixin {
     private void cobblemon$sendChanges(CallbackInfo ci) {
         cobblemon$sendOrientationChanges();
         cobblemon$sendRidingStateChanges();
+        cobblemon$sendDriverInput();
     }
 
     private void cobblemon$sendRidingStateChanges() {
         if (!(this.entity instanceof PokemonEntity pokemonEntity)) return;
-        if (pokemonEntity.getRidingState() == null) return;
-        if (pokemonEntity.getRiding() == null) return;
-        var ridingBehaviour = pokemonEntity.getRiding();
-        var ridingState = pokemonEntity.getRidingState();
+        if (pokemonEntity.getRidingController() == null) return;
+        var ridingController = pokemonEntity.getRidingController();
+        if (ridingController.getContext() == null) return;
+        var context = ridingController.getContext();
+        var ridingBehaviour = context.getBehaviour();
+        var ridingState = context.getState();
         var previousRidingState = pokemonEntity.getPreviousRidingState();
         if (previousRidingState != null && !ridingState.shouldSync(previousRidingState)) return;
-        cobblemon$broadcast(new ClientboundUpdateRidingStatePacket(pokemonEntity.getId(), ridingBehaviour.getKey(), pokemonEntity.getRidingState(), null));
+        cobblemon$broadcast(new ClientboundUpdateRidingStatePacket(pokemonEntity.getId(), ridingBehaviour, ridingState, null));
     }
 
     private void cobblemon$sendOrientationChanges() {
@@ -82,6 +88,19 @@ public abstract class ServerEntityMixin {
         cobblemon$broadcast(new ClientboundUpdateOrientationPacket(currOrientation, currActive, entity.getId()));
     }
 
+    private void cobblemon$sendDriverInput() {
+        if (!(this.entity instanceof ServerPlayer serverPlayer)) return;
+        if(!(serverPlayer.getVehicle() instanceof PokemonEntity)) return;
+        Vector3f driverInput = ((PlayerDuck)serverPlayer).getDriverInput();
+        if(driverInput == null) return;
+
+        // If no change in input is detected then don't send a new packet
+        Vector3f lastSentDriverInput = ((PlayerDuck)serverPlayer).getLastSentDriverInput();
+        if (driverInput.equals(lastSentDriverInput)) return;
+        ((PlayerDuck)serverPlayer).setLastSentDriverInput(driverInput);
+        cobblemon$broadcast(new ClientboundUpdateDriverInputPacket(driverInput, entity.getId()));
+    }
+
     private void cobblemon$broadcast(NetworkPacket<?> packet) {
         if (!(entity.level() instanceof ServerLevel level)) return;
         ChunkMap chunkMap = level.getChunkSource().chunkMap;
@@ -97,5 +116,4 @@ public abstract class ServerEntityMixin {
         }
     }
 
-
 }

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

@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.phys.AABB;
+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;
+
+import java.util.List;
+import java.util.Optional;
+
+
+@Mixin(ServerLevel.class)
+public abstract class ServerLevelMixin {
+
+    @Inject(method = "findLightningRod", at = @At(value = "RETURN"), cancellable = true)
+    private void cobblemon$findLightningRod(BlockPos blockPos, CallbackInfoReturnable<Optional<BlockPos>> ci) {
+        final ServerLevel serverLevel = (ServerLevel) (Object) this;
+        if (ci.getReturnValue().isEmpty()) {
+            // Search for Pokemon with the ability Lightning Rod and redirect to them
+            AABB aABB = AABB.encapsulatingFullBlocks(blockPos, new BlockPos(blockPos.atY(serverLevel.getMaxBuildHeight()))).inflate(64.0);
+            List<LivingEntity> list = serverLevel.getEntitiesOfClass(LivingEntity.class, aABB, (livingEntity) -> livingEntity != null
+                    && livingEntity.isAlive()
+                    && livingEntity instanceof PokemonEntity
+                    && ((PokemonEntity) livingEntity).getBeamMode() == 0
+                    && ((PokemonEntity) livingEntity).getPokemon().getAbility().getName().equals("lightningrod"));
+            if (!list.isEmpty()) {
+                ci.setReturnValue(Optional.of((list.get(serverLevel.random.nextInt(list.size()))).blockPosition()));
+            }
+        }
+    }
+}

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

@@ -10,7 +10,10 @@ package com.cobblemon.mod.common.mixin;
 
 import com.cobblemon.mod.common.OrientationControllable;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
+import com.llamalad7.mixinextras.sugar.Local;
 import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.Entity;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
@@ -43,4 +46,10 @@ public abstract class ServerPlayerMixin {
         controllable.getOrientationController().setActive(false);
     }
 
+    //TODO: Switch to sending out on load instead of preventing saving
+    @ModifyExpressionValue(method = "addAdditionalSaveData", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/entity/Entity;hasExactlyOnePlayerPassenger()Z"))
+    private boolean cobblemon$cancelSavingPokemonMounts(boolean original, @Local(ordinal=0) Entity entity) {
+        return original && !(entity instanceof PokemonEntity);
+    }
+
 }

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

@@ -0,0 +1,50 @@
+/*
+ * 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.HeartyGrainsBlock;
+import com.llamalad7.mixinextras.sugar.Local;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.WorldGenLevel;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.DoublePlantBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.properties.DoubleBlockHalf;
+import net.minecraft.world.level.levelgen.feature.FeaturePlaceContext;
+import net.minecraft.world.level.levelgen.feature.SimpleBlockFeature;
+import net.minecraft.world.level.levelgen.feature.configurations.SimpleBlockConfiguration;
+import org.spongepowered.asm.mixin.Debug;
+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(SimpleBlockFeature.class)
+@Debug(export = true, print = true)
+public class SimpleBlockFeatureMixin {
+    //this mixin inserts the logic needed to ensure that when hearty grains are of a certain age, they place with the upper block too
+    //similarly to what the doubleblock logic is here
+    @Inject(method = "place", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/level/block/state/BlockState;canSurvive(Lnet/minecraft/world/level/LevelReader;Lnet/minecraft/core/BlockPos;)Z", shift = At.Shift.AFTER), cancellable = true)
+    public void place(FeaturePlaceContext<SimpleBlockConfiguration> context, CallbackInfoReturnable<Boolean> cir,
+                      @Local BlockState blockState, @Local BlockPos blockPos, @Local WorldGenLevel worldGenLevel) {
+        if (!(blockState.getBlock() instanceof HeartyGrainsBlock)) {
+            return;
+        }
+        if (blockState.getValue(HeartyGrainsBlock.Companion.getAGE()) <= HeartyGrainsBlock.AGE_AFTER_HARVEST) {
+            return; //block is too young to be double
+        }
+        if (!worldGenLevel.isEmptyBlock(blockPos.above())) {
+            cir.setReturnValue(false); //no space for the 2nd block above
+            return;
+        }
+        DoublePlantBlock.placeAt(worldGenLevel, blockState, blockPos, Block.UPDATE_CLIENTS);
+        cir.setReturnValue(true);
+    }
+}

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

@@ -8,23 +8,33 @@
 
 package com.cobblemon.mod.common.mixin;
 
+import com.cobblemon.mod.common.api.riding.sound.RideAttenuationModel;
+import com.cobblemon.mod.common.api.riding.sound.RideLoopSound;
 import com.cobblemon.mod.common.client.sound.BattleMusicController;
+import com.cobblemon.mod.common.duck.ChannelDuck;
 import com.cobblemon.mod.common.duck.SoundEngineDuck;
 import com.google.common.collect.Multimap;
+import com.llamalad7.mixinextras.sugar.Local;
 import com.mojang.blaze3d.audio.Channel;
+import net.minecraft.client.resources.sounds.Sound;
 import net.minecraft.client.resources.sounds.SoundInstance;
+import net.minecraft.client.resources.sounds.TickableSoundInstance;
 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.world.phys.Vec3;
 import org.jetbrains.annotations.Nullable;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
 
+import java.util.Iterator;
 import java.util.Map;
 
 @Mixin(SoundEngine.class)
@@ -45,6 +55,86 @@ public abstract class SoundEngineMixin implements SoundEngineDuck {
     @Shadow
     public abstract boolean isActive(SoundInstance sound);
 
+    @Inject(method = "play",
+            at = @At(
+                    value = "INVOKE",
+                    target = "Lnet/minecraft/client/sounds/ChannelAccess$ChannelHandle;execute(Ljava/util/function/Consumer;)V"
+            ),
+            cancellable = true
+    )
+    private void cobblemon$overrideChannelExecute(
+            SoundInstance sound,
+            CallbackInfo ci,
+            @Local(name = "h") float h,
+            @Local(name = "i") float i,
+            @Local(name = "g") float g,
+            @Local(name = "bl2") boolean bl2,
+            @Local(name = "bl3") boolean bl3,
+            @Local(name = "bl") boolean bl,
+            @Local(name = "vec3") Vec3 vec3,
+            @Local(name = "channelHandle") ChannelAccess.ChannelHandle handle
+    ) {
+        if (!(sound instanceof RideLoopSound rideSound)) return;
+
+        if (handle == null) return;
+
+        handle.execute((channel) -> {
+            channel.setPitch(i);
+            channel.setVolume(h);
+
+            if (rideSound.getRideAttenuation() == RideAttenuationModel.LINEAR) {
+                channel.linearAttenuation(g);
+            } else if (rideSound.getRideAttenuation() == RideAttenuationModel.EXPONENTIAL){
+                ((ChannelDuck) channel).cobblemon$inverseAttenuation(g);
+            } else {
+                channel.disableAttenuation();
+            }
+
+            // Apply low pass filter if the rideSound dictate that it should be muffled
+            if (rideSound.getShouldMuffle()) {
+                ((ChannelDuck) channel).cobblemon$applyLowPassFilter(1.0f, rideSound.getMuffleAmount());
+            } else {
+                ((ChannelDuck) channel).cobblemon$clearFilters();
+            }
+
+            channel.setLooping(bl2 && !bl3);
+            channel.setSelfPosition(vec3);
+            channel.setRelative(bl);
+        });
+    }
+
+    @Inject(
+            method = "tickNonPaused",
+            at = @At(
+                    value = "INVOKE",
+                    target = "Lnet/minecraft/client/sounds/ChannelAccess$ChannelHandle;execute(Ljava/util/function/Consumer;)V",
+                    ordinal = 0
+            )
+    )
+    private void cobblemon$tickableSoundTick(
+            CallbackInfo ci,
+            @Local(name = "tickableSoundInstance") TickableSoundInstance instance,
+            @Local(name = "channelHandle", ordinal = 0) ChannelAccess.ChannelHandle handle,
+            @Local(name = "f", ordinal = 0) float volume,
+            @Local(name = "g", ordinal = 0) float pitch,
+            @Local(name = "vec3", ordinal = 0) Vec3 vec3
+    ) {
+        if (!(instance instanceof RideLoopSound rideSound)) return;
+
+        handle.execute(channel -> {
+            channel.setVolume(volume);
+            channel.setPitch(pitch);
+            channel.setSelfPosition(vec3);
+
+            // Apply low pass filter if the rideSound dictate that it should be muffled
+            if (rideSound.getShouldMuffle()) {
+                ((ChannelDuck) channel).cobblemon$applyLowPassFilter(1.0f, rideSound.getMuffleAmount());
+            } else {
+                ((ChannelDuck) channel).cobblemon$clearFilters();
+            }
+        });
+    }
+
     /** Resumes the Source belonging to the queried SoundInstance. */
     private void resume(SoundInstance sound) {
         ChannelAccess.ChannelHandle sourceManager = this.instanceToChannel.get(sound);

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

@@ -8,6 +8,7 @@
 
 package com.cobblemon.mod.common.mixin.accessor;
 
+import net.minecraft.server.level.ServerEntity;
 import net.minecraft.server.network.ServerPlayerConnection;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.gen.Accessor;
@@ -18,4 +19,7 @@ import java.util.Set;
 public interface TrackedEntityAccessor {
     @Accessor("seenBy")
     Set<ServerPlayerConnection> getSeenBy();
+
+    @Accessor("serverEntity")
+    ServerEntity getServerEntity();
 }

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

@@ -11,6 +11,7 @@ package com.cobblemon.mod.common.mixin.client;
 import com.cobblemon.mod.common.CobblemonRecipeCategories;
 import com.cobblemon.mod.common.item.crafting.CookingPotBookCategory;
 import com.cobblemon.mod.common.item.crafting.CookingPotRecipe;
+import com.cobblemon.mod.common.item.crafting.CookingPotRecipeBase;
 import com.cobblemon.mod.common.item.crafting.CookingPotShapelessRecipe;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
@@ -48,10 +49,8 @@ public abstract class ClientRecipeBookMixin {
     @Inject(method = "getCategory", at = @At(value = "HEAD"), cancellable = true)
     private static void addCustomCategory(RecipeHolder<?> recipe, CallbackInfoReturnable<RecipeBookCategories> cir) {
         Recipe<?> recipe2 = recipe.value();
-        if (recipe2 instanceof CookingPotRecipe || recipe2 instanceof CookingPotShapelessRecipe) {
-            CookingPotBookCategory category = recipe2 instanceof CookingPotRecipe
-                    ? ((CookingPotRecipe) recipe2).getCategory()
-                    : ((CookingPotShapelessRecipe) recipe2).category();
+        if (recipe2 instanceof CookingPotRecipeBase) {
+            CookingPotBookCategory category = ((CookingPotRecipeBase) recipe2).getCategory();
             RecipeBookCategories var7;
             switch (category) {
                 case MISC -> var7 = CobblemonRecipeCategories.COOKING_POT_MISC.toVanillaCategory();

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

@@ -9,22 +9,21 @@
 package com.cobblemon.mod.common.mixin.client;
 
 import com.cobblemon.mod.common.client.gui.ScrollingWidget;
+import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
 import net.minecraft.client.gui.components.AbstractSelectionList;
 import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.Constant;
-import org.spongepowered.asm.mixin.injection.ModifyConstant;
+import org.spongepowered.asm.mixin.injection.At;
 
 @Mixin(AbstractSelectionList.class)
 public abstract class EntryListWidgetMixin {
 
     @SuppressWarnings("ConstantValue")
-    @ModifyConstant(method = "getEntryAtPosition", constant = @Constant(intValue = 4))
-    public int cobblemon$adjustOnlyIfNecessary(int input) {
+    @ModifyExpressionValue(method = "getEntryAtPosition", at = @At(value = "CONSTANT", args = {"intValue=4"}))
+    public int cobblemon$adjustOnlyIfNecessary(int original) {
         if(ScrollingWidget.class.isInstance(this)) {
             return 0;
         }
 
-        return input;
+        return original;
     }
-
 }

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

@@ -8,6 +8,7 @@
 
 package com.cobblemon.mod.common.mixin.client;
 
+import com.cobblemon.mod.common.OrientationControllable;
 import com.cobblemon.mod.common.client.render.player.MountedPlayerRenderer;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
 import net.minecraft.client.model.HumanoidModel;
@@ -59,9 +60,9 @@ public class HumanoidModelMixin {
         }
 
         Entity vehicle = entity.getVehicle();
-        if (vehicle instanceof PokemonEntity pokemonEntity && entity instanceof AbstractClientPlayer) {
+        if (vehicle instanceof PokemonEntity pokemonEntity && entity instanceof OrientationControllable) {
             var shouldRotatePlayerHead = pokemonEntity.ifRidingAvailableSupply(false, (behaviour, settings, state) -> {
-                return behaviour.shouldRotatePlayerHead(settings, state, pokemonEntity);
+                return behaviour.shouldRotateRiderHead(settings, state, pokemonEntity);
             });
 
             if (!shouldRotatePlayerHead) {
@@ -73,7 +74,9 @@ public class HumanoidModelMixin {
                 }
             }
 
-            MountedPlayerRenderer.INSTANCE.animate(pokemonEntity, (AbstractClientPlayer) entity, relevantPartsByName, netHeadYaw, headPitch, ageInTicks, limbSwing, limbSwingAmount);
+            if (!(entity instanceof AbstractClientPlayer player)) return;
+
+            MountedPlayerRenderer.INSTANCE.animate(pokemonEntity, player, relevantPartsByName, netHeadYaw, headPitch, ageInTicks, limbSwing, limbSwingAmount);
         }
     }
 }

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

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin.client;
+
+import com.cobblemon.mod.common.client.render.entity.MountedLivingEntityRenderer;
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
+import com.mojang.blaze3d.vertex.PoseStack;
+import net.minecraft.client.model.EntityModel;
+import net.minecraft.client.renderer.entity.LivingEntityRenderer;
+import net.minecraft.world.entity.LivingEntity;
+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.CallbackInfo;
+
+@Mixin(LivingEntityRenderer.class)
+public class LivingEntityRendererMixin<T extends LivingEntity, M extends EntityModel<T>> {
+
+    @Inject(
+            method = "setupRotations",
+            at = @At("HEAD")
+    )
+    private void cobblemon$modifyRoll(LivingEntity entity, PoseStack poseStack, float bob, float yBodyRot, float partialTick, float scale, CallbackInfo ci) {
+        if (entity.isPassenger()) {
+            var vehicle = entity.getVehicle();
+            if (vehicle instanceof PokemonEntity pokemonEntity) {
+                MountedLivingEntityRenderer.INSTANCE.render(entity, pokemonEntity, poseStack, bob, yBodyRot, partialTick, scale);
+            }
+        }
+    }
+}

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

@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.mixin.client;
 
 import com.cobblemon.mod.common.CobblemonNetwork;
+import com.cobblemon.mod.common.DoubleJump;
 import com.cobblemon.mod.common.OrientationControllable;
 import com.cobblemon.mod.common.api.orientation.OrientationController;
 import com.cobblemon.mod.common.api.riding.Seat;
@@ -17,17 +18,21 @@ import com.cobblemon.mod.common.client.render.MatrixWrapper;
 import com.cobblemon.mod.common.client.render.models.blockbench.FloatingState;
 import com.cobblemon.mod.common.client.render.models.blockbench.PosableModel;
 import com.cobblemon.mod.common.client.render.models.blockbench.repository.VaryingModelRepository;
+import com.cobblemon.mod.common.duck.PlayerDuck;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
 import com.cobblemon.mod.common.net.messages.server.orientation.ServerboundUpdateOrientationPacket;
+import com.cobblemon.mod.common.net.messages.server.riding.ServerboundUpdateDriverInputPacket;
 import com.mojang.authlib.GameProfile;
 import net.minecraft.client.CameraType;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.multiplayer.ClientLevel;
 import net.minecraft.client.player.AbstractClientPlayer;
+import net.minecraft.client.player.Input;
 import net.minecraft.client.player.LocalPlayer;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.entity.EntityType;
 import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.level.ClipContext;
 import net.minecraft.world.level.Level;
 import net.minecraft.world.phys.HitResult;
@@ -46,13 +51,23 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 import java.util.Map;
 
 @Mixin(LocalPlayer.class)
-public abstract class LocalPlayerMixin extends AbstractClientPlayer implements OrientationControllable{
+public abstract class LocalPlayerMixin extends AbstractClientPlayer implements OrientationControllable, DoubleJump {
 
     @Unique Matrix3f cobblemon$lastOrientation;
 
+    @Unique boolean cobblemon$isDoubleJumping = false;
+
     @Shadow
     private float jumpRidingScale;
 
+    @Shadow public Input input;
+
+    @Shadow private int autoJumpTime;
+
+    @Unique private int cobblemon$survivalJumpTriggerTime;
+
+    @Unique private boolean cobblemon$isJumping;
+
     public LocalPlayerMixin(ClientLevel clientLevel, GameProfile gameProfile) {
         super(clientLevel, gameProfile);
     }
@@ -83,6 +98,23 @@ public abstract class LocalPlayerMixin extends AbstractClientPlayer implements O
         controllable.getOrientationController().setActive(shouldUseCustomOrientation);
     }
 
+    @Inject(method = "rideTick", at = @At("HEAD"))
+    private void cobblemon$updateDriverInputRideTick(CallbackInfo ci) {
+        if (Minecraft.getInstance().player != (Object)this) return;
+        if (!(this.getVehicle() instanceof PokemonEntity pokemonEntity)) return;
+
+        // Gather driver Input
+        float vertInput = this.jumping ? 1.0f : (((Player)this).isShiftKeyDown() ? -1.0f : 0.0f);
+        Vector3f driverInput = new Vector3f(Math.signum(this.xxa), vertInput, Math.signum(this.zza));
+
+        // Check if player input has changed. If it has then update the last sent and send it
+        Vector3f lastSentDriverInput = ((PlayerDuck)this).getLastSentDriverInput();
+        if (driverInput.equals(lastSentDriverInput)) return;
+        ((PlayerDuck)this).setLastSentDriverInput(driverInput);
+
+        CobblemonNetwork.INSTANCE.sendToServer(new ServerboundUpdateDriverInputPacket(driverInput));
+    }
+
     @Unique
     private boolean cobblemon$shouldUseCustomOrientation(LocalPlayer player) {
         var playerVehicle = player.getVehicle();
@@ -115,6 +147,33 @@ public abstract class LocalPlayerMixin extends AbstractClientPlayer implements O
         }
     }
 
+    @Inject(method = "aiStep", at = @At("HEAD"))
+    private void cobblemon$aiStep(CallbackInfo ci) {
+        this.cobblemon$isDoubleJumping = false;
+        this.cobblemon$isJumping = this.input.jumping;
+    }
+
+    @Inject(method = "aiStep", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/player/LocalPlayer;isSprinting()Z", shift = At.Shift.BEFORE))
+    private void cobblemon$updateDoubleJumping(CallbackInfo ci) {
+        if (!this.cobblemon$isJumping && this.input.jumping && this.autoJumpTime <= 0 && !this.isSwimming()) {
+            if (this.cobblemon$survivalJumpTriggerTime != 0) {
+                this.cobblemon$isDoubleJumping = true;
+                this.cobblemon$survivalJumpTriggerTime = 0;
+            }
+            else {
+                this.cobblemon$survivalJumpTriggerTime = 7;
+            }
+        }
+        else if (this.cobblemon$survivalJumpTriggerTime > 0) {
+            this.cobblemon$survivalJumpTriggerTime--;
+        }
+    }
+
+    @Override
+    public boolean isDoubleJumping() {
+        return this.cobblemon$isDoubleJumping;
+    }
+
     @Override
     public HitResult pick(double hitDistance, float partialTicks, boolean hitFluids) {
         Entity vehicle = this.getVehicle();
@@ -127,7 +186,7 @@ public abstract class LocalPlayerMixin extends AbstractClientPlayer implements O
                 return super.pick(hitDistance, partialTicks, hitFluids);
             }
 
-            Vec3 locatorOffset = new Vec3(locator.getMatrix().getTranslation(new Vector3f()));
+            Vec3 locatorOffset = locator != null ? new Vec3(locator.getMatrix().getTranslation(new Vector3f())) : Vec3.ZERO;
 
             OrientationController controller = this.getOrientationController();
 

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

@@ -9,20 +9,16 @@
 package com.cobblemon.mod.common.mixin.client;
 
 import com.cobblemon.mod.common.client.render.ClientPlayerIcon;
-import com.cobblemon.mod.common.client.render.player.MountedPlayerRenderer;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
 import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import com.mojang.blaze3d.vertex.PoseStack;
-import net.minecraft.client.model.EntityModel;
 import net.minecraft.client.model.PlayerModel;
 import net.minecraft.client.player.AbstractClientPlayer;
 import net.minecraft.client.renderer.MultiBufferSource;
 import net.minecraft.client.renderer.entity.EntityRendererProvider;
 import net.minecraft.client.renderer.entity.LivingEntityRenderer;
 import net.minecraft.client.renderer.entity.player.PlayerRenderer;
-import net.minecraft.world.entity.LivingEntity;
-import net.minecraft.world.entity.player.Player;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
@@ -35,9 +31,9 @@ public abstract class PlayerRendererMixin extends LivingEntityRenderer<AbstractC
         super(context, model, shadowRadius);
     }
 
-    @Inject(method = "render(Lnet/minecraft/world/entity/LivingEntity;FFLcom/mojang/blaze3d/vertex/PoseStack;Lnet/minecraft/client/renderer/MultiBufferSource;I)V", at = @At(value = "TAIL"))
-    public void cobblemon$clientPlayerIcon(LivingEntity entity, float entityYaw, float partialTicks, PoseStack poseStack, MultiBufferSource buffer, int packedLight, CallbackInfo ci) {
-        ClientPlayerIcon.Companion.onRenderPlayer((Player) entity);
+    @Inject(method = "render", at = @At(value = "TAIL"))
+    public void renderPlayer(AbstractClientPlayer player, float f, float g, PoseStack poseStack, MultiBufferSource multiBufferSource, int i, CallbackInfo ci) {
+        ClientPlayerIcon.Companion.onRenderPlayer(player);
     }
 
     @WrapOperation(method = "getRenderOffset(Lnet/minecraft/client/player/AbstractClientPlayer;F)Lnet/minecraft/world/phys/Vec3;", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/player/AbstractClientPlayer;isCrouching()Z"))
@@ -55,17 +51,4 @@ public abstract class PlayerRendererMixin extends LivingEntityRenderer<AbstractC
             playerModel.crouching = false;
         }
     }
-
-    @Inject(
-            method = "setupRotations(Lnet/minecraft/client/player/AbstractClientPlayer;Lcom/mojang/blaze3d/vertex/PoseStack;FFFF)V",
-            at = @At("HEAD")
-    )
-    private void cobblemon$modifyRoll(AbstractClientPlayer player, PoseStack poseStack, float a, float b, float partialTicks, float i, CallbackInfo ci) {
-        if (player.isPassenger()) {
-            var vehicle = player.getVehicle();
-            if (vehicle instanceof PokemonEntity entity) {
-                MountedPlayerRenderer.INSTANCE.render(player, entity, poseStack, a, b, partialTicks, i);
-            }
-        }
-    }
 }

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

@@ -75,6 +75,7 @@ import com.cobblemon.mod.common.config.constraint.IntConstraint
 import com.cobblemon.mod.common.config.starter.StarterConfig
 import com.cobblemon.mod.common.data.CobblemonDataProvider
 import com.cobblemon.mod.common.events.AdvancementHandler
+import com.cobblemon.mod.common.events.EntityCallbackHandler
 import com.cobblemon.mod.common.events.FlowHandler
 import com.cobblemon.mod.common.events.PokedexHandler
 import com.cobblemon.mod.common.events.ServerTickHandler
@@ -313,6 +314,7 @@ object Cobblemon {
         CobblemonEvents.POKEMON_PROPERTY_INITIALISED.emit(Unit)
 
         FlowHandler.setup()
+        EntityCallbackHandler.setup()
 
         ifDedicatedServer {
             isDedicatedServer = true

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

@@ -19,6 +19,7 @@ object CobblemonActivities {
     val POKEMON_GROW_CROP = register(Activity("pokemon_grow_crop"))
     val POKEMON_SLEEP_ON_TRAINER_BED = register(Activity("pokemon_sleep_on_trainer_bed"))
     val POKEMON_HERD = register(Activity("pokemon_herd"))
+    val POKEMON_POLLINATION = register(Activity("pokemon_pollination"))
 
     fun register(activity: Activity): Activity {
         activities.add(activity)

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

@@ -78,6 +78,9 @@ object CobblemonBehaviours : JsonDataRegistry<CobblemonBehaviour> {
      */
     val autoPokemonBehaviours = mutableListOf<CobblemonBehaviour>()
 
+    /** See [autoPokemonBehaviours] but think npc instead of pokemon*/
+    val autoNPCBehaviours = mutableListOf<CobblemonBehaviour>()
+
     val behaviours = mutableMapOf<ResourceLocation, CobblemonBehaviour>()
 
     override fun sync(player: ServerPlayer) {
@@ -86,6 +89,7 @@ object CobblemonBehaviours : JsonDataRegistry<CobblemonBehaviour> {
 
     override fun reload(manager: ResourceManager) {
         autoPokemonBehaviours.clear()
+        autoNPCBehaviours.clear()
         val data = mutableMapOf<ResourceLocation, CobblemonBehaviour>()
         manager.listResources(resourcePath) { path -> path.endsWith(JSON_EXTENSION) }.forEach { (identifier, resource) ->
             resource.open().use { stream ->
@@ -94,6 +98,8 @@ object CobblemonBehaviours : JsonDataRegistry<CobblemonBehaviour> {
                     val behaviour = parse(reader, resolvedIdentifier)
                     if ("pokemon/auto/" in identifier.path) {
                         autoPokemonBehaviours.add(behaviour)
+                    } else if ("npc/auto/" in identifier.path) {
+                        autoNPCBehaviours.add(behaviour)
                     }
                     data[resolvedIdentifier] = behaviour
                 }

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

@@ -8,7 +8,6 @@
 
 package com.cobblemon.mod.common
 
-import com.cobblemon.mod.common.block.entity.PokeCakeBlockEntity
 import com.cobblemon.mod.common.block.entity.BerryBlockEntity
 import com.cobblemon.mod.common.block.entity.HealingMachineBlockEntity
 import com.cobblemon.mod.common.block.entity.PCBlockEntity
@@ -88,35 +87,23 @@ object CobblemonBlockEntities : PlatformRegistry<Registry<BlockEntityType<*>>, R
         BlockEntityType.Builder.of(::DisplayCaseBlockEntity, CobblemonBlocks.DISPLAY_CASE).build(null)
     )
 
-    @JvmField
-    val INCENSE_SWEET: BlockEntityType<SweetIncenseBlockEntity> = this.create("incense_sweet",
-            BlockEntityType.Builder.of(::SweetIncenseBlockEntity, CobblemonBlocks.INCENSE_SWEET).build(null)
-    )
+    // TODO after 1.7
+//    @JvmField
+//    val INCENSE_SWEET: BlockEntityType<SweetIncenseBlockEntity> = this.create("incense_sweet",
+//            BlockEntityType.Builder.of(::SweetIncenseBlockEntity, CobblemonBlocks.INCENSE_SWEET).build(null)
+//    )
 
     @JvmField
     val CAMPFIRE: BlockEntityType<CampfireBlockEntity> = this.create("campfire_pot",
-            BlockEntityType.Builder.of(::CampfireBlockEntity, CobblemonBlocks.CAMPFIRE).build(null)
+            BlockEntityType.Builder.of(::CampfireBlockEntity,
+                CobblemonBlocks.CAMPFIRE,
+                CobblemonBlocks.SOUL_CAMPFIRE
+            ).build(null)
     )
 
-    /*@JvmField
-    val LURE_CAKE: BlockEntityType<LureCakeBlockEntity> =
-        BlockEntityType.Builder.of({ pos, state -> LureCakeBlockEntity(pos, state) },
-            CobblemonBlocks.LURE_CAKE
-        ).build(null)*/
-
     @JvmField
-    val LURE_CAKE: BlockEntityType<LureCakeBlockEntity> = this.create(
-        "lure_cake",
-        BlockEntityType.Builder.of(::LureCakeBlockEntity, CobblemonBlocks.LURE_CAKE).build(null)
-    )
-    @JvmField
-    val POKE_CAKE: BlockEntityType<PokeCakeBlockEntity> = this.create(
-        "poke_cake",
-        BlockEntityType.Builder.of(::PokeCakeBlockEntity, CobblemonBlocks.POKE_CAKE).build(null)
-    )
-    @JvmField
-    val CANDLE_POKE_CAKE: BlockEntityType<CandlePokeCakeBlockEntity> = this.create(
-        "candle_poke_cake",
-        BlockEntityType.Builder.of(::CandlePokeCakeBlockEntity, CobblemonBlocks.CANDLE_POKE_CAKE).build(null)
+    val POKE_SNACK: BlockEntityType<PokeSnackBlockEntity> = this.create(
+        "poke_snack",
+        BlockEntityType.Builder.of(::PokeSnackBlockEntity, CobblemonBlocks.POKE_SNACK, CobblemonBlocks.POKE_CAKE).build(null)
     )
 }

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

@@ -40,6 +40,7 @@ import net.minecraft.world.level.block.*
 import net.minecraft.world.level.block.state.BlockBehaviour
 import net.minecraft.world.level.block.state.BlockState
 import net.minecraft.world.level.block.state.properties.BlockSetType
+import net.minecraft.world.level.block.state.properties.BlockStateProperties
 import net.minecraft.world.level.block.state.properties.BlockStateProperties.LIT
 import net.minecraft.world.level.block.state.properties.NoteBlockInstrument
 import net.minecraft.world.level.block.state.properties.WoodType
@@ -230,8 +231,10 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
 
     @JvmField
     val MEDICINAL_LEEK = this.create("medicinal_leek", MedicinalLeekBlock(BlockBehaviour.Properties.of().pushReaction(PushReaction.DESTROY).ignitedByLava().mapColor(MapColor.CRIMSON_NYLIUM).noCollission().randomTicks().instabreak().sound(CobblemonSounds.MEDICINAL_LEEK_SOUNDS)))
-    @JvmField
-    val BUGWORT = this.create("bugwort", BugwortBlock(BlockBehaviour.Properties.of().pushReaction(PushReaction.DESTROY).ignitedByLava().mapColor(MapColor.COLOR_PURPLE).noCollission().randomTicks().instabreak().sound(CobblemonSounds.MEDICINAL_LEEK_SOUNDS)))
+
+    // TODO after 1.7
+//    @JvmField
+//    val BUGWORT = this.create("bugwort", BugwortBlock(BlockBehaviour.Properties.of().pushReaction(PushReaction.DESTROY).ignitedByLava().mapColor(MapColor.COLOR_PURPLE).noCollission().randomTicks().instabreak().sound(CobblemonSounds.MEDICINAL_LEEK_SOUNDS)))
     @JvmField
     val ENERGY_ROOT = this.create("energy_root", EnergyRootBlock(BlockBehaviour.Properties.of().pushReaction(PushReaction.DESTROY).ignitedByLava().mapColor(MapColor.DIRT).noCollission().randomTicks().instabreak().sound(CobblemonSounds.ENERGY_ROOT_SOUNDS)))
     @JvmField
@@ -240,11 +243,9 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     val REVIVAL_HERB = this.create("revival_herb", RevivalHerbBlock(BlockBehaviour.Properties.of().pushReaction(PushReaction.DESTROY).mapColor(MapColor.PLANT).ignitedByLava().noCollission().instabreak().sound(CobblemonSounds.REVIVAL_HERB_SOUNDS)))
 
     @JvmField
-    val LURE_CAKE = this.create("lure_cake", LureCakeBlock(BlockBehaviour.Properties.of().forceSolidOn().strength(0.5F).sound(SoundType.WOOL).pushReaction(PushReaction.DESTROY)))
+    val POKE_CAKE = this.create("poke_cake", PokeSnackBlock(BlockBehaviour.Properties.of().forceSolidOn().strength(0.5F).sound(SoundType.WOOL).pushReaction(PushReaction.DESTROY).lightLevel { if (it.getValue(LIT)) 3 else 0 }, false))
     @JvmField
-    val POKE_CAKE = this.create("poke_cake", PokeCakeBlock(BlockBehaviour.Properties.ofFullCopy(LURE_CAKE)))
-    @JvmField
-    val CANDLE_POKE_CAKE = this.create("candle_poke_cake", CandlePokeCakeBlock(BlockBehaviour.Properties.ofFullCopy(LURE_CAKE).lightLevel { blockState -> if (blockState.getValue(LIT) == true) 3 else 0 }))
+    val POKE_SNACK = this.create("poke_snack", PokeSnackBlock(BlockBehaviour.Properties.of().forceSolidOn().strength(0.5F).sound(SoundType.WOOL).pushReaction(PushReaction.DESTROY).lightLevel { if (it.getValue(LIT)) 3 else 0 }, true))
 
     @JvmField
     val TUMBLESTONE_CLUSTER = tumblestoneBlock("tumblestone_cluster", GrowableStoneBlock.STAGE_3, 7, 3, null)
@@ -449,7 +450,10 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     )
 
     @JvmField
-    val CAMPFIRE = create("campfire", CampfireBlock(BlockBehaviour.Properties.of().sound(SoundType.WOOD).noOcclusion().pushReaction(PushReaction.BLOCK).mapColor(MapColor.PODZOL).strength(2.0F).lightLevel { if ((it.getValue(CampfireBlock.SOUL) as Boolean)) 9 else 14 }))
+    val CAMPFIRE = create("campfire", CampfireBlock(BlockBehaviour.Properties.of().sound(SoundType.WOOD).noOcclusion().pushReaction(PushReaction.BLOCK).mapColor(MapColor.PODZOL).strength(2.0F).lightLevel{14}, false))
+
+    @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))
@@ -492,8 +496,9 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     @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()))
 
-    @JvmField
-    val INCENSE_SWEET = create("incense_sweet", SweetIncenseBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.DISPLAY_CASE_SOUNDS).noOcclusion().pushReaction(PushReaction.BLOCK).mapColor(MapColor.STONE).strength(0.3f)))
+    // TODO after 1.7
+//    @JvmField
+//    val INCENSE_SWEET = create("incense_sweet", SweetIncenseBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.DISPLAY_CASE_SOUNDS).noOcclusion().pushReaction(PushReaction.BLOCK).mapColor(MapColor.STONE).strength(0.3f)))
 
     @JvmField
     val PASTURE = create("pasture", PastureBlock(BlockBehaviour.Properties.of().mapColor(MapColor.COLOR_BROWN).sound(SoundType.WOOD).strength(2F).noOcclusion().pushReaction(PushReaction.BLOCK).lightLevel { if ((it.getValue(PastureBlock.ON) as Boolean) && (it.getValue(PastureBlock.PART) == PastureBlock.PasturePart.TOP)) 13 else 0 }))
@@ -517,7 +522,7 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     @JvmField
     val POTTED_PEP_UP_FLOWER = this.create("potted_pep_up_flower", BlocksInvoker.createFlowerPotBlock(PEP_UP_FLOWER))
     @JvmField
-    val HEARTY_GRAINS = this.create("hearty_grains", HeartyGrainsBlock(BlockBehaviour.Properties.of().pushReaction(PushReaction.DESTROY).ignitedByLava().mapColor(MapColor.PLANT).noCollission().randomTicks().instabreak().sound(CobblemonSounds.VIVICHOKE_SOUNDS)))
+    val HEARTY_GRAINS = this.create("hearty_grains", HeartyGrainsBlock(BlockBehaviour.Properties.of().pushReaction(PushReaction.DESTROY).ignitedByLava().mapColor(MapColor.PLANT).noCollission().randomTicks().instabreak()))
 
     @JvmField
     val GALARICA_NUT_BUSH = this.create("galarica_nut_bush", NutBushBlock(BlockBehaviour.Properties.of().mapColor(MapColor.PLANT).randomTicks().noCollission().sound(SoundType.SWEET_BERRY_BUSH).pushReaction(PushReaction.DESTROY)))
@@ -540,11 +545,11 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     val POTTED_SACCHARINE_SAPLING = this.create("potted_saccharine_sapling", BlocksInvoker.createFlowerPotBlock(SACCHARINE_SAPLING))
 
     @JvmField
-    val HEARTY_GRAIN_BALE = this.create("hearty_grain_bale", BaleBlock(BlockBehaviour.Properties.of().mapColor(MapColor.PLANT).instrument(NoteBlockInstrument.BANJO).strength(0.5F).sound(SoundType.GRASS)))
+    val HEARTY_GRAIN_BALE = this.create("hearty_grain_bale", BaleBlock(BlockBehaviour.Properties.of().mapColor(MapColor.PLANT).instrument(NoteBlockInstrument.BANJO).strength(0.5F).sound(CobblemonSounds.HEARTY_GRAIN_BALE_SOUNDS)))
     @JvmField
-    val TATAMI_BLOCK = this.create("tatami_block", HorizontalRotationalBlock(BlockBehaviour.Properties.of().ignitedByLava().mapColor(MapColor.PLANT).strength(0.1F).sound(SoundType.MOSS_CARPET)))
+    val TATAMI_BLOCK = this.create("tatami_block", HorizontalRotationalBlock(BlockBehaviour.Properties.of().ignitedByLava().mapColor(MapColor.PLANT).strength(0.1F).sound(CobblemonSounds.TATAMI_BLOCK_SOUNDS)))
     @JvmField
-    val TATAMI_MAT = this.create("tatami_mat", HorizontalRotationCarpetBlock(BlockBehaviour.Properties.of().ignitedByLava().mapColor(MapColor.PLANT).strength(0.1F).sound(SoundType.MOSS_CARPET)))
+    val TATAMI_MAT = this.create("tatami_mat", HorizontalRotationCarpetBlock(BlockBehaviour.Properties.of().ignitedByLava().mapColor(MapColor.PLANT).strength(0.1F).sound(CobblemonSounds.TATAMI_MAT_SOUNDS)))
 
     /**
      * Returns a map of all the blocks that can be stripped with an axe in the format of input - output.

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

@@ -59,6 +59,7 @@ object CobblemonCommands {
         ApplyPlayerTextureCommand.register(dispatcher)
         RenameBoxCommand.register(dispatcher)
         ChangeBoxWallpaperCommand.register(dispatcher)
+        RunMolangCommand.register(dispatcher)
         RunMolangScriptCommand.register(dispatcher)
         SpectateBattleCommand.register(dispatcher)
         CobblemonConfigCommand.register(dispatcher)
@@ -70,6 +71,7 @@ object CobblemonCommands {
         MarkGiveAllCommand.register(dispatcher)
         PcSearchCommand.register(dispatcher)
         PcTakeCommand.register(dispatcher)
+        ValidateTeamCommand.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

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

@@ -93,6 +93,8 @@ object CobblemonFlows : DataRegistry {
         functions: Map<String, (MoParams) -> Any> = emptyMap(),
         cancelable: Cancelable? = null
     ) {
+        if (eventResourceLocation !in flows) return
+
         if (cancelable == null) {
             runtime.environment.query.functions.remove("cancel")
         } else {

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

@@ -349,15 +349,15 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val SACCHARINE_SAPLING = compostableBlockItem("saccharine_sapling", CobblemonBlocks.SACCHARINE_SAPLING, 0.30f)
 
-    @JvmField
-    val BUGWORT = compostableBlockItem("bugwort", CobblemonBlocks.BUGWORT)
+//    @JvmField
+//    val BUGWORT = compostableBlockItem("bugwort", CobblemonBlocks.BUGWORT) // TODO after 1.7
     @JvmField
     val POKE_BAIT = noSettingsItem("poke_bait")
 
     @JvmField
-    val LURE_CAKE = blockItem("lure_cake", CobblemonBlocks.LURE_CAKE)
+    val POKE_CAKE = this.create("poke_cake", BlockItem(CobblemonBlocks.POKE_CAKE, Item.Properties().stacksTo(1)))
     @JvmField
-    val POKE_CAKE = blockItem("poke_cake", CobblemonBlocks.POKE_CAKE)
+    val POKE_SNACK = this.create("poke_snack", BlockItem(CobblemonBlocks.POKE_SNACK, Item.Properties().stacksTo(16)))
 
     val aprijuices = mutableListOf<AprijuiceItem>()
     @JvmField
@@ -386,43 +386,31 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
 
     // FOODS
     @JvmField
-    val SWEET_HEART = noSettingsItem("sweet_heart") // todo make a SweetHeartItem class for breeding purposes
+    val SWEET_HEART = noSettingsItem("sweet_heart") // TODO make a SweetHeartItem class for breeding purposes
 
     @JvmField
-    val TASTY_TAIL = noSettingsItem("tasty_tail")
+    val TASTY_TAIL = create("tasty_tail", foodItem(3, 0.3f))
 
-    @JvmField // todo get final values for this from vera
-    val PEWTER_CRUNCHIES = regionalFoodItem("pewter_crunchies", 16, 10, 1.2f, MobEffectInstance(MobEffects.ABSORPTION, 900, 0), 1f, false)
-
-    @JvmField // todo get final values for this from vera
-    val RAGE_CANDY_BAR = regionalFoodItem("rage_candy_bar", 16, 10, 1.2f, MobEffectInstance(MobEffects.ABSORPTION, 900, 0), 1f, false)
-
-    @JvmField // todo get final values for this from vera
-    val LAVA_COOKIE = regionalFoodItem("lava_cookie", 16, 10, 1.2f, MobEffectInstance(MobEffects.ABSORPTION, 900, 0), 1f)
-
-    @JvmField // todo get final values for this from vera
-    val OLD_GATEAU = regionalFoodItem("old_gateau", 16, 10, 1.2f, MobEffectInstance(MobEffects.ABSORPTION, 900, 0), 1f)
-
-    @JvmField // todo get final values for this from vera
-    val CASTELIACONE = regionalFoodItem("casteliacone", 16, 10, 1.2f, MobEffectInstance(MobEffects.ABSORPTION, 900, 0), 1f)
-
-    @JvmField // todo get final values for this from vera
-    val SHALOUR_SABLE = regionalFoodItem("shalour_sable", 16, 10, 1.2f, MobEffectInstance(MobEffects.ABSORPTION, 900, 0), 1f)
-
-    @JvmField // todo get final values for this from vera
-    val LUMIOSE_GALETTE = regionalFoodItem("lumiose_galette", 16, 10, 1.2f, MobEffectInstance(MobEffects.ABSORPTION, 900, 0), 1f)
-
-    @JvmField // todo get final values for this from vera
-    val BIG_MALASADA = regionalFoodItem("big_malasada", 16, 10, 1.2f, MobEffectInstance(MobEffects.ABSORPTION, 900, 0), 1f)
-
-    @JvmField // todo get final values for this from vera
-    val SMOKED_TAIL_CURRY = regionalFoodItem("smoked_tail_curry", 16, 10, 1.2f, MobEffectInstance(MobEffects.ABSORPTION, 900, 0), 1f, false, ItemStack(Items.BOWL, 1))
-
-    @JvmField // todo get final values for this from vera
-    val JUBILIFE_MUFFIN = regionalFoodItem("jubilife_muffin", 16, 10, 1.2f, MobEffectInstance(MobEffects.ABSORPTION, 900, 0), 1f)
-
-    @JvmField // todo get final values for this from vera
-    val OPEN_FACED_SANDWICH = regionalFoodItem("open_faced_sandwich", 16, 10, 1.2f, MobEffectInstance(MobEffects.ABSORPTION, 900, 0), 1f)
+    @JvmField
+    val PEWTER_CRUNCHIES = regionalFoodItem("pewter_crunchies", 64, 7, 0.343f, false)
+    @JvmField
+    val RAGE_CANDY_BAR = regionalFoodItem("rage_candy_bar", 64, 8, 0.2f, false)
+    @JvmField
+    val LAVA_COOKIE = regionalFoodItem("lava_cookie", 64, 2, 0.3f, false)
+    @JvmField
+    val OLD_GATEAU = regionalFoodItem("old_gateau", 64, 9, 0.1335f, false)
+    @JvmField
+    val CASTELIACONE = regionalFoodItem("casteliacone", 64, 5, .28f, false)
+    @JvmField
+    val LUMIOSE_GALETTE = regionalFoodItem("lumiose_galette", 64, 4, 0.4f, false)
+    @JvmField
+    val BIG_MALASADA = regionalFoodItem("big_malasada", 64, 7, 0.343f, false)
+    @JvmField
+    val SMOKED_TAIL_CURRY = regionalFoodItem("smoked_tail_curry", 64, 10, 0.6f, false, ItemStack(Items.BOWL, 1))
+    @JvmField
+    val JUBILIFE_MUFFIN = regionalFoodItem("jubilife_muffin", 64, 8, 0.2f, false)
+    @JvmField
+    val OPEN_FACED_SANDWICH = regionalFoodItem("open_faced_sandwich", 64, 13, 0.5f, false)
 
     // todo we might need to wait on these for later? These impact battles and may be harder to do
     /*@JvmField
@@ -433,32 +421,24 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     val TWICE_SPICED_BEETROOT = noSettingsItem("twice_spiced_beetroot") // todo make a TwiceSpiceBeetrootItem class for battle purposes
 */
     @JvmField
-    val POTATO_MOCHI = create("potato_mochi", CobblemonItem(Properties().stacksTo(16)
+    val POTATO_MOCHI = create("potato_mochi", CobblemonItem(Properties().stacksTo(64)
         .food(FoodProperties.Builder()
-            .nutrition(10) // todo get final values for this from vera
-            .saturationModifier(1.2F) // todo get final values for this from vera
-            .alwaysEdible()
+            .nutrition(4)
+            .saturationModifier(0.4F)
             .build())))
     @JvmField
-    val FRIED_RICE = create("fried_rice", CobblemonItem(Properties().stacksTo(16)
+    val CANDIED_APPLE = create("candied_apple",  CobblemonItem(Properties().stacksTo(64)
         .food(FoodProperties.Builder()
-            .nutrition(10) // todo get final values for this from vera
-            .saturationModifier(1.2F) // todo get final values for this from vera
-            .alwaysEdible()
+            .nutrition(6)
+            .saturationModifier(0.2335F)
+            .usingConvertsTo(Items.STICK)
             .build())))
     @JvmField
-    val CANDIED_APPLE = create("candied_apple",  CobblemonItem(Properties().stacksTo(16)
+    val CANDIED_BERRY = create("candied_berry",  CobblemonItem(Properties().stacksTo(64)
         .food(FoodProperties.Builder()
-            .nutrition(10) // todo get final values for this from vera
-            .saturationModifier(1.2F) // todo get final values for this from vera
-            .alwaysEdible()
-            .build())))
-    @JvmField
-    val CANDIED_BERRY = create("candied_berry",  CobblemonItem(Properties().stacksTo(16)
-        .food(FoodProperties.Builder()
-            .nutrition(10) // todo get final values for this from vera
-            .saturationModifier(1.2F) // todo get final values for this from vera
-            .alwaysEdible()
+            .nutrition(5)
+            .saturationModifier(0.22F)
+            .usingConvertsTo(Items.STICK)
             .build())))
 
     //@JvmField
@@ -480,8 +460,8 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     val PASTURE = blockItem("pasture", CobblemonBlocks.PASTURE)
     @JvmField
     val DISPLAY_CASE = blockItem("display_case", CobblemonBlocks.DISPLAY_CASE)
-    @JvmField
-    val INCENSE_SWEET = blockItem("incense_sweet", CobblemonBlocks.INCENSE_SWEET)
+//    @JvmField
+//    val INCENSE_SWEET = blockItem("incense_sweet", CobblemonBlocks.INCENSE_SWEET) // TODO after 1.7
 
 
     // Evolution items
@@ -685,14 +665,12 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val MEDICINAL_LEEK = heldItem("medicinal_leek", MedicinalLeekItem(CobblemonBlocks.MEDICINAL_LEEK, Item.Properties().food(FoodProperties.Builder().fast().nutrition(1).saturationModifier(0.2f).build())), "leek")
     @JvmField
-    val ROASTED_LEEK = compostableItem("roasted_leek", CobblemonItem(Item.Properties().food(FoodProperties.Builder().fast().nutrition(3).saturationModifier(0.3f).build())), 0.85f)
-    @JvmField
-    val BRAISED_VIVICHOKE = compostableItem("braised_vivichoke", foodItem(6, 0.6F), 0.85f)
+    val ROASTED_LEEK = compostableItem("roasted_leek", CobblemonItem(Item.Properties().food(FoodProperties.Builder().fast().nutrition(3).saturationModifier(0.2f).build())), 0.85f)
     @JvmField
     val VIVICHOKE_DIP = create("vivichoke_dip", object : CobblemonItem(Properties().stacksTo(1)
         .food(FoodProperties.Builder()
             .nutrition(10)
-            .saturationModifier(1.2F)
+            .saturationModifier(0.6F)
             .effect(MobEffectInstance(MobEffects.ABSORPTION, 900, 0), 1F)
             .alwaysEdible()
             .usingConvertsTo(Items.BOWL)
@@ -703,7 +681,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
         }
     })
     @JvmField
-    val ENERGY_ROOT = compostableItem("energy_root", EnergyRootItem(CobblemonBlocks.ENERGY_ROOT, Item.Properties().food(FoodProperties.Builder().nutrition(1).fast().saturationModifier(0.2f).build())), 0.60f)
+    val ENERGY_ROOT = compostableItem("energy_root", EnergyRootItem(CobblemonBlocks.ENERGY_ROOT, Properties()), 0.60f)
     @JvmField
     val REVIVAL_HERB = compostableItem("revival_herb", RevivalHerbItem(CobblemonBlocks.REVIVAL_HERB))
     @JvmField
@@ -717,7 +695,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val SUPERB_REMEDY = compostableItem("superb_remedy", RemedyItem(RemedyItem.SUPERB), 0.85f)
     @JvmField
-    val MOOMOO_MILK = noSettingsItem("moomoo_milk")
+    val MOOMOO_MILK = create("moomoo_milk", CobblemonItem(Item.Properties().craftRemainder(Items.GLASS_BOTTLE)))
 
     @JvmField
     val POTION = create("potion", PotionItem(PotionType.POTION))
@@ -733,7 +711,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val HEAL_POWDER = create("heal_powder", HealPowderItem())
     @JvmField
-    val LEEK_AND_POTATO_STEW = create("leek_and_potato_stew", CobblemonItem(Item.Properties().food(FoodProperties.Builder().nutrition(8).saturationModifier(0.6f).usingConvertsTo(Items.BOWL).build()).stacksTo(1)))
+    val LEEK_AND_POTATO_STEW = create("leek_and_potato_stew", CobblemonItem(Item.Properties().food(FoodProperties.Builder().nutrition(6).saturationModifier(0.6f).usingConvertsTo(Items.BOWL).build()).stacksTo(1)))
     @JvmField
     val REVIVE = create("revive", ReviveItem(max = false))
     @JvmField
@@ -1544,8 +1522,6 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
         stacksTo: Int,
         nutrition: Int,
         saturationModifier: Float,
-        effect: MobEffectInstance? = null,
-        effectChance: Float? = null,
         alwaysEdible: Boolean = false,
         convertsToOnUse: ItemStack? = null
     ): RegionalFoodItem {
@@ -1553,10 +1529,6 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
             .nutrition(nutrition)
             .saturationModifier(saturationModifier)
 
-        if (effect != null && effectChance != null) {
-            foodPropertiesBuilder.effect(effect, effectChance)
-        }
-
         if (alwaysEdible == true) {
             foodPropertiesBuilder.alwaysEdible()
         }

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

@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common
 
 import com.cobblemon.mod.common.api.ai.CobblemonAttackTargetData
+import com.cobblemon.mod.common.api.ai.CobblemonWanderControl
 import com.cobblemon.mod.common.api.dialogue.ActiveDialogue
 import com.cobblemon.mod.common.api.moves.animations.ActionEffectContext
 import com.mojang.serialization.Codec
@@ -43,11 +44,16 @@ object CobblemonMemories {
     val NEAREST_VISIBLE_ATTACKER = register<LivingEntity>("nearest_visible_attacker")
     val NEARBY_GROWABLE_CROPS = register<BlockPos>("nearby_growable_crops")
     val RECENTLY_ATE_GRASS = register<Boolean>("recently_ate_grass")
+    val HIVE_LOCATION = register<BlockPos>("hive_location")
+    val HIVE_COOLDOWN = register<Boolean>("hive_cooldown")
+    val NEARBY_FLOWERS = register<List<BlockPos>>("nearby_flower")
+    val POLLINATED = register<Boolean>("pollinated", PrimitiveCodec.BOOL)
     /** who am i following rn? */
     val HERD_LEADER = register<String>("herd_leader", PrimitiveCodec.STRING)
     /** how many are following me rn? */
     val HERD_SIZE = register<Int>("herd_size") // Don't bother saving it, we'll try to keep count roughly.
     val ATTACK_TARGET_DATA = register<CobblemonAttackTargetData>("attack_target_data") // This is used to store additional information about the attack target, such as when to give up pursuit.
+    val WANDER_CONTROL = register<CobblemonWanderControl>("wander_control")
 
     fun <U> register(id: String, codec: Codec<U>): MemoryModuleType<U> {
         val memoryModule = MemoryModuleType(Optional.of(codec))

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

@@ -23,7 +23,9 @@ import com.cobblemon.mod.common.client.net.data.DataRegistrySyncPacketHandler
 import com.cobblemon.mod.common.client.net.data.UnlockReloadPacketHandler
 import com.cobblemon.mod.common.client.net.dialogue.DialogueClosedHandler
 import com.cobblemon.mod.common.client.net.dialogue.DialogueOpenedHandler
+import com.cobblemon.mod.common.client.net.effect.PokeSnackBlockParticlesHandler
 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.InteractPokemonUIPacketHandler
@@ -40,6 +42,7 @@ import com.cobblemon.mod.common.client.net.pasture.UpdatePastureConflictFlagHand
 import com.cobblemon.mod.common.client.net.pokedex.ServerConfirmedRegisterHandler
 import com.cobblemon.mod.common.client.net.pokemon.update.ClientboundUpdateRidingStateHandler
 import com.cobblemon.mod.common.client.net.pokemon.update.PokemonUpdatePacketHandler
+import com.cobblemon.mod.common.client.net.riding.ClientboundUpdateDriverInputHandler
 import com.cobblemon.mod.common.client.net.settings.OpenCobblemonConfigEditorHandler
 import com.cobblemon.mod.common.client.net.settings.ServerSettingsPacketHandler
 import com.cobblemon.mod.common.client.net.sound.UnvalidatedPlaySoundS2CPacketHandler
@@ -76,11 +79,14 @@ import com.cobblemon.mod.common.net.messages.client.cooking.ToggleCookingPotLidP
 import com.cobblemon.mod.common.net.messages.client.data.*
 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
 import com.cobblemon.mod.common.net.messages.client.effect.RunPosableMoLangPacket
+import com.cobblemon.mod.common.net.messages.client.effect.SaccharineLogBlockParticlesPacket
 import com.cobblemon.mod.common.net.messages.client.effect.SpawnSnowstormEntityParticlePacket
 import com.cobblemon.mod.common.net.messages.client.effect.SpawnSnowstormParticlePacket
 import com.cobblemon.mod.common.net.messages.client.npc.CloseNPCEditorPacket
 import com.cobblemon.mod.common.net.messages.client.npc.OpenNPCEditorPacket
+import com.cobblemon.mod.common.net.messages.client.orientation.ClientboundUpdateDriverInputPacket
 import com.cobblemon.mod.common.net.messages.client.orientation.ClientboundUpdateOrientationPacket
 import com.cobblemon.mod.common.net.messages.client.pasture.ClosePasturePacket
 import com.cobblemon.mod.common.net.messages.client.pasture.OpenPasturePacket
@@ -171,6 +177,7 @@ import com.cobblemon.mod.common.net.messages.server.pokemon.update.SetMarkingsPa
 import com.cobblemon.mod.common.net.messages.server.pokemon.update.ServerboundUpdateRidingStatePacket
 import com.cobblemon.mod.common.net.messages.server.pokemon.update.evolution.AcceptEvolutionPacket
 import com.cobblemon.mod.common.net.messages.server.riding.DismountPokemonPacket
+import com.cobblemon.mod.common.net.messages.server.riding.ServerboundUpdateDriverInputPacket
 import com.cobblemon.mod.common.net.messages.server.starter.RequestStarterScreenPacket
 import com.cobblemon.mod.common.net.messages.server.storage.SwapPCPartyPokemonPacket
 import com.cobblemon.mod.common.net.messages.server.storage.party.MovePartyPokemonPacket
@@ -221,6 +228,7 @@ import com.cobblemon.mod.common.net.serverhandling.pokemon.update.SetActiveMarkH
 import com.cobblemon.mod.common.net.serverhandling.pokemon.update.SetMarkingsHandler
 import com.cobblemon.mod.common.net.serverhandling.pokemon.update.ServerboundUpdateRidingStateHandler
 import com.cobblemon.mod.common.net.serverhandling.riding.DismountPokemonPacketHandler
+import com.cobblemon.mod.common.net.serverhandling.riding.DriverInputPacketHandler
 import com.cobblemon.mod.common.net.serverhandling.starter.RequestStarterScreenHandler
 import com.cobblemon.mod.common.net.serverhandling.starter.SelectStarterPacketHandler
 import com.cobblemon.mod.common.net.serverhandling.storage.BenchMoveHandler
@@ -402,6 +410,8 @@ object CobblemonNetwork {
         list.add(PacketRegisterInfo(SpawnSnowstormParticlePacket.ID, SpawnSnowstormParticlePacket::decode, SpawnSnowstormParticleHandler))
         list.add(PacketRegisterInfo(SpawnSnowstormEntityParticlePacket.ID, SpawnSnowstormEntityParticlePacket::decode, SpawnSnowstormEntityParticleHandler))
         list.add(PacketRegisterInfo(RunPosableMoLangPacket.ID, RunPosableMoLangPacket::decode, RunPosableMoLangHandler))
+        list.add(PacketRegisterInfo(SaccharineLogBlockParticlesPacket.ID, SaccharineLogBlockParticlesPacket::decode, SaccharineLogBlockParticlesHandler))
+        list.add(PacketRegisterInfo(PokeSnackBlockParticlesPacket.ID, PokeSnackBlockParticlesPacket::decode, PokeSnackBlockParticlesHandler))
 
         // Hax
         list.add(PacketRegisterInfo(UnvalidatedPlaySoundS2CPacket.ID, UnvalidatedPlaySoundS2CPacket::decode, UnvalidatedPlaySoundS2CPacketHandler))
@@ -462,6 +472,7 @@ object CobblemonNetwork {
 
         // Riding
         list.add(PacketRegisterInfo(ClientboundUpdateRidingStatePacket.ID, ClientboundUpdateRidingStatePacket::decode, ClientboundUpdateRidingStateHandler))
+        list.add(PacketRegisterInfo(ClientboundUpdateDriverInputPacket.ID, ClientboundUpdateDriverInputPacket::decode, ClientboundUpdateDriverInputHandler))
 
         return list
     }
@@ -568,6 +579,7 @@ object CobblemonNetwork {
         list.add(PacketRegisterInfo(ServerboundUpdateRidingStatsPacket.ID, ServerboundUpdateRidingStatsPacket::decode, ServerboundUpdateRidingStatsHandler))
         list.add(PacketRegisterInfo(ServerboundUpdateRidingStatRangePacket.ID, ServerboundUpdateRidingStatRangePacket::decode, ServerboundUpdateRidingStatRangeHandler))
         list.add(PacketRegisterInfo(DismountPokemonPacket.ID, DismountPokemonPacket::decode, DismountPokemonPacketHandler))
+        list.add(PacketRegisterInfo(ServerboundUpdateDriverInputPacket.ID, ServerboundUpdateDriverInputPacket::decode, DriverInputPacketHandler))
 
         // Cooking
         list.add(PacketRegisterInfo(ToggleCookingPotLidPacket.ID, ToggleCookingPotLidPacket::decode, ToggleCookingPotLidHandler))

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

@@ -26,11 +26,12 @@ object CobblemonPoiTypes: PlatformRegistry<Registry<PoiType>, ResourceKey<Regist
     @JvmField
     val NURSE_KEY = createKey("nurse", CobblemonBlocks.HEALING_MACHINE, 1, 1)
     @JvmField
-    val LURE_CAKE_KEY = createKey("lure_cake", CobblemonBlocks.LURE_CAKE, 0, 1)
+    val POKE_SNACK_KEY = createKey("poke_snack", CobblemonBlocks.POKE_SNACK, 0, 1)
     @JvmField
     val SACCHARINE_LOG_SLATHERED_KEY = createKey("saccharine_log_slathered", CobblemonBlocks.SACCHARINE_LOG_SLATHERED, 0, 1)
-    @JvmField
-    val INCENSE_SWEET_KEY = createKey("incense_sweet", CobblemonBlocks.INCENSE_SWEET, 0, 1)
+    // TODO after 1.7
+//    @JvmField
+//    val INCENSE_SWEET_KEY = createKey("incense_sweet", CobblemonBlocks.INCENSE_SWEET, 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

@@ -8,10 +8,7 @@
 
 package com.cobblemon.mod.common
 
-import com.cobblemon.mod.common.entity.pokemon.ai.sensors.DefendOwnerSensor
-import com.cobblemon.mod.common.entity.pokemon.ai.sensors.DrowsySensor
-import com.cobblemon.mod.common.entity.pokemon.ai.sensors.PokemonAdultSensor
-import com.cobblemon.mod.common.entity.pokemon.ai.sensors.PokemonGrowableCropSensor
+import com.cobblemon.mod.common.entity.pokemon.ai.sensors.*
 import com.cobblemon.mod.common.pokemon.ai.PokemonDisturbancesSensor
 import com.cobblemon.mod.common.entity.sensor.BattlingPokemonSensor
 import com.cobblemon.mod.common.entity.sensor.NPCBattlingSensor
@@ -36,6 +33,10 @@ object CobblemonSensors {
 
     val NEARBY_GROWABLE_CROPS = register("nearby_growable_crops", ::PokemonGrowableCropSensor)
 
+    val NEARBY_BEE_HIVE = register("nearby_bee_hive", ::BeeHiveSensor)
+
+    val NEARBY_FLOWER = register("nearby_flower", ::FlowerSensor)
+
     fun <E : Entity, U : Sensor<E>> register(id: String, supplier: Supplier<U>): SensorType<U> {
         val sensor = SensorType(supplier)
         sensors[id] = sensor

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

@@ -204,6 +204,19 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
     @JvmField
     val EVOLUTION_STONE_BLOCK_STEP = this.create("block.evolution_stone_block.step")
 
+    @JvmField
+    val TATAMI_BLOCK_BREAK = this.create("block.tatami.break")
+    @JvmField
+    val TATAMI_BLOCK_HIT = this.create("block.tatami.hit")
+    @JvmField
+    val TATAMI_BLOCK_PLACE = this.create("block.tatami.place")
+    @JvmField
+    val TATAMI_BLOCK_STEP = this.create("block.tatami.step")
+    @JvmField
+    val TATAMI_MAT_BREAK = this.create("block.tatami_mat.break")
+    @JvmField
+    val TATAMI_MAT_PLACE = this.create("block.tatami_mat.place")
+
     @JvmField
     val GIMMIGHOUL_GIVE_ITEM = this.create("pokemon.gimmighoul.give_item")
     @JvmField
@@ -230,6 +243,24 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
     @JvmField
     val VIVICHOKE_PLACE = this.create("block.vivichoke.place")
 
+    @JvmField
+    val HEARTY_GRAIN_BALE_BREAK = this.create("block.hearty_grain_bale.break")
+    @JvmField
+    val HEARTY_GRAIN_BALE_PLACE = this.create("block.hearty_grain_bale.place")
+    @JvmField
+    val HEARTY_GRAIN_BALE_HIT = this.create("block.hearty_grain_bale.hit")
+    @JvmField
+    val HEARTY_GRAIN_BALE_STEP = this.create("block.hearty_grain_bale.step")
+
+    @JvmField
+    val HEARTY_GRAINS_BREAK = this.create("block.hearty_grains.break")
+    @JvmField
+    val HEARTY_GRAINS_PLACE = this.create("block.hearty_grains.place")
+    @JvmField
+    val HEARTY_GRAINS_BREAK_WATER = this.create("block.hearty_grains.break_water")
+    @JvmField
+    val HEARTY_GRAINS_PLACE_WATER = this.create("block.hearty_grains.place_water")
+
     @JvmField
     val MINT_BREAK = this.create("block.mint.break")
     @JvmField
@@ -275,6 +306,11 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
         RELIC_COIN_SACK_STEP
     )
 
+    @JvmField
+    val RIDE_LOOP_LEATHER = create("ride.loop.leather")
+    @JvmField
+    val RIDE_LOOP_PLUMAGE = create("ride.loop.plumage")
+
     @JvmField
     val MOVE_QUICKATTACK_TARGET = this.create("move.quickattack.target")
     @JvmField
@@ -319,6 +355,8 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
     @JvmField
     val IMPACT_WATER = this.create("impact.water")
 
+    // Note to self or whoever's peeking, block sounds have to be at 1.1f pitch
+    // For some reason, the game pitches them down and compensating for it here returns them to normal
     @JvmField
     val TUMBLESTONE_SOUNDS = SoundType(1f, 1.1f,
         TUMBLESTONE_BREAK,
@@ -336,6 +374,7 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
         TUMBLESTONE_HIT,
         TUMBLESTONE_STEP
     )
+
     @JvmField
     val EVOLUTION_STONE_BLOCK_SOUNDS = SoundType(1f, 1.1f,
         EVOLUTION_STONE_BLOCK_BREAK,
@@ -345,6 +384,23 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
         EVOLUTION_STONE_BLOCK_STEP
     )
 
+    @JvmField
+    val TATAMI_BLOCK_SOUNDS = SoundType(1f, 1.1f,
+        TATAMI_BLOCK_BREAK,
+        TATAMI_BLOCK_STEP,
+        TATAMI_BLOCK_PLACE,
+        TATAMI_BLOCK_HIT,
+        TATAMI_BLOCK_STEP
+    )
+
+    @JvmField
+    val TATAMI_MAT_SOUNDS = SoundType(1f, 1.1f,
+        TATAMI_MAT_BREAK,
+        TATAMI_BLOCK_STEP,
+        TATAMI_MAT_PLACE,
+        TATAMI_BLOCK_HIT,
+        TATAMI_BLOCK_STEP
+    )
 
     @JvmField
     val BERRY_BUSH_SOUNDS = SoundType(0.8f, 1.1f,
@@ -391,6 +447,33 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
         SoundEvents.GRASS_FALL
     )
 
+    @JvmField
+    val HEARTY_GRAIN_BALE_SOUNDS = SoundType(0.6f, 1.1f,
+        HEARTY_GRAIN_BALE_BREAK,
+        HEARTY_GRAIN_BALE_STEP,
+        HEARTY_GRAIN_BALE_PLACE,
+        HEARTY_GRAIN_BALE_HIT,
+        HEARTY_GRAIN_BALE_STEP
+    )
+
+    @JvmField
+    val HEARTY_GRAINS_SOUNDS = SoundType(0.6f, 1.1f,
+        HEARTY_GRAINS_BREAK,
+        HEARTY_GRAIN_BALE_STEP,
+        HEARTY_GRAINS_PLACE,
+        HEARTY_GRAIN_BALE_HIT,
+        HEARTY_GRAIN_BALE_STEP
+    )
+
+    @JvmField
+    val HEARTY_GRAINS_WATER_SOUNDS = SoundType(0.6f, 1.1f,
+        HEARTY_GRAINS_BREAK_WATER,
+        SoundEvents.GRASS_STEP,
+        HEARTY_GRAINS_PLACE_WATER,
+        SoundEvents.GRASS_HIT,
+        SoundEvents.GRASS_FALL
+    )
+
     @JvmField
     val MINT_SOUNDS = SoundType(0.6f, 1.1f,
         MINT_BREAK,
@@ -430,7 +513,6 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
     val DISPLAY_CASE_PLACE = this.create("block.display_case.place")
     @JvmField
     val DISPLAY_CASE_STEP = this.create("block.display_case.step")
-
     @JvmField
     val DISPLAY_CASE_SOUNDS = SoundType(1f, 1f,
         DISPLAY_CASE_BREAK,
@@ -441,7 +523,7 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
     )
 
     @JvmField
-    val CAMPFIRE_POT_PLACE_CAMPFIRE = this.create("block.campfire_pot.place_campfire")
+    val CAMPFIRE_POT_SET = this.create("block.campfire_pot.set")
     @JvmField
     val CAMPFIRE_POT_RETRIEVE = this.create("block.campfire_pot.retrieve")
     @JvmField
@@ -449,12 +531,14 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
     @JvmField
     val CAMPFIRE_POT_CLOSE = this.create("block.campfire_pot.close")
     @JvmField
-    val CAMPFIRE_POT_USE = this.create("block.campfire_pot.use")
+    val CAMPFIRE_POT_TAKE_ITEM = this.create("block.campfire_pot.take_item")
+    @JvmField
+    val CAMPFIRE_POT_ACTIVE = this.create("block.campfire_pot.active")
+    @JvmField
+    val CAMPFIRE_POT_AMBIENT = this.create("block.campfire_pot.ambient")
     @JvmField
     val CAMPFIRE_POT_COOK = this.create("block.campfire_pot.cook")
     @JvmField
-    val CAMPFIRE_POT_CRAFT = this.create("block.campfire_pot.craft")
-    @JvmField
     val CAMPFIRE_POT_PLACE = this.create("block.campfire_pot.place")
     @JvmField
     val CAMPFIRE_POT_BREAK = this.create("block.campfire_pot.break")

common/src/main/kotlin/com/cobblemon/mod/common/api/abilities/Abilities.kt

@@ -15,9 +15,12 @@ import com.cobblemon.mod.common.battles.runner.ShowdownService
 import com.cobblemon.mod.common.net.messages.client.data.AbilityRegistrySyncPacket
 import com.cobblemon.mod.common.pokemon.abilities.HiddenAbilityType
 import com.cobblemon.mod.common.util.cobblemonResource
+import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.server.packs.PackType
 import net.minecraft.server.packs.resources.ResourceManager
+import java.io.File
+import kotlin.collections.set
 
 /**
  * Registry for all known Abilities
@@ -31,15 +34,31 @@ object Abilities : DataRegistry {
     val DUMMY = AbilityTemplate(name = "dummy")
 
     private val abilityMap = mutableMapOf<String, AbilityTemplate>()
+    internal val abilityScripts = mutableMapOf<String, String>() // abilityId to JavaScript
 
     override fun reload(manager: ResourceManager) {
         PotentialAbility.types.clear()
         PotentialAbility.types.add(CommonAbilityType)
         PotentialAbility.types.add(HiddenAbilityType)
         this.abilityMap.clear()
-        val abilitiesJson = ShowdownService.service.getAbilityIds()
+        this.abilityScripts.clear()
+
+        ShowdownService.service.resetRegistryData("ability")
+        manager.listResources("abilities") { it.path.endsWith(".js") }.forEach { (identifier, resource) ->
+            resource.open().use { stream ->
+                stream.bufferedReader().use { reader ->
+                    val resolvedIdentifier = ResourceLocation.fromNamespaceAndPath(identifier.namespace, File(identifier.path).nameWithoutExtension)
+                    val js = reader.readText()
+                    abilityScripts[resolvedIdentifier.path] = js
+                }
+            }
+        }
+        ShowdownService.service.sendRegistryData(abilityScripts, "ability")
+
+        val abilitiesJson = ShowdownService.service.getRegistryData("ability")
         for (i in 0 until abilitiesJson.size()) {
-            val id = abilitiesJson[i].asString
+            val jsonAbility = abilitiesJson[i].asJsonObject
+            val id = jsonAbility.get("id").asString
             val ability = AbilityTemplate(id)
             this.register(ability)
         }

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

@@ -8,8 +8,15 @@
 
 package com.cobblemon.mod.common.api.ai
 
+import com.bedrockk.molang.runtime.MoLangRuntime
 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.entity.MoLangScriptingEntity
+import com.cobblemon.mod.common.util.resolve
+import com.cobblemon.mod.common.util.withQueryValue
 import com.mojang.serialization.Dynamic
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.world.entity.LivingEntity
@@ -28,6 +35,9 @@ class BehaviourConfigurationContext {
     val memories = mutableSetOf<MemoryModuleType<*>>()
     val sensors = mutableSetOf<SensorType<*>>()
 
+    val onAddScripts = mutableListOf<ResourceLocation>()
+    val onAdd = mutableListOf<ExpressionLike>()
+
     fun getOrCreateActivity(activity: Activity): ActivityConfigurationContext {
         return activities.firstOrNull { it.activity == activity } ?: ActivityConfigurationContext(activity).also(activities::add)
     }
@@ -48,6 +58,14 @@ class BehaviourConfigurationContext {
         this.sensors.addAll(sensors)
     }
 
+    fun addOnAddScript(script: ResourceLocation) {
+        onAddScripts.add(script)
+    }
+
+    fun addOnAddScript(script: ExpressionLike) {
+        onAdd.add(script)
+    }
+
     fun apply(entity: LivingEntity, behaviourConfigs: List<BehaviourConfig>, dynamic: Dynamic<*>) {
 
         if (entity is MoLangScriptingEntity) {
@@ -62,6 +80,11 @@ class BehaviourConfigurationContext {
         // Apply the brain config
         if (entity is MoLangScriptingEntity) {
             brain = entity.assignNewBrainWithMemoriesAndSensors(dynamic, memories, sensors)
+
+            val runtime = MoLangRuntime().setup()
+            runtime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
+            onAddScripts.forEach { CobblemonScripts.run(it, runtime) }
+            onAdd.forEach { runtime.resolve(it) }
         }
         activities.forEach { it.apply(entity) }
         brain.setCoreActivities(coreActivities)

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

@@ -9,7 +9,17 @@
 package com.cobblemon.mod.common.api.ai
 
 import com.bedrockk.molang.Expression
+import com.bedrockk.molang.runtime.MoLangRuntime
+import com.bedrockk.molang.runtime.value.DoubleValue
+import com.cobblemon.mod.common.Cobblemon
+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.util.asExpression
+import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
+import com.cobblemon.mod.common.util.resolve
+import net.minecraft.world.entity.Entity
 
 /**
  * This is used in the AI system to store optional additional information about the attack target,
@@ -30,5 +40,32 @@ import com.cobblemon.mod.common.util.asExpression
  */
 class CobblemonAttackTargetData(
     /** An expression that returns false when the target is no longer worth attacking. */
-    val shouldContinue: Expression = "true".asExpression()
-)
+    var shouldContinue: Expression = "true".asExpression(),
+    var hitsUntilDisengage: Int = -1, // -1 means no limit
+    var disengageAction: (entity: Entity) -> Unit = {}
+) {
+    val struct = ObjectValue<CobblemonAttackTargetData>(this).also {
+        it.addFunction("hits_until_disengage") { DoubleValue(hitsUntilDisengage.toDouble()) }
+        it.addFunction("set_hits_until_disengage") { params ->
+            val value = params.getDouble(0)
+            hitsUntilDisengage = value.toInt()
+            DoubleValue(hitsUntilDisengage.toDouble())
+        }
+        it.addFunction("set_disengage_action") { params ->
+            val script = params.getString(0).asIdentifierDefaultingNamespace()
+            val function = CobblemonScripts.scripts[script] ?: run {
+                Cobblemon.LOGGER.warn("set_disengage_action was given script '$script' which does not exist.")
+                return@addFunction DoubleValue.ZERO
+            }
+            disengageAction = { entity ->
+                val runtime = MoLangRuntime().setup()
+                runtime.environment.query.addFunction("entity") { entity.asMostSpecificMoLangValue() }
+                runtime.resolve(function)
+            }
+            DoubleValue.ONE
+        }
+        it.addFunction("unset_disengage_action") { params ->
+            disengageAction = {}
+        }
+    }
+}

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

@@ -17,6 +17,7 @@ import com.cobblemon.mod.common.api.scripting.CobblemonScripts
 import com.cobblemon.mod.common.util.asTranslated
 import com.cobblemon.mod.common.util.resolve
 import com.cobblemon.mod.common.util.withQueryValue
+import com.google.gson.annotations.SerializedName
 import net.minecraft.network.chat.Component
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.world.entity.LivingEntity
@@ -28,23 +29,35 @@ class CobblemonBehaviour(
     val visible: Boolean = true,
     val entityType: ResourceLocation? = null,
     val configurations: List<BehaviourConfig> = mutableListOf(),
-    val undo: ExpressionLike? = null,
-    val undoScript: ResourceLocation? = null,
+    // 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,
+    @SerializedName("onRemoveScript", alternate = ["undoScript"])
+    val onRemoveScript: ResourceLocation? = null,
+    val onAdd: ExpressionLike? = null,
+    val onAddScript: ResourceLocation? = null,
 ) {
     fun canBeApplied(entity: LivingEntity) = entityType?.let { entityType == entity.type.builtInRegistryHolder().unwrapKey().get().location() } != false
     fun configure(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext) {
+        if (onAdd != null) {
+            behaviourConfigurationContext.addOnAddScript(onAdd)
+        }
+        if (onAddScript != null) {
+            behaviourConfigurationContext.addOnAddScript(onAddScript)
+        }
         configurations.forEach { it.configure(entity, behaviourConfigurationContext) }
     }
 
     /** Undoes anything that needs undoing once this configuration is being removed from an entity that had it before. */
-    fun undo(entity: LivingEntity) {
+    fun onRemove(entity: LivingEntity) {
         val runtime = MoLangRuntime().setup()
         runtime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
-        if (undoScript != null) {
-            CobblemonScripts.run(undoScript, runtime)
+        if (onRemoveScript != null) {
+            CobblemonScripts.run(onRemoveScript, runtime)
         }
-        if (undo != null) {
-            runtime.resolve(undo)
+        if (onRemove != null) {
+            runtime.resolve(onRemove)
         }
     }
 }

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

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.ai
+
+import net.minecraft.world.entity.ai.behavior.BlockPosTracker
+import net.minecraft.world.phys.Vec3
+
+/**
+ * Wraps around [BlockPosTracker] to add additional flags for Cobblemon-specific behavior.
+ *
+ * @author Hiroku
+ * @since August 4th, 2025
+ */
+class CobblemonBlockPosTracker(
+    pos: Vec3,
+    val flags: Set<String> = emptySet(),
+) : BlockPosTracker(pos) {
+    companion object {
+        const val BATTLE_LOOK_BYPASS_FLAG = "battle_look_bypass"
+    }
+
+    fun isBattleLookBypass() = flags.contains(BATTLE_LOOK_BYPASS_FLAG)
+}

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

@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.ai
+
+import com.bedrockk.molang.runtime.struct.QueryStruct
+import com.cobblemon.mod.common.util.getBooleanOrNull
+import com.cobblemon.mod.common.util.getDoubleOrNull
+import kotlin.math.sqrt
+import net.minecraft.core.BlockPos
+import net.minecraft.world.entity.PathfinderMob
+
+/**
+ * Used to maintain some settings around how the entity should wander this tick. The idea is you
+ * reset this with some script task at priority 0 then some number of steps before it gets to the wander
+ * tasks you can have other conditional tasks jump in to configure parts of this.
+ *
+ * @author Hiroku
+ * @since July 18, 2025
+ */
+class CobblemonWanderControl(
+    var center: WanderCenter? = null,
+    var maxAttempts: Int = 4, // How many times to try to find a suitable point before giving up on that tick.
+    var allowLand: Boolean = true,
+    var allowWater: Boolean = false,
+    var allowAir: Boolean = false,
+    var pathCooldownTicks: Int = 20 * 5, // Used to mitigate the cost of pathfinding.
+    var wanderSpeed: Float = 0.35F,
+) {
+    class WanderCenter(val x: Number, val y: Number, val z: Number, val minRange: Float, val maxRange: Float)
+
+    @Transient
+    val struct: QueryStruct = QueryStruct(hashMapOf())
+        .addFunction("center_x") { center?.x ?: 0.0 }
+        .addFunction("center_y") { center?.y ?: 0.0 }
+        .addFunction("center_z") { center?.z ?: 0.0 }
+        .addFunction("max_attempts") { maxAttempts.toDouble() }
+        .addFunction("min_range") { center?.minRange ?: 0.0 }
+        .addFunction("max_range") { center?.maxRange ?: 0.0 }
+        .addFunction("allow_land") { if (allowLand) 1.0 else 0.0 }
+        .addFunction("allow_water") { if (allowWater) 1.0 else 0.0 }
+        .addFunction("allow_air") { if (allowAir) 1.0 else 0.0 }
+        .addFunction("path_cooldown_ticks") { pathCooldownTicks.toDouble() }
+        .addFunction("wander_speed") { wanderSpeed }
+        .addFunction("set_center") { params ->
+            if (params.params.size < 3) {
+                throw IllegalArgumentException("set_center requires at least 3 parameters: x, y, z")
+            }
+            val x = params.getDouble(0)
+            val y = params.getDouble(1)
+            val z = params.getDouble(2)
+            val minRange = params.getDoubleOrNull(3) ?: 0.0
+            val maxRange = params.getDoubleOrNull(4) ?: Float.MAX_VALUE.toDouble()
+            center = WanderCenter(
+                x = x,
+                y = y,
+                z = z,
+                minRange = minRange.toFloat(),
+                maxRange = maxRange.toFloat(),
+            )
+        }
+        .addFunction("set_max_attempts") { params -> maxAttempts = params.getDoubleOrNull(0)?.toInt() ?: 4 }
+        .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") {
+            center = null
+            allowLand = false
+            allowWater = false
+            allowAir = false
+            pathCooldownTicks = 20 * 5
+            wanderSpeed = 0.35F
+            maxAttempts = 4
+        }
+
+    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
+    }
+}
+

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

@@ -0,0 +1,45 @@
+/*
+ * 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.api.ai.BehaviourConfigurationContext
+import com.cobblemon.mod.common.api.molang.ExpressionLike
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
+import com.cobblemon.mod.common.api.npc.configuration.MoLangConfigVariable
+import com.cobblemon.mod.common.util.asExpressionLike
+import com.cobblemon.mod.common.util.withQueryValue
+import net.minecraft.server.level.ServerLevel
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.ai.behavior.BehaviorControl
+import net.minecraft.world.entity.ai.behavior.OneShot
+import net.minecraft.world.entity.schedule.Activity
+
+class ActivityChangeTaskConfig : SingleTaskConfig {
+    val activity: Activity = Activity.IDLE
+    val condition: ExpressionLike = "false".asExpressionLike()
+
+    override fun getVariables(entity: LivingEntity): List<MoLangConfigVariable> = emptyList()
+
+    override fun createTask(
+        entity: LivingEntity,
+        behaviourConfigurationContext: BehaviourConfigurationContext
+    ): BehaviorControl<in LivingEntity>? {
+        return object : OneShot<LivingEntity>() {
+            override fun trigger(serverLevel: ServerLevel, livingEntity: LivingEntity, l: Long): Boolean {
+                runtime.withQueryValue("entity", livingEntity.asMostSpecificMoLangValue())
+                if (condition.resolveBoolean(runtime)) {
+                    livingEntity.brain.setActiveActivityIfPossible(activity)
+                    return true
+                } else {
+                    return false
+                }
+            }
+        }
+    }
+}

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

@@ -21,6 +21,7 @@ import net.minecraft.world.entity.Mob
 import net.minecraft.world.entity.ai.behavior.BehaviorControl
 import net.minecraft.world.entity.ai.behavior.LookAtTargetSink
 import net.minecraft.world.entity.ai.memory.MemoryModuleType
+import net.minecraft.world.entity.ai.sensing.SensorType
 
 class LookAtTargetTaskConfig : SingleTaskConfig {
     val condition: ExpressionOrEntityVariable = Either.left("true".asExpression())
@@ -39,7 +40,8 @@ class LookAtTargetTaskConfig : SingleTaskConfig {
     ): BehaviorControl<in LivingEntity>? {
         runtime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
         if (!condition.resolveBoolean()) return null
-        behaviourConfigurationContext.addMemories(MemoryModuleType.LOOK_TARGET)
+        behaviourConfigurationContext.addMemories(MemoryModuleType.LOOK_TARGET, MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES)
+        behaviourConfigurationContext.addSensors(SensorType.NEAREST_LIVING_ENTITIES)
         return WrapperLivingEntityTask(LookAtTargetSink(minDurationTicks.resolveInt(), maxDurationTicks.resolveInt()), Mob::class.java)
     }
 }

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

@@ -0,0 +1,82 @@
+/*
+ * 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.bedrockk.molang.ast.StringExpression
+import com.bedrockk.molang.runtime.value.StringValue
+import com.cobblemon.mod.common.Cobblemon
+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.entity.npc.NPCEntity
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.mojang.datafixers.util.Either
+import net.minecraft.server.level.ServerLevel
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.ai.behavior.Behavior
+import net.minecraft.world.entity.ai.behavior.BehaviorControl
+import net.minecraft.world.entity.ai.memory.MemoryModuleType
+import net.minecraft.world.entity.ai.memory.MemoryStatus
+
+/**
+ * A task that modifies the aspects of a Pokémon or NPC based on a memory module.
+ * If the memory is registered, the aspect is added; if it is absent, the aspect is removed.
+ *
+ * @author Hiroku
+ * @since July 6th, 2025
+ */
+class MemoryAspectTaskConfig : SingleTaskConfig {
+    var memory: MemoryModuleType<*> = MemoryModuleType.DUMMY
+    var aspect: ExpressionOrEntityVariable = Either.left(StringExpression(StringValue("")))
+
+    override fun getVariables(entity: LivingEntity) = listOf(aspect).asVariables()
+    override fun createTask(
+        entity: LivingEntity,
+        behaviourConfigurationContext: BehaviourConfigurationContext
+    ): BehaviorControl<in LivingEntity>? {
+        if (entity !is PokemonEntity && entity !is NPCEntity) {
+            return null
+        } else if (memory == MemoryModuleType.DUMMY) {
+            Cobblemon.LOGGER.error("MemoryAspectTaskConfig: Memory module type is not set for ${entity.name.string}.")
+            return null
+        } else if (aspect.left().orElse(null)?.originalString == "") {
+            Cobblemon.LOGGER.error("MemoryAspectTaskConfig: Aspect is not set for ${entity.name.string}.")
+            return null
+        }
+
+        val aspect = aspect.resolveString()
+
+        return object : Behavior<LivingEntity>(
+            mapOf(memory to MemoryStatus.REGISTERED),
+            Int.MAX_VALUE,
+            Int.MAX_VALUE
+        ) {
+            override fun canStillUse(level: ServerLevel, entity: LivingEntity, gameTime: Long) = true
+
+            override fun tick(level: ServerLevel, owner: LivingEntity, gameTime: Long) {
+                val hasMemory = !owner.brain.hasMemoryValue(memory)
+                if (owner is PokemonEntity) {
+                    if (!hasMemory && aspect in owner.pokemon.forcedAspects) {
+                        owner.pokemon.forcedAspects -= aspect
+                    } else if (hasMemory && aspect !in owner.pokemon.forcedAspects) {
+                        owner.pokemon.forcedAspects += aspect
+                    } else return
+                    owner.pokemon.updateAspects()
+                } else if (owner is NPCEntity) {
+                    if (!hasMemory && aspect in owner.appliedAspects) {
+                        owner.appliedAspects -= aspect
+                    } else if (hasMemory && aspect !in owner.appliedAspects) {
+                        owner.appliedAspects += aspect
+                    } else return
+                    owner.updateAspects()
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,41 @@
+/*
+ * 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.api.ai.BehaviourConfigurationContext
+import com.cobblemon.mod.common.api.ai.asVariables
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.entity.pokemon.ai.tasks.PathToBeeHiveTask
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.ai.behavior.BehaviorControl
+
+class PathToBeeHiveTaskConfig : SingleTaskConfig {
+    companion object {
+        const val HONEY = "honey"
+    }
+
+    val condition = booleanVariable(HONEY, "can_add_honey", true).asExpressible()
+
+    override fun getVariables(entity: LivingEntity) = listOf(
+        condition,
+    ).asVariables()
+
+    override fun createTask(
+        entity: LivingEntity,
+        behaviourConfigurationContext: BehaviourConfigurationContext
+    ): BehaviorControl<in LivingEntity>? {
+        if (entity !is PokemonEntity) {
+            return null
+        }
+        if (!checkCondition(entity, condition)) {
+            return null
+        }
+        return PathToBeeHiveTask.create()
+    }
+}

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

@@ -0,0 +1,51 @@
+/*
+ * 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.ai.asVariables
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.entity.pokemon.ai.tasks.PathToFlowerTask
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.ai.behavior.BehaviorControl
+
+class PathToFlowerTaskConfig : SingleTaskConfig {
+    companion object {
+        const val POLLINATE = "pollinate"
+    }
+
+    val condition = booleanVariable(POLLINATE, "can_pollinate", true).asExpressible()
+
+    override fun getVariables(entity: LivingEntity) = listOf(
+        condition
+    ).asVariables()
+
+    override fun createTask(
+        entity: LivingEntity,
+        behaviourConfigurationContext: BehaviourConfigurationContext
+    ): BehaviorControl<in LivingEntity>? {
+        if (entity !is PokemonEntity) {
+            return null
+        }
+
+        if (!checkCondition(entity, condition)) {
+            return null
+        }
+        behaviourConfigurationContext.addMemories(
+            CobblemonMemories.NEARBY_FLOWERS,
+            CobblemonMemories.HIVE_COOLDOWN,
+            CobblemonMemories.HIVE_LOCATION,
+            CobblemonMemories.POLLINATED
+        )
+        behaviourConfigurationContext.addSensors(CobblemonSensors.NEARBY_BEE_HIVE, CobblemonSensors.NEARBY_FLOWER)
+        return PathToFlowerTask.create()
+    }
+}

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

@@ -0,0 +1,41 @@
+/*
+ * 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.api.ai.BehaviourConfigurationContext
+import com.cobblemon.mod.common.api.ai.asVariables
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.entity.pokemon.ai.tasks.PlaceHoneyInHiveTask
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.ai.behavior.BehaviorControl
+
+class PlaceHoneyInHiveTaskConfig : SingleTaskConfig {
+    companion object {
+        const val HONEY = "honey"
+    }
+
+    val condition = booleanVariable(HONEY, "can_add_honey", true).asExpressible()
+
+    override fun getVariables(entity: LivingEntity) = listOf(
+        condition
+    ).asVariables()
+
+    override fun createTask(
+        entity: LivingEntity,
+        behaviourConfigurationContext: BehaviourConfigurationContext
+    ): BehaviorControl<in LivingEntity>? {
+        if (entity !is PokemonEntity) {
+            return null
+        }
+        if (!checkCondition(entity, condition)) {
+            return null
+        }
+        return PlaceHoneyInHiveTask.create()
+    }
+}

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

@@ -0,0 +1,94 @@
+/*
+ * 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.api.ai.BehaviourConfigurationContext
+import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
+import com.cobblemon.mod.common.api.ai.asVariables
+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.sendParticlesServer
+import com.mojang.datafixers.util.Either
+import net.minecraft.core.particles.ParticleTypes
+import net.minecraft.server.level.ServerLevel
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.ai.behavior.Behavior
+import net.minecraft.world.entity.ai.behavior.BehaviorControl
+import net.minecraft.world.entity.ai.memory.MemoryModuleType
+import net.minecraft.world.entity.ai.memory.MemoryStatus
+import net.minecraft.world.phys.Vec3
+
+class PollinateFlowerTaskConfig : SingleTaskConfig {
+    companion object {
+        const val POLLINATE = "pollinate"
+    }
+
+    val condition = booleanVariable(POLLINATE, "can_pollinate", true).asExpressible()
+    val durationTicks: ExpressionOrEntityVariable = Either.left("30".asExpression())
+
+    override fun getVariables(entity: LivingEntity) = listOf(
+        condition
+    ).asVariables()
+
+    override fun createTask(
+        entity: LivingEntity,
+        behaviourConfigurationContext: BehaviourConfigurationContext
+    ): BehaviorControl<in LivingEntity>? {
+        if (entity !is PokemonEntity) {
+            return null
+        }
+        if (!checkCondition(entity, condition)) {
+            return null
+        }
+
+        return object : Behavior<LivingEntity>(
+            mapOf(
+                CobblemonMemories.NEARBY_FLOWERS to MemoryStatus.VALUE_PRESENT,
+                MemoryModuleType.WALK_TARGET to MemoryStatus.VALUE_ABSENT,
+                CobblemonMemories.POLLINATED to MemoryStatus.VALUE_ABSENT,
+                CobblemonMemories.HIVE_COOLDOWN to MemoryStatus.VALUE_ABSENT,
+            ),
+            15,
+            45
+        ) {
+            override fun checkExtraStartConditions(level: ServerLevel, owner: LivingEntity): Boolean {
+                return entity.brain.getMemorySafely(CobblemonMemories.NEARBY_FLOWERS).orElse(emptyList()).any {
+                    Vec3.atCenterOf(it).distanceTo(entity.position()) <= 1.0
+                }
+            }
+
+            override fun canStillUse(level: ServerLevel, entity: LivingEntity, gameTime: Long): Boolean {
+                return checkExtraStartConditions(level, entity)
+            }
+
+            override fun start(level: ServerLevel, entity: LivingEntity, gameTime: Long) {
+                super.start(level, entity, gameTime)
+            }
+
+            override fun tick(level: ServerLevel, owner: LivingEntity, gameTime: Long) {
+                level.sendParticlesServer(
+                    particleType = ParticleTypes.DRIPPING_HONEY,
+                    position = owner.eyePosition,
+                    particles = 3,
+                    offset = Vec3.ZERO,
+                    speed = 0.0
+                )
+            }
+
+            override fun stop(level: ServerLevel, entity: LivingEntity, gameTime: Long) {
+                val flowerStillThere = canStillUse(level, entity, gameTime)
+                if (flowerStillThere) {
+                    entity.brain.setMemory(CobblemonMemories.POLLINATED, true)
+                }
+            }
+        }
+    }
+}

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

@@ -99,6 +99,11 @@ interface TaskConfig {
             cobblemonResource("eat_grass") to EatGrassTaskConfig::class.java,
             cobblemonResource("find_air") to FindAirTaskConfig::class.java,
             cobblemonResource("go_to_land") to GoToLandTaskConfig::class.java,
+            cobblemonResource("path_to_hive") to PathToBeeHiveTaskConfig::class.java,
+            cobblemonResource("place_honey_in_hive") to PlaceHoneyInHiveTaskConfig::class.java,
+            cobblemonResource("path_to_flower") to PathToFlowerTaskConfig::class.java,
+            cobblemonResource("pollinate_flower") to PollinateFlowerTaskConfig::class.java,
+            cobblemonResource("go_to_land") to GoToLandTaskConfig::class.java,
             cobblemonResource("manage_flight_in_battle") to ManageFlightInBattleTaskConfig::class.java,
             cobblemonResource("attack_hostile_mobs") to AttackHostileMobsTaskConfig::class.java,
             cobblemonResource("move_into_fluid") to MoveIntoFluidTaskConfig::class.java,
@@ -110,6 +115,8 @@ interface TaskConfig {
             cobblemonResource("count_followers") to CountFollowersTaskConfig::class.java,
             cobblemonResource("hate_entity") to HateEntityTaskConfig::class.java,
             cobblemonResource("target_entity") to TargetEntityTaskConfig::class.java,
+            cobblemonResource("memory_aspect") to MemoryAspectTaskConfig::class.java,
+            cobblemonResource("activity_change") to ActivityChangeTaskConfig::class.java,
         )
 
         val runtime = MoLangRuntime().setup()

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

@@ -10,12 +10,14 @@ package com.cobblemon.mod.common.api.ai.config.task
 
 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.molang.MoLangFunctions.asMostSpecificMoLangValue
 import com.cobblemon.mod.common.entity.ai.CobblemonWalkTarget
 import com.cobblemon.mod.common.util.asExpression
 import com.cobblemon.mod.common.util.resolveFloat
+import com.cobblemon.mod.common.util.toVec3d
 import com.cobblemon.mod.common.util.withQueryValue
 import com.mojang.datafixers.util.Either
 import net.minecraft.core.BlockPos
@@ -23,9 +25,11 @@ import net.minecraft.server.level.ServerLevel
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.PathfinderMob
 import net.minecraft.world.entity.ai.behavior.BehaviorControl
+import net.minecraft.world.entity.ai.behavior.BlockPosTracker
 import net.minecraft.world.entity.ai.behavior.declarative.BehaviorBuilder
 import net.minecraft.world.entity.ai.behavior.declarative.Trigger
 import net.minecraft.world.entity.ai.memory.MemoryModuleType
+import net.minecraft.world.entity.ai.util.HoverRandomPos
 import net.minecraft.world.entity.ai.util.LandRandomPos
 import net.minecraft.world.level.pathfinder.PathType
 
@@ -101,45 +105,70 @@ class WanderTaskConfig : SingleTaskConfig {
         behaviourConfigurationContext.addMemories(
             MemoryModuleType.WALK_TARGET,
             MemoryModuleType.LOOK_TARGET,
-            CobblemonMemories.PATH_COOLDOWN
+            CobblemonMemories.PATH_COOLDOWN,
+            CobblemonMemories.WANDER_CONTROL
         )
 
         return BehaviorBuilder.create {
             it.group(
                 it.absent(MemoryModuleType.WALK_TARGET),
                 it.registered(MemoryModuleType.LOOK_TARGET),
-                it.absent(CobblemonMemories.PATH_COOLDOWN)
-            ).apply(it) { walkTarget, lookTarget, pathCooldown ->
+                it.absent(CobblemonMemories.PATH_COOLDOWN),
+                it.registered(CobblemonMemories.WANDER_CONTROL)
+            ).apply(it) { walkTarget, lookTarget, pathCooldown, wanderControl ->
                 Trigger { world, entity, time ->
                     if (entity !is PathfinderMob || entity.isUnderWater) {
                         return@Trigger false
                     }
 
+                    val wanderControl = it.tryGet(wanderControl).orElse(null) ?: CobblemonWanderControl()
+                    val avoidsTargetingAir = avoidTargetingAir.resolveBoolean()
+
                     runtime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
                     val wanderChance = runtime.resolveFloat(wanderChanceExpression)
-                    if (wanderChance <= 0 || world.random.nextFloat() > wanderChance) {
+                    if (wanderChance <= 0 || world.random.nextFloat() > wanderChance || !wanderControl.allowLand) {
                         return@Trigger false
                     }
 
-                    pathCooldown.setWithExpiry(true, 40L)
-                    val avoidsTargetingAir = avoidTargetingAir.resolveBoolean()
-
-//                    val targetVec = getLandTarget(entity) ?: return@Trigger true
-                    val targetVec = LandRandomPos.getPos(
-                        entity,
-                        horizontalRange.resolveInt(),
-                        verticalRange.resolveInt()
-                    ) ?: return@Trigger false
-
+                    pathCooldown.setWithExpiry(true, wanderControl.pathCooldownTicks.toLong())
                     val minimumHeight = minimumHeight.resolveInt()
                     val maximumHeight = maximumHeight.resolveInt()
 
-                    val pos = applyHeightConstraints(
-                        pos = BlockPos.containing(targetVec),
-                        minimumHeight = minimumHeight,
-                        maximumHeight = maximumHeight,
-                        world = world
-                    )
+                    var attempts = 0
+                    var pos: BlockPos? = null
+                    while (attempts++ < wanderControl.maxAttempts && pos == null) {
+//                    val targetVec = getLandTarget(entity) ?: return@Trigger true
+                        val targetVec = if (maximumHeight != -1) {
+                            HoverRandomPos.getPos(
+                                entity,
+                                horizontalRange.resolveInt(),
+                                maxOf(verticalRange.resolveInt(), maximumHeight), // In case they fly up pretty high and need to find a way down
+                                entity.random.nextFloat() - 0.5,
+                                entity.random.nextFloat() - 0.5,
+                                Math.PI.toFloat(),
+                                maximumHeight,
+                                minimumHeight
+                            )
+                        } else {
+                                LandRandomPos.getPos(
+                                    entity,
+                                    horizontalRange.resolveInt(),
+                                    verticalRange.resolveInt()
+                                )
+                        } ?: continue
+
+                        pos = applyHeightConstraints(
+                            pos = BlockPos.containing(targetVec),
+                            minimumHeight = minimumHeight,
+                            maximumHeight = maximumHeight,
+                            world = world
+                        ).takeIf(wanderControl::isSuitable)
+                    }
+
+                    if (pos == null) {
+                        return@Trigger false
+                    }
+
                     walkTarget.set(
                         CobblemonWalkTarget(
                             pos = pos,
@@ -149,7 +178,7 @@ class WanderTaskConfig : SingleTaskConfig {
                             destinationNodeTypeFilter = { nodeType -> !avoidsTargetingAir || nodeType !in listOf(PathType.OPEN) }
                         )
                     )
-                    lookTarget.erase()
+                    lookTarget.set(BlockPosTracker(pos.toVec3d().add(0.0, entity.eyeHeight.toDouble(), 0.0)))
                     return@Trigger true
                 }
             }

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

@@ -10,6 +10,7 @@ package com.cobblemon.mod.common.api.ai.config.task
 
 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.config.task.WanderTaskConfig.Companion.WANDER
@@ -30,6 +31,7 @@ import net.minecraft.world.entity.ai.behavior.declarative.BehaviorBuilder
 import net.minecraft.world.entity.ai.behavior.declarative.Trigger
 import net.minecraft.world.entity.ai.memory.MemoryModuleType
 import net.minecraft.world.level.pathfinder.PathType
+import net.minecraft.world.phys.Vec3
 
 class WaterWanderTaskConfig : SingleTaskConfig {
     val condition = booleanVariable(WANDER, "water_wanders", true).asExpressible()
@@ -54,35 +56,56 @@ class WaterWanderTaskConfig : SingleTaskConfig {
         behaviourConfigurationContext.addMemories(
             MemoryModuleType.WALK_TARGET,
             MemoryModuleType.LOOK_TARGET,
-            CobblemonMemories.PATH_COOLDOWN
+            CobblemonMemories.PATH_COOLDOWN,
+            CobblemonMemories.WANDER_CONTROL
         )
 
         return BehaviorBuilder.create {
             it.group(
                 it.absent(MemoryModuleType.WALK_TARGET),
                 it.registered(MemoryModuleType.LOOK_TARGET),
-                it.registered(CobblemonMemories.PATH_COOLDOWN)
-            ).apply(it) { walkTarget, lookTarget, pathCooldown ->
+                it.registered(CobblemonMemories.PATH_COOLDOWN),
+                it.registered(CobblemonMemories.WANDER_CONTROL)
+            ).apply(it) { walkTarget, lookTarget, pathCooldown, wanderControlData ->
                 Trigger { world, entity, time ->
                     if (entity !is PathfinderMob || !entity.isInWater) {
                         return@Trigger false
                     }
 
+                    val wanderControl = it.tryGet(wanderControlData).orElse(null) ?: CobblemonWanderControl()
+                    if (!wanderControl.allowWater) {
+                        return@Trigger false
+                    }
+
                     runtime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
                     val wanderChance = runtime.resolveFloat(wanderChanceExpression)
                     if (wanderChance <= 0 || world.random.nextFloat() > wanderChance) {
                         return@Trigger false
                     }
 
-                    pathCooldown.setWithExpiry(true, 60L)
+                    pathCooldown.setWithExpiry(true, wanderControl.pathCooldownTicks.toLong())
+
+                    var pos: BlockPos? = null
+                    var target: Vec3? = null
+                    var attempts = 0
+
+                    while (attempts < wanderControl.maxAttempts && pos == null) {
+                        attempts++
+                        target = BehaviorUtils.getRandomSwimmablePos(entity, horizontalRange.resolveInt(), verticalRange.resolveInt())
+                            ?: continue
+                        pos = BlockPos.containing(target).takeIf(wanderControl::isSuitable)
+                    }
+
+                    if (pos == null || target == null) {
+                        return@Trigger false
+                    }
 
-                    val target = BehaviorUtils.getRandomSwimmablePos(entity, horizontalRange.resolveInt(), verticalRange.resolveInt()) ?: return@Trigger false
                     walkTarget.set(
                         CobblemonWalkTarget(
-                            pos = BlockPos.containing(target),
+                            pos = pos,
                             nodeTypeFilter = { it == PathType.WATER || it == PathType.WATER_BORDER },
                             speedModifier = speedMultiplier.resolveFloat(),
-                            completionRange = 1
+                            completionRange = 0
                         )
                     )
                     lookTarget.set(BlockPosTracker(target))

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

@@ -13,6 +13,7 @@ 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.Cobblemon.LOGGER
+import com.cobblemon.mod.common.CobblemonBuildDetails
 import com.cobblemon.mod.common.CobblemonNetwork
 import com.cobblemon.mod.common.api.battles.interpreter.BattleMessage
 import com.cobblemon.mod.common.api.battles.model.actor.ActorType
@@ -77,7 +78,7 @@ open class PokemonBattle(
     val side2: BattleSide
 ) {
     /** Whether logging will be silenced for this battle. */
-    var mute = true
+    var mute = !CobblemonBuildDetails.SNAPSHOT
     val struct = this.asMoLangValue()
     val runtime = MoLangRuntime().also { it.environment.query = struct }
 

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

@@ -12,9 +12,17 @@ import com.cobblemon.mod.common.Cobblemon.LOGGER
 import com.cobblemon.mod.common.api.battles.model.ai.BattleAI
 import com.cobblemon.mod.common.api.net.NetworkPacket
 import com.cobblemon.mod.common.battles.PassActionResponse
+import com.cobblemon.mod.common.battles.ShowdownActionResponse
 import com.cobblemon.mod.common.battles.pokemon.BattlePokemon
 import com.cobblemon.mod.common.exception.IllegalActionChoiceException
+import com.cobblemon.mod.common.net.messages.client.battle.BattleFaintPacket
+import com.cobblemon.mod.common.net.messages.client.battle.BattleHealthChangePacket
 import com.cobblemon.mod.common.net.messages.client.battle.BattleMakeChoicePacket
+import com.cobblemon.mod.common.net.messages.client.battle.BattlePersistentStatusPacket
+import com.cobblemon.mod.common.net.messages.client.battle.BattleReplacePokemonPacket
+import com.cobblemon.mod.common.net.messages.client.battle.BattleSwapPokemonPacket
+import com.cobblemon.mod.common.net.messages.client.battle.BattleSwitchPokemonPacket
+import com.cobblemon.mod.common.net.messages.client.battle.BattleTransformPokemonPacket
 import java.util.UUID
 
 abstract class AIBattleActor(
@@ -25,8 +33,15 @@ abstract class AIBattleActor(
     override fun sendUpdate(packet: NetworkPacket<*>) {
         super.sendUpdate(packet)
 
-        if (packet is BattleMakeChoicePacket) {
-            this.onChoiceRequested()
+        when (packet) {
+            is BattleMakeChoicePacket -> this.onChoiceRequested()
+            is BattlePersistentStatusPacket -> {}
+            is BattleFaintPacket -> {}
+            is BattleSwitchPokemonPacket -> if (!packet.isAlly) { /* TODO this might be redundant; switch on opposing site should be visible during turn */ }
+            is BattleSwapPokemonPacket -> { /* TODO CONSIDER MULTI SHIFTING */ }
+            is BattleHealthChangePacket -> battleAI.onHealthChange(packet)
+            is BattleTransformPokemonPacket -> if (!packet.isAlly) { /* TODO this might be redundant; switch on opposing site should be visible during turn */ }
+            is BattleReplacePokemonPacket -> if (!packet.isAlly) { /* TODO this might be redundant; switch on opposing site should be visible during turn */ }
         }
     }
 
@@ -35,11 +50,35 @@ abstract class AIBattleActor(
      */
     open fun onChoiceRequested() {
         try {
-            setActionResponses(request!!.iterate(this.activePokemon, battleAI::choose))
+            request?.let {
+                setActionResponses(it.iterate(this.activePokemon) { battleMon, moveset, forceSwitch ->
+                    battleAI.choose(battleMon, battle, getSide(), moveset, forceSwitch)
+                })
+                pokemonList.forEach { pokemon ->
+                    pokemon.willBeSwitchedIn = false
+                }
+            } ?: {
+                val response = mutableListOf<ShowdownActionResponse>()
+                repeat(activePokemon.size) {
+                    response.add(PassActionResponse)
+                }
+                setActionResponses(response)
+                LOGGER.warn("AI requested choice, but no request was set. Returning PassActionResponses.")
+            }
         } catch (exception: IllegalActionChoiceException) {
-            LOGGER.error("AI was unable to choose a move, we're going to need to pass!")
+            LOGGER.error("AI was unable to choose an action, we're going to need to pass!")
             exception.printStackTrace()
-            setActionResponses(request!!.iterate(this.activePokemon) { _, _, _ -> PassActionResponse })
+            request?.let {
+                setActionResponses(it.iterate(this.activePokemon) { _, _ , _->
+                    PassActionResponse
+                })
+            } ?: {
+                val response = mutableListOf<ShowdownActionResponse>()
+                repeat(activePokemon.size) {
+                    response.add(PassActionResponse)
+                }
+                setActionResponses(response)
+            }
         }
     }
 }

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

@@ -8,23 +8,36 @@
 
 package com.cobblemon.mod.common.api.battles.model.ai
 
+import com.cobblemon.mod.common.api.battles.model.PokemonBattle
 import com.cobblemon.mod.common.battles.ActiveBattlePokemon
+import com.cobblemon.mod.common.battles.BattleSide
 import com.cobblemon.mod.common.battles.ShowdownActionResponse
 import com.cobblemon.mod.common.battles.ShowdownMoveset
+import com.cobblemon.mod.common.net.messages.client.battle.BattleHealthChangePacket
 
 /**
- * Interface for an actors battle AI
+ * Interface for an actor battle AI
  *
  * @since January 16th, 2022
- * @author Deltric
+ * @author Deltric, Polymeta
  */
 interface BattleAI {
     /**
      * Requests that the AI choose an action for the given Pokémon
      * @param activeBattlePokemon The Pokémon slot that is choosing an action
-     * @param moveset The [ShowdownMoveset] for this slot. This can be null if [forceSwitch] is true. Otherwise it is the available move information from Showdown.
-     * @param forceSwitch Whether or not this is a force switch situation.
+     * @param battle The ongoing [PokemonBattle]
+     * @param aiSide The [BattleSide] the AI is fighting on, useful for allies and opponent determination
+     * @param moveset The [ShowdownMoveset] for this slot. This can be null if [forceSwitch] is true. Otherwise, it is the available move information from Showdown.
+     * @param forceSwitch Whether this is a force switch situation.
      * @return the action response
      */
-    fun choose(activeBattlePokemon: ActiveBattlePokemon, moveset: ShowdownMoveset?, forceSwitch: Boolean): ShowdownActionResponse
+    fun choose(
+        activeBattlePokemon: ActiveBattlePokemon,
+        battle: PokemonBattle,
+        aiSide: BattleSide,
+        moveset: ShowdownMoveset?,
+        forceSwitch: Boolean
+    ): ShowdownActionResponse
+
+    fun onHealthChange(packet: BattleHealthChangePacket) {}
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/berry/Berry.kt

@@ -95,6 +95,7 @@ class Berry(
     val fruitModelIdentifier: ResourceLocation,
     val fruitTexture: ResourceLocation,
     val stageOnePositioning: GrowthPoint,
+    val pokeSnackPositionings: Array<GrowthPoint>,
     val weight: Float,
     val boneMealChance: Float
 ) {
@@ -293,6 +294,14 @@ class Berry(
         buffer.writeDouble(stageOnePositioning.rotation.x)
         buffer.writeDouble(stageOnePositioning.rotation.y)
         buffer.writeDouble(stageOnePositioning.rotation.z)
+        buffer.writeCollection(this.pokeSnackPositionings.toList())  { writer, value ->
+            writer.writeDouble(value.position.x)
+            writer.writeDouble(value.position.y)
+            writer.writeDouble(value.position.z)
+            writer.writeDouble(value.rotation.x)
+            writer.writeDouble(value.rotation.y)
+            writer.writeDouble(value.rotation.z)
+        }
         buffer.writeFloat(boneMealChance)
     }
 
@@ -360,9 +369,12 @@ class Berry(
             val flowerTexture = buffer.readIdentifier()
             val fruitModelIdentifier = buffer.readIdentifier()
             val fruitTexture = buffer.readIdentifier()
-            val stageOneYPos = GrowthPoint(Vec3(buffer.readDouble(), buffer.readDouble(), buffer.readDouble()), Vec3(buffer.readDouble(), buffer.readDouble(), buffer.readDouble()))
+            val stageOnePos = GrowthPoint(Vec3(buffer.readDouble(), buffer.readDouble(), buffer.readDouble()), Vec3(buffer.readDouble(), buffer.readDouble(), buffer.readDouble()))
+            val pokeSnackPos = buffer.readList { reader ->
+                GrowthPoint(Vec3(reader.readDouble(), reader.readDouble(), reader.readDouble()), Vec3(reader.readDouble(), reader.readDouble(), reader.readDouble()))
+            }.toTypedArray()
             val boneMealChance = buffer.readFloat()
-            return Berry(identifier, baseYield, emptyList(), growthTime, refreshRate, favMulchs, emptySet(), emptyList(), growthPoints, randomizedGrowthPoints, mutations, sproutShapeBoxes, matureShapeBoxes, flavors, colour, tintIndexes, flowerModelIdentifier, flowerTexture, fruitModelIdentifier, fruitTexture, stageOneYPos, 0F, boneMealChance)
+            return Berry(identifier, baseYield, emptyList(), growthTime, refreshRate, favMulchs, emptySet(), emptyList(), growthPoints, randomizedGrowthPoints, mutations, sproutShapeBoxes, matureShapeBoxes, flavors, colour, tintIndexes, flowerModelIdentifier, flowerTexture, fruitModelIdentifier, fruitTexture, stageOnePos, pokeSnackPos, 0F, boneMealChance)
         }
 
     }

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

@@ -21,6 +21,7 @@ interface PokemonSideDelegate : EntitySideDelegate<PokemonEntity> {
     fun updatePostDeath() {}
     fun handleStatus(status: Byte) {}
     fun spawnShinyParticle(player: Player) {}
+    fun spawnAspectParticle() {}
     fun positionRider(passenger: Entity, positionUpdater: MoveFunction)
     fun updateAge(age: Int) {}
 }

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

@@ -231,7 +231,7 @@ object CobblemonEvents {
     @JvmField
     val POKEMON_GAINED = EventObservable<PokemonGainedEvent>()
     @JvmField
-    val POKEMON_SEEN = EventObservable<PokemonSeenEvent>()
+    val POKEMON_SEEN = CancelableObservable<PokemonSeenEvent>()
     @JvmField
     val POKEMON_ASPECTS_CHANGED = EventObservable<PokemonAspectsChangedEvent>()
     @JvmField

common/src/main/kotlin/com/cobblemon/mod/common/api/events/berry/BerryHarvestEvent.kt

@@ -8,9 +8,14 @@
 
 package com.cobblemon.mod.common.api.events.berry
 
+import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.berry.Berry
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.block.entity.BerryBlockEntity
+import com.cobblemon.mod.common.util.toArrayStruct
+import com.cobblemon.mod.common.util.worldRegistry
 import net.minecraft.core.BlockPos
+import net.minecraft.core.registries.Registries
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.world.item.ItemStack
 import net.minecraft.world.level.Level
@@ -38,4 +43,11 @@ data class BerryHarvestEvent(
     val state: BlockState,
     val blockEntity: BerryBlockEntity,
     val drops: MutableList<ItemStack>
-) : BerryEvent
+) : BerryEvent {
+    val context = mutableMapOf(
+        "player" to player.asMoLangValue(),
+        "berry" to StringValue(berry.identifier.toString()),
+        "world" to world.worldRegistry.wrapAsHolder(world).asMoLangValue(Registries.DIMENSION),
+        "pos" to pos.toArrayStruct()
+    )
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/events/drops/LootDroppedEvent.kt

@@ -8,10 +8,16 @@
 
 package com.cobblemon.mod.common.api.events.drops
 
+import com.bedrockk.molang.runtime.value.DoubleValue
+import com.bedrockk.molang.runtime.value.MoValue
 import com.cobblemon.mod.common.api.drop.DropEntry
 import com.cobblemon.mod.common.api.drop.DropTable
 import com.cobblemon.mod.common.api.events.Cancelable
 import com.cobblemon.mod.common.api.events.CobblemonEvents
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
+import com.cobblemon.mod.common.util.asArrayValue
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.world.entity.LivingEntity
 
@@ -38,4 +44,14 @@ class LootDroppedEvent(
     val player: ServerPlayer?,
     val entity: LivingEntity?,
     val drops: MutableList<DropEntry>
-) : Cancelable()
+) : Cancelable() {
+    val context = mapOf<String, MoValue>(
+        "player" to (player?.asMoLangValue() ?: DoubleValue.ZERO),
+        "entity" to (entity?.asMostSpecificMoLangValue() ?: DoubleValue.ZERO),
+        "drops" to drops.asArrayValue { it.asMoLangValue() }
+    )
+
+    val functions = moLangFunctionMap(
+        cancelFunc
+    )
+}

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

@@ -9,10 +9,21 @@
 package com.cobblemon.mod.common.api.events.fishing
 
 import com.cobblemon.mod.common.api.events.Cancelable
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
+import com.cobblemon.mod.common.util.server
 import net.minecraft.world.item.ItemStack
 
 /**
  * Event that is fired when a bait is consumed.
  * @param rod The ItemStack of the rod that consumed the bait.
  */
-class BaitConsumedEvent(val rod: ItemStack) : Cancelable()
+class BaitConsumedEvent(val rod: ItemStack) : Cancelable() {
+    val context = mutableMapOf(
+        "rod" to rod.asMoLangValue(server()!!.registryAccess())
+    )
+
+    val functions = moLangFunctionMap(
+        cancelFunc
+    )
+}

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

@@ -8,8 +8,12 @@
 
 package com.cobblemon.mod.common.api.events.fishing
 
+import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.events.Cancelable
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.api.reactive.CancelableObservable
+import com.cobblemon.mod.common.util.server
 import net.minecraft.world.item.ItemStack
 
 /**
@@ -17,4 +21,12 @@ import net.minecraft.world.item.ItemStack
  * @param rod The ItemStack of the rod that the bait is set on.
  * @param bait The ItemStack of the bait that is set on the rod.
  */
-class BaitSetEvent(val rod: ItemStack, val bait: ItemStack) : Cancelable()
+class BaitSetEvent(val rod: ItemStack, val bait: ItemStack) : Cancelable() {
+    val context = mutableMapOf(
+        "rod" to rod.asMoLangValue(server()!!.registryAccess()),
+        "bait" to bait.asMoLangValue(server()!!.registryAccess())
+    )
+    val functions = moLangFunctionMap(
+        cancelFunc
+    )
+}

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

@@ -9,14 +9,18 @@
 package com.cobblemon.mod.common.api.events.fishing
 
 import com.bedrockk.molang.runtime.value.MoValue
+import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.events.Cancelable
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.api.molang.ObjectValue
 import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.detail.SpawnAction
 import com.cobblemon.mod.common.entity.fishing.PokeRodFishingBobberEntity
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.itemRegistry
+import com.cobblemon.mod.common.util.server
 import net.minecraft.core.registries.Registries
 import net.minecraft.world.item.ItemStack
 
@@ -35,7 +39,14 @@ interface BobberSpawnPokemonEvent {
         val bobber: PokeRodFishingBobberEntity,
         val spawnAction: SpawnAction<*>,
         val rod: ItemStack
-    ) : Cancelable(), BobberSpawnPokemonEvent
+    ) : Cancelable(), BobberSpawnPokemonEvent {
+        val context = mutableMapOf<String, MoValue>(
+            "rod" to rod.asMoLangValue(server()!!.registryAccess())
+        )
+        val functions = moLangFunctionMap(
+            cancelFunc
+        )
+    }
 
     /**
      * Event that is fired when a Pokemon is modified before it is spawned by a bobber.

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

@@ -8,8 +8,12 @@
 
 package com.cobblemon.mod.common.api.events.fishing
 
+import com.bedrockk.molang.runtime.value.MoValue
 import com.cobblemon.mod.common.api.events.Cancelable
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.entity.fishing.PokeRodFishingBobberEntity
+import com.cobblemon.mod.common.util.server
 import net.minecraft.world.item.ItemStack
 
 /**
@@ -28,7 +32,15 @@ interface PokerodCastEvent {
         override var rod: ItemStack,
         var bobber: PokeRodFishingBobberEntity,
         var bait: ItemStack
-    ) : PokerodCastEvent, Cancelable()
+    ) : PokerodCastEvent, Cancelable() {
+        val context = mutableMapOf<String, MoValue>(
+            "rod" to rod.asMoLangValue(server()!!.registryAccess()),
+            "bait" to bait.asMoLangValue(server()!!.registryAccess())
+        )
+        val functions = moLangFunctionMap(
+            cancelFunc
+        )
+    }
 
     /**
      * Event that is fired after a fishing rod is cast.
@@ -40,5 +52,10 @@ interface PokerodCastEvent {
         override var rod: ItemStack,
         var bobber: PokeRodFishingBobberEntity,
         var bait: ItemStack
-    ) : PokerodCastEvent
+    ) : PokerodCastEvent {
+        val context = mutableMapOf<String, MoValue>(
+            "rod" to rod.asMoLangValue(server()!!.registryAccess()),
+            "bait" to bait.asMoLangValue(server()!!.registryAccess())
+        )
+    }
 }

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

@@ -9,6 +9,9 @@
 package com.cobblemon.mod.common.api.events.fishing
 
 import com.cobblemon.mod.common.api.events.Cancelable
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
+import com.cobblemon.mod.common.util.server
 import net.minecraft.world.entity.player.Player
 import net.minecraft.world.item.ItemStack
 
@@ -16,4 +19,13 @@ import net.minecraft.world.item.ItemStack
  * Event that is fired when a fishing rod is reeled.
  * @param rod The ItemStack of the rod that is being reeled.
  */
-class PokerodReelEvent(val player: Player, val rod: ItemStack) : Cancelable()
+class PokerodReelEvent(val player: Player, val rod: ItemStack) : Cancelable() {
+    val context = mutableMapOf(
+        "player" to player.asMoLangValue(),
+        "rod" to rod.asMoLangValue(server()!!.registryAccess())
+    )
+
+    val functions = moLangFunctionMap(
+        cancelFunc
+    )
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/events/pokeball/PokemonCatchRateEvent.kt

@@ -8,6 +8,9 @@
 
 package com.cobblemon.mod.common.api.events.pokeball
 
+import com.bedrockk.molang.runtime.value.DoubleValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.entity.pokeball.EmptyPokeBallEntity
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import net.minecraft.world.entity.LivingEntity
@@ -27,4 +30,17 @@ class PokemonCatchRateEvent(
     val pokeBallEntity: EmptyPokeBallEntity,
     val pokemonEntity: PokemonEntity,
     var catchRate: Float
-)
+) {
+    val context = mutableMapOf(
+        "thrower" to thrower.asMostSpecificMoLangValue(),
+        "poke_ball_entity" to pokeBallEntity.struct,
+        "pokemon_entity" to pokemonEntity.struct,
+        "catch_rate" to DoubleValue(catchRate.toDouble())
+    )
+    val functions = moLangFunctionMap(
+        "set_catch_rate" to {
+            catchRate = it.getDouble(0).toFloat()
+            DoubleValue.ONE
+        }
+    )
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/events/pokeball/ThrownPokeballHitEvent.kt

@@ -10,6 +10,7 @@ package com.cobblemon.mod.common.api.events.pokeball
 
 import com.cobblemon.mod.common.api.events.Cancelable
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.entity.pokeball.EmptyPokeBallEntity
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 
@@ -20,8 +21,9 @@ class ThrownPokeballHitEvent(
     val pokeBall : EmptyPokeBallEntity,
     val pokemon : PokemonEntity
 ) : Cancelable() {
-    val context = mutableMapOf(
-        "pokeball" to pokeBall.struct,
-        "pokemon" to pokemon.asMoLangValue()
+    val functions = moLangFunctionMap(
+        "pokeball" to { pokeBall.struct },
+        "pokemon" to { pokemon.asMoLangValue() },
+        cancelFunc
     )
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/events/pokedex/scanning/PokemonScannedEvent.kt

@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.api.events.pokedex.scanning
 
 import com.bedrockk.molang.runtime.value.DoubleValue
+import com.bedrockk.molang.runtime.value.MoValue
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
@@ -21,15 +22,14 @@ data class PokemonScannedEvent(val player: ServerPlayer, val scannedPokemonEntit
     val isOwned: Boolean
         get() = scannedPokemonEntityData.pokemon.getOwnerUUID() == player.uuid
 
-    val context = mutableMapOf(
+    val context: MutableMap<String, MoValue> = mutableMapOf(
         "player" to player.asMoLangValue(),
         "pokemon" to scannedPokemonEntityData.pokemon.struct,
         "disguise" to (scannedPokemonEntityData.disguise?.struct ?: DoubleValue.ZERO),
-        "entity" to {
-            when (scannedEntity) {
-                is LivingEntity -> scannedEntity.asMostSpecificMoLangValue()
-                else -> DoubleValue.ZERO
-            }
+        "entity" to when (scannedEntity) {
+            is LivingEntity -> scannedEntity.asMostSpecificMoLangValue()
+            else -> DoubleValue.ZERO
         },
+        "is_owned" to DoubleValue(if (isOwned) 1.0 else 0.0)
     )
 }

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

@@ -8,9 +8,13 @@
 
 package com.cobblemon.mod.common.api.events.pokemon
 
+import com.bedrockk.molang.runtime.value.DoubleValue
 import com.cobblemon.mod.common.api.events.Cancelable
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.api.pokemon.PokemonProperties
 import com.cobblemon.mod.common.pokemon.Pokemon
+import com.cobblemon.mod.common.util.getPlayer
 import net.minecraft.server.level.ServerPlayer
 
 class CollectEggEvent (
@@ -18,4 +22,13 @@ class CollectEggEvent (
     val maleParent : Pokemon,
     val femaleParent : Pokemon,
     val player : ServerPlayer
-) : Cancelable()
+) : Cancelable() {
+    val context = mutableMapOf(
+        "male_parent" to maleParent.struct,
+        "female_parent" to femaleParent.struct,
+        "player" to (player.uuid.getPlayer()?.asMoLangValue() ?: DoubleValue.ZERO)
+    )
+    val functions = moLangFunctionMap(
+        cancelFunc
+    )
+}

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

@@ -14,9 +14,7 @@ import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.events.Cancelable
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
-import com.cobblemon.mod.common.api.pokemon.stats.EvSource
-import com.cobblemon.mod.common.api.pokemon.stats.ItemEvSource
-import com.cobblemon.mod.common.api.pokemon.stats.Stat
+import com.cobblemon.mod.common.api.pokemon.stats.*
 import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.util.getPlayer
 import com.cobblemon.mod.common.util.ifIsType
@@ -56,7 +54,15 @@ interface EvGainedEvent {
         val context = mutableMapOf(
             "pokemon" to source.pokemon.struct,
             "stat" to StringValue(stat.identifier.toString()),
-            "amount" to DoubleValue(amount.toDouble())
+            "amount" to DoubleValue(amount.toDouble()),
+            "source" to StringValue(
+                when (source) {
+                    is BattleEvSource -> "battle"
+                    is ItemEvSource -> "interaction"
+                    is SidemodEvSource -> source.sidemodId
+                    else -> "unknown"
+                }
+            )
         )
         val functions = moLangFunctionMap(
             cancelFunc,
@@ -78,7 +84,15 @@ interface EvGainedEvent {
         val context = mutableMapOf(
             "pokemon" to source.pokemon.struct,
             "stat" to StringValue(stat.identifier.toString()),
-            "amount" to DoubleValue(amount.toDouble())
+            "amount" to DoubleValue(amount.toDouble()),
+            "source" to StringValue(
+                when (source) {
+                    is BattleEvSource -> "battle"
+                    is ItemEvSource -> "interaction"
+                    is SidemodEvSource -> source.sidemodId
+                    else -> "unknown"
+                }
+            )
         )
     }
 

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

@@ -8,9 +8,12 @@
 
 package com.cobblemon.mod.common.api.events.pokemon
 
+import com.bedrockk.molang.runtime.value.DoubleValue
+import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.events.Cancelable
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.api.moves.MoveTemplate
-import com.cobblemon.mod.common.api.pokemon.experience.ExperienceSource
+import com.cobblemon.mod.common.api.pokemon.experience.*
 import com.cobblemon.mod.common.pokemon.Pokemon
 
 /**
@@ -24,7 +27,28 @@ class ExperienceGainedPreEvent(
     val pokemon: Pokemon,
     val source: ExperienceSource,
     var experience: Int
-) : Cancelable()
+) : Cancelable() {
+    val context = mutableMapOf(
+        "pokemon" to pokemon.struct,
+        "source" to StringValue(
+            when (source) {
+                is BattleExperienceSource -> "battle"
+                is CandyExperienceSource -> "interaction"
+                is CommandExperienceSource -> "command"
+                is SidemodExperienceSource -> source.sidemodId
+                else -> "unknown"
+            }
+        ),
+        "experience" to DoubleValue(experience.toDouble())
+    )
+    val functions = moLangFunctionMap(
+        cancelFunc,
+        "set_amount" to {
+            experience = it.getInt(0)
+            DoubleValue.ONE
+        }
+    )
+}
 
 /**
  * Event fired when experience has been gained. Information about whether it leveled up or not is
@@ -40,4 +64,20 @@ class ExperienceGainedPostEvent(
     val previousLevel: Int,
     val currentLevel: Int,
     val learnedMoves: MutableSet<MoveTemplate>
-)
+) {
+    val context = mutableMapOf(
+        "pokemon" to pokemon.struct,
+        "source" to StringValue(
+            when (source) {
+                is BattleExperienceSource -> "battle"
+                is CandyExperienceSource -> "interaction"
+                is CommandExperienceSource -> "command"
+                is SidemodExperienceSource -> source.sidemodId
+                else -> "unknown"
+            }
+        ),
+        "experience" to DoubleValue(experience.toDouble()),
+        "previous_level" to DoubleValue(previousLevel.toDouble()),
+        "current_level" to DoubleValue(currentLevel.toDouble())
+    )
+}

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

@@ -8,7 +8,9 @@
 
 package com.cobblemon.mod.common.api.events.pokemon
 
+import com.bedrockk.molang.runtime.value.DoubleValue
 import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.pokemon.Pokemon
 
 /**
@@ -25,4 +27,16 @@ data class FriendshipUpdatedEvent(
         set(value) {
             field = value.coerceIn(0, Cobblemon.config.maxPokemonFriendship)
         }
+
+    val context = mutableMapOf(
+        "pokemon" to pokemon.struct,
+        "new_friendship" to DoubleValue(newFriendship.toDouble())
+    )
+
+    val functions = moLangFunctionMap(
+        "set_new_friendship" to {
+            newFriendship = it.getInt(0)
+            DoubleValue.ONE
+        }
+    )
 }

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

@@ -10,6 +10,8 @@ package com.cobblemon.mod.common.api.events.pokemon
 
 import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.pokemon.Pokemon
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
+import com.bedrockk.molang.runtime.value.DoubleValue
 
 /**
  * Event that is fired when a player owned Pokémon has its fullness changed
@@ -22,4 +24,16 @@ data class FullnessUpdatedEvent(
         set(value) {
             field = value.coerceIn(0, pokemon.getMaxFullness())
         }
+
+    val context = mutableMapOf(
+        "pokemon" to pokemon.struct,
+        "new_fullness" to DoubleValue(newFullness.toDouble())
+    )
+
+    val functions = moLangFunctionMap(
+        "set_new_fullness" to {
+            newFullness = it.getInt(0)
+            DoubleValue.ONE
+        }
+    )
 }

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

@@ -8,15 +8,30 @@
 
 package com.cobblemon.mod.common.api.events.pokemon
 
+import com.bedrockk.molang.runtime.value.DoubleValue
 import com.cobblemon.mod.common.api.events.Cancelable
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.api.pokemon.PokemonProperties
+import com.cobblemon.mod.common.util.getPlayer
 import net.minecraft.server.level.ServerPlayer
 
 interface HatchEggEvent {
     val egg: PokemonProperties
     val player: ServerPlayer
 
-    data class Pre(override var egg : PokemonProperties, override var player: ServerPlayer) : HatchEggEvent, Cancelable()
+    data class Pre(override var egg : PokemonProperties, override var player: ServerPlayer) : HatchEggEvent, Cancelable() {
+        val context = mutableMapOf(
+            "player" to (player.uuid.getPlayer()?.asMoLangValue() ?: DoubleValue.ZERO)
+        )
+        val functions = moLangFunctionMap(
+            cancelFunc
+        )
+    }
 
-    data class Post(override var egg : PokemonProperties, override var player: ServerPlayer) : HatchEggEvent
+    data class Post(override var egg : PokemonProperties, override var player: ServerPlayer) : HatchEggEvent {
+        val context = mutableMapOf(
+            "player" to (player.uuid.getPlayer()?.asMoLangValue() ?: DoubleValue.ZERO)
+        )
+    }
 }

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

@@ -50,7 +50,7 @@ interface HeldItemEvent {
                 "pokemon" to pokemon.struct,
                 "receiving" to receiving.asMoLangValue(server()!!.registryAccess()),
                 "returning" to returning.asMoLangValue(server()!!.registryAccess()),
-                "decrement" to DoubleValue(if (decrement) 1.0 else 0.0),
+                "decrement" to DoubleValue(if (decrement) 1.0 else 0.0)
             )
         }
         val functions = moLangFunctionMap(
@@ -74,7 +74,7 @@ interface HeldItemEvent {
                 "pokemon" to pokemon.struct,
                 "received" to received.asMoLangValue(server()!!.registryAccess()),
                 "returned" to returned.asMoLangValue(server()!!.registryAccess()),
-                "decremented" to DoubleValue(if (decremented) 1.0 else 0.0),
+                "decremented" to DoubleValue(if (decremented) 1.0 else 0.0)
             )
         }
     }

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

@@ -8,10 +8,18 @@
 
 package com.cobblemon.mod.common.api.events.pokemon
 
+import com.bedrockk.molang.runtime.value.DoubleValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.pokemon.Pokemon
+import com.cobblemon.mod.common.util.getPlayer
 import java.util.*
 
 data class PokemonAspectsChangedEvent(
     val ownerId: UUID?,
     val pokemon: Pokemon,
-)
+) {
+    val context = mutableMapOf(
+        "player" to (ownerId?.getPlayer()?.asMoLangValue() ?: DoubleValue.ZERO),
+        "pokemon" to pokemon.struct
+    )
+}

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

@@ -8,10 +8,23 @@
 
 package com.cobblemon.mod.common.api.events.pokemon
 
+import com.bedrockk.molang.runtime.value.MoValue
+import com.cobblemon.mod.common.api.events.Cancelable
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.pokemon.Pokemon
+import com.cobblemon.mod.common.util.getPlayer
 import java.util.UUID
 
 data class PokemonSeenEvent(
     val playerId: UUID,
     val pokemon: Pokemon
-)
+) : Cancelable() {
+    val context = mapOf<String, MoValue>(
+        "player" to playerId.getPlayer()!!.asMoLangValue(),
+        "pokemon" to pokemon.struct
+    )
+    val functions = moLangFunctionMap(
+        cancelFunc
+    )
+}

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

@@ -8,7 +8,9 @@
 
 package com.cobblemon.mod.common.api.events.pokemon
 
+import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.events.Cancelable
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.pokemon.Pokemon
 import net.minecraft.server.level.ServerLevel
@@ -25,7 +27,15 @@ data class PokemonSentPreEvent(
     val pokemon: Pokemon,
     val level: ServerLevel,
     val position: Vec3
-) : Cancelable()
+) : Cancelable() {
+    val context = mutableMapOf(
+        "pokemon" to pokemon.struct,
+        "position" to StringValue(position.toString())
+    )
+    val functions = moLangFunctionMap(
+        cancelFunc
+    )
+}
 
 /**
  * Event fired after a [PokemonEntity] is spawned from a player's party and after its animations are finished.
@@ -37,4 +47,9 @@ data class PokemonSentPreEvent(
 data class PokemonSentPostEvent(
     val pokemon: Pokemon,
     val pokemonEntity: PokemonEntity
-)
+) {
+    val context = mutableMapOf(
+        "pokemon" to pokemon.struct,
+        "pokemon_entity" to pokemonEntity.struct
+    )
+}

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

@@ -8,7 +8,10 @@
 
 package com.cobblemon.mod.common.api.events.pokemon
 
+import com.bedrockk.molang.runtime.value.DoubleValue
 import com.cobblemon.mod.common.api.events.Cancelable
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.pokemon.Pokemon
 import net.minecraft.server.level.ServerPlayer
 
@@ -22,4 +25,13 @@ data class ShoulderMountEvent(
     val player: ServerPlayer,
     val pokemon: Pokemon,
     val isLeft: Boolean
-) : Cancelable()
+) : Cancelable() {
+    val context = mutableMapOf(
+        "player" to (player.asMoLangValue() ?: DoubleValue.ZERO),
+        "pokemon" to pokemon.struct,
+        "is_left" to DoubleValue(if (isLeft) 1.0 else 0.0),
+    )
+    val functions = moLangFunctionMap(
+        cancelFunc
+    )
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/events/pokemon/healing/PokemonHealedEvent.kt

@@ -8,9 +8,12 @@
 
 package com.cobblemon.mod.common.api.events.pokemon.healing
 
+import com.bedrockk.molang.runtime.value.DoubleValue
+import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.events.Cancelable
 import com.cobblemon.mod.common.api.events.CobblemonEvents
 import com.cobblemon.mod.common.api.item.HealingSource
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.moLangFunctionMap
 import com.cobblemon.mod.common.item.berry.HealingBerryItem
 import com.cobblemon.mod.common.item.interactive.PotionItem
 import com.cobblemon.mod.common.item.interactive.PotionType
@@ -31,4 +34,14 @@ class PokemonHealedEvent(
 ) : Cancelable() {
     fun isFullHeal() = amount == -1
     fun isHealed() = amount > 0
+
+    val context = mutableMapOf(
+        "pokemon" to pokemon.struct,
+        "amount" to DoubleValue(amount),
+        "source" to StringValue(source.toString())
+    )
+
+    val functions = moLangFunctionMap(
+        cancelFunc
+    )
 }

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

@@ -8,7 +8,10 @@
 
 package com.cobblemon.mod.common.api.events.storage
 
+import com.bedrockk.molang.runtime.value.DoubleValue
+import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.events.Cancelable
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.api.storage.pc.PCBox
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerPlayer
@@ -42,11 +45,26 @@ interface ChangePCBoxWallpaperEvent {
         override val player: ServerPlayer,
         override val box: PCBox,
         override var wallpaper: ResourceLocation
-    ) : ChangePCBoxWallpaperEvent, Cancelable()
+    ) : ChangePCBoxWallpaperEvent, Cancelable() {
+        val context = mutableMapOf(
+            "player" to player.asMoLangValue(),
+            "box" to StringValue(box.toString()),
+            "wallpaper" to StringValue(wallpaper.toString())
+        )
+        val functions = mapOf(
+            cancelFunc
+        )
+    }
 
     class Post(
         override val player: ServerPlayer,
         override val box: PCBox,
         override val wallpaper: ResourceLocation
-    ) : ChangePCBoxWallpaperEvent
+    ) : ChangePCBoxWallpaperEvent {
+        val context = mutableMapOf(
+            "player" to player.asMoLangValue(),
+            "box" to StringValue(box.toString()),
+            "wallpaper" to StringValue(wallpaper.toString())
+        )
+    }
 }

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

@@ -12,6 +12,7 @@ import com.bedrockk.molang.runtime.MoLangEnvironment
 import com.bedrockk.molang.runtime.MoLangRuntime
 import com.bedrockk.molang.runtime.MoParams
 import com.bedrockk.molang.runtime.struct.ArrayStruct
+import com.bedrockk.molang.runtime.struct.MoStruct
 import com.bedrockk.molang.runtime.struct.QueryStruct
 import com.bedrockk.molang.runtime.struct.VariableStruct
 import com.bedrockk.molang.runtime.value.DoubleValue
@@ -23,15 +24,22 @@ import com.cobblemon.mod.common.CobblemonBlockEntities
 import com.cobblemon.mod.common.CobblemonMemories
 import com.cobblemon.mod.common.CobblemonUnlockableWallpapers
 import com.cobblemon.mod.common.Environment
+import com.cobblemon.mod.common.api.ai.CobblemonBlockPosTracker
+import com.cobblemon.mod.common.api.ai.CobblemonWanderControl
+import com.cobblemon.mod.common.api.battles.interpreter.BattleMessage
 import com.cobblemon.mod.common.api.battles.model.PokemonBattle
 import com.cobblemon.mod.common.api.battles.model.actor.ActorType
 import com.cobblemon.mod.common.api.battles.model.actor.BattleActor
 import com.cobblemon.mod.common.api.dialogue.PlayerDialogueFaceProvider
 import com.cobblemon.mod.common.api.dialogue.ReferenceDialogueFaceProvider
+import com.cobblemon.mod.common.api.drop.DropEntry
 import com.cobblemon.mod.common.api.mark.Marks
+import com.cobblemon.mod.common.api.moves.BenchedMove
+import com.cobblemon.mod.common.api.moves.Moves
 import com.cobblemon.mod.common.api.moves.animations.ActionEffectContext
 import com.cobblemon.mod.common.api.moves.animations.ActionEffects
 import com.cobblemon.mod.common.api.moves.animations.NPCProvider
+import com.cobblemon.mod.common.api.moves.animations.TargetsProvider
 import com.cobblemon.mod.common.api.npc.NPCClasses
 import com.cobblemon.mod.common.api.npc.configuration.interaction.DialogueNPCInteractionConfiguration
 import com.cobblemon.mod.common.api.npc.configuration.interaction.ScriptNPCInteractionConfiguration
@@ -45,11 +53,14 @@ import com.cobblemon.mod.common.api.pokedex.SeenCount
 import com.cobblemon.mod.common.api.pokedex.SeenPercent
 import com.cobblemon.mod.common.api.pokemon.PokemonProperties
 import com.cobblemon.mod.common.api.pokemon.evolution.Evolution
+import com.cobblemon.mod.common.api.pokemon.experience.SidemodExperienceSource
+import com.cobblemon.mod.common.api.pokemon.moves.LearnsetQuery
 import com.cobblemon.mod.common.api.pokemon.stats.Stats
 import com.cobblemon.mod.common.api.scheduling.ClientTaskTracker
 import com.cobblemon.mod.common.api.scheduling.Schedulable
 import com.cobblemon.mod.common.api.scheduling.ServerTaskTracker
 import com.cobblemon.mod.common.api.scripting.CobblemonScripts
+import com.cobblemon.mod.common.api.spawning.TimeRange
 import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
 import com.cobblemon.mod.common.api.storage.PokemonStore
 import com.cobblemon.mod.common.api.storage.party.NPCPartyStore
@@ -59,10 +70,13 @@ import com.cobblemon.mod.common.api.storage.pc.PCPosition
 import com.cobblemon.mod.common.api.storage.pc.PCStore
 import com.cobblemon.mod.common.api.tags.CobblemonItemTags
 import com.cobblemon.mod.common.api.text.text
+import com.cobblemon.mod.common.battles.BattleBuilder
+import com.cobblemon.mod.common.battles.BattleFormat
 import com.cobblemon.mod.common.battles.BattleRegistry
 import com.cobblemon.mod.common.battles.actor.PlayerBattleActor
 import com.cobblemon.mod.common.battles.actor.PokemonBattleActor
 import com.cobblemon.mod.common.client.render.models.blockbench.wavefunction.WaveFunctions
+import com.cobblemon.mod.common.entity.MoLangScriptingEntity
 import com.cobblemon.mod.common.entity.PosableEntity
 import com.cobblemon.mod.common.entity.npc.NPCBattleActor
 import com.cobblemon.mod.common.entity.npc.NPCEntity
@@ -91,6 +105,7 @@ import net.minecraft.core.BlockPos
 import net.minecraft.core.Holder
 import net.minecraft.core.Registry
 import net.minecraft.core.RegistryAccess
+import net.minecraft.core.Vec3i
 import net.minecraft.core.registries.BuiltInRegistries
 import net.minecraft.core.registries.Registries
 import net.minecraft.nbt.CompoundTag
@@ -143,6 +158,17 @@ object MoLangFunctions {
             val message = params.get<MoValue>(0).asString()
             Cobblemon.LOGGER.info(message)
         },
+        "delete_variable" to java.util.function.Function { params ->
+            val struct = params.get<VariableStruct>(0)
+            val variable = params.getString(1)
+            struct.map.remove(variable)
+            DoubleValue.ONE
+        },
+        "delete_variables" to java.util.function.Function { params ->
+            val struct = params.get<VariableStruct>(0)
+            struct.map.clear()
+            DoubleValue.ONE
+        },
         "set_query" to java.util.function.Function { params ->
             val variable = params.getString(0)
             val value = params.get<MoValue>(1)
@@ -155,6 +181,20 @@ object MoLangFunctions {
             val replace = params.getString(2)
             return@Function StringValue(text.replace(search, replace))
         },
+        "is_included" to java.util.function.Function { params ->
+            val text = params.getString(0)
+            val search = params.getString(1)
+            return@Function DoubleValue(text.contains(search))
+        },
+        "to_lower" to java.util.function.Function { params ->
+            return@Function StringValue(params.getString(0).lowercase())
+        },
+        "to_upper" to java.util.function.Function { params ->
+            return@Function StringValue(params.getString(0).uppercase())
+        },
+        "string_length" to java.util.function.Function { params ->
+            return@Function DoubleValue(params.getString(0).length)
+        },
         "is_blank" to java.util.function.Function { params ->
             val arg = params.get<MoValue>(0)
             return@Function DoubleValue((arg is StringValue && (arg.value.isBlank() || arg.value.toDoubleOrNull() == 0.0)) || (arg is DoubleValue && arg.value == 0.0))
@@ -192,6 +232,48 @@ object MoLangFunctions {
             values.forEachIndexed { index, moValue -> array.setDirectly("$index", moValue) }
             return@Function array
         },
+        "length" to java.util.function.Function { params ->
+            val array = params.get<ArrayStruct>(0)
+            return@Function DoubleValue(array.map.size.toDouble())
+        },
+        "append" to java.util.function.Function { params ->
+            val array = params.get<ArrayStruct>(0)
+            val value = params.get<MoValue>(1)
+            val nextIndex = array.map.size
+            array.setDirectly("$nextIndex", value)
+            return@Function array
+        },
+        "insert" to java.util.function.Function { params ->
+            val array = params.get<ArrayStruct>(0)
+            val index = params.getInt(1)
+            val value = params.get<MoValue>(2)
+            val size = array.map.size
+
+            // Shift elements at and after index up by 1
+            for (i in (size - 1) downTo index) {
+                val current = array.map[i.toString()]
+                if (current != null) {
+                    array.map[(i + 1).toString()] = current
+                }
+            }
+            array.map[index.toString()] = value
+            return@Function array
+        },
+        "delete" to java.util.function.Function { params ->
+            val array = params.get<ArrayStruct>(0)
+            val index = params.getInt(1)
+            if (index in 0 until array.map.size) {
+                array.map.remove(index.toString())
+                // Re-index the array to keep keys sequential in numerical order
+                val newMap = hashMapOf<String, MoValue>()
+                array.map.keys.mapNotNull { it.toIntOrNull() }
+                    .sorted()
+                    .forEachIndexed { i, k -> newMap[i.toString()] = array.map[k.toString()]!! }
+                array.map.clear()
+                array.map.putAll(newMap)
+            }
+            return@Function array
+        },
         "run_script" to java.util.function.Function { params ->
             val runtime = MoLangRuntime()
             runtime.environment.query = params.environment.query
@@ -250,6 +332,12 @@ object MoLangFunctions {
         { worldHolder ->
             val world = worldHolder.value()
             val map = hashMapOf<String, java.util.function.Function<MoParams, Any>>()
+            map.put("is_time_of_day") { params ->
+                val timeOfDay = TimeRange.timeRanges[params.getString(0).lowercase()]
+                    ?: return@put DoubleValue.ZERO
+                val time = world.dayTime % 24000
+                return@put DoubleValue(timeOfDay.contains(time.toInt()))
+            }
             map.put("game_time") { _ -> DoubleValue(world.gameTime.toDouble()) }
             map.put("time_of_day") {
                 val time = world.dayTime % 24000
@@ -418,6 +506,14 @@ object MoLangFunctions {
             map.put("uuid") { _ -> StringValue(player.gameProfile.id.toString()) }
             map.put("main_held_item") { _ -> player.mainHandItem.asMoLangValue(player.registryAccess()) }
             map.put("off_held_item") { _ -> player.offhandItem.asMoLangValue(player.registryAccess()) }
+            map.put("inventory") { _ ->
+                val inventory = player.inventory
+                val items = ArrayStruct(hashMapOf())
+                for (i in 0 until inventory.containerSize) {
+                    items.setDirectly("$i", inventory.getItem(i).asMoLangValue(player.registryAccess()))
+                }
+                return@put items
+            }
             map.put("face") { params -> ObjectValue(PlayerDialogueFaceProvider(player.uuid, params.getBooleanOrNull(0) != false)) }
             map.put("swing_hand") { _ -> player.swing(player.usedItemHand) }
             map.put("food_level") { _ -> DoubleValue(player.foodData.foodLevel) }
@@ -529,6 +625,50 @@ object MoLangFunctions {
                     }
                     return@put DoubleValue.ZERO
                 }
+                map.put("start_battle") { params ->
+                    val opponentValue = params.get<MoValue>(0)
+                    val opponent = if (opponentValue is ObjectValue<*>) {
+                        opponentValue.obj as ServerPlayer
+                    } else {
+                        val paramString = opponentValue.asString()
+                        val playerUUID = paramString.asUUID
+                        if (playerUUID != null) {
+                            server()?.playerList?.getPlayer(playerUUID) ?: return@put DoubleValue.ZERO
+                        } else {
+                            server()?.playerList?.getPlayerByName(paramString) ?: return@put DoubleValue.ZERO
+                        }
+                    }
+                    val format = params.getStringOrNull(1)
+                        ?.let(BattleFormat::fromFormatIdentifier)
+                        ?: BattleFormat.GEN_9_SINGLES
+
+                    val setLevel = params.getIntOrNull(2) ?: -1
+                    format.adjustLevel = setLevel
+
+                    val rules = params.getStringOrNull(5)
+                        ?.split(",")
+                        ?.toSet()
+                        ?: emptySet()
+
+                    val modifiedBattleFormat = BattleFormat.setBattleRules(
+                        battleFormat = format,
+                        rules = rules
+                    )
+
+                    val cloneParties = (setLevel != -1) || (params.getBooleanOrNull(3) ?: false)
+                    val healFirst = params.getBooleanOrNull(4) ?: false
+
+                    val battleStartResult = BattleBuilder.pvp1v1(
+                        player1 = player,
+                        player2 = opponent,
+                        battleFormat = modifiedBattleFormat,
+                        cloneParties = cloneParties,
+                        healFirst = healFirst
+                    )
+                    var returnValue: MoValue = DoubleValue.ZERO
+                    battleStartResult.ifSuccessful { returnValue = it.struct }
+                    return@put returnValue
+                }
             }
             map
         }
@@ -580,6 +720,37 @@ object MoLangFunctions {
                 val owner = entity.owner
                 return@put owner?.asMostSpecificMoLangValue() ?: DoubleValue.ZERO
             }
+            map.put("delta_movement") {
+                return@put listOf(entity.deltaMovement.x, entity.deltaMovement.y, entity.deltaMovement.z).asArrayValue(::DoubleValue)
+            }
+
+            if (entity is MoLangScriptingEntity) {
+                map.put("add_callback") { params ->
+                    val type = params.getString(0).asIdentifierDefaultingNamespace()
+                    val callback = params.getString(1).asIdentifierDefaultingNamespace()
+                    val allowDuplicates = params.getBooleanOrNull(2) ?: false
+                    entity.callbacks.addCallback(type, callback, allowDuplicates)
+                }
+                map.put("remove_callback") { params ->
+                    val type = params.getString(0).asIdentifierDefaultingNamespace()
+                    val callback = params.getString(1).asIdentifierDefaultingNamespace()
+                    entity.callbacks.removeCallback(type, callback)
+                }
+                map.put("has_callback") { params ->
+                    val type = params.getString(0).asIdentifierDefaultingNamespace()
+                    val callback = params.getString(1).asIdentifierDefaultingNamespace()
+                    return@put DoubleValue(callback in (entity.callbacks[type] ?: emptySet()))
+                }
+                map.put("clear_callbacks") { params ->
+                    val type = params.getStringOrNull(0)?.asIdentifierDefaultingNamespace()
+                    if (type != null) {
+                        entity.callbacks[type]?.clear()
+                    } else {
+                        entity.callbacks.clear()
+                    }
+                    return@put DoubleValue.ONE
+                }
+            }
 
             if (entity is PathfinderMob) {
                 map.put("walk_to") { params ->
@@ -696,14 +867,12 @@ object MoLangFunctions {
             }
             map.put("is_standing_on_blocks") { params ->
                 val depth = params.getDouble(0).toInt()
-                val blocks: MutableSet<Block> = mutableSetOf()
+                val blockStrings: MutableSet<String> = mutableSetOf()
                 for (blockIndex in 1..<params.params.size) {
-                    val blockString = params.getString(blockIndex)
-                    val block = BuiltInRegistries.BLOCK.get(blockString.asIdentifierDefaultingNamespace("minecraft"))
-                    blocks.add(block)
+                    blockStrings.add(params.getString(blockIndex))
                 }
 
-                return@put if (entity.isStandingOn(blocks, depth)) DoubleValue.ONE else DoubleValue.ZERO
+                return@put if (entity.isStandingOn(blockStrings, depth)) DoubleValue.ONE else DoubleValue.ZERO
             }
             if (entity is PosableEntity) {
                 map.put("play_animation") { params ->
@@ -729,6 +898,10 @@ object MoLangFunctions {
                         return@put DoubleValue.ONE
                     }
                 }
+
+                map.put("face") { params -> ObjectValue(ReferenceDialogueFaceProvider(entity.id, params.getBooleanOrNull(0) != false))
+
+                }
             }
             if (entity is Schedulable) {
                 map.put("run_molang_after") { params ->
@@ -770,6 +943,80 @@ object MoLangFunctions {
             map.put("is_sleeping") { _ -> DoubleValue(entity.isSleeping) }
             map.put("health") { _ -> DoubleValue(entity.health) }
             map.put("max_health") { _ -> DoubleValue(entity.maxHealth) }
+            map.put("look_at_position") { params ->
+                val x = params.getDouble(0)
+                val y = params.getDouble(1)
+                val z = params.getDouble(2)
+                val duration = params.getIntOrNull(3) ?: 20
+                val flags = params.params.subList(4, params.params.size).map { it.asString() }
+                val brain = entity.brain
+                brain.setMemoryWithExpiry(MemoryModuleType.LOOK_TARGET, CobblemonBlockPosTracker(Vec3(x, y, z), flags.toSet()), duration.toLong())
+            }
+            map.put("get_wander_control_memory") {
+                val value = entity.brain.getMemorySafely(CobblemonMemories.WANDER_CONTROL).orElse(null)
+                    ?: CobblemonWanderControl()
+                if (
+                    !entity.brain.checkMemory(CobblemonMemories.WANDER_CONTROL, MemoryStatus.VALUE_PRESENT)
+                    && entity.brain.checkMemory(CobblemonMemories.WANDER_CONTROL, MemoryStatus.REGISTERED)
+                ) {
+                    entity.brain.setMemory(CobblemonMemories.WANDER_CONTROL, value)
+                }
+                return@put value.struct
+            }
+            map.put("get_position_memory") { params ->
+                val id = params.getString(0).asIdentifierDefaultingNamespace()
+                val memoryType = BuiltInRegistries.MEMORY_MODULE_TYPE.get(id)
+                if (entity.brain.checkMemory(memoryType, MemoryStatus.VALUE_PRESENT)) {
+                    val memory = entity.brain.getMemory(memoryType).get()
+                    return@put when (memory) {
+                        is Vec3i -> VariableStruct(
+                            mapOf(
+                                "x" to DoubleValue(memory.x),
+                                "y" to DoubleValue(memory.y),
+                                "z" to DoubleValue(memory.z)
+                            )
+                        )
+                        is net.minecraft.core.Position -> VariableStruct(
+                            mapOf(
+                                "x" to DoubleValue(memory.x()),
+                                "y" to DoubleValue(memory.y()),
+                                "z" to DoubleValue(memory.z())
+                            )
+                        )
+                        else -> DoubleValue.ZERO
+                    }
+                } else {
+                    return@put DoubleValue.ZERO
+                }
+            }
+            map.put("set_uuid_memory") { params ->
+                val memory = params.getString(0).asIdentifierDefaultingNamespace().let(BuiltInRegistries.MEMORY_MODULE_TYPE::get) as MemoryModuleType<UUID>
+                val uuid = params.getString(1).asUUID ?: return@put DoubleValue.ZERO
+                val expiry = params.getIntOrNull(2) ?: -1
+                if (expiry != -1) {
+                    entity.brain.setMemoryWithExpiry(memory, uuid, expiry.toLong())
+                } else {
+                    entity.brain.setMemory(memory, uuid)
+                }
+                return@put DoubleValue.ONE
+            }
+            map.put("erase_memory") { params ->
+                val memories = params.params.map { it.asString().asIdentifierDefaultingNamespace() }.map(BuiltInRegistries.MEMORY_MODULE_TYPE::get)
+                memories.forEach { entity.brain.eraseMemory(it) }
+                return@put DoubleValue.ONE
+            }
+            map.put("has_memory_value") { params ->
+                val memoryTypes = params.params.map {
+                    it.asString().asIdentifierDefaultingNamespace()
+                }.map(BuiltInRegistries.MEMORY_MODULE_TYPE::get)
+                return@put DoubleValue(memoryTypes.all { entity.brain.checkMemory(it, MemoryStatus.VALUE_PRESENT) })
+            }
+            map.put("lacks_memory_value") { params ->
+                val memoryTypes = params.params.map {
+                    it.asString().asIdentifierDefaultingNamespace()
+                }.map(BuiltInRegistries.MEMORY_MODULE_TYPE::get)
+                return@put DoubleValue(memoryTypes.none { entity.brain.checkMemory(it, MemoryStatus.VALUE_PRESENT) })
+            }
             map.put("can_see") { params ->
                 val target = params.get<MoValue>(0)
                 val range = params.getDoubleOrNull(1) ?: 32.0
@@ -824,7 +1071,6 @@ object MoLangFunctions {
             map.put("name") { StringValue(npc.name.string) }
             map.put("level") { DoubleValue(npc.level) }
             map.put("has_aspect") { params -> DoubleValue(npc.aspects.contains(params.getString(0))) }
-            map.put("face") { params -> ObjectValue(ReferenceDialogueFaceProvider(npc.id, params.getBooleanOrNull(0) != false)) }
             map.put("in_battle") { DoubleValue(npc.isInBattle()) }
             map.put("battles") { ArrayStruct(npc.battleIds.mapNotNull { BattleRegistry.getBattle(it)?.struct }.mapIndexed { index, value -> "$index" to value }.toMap()) }
             map.put("stop_battles") { _ -> npc.battleIds.forEach { BattleRegistry.getBattle(it)?.stop() } }
@@ -1076,6 +1322,23 @@ object MoLangFunctions {
         }
     )
 
+    val battleMessageFunctions = mutableListOf<(BattleMessage) -> HashMap<String, java.util.function.Function<MoParams, Any>>>(
+        { message ->
+            val map = hashMapOf<String, java.util.function.Function<MoParams, Any>>()
+            map.put("has_argument_at") { params ->
+                val index = params.getInt(0)
+                val value = params.getStringOrNull(1) ?: ""
+                return@put DoubleValue(value == message.argumentAt(index))
+            }
+            map.put("has_argument") { params ->
+                val argumentName = params.getString(0)
+                val value = params.getStringOrNull(1) ?: ""
+                return@put DoubleValue(value == message.optionalArgument(argumentName))
+            }
+            return@mutableListOf map
+        }
+    )
+
     val pokemonFunctions = mutableListOf<(Pokemon) -> HashMap<String, java.util.function.Function<MoParams, Any>>>(
         { pokemon ->
             val map = hashMapOf<String, java.util.function.Function<MoParams, Any>>()
@@ -1085,9 +1348,37 @@ object MoLangFunctions {
             map.put("max_hp") { DoubleValue(pokemon.maxHealth.toDouble()) }
             map.put("current_hp") { DoubleValue(pokemon.currentHealth.toDouble()) }
             map.put("friendship") { DoubleValue(pokemon.friendship.toDouble()) }
+            map.put("max_fullness") { DoubleValue(pokemon.getMaxFullness().toDouble()) }
+            map.put("fullness") { DoubleValue(pokemon.currentFullness.toDouble()) }
+            map.put("lose_fullness") { params ->
+                val amount = params.getDouble(0)
+                pokemon.loseFullness(amount.toInt())
+            }
+            map.put("feed_pokemon") { params ->
+                val amount = params.getDouble(0)
+                val playSound = params.getBooleanOrNull(1) ?: true
+                pokemon.feedPokemon(amount.toInt(), playSound)
+            }
             map.put("behaviour") { pokemon.form.behaviour.struct }
             map.put("behavior") { pokemon.form.behaviour.struct } // Inferior
             map.put("pokeball") { StringValue(pokemon.caughtBall.toString()) }
+            map.put("ability") { StringValue(pokemon.ability.name) }
+            map.put("has_learned") { params ->
+                val moveName = params.getString(0)
+                val move = pokemon.allAccessibleMoves.find { it.name == moveName }
+                if(move != null) {
+                    return@put DoubleValue.ONE
+                } else {
+                    return@put DoubleValue.ZERO
+                }
+            }
+            map.put("moveset") {
+                val struct = QueryStruct(hashMapOf())
+                for ((index, move) in pokemon.moveSet.withIndex()) {
+                    struct.addFunction(index.toString()) { move.struct }
+                }
+                struct
+            }
             map.put("evs") {
                 val struct = QueryStruct(hashMapOf())
                 for (stat in Stats.PERMANENT) {
@@ -1102,6 +1393,13 @@ object MoLangFunctions {
                 }
                 struct
             }
+            map.put("hyper_trained_ivs") {
+                val struct = QueryStruct(hashMapOf())
+                for (stat in Stats.PERMANENT) {
+                    struct.addFunction(stat.showdownId) { DoubleValue(pokemon.ivs.hyperTrainedIVs[stat] ?: -1.0) }
+                }
+                struct
+            }
             map.put("natdex_number") {
                 DoubleValue(pokemon.species.nationalPokedexNumber.toDouble())
             }
@@ -1190,6 +1488,17 @@ object MoLangFunctions {
                 }
                 struct
             }
+            map.put("aspects") {
+                val aspects = pokemon.aspects
+                return@put aspects.asArrayValue { StringValue(it) }
+            }
+            map.put("form_aspects") {
+                val aspects = pokemon.form.aspects
+                return@put aspects.asArrayValue { StringValue(it) }
+            }
+            map.put("form_name") {
+                StringValue(pokemon.form.name.toString())
+            }
             // Yes, this is the lazy call for a single hardcoded pre-evolution.
             // Lol. Lmao, even.
             // TO-DO: Subscribe to [PokemonSpecies.observable].
@@ -1214,6 +1523,18 @@ object MoLangFunctions {
             map.put("remove_held_item") { _ ->
                 pokemon.removeHeldItem()
             }
+            map.put("add_aspects") { params ->
+                for (aspect in params.params) pokemon.forcedAspects += aspect.asString()
+                pokemon.updateAspects()
+            }
+            map.put("remove_aspects") { params ->
+                for (aspect in params.params) pokemon.forcedAspects -= aspect.asString()
+                pokemon.updateAspects()
+            }
+            map.put("cosmetic_item") { pokemon.cosmeticItem().asMoLangValue(server()!!.registryAccess()) ?: DoubleValue.ZERO }
+            map.put("remove_cosmetic_item") { _ ->
+                pokemon.removeCosmeticItem()
+            }
             map.put("add_marks") { params ->
                 for (param in params.params) {
                     val identifier = param.asString().asIdentifierDefaultingNamespace()
@@ -1255,6 +1576,92 @@ object MoLangFunctions {
                     return@put DoubleValue.ZERO
                 }
             }
+            map.put("add_exp") { params ->
+                val exp = params.getDouble(0).toInt()
+                pokemon.addExperience(SidemodExperienceSource("molang"), exp)
+                return@put DoubleValue.ONE
+            }
+            map.put("set_iv") { params ->
+                val statId = params.getString(0)
+                val stat = Stats.getStat(statId)
+                val value = params.getIntOrNull(1)?.coerceIn(0, IVs.MAX_VALUE) ?: IVs.MAX_VALUE
+
+                if (Stats.PERMANENT.contains(stat)) {
+                    pokemon.setIV(stat, value)
+                    return@put DoubleValue.ONE
+                } else {
+                    return@put DoubleValue.ZERO
+                }
+            }
+            map.put("set_ev") { params ->
+                val statId = params.getString(0)
+                val stat = Stats.getStat(statId)
+                val value = (params.getIntOrNull(1) ?: 0).coerceIn(0, 255)
+
+                if (Stats.PERMANENT.contains(stat)) {
+                    pokemon.setEV(stat, value)
+                    return@put DoubleValue.ONE
+                } else {
+                    return@put DoubleValue.ZERO
+                }
+            }
+            map.put("initialize_moveset") { params ->
+                val preferLatest = params.getBooleanOrNull(0) ?: true
+                pokemon.initializeMoveset(preferLatest)
+                return@put DoubleValue.ONE
+            }
+            map.put("validate_moveset") { params ->
+                val includeLegacy = params.getBooleanOrNull(0) ?: true
+                pokemon.validateMoveset(includeLegacy)
+                return@put DoubleValue.ONE
+            }
+            map.put("teach_learnable_moves") { params ->
+                val includeLegacy = params.getBooleanOrNull(0) ?: true
+                pokemon.teachLearnableMoves(includeLegacy)
+                return@put DoubleValue.ONE
+            }
+            map.put("teach_move") { params ->
+                val moveName = params.getString(0)
+                val moveTemplate = Moves.getByName(moveName) ?: return@put DoubleValue.ZERO
+                val bypass = params.getBooleanOrNull(1) ?: false
+
+                val canLearn = bypass || LearnsetQuery.ANY.canLearn(moveTemplate, pokemon.form.moves)
+                if (!canLearn) {
+                    return@put DoubleValue.ZERO
+                }
+
+                val alreadyKnows = pokemon.moveSet.getMoves().any { it.template == moveTemplate } ||
+                        pokemon.benchedMoves.any { it.moveTemplate == moveTemplate }
+                if (alreadyKnows) {
+                    return@put DoubleValue.ZERO
+                }
+
+                if (pokemon.moveSet.hasSpace()) {
+                    pokemon.moveSet.add(moveTemplate.create())
+                } else {
+                    pokemon.benchedMoves.add(BenchedMove(moveTemplate, 0))
+                }
+
+                DoubleValue.ONE
+            }
+            map.put("can_learn_move") { params ->
+                val moveName = params.getString(0)
+                val moveTemplate = Moves.getByName(moveName) ?: return@put DoubleValue.ZERO
+                val includeLegacy = params.getBooleanOrNull(1) ?: true
+
+                val canLearn = LearnsetQuery.ANY.canLearn(moveTemplate, pokemon.form.moves)
+                return@put DoubleValue(if (canLearn) 1.0 else 0.0)
+            }
+            map.put("unlearn_move") { params ->
+                val moveName = params.getString(0)
+                val moveTemplate = Moves.getByName(moveName)
+                if (moveTemplate != null) {
+                    pokemon.unlearnMove(moveTemplate)
+                    return@put DoubleValue.ONE
+                } else {
+                    return@put DoubleValue.ZERO
+                }
+            }
             map
         }
     )
@@ -1269,6 +1676,8 @@ object MoLangFunctions {
             map.put("get_alt_pose") { StringValue(pokemonEntity.getAltPose()) }
             map.put("is_gliding") { DoubleValue(pokemonEntity.isUsingAltPose(cobblemonResource("gliding"))) }
             map.put("is_sprinting") { DoubleValue(pokemonEntity.isUsingAltPose(cobblemonResource("sprinting"))) }
+            map.put("is_drifting") { DoubleValue(pokemonEntity.isUsingAltPose(cobblemonResource("drifting"))) }
+            map.put("is_powered_drifting") { DoubleValue(pokemonEntity.isUsingAltPose(cobblemonResource("powered_drifting"))) }
             map.put("in_air") { DoubleValue(pokemonEntity.isUsingAltPose(cobblemonResource("in_air"))) }
             map.put("is_wild") { DoubleValue(pokemonEntity.ownerUUID == null) }
             map.put("is_in_party") { DoubleValue(pokemonEntity.pokemon.storeCoordinates.get()?.store is PartyStore) }
@@ -1286,6 +1695,34 @@ object MoLangFunctions {
             map.put("pasture_conflict_enabled") {
                 DoubleValue(pokemonEntity.getBehaviourFlag(PokemonBehaviourFlag.PASTURE_CONFLICT))
             }
+            map.put("run_action_effect") { params ->
+                val runtime = MoLangRuntime().setup()
+                runtime.environment.cloneFrom(params.environment)
+                runtime.withQueryValue("entity", pokemonEntity.struct)
+                val actionEffect = ActionEffects.actionEffects[params.getString(0).asIdentifierDefaultingNamespace()]
+                if (actionEffect != null) {
+                    val context = ActionEffectContext(
+                        actionEffect = actionEffect,
+                        providers = mutableListOf(TargetsProvider(pokemonEntity)),
+                        runtime = runtime,
+                        level = pokemonEntity.level()
+                    )
+                    // This was taken from NPC run_action_effect but this variable isn't used, so I just commented it out.
+                    // pokemonEntity.actionEffect = context
+                    pokemonEntity.brain.setMemory(CobblemonMemories.ACTIVE_ACTION_EFFECT, context)
+                    pokemonEntity.brain.setActiveActivityIfPossible(CobblemonActivities.ACTION_EFFECT)
+                    actionEffect.run(context).thenRun {
+                        val pokemonActionEffect = pokemonEntity.brain.getMemory(CobblemonMemories.ACTIVE_ACTION_EFFECT).orElse(null)
+                        if (pokemonActionEffect == context && pokemonEntity.brain.isActive(CobblemonActivities.ACTION_EFFECT)) {
+                            pokemonEntity.brain.eraseMemory(CobblemonMemories.ACTIVE_ACTION_EFFECT)
+                            //pokemonEntity.actionEffect = null
+                        }
+                    }
+
+                    return@put DoubleValue.ONE
+                }
+                return@put DoubleValue.ZERO
+            }
             map
         }
     )
@@ -1378,6 +1815,12 @@ object MoLangFunctions {
                 val pokemon = party.get(index) ?: return@put DoubleValue.ZERO
                 return@put pokemon.struct
             }
+            map.put("set_pokemon") { params ->
+                val index = params.getInt(0)
+                val pokemon = params.get<ObjectValue<Pokemon>>(1).obj
+                party.set(index, pokemon)
+                return@put DoubleValue.ONE
+            }
             return@mutableListOf map
         })
 
@@ -1390,6 +1833,13 @@ object MoLangFunctions {
                 val pokemon = pc[PCPosition(box, slot)] ?: return@put DoubleValue.ZERO
                 return@put pokemon.struct
             }
+            map.put("set_pokemon") { params ->
+                val box = params.getInt(0)
+                val slot = params.getInt(1)
+                val pokemon = params.get<ObjectValue<Pokemon>>(2).obj
+                pc.set(PCPosition(box, slot), pokemon)
+                return@put DoubleValue.ONE
+            }
             map.put("resize") { params ->
                 val newSize = params.getInt(0)
                 val lockNewSize = params.getBooleanOrNull(1) == true
@@ -1552,8 +2002,8 @@ object MoLangFunctions {
 
             map.put("identifier") { StringValue(species.resourceIdentifier.toString()) }
             map.put("name") { StringValue(species.name) }
-            map.put("primary_type") { StringValue(species.primaryType.name) }
-            map.put("secondary_type") { StringValue(species.secondaryType?.name ?: "null") }
+            map.put("primary_type") { StringValue(species.primaryType.showdownId) }
+            map.put("secondary_type") { StringValue(species.secondaryType?.showdownId ?: "null") }
             map.put("experience_group") { StringValue(species.experienceGroup.name) }
             map.put("height") { DoubleValue(species.height) }
             map.put("weight") { DoubleValue(species.weight) }
@@ -1568,6 +2018,21 @@ object MoLangFunctions {
         }
     )
 
+    val dropEntryFunctions: MutableList<(DropEntry) -> HashMap<String, java.util.function.Function<MoParams, Any>>> = mutableListOf(
+        { dropEntry ->
+            val map = hashMapOf<String, java.util.function.Function<MoParams, Any>>()
+
+            map.put("percentage") { DoubleValue(dropEntry.percentage.toDouble()) }
+            map.put("quantity") { DoubleValue(dropEntry.quantity.toDouble()) }
+            map.put("max_selectable_times") { DoubleValue(dropEntry.maxSelectableTimes.toDouble()) }
+            map.put("can_drop") { params ->
+                val pokemon = params.getOrNull<ObjectValue<Pokemon>>(0)?.obj
+                DoubleValue(if (dropEntry.canDrop(pokemon)) 1.0 else 0.0)
+            }
+            map
+        }
+    )
+
     val pokemonPropertiesFunctions: MutableList<(PokemonProperties) -> HashMap<String, java.util.function.Function<MoParams, Any>>> = mutableListOf(
         { props ->
             val map = hashMapOf<String, java.util.function.Function<MoParams, Any>>()
@@ -1696,6 +2161,15 @@ object MoLangFunctions {
         return value
     }
 
+    fun DropEntry.asMoLangValue(): ObjectValue<DropEntry> {
+        val value = ObjectValue(
+            obj = this,
+            stringify = { it.toString() }
+        )
+        value.addFunctions(dropEntryFunctions.flatMap { it(this).entries.map { it.key to it.value } }.toMap())
+        return value
+    }
+
     fun PokemonProperties.asMoLangValue(): ObjectValue<PokemonProperties> {
         val value = ObjectValue(
             obj = this,
@@ -1853,6 +2327,14 @@ object MoLangFunctions {
         return this
     }
 
+    fun QueryStruct.addBattleMessageFunctions(battleMessage: BattleMessage): QueryStruct {
+        val addedFunctions = battleMessageFunctions
+            .flatMap { it.invoke(battleMessage).entries }
+            .associate { it.key to it.value }
+        functions.putAll(addedFunctions)
+        return this
+    }
+
     fun QueryStruct.addPokemonEntityFunctions(pokemonEntity: PokemonEntity): QueryStruct {
         val addedFunctions = pokemonEntityFunctions
             .flatMap { it.invoke(pokemonEntity).entries }

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

@@ -103,7 +103,7 @@ open class Move(
                 "name" to Function { StringValue(name) },
                 "display_name" to Function { StringValue(displayName.string) },
                 "description" to Function { StringValue(description.string) },
-                "type" to Function { StringValue(type.name) },
+                "type" to Function { StringValue(type.showdownId) },
                 "damage_category" to Function { StringValue(damageCategory.name) },
                 "power" to Function { DoubleValue(power) },
                 "accuracy" to Function { DoubleValue(accuracy) },

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

@@ -59,7 +59,7 @@ open class MoveTemplate(
     val struct: MoStruct by lazy {
         QueryStruct(hashMapOf())
             .addFunction("name") { StringValue(name) }
-            .addFunction("type") { StringValue(elementalType.name) }
+            .addFunction("type") { StringValue(elementalType.showdownId) }
             .addFunction("damage_category") { StringValue(damageCategory.name) }
             .addFunction("power") { DoubleValue(power) }
             .addFunction("target") { StringValue(target.name) }

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

@@ -21,9 +21,12 @@ import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.google.gson.JsonArray
 import com.google.gson.JsonObject
+import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.server.packs.PackType
 import net.minecraft.server.packs.resources.ResourceManager
+import java.io.File
+import kotlin.collections.set
 
 /**
  * Registry for all known Moves
@@ -36,11 +39,26 @@ object Moves : DataRegistry {
 
     private val allMoves = mutableMapOf<String, MoveTemplate>()
     private val idMapping = mutableMapOf<Int, MoveTemplate>()
+    internal val moveScripts = mutableMapOf<String, String>() // moveId to JavaScript
 
     override fun reload(manager: ResourceManager) {
         this.allMoves.clear()
         this.idMapping.clear()
-        val movesJson = ShowdownService.service.getMoves()
+        this.moveScripts.clear()
+
+        ShowdownService.service.resetRegistryData("move")
+        manager.listResources("moves") { it.path.endsWith(".js") }.forEach { (identifier, resource) ->
+            resource.open().use { stream ->
+                stream.bufferedReader().use { reader ->
+                    val resolvedIdentifier = ResourceLocation.fromNamespaceAndPath(identifier.namespace, File(identifier.path).nameWithoutExtension)
+                    val js = reader.readText()
+                    moveScripts[resolvedIdentifier.path] = js
+                }
+            }
+        }
+        ShowdownService.service.sendRegistryData(moveScripts, "move")
+
+        val movesJson = ShowdownService.service.getRegistryData("move")
         for (i in 0 until movesJson.size()) {
             val jsMove = movesJson[i].asJsonObject
             val id = jsMove.get("id").asString

common/src/main/kotlin/com/cobblemon/mod/common/api/orientation/OrientationController.kt

@@ -10,14 +10,12 @@ package com.cobblemon.mod.common.api.orientation
 
 import com.cobblemon.mod.common.util.math.geometry.toDegrees
 import com.cobblemon.mod.common.util.math.geometry.toRadians
-import net.minecraft.resources.ResourceLocation
 import net.minecraft.util.Mth
 import net.minecraft.world.entity.LivingEntity
 import org.joml.Matrix3f
 import org.joml.Quaternionf
 import org.joml.Vector3f
 import kotlin.math.asin
-import kotlin.math.sign
 
 open class OrientationController(val entity: LivingEntity) {
 

common/src/main/kotlin/com/cobblemon/mod/common/api/permission/CobblemonPermissions.kt

@@ -132,6 +132,8 @@ object CobblemonPermissions {
     @JvmStatic
     val ABANDON_MULTITEAM = this.create("${COMMAND_PREFIX}abandonmultiteam", PermissionLevel.NONE)
     @JvmStatic
+    val RUN_MOLANG = this.create("${COMMAND_PREFIX}runmolang", PermissionLevel.CHEAT_COMMANDS_AND_COMMAND_BLOCKS)
+    @JvmStatic
     val RUN_MOLANG_SCRIPT = this.create("${COMMAND_PREFIX}runmolangscript", PermissionLevel.CHEAT_COMMANDS_AND_COMMAND_BLOCKS)
     @JvmStatic
     val COBBLEMON_CONFIG_RELOAD = this.create("${COMMAND_PREFIX}cobblemonconfig.reload", PermissionLevel.CHEAT_COMMANDS_AND_COMMAND_BLOCKS)
@@ -141,6 +143,8 @@ object CobblemonPermissions {
     val CHANGE_BOX_COUNT = this.create("${COMMAND_PREFIX}boxcount", PermissionLevel.CHEAT_COMMANDS_AND_COMMAND_BLOCKS)
     @JvmStatic
     val SPECTATE_BATTLE = this.create("${COMMAND_PREFIX}spectatebattle", PermissionLevel.ALL_COMMANDS)
+    @JvmStatic
+    val VALIDATE_TEAM = this.create("${COMMAND_PREFIX}validateteam", PermissionLevel.ALL_COMMANDS)
 
     @JvmStatic
     val SEE_HIDDEN_NPCS = this.create("seehiddennpcs", PermissionLevel.CHEAT_COMMANDS_AND_COMMAND_BLOCKS)

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

@@ -17,6 +17,7 @@ import net.minecraft.resources.ResourceLocation
  * As opposed to the [GlobalPokedexValueCalculator] this interface is always called on a specific dex definition (e.g. galar, kanto)
  */
 interface PokedexValueCalculator<T> {
+    val outputIsPercentage: Boolean
     fun calculate(dexManager: AbstractPokedexManager, dex: Map<ResourceLocation, PokedexEntry>): T
 }
 
@@ -25,6 +26,7 @@ interface PokedexValueCalculator<T> {
  * The calculation of this interface is aimed to consider all available Pokédex entries and is not limited or filtered to a particular dex
  */
 interface GlobalPokedexValueCalculator<T> {
+    val outputIsPercentage: Boolean
     fun calculate(dexManager: AbstractPokedexManager): T
 }
 
@@ -32,6 +34,7 @@ interface GlobalPokedexValueCalculator<T> {
  * Calculates the amount of caught Pokémon (globally or per dex)
  */
 object CaughtCount : PokedexValueCalculator<Int>, GlobalPokedexValueCalculator<Int> {
+    override val outputIsPercentage = false
     override fun calculate(dexManager: AbstractPokedexManager): Int {
         return dexManager.speciesRecords.values.count { it.getKnowledge() == PokedexEntryProgress.CAUGHT }
     }
@@ -45,6 +48,7 @@ object CaughtCount : PokedexValueCalculator<Int>, GlobalPokedexValueCalculator<I
  * Calculates the amount of seen Pokémon (globally or per dex)
  */
 object SeenCount : PokedexValueCalculator<Int>, GlobalPokedexValueCalculator<Int> {
+    override val outputIsPercentage = false
     override fun calculate(dexManager: AbstractPokedexManager): Int {
         return dexManager.speciesRecords.values.count { it.getKnowledge() != PokedexEntryProgress.NONE }
     }
@@ -58,12 +62,14 @@ object SeenCount : PokedexValueCalculator<Int>, GlobalPokedexValueCalculator<Int
  * Calculates the seen percentage globally or relative to a particular dex
  */
 object SeenPercent : PokedexValueCalculator<Float>, GlobalPokedexValueCalculator<Float> {
+    override val outputIsPercentage = true
+
     override fun calculate(dexManager: AbstractPokedexManager): Float {
-        return dexManager.speciesRecords.values.count { it.getKnowledge() != PokedexEntryProgress.NONE }.toFloat() / DexEntries.entries.count().toFloat() * 100F
+        return dexManager.speciesRecords.values.count { it.getKnowledge() != PokedexEntryProgress.NONE }.toFloat() / DexEntries.entries.values.map { it.speciesId }.toSet().size * 100F
     }
 
     override fun calculate(dexManager: AbstractPokedexManager, dex: Map<ResourceLocation, PokedexEntry>): Float {
-        return dex.entries.map { it.value }.count { dexManager.getKnowledgeForSpecies(it.speciesId) != PokedexEntryProgress.NONE }.toFloat() / DexEntries.entries.count().toFloat() * 100F
+        return dex.entries.map { it.value }.count { dexManager.getKnowledgeForSpecies(it.speciesId) != PokedexEntryProgress.NONE }.toFloat() / dex.entries.size * 100F
     }
 }
 
@@ -71,11 +77,13 @@ object SeenPercent : PokedexValueCalculator<Float>, GlobalPokedexValueCalculator
  * Calculates the caught percentage globally or relative to a particular dex
  */
 object CaughtPercent : PokedexValueCalculator<Float>, GlobalPokedexValueCalculator<Float> {
+    override val outputIsPercentage = true
+
     override fun calculate(dexManager: AbstractPokedexManager): Float {
-        return dexManager.speciesRecords.values.count { it.getKnowledge() == PokedexEntryProgress.CAUGHT }.toFloat() / DexEntries.entries.count().toFloat().toFloat() * 100F
+        return dexManager.speciesRecords.values.count { it.getKnowledge() == PokedexEntryProgress.CAUGHT }.toFloat() / DexEntries.entries.values.map { it.speciesId }.toSet().size * 100F
     }
 
     override fun calculate(dexManager: AbstractPokedexManager, dex: Map<ResourceLocation, PokedexEntry>): Float {
-        return dex.entries.map { it.value }.count { dexManager.getKnowledgeForSpecies(it.speciesId) == PokedexEntryProgress.CAUGHT }.toFloat() / DexEntries.entries.count().toFloat().toFloat() * 100F
+        return dex.entries.map { it.value }.count { dexManager.getKnowledgeForSpecies(it.speciesId) == PokedexEntryProgress.CAUGHT }.toFloat() / dex.entries.size * 100F
     }
 }

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

@@ -136,7 +136,7 @@ open class PokemonProperties {
             props.ability = parseStringOfRegistry(keyPairs, listOf("ability")) { Abilities.get(it)?.name }
             props.status = parseStringOfRegistry(keyPairs, listOf("status")) { (Statuses.getStatus(it) ?: Statuses.getStatus(it.asIdentifierDefaultingNamespace()))?.showdownName }
             props.nickname = parseText(keyPairs, listOf("nickname", "nick"))
-            props.type = parseStringOfRegistry(keyPairs, listOf("type", "elemental_type")) { ElementalTypes.get(it)?.name }
+            props.type = parseStringOfRegistry(keyPairs, listOf("type", "elemental_type")) { ElementalTypes.get(it)?.showdownId }
             props.teraType = parseIdentifierOfRegistry(keyPairs, listOf("tera_type", "tera")) { TeraTypes.get(it)?.id?.simplify() }
             props.dmaxLevel = parseIntProperty(keyPairs, listOf("dmax_level", "dmax"))?.coerceIn(0, Cobblemon.config.maxDynamaxLevel)
             props.gmaxFactor = parseBooleanProperty(keyPairs, listOf("gmax_factor", "gmax"))
@@ -340,6 +340,7 @@ open class PokemonProperties {
     var originalTrainer: String? = null // Original Trainer by Username or UUID
     var moves: List<String>? = null
     var heldItem: String? = null
+    var cosmeticItem: String? = null
 
     var ivs: IVs? = null
     var evs: EVs? = null

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

@@ -13,7 +13,7 @@ import com.cobblemon.mod.common.pokemon.Pokemon
 enum class PokemonSortMode(val comparator: Comparator<Pokemon?>, val reverseComparator: Comparator<Pokemon?>) {
     NAME({ it?.getDisplayName()?.string }),
     LEVEL({ it?.level }),
-    TYPE({ it?.primaryType?.name }),
+    TYPE({ it?.primaryType?.showdownId }),
     POKEDEX_NUMBER({ it?.species?.nationalPokedexNumber }),
     GENDER({ it?.gender });
 

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

@@ -37,10 +37,12 @@ import com.cobblemon.mod.common.api.pokemon.stats.Stat
 import com.cobblemon.mod.common.api.pokemon.stats.Stats
 import com.cobblemon.mod.common.api.reactive.SimpleObservable
 import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviourSettings
+import com.cobblemon.mod.common.api.riding.sound.RideSoundSettingsList
 import com.cobblemon.mod.common.api.riding.stats.RidingStatDefinition
 import com.cobblemon.mod.common.api.spawning.TimeRange
 import com.cobblemon.mod.common.api.types.ElementalType
 import com.cobblemon.mod.common.api.types.adapters.ElementalTypeAdapter
+import com.cobblemon.mod.common.battles.runner.ShowdownService
 import com.cobblemon.mod.common.net.messages.client.data.SpeciesRegistrySyncPacket
 import com.cobblemon.mod.common.pokemon.FormData
 import com.cobblemon.mod.common.pokemon.Species
@@ -75,6 +77,7 @@ import net.minecraft.world.item.Item
 import net.minecraft.world.level.biome.Biome
 import net.minecraft.world.level.block.Block
 import net.minecraft.world.level.levelgen.structure.Structure
+import net.minecraft.world.level.material.Fluid
 import net.minecraft.world.phys.AABB
 
 object PokemonSpecies : JsonDataRegistry<Species> {
@@ -122,11 +125,13 @@ object PokemonSpecies : JsonDataRegistry<Species> {
         .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Block::class.java).type, BlockLikeConditionAdapter)
         .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Item::class.java).type, ItemLikeConditionAdapter)
         .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Structure::class.java).type, StructureLikeConditionAdapter)
+        .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Fluid::class.java).type, FluidLikeConditionAdapter)
         .registerTypeAdapter(EggGroup::class.java, EggGroupAdapter)
         .registerTypeAdapter(MobEffect::class.java, RegistryElementAdapter<MobEffect>(BuiltInRegistries::MOB_EFFECT))
         .registerTypeAdapter(ItemPredicate::class.java, LegacyItemConditionWrapperAdapter)
         .registerTypeAdapter(RidingBehaviourSettings::class.java, RidingBehaviourSettingsAdapter)
         .registerTypeAdapter(RidingStatDefinition::class.java, RidingStatDefinitionAdapter)
+        .registerTypeAdapter(RideSoundSettingsList::class.java, RideSoundSettingsListAdapter)
         .registerTypeAdapter(Expression::class.java, ExpressionAdapter)
         .disableHtmlEscaping()
         .enableComplexMapKeySerialization()
@@ -155,7 +160,8 @@ object PokemonSpecies : JsonDataRegistry<Species> {
             }
             this.species.forEach(Species::resolveEvolutionMoves)
             Cobblemon.showdownThread.queue {
-                it.registerSpecies()
+                it.resetRegistryData("species")
+                it.sendRegistryData(allShowdownSpecies(), "species")
                 it.indicateSpeciesInitialized()
                 // Reload this with the mod
                 CobblemonHeldItemManager.load()
@@ -265,7 +271,7 @@ object PokemonSpecies : JsonDataRegistry<Species> {
             "H" to "No Ability",
             "S" to "No Ability"
         )
-        val types = (form?.types ?: species.types).map { it.name.replaceFirstChar(Char::uppercase) }
+        val types = (form?.types ?: species.types).map { it.name }
         val preevo: String? = (form?.preEvolution ?: species.preEvolution)?.let { if (it.form == it.species.standardForm) createShowdownName(it.species) else "${createShowdownName(it.species)}-${it.form.name}" }
         // For the context of battles the content here doesn't matter whatsoever and due to how PokemonProperties work we can't guarantee an actual specific species is defined.
         val evos = if ((form?.evolutions ?: species.evolutions).isEmpty()) emptyList() else arrayListOf("")
@@ -310,4 +316,18 @@ object PokemonSpecies : JsonDataRegistry<Species> {
         return "${species.resourceIdentifier.namespace}:${species.name}"
     }
 
+    internal fun allShowdownSpecies(): Map<String, String> {
+        val result = mutableMapOf<String, String>()
+        this.species.forEach {species ->
+            val baseSpecies = ShowdownSpecies(species, null)
+            result[baseSpecies.name] = this.gson.toJson(baseSpecies)
+            species.forms.forEach { form ->
+                if (form != species.standardForm) {
+                    val formSpecies = ShowdownSpecies(species, form)
+                    result[formSpecies.name] = this.gson.toJson(formSpecies)
+                }
+            }
+        }
+        return result
+    }
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/pokemon/aspect/AspectParticleMap.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.pokemon.aspect
+
+import com.cobblemon.mod.common.CobblemonBlocks
+import com.cobblemon.mod.common.api.spawning.influence.SaccharineLogSlatheredInfluence
+import com.cobblemon.mod.common.api.spawning.prospecting.LurePokeSnackDetector
+import com.cobblemon.mod.common.client.entity.PokemonClientDelegate
+import net.minecraft.core.particles.BlockParticleOption
+import net.minecraft.core.particles.ParticleOptions
+import net.minecraft.core.particles.ParticleTypes
+import net.minecraft.resources.ResourceLocation
+
+/**
+ * Used by [PokemonClientDelegate.spawnAspectParticle] to spawn associated particles for aspects
+ */
+val aspectParticleMap: Map<String, ParticleData> = mapOf(
+    SaccharineLogSlatheredInfluence.HONEY_DRENCHED_ASPECT to ParticleData.MinecraftParticle(ParticleTypes.FALLING_HONEY, 0.075, 1),
+    LurePokeSnackDetector.POKE_SNACK_CRUMBED_ASPECT to ParticleData.MinecraftParticle(
+        BlockParticleOption(
+            ParticleTypes.BLOCK,
+            CobblemonBlocks.POKE_SNACK.defaultBlockState()
+        ), 0.05, 3),
+)
+
+sealed class ParticleData {
+    data class SnowstormParticle(val particle: ResourceLocation, val chance: Double, val amount: Int, val locators: List<String>): ParticleData()
+    data class MinecraftParticle(val particle: ParticleOptions, val chance: Double, val amount: Int): ParticleData()
+}

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

@@ -99,6 +99,15 @@ open class Learnset : ClientDataSynchronizer<Learnset> {
         .flatMap { it.value }
         .toSet()
 
+    fun getAllLegalMoves(): Set<MoveTemplate> {
+        return levelUpMoves.values.flatten().toSet() +
+                eggMoves +
+                tutorMoves +
+                tmMoves +
+                formChangeMoves +
+                evolutionMoves
+    }
+
     // We only sync level up moves atm
     override fun shouldSynchronize(other: Learnset) = other.levelUpMoves != this.levelUpMoves
 

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

@@ -18,11 +18,4 @@ import net.minecraft.world.entity.PlayerRideableJumping
  *
  * @since 1.7.0
  */
-interface Rideable : PlayerRideableJumping {
-
-    /**
-     * Denotes the manager responsible for handling any instance of riding taking place on an entity
-     */
-    val riding: RidingBehaviour<RidingBehaviourSettings, RidingBehaviourState>?
-
-}
+interface Rideable : PlayerRideableJumping

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

@@ -18,58 +18,41 @@ import com.cobblemon.mod.common.util.adapters.RidingBehaviourSettingsAdapter
 import net.minecraft.network.RegistryFriendlyByteBuf
 
 class RidingProperties(
-        val stats: MutableMap<RidingStat, RidingStatDefinition> = mutableMapOf(),
         val seats: List<Seat> = listOf(),
         val conditions: List<Expression> = listOf(),
-        val behaviour: RidingBehaviourSettings? = null
+        val behaviours: Map<RidingStyle, RidingBehaviourSettings>? = null
 ) {
 
     companion object {
         fun decode(buffer: RegistryFriendlyByteBuf): RidingProperties {
-            val stats: MutableMap<RidingStat, RidingStatDefinition> = buffer.readMap(
-                    { buffer.readEnum(RidingStat::class.java) },
-                    { RidingStatDefinition.decode(buffer) }
-            ).toMutableMap()
             val seats: List<Seat> = buffer.readList { _ -> Seat.decode(buffer) }
             val conditions = buffer.readList { buffer.readString().asExpression() }
-            val behaviour = buffer.readNullable { _ ->
-                val key = buffer.readResourceLocation()
-                val settings = RidingBehaviourSettingsAdapter.types[key]?.getConstructor()?.newInstance() ?: error("Unknown controller key: $key")
-                settings.decode(buffer)
-                return@readNullable settings
+            val behaviours = buffer.readNullable { _ ->
+                buffer.readMap(
+                    { buffer.readEnumConstant(RidingStyle::class.java) },
+                    {
+                        val key = buffer.readResourceLocation()
+                        val settings = RidingBehaviourSettingsAdapter.types[key]?.getConstructor()?.newInstance()
+                            ?: error("Unknown controller key: $key")
+                        settings.decode(buffer)
+                        settings
+                    }
+                )
             }
 
-            return RidingProperties(stats = stats, seats = seats, conditions = conditions, behaviour = behaviour)
+            return RidingProperties(seats = seats, conditions = conditions, behaviours = behaviours)
         }
     }
 
-    internal fun updateStatRange(stat: RidingStat, style: RidingStyle, min: Int, max: Int) {
-        if (!Cobblemon.config.enableDebugKeys) return
-        if (stats[stat] == null) {
-            stats[stat] = RidingStatDefinition()
-        }
-        stats[stat]!!.ranges[style] = min..max
-    }
-
     fun encode(buffer: RegistryFriendlyByteBuf) {
-        buffer.writeMap(
-                stats,
-                { _, stat -> buffer.writeEnum(stat) },
-                { _, stat -> stat.encode(buffer) }
-        )
         buffer.writeCollection(seats) { _, seat -> seat.encode(buffer) }
         buffer.writeCollection(conditions) { _, condition -> buffer.writeString(condition.getString()) }
-        buffer.writeNullable(behaviour) { _, behaviour ->
-            behaviour.encode(buffer)
+        buffer.writeNullable(behaviours) { _, v ->
+            buffer.writeMap(
+                v,
+                { _, style -> buffer.writeEnumConstant(style) },
+                { _, behaviour -> behaviour.encode(buffer) }
+            )
         }
     }
-
-    fun calculate(stat: RidingStat, style: RidingStyle, boosts: Int): Float {
-        val definitions = stats[stat] ?: return 0F
-        return definitions.calculate(style, boosts)
-    }
-
-    fun hasStat(stat: RidingStat, style: RidingStyle): Boolean {
-        return stats[stat]?.ranges?.containsKey(style) == true
-    }
 }

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

@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.api.riding.behaviour
 
 import com.cobblemon.mod.common.api.riding.RidingStyle
+import com.cobblemon.mod.common.api.riding.sound.RideSoundSettingsList
 import com.cobblemon.mod.common.entity.PoseType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import net.minecraft.resources.ResourceLocation
@@ -86,7 +87,9 @@ interface RidingBehaviour<Settings : RidingBehaviourSettings, State : RidingBeha
 
     fun shouldRotatePokemonHead(settings: Settings, state: State, vehicle: PokemonEntity): Boolean
 
-    fun shouldRotatePlayerHead(settings: Settings, state: State, vehicle: PokemonEntity): Boolean
+    fun shouldRotateRiderHead(settings: Settings, state: State, vehicle: PokemonEntity): Boolean
+
+    fun getRideSounds(settings: Settings, state: State, vehicle: PokemonEntity): RideSoundSettingsList
 
     fun maxUpStep(settings: Settings, state: State, vehicle: PokemonEntity): Float? = null
 
@@ -98,4 +101,19 @@ interface RidingBehaviour<Settings : RidingBehaviourSettings, State : RidingBeha
      * Calculate the damage a horizontal collision will do to a ridden Pokémon. This is only relevant to fast flying behaviours, fall damage is separate!
      */
     fun damageOnCollision(settings: Settings, state: State, vehicle: PokemonEntity, impactVec: Vec3): Boolean = false
+
+
+    /**
+     * Internal helpers to help behaviour specific calculations
+     */
+    companion object {
+        /**
+         *  Scales a given value between a min and a max.
+         *  The result is clamped between 0.0 and 1.0, where 0.0 represents x is at or below min
+         *  and 1.0 represents x is at or above it.
+         */
+        internal fun scaleToRange(x: Double, min: Double, max: Double): Double {
+            return ((x - min) / (max - min)).coerceIn(0.0, 1.0)
+        }
+    }
 }

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

@@ -10,6 +10,8 @@ package com.cobblemon.mod.common.api.riding.behaviour
 
 import com.cobblemon.mod.common.api.net.Decodable
 import com.cobblemon.mod.common.api.net.Encodable
+import com.cobblemon.mod.common.api.riding.RidingStyle
+import com.cobblemon.mod.common.api.riding.stats.RidingStat
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.world.phys.Vec3
 
@@ -23,4 +25,13 @@ import net.minecraft.world.phys.Vec3
  */
 interface RidingBehaviourSettings: Encodable, Decodable {
     val key: ResourceLocation
+    val stats: MutableMap<RidingStat, IntRange>
+
+    fun calculate(stat: RidingStat, boosts: Int): Float {
+        val range = stats[stat] ?: return 0F
+        val boostQuotient = boosts / 255F
+        return range.first + (range.last - range.first) * boostQuotient
+    }
+
+    fun hasStat(stat: RidingStat) = stats.containsKey(stat)
 }

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

@@ -12,6 +12,7 @@ import com.cobblemon.mod.common.api.riding.behaviour.types.air.*
 import com.cobblemon.mod.common.api.riding.behaviour.types.composite.CompositeBehaviour
 import com.cobblemon.mod.common.api.riding.behaviour.types.land.HorseBehaviour
 import com.cobblemon.mod.common.api.riding.behaviour.types.land.VehicleBehaviour
+import com.cobblemon.mod.common.api.riding.behaviour.types.land.MinekartBehaviour
 import com.cobblemon.mod.common.api.riding.behaviour.types.liquid.BoatBehaviour
 import com.cobblemon.mod.common.api.riding.behaviour.types.liquid.BurstBehaviour
 import com.cobblemon.mod.common.api.riding.behaviour.types.liquid.DolphinBehaviour
@@ -22,21 +23,25 @@ object RidingBehaviours {
 
     init {
         register(BirdBehaviour.KEY, BirdBehaviour())
+        register(BirdNoRollBehaviour.KEY, BirdNoRollBehaviour())
         register(DolphinBehaviour.KEY, DolphinBehaviour())
         register(HorseBehaviour.KEY, HorseBehaviour())
         register(BoatBehaviour.KEY, BoatBehaviour())
         register(GliderBehaviour.KEY, GliderBehaviour())
         register(HelicopterBehaviour.KEY, HelicopterBehaviour())
         register(JetBehaviour.KEY, JetBehaviour())
+        register(JetNoRollBehaviour.KEY, JetNoRollBehaviour())
         register(BurstBehaviour.KEY, BurstBehaviour())
         register(VehicleBehaviour.KEY, VehicleBehaviour())
+        register(MinekartBehaviour.KEY, MinekartBehaviour())
         register(HoverBehaviour.KEY, HoverBehaviour())
+        register(RocketBehaviour.KEY, RocketBehaviour())
         register(CompositeBehaviour.KEY, CompositeBehaviour())
     }
 
     fun register(key: ResourceLocation, behaviour: RidingBehaviour<out RidingBehaviourSettings, out RidingBehaviourState>) {
         if (behaviours.contains(key)) error("Behaviour already registered to key $key")
-        behaviours[key] = RidingController(behaviour) as RidingBehaviour<RidingBehaviourSettings, RidingBehaviourState>
+        behaviours[key] = behaviour as RidingBehaviour<RidingBehaviourSettings, RidingBehaviourState>
     }
 
     fun get(key: ResourceLocation): RidingBehaviour<RidingBehaviourSettings, RidingBehaviourState> {