add pokeball firework shape

.gitignore

@@ -12,8 +12,7 @@ out
 *.ipr
 *.iws
 *.iml
-.idea/*
-!.idea/icon.png
+.idea
 
 # gradle
 build

CHANGELOG-SPAWNING.md

@@ -12,14 +12,6 @@
   - SpawningContext is now SpawnablePosition
   - WorldSlice is SpawningZone
   - SpawningProspector is now SpawningZoneGenerator
--  Majorly refactored the hierarchy of Spawner
-  - The base Spawner interface provides more functions to allow single-point and area spawning given appropriate inputs.
-  - TickingSpawner is removed in favour of outside code handling ticking logic.
-  - AreaSpawner is removed.
-  - BasicSpawner is the first implementation of Spawner which can be used for any purpose.
-  - PlayerSpawners are now mixin'd into ServerPlayer and ticked from ServerPlayer#tick.
-  - A hierarchy diagram can be found at `./docs/spawner-hierarchy.png` in the mod repository.
-- The SpawnerManager class has been removed as its functionality is all now handled elsewhere.
 - Renamed things in Spawn Rules to go with the other renames:
-    - contextSelector is now spawnablePositionSelector
+  - contextSelector is now spawnablePositionSelector
   - context is now spawnable_position

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

@@ -1,22 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common;
-
-import com.cobblemon.mod.common.api.spawning.spawner.PlayerSpawner;
-
-/**
- * Used for mixin shenanigans. ServerPlayers now store their Cobblemon spawner
- * inside, so this interface helps execute that.
- *
- * @author Hiroku
- * @since October 27th, 2025
- */
-public interface PlayerSpawnerGetter {
-    PlayerSpawner getPlayerSpawner();
-}

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

@@ -7,7 +7,6 @@
  */
 
 package com.cobblemon.mod.common.mixin;
-
 import com.cobblemon.mod.common.duck.ChannelDuck;
 import com.mojang.blaze3d.audio.Channel;
 import org.lwjgl.openal.AL10;

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

@@ -0,0 +1,75 @@
+/*
+ * 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.mojang.serialization.Codec;
+import io.netty.buffer.ByteBuf;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.util.ByIdMap;
+import net.minecraft.util.StringRepresentable;
+import net.minecraft.world.item.component.FireworkExplosion;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Mutable;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.gen.Invoker;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.IntFunction;
+
+@Mixin(FireworkExplosion.Shape.class)
+public abstract class FireworkExplosionShapeMixin {
+
+    @Shadow
+    @Final
+    @Mutable
+    private static FireworkExplosion.Shape[] $VALUES;
+
+
+    @Shadow
+    @Final
+    @Mutable
+    private static IntFunction<FireworkExplosion.Shape> BY_ID;
+
+    @Shadow
+    @Final
+    @Mutable
+    public static StreamCodec<ByteBuf, FireworkExplosion.Shape> STREAM_CODEC;
+
+    @Shadow
+    @Final
+    @Mutable
+    public static Codec<FireworkExplosion.Shape> CODEC;
+
+    @Invoker("<init>")
+    private static FireworkExplosion.Shape cobblemon$createFireworkExplosionShape(String enumName, int internalId, int id, String name) {
+        throw new AssertionError();
+    }
+
+    @Inject(
+        method = "<clinit>",
+        at = @At("TAIL")
+    )
+    private static void cobblemon$addFireworkExplosionShape(CallbackInfo ci) {
+        ArrayList<FireworkExplosion.Shape> types = new ArrayList<>(List.of($VALUES));
+
+        types.add(cobblemon$createFireworkExplosionShape("POKEBALL", $VALUES.length, 5, "pokeball"));
+
+        $VALUES = types.toArray(FireworkExplosion.Shape[]::new);
+
+        BY_ID = ByIdMap.continuous(FireworkExplosion.Shape::getId, FireworkExplosion.Shape.values(), ByIdMap.OutOfBoundsStrategy.ZERO);
+        STREAM_CODEC = ByteBufCodecs.idMapper(BY_ID, FireworkExplosion.Shape::getId);
+        CODEC = StringRepresentable.fromValues(FireworkExplosion.Shape::values);
+    }
+}

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

@@ -0,0 +1,87 @@
+/*
+ * 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.llamalad7.mixinextras.sugar.Local;
+import it.unimi.dsi.fastutil.ints.IntList;
+import net.minecraft.client.particle.FireworkParticles;
+import net.minecraft.world.item.component.FireworkExplosion;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
+
+@Mixin(FireworkParticles.Starter.class)
+public abstract class FireworkParticlesMixin {
+
+    @Shadow
+    protected abstract void createParticleShape(double speed, double[][] coords, IntList colors, IntList fadeColors, boolean trail, boolean twinkle, boolean isCreeper);
+
+    @Inject(
+        method = "tick()V",
+        at = @At(
+            value = "INVOKE",
+            target = "Lnet/minecraft/client/particle/Particle;setColor(FFF)V",
+            shift = At.Shift.BEFORE,
+            by = 2
+        )
+    )
+    private void cobblemon$createPokeballParticleShape(
+        CallbackInfo ci,
+        @Local FireworkExplosion fireworkExplosion2,
+        @Local(ordinal = 0) int bl3,
+        @Local(ordinal = 0) int bl4,
+        @Local(ordinal = 0) IntList intList,
+        @Local(ordinal = 0) IntList intList2
+    ) {
+        if (fireworkExplosion2.shape().getSerializedName().equals("pokeball")) {
+            final double[][] POKEBALL_PARTICLE_COORDS = new double[][]{
+                {0, 0.5},
+                {0.05, 0.497494},
+                {0.1, 0.489898},
+                {0.15, 0.47697},
+                {0.2, 0.458258},
+                {0.25, 0.433013},
+                {0.3, 0.4},
+                {0.35, 0.357071},
+                {0.4, 0.3},
+                {0.45, 0.217945},
+                {0.4975, 0.049937},
+                {0.086606, 0.049994},
+                {0.05, 0.086603},
+                {0, 0.1},
+                {0.05, 0.049994},
+
+                {0.05, -0.049994},
+                {0, -0.1},
+                {0.05, -0.086603},
+                {0.086606, -0.049994},
+                {0.0, -0.049937},
+                {0.4975, -0.049937},
+                {0.45, -0.217945},
+                {0.4, -0.3},
+                {0.35, -0.357071},
+                {0.3, -0.4},
+                {0.25, -0.433013},
+                {0.2, -0.458258},
+                {0.15, -0.47697},
+                {0.1, -0.489898},
+                {0.05, -0.497494},
+                {0, -0.5},
+            };
+
+            boolean b3 = bl3 == 1;
+            boolean b4 = bl4 == 1;
+
+            this.createParticleShape(0.5, POKEBALL_PARTICLE_COORDS, intList, intList2, b3, b4, true);
+        }
+    }
+}

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

@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.mixin;
+
+import com.cobblemon.mod.common.CobblemonItems;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.component.FireworkExplosion;
+import net.minecraft.world.item.crafting.FireworkStarRecipe;
+import net.minecraft.world.item.crafting.Ingredient;
+import net.minecraft.world.level.ItemLike;
+import org.spongepowered.asm.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.Arrays;
+import java.util.Map;
+
+@Mixin(FireworkStarRecipe.class)
+public class FireworkStarRecipeMixin {
+
+    @Mutable
+    @Shadow
+    @Final
+    private static Map<Item, FireworkExplosion.Shape> SHAPE_BY_ITEM;
+
+    @Mutable
+    @Shadow
+    @Final
+    private static Ingredient SHAPE_INGREDIENT;
+
+    @Inject(method = "<clinit>", at = @At("TAIL"))
+    private static void cobblemon$addCustomShape(CallbackInfo ci) {
+        ItemStack[] existing = SHAPE_INGREDIENT.getItems();
+        ItemStack[] extended = new ItemStack[existing.length + 1];
+        System.arraycopy(existing, 0, extended, 0, existing.length);
+
+        extended[existing.length] = new ItemStack(CobblemonItems.POKE_BALL);
+
+        SHAPE_INGREDIENT = Ingredient.of(Arrays.stream(extended)
+            .map(ItemStack::getItem)
+            .toArray(ItemLike[]::new));
+        SHAPE_BY_ITEM.put(CobblemonItems.POKE_BALL, FireworkExplosion.Shape.byId(5));
+    }
+}

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

@@ -55,6 +55,48 @@ public abstract class LivingEntityMixin extends Entity implements OrientationCon
         }
     }
 
+    @Override
+    public @NotNull HitResult pick(double hitDistance, float partialTicks, boolean hitFluids) {
+        Entity vehicle = this.getVehicle();
+        if (vehicle instanceof PokemonEntity pokemonEntity && pokemonEntity.getDelegate() instanceof PokemonClientDelegate delegate) {
+            int seatIndex = pokemonEntity.getPassengers().indexOf(this);
+            Seat seat = pokemonEntity.getSeats().get(seatIndex);
+            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();

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

@@ -8,51 +8,20 @@
 
 package com.cobblemon.mod.common.mixin;
 
-import com.cobblemon.mod.common.Cobblemon;
 import com.cobblemon.mod.common.OrientationControllable;
-import com.cobblemon.mod.common.PlayerSpawnerGetter;
-import com.cobblemon.mod.common.api.spawning.spawner.PlayerSpawner;
-import com.cobblemon.mod.common.api.spawning.spawner.PlayerSpawnerFactory;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
-import com.cobblemon.mod.common.world.gamerules.CobblemonGameRules;
 import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
 import com.llamalad7.mixinextras.sugar.Local;
-import net.minecraft.server.level.ServerLevel;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.entity.Entity;
 import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 @Mixin(ServerPlayer.class)
-public abstract class ServerPlayerMixin implements PlayerSpawnerGetter {
-    @Shadow
-    public abstract ServerLevel serverLevel();
-
-    @Unique
-    public PlayerSpawner cobblemon$spawner;
-
-    @Override
-    public PlayerSpawner getPlayerSpawner() {
-        ServerPlayer player = (ServerPlayer)(Object)this;
-        if (cobblemon$spawner == null) {
-            cobblemon$spawner = PlayerSpawnerFactory.INSTANCE.create(player);
-        }
-        return cobblemon$spawner;
-    }
-
-    @Inject(method = "tick", at = @At("TAIL"))
-    private void cobblemon$tickSpawner(CallbackInfo ci) {
-        if (!Cobblemon.config.getEnableSpawning()) {
-            return;
-        } else if (!serverLevel().getGameRules().getBoolean(CobblemonGameRules.DO_POKEMON_SPAWNING)) {
-            return;
-        }
-        getPlayerSpawner().tick();
-    }
+public abstract class ServerPlayerMixin {
 
     @Inject(method = "rideTick", at = @At("HEAD"))
     private void cobblemon$updateOrientationControllerRideTick(CallbackInfo ci) {
@@ -82,4 +51,5 @@ public abstract class ServerPlayerMixin implements PlayerSpawnerGetter {
     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/client/GameRendererMixin.java

@@ -9,21 +9,15 @@
 package com.cobblemon.mod.common.mixin.client;
 
 import com.cobblemon.mod.common.api.scheduling.ClientTaskTracker;
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
-import com.llamalad7.mixinextras.sugar.Local;
 import net.minecraft.client.DeltaTracker;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.GameRenderer;
-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;
 import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.ModifyArg;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
-import java.util.function.Predicate;
-
 @Mixin(GameRenderer.class)
 public class GameRendererMixin {
     @Unique
@@ -48,16 +42,4 @@ public class GameRendererMixin {
         lastTime = newTime;
     }
 
-    @ModifyArg(
-        method = "pick(Lnet/minecraft/world/entity/Entity;DDF)Lnet/minecraft/world/phys/HitResult;",
-        at = @At(
-            value = "INVOKE",
-            target = "Lnet/minecraft/world/entity/projectile/ProjectileUtil;getEntityHitResult(Lnet/minecraft/world/entity/Entity;Lnet/minecraft/world/phys/Vec3;Lnet/minecraft/world/phys/Vec3;Lnet/minecraft/world/phys/AABB;Ljava/util/function/Predicate;D)Lnet/minecraft/world/phys/EntityHitResult;"
-        ),
-        index = 4
-    )
-    private Predicate<Entity> filterPokemonVehicle(Predicate<Entity> original, @Local(ordinal = 0, argsOnly = true) Entity entity) {
-        return (entityX) -> !(entity.getVehicle() == entityX && entityX instanceof PokemonEntity) && original.test(entityX);
-    }
-
 }

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

@@ -26,6 +26,8 @@ object CobblemonPoiTypes: PlatformRegistry<Registry<PoiType>, ResourceKey<Regist
     @JvmField
     val NURSE_KEY = createKey("nurse", CobblemonBlocks.HEALING_MACHINE, 1, 1)
     @JvmField
+    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)
     // TODO after 1.7
 //    @JvmField

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

@@ -806,8 +806,8 @@ open class PokemonProperties {
         return PokemonProperties().loadFromJSON(this.saveToJSON())
     }
 
-    // If the config value is at least 0, then do 1/x and use that as the property chance
-    private fun Float.checkRate(): Boolean = this > 0 && (Random.nextFloat() < 1 / this)
+    // If the config value is at least 1, then do 1/x and use that as the property chance
+    private fun Float.checkRate(): Boolean = if (this >= 1) (Random.Default.nextFloat() < 1 / this) else Random.Default.nextFloat() < this
 
     /**
      * Attempts to find an ability by ID and resolve if it should be forced or if it's legal for the given form.

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

@@ -11,7 +11,7 @@ package com.cobblemon.mod.common.api.pokemon.aspect
 import com.cobblemon.mod.common.CobblemonBlocks
 import com.cobblemon.mod.common.api.ai.config.task.PollinateFlowerTaskConfig
 import com.cobblemon.mod.common.api.spawning.influence.SaccharineLogSlatheredInfluence
-import com.cobblemon.mod.common.block.entity.PokeSnackBlockEntity
+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
@@ -23,7 +23,7 @@ import net.minecraft.resources.ResourceLocation
  */
 val aspectParticleMap: Map<String, ParticleData> = mapOf(
     SaccharineLogSlatheredInfluence.HONEY_DRENCHED_ASPECT to ParticleData.MinecraftParticle(ParticleTypes.FALLING_HONEY, 0.075, 1),
-    PokeSnackBlockEntity.POKE_SNACK_CRUMBED_ASPECT to ParticleData.MinecraftParticle(
+    LurePokeSnackDetector.POKE_SNACK_CRUMBED_ASPECT to ParticleData.MinecraftParticle(
         BlockParticleOption(
             ParticleTypes.BLOCK,
             CobblemonBlocks.POKE_SNACK.defaultBlockState()

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

@@ -18,11 +18,18 @@ import com.cobblemon.mod.common.api.spawning.condition.SeafloorSpawningCondition
 import com.cobblemon.mod.common.api.spawning.condition.SpawningCondition
 import com.cobblemon.mod.common.api.spawning.condition.SubmergedSpawningCondition
 import com.cobblemon.mod.common.api.spawning.condition.SurfaceSpawningCondition
+import com.cobblemon.mod.common.api.spawning.position.calculators.GroundedSpawnablePositionCalculator
+import com.cobblemon.mod.common.api.spawning.position.calculators.LavafloorSpawnablePositionCalculator
+import com.cobblemon.mod.common.api.spawning.position.calculators.SeafloorSpawnablePositionCalculator
+import com.cobblemon.mod.common.api.spawning.position.calculators.SpawnablePositionCalculator
+import com.cobblemon.mod.common.api.spawning.position.calculators.SubmergedSpawnablePositionCalculator
+import com.cobblemon.mod.common.api.spawning.position.calculators.SurfaceSpawnablePositionCalculator
 import com.cobblemon.mod.common.api.spawning.detail.NPCSpawnDetail
 import com.cobblemon.mod.common.api.spawning.detail.PokemonHerdSpawnDetail
 import com.cobblemon.mod.common.api.spawning.detail.PokemonSpawnDetail
 import com.cobblemon.mod.common.api.spawning.detail.SpawnAction
 import com.cobblemon.mod.common.api.spawning.detail.SpawnDetail
+import com.cobblemon.mod.common.api.spawning.fishing.FishingSpawner
 import com.cobblemon.mod.common.api.spawning.influence.SpawningInfluence
 import com.cobblemon.mod.common.api.spawning.position.AreaSpawnablePositionResolver
 import com.cobblemon.mod.common.api.spawning.position.FishingSpawnablePosition
@@ -32,21 +39,16 @@ import com.cobblemon.mod.common.api.spawning.position.SeafloorSpawnablePosition
 import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
 import com.cobblemon.mod.common.api.spawning.position.SubmergedSpawnablePosition
 import com.cobblemon.mod.common.api.spawning.position.SurfaceSpawnablePosition
-import com.cobblemon.mod.common.api.spawning.position.calculators.GroundedSpawnablePositionCalculator
-import com.cobblemon.mod.common.api.spawning.position.calculators.LavafloorSpawnablePositionCalculator
-import com.cobblemon.mod.common.api.spawning.position.calculators.SeafloorSpawnablePositionCalculator
-import com.cobblemon.mod.common.api.spawning.position.calculators.SpawnablePositionCalculator
-import com.cobblemon.mod.common.api.spawning.position.calculators.SubmergedSpawnablePositionCalculator
-import com.cobblemon.mod.common.api.spawning.position.calculators.SurfaceSpawnablePositionCalculator
 import com.cobblemon.mod.common.api.spawning.preset.BasicSpawnDetailPreset
 import com.cobblemon.mod.common.api.spawning.preset.BestSpawnerConfig
 import com.cobblemon.mod.common.api.spawning.preset.PokemonSpawnDetailPreset
 import com.cobblemon.mod.common.api.spawning.selection.SpawningSelector
-import com.cobblemon.mod.common.api.spawning.spawner.BasicSpawner
+import com.cobblemon.mod.common.api.spawning.spawner.AreaSpawner
 import com.cobblemon.mod.common.api.spawning.spawner.FixedAreaSpawner
 import com.cobblemon.mod.common.api.spawning.spawner.PlayerSpawner
 import com.cobblemon.mod.common.api.spawning.spawner.PlayerSpawnerFactory
 import com.cobblemon.mod.common.api.spawning.spawner.Spawner
+import com.cobblemon.mod.common.api.spawning.spawner.TickingSpawner
 import com.cobblemon.mod.common.entity.pokemon.CobblemonAgingDespawner
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import net.minecraft.server.MinecraftServer
@@ -64,13 +66,14 @@ import net.minecraft.server.MinecraftServer
  * In the case of more specialized use, the creation of a [SpawnablePosition] that motivates most of the spawn
  * process can be created manually, skipping the first two steps.
  *
- * An individually spawnable thing is defined as a [SpawnDetail]. A processor handling this process is a [Spawner].
- * Some subclasses exist for more specialized cases. If you are spawning in a fixed area and the spawner controlling
+ * An individually spawnable entity is defined as a [SpawnDetail]. A processor handling this process is a [Spawner].
+ * Various subclasses exist for more specialized cases. A spawner that is constantly ticking and will spawn things
+ * without prompts is a [TickingSpawner], and one of those which occurs within a defined area is a [AreaSpawner]. If
  * that area is unmoving then it is a [FixedAreaSpawner] whereas if it is actively following the player it is a
- * [PlayerSpawner]. You can also use a [BasicSpawner] for more general-purpose spawning without any issue.
+ * [PlayerSpawner].
  *
- * PlayerSpawners are stored inside ServerPlayers using a mixin and tick at the end of a player's tick. The [PlayerSpawnerFactory]
- * is used to build those. An extension function exists for getting the spawner for a player.
+ * Spawning is coordinated and ticked using a [SpawnerManager], and all the current managers are accessible from
+ * [BestSpawner.spawnerManagers].
  *
  * Spawners and spawnable positions are often put under the effects of [SpawningInfluence]s which can be used to make
  * temporary or lasting changes to spawning for whatever component they are attached to (whether that is a spawner or a
@@ -84,9 +87,9 @@ import net.minecraft.server.MinecraftServer
  */
 object BestSpawner {
     var config = BestSpawnerConfig()
-
+    val spawnerManagers = mutableListOf<SpawnerManager>(CobblemonWorldSpawnerManager)
     lateinit var defaultPokemonDespawner: Despawner<PokemonEntity>
-    lateinit var fishingSpawner: BasicSpawner
+    lateinit var fishingSpawner: FishingSpawner
 
     fun init() {
         LOGGER.info("Starting the Best Spawner...")
@@ -134,13 +137,12 @@ object BestSpawner {
 
     fun reloadConfig() {
         loadConfig()
+        spawnerManagers.forEach(SpawnerManager::onConfigReload)
     }
 
     fun onServerStarted(server: MinecraftServer) {
         CobblemonSpawnPools.onServerLoad(server)
-        fishingSpawner = BasicSpawner(
-            name = "fishing",
-            spawnPool = CobblemonSpawnPools.WORLD_SPAWN_POOL
-        )
+        spawnerManagers.forEach(SpawnerManager::onServerStarted)
+        fishingSpawner = FishingSpawner()
     }
 }

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

@@ -40,6 +40,7 @@ object CobblemonSpawnPools {
 
     fun onServerLoad(server: MinecraftServer) {
         Cobblemon.LOGGER.info("Optimizing spawn pools...")
-        WORLD_SPAWN_POOL.onServerLoad(server)
+        WORLD_SPAWN_POOL.forEach { it.onServerLoad(server) }
+        WORLD_SPAWN_POOL.precalculate()
     }
 }

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

@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.spawning
+
+import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.api.spawning.spawner.PlayerSpawner
+import com.cobblemon.mod.common.api.spawning.spawner.PlayerSpawnerFactory
+import com.cobblemon.mod.common.platform.events.PlatformEvents
+import com.cobblemon.mod.common.world.gamerules.CobblemonGameRules
+import net.minecraft.server.level.ServerLevel
+import java.util.UUID
+import net.minecraft.server.level.ServerPlayer
+
+/**
+ * The [SpawnerManager] that handles Cobblemon's world spawner, which is made up
+ * of [PlayerSpawner] instances. This manager listens for login and logout and
+ * cleans up where relevant.
+ *
+ * @author Hiroku
+ * @since February 14th, 2022
+ */
+object CobblemonWorldSpawnerManager : SpawnerManager() {
+
+    var spawnersForPlayers = mutableMapOf<UUID, PlayerSpawner>()
+
+    init {
+        PlatformEvents.SERVER_PLAYER_LOGIN.subscribe { this.onPlayerLogin(it.player) }
+        PlatformEvents.SERVER_PLAYER_LOGOUT.subscribe { this.onPlayerLogout(it.player) }
+        PlatformEvents.CHANGE_DIMENSION.subscribe { this.onDimensionChange(it.player, it.origin, it.destination) }
+    }
+
+    fun onPlayerLogin(player: ServerPlayer) {
+        // Disables spawning
+        if (!Cobblemon.config.enableSpawning || player.level().gameRules.getBoolean(CobblemonGameRules.DO_POKEMON_SPAWNING) == false) {
+            return;
+        }
+
+        registerPlayerSpawner(player)
+    }
+
+    fun onPlayerLogout(player: ServerPlayer) {
+        unregisterPlayerSpawner(player)
+    }
+
+    fun onDimensionChange(player: ServerPlayer, origin: ServerLevel?, destination: ServerLevel?) {
+        fun getSpawnRule(level: ServerLevel?) = level?.gameRules?.getBoolean(CobblemonGameRules.DO_POKEMON_SPAWNING)
+
+        if (!Cobblemon.config.enableSpawning || getSpawnRule(origin) == getSpawnRule(destination)) {
+            return
+        }
+
+        val spawnerAction = if (destination?.gameRules?.getBoolean(CobblemonGameRules.DO_POKEMON_SPAWNING) == false) {
+            ::unregisterPlayerSpawner
+        } else {
+            ::registerPlayerSpawner
+        }
+        spawnerAction(player)
+    }
+
+    private fun unregisterPlayerSpawner(player: ServerPlayer) {
+        spawnersForPlayers.remove(player.uuid)?.let { unregisterSpawner(it) }
+    }
+
+    private fun registerPlayerSpawner(player: ServerPlayer) {
+        PlayerSpawnerFactory.create(this, player).also {
+            spawnersForPlayers[player.uuid] = it
+            registerSpawner(it)
+        }
+    }
+}

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

@@ -17,21 +17,16 @@ import net.minecraft.world.entity.EntityType
 open class SpawnCause(
     val spawner: Spawner,
     entity: Entity? = null
-) : SpawningInfluence {
+): SpawningInfluence {
     val entityWorldId = entity?.level()?.dimension()
     val entityId = entity?.id
     val entityUUID = entity?.uuid
     val entityType = entity?.type
 
     val entity: Entity?
-        get() =
-            if (entityType == EntityType.PLAYER) {
-                entityUUID?.let {
-                    server()?.playerList?.getPlayer(it)
-                }
-            } else if (entityWorldId != null && entityId != null) {
-                server()?.getLevel(entityWorldId)?.getEntity(entityId)
-            } else {
-                null
-            }
+        get() = if (entityType == EntityType.PLAYER) {
+            server()?.playerList?.getPlayer(entityUUID!!)
+        } else {
+            server()?.getLevel(entityWorldId!!)?.getEntity(entityId!!)
+        }
 }

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

@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.spawning
+
+import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.api.spawning.influence.SpawningInfluence
+import com.cobblemon.mod.common.api.spawning.spawner.PlayerSpawner
+import com.cobblemon.mod.common.api.spawning.spawner.Spawner
+import com.cobblemon.mod.common.api.spawning.spawner.TickingSpawner
+import com.cobblemon.mod.common.util.server
+import com.cobblemon.mod.common.world.gamerules.CobblemonGameRules.DO_POKEMON_SPAWNING
+
+/**
+ * A manager of various spawners. This is a class in which you should register
+ * ticking spawners so that they can be automatically ticked by the server.
+ * This also supports registering [SpawningInfluence]s to apply to each spawner
+ * that is registered.
+ *
+ * @author Hiroku
+ * @since February 5th, 2022
+ */
+open class SpawnerManager {
+    val spawners = mutableListOf<Spawner>()
+        get() {
+            if (server()?.isSameThread == false) {
+                Cobblemon.LOGGER.error("Illegal access to spawners list from non-server thread!")
+                Exception().printStackTrace()
+            }
+            return field
+        }
+    val influences = mutableListOf<SpawningInfluence>()
+        get() {
+            if (server()?.isSameThread == false) {
+                Cobblemon.LOGGER.error("Illegal access to influences from non-server thread!")
+                Exception().printStackTrace()
+            }
+            return field
+        }
+    inline fun <reified T : Spawner> getSpawnersOfType() = spawners.filterIsInstance<T>()
+    open fun getSpawnerByName(name: String) = spawners.find { it.name == name }
+
+    open fun registerSpawner(spawner: Spawner) {
+        spawners.add(spawner)
+        if (spawner !is TickingSpawner) {
+            spawner.influences.addAll(influences)
+        }
+    }
+
+    open fun unregisterSpawner(spawner: Spawner) {
+        spawners.remove(spawner)
+        if (spawner !is TickingSpawner) {
+            spawner.influences.removeAll(influences)
+        }
+    }
+
+    open fun onConfigReload() {
+        spawners.filterIsInstance<PlayerSpawner>().forEach {
+            it.ticksBetweenSpawns = Cobblemon.config.ticksBetweenSpawnAttempts
+        }
+    }
+
+    open fun onServerStarted() {
+        spawners.clear()
+    }
+
+    open fun onServerTick() {
+        // Disables spawning
+        if (!Cobblemon.config.enableSpawning) {
+            return
+        }
+        influences.removeIf { it.isExpired() }
+        getSpawnersOfType<TickingSpawner>().forEach {
+            if (it.getCauseEntity()?.level()?.gameRules?.getBoolean(DO_POKEMON_SPAWNING) == false) {
+                return@forEach
+            }
+            it.tick()
+        }
+    }
+}

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

@@ -39,13 +39,9 @@ import net.minecraft.server.MinecraftServer
  */
 abstract class SpawnDetail : ModDependant {
     companion object {
-        val pokemonTypes = mutableListOf<String>()
         val spawnDetailTypes = mutableMapOf<String, RegisteredSpawnDetail<*>>()
         fun <T : SpawnDetail> registerSpawnType(name: String, detailClass: Class<T>) {
             spawnDetailTypes[name] = RegisteredSpawnDetail(detailClass)
-            if (detailClass == PokemonSpawnDetail::class.java || detailClass == PokemonHerdSpawnDetail::class.java) {
-                pokemonTypes.add(name)
-            }
         }
     }
 

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

@@ -24,7 +24,6 @@ import com.cobblemon.mod.common.util.server
 import com.google.gson.Gson
 import com.google.gson.reflect.TypeToken
 import net.minecraft.resources.ResourceLocation
-import net.minecraft.server.MinecraftServer
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.server.packs.PackType
 
@@ -73,13 +72,6 @@ class SpawnPool(val name: String) : JsonDataRegistry<SpawnSet>, Iterable<SpawnDe
         return this
     }
 
-    fun onServerLoad(server: MinecraftServer) {
-        for (detail in details) {
-            detail.onServerLoad(server)
-        }
-        precalculate()
-    }
-
     /**
      * Precalculates spawns into hash mappings using the [precalculators] included
      * in this pool as well as the range of spawnable positions mentioned in the pool.

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

@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.spawning.fishing
+
+import com.cobblemon.mod.common.api.spawning.CobblemonSpawnPools
+import com.cobblemon.mod.common.api.spawning.position.FishingSpawnablePosition
+import com.cobblemon.mod.common.api.spawning.detail.SpawnPool
+import com.cobblemon.mod.common.api.spawning.spawner.TriggerSpawner
+import net.minecraft.server.level.ServerLevel
+import net.minecraft.core.BlockPos
+
+/**
+ * A spawner that takes in a [FishingSpawnCause] and spawns things.
+ *
+ * @author Hiroku
+ * @since February 3rd, 2024
+ */
+open class FishingSpawner(
+    override val name: String = "fishing",
+    pool: SpawnPool = CobblemonSpawnPools.WORLD_SPAWN_POOL
+) : TriggerSpawner<FishingSpawnCause>(name, pool) {
+    override fun parseSpawnablePosition(cause: FishingSpawnCause, world: ServerLevel, pos: BlockPos): FishingSpawnablePosition? {
+        // Maybe confirm that it's water we're fishing in?
+        val spawnablePosition = FishingSpawnablePosition(
+            cause = cause,
+            world = world,
+            pos = pos,
+            influences = influences
+        )
+        return spawnablePosition
+    }
+}

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

@@ -1,35 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.api.spawning.influence
-
-import com.cobblemon.mod.common.api.spawning.SpawnBucket
-
-/**
- * A [SpawningInfluence] that multiplies bucket weights by the provided values
- * and then normalizes the resulting weights so that their total adds up to 100.
- */
-class BucketMultiplyingInfluence(
-    val multipliers: Map<String, Float>,
-) : SpawningInfluence {
-    override fun affectBucketWeights(bucketWeights: MutableMap<SpawnBucket, Float>) {
-        val updates = mutableMapOf<SpawnBucket, Float>()
-        for ((bucket, weight) in bucketWeights) {
-            val multiplier = multipliers[bucket.name]
-            if (multiplier != null) {
-                updates[bucket] = weight * multiplier
-            }
-        }
-
-        for ((bucket, newWeight) in updates) {
-            bucketWeights[bucket] = newWeight
-        }
-
-        normalizeBucketWeights(bucketWeights)
-    }
-}

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

@@ -44,6 +44,11 @@ open class BucketNormalizingInfluence(
             bucketWeights[it] = weight.toDouble().pow(1 / normalizationFactor).toFloat()
         }
 
-        normalizeBucketWeights(bucketWeights)
+        val sum = bucketWeights.values.sum()
+        val to100 = 100F / sum
+        bucketWeights.keys.toList().forEach {
+            val weight = bucketWeights[it] ?: return@forEach
+            bucketWeights[it] = weight * to100
+        }
     }
 }

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

@@ -40,15 +40,6 @@ interface SpawningInfluence {
     fun affectSpawn(action: SpawnAction<*>, entity: Entity) {}
     /** Applies some influence over the weight of spawn buckets. */
     fun affectBucketWeights(bucketWeights: MutableMap<SpawnBucket, Float>) {}
-    /** Normalizes all bucket weights to add up to 100 */
-    fun normalizeBucketWeights(bucketWeights: MutableMap<SpawnBucket, Float>) {
-        val sum = bucketWeights.values.sum()
-        val to100 = 100F / sum
-        bucketWeights.keys.toList().forEach {
-            val weight = bucketWeights[it] ?: return@forEach
-            bucketWeights[it] = weight * to100
-        }
-    }
     /** Filters positions that could be usable for a spawnable position calculator */
     fun isAllowedPosition(world: ServerLevel, pos: BlockPos, spawnablePositionCalculator: SpawnablePositionCalculator<*, *>): Boolean = true
     /**

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

@@ -9,15 +9,16 @@
 package com.cobblemon.mod.common.api.spawning.influence.detector
 
 import com.cobblemon.mod.common.api.spawning.SpawningZone
-import com.cobblemon.mod.common.api.spawning.SpawningZoneGenerator
 import com.cobblemon.mod.common.api.spawning.influence.SpawningZoneInfluence
-import com.cobblemon.mod.common.api.spawning.prospecting.IncenseSweetDetector
-import com.cobblemon.mod.common.api.spawning.prospecting.SaccharineLogSlatheredDetector
 import com.cobblemon.mod.common.api.spawning.spawner.Spawner
 import com.cobblemon.mod.common.api.spawning.spawner.SpawningZoneInput
 import net.minecraft.core.BlockPos
 import net.minecraft.server.level.ServerLevel
 import net.minecraft.world.level.block.state.BlockState
+import com.cobblemon.mod.common.api.spawning.SpawningZoneGenerator
+import com.cobblemon.mod.common.api.spawning.prospecting.IncenseSweetDetector
+import com.cobblemon.mod.common.api.spawning.prospecting.LurePokeSnackDetector
+import com.cobblemon.mod.common.api.spawning.prospecting.SaccharineLogSlatheredDetector
 
 /**
  * Prospects for [SpawningZoneInfluence] in a world at a given position. Occurs as part of a
@@ -30,6 +31,7 @@ interface SpawningInfluenceDetector {
     companion object {
         @JvmStatic
         val detectors = mutableSetOf<SpawningInfluenceDetector>(
+            LurePokeSnackDetector,
             SaccharineLogSlatheredDetector,
             IncenseSweetDetector
         )

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

@@ -28,7 +28,7 @@ class FishingSpawnablePosition(
     world: ServerLevel,
     pos: BlockPos,
     influences: MutableList<SpawningInfluence>
-) : BasicSpawnablePosition(
+) : TriggerSpawnablePosition(
     cause = cause,
     world = world,
     position = pos,

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

@@ -14,15 +14,13 @@ import net.minecraft.server.level.ServerLevel
 import net.minecraft.core.BlockPos
 
 /**
- * A spawnable position relating to single-point spawning. Uses a single-point structure cache which is
- * the only contribution of this implementation really. By contrast, the area spawnable position provides
- * a structure cache that's shared across the entire zone that was used for spawning, which is great for
- * performance. That kind of optimization shouldn't be necessary for single-point spawning.
+ * A spawnable position relating to triggered spawning. Uses a single-point structure cache which is
+ * the only contribution of this implementation.
  *
  * @author Hiroku
  * @since February 3rd, 2024
  */
-open class BasicSpawnablePosition(
+open class TriggerSpawnablePosition(
     override val cause: SpawnCause,
     override val world: ServerLevel,
     override val position: BlockPos,
@@ -31,6 +29,6 @@ open class BasicSpawnablePosition(
     override val canSeeSky: Boolean,
     override val influences: MutableList<SpawningInfluence>
 ) : SpawnablePosition() {
-    val singlePointStructureCache = StructureChunkCache()
-    override fun getStructureCache(pos: BlockPos) = singlePointStructureCache
+    val triggerStructureCache = StructureChunkCache()
+    override fun getStructureCache(pos: BlockPos) = triggerStructureCache
 }

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

@@ -36,7 +36,6 @@ interface SpawnablePositionCalculator<I : SpawnablePositionInput, O : SpawnableP
         val isLavaCondition: (BlockState) -> Boolean = { it.fluidState.`is`(FluidTags.LAVA) && it.fluidState.isSource }
 
         private val calculators = PrioritizedList<SpawnablePositionCalculator<*, *>>()
-
         val prioritizedAreaCalculators: List<AreaSpawnablePositionCalculator<*>>
             get() = calculators.filterIsInstance<AreaSpawnablePositionCalculator<*>>()
 

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

@@ -0,0 +1,189 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.spawning.prospecting
+
+import com.cobblemon.mod.common.CobblemonPoiTypes
+import com.cobblemon.mod.common.api.fishing.SpawnBait
+import com.cobblemon.mod.common.api.spawning.influence.BucketNormalizingInfluence
+import com.cobblemon.mod.common.api.spawning.influence.SpatialSpawningZoneInfluence
+import com.cobblemon.mod.common.api.spawning.influence.SpawnBaitInfluence
+import com.cobblemon.mod.common.api.spawning.influence.SpawningZoneInfluence
+import com.cobblemon.mod.common.api.spawning.influence.UnconditionalSpawningZoneInfluence
+import com.cobblemon.mod.common.api.spawning.influence.detector.SpawningInfluenceDetector
+import com.cobblemon.mod.common.api.spawning.spawner.Spawner
+import com.cobblemon.mod.common.api.spawning.spawner.SpawningZoneInput
+import com.cobblemon.mod.common.block.PokeSnackBlock
+import com.cobblemon.mod.common.block.entity.PokeSnackBlockEntity
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.net.messages.client.effect.PokeSnackBlockParticlesPacket
+import com.cobblemon.mod.common.util.math.pow
+import com.cobblemon.mod.common.util.toBlockPos
+import kotlin.math.ceil
+import kotlin.math.sqrt
+import net.minecraft.core.BlockPos
+import net.minecraft.core.Direction
+import net.minecraft.core.Holder
+import net.minecraft.server.level.ServerLevel
+import net.minecraft.world.entity.ai.village.poi.PoiManager
+import net.minecraft.world.entity.ai.village.poi.PoiType
+import net.minecraft.world.level.block.Blocks
+import net.minecraft.world.level.block.state.BlockState
+import net.minecraft.world.phys.Vec3
+import kotlin.math.abs
+
+object LurePokeSnackDetector : SpawningInfluenceDetector {
+
+    @JvmField
+    val RANGE: Int = 48
+
+    @JvmField
+    val POKE_SNACK_CRUMBED_ASPECT = "poke_snack_crumbed"
+
+    override fun detectFromInput(spawner: Spawner, input: SpawningZoneInput): MutableList<SpawningZoneInfluence> {
+        val world = input.world
+        val listOfInfluences = mutableListOf<SpawningZoneInfluence>()
+
+        val searchRange = RANGE + ceil(sqrt(((input.length pow 2) + (input.width pow 2)).toDouble())).toInt()
+        val lurePokeSnackPositions = world.poiManager.findAll(
+            { holder: Holder<PoiType> -> holder.`is`(CobblemonPoiTypes.POKE_SNACK_KEY) },
+            { true },
+            input.getCenter().toBlockPos(),
+            searchRange,
+            PoiManager.Occupancy.ANY
+        ).toList()
+
+        var highestLureTier = 0
+
+        for (lurePokeSnackPos in lurePokeSnackPositions) {
+            val blockState = world.getBlockState(lurePokeSnackPos)
+            if (blockState.block !is PokeSnackBlock) continue
+
+            val blockEntity = world.getBlockEntity(lurePokeSnackPos) as? PokeSnackBlockEntity ?: continue
+            val baitEffects = blockEntity.getBaitEffects()
+
+            highestLureTier = maxOf(highestLureTier, baitEffects.filter { it.type == SpawnBait.Effects.RARITY_BUCKET }.maxOfOrNull { it.value }?.toInt() ?: 0)
+
+            listOfInfluences.add(
+                SpatialSpawningZoneInfluence(
+                    pos = lurePokeSnackPos,
+                    radius = RANGE.toFloat(),
+                    influence = SpawnBaitInfluence(
+                        effects = baitEffects,
+                        onUsed = { usedAmount, entity ->
+                            entity?.let {
+                                // Prevent triggering twice on same entity
+                                if (usedAmount % 2 == 0) {
+                                    tryBite(world, lurePokeSnackPos)
+                                    moveAndApplyAspect(world, lurePokeSnackPos, entity)
+                                }
+                            }
+                        }
+                    )
+                )
+            )
+        }
+
+        if (highestLureTier > 0) {
+            listOfInfluences.add(UnconditionalSpawningZoneInfluence(influence = BucketNormalizingInfluence(tier = highestLureTier)))
+        }
+
+        return listOfInfluences
+    }
+
+    private fun tryBite(level: ServerLevel, blockPos: BlockPos) {
+       if (level.isLoaded(blockPos)) {
+           val blockState = level.getBlockState(blockPos)
+           val block = blockState.block as? PokeSnackBlock ?: return
+
+           block.eat(level, blockPos, blockState, null)
+        }
+    }
+
+    private fun moveAndApplyAspect(level: ServerLevel, blockPos: BlockPos, entity: PokemonEntity?) {
+        entity?.let {
+            entity.pokemon.forcedAspects += POKE_SNACK_CRUMBED_ASPECT
+            attemptSafeMove(level, blockPos, entity)
+        }
+    }
+
+    fun attemptSafeMove(level: ServerLevel, startPos: BlockPos, entity: PokemonEntity) {
+        val inWater = entity.isInWater
+        val maxDistance = 10  // maximum search radius
+        val maxPositions = 10 // maximum number of positions at the closest distance
+
+        var foundPositions: List<BlockPos> = emptyList()
+
+        // Search layer by layer, starting from the closest
+        for (distance in 1..maxDistance) {
+            val positionsAtThisDistance = mutableListOf<BlockPos>()
+
+            for (dx in -distance..distance) {
+                for (dy in -distance..distance) {
+                    for (dz in -distance..distance) {
+                        // Consider only positions on the surface of the cube at current distance
+                        if (listOf(dx, dy, dz).count { abs(it) != 0 } == distance) {
+                            val candidatePos = startPos.offset(dx, dy, dz)
+                            if (!candidatePos.equals(startPos.relative(Direction.UP))) {
+                                // Check collision
+                                val currentBox = entity.boundingBox.move(
+                                    candidatePos.x - entity.x,
+                                    candidatePos.y - entity.y,
+                                    candidatePos.z - entity.z
+                                )
+
+                                if (level.noCollision(entity, currentBox)) {
+                                    val blockBelowPos = candidatePos.below()
+                                    val blockState = level.getBlockState(blockBelowPos)
+
+                                    val isWater = blockState.block == Blocks.WATER
+                                    if (inWater) {
+                                        if (isWater) {
+                                            positionsAtThisDistance.add(candidatePos)
+                                        }
+                                    } else {
+                                        if (!blockState.isAir) {
+                                            positionsAtThisDistance.add(candidatePos)
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (positionsAtThisDistance.isNotEmpty()) {
+                // Limit to 10 nearest positions (all at this distance)
+                foundPositions = if (positionsAtThisDistance.size > maxPositions) {
+                    positionsAtThisDistance.shuffled().take(maxPositions)
+                } else {
+                    positionsAtThisDistance
+                }
+                break // Found the nearest layer with safe positions, stop expanding
+            }
+        }
+
+        if (foundPositions.isNotEmpty()) {
+            val chosenPos = foundPositions.random()
+            val centerX = chosenPos.x + 0.5
+            val centerZ = chosenPos.z + 0.5
+            entity.moveTo(Vec3(centerX, chosenPos.y.toDouble(), centerZ))
+
+            PokeSnackBlockParticlesPacket(startPos, chosenPos).sendToPlayersAround(
+                startPos.x.toDouble(),
+                startPos.y.toDouble(),
+                startPos.z.toDouble(),
+                64.0,
+                level.dimension()
+            )
+        }
+    }
+
+    override fun detectFromBlock(level: ServerLevel, pos: BlockPos, blockState: BlockState) = emptyList<SpawningZoneInfluence>()
+}

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

@@ -24,11 +24,6 @@ import com.cobblemon.mod.common.api.spawning.spawner.Spawner
  * @since January 31st, 2022
  */
 interface SpawningSelector<T : SpawnSelectionData> {
-    companion object {
-        @JvmField
-        val DEFAULT = FlatSpawnablePositionWeightedSelector()
-    }
-
     fun getSelectionData(spawner: Spawner, bucket: SpawnBucket, spawnablePositions: List<SpawnablePosition>): T
 
     fun selectSpawnAction(
@@ -37,12 +32,12 @@ interface SpawningSelector<T : SpawnSelectionData> {
         selectionData: T
     ): SpawnAction<*>?
 
-    fun select(spawner: Spawner, bucket: SpawnBucket, spawnablePositions: List<SpawnablePosition>, maxSpawns: Int): List<SpawnAction<*>> {
+    fun select(spawner: Spawner, bucket: SpawnBucket, spawnablePositions: List<SpawnablePosition>, max: Int): List<SpawnAction<*>> {
         val selectionData = getSelectionData(spawner, bucket, spawnablePositions)
 
         val spawnActions = selectionData.spawnActions
 
-        while (spawnActions.size < maxSpawns) {
+        while (spawnActions.size < max) {
             val spawnAction = selectSpawnAction(
                 spawner = spawner,
                 bucket = bucket,

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

@@ -0,0 +1,180 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.spawning.spawner
+
+import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.api.spawning.SpawnCause
+import com.cobblemon.mod.common.api.spawning.SpawnerManager
+import com.cobblemon.mod.common.api.spawning.position.AreaSpawnablePositionResolver
+import com.cobblemon.mod.common.api.spawning.position.calculators.AreaSpawnablePositionCalculator
+import com.cobblemon.mod.common.api.spawning.position.calculators.SpawnablePositionCalculator.Companion.prioritizedAreaCalculators
+import com.cobblemon.mod.common.api.spawning.detail.SpawnPool
+import com.cobblemon.mod.common.api.spawning.SpawningZoneGenerator
+import com.cobblemon.mod.common.api.spawning.detail.SpawnAction
+import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.util.isBoxLoaded
+import com.cobblemon.mod.common.util.squeezeWithinBounds
+import com.cobblemon.mod.common.util.toVec3f
+import net.minecraft.core.BlockPos
+import net.minecraft.core.SectionPos
+import net.minecraft.world.level.ChunkPos
+import net.minecraft.world.level.Level
+import net.minecraft.world.level.chunk.ChunkAccess
+import net.minecraft.world.level.chunk.status.ChunkStatus
+import net.minecraft.world.level.pathfinder.PathComputationType
+import net.minecraft.world.phys.AABB
+import net.minecraft.world.phys.Vec3
+
+/**
+ * A type of [TickingSpawner] that operates within some area. When this spawner type
+ * is told to do a spawning action, the subclass can provide a [SpawningZoneInput] to use.
+ * If a non-null value is returned, the [spawningZoneGenerator] and [spawnablePositionResolver] will be used to
+ * select a spawn and action it.
+ *
+ * Subclasses must implement the function retrieving what area to do the spawning in,
+ * but otherwise this class is feature-complete.
+ *
+ * @author Hiroku
+ * @since February 5th, 2022
+ */
+abstract class AreaSpawner(
+    name: String,
+    spawns: SpawnPool,
+    manager: SpawnerManager
+) : TickingSpawner(name, spawns, manager) {
+    abstract fun getZoneInput(cause: SpawnCause): SpawningZoneInput?
+
+    companion object {
+        const val CHUNK_REACH = 3
+    }
+
+    var spawningZoneGenerator: SpawningZoneGenerator = Cobblemon.spawningZoneGenerator
+    var spawnablePositionResolver: AreaSpawnablePositionResolver = Cobblemon.areaSpawnablePositionResolver
+    var spawnablePositionCalculators: List<AreaSpawnablePositionCalculator<*>> = prioritizedAreaCalculators
+
+    var spawnsPerPass: Int? = null
+
+    override fun run(cause: SpawnCause): List<SpawnAction<*>> {
+        val areaInput = getZoneInput(cause)
+        val constrainedArea = if (areaInput != null) constrainArea(areaInput) else null
+        if (constrainedArea != null) {
+
+            val areaBox = AABB.ofSize(
+                Vec3(constrainedArea.getCenter().toVec3f()),
+                CHUNK_REACH * 16.0 * 2,
+                1000.0,
+                CHUNK_REACH * 16.0 * 2
+            )
+
+            if (!constrainedArea.world.isBoxLoaded(areaBox)) {
+                return emptyList()
+            }
+
+            val numberNearby = constrainedArea.world.getEntitiesOfClass(
+                PokemonEntity::class.java,
+                areaBox,
+                PokemonEntity::countsTowardsSpawnCap
+            ).size
+
+            val chunksCovered = CHUNK_REACH * CHUNK_REACH
+            if (numberNearby.toFloat() / chunksCovered >= Cobblemon.config.pokemonPerChunk) {
+                return emptyList()
+            }
+
+            //val prospectStart = System.currentTimeMillis()
+            val zone = spawningZoneGenerator.generate(this, constrainedArea)
+            //val prospectEnd = System.currentTimeMillis()
+            val spawnablePositions = spawnablePositionResolver.resolve(this, spawnablePositionCalculators, zone)
+
+            val influences = this.getAllInfluences() + zone.unconditionalInfluences
+
+            val bucket = chooseBucket(cause, influences)
+            //val resolveEnd = System.currentTimeMillis()
+            //val prospectDuration = prospectEnd - prospectStart
+            //val resolveDuration = resolveEnd - prospectEnd
+            //println("Prospecting took: $prospectDuration ms. Resolution took: $resolveDuration ms")
+            // Takes about 3ms on my laptop to prospect, similar to spawnable position resolve - not very good, needs some thought
+            return getSpawningSelector().select(spawner = this, bucket = bucket, spawnablePositions = spawnablePositions, max = spawnsPerPass ?: Cobblemon.config.maximumSpawnsPerPass)
+        }
+
+        return emptyList()
+    }
+
+    fun isValidStartPoint(world: Level, chunk: ChunkAccess, startPos: BlockPos.MutableBlockPos): Boolean {
+        val y = startPos.y
+        if (!world.isLoaded(startPos) || !world.isLoaded(startPos.setY(y + 1))) {
+            return false
+        }
+
+        val mid = chunk.getBlockState(startPos.setY(y))
+        val above = chunk.getBlockState(startPos.setY(y + 1))
+
+        // Above must be non-solid
+         if (!above.isPathfindable(PathComputationType.AIR)) {
+             return false
+         }
+        // Position must be non-air
+        if (mid.isAir) {
+            return false
+        }
+
+        return true
+    }
+
+    fun constrainArea(area: SpawningZoneInput): SpawningZoneInput? {
+        val basePos = BlockPos.MutableBlockPos(area.baseX, area.baseY, area.baseZ)
+        val originalY = area.baseY
+
+        val (chunkX, chunkZ) = Pair(SectionPos.blockToSectionCoord(area.baseX), SectionPos.blockToSectionCoord(area.baseZ))
+
+        // if the chunk isn't loaded, we don't want to go further & we don't want the getChunk function below to load/create the chunk.
+        if (!area.world.areEntitiesLoaded(ChunkPos.asLong(chunkX, chunkZ))) return null
+
+        val chunk = area.world.getChunk(chunkX, chunkZ, ChunkStatus.FULL) ?: return null
+
+        var valid = isValidStartPoint(area.world, chunk, basePos)
+
+        if (!valid) {
+            var offset = 1
+            do {
+                if (isValidStartPoint(area.world, chunk, basePos.setY(originalY + offset))) {
+                    valid = true
+                    basePos.y = originalY + offset
+                    break
+                } else if (isValidStartPoint(area.world, chunk, basePos.setY(originalY - offset))) {
+                    valid = true
+                    basePos.y = originalY - offset
+                    break
+                }
+                offset++
+            } while (offset <= Cobblemon.config.maxVerticalCorrectionBlocks)
+        }
+
+        if (valid) {
+            val min = area.world.squeezeWithinBounds(basePos)
+            val max = area.world.squeezeWithinBounds(basePos.move(area.length, area.height, area.width))
+            if (area.world.isLoaded(min) && area.world.isLoaded(max) &&
+                min.x < max.x && min.y < max.y && min.z < max.z
+            ) {
+                return SpawningZoneInput(
+                    cause = area.cause,
+                    world = area.world,
+                    baseX = min.x,
+                    baseY = min.y,
+                    baseZ = min.z,
+                    length = max.x - min.x,
+                    height = max.y - min.y,
+                    width = max.z - min.z
+                )
+            }
+        }
+
+        return null
+    }
+}

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

@@ -1,34 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.api.spawning.spawner
-
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.api.spawning.SpawningZoneGenerator
-import com.cobblemon.mod.common.api.spawning.detail.SpawnPool
-import com.cobblemon.mod.common.api.spawning.influence.SpawningInfluence
-import com.cobblemon.mod.common.api.spawning.position.AreaSpawnablePositionResolver
-import com.cobblemon.mod.common.api.spawning.selection.SpawningSelector
-
-/**
- * A basic spawner implementation that uses Cobblemon's default algorithms for zone generation,
- * position resolving, and spawn selection.
- *
- * @author Hiroku
- * @since October 27th, 2025
- */
-open class BasicSpawner(
-    override val name: String,
-    override var spawnPool: SpawnPool,
-    override var maxPokemonPerChunk: Float = Cobblemon.config.pokemonPerChunk
-) : Spawner {
-    override var selector: SpawningSelector<*> = SpawningSelector.DEFAULT
-    override var generator: SpawningZoneGenerator = Cobblemon.spawningZoneGenerator
-    override var resolver: AreaSpawnablePositionResolver = Cobblemon.areaSpawnablePositionResolver
-    override val influences = mutableListOf<SpawningInfluence>()
-}

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

@@ -8,37 +8,33 @@
 
 package com.cobblemon.mod.common.api.spawning.spawner
 
-import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.api.spawning.SpawnCause
+import com.cobblemon.mod.common.api.spawning.SpawnerManager
 import com.cobblemon.mod.common.api.spawning.detail.SpawnPool
 import net.minecraft.server.level.ServerLevel
 import net.minecraft.core.BlockPos
 
 /**
- * A spawner that works within a fixed area. Instances provide the center point and the radii and then the spawner
- * can be told to [run] and it will spawn Pokémon within that area.
+ * A spawner that works within a fixed area, and ticks on its own. The location
+ * and size of the area is necessary for construction, but after that this spawner
+ * can be registered in a [SpawnerManager] and left to its own devices.
  *
  * @author Hiroku
  * @since February 5th, 2022
  */
 open class FixedAreaSpawner(
     name: String,
-    spawnPool: SpawnPool,
+    spawns: SpawnPool,
+    manager: SpawnerManager,
     val world: ServerLevel,
     val position: BlockPos,
     val horizontalRadius: Int,
     val verticalRadius: Int,
-    maxPokemonPerChunk: Float = Cobblemon.config.pokemonPerChunk
-) : BasicSpawner(name, spawnPool, maxPokemonPerChunk) {
-    fun run(cause: SpawnCause, maxSpawns: Int? = null): List<Any> {
-        return runForArea(
-            zoneInput = getZoneInput(cause),
-            maxSpawns = maxSpawns
-        )
-    }
-
-    fun getZoneInput(cause: SpawnCause): SpawningZoneInput {
+    override var ticksBetweenSpawns: Float = 20F
+) : AreaSpawner(name, spawns, manager) {
+    override fun getZoneInput(cause: SpawnCause): SpawningZoneInput? {
         val basePos = position.offset(-horizontalRadius, -verticalRadius, -horizontalRadius)
+
         return SpawningZoneInput(
             cause = cause,
             world = world,

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

@@ -10,6 +10,7 @@ package com.cobblemon.mod.common.api.spawning.spawner
 
 import com.cobblemon.mod.common.Cobblemon.config
 import com.cobblemon.mod.common.api.spawning.SpawnCause
+import com.cobblemon.mod.common.api.spawning.SpawnerManager
 import com.cobblemon.mod.common.api.spawning.detail.SpawnPool
 import com.cobblemon.mod.common.util.getPlayer
 import com.cobblemon.mod.common.util.nextBetween
@@ -30,16 +31,11 @@ import kotlin.random.Random
  * @author Hiroku
  * @since February 14th, 2022
  */
-class PlayerSpawner(
-    player: ServerPlayer,
-    spawnPool: SpawnPool
-) : BasicSpawner(
-    name = player.name.string,
-    spawnPool = spawnPool
-) {
+class PlayerSpawner(player: ServerPlayer, spawns: SpawnPool, manager: SpawnerManager) : AreaSpawner(player.name.string, spawns, manager) {
     val uuid: UUID = player.uuid
-
-    fun getZoneInput(cause: SpawnCause): SpawningZoneInput? {
+    override var ticksBetweenSpawns = config.ticksBetweenSpawnAttempts
+    override fun getCauseEntity() = uuid.getPlayer()
+    override fun getZoneInput(cause: SpawnCause): SpawningZoneInput? {
         val player = uuid.getPlayer() ?: return null
         val zoneDiameter = config.spawningZoneDiameter
         val zoneHeight = config.spawningZoneHeight
@@ -57,7 +53,6 @@ class PlayerSpawner(
         } else {
             thetatemp
         }
-
         val x = center.x + r * cos(theta)
         val z = center.z + r * sin(theta)
 
@@ -72,22 +67,4 @@ class PlayerSpawner(
             width = zoneDiameter
         )
     }
-
-    var active = true
-    var ticksUntilNextSpawn = 100F
-    var ticksBetweenSpawns: Float = config.ticksBetweenSpawnAttempts
-    var tickTimerMultiplier = 1F
-
-    fun tick() {
-        if (!active) {
-            return
-        }
-
-        ticksUntilNextSpawn -= tickTimerMultiplier
-        if (ticksUntilNextSpawn <= 0) {
-            val zoneInput = getZoneInput(cause = SpawnCause(spawner = this, entity = uuid.getPlayer()))
-            zoneInput?.let(::runForArea)
-            ticksUntilNextSpawn = ticksBetweenSpawns
-        }
-    }
 }

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

@@ -10,6 +10,7 @@ package com.cobblemon.mod.common.api.spawning.spawner
 
 import com.cobblemon.mod.common.api.spawning.CobblemonSpawnPools
 import com.cobblemon.mod.common.api.spawning.CobblemonSpawnRules
+import com.cobblemon.mod.common.api.spawning.SpawnerManager
 import com.cobblemon.mod.common.api.spawning.detail.SpawnPool
 import com.cobblemon.mod.common.api.spawning.influence.PlayerLevelRangeInfluence
 import com.cobblemon.mod.common.api.spawning.influence.PlayerLevelRangeInfluence.Companion.TYPICAL_VARIATION
@@ -27,7 +28,7 @@ import net.minecraft.server.level.ServerPlayer
  * @since February 14th, 2022
  */
 object PlayerSpawnerFactory {
-    var spawnPool: SpawnPool by mutableLazy {
+    var spawns: SpawnPool by mutableLazy {
         CobblemonSpawnPools.WORLD_SPAWN_POOL
     }
 
@@ -45,9 +46,9 @@ object PlayerSpawnerFactory {
         )
     })
 
-    fun create(player: ServerPlayer): PlayerSpawner {
+    fun create(spawnerManager: SpawnerManager, player: ServerPlayer): PlayerSpawner {
         val influences = influenceBuilders.mapNotNull { it(player) }
-        return PlayerSpawner(player, spawnPool).also {
+        return PlayerSpawner(player, spawns, spawnerManager).also {
             it.influences.addAll(influences)
             it.influences.addAll(
                 CobblemonSpawnRules.rules.values.filter(SpawnRule::enabled).flatMap(SpawnRule::components)

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

@@ -14,67 +14,33 @@ import com.cobblemon.mod.common.api.events.entity.SpawnBucketChosenEvent
 import com.cobblemon.mod.common.api.spawning.BestSpawner
 import com.cobblemon.mod.common.api.spawning.SpawnBucket
 import com.cobblemon.mod.common.api.spawning.SpawnCause
-import com.cobblemon.mod.common.api.spawning.SpawningZoneGenerator
-import com.cobblemon.mod.common.api.spawning.detail.EntitySpawnResult
 import com.cobblemon.mod.common.api.spawning.detail.SpawnAction
 import com.cobblemon.mod.common.api.spawning.detail.SpawnDetail
 import com.cobblemon.mod.common.api.spawning.detail.SpawnPool
 import com.cobblemon.mod.common.api.spawning.influence.SpawningInfluence
-import com.cobblemon.mod.common.api.spawning.position.AreaSpawnablePositionResolver
 import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
-import com.cobblemon.mod.common.api.spawning.position.calculators.SpawnablePositionCalculator.Companion.prioritizedAreaCalculators
 import com.cobblemon.mod.common.api.spawning.selection.SpawningSelector
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.isBoxLoaded
-import com.cobblemon.mod.common.util.squeezeWithinBounds
-import com.cobblemon.mod.common.util.toVec3f
 import com.cobblemon.mod.common.util.weightedSelection
-import kotlin.Any
-import kotlin.Boolean
-import kotlin.Float
-import kotlin.Int
-import kotlin.Pair
-import kotlin.String
-import kotlin.collections.plus
-import kotlin.math.max
-import net.minecraft.core.BlockPos
-import net.minecraft.core.SectionPos
-import net.minecraft.world.level.ChunkPos
-import net.minecraft.world.level.Level
-import net.minecraft.world.level.chunk.ChunkAccess
-import net.minecraft.world.level.chunk.status.ChunkStatus
-import net.minecraft.world.level.pathfinder.PathComputationType
-import net.minecraft.world.phys.AABB
-import net.minecraft.world.phys.Vec3
 
 /**
  * Interface representing something that performs the action of spawning. Various functions
  * exist to streamline the process of using the [BestSpawner].
  *
- * The simplest implementation is a [BasicSpawner]
- *
  * @author Hiroku
  * @since January 24th, 2022
  */
 interface Spawner {
     val name: String
     val influences: MutableList<SpawningInfluence>
-    var spawnPool: SpawnPool
-    var selector: SpawningSelector<*>
-    var generator: SpawningZoneGenerator
-    var resolver: AreaSpawnablePositionResolver
-    var maxPokemonPerChunk: Float
-
+    fun getSpawningSelector(): SpawningSelector<*>
+    fun setSpawningSelector(selector: SpawningSelector<*>)
+    fun getSpawnPool(): SpawnPool
+    fun setSpawnPool(spawnPool: SpawnPool)
     fun <R> afterSpawn(action: SpawnAction<R>, result: R) {}
 
-    companion object {
-        /** The chunk range radius over which spawning will roughly keep the entity density under control. */
-        const val ENTITY_LIMIT_CHUNK_RANGE = 3
-    }
-
     fun getMatchingSpawns(bucket: SpawnBucket, spawnablePosition: SpawnablePosition): List<SpawnDetail> {
         val spawns = mutableListOf<SpawnDetail>()
-        spawns.addAll(spawnPool.retrieve(bucket, spawnablePosition).filter { it.isSatisfiedBy(spawnablePosition) })
+        spawns.addAll(getSpawnPool().retrieve(bucket, spawnablePosition).filter { it.isSatisfiedBy(spawnablePosition) })
         spawnablePosition.influences.forEach { influence ->
             val influencedSpawns = influence.injectSpawns(bucket, spawnablePosition)
             if (influencedSpawns != null) {
@@ -84,101 +50,6 @@ interface Spawner {
         return spawns
     }
 
-    /**
-     * Runs the spawner for a specific [SpawnablePosition] and calculates a [SpawnAction] that could spawn there.
-     * This does not trigger the resulting spawn. You can trigger the spawn in the same action by running
-     * [runForPosition] instead or manually complete the [SpawnAction] it returns using [SpawnAction.complete].
-     */
-    fun calculateSpawnActionForPosition(
-        cause: SpawnCause,
-        spawnablePosition: SpawnablePosition,
-    ): SpawnAction<*>? {
-        influences.removeIf { it.isExpired() }
-        spawnablePosition.influences.addAll(influences)
-        val bucket = chooseBucket(cause, spawnablePosition.influences)
-        return selector.select(
-            spawner = this,
-            bucket = bucket,
-            spawnablePositions = listOf(spawnablePosition),
-            maxSpawns = 1
-        ).firstOrNull()
-    }
-
-    fun calculateSpawnActionsForArea(
-        zoneInput: SpawningZoneInput,
-        maxSpawns: Int?
-    ): List<SpawnAction<*>> {
-        val maxSpawns = maxSpawns ?: Cobblemon.config.maximumSpawnsPerPass
-        influences.removeIf { it.isExpired() }
-
-        val constrainedArea = constrainArea(zoneInput)
-            ?: return emptyList()
-
-        val areaBox = AABB.ofSize(
-            Vec3(constrainedArea.getCenter().toVec3f()),
-            ENTITY_LIMIT_CHUNK_RANGE * 16.0 * 2,
-            1000.0,
-            ENTITY_LIMIT_CHUNK_RANGE * 16.0 * 2
-        )
-
-        if (!constrainedArea.world.isBoxLoaded(areaBox)) {
-            return emptyList()
-        }
-
-        val numberNearby = constrainedArea.world.getEntitiesOfClass(
-            PokemonEntity::class.java,
-            areaBox,
-            PokemonEntity::countsTowardsSpawnCap
-        ).size
-
-        val chunksCovered = ENTITY_LIMIT_CHUNK_RANGE * ENTITY_LIMIT_CHUNK_RANGE
-        val maxPokemonPerChunk = max(Cobblemon.config.pokemonPerChunk, zoneInput.cause.spawner.maxPokemonPerChunk)
-        if (numberNearby.toFloat() / chunksCovered >= maxPokemonPerChunk) {
-            return emptyList()
-        }
-
-        val zone = generator.generate(this, constrainedArea)
-        val spawnablePositions = resolver.resolve(this, prioritizedAreaCalculators, zone)
-        val influences = influences + zone.unconditionalInfluences
-        val bucket = chooseBucket(zoneInput.cause, influences)
-
-        return selector.select(
-            spawner = this,
-            bucket = bucket,
-            spawnablePositions = spawnablePositions,
-            maxSpawns = maxSpawns
-        )
-    }
-
-    /**
-     * Runs the spawner at the given [SpawnablePosition] and returns whatever the calculated [SpawnAction] produces,
-     * if any spawn occurred. For most implementations of [SpawnAction], the resulting type is
-     * [EntitySpawnResult]. Technically you can make spawns for anything though.
-     */
-    fun runForPosition(
-        cause: SpawnCause,
-        spawnablePosition: SpawnablePosition
-    ): Any? {
-        val action = calculateSpawnActionForPosition(
-            cause = cause,
-            spawnablePosition = spawnablePosition
-        ) ?: return null
-
-        return action.complete()
-    }
-
-    fun runForArea(
-        zoneInput: SpawningZoneInput,
-        maxSpawns: Int? = null
-    ): List<Any> {
-        val spawnActions = calculateSpawnActionsForArea(zoneInput = zoneInput, maxSpawns = maxSpawns)
-        val results = mutableListOf<Any>()
-        for (spawnAction in spawnActions) {
-            spawnAction.complete()?.let(results::add)
-        }
-        return results
-    }
-
     fun copyInfluences() = influences.filter { !it.isExpired() }.toMutableList()
 
     fun chooseBucket(cause: SpawnCause, influences: List<SpawningInfluence>): SpawnBucket {
@@ -195,77 +66,4 @@ interface Spawner {
         CobblemonEvents.SPAWN_BUCKET_CHOSEN.post(event)
         return event.bucket
     }
-
-    fun isValidStartPoint(world: Level, chunk: ChunkAccess, startPos: BlockPos.MutableBlockPos): Boolean {
-        val y = startPos.y
-        if (!world.isLoaded(startPos) || !world.isLoaded(startPos.setY(y + 1))) {
-            return false
-        }
-
-        val mid = chunk.getBlockState(startPos.setY(y))
-        val above = chunk.getBlockState(startPos.setY(y + 1))
-
-        // Above must be non-solid
-        if (!above.isPathfindable(PathComputationType.AIR)) {
-            return false
-        }
-
-        // Position must be non-air
-        if (mid.isAir) {
-            return false
-        }
-
-        return true
-    }
-
-    fun constrainArea(area: SpawningZoneInput): SpawningZoneInput? {
-        val basePos = BlockPos.MutableBlockPos(area.baseX, area.baseY, area.baseZ)
-        val originalY = area.baseY
-
-        val (chunkX, chunkZ) = Pair(SectionPos.blockToSectionCoord(area.baseX), SectionPos.blockToSectionCoord(area.baseZ))
-
-        // if the chunk isn't loaded, we don't want to go further & we don't want the getChunk function below to load/create the chunk.
-        if (!area.world.areEntitiesLoaded(ChunkPos.asLong(chunkX, chunkZ))) return null
-
-        val chunk = area.world.getChunk(chunkX, chunkZ, ChunkStatus.FULL) ?: return null
-
-        var valid = isValidStartPoint(area.world, chunk, basePos)
-
-        if (!valid) {
-            var offset = 1
-            do {
-                if (isValidStartPoint(area.world, chunk, basePos.setY(originalY + offset))) {
-                    valid = true
-                    basePos.y = originalY + offset
-                    break
-                } else if (isValidStartPoint(area.world, chunk, basePos.setY(originalY - offset))) {
-                    valid = true
-                    basePos.y = originalY - offset
-                    break
-                }
-                offset++
-            } while (offset <= Cobblemon.config.maxVerticalCorrectionBlocks)
-        }
-
-        if (valid) {
-            val min = area.world.squeezeWithinBounds(basePos)
-            val max = area.world.squeezeWithinBounds(basePos.move(area.length, area.height, area.width))
-            if (area.world.isLoaded(min) && area.world.isLoaded(max) &&
-                min.x < max.x && min.y < max.y && min.z < max.z
-            ) {
-                return SpawningZoneInput(
-                    cause = area.cause,
-                    world = area.world,
-                    baseX = min.x,
-                    baseY = min.y,
-                    baseZ = min.z,
-                    length = max.x - min.x,
-                    height = max.y - min.y,
-                    width = max.z - min.z
-                )
-            }
-        }
-
-        return null
-    }
 }

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

@@ -0,0 +1,89 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.spawning.spawner
+
+import com.cobblemon.mod.common.api.spawning.SpawnCause
+import com.cobblemon.mod.common.api.spawning.SpawnerManager
+import com.cobblemon.mod.common.api.spawning.detail.EntitySpawnResult
+import com.cobblemon.mod.common.api.spawning.detail.SpawnAction
+import com.cobblemon.mod.common.api.spawning.detail.SpawnPool
+import com.cobblemon.mod.common.api.spawning.influence.SpawningInfluence
+import com.cobblemon.mod.common.api.spawning.selection.FlatSpawnablePositionWeightedSelector
+import com.cobblemon.mod.common.api.spawning.selection.SpawningSelector
+import net.minecraft.world.entity.Entity
+
+/**
+ * A spawner that regularly attempts spawning entities. It has timing utilities,
+ * and subclasses must provide the logic for generating a spawn which is called
+ * periodically by the server.
+ *
+ * @author Hiroku
+ * @since February 5th, 2022
+ */
+abstract class TickingSpawner(
+    override val name: String,
+    var spawns: SpawnPool,
+    val manager: SpawnerManager
+) : Spawner {
+    private var selector: SpawningSelector<*> = FlatSpawnablePositionWeightedSelector()
+    override val influences = mutableListOf<SpawningInfluence>()
+
+    override fun getSpawningSelector() = selector
+    override fun setSpawningSelector(selector: SpawningSelector<*>) { this.selector = selector }
+    override fun getSpawnPool() = spawns
+    override fun setSpawnPool(spawnPool: SpawnPool) { spawns = spawnPool }
+
+    abstract fun run(cause: SpawnCause): List<SpawnAction<*>>
+
+    var active = true
+    val spawnedEntities = mutableListOf<Entity>()
+
+    var lastSpawnTime = 0L
+    var ticksUntilNextSpawn = 100F
+    abstract var ticksBetweenSpawns: Float
+    var tickTimerMultiplier = 1F
+
+    var removalCheckTicks = 0
+
+    open fun tick() {
+        removalCheckTicks++
+        influences.removeIf { it.isExpired() }
+        if (removalCheckTicks == 60) {
+            spawnedEntities.removeIf { it.isRemoved }
+            removalCheckTicks = 0
+        }
+
+        if (!active) {
+            return
+        }
+
+        ticksUntilNextSpawn -= tickTimerMultiplier
+        if (ticksUntilNextSpawn <= 0) {
+            val spawnActions = run(cause = SpawnCause(spawner = this, entity = getCauseEntity()))
+            ticksUntilNextSpawn = ticksBetweenSpawns
+            for (spawnAction in spawnActions) {
+                spawnAction.complete()
+            }
+        }
+    }
+
+    override fun <R> afterSpawn(action: SpawnAction<R>, result: R) {
+        super.afterSpawn(action, result)
+        if (result is EntitySpawnResult) {
+            spawnedEntities.addAll(result.entities)
+        }
+        lastSpawnTime = System.currentTimeMillis()
+    }
+
+    open fun getCauseEntity(): Entity? = null
+
+    fun getAllInfluences() = this.influences + manager.influences
+
+    override fun copyInfluences() = this.getAllInfluences().toMutableList()
+}

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

@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.api.spawning.spawner
+
+import com.cobblemon.mod.common.api.spawning.SpawnCause
+import com.cobblemon.mod.common.api.spawning.detail.SpawnAction
+import com.cobblemon.mod.common.api.spawning.detail.SpawnPool
+import com.cobblemon.mod.common.api.spawning.influence.SpawningInfluence
+import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
+import com.cobblemon.mod.common.api.spawning.selection.FlatSpawnablePositionWeightedSelector
+import com.cobblemon.mod.common.api.spawning.selection.SpawningSelector
+import net.minecraft.core.BlockPos
+import net.minecraft.server.level.ServerLevel
+
+/**
+ * A type of spawner that occurs at a single point and provides its own means of generating a
+ * spawnable position from a particular cause and position. The trigger spawner must be directly called to
+ * spawn things (almost as if it was being triggered!!!) as opposed to being scheduled on a ticker.
+ *
+ * @author Hiroku
+ * @since February 3rd, 2024
+ */
+abstract class TriggerSpawner<T : SpawnCause>(override val name: String, var spawns: SpawnPool) : Spawner {
+    private var selector: SpawningSelector<*> = FlatSpawnablePositionWeightedSelector()
+    override val influences = mutableListOf<SpawningInfluence>()
+
+    open fun getSpawnAction(
+        cause: T,
+        world: ServerLevel,
+        pos: BlockPos,
+        influences: List<SpawningInfluence> = emptyList()
+    ): SpawnAction<*>? {
+        val spawnablePosition = parseSpawnablePosition(cause, world, pos) ?: return null
+        spawnablePosition.influences.addAll(influences)
+        val bucket = chooseBucket(cause, spawnablePosition.influences)
+        return selector.select(this, bucket, listOf(spawnablePosition), max = 1).firstOrNull()
+    }
+
+    /** Parses a spawnable position, if possible, from the given cause and position. */
+    abstract fun parseSpawnablePosition(cause: T, world: ServerLevel, pos: BlockPos): SpawnablePosition?
+
+    override fun getSpawningSelector() = selector
+    override fun setSpawningSelector(selector: SpawningSelector<*>) { this.selector = selector }
+    override fun getSpawnPool() = spawns
+    override fun setSpawnPool(spawnPool: SpawnPool) { spawns = spawnPool }
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/tags/CobblemonItemTags.kt

@@ -137,9 +137,6 @@ object CobblemonItemTags {
     @JvmField val WEARABLE_HAT_ITEMS = create("held/visibility/hat")
     @JvmField val HIDDEN_ITEMS = create("held/visibility/hidden")
 
-    //Empty Tag
-    @JvmField val EMPTY = create("empty")
-
 
     private fun create(path: String) = TagKey.create(Registries.ITEM, cobblemonResource(path))
 

common/src/main/kotlin/com/cobblemon/mod/common/block/PokeSnackBlock.kt

@@ -18,7 +18,6 @@ import net.minecraft.core.BlockPos
 import net.minecraft.core.particles.BlockParticleOption
 import net.minecraft.core.particles.ColorParticleOption
 import net.minecraft.core.particles.ParticleTypes
-import net.minecraft.server.level.ServerLevel
 import net.minecraft.sounds.SoundEvents
 import net.minecraft.sounds.SoundSource
 import net.minecraft.stats.Stats
@@ -141,14 +140,13 @@ class PokeSnackBlock(settings: Properties, val isLure: Boolean): BaseEntityBlock
         return SHAPES[state.getValue(BITES)]
     }
 
-    override fun getRenderShape(blockState: BlockState) = RenderShape.MODEL
+    override fun getRenderShape(blockState: BlockState?) = RenderShape.MODEL
 
     override fun setPlacedBy(level: Level, pos: BlockPos, state: BlockState, placer: LivingEntity?, stack: ItemStack) {
         super.setPlacedBy(level, pos, state, placer, stack)
 
-        val blockEntity = level.getBlockEntity(pos) as? PokeSnackBlockEntity ?: return
-        blockEntity.initializeFromItemStack(stack)
-        blockEntity.placedBy = placer?.uuid
+        val blockEntity = level.getBlockEntity(pos) as? PokeSnackBlockEntity
+        blockEntity?.initializeFromItemStack(stack)
     }
 
     override fun getCloneItemStack(level: LevelReader, pos: BlockPos, state: BlockState): ItemStack {
@@ -310,7 +308,6 @@ class PokeSnackBlock(settings: Properties, val isLure: Boolean): BaseEntityBlock
 
         if (newBites > MAX_BITES) {
             dropCandle(level, pos, state, player)
-
             level.removeBlock(pos, false)
             level.removeBlockEntity(pos)
         } else {
@@ -369,19 +366,8 @@ class PokeSnackBlock(settings: Properties, val isLure: Boolean): BaseEntityBlock
                 0.0,
                 0.0,
                 0.0
+
             )
         }
     }
-
-    override fun isRandomlyTicking(state: BlockState) = isLure
-
-    override fun randomTick(
-        state: BlockState,
-        level: ServerLevel,
-        pos: BlockPos,
-        random: RandomSource
-    ) {
-        if (level.isClientSide) return
-        (level.getBlockEntity(pos) as? PokeSnackBlockEntity)?.randomTick()
-    }
 }

common/src/main/kotlin/com/cobblemon/mod/common/block/campfirepot/CookingPotMenu.kt

@@ -52,8 +52,8 @@ class CookingPotMenu : RecipeBookMenu<CraftingInput, CookingPotRecipeBase>, Cont
     constructor(containerId: Int, playerInventory: Inventory) : super(CobblemonMenuType.COOKING_POT, containerId) {
         this.playerInventory = playerInventory
         this.container = CookingPotContainer(this,
-            CampfireBlockEntity.CRAFTING_GRID_WIDTH,
-            CampfireBlockEntity.CRAFTING_GRID_WIDTH
+            CampfireBlockEntity.Companion.CRAFTING_GRID_WIDTH,
+            CampfireBlockEntity.Companion.CRAFTING_GRID_WIDTH
         )
         this.resultContainer = ResultContainer()
         this.containerData = SimpleContainerData(4)
@@ -82,25 +82,25 @@ class CookingPotMenu : RecipeBookMenu<CraftingInput, CookingPotRecipeBase>, Cont
         val resultSlotX = 128
         val resultSlotY = 55
 
-        addSlot(CookingPotResultSlot(this.container, CampfireBlockEntity.RESULT_SLOT, resultSlotX, resultSlotY))
+        addSlot(CookingPotResultSlot(this.container, CampfireBlockEntity.Companion.RESULT_SLOT, resultSlotX, resultSlotY))
 
-        for ((index, slotIndex) in CampfireBlockEntity.CRAFTING_GRID_SLOTS.withIndex()) {
-            val i = index / CampfireBlockEntity.CRAFTING_GRID_WIDTH
-            val j = index % CampfireBlockEntity.CRAFTING_GRID_WIDTH
+        for ((index, slotIndex) in CampfireBlockEntity.Companion.CRAFTING_GRID_SLOTS.withIndex()) {
+            val i = index / CampfireBlockEntity.Companion.CRAFTING_GRID_WIDTH
+            val j = index % CampfireBlockEntity.Companion.CRAFTING_GRID_WIDTH
             addSlot(Slot(this.container, slotIndex, 33 + j * 18, 18 + i * 18))
         }
 
-        for ((index, slotIndex) in CampfireBlockEntity.SEASONING_SLOTS.withIndex()) {
-            addSlot(SeasoningSlot(this, this.container, slotIndex, 110 + index * 18, 18))
+        for ((index, slotIndex) in CampfireBlockEntity.Companion.SEASONING_SLOTS.withIndex()) {
+            addSlot(SeasoningSlot(this.container, slotIndex, 110 + index * 18, 18))
         }
 
-        for ((index, _) in CampfireBlockEntity.PLAYER_INVENTORY_SLOTS.withIndex()) {
-            val i = index / CampfireBlockEntity.PLAYER_INVENTORY_WIDTH
-            val j = index % CampfireBlockEntity.PLAYER_INVENTORY_WIDTH
+        for ((index, _) in CampfireBlockEntity.Companion.PLAYER_INVENTORY_SLOTS.withIndex()) {
+            val i = index / CampfireBlockEntity.Companion.PLAYER_INVENTORY_WIDTH
+            val j = index % CampfireBlockEntity.Companion.PLAYER_INVENTORY_WIDTH
             addSlot(Slot(playerInventory, index + 9, 8 + j * 18, 84 + i * 18))
         }
 
-        for ((index, _) in CampfireBlockEntity.PLAYER_HOTBAR_SLOTS.withIndex()) {
+        for ((index, _) in CampfireBlockEntity.Companion.PLAYER_HOTBAR_SLOTS.withIndex()) {
             addSlot(Slot(playerInventory, index, 8 + index * 18, 142))
         }
     }
@@ -173,31 +173,29 @@ class CookingPotMenu : RecipeBookMenu<CraftingInput, CookingPotRecipeBase>, Cont
         currentActiveRecipe = recipe
         if (recipe != null) {
             previewItem = recipe.value.assemble(craftInput, level.registryAccess())
-            // Apply seasoning to the preview item
             recipe.value.applySeasoning(
                 previewItem,
                 container.items.subList(CampfireBlockEntity.SEASONING_SLOTS.first,
                     CampfireBlockEntity.SEASONING_SLOTS.last + 1)
                     .filterNotNull()
-                    .filter { !it.isEmpty && it.`is`(recipe.value.seasoningTag) })
-
+                    .filter { !it.isEmpty })
         } else previewItem = ItemStack.EMPTY
     }
 
     override fun getResultSlotIndex(): Int {
-        return CampfireBlockEntity.RESULT_SLOT
+        return CampfireBlockEntity.Companion.RESULT_SLOT
     }
 
     override fun getGridWidth(): Int {
-        return CampfireBlockEntity.CRAFTING_GRID_WIDTH
+        return CampfireBlockEntity.Companion.CRAFTING_GRID_WIDTH
     }
 
     override fun getGridHeight(): Int {
-        return CampfireBlockEntity.CRAFTING_GRID_WIDTH
+        return CampfireBlockEntity.Companion.CRAFTING_GRID_WIDTH
     }
 
     override fun getSize(): Int {
-        return CampfireBlockEntity.ITEMS_SIZE
+        return CampfireBlockEntity.Companion.ITEMS_SIZE
     }
 
     fun getBurnProgress(): Float {
@@ -229,24 +227,24 @@ class CookingPotMenu : RecipeBookMenu<CraftingInput, CookingPotRecipeBase>, Cont
             val slotItemStack = slot.item
             itemStack = slotItemStack.copy()
 
-            if (index == CampfireBlockEntity.RESULT_SLOT) {
-                if (!this.moveItemStackTo(slotItemStack, CampfireBlockEntity.PLAYER_INVENTORY_SLOTS.first, CampfireBlockEntity.PLAYER_HOTBAR_SLOTS.last + 1, false)) {
+            if (index == CampfireBlockEntity.Companion.RESULT_SLOT) {
+                if (!this.moveItemStackTo(slotItemStack, CampfireBlockEntity.Companion.PLAYER_INVENTORY_SLOTS.first, CampfireBlockEntity.Companion.PLAYER_HOTBAR_SLOTS.last + 1, false)) {
                     return ItemStack.EMPTY
                 }
 
                 slot.onQuickCraft(slotItemStack, itemStack);
-            } else if (index in CampfireBlockEntity.PLAYER_INVENTORY_SLOTS || index in CampfireBlockEntity.PLAYER_HOTBAR_SLOTS) {
+            } else if (index in CampfireBlockEntity.Companion.PLAYER_INVENTORY_SLOTS || index in CampfireBlockEntity.Companion.PLAYER_HOTBAR_SLOTS) {
                 if (Seasonings.isSeasoning(slotItemStack)) {
-                    if (!this.moveItemStackTo(slotItemStack, CampfireBlockEntity.CRAFTING_GRID_SLOTS.first, CampfireBlockEntity.CRAFTING_GRID_SLOTS.last + 1, false) &&
-                        !this.moveItemStackTo(slotItemStack, CampfireBlockEntity.SEASONING_SLOTS.first, CampfireBlockEntity.SEASONING_SLOTS.last + 1, false)
+                    if (!this.moveItemStackTo(slotItemStack, CampfireBlockEntity.Companion.CRAFTING_GRID_SLOTS.first, CampfireBlockEntity.Companion.CRAFTING_GRID_SLOTS.last + 1, false) &&
+                        !this.moveItemStackTo(slotItemStack, CampfireBlockEntity.Companion.SEASONING_SLOTS.first, CampfireBlockEntity.Companion.SEASONING_SLOTS.last + 1, false)
                     ) {
                         return ItemStack.EMPTY
                     }
-                } else if (!this.moveItemStackTo(slotItemStack, CampfireBlockEntity.CRAFTING_GRID_SLOTS.first, CampfireBlockEntity.CRAFTING_GRID_SLOTS.last + 1, false)) {
+                } else if (!this.moveItemStackTo(slotItemStack, CampfireBlockEntity.Companion.CRAFTING_GRID_SLOTS.first, CampfireBlockEntity.Companion.CRAFTING_GRID_SLOTS.last + 1, false)) {
                     return ItemStack.EMPTY
                 }
-            } else if (index in CampfireBlockEntity.CRAFTING_GRID_SLOTS || index in CampfireBlockEntity.SEASONING_SLOTS) {
-                if (!this.moveItemStackTo(slotItemStack, CampfireBlockEntity.PLAYER_INVENTORY_SLOTS.first, CampfireBlockEntity.PLAYER_HOTBAR_SLOTS.last + 1, false)) {
+            } else if (index in CampfireBlockEntity.Companion.CRAFTING_GRID_SLOTS || index in CampfireBlockEntity.Companion.SEASONING_SLOTS) {
+                if (!this.moveItemStackTo(slotItemStack, CampfireBlockEntity.Companion.PLAYER_INVENTORY_SLOTS.first, CampfireBlockEntity.Companion.PLAYER_HOTBAR_SLOTS.last + 1, false)) {
                     return ItemStack.EMPTY
                 }
             }

common/src/main/kotlin/com/cobblemon/mod/common/block/campfirepot/SeasoningSlot.kt

@@ -8,13 +8,13 @@
 
 package com.cobblemon.mod.common.block.campfirepot
 
+import com.cobblemon.mod.common.api.cooking.Seasonings
 import net.minecraft.world.Container
 import net.minecraft.world.inventory.Slot
 import net.minecraft.world.item.ItemStack
 
-class SeasoningSlot(val menu: CookingPotMenu, container: Container, slot: Int, x: Int, y: Int) : Slot(container, slot, x, y) {
+class SeasoningSlot(container: Container, slot: Int, x: Int, y: Int) : Slot(container, slot, x, y) {
     override fun mayPlace(stack: ItemStack): Boolean {
-        val recipe = menu.currentActiveRecipe?.value() ?: return false
-        return stack.`is`(recipe.seasoningTag) && super.mayPlace(stack)
+        return Seasonings.isSeasoning(stack) && super.mayPlace(stack)
     }
 }

common/src/main/kotlin/com/cobblemon/mod/common/block/entity/CampfireBlockEntity.kt

@@ -168,7 +168,7 @@ class CampfireBlockEntity(pos: BlockPos, state: BlockState) : BaseContainerBlock
                 val cookedItem = recipe.assemble(craftingInput, level.registryAccess())
                 val resultSlotItem = campfireBlockEntity.getItem(0)
 
-                recipe.applySeasoning(cookedItem, campfireBlockEntity.getSeasonings().filter { it.`is`(recipe.seasoningTag) })
+                recipe.applySeasoning(cookedItem, campfireBlockEntity.getSeasonings())
 
                 if (!campfireBlockEntity.blockState.getValue(CampfireBlock.LID)) {
                     campfireBlockEntity.cookingProgress = 0
@@ -314,7 +314,7 @@ class CampfireBlockEntity(pos: BlockPos, state: BlockState) : BaseContainerBlock
             consumeItem(i)
         }
         for (i in SEASONING_SLOTS.first..SEASONING_SLOTS.last) {
-            if (getItem(i).`is`(recipe.seasoningTag) && recipe.seasoningProcessors.any { it.consumesItem(getItem(i)) }) consumeItem(i)
+            if (recipe.seasoningProcessors.any { it.consumesItem(getItem(i)) }) consumeItem(i)
         }
 
         val direction = state.getValue(CampfireBlock.ITEM_DIRECTION)

common/src/main/kotlin/com/cobblemon/mod/common/block/entity/PokeSnackBlockEntity.kt

@@ -8,118 +8,34 @@
 
 package com.cobblemon.mod.common.block.entity
 
-import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.CobblemonBlockEntities
 import com.cobblemon.mod.common.CobblemonItemComponents
 import com.cobblemon.mod.common.api.cooking.getColourMixFromFlavours
 import com.cobblemon.mod.common.api.fishing.SpawnBait
 import com.cobblemon.mod.common.api.fishing.SpawnBait.Effect
 import com.cobblemon.mod.common.api.fishing.SpawnBaitEffects
-import com.cobblemon.mod.common.api.spawning.CobblemonSpawnPools
-import com.cobblemon.mod.common.api.spawning.SpawnCause
-import com.cobblemon.mod.common.api.spawning.detail.PokemonHerdSpawnDetail
-import com.cobblemon.mod.common.api.spawning.detail.SpawnAction
-import com.cobblemon.mod.common.api.spawning.detail.SpawnDetail
-import com.cobblemon.mod.common.api.spawning.influence.BucketMultiplyingInfluence
-import com.cobblemon.mod.common.api.spawning.influence.BucketNormalizingInfluence
-import com.cobblemon.mod.common.api.spawning.influence.SpawnBaitInfluence
-import com.cobblemon.mod.common.api.spawning.influence.SpawningInfluence
-import com.cobblemon.mod.common.api.spawning.position.SpawnablePosition
-import com.cobblemon.mod.common.api.spawning.spawner.FixedAreaSpawner
 import com.cobblemon.mod.common.block.PokeSnackBlock
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.item.components.BaitEffectsComponent
 import com.cobblemon.mod.common.item.components.FlavourComponent
 import com.cobblemon.mod.common.item.components.IngredientComponent
-import com.cobblemon.mod.common.net.messages.client.effect.PokeSnackBlockParticlesPacket
 import com.cobblemon.mod.common.util.DataKeys
-import java.util.UUID
 import net.minecraft.core.BlockPos
 import net.minecraft.core.HolderLookup
-import net.minecraft.nbt.CompoundTag
-import net.minecraft.nbt.NbtOps
-import net.minecraft.server.level.ServerLevel
-import net.minecraft.world.entity.Entity
-import net.minecraft.world.entity.player.Player
+import net.minecraft.nbt.*
 import net.minecraft.world.item.ItemStack
 import net.minecraft.world.level.block.state.BlockState
+import kotlin.collections.orEmpty
 
-open class PokeSnackBlockEntity(pos: BlockPos, state: BlockState) :
-    TintBlockEntity(CobblemonBlockEntities.POKE_SNACK, pos, state),
-    SpawningInfluence {
+open class PokeSnackBlockEntity(pos: BlockPos, state: BlockState) : TintBlockEntity(CobblemonBlockEntities.POKE_SNACK, pos, state) {
 
     companion object {
-        const val SPAWNS_PER_BITE = 1
-        const val RADIUS = 8
-        const val RANDOM_TICKS_BETWEEN_SPAWNS = 4
-        const val POKE_SNACK_CRUMBED_ASPECT = "poke_snack_crumbed"
+        const val SPAWNS_PER_BITE = 4
     }
 
-    val spawner: FixedAreaSpawner by lazy {
-        FixedAreaSpawner(
-            name = "poke_snack_spawner_${level?.dimension()?.location()}}_$blockPos",
-            spawnPool = CobblemonSpawnPools.WORLD_SPAWN_POOL,
-            world = level as ServerLevel,
-            position = blockPos,
-            horizontalRadius = RADIUS,
-            verticalRadius = RADIUS,
-            maxPokemonPerChunk = Cobblemon.config.pokeSnackPokemonPerChunk
-        ).also {
-            it.influences.add(this)
-
-            val baitEffects = getBaitEffects()
-
-            val highestLureTier = baitEffects
-                .filter { it.type == SpawnBait.Effects.RARITY_BUCKET }
-                .maxOfOrNull { it.value }
-                ?.toInt()
-                ?: 0
-
-            if (highestLureTier > 0) {
-                it.influences += BucketNormalizingInfluence(tier = highestLureTier)
-            }
-
-            it.influences += BucketMultiplyingInfluence(
-                mapOf(
-                    "uncommon" to 2.25f,
-                    "rare" to 5.5f,
-                    "ultra-rare" to 5.5f,
-                )
-            )
-
-            it.influences += SpawnBaitInfluence(effects = baitEffects)
-        }
-    }
-
-    // Only non-herd Pokémon can be spawned from a Poké Snack
-    override fun affectSpawnable(detail: SpawnDetail, spawnablePosition: SpawnablePosition) = detail.type in SpawnDetail.pokemonTypes && detail !is PokemonHerdSpawnDetail
-
-    // When a Pokémon spawns, apply the crumbed aspect and play the eating effects. Eat part of the cake, too.
-    override fun affectSpawn(action: SpawnAction<*>, entity: Entity) {
-        if (entity is PokemonEntity) {
-            entity.pokemon.forcedAspects += POKE_SNACK_CRUMBED_ASPECT
-            val block = blockState.block as? PokeSnackBlock ?: return
-            val level = level ?: return
-            val entityPos = entity.blockPosition()
-
-            PokeSnackBlockParticlesPacket(blockPos, entityPos).sendToPlayersAround(
-                blockPos.x.toDouble(),
-                blockPos.y.toDouble(),
-                blockPos.z.toDouble(),
-                64.0,
-                level.dimension(),
-            )
-
-            block.eat(level, blockPos, blockState, action.spawnablePosition.cause.entity as? Player)
-        }
-    }
-
-    var placedBy: UUID? = null
     var amountSpawned: Int = 0
     var flavourComponent: FlavourComponent? = null
     var baitEffectsComponent: BaitEffectsComponent? = null
     var ingredientComponent: IngredientComponent? = null
-    var randomTicksUntilNextSpawn: Float = getRandomTicksBetweenSpawns()
 
     fun initializeFromItemStack(itemStack: ItemStack) {
         flavourComponent = itemStack.get(CobblemonItemComponents.FLAVOUR)
@@ -127,7 +43,9 @@ open class PokeSnackBlockEntity(pos: BlockPos, state: BlockState) :
         if (isLure()) baitEffectsComponent = itemStack.get(CobblemonItemComponents.BAIT_EFFECTS)
 
         flavourComponent?.let {
-            getColourMixFromFlavours(it.getDominantFlavours())?.let(::setTint)
+            getColourMixFromFlavours(it.getDominantFlavours())?.let {
+                setTint(it)
+            }
         }
     }
 
@@ -139,45 +57,6 @@ open class PokeSnackBlockEntity(pos: BlockPos, state: BlockState) :
         return false
     }
 
-    fun randomTick() {
-        randomTicksUntilNextSpawn--
-        if (randomTicksUntilNextSpawn <= 0) {
-            val nearestPlayer = level?.getNearestPlayer(
-                blockPos.x.toDouble(),
-                blockPos.y.toDouble(),
-                blockPos.z.toDouble(),
-                Cobblemon.config.maximumSpawningZoneDistanceFromPlayer.toDouble(),
-                false, // true here makes it so creative players aren't considered
-            )
-            // High simulation distances may cause the player to be null here, we don't want to spawn without a player nearby.
-            if (nearestPlayer != null) {
-                spawner.run(
-                    cause = SpawnCause(spawner = spawner, entity = nearestPlayer),
-                    maxSpawns = 1
-                )
-            }
-            randomTicksUntilNextSpawn = getRandomTicksBetweenSpawns()
-        }
-    }
-
-    fun getRandomTicksBetweenSpawns(): Float {
-        val biteTimeMultiplier = getBiteTimeMultiplier()
-        return (RANDOM_TICKS_BETWEEN_SPAWNS * biteTimeMultiplier).coerceAtLeast(1F)
-    }
-
-    fun getBiteTimeMultiplier(): Float {
-        val baitEffects = getBaitEffects()
-        val biteTimeEffects = baitEffects.filter { it.type == SpawnBait.Effects.BITE_TIME }
-        if (biteTimeEffects.isEmpty()) return 1F
-
-        val biteTimeEffect = biteTimeEffects.random()
-        if (Math.random() > biteTimeEffect.chance) {
-            return 1F
-        }
-
-        return 1F - biteTimeEffect.value.toFloat()
-    }
-
     fun toItemStack(): ItemStack {
         val stack = ItemStack(this.blockState.block)
 
@@ -200,11 +79,7 @@ open class PokeSnackBlockEntity(pos: BlockPos, state: BlockState) :
      * Combine all the [SpawnBait.Effect] values from the [baitEffectsComponent] data.
      */
     fun getBaitEffects(): List<Effect> {
-        return baitEffectsComponent
-            ?.effects
-            ?.mapNotNull(SpawnBaitEffects::getFromIdentifier)
-            ?.flatMap { it.effects }
-            .orEmpty()
+        return baitEffectsComponent?.effects?.mapNotNull(SpawnBaitEffects::getFromIdentifier)?.flatMap { it.effects }.orEmpty()
     }
 
     override fun saveAdditional(tag: CompoundTag, registries: HolderLookup.Provider) {
@@ -238,12 +113,6 @@ open class PokeSnackBlockEntity(pos: BlockPos, state: BlockState) :
                     tag.put(DataKeys.INGREDIENTS, encodedTag)
                 }
         }
-
-        tag.putFloat(DataKeys.TICKS_UNTIL_NEXT_SPAWN, randomTicksUntilNextSpawn)
-
-        placedBy?.let {
-            tag.putUUID(DataKeys.PLACED_BY, it)
-        }
     }
 
     override fun loadAdditional(tag: CompoundTag, registries: HolderLookup.Provider) {
@@ -277,13 +146,5 @@ open class PokeSnackBlockEntity(pos: BlockPos, state: BlockState) :
                     ingredientComponent = component
                 }
         }
-
-        if (tag.contains(DataKeys.TICKS_UNTIL_NEXT_SPAWN)) {
-            randomTicksUntilNextSpawn = tag.getFloat(DataKeys.TICKS_UNTIL_NEXT_SPAWN)
-        }
-
-        if (tag.contains(DataKeys.PLACED_BY)) {
-            placedBy = tag.getUUID(DataKeys.PLACED_BY)
-        }
     }
 }

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/cookingpot/CookingPotScreen.kt

@@ -201,7 +201,7 @@ class CookingPotScreen(
     }
 
     override fun renderSlot(guiGraphics: GuiGraphics, slot: Slot) {
-        if (slot is SeasoningSlot && ((!menu.carried.isEmpty && !slot.mayPlace(menu.carried)) || (slot.hasItem() && !slot.mayPlace(slot.item))) ) {
+        if (slot is SeasoningSlot && !menu.carried.isEmpty && !slot.mayPlace(menu.carried)) {
             val x = slot.x
             val y = slot.y
             guiGraphics.fill(x,y,x+16,y+16,822018048)

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/portrait/AnimatedPortraitDrawer.kt

@@ -24,7 +24,6 @@ abstract class AnimatedPortraitDrawer : PortraitDrawer {
     private val stateAtIndex = hashMapOf<Int, Pair<UUID, FloatingState>>()
 
     override fun draw(pokemon: Pokemon, poseStack: PoseStack, partialTicks: Float, isSelected: Boolean, index: Int) {
-        state.currentAspects = pokemon.aspects
         drawPosablePortrait(
             identifier = pokemon.species.resourceIdentifier,
             matrixStack = poseStack,

common/src/main/kotlin/com/cobblemon/mod/common/client/render/VaryingRenderableResolver.kt

@@ -11,14 +11,7 @@ package com.cobblemon.mod.common.client.render
 import com.cobblemon.mod.common.api.molang.ExpressionLike
 import com.cobblemon.mod.common.client.render.models.blockbench.PosableModel
 import com.cobblemon.mod.common.client.render.models.blockbench.PosableState
-import com.cobblemon.mod.common.client.render.models.blockbench.animation.PoseTransitionAnimation
-import com.cobblemon.mod.common.client.render.models.blockbench.bedrock.animation.BedrockActiveAnimation
-import com.cobblemon.mod.common.client.render.models.blockbench.bedrock.animation.BedrockAnimation
-import com.cobblemon.mod.common.client.render.models.blockbench.bedrock.animation.BedrockPoseAnimation
-import com.cobblemon.mod.common.client.render.models.blockbench.bedrock.animation.TextureInterpolationType
 import com.cobblemon.mod.common.client.render.models.blockbench.pose.Bone
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
-import com.cobblemon.mod.common.client.render.models.blockbench.repository.RenderContext
 import com.cobblemon.mod.common.client.render.models.blockbench.repository.VaryingModelRepository
 import com.cobblemon.mod.common.util.adapters.*
 import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
@@ -28,13 +21,10 @@ import com.cobblemon.mod.common.util.toRGBA
 import com.google.gson.GsonBuilder
 import com.google.gson.annotations.SerializedName
 import com.mojang.blaze3d.platform.NativeImage
-import com.mojang.blaze3d.systems.RenderSystem
 import net.minecraft.client.Minecraft
-import net.minecraft.client.renderer.RenderStateShard
 import net.minecraft.client.renderer.texture.DynamicTexture
 import kotlin.math.floor
 import net.minecraft.resources.ResourceLocation
-import org.joml.Vector2d
 import org.joml.Vector3f
 import org.joml.Vector4f
 
@@ -63,7 +53,7 @@ class VaryingRenderableResolver(
     }
 
     fun getResolvedTexture(state: PosableState): ResourceLocation {
-        return getVariationValue(state) { texture }?.getTexture(state)
+        return getVariationValue(state) { texture }?.invoke(state)
             ?: throw IllegalStateException("Unable to find a texture for $name with aspects ${state.currentAspects.joinToString()}. This shouldn't be possible if you've defined the fallback variation.")
     }
 
@@ -190,13 +180,6 @@ class ModelAssetVariation(
     }
 }
 
-/** Needed a custom one, so I can make it take in a dynamic texture instead of resource location */
-class DynamicStateShard(texture: DynamicTexture) : RenderStateShard.EmptyTextureStateShard(Runnable {
-    RenderSystem.setShaderTexture(0, texture.id)
-}, Runnable {
-    texture.close() // Cleanup
-})
-
 /**
  * Given the animation seconds, returns a texture to use. Only implemented
  * by [StaticModelTextureSupplier] and [AnimatedModelTextureSupplier].
@@ -204,17 +187,12 @@ class DynamicStateShard(texture: DynamicTexture) : RenderStateShard.EmptyTexture
  * @author Hiroku
  * @since February 6th, 2023
  */
-interface ModelTextureSupplier {
-    operator fun invoke(state: PosableState): RenderStateShard.EmptyTextureStateShard
-    fun getTexture(state: PosableState): ResourceLocation
+fun interface ModelTextureSupplier {
+    operator fun invoke(state: PosableState): ResourceLocation
 }
 
 class StaticModelTextureSupplier(val texture: ResourceLocation): ModelTextureSupplier {
-    override fun invoke(state: PosableState): RenderStateShard.EmptyTextureStateShard {
-        return RenderStateShard.TextureStateShard(texture, false, false)
-    }
-
-    override fun getTexture(state: PosableState): ResourceLocation {
+    override fun invoke(state: PosableState): ResourceLocation {
         return texture
     }
 }
@@ -225,196 +203,80 @@ class AnimatedModelTextureSupplier(
     val frames: List<ResourceLocation>,
     val interpolation: Boolean
 ): ModelTextureSupplier {
-    override fun invoke(state: PosableState): RenderStateShard.EmptyTextureStateShard {
-        var frameIndex = state.animationSeconds * fps
-        if (frameIndex > frames.size - 1.0f && !loop) frameIndex = frames.size.toFloat() - 1.0f
-        val i = frameIndex % 1.0
-
-        if (interpolation && i != 0.0) {
-            val o = floor(frameIndex).toInt() % frames.size
-            val s = if (o == frames.size - 1) 0 else o + 1
-
-            val resourceManager = Minecraft.getInstance().resourceManager
-            val texture1 = NativeImage.read(resourceManager.getResourceOrThrow(frames[o]).open())
-            val texture2 = NativeImage.read(resourceManager.getResourceOrThrow(frames[s]).open())
-
-            val image = getInterpolatedTexture(texture1, texture2, i)
-            val newTexture = DynamicTexture(image)
-            newTexture.setFilter(false, false)
-            return DynamicStateShard(newTexture)
-        }
-        else {
-            val frame = floor(frameIndex).toInt() % frames.size
-            return RenderStateShard.TextureStateShard(frames[frame], false, false)
-        }
-    }
-
-    override fun getTexture(state: PosableState): ResourceLocation {
+    override fun invoke(state: PosableState): ResourceLocation {
         val frameIndex = floor(state.animationSeconds * fps).toInt()
-        return frames[frameIndex]
-    }
-}
-
-class KeyframableTextureSupplier(val textures: MutableList<ResourceLocation>) : ModelTextureSupplier {
-    var layerName = ""
-
-    override fun invoke(state: PosableState): RenderStateShard.EmptyTextureStateShard {
-        val resourceManager = Minecraft.getInstance().resourceManager
-
-        if (state.primaryAnimation?.animation is PoseTransitionAnimation) {
-            val poseTransition = state.primaryAnimation!!.animation as PoseTransitionAnimation
-
-            val (animation1, startTime1) = getMainAnimFromPose(poseTransition.beforePose, state, true)
-            val (animation2, startTime2) = getMainAnimFromPose(poseTransition.afterPose, state, true)
-
-            val texture2 = if (animation2 != null) {
-                getImageFromAnimation(animation2, state.animationSeconds - startTime2)
-            } else {
-                val image = NativeImage.read(resourceManager.getResourceOrThrow(textures[0]).open())
-                getEmptyTexture(image.width, image.height)
-            }
-            val (interpType, cubicValues) = poseTransition.beforePose.texturePhaseOut
-                ?: poseTransition.afterPose.texturePhaseIn
-
-            if (interpType == TextureInterpolationType.STEP) {
-                val newTexture = DynamicTexture(texture2)
-                newTexture.setFilter(false, false)
-                return DynamicStateShard(newTexture)
-            }
-
-            val texture1 = if (animation1 != null) {
-                getImageFromAnimation(animation1, state.animationSeconds - startTime1)
-            } else {
-                val image = NativeImage.read(resourceManager.getResourceOrThrow(textures[0]).open())
-                getEmptyTexture(image.width, image.height)
-            }
-            var i =
-                ((state.animationSeconds - poseTransition.startTime) / (poseTransition.endTime - poseTransition.startTime)).toDouble() //Linear
-            if (interpType == TextureInterpolationType.BEZIER) { //Switch to Bezier
-                i = resolveCubicValues(cubicValues, i)
-            }
-
-            val newImage = getInterpolatedTexture(texture1, texture2, i)
-            val newTexture = DynamicTexture(newImage)
-            newTexture.setFilter(false, false)
-            return DynamicStateShard(newTexture)
-
+        return if (frameIndex >= frames.size && !loop) {
+            frames.last()
         } else {
-            var animation = if ((state.primaryAnimation?.animation as? BedrockActiveAnimation)?.animation?.cobblemonTextures?.get(layerName) != null) {
-                (state.primaryAnimation?.animation as? BedrockActiveAnimation)?.animation
-            } else null
-            var startTime = 0F
-
-            if (animation == null) {
-                val data = getMainAnimFromPose(state.currentPose?.let(state.currentModel!!.poses::get), state)
-                animation = data.first
-                startTime = data.second
-            }
-
-            if (animation != null) {
-                val image = getImageFromAnimation(animation, state.animationSeconds - startTime)
-                val newTexture = DynamicTexture(image)
-                newTexture.setFilter(false, false)
-                return DynamicStateShard(newTexture)
-            }
+            frames[frameIndex % frames.size]
         }
-
-        val image = NativeImage.read(resourceManager.getResourceOrThrow(textures[0]).open())
-        val newTexture = DynamicTexture(getEmptyTexture(image.width, image.height))
-        newTexture.setFilter(false, false)
-        return DynamicStateShard(newTexture)
     }
 
-    override fun getTexture(state: PosableState): ResourceLocation {
-        return textures[0]
-    }
-
-    private fun getMainAnimFromPose(pose: Pose?, state: PosableState, transitionAnimation: Boolean = false): Pair<BedrockAnimation?, Float> {
-        var animation: BedrockAnimation? = null
-        var startTime = 0F
-
-        pose?.animations?.filterIsInstance<BedrockPoseAnimation>()?.filter{ transitionAnimation || state.shouldIdleRun(it, 0F) }?.forEach {
-            if (it.animation.cobblemonTextures[layerName] != null) {
-                animation = it.animation
-            }
-        }
-
-        if (state.primaryAnimation == null && state.currentModel!!.context.request(RenderContext.DO_QUIRKS) != false) {
-            pose?.quirks?.forEach { quirk ->
-                val quirkData = quirk.getOrCreateData(state)
-                quirkData.animations.filterIsInstance<BedrockActiveAnimation>().forEach {
-                    if (it.animation.cobblemonTextures[layerName] != null) {
-                        startTime = it.startedSeconds
-                        animation = it.animation
-                    }
-                }
-            }
-        }
-
-        return Pair(animation, startTime)
-    }
-
-    private fun getImageFromAnimation(animation: BedrockAnimation, animationSeconds: Float): NativeImage {
+    fun interpolatedTexture(state: PosableState): DynamicTexture? {
         val resourceManager = Minecraft.getInstance().resourceManager
 
-        val keyframeMap = animation.cobblemonTextures[layerName]
-        if (keyframeMap.isNullOrEmpty()) {
-            val image1 = NativeImage.read(resourceManager.getResourceOrThrow(textures[0]).open())
-            return getEmptyTexture(image1.width, image1.height)
-        }
-
-        var adjustedTime = animationSeconds
-        if (animation.shouldLoop) adjustedTime %= animation.animationLength.toFloat()
-        val keyIndex = keyframeMap.keys.indexOfLast { it <= adjustedTime }
-        val keyframe1 = when(keyIndex) {
-            -1 -> keyframeMap.firstEntry()
-            else -> keyframeMap.entries.toMutableList()[keyIndex]
-        }
-        val keyframe2 = when {
-            keyIndex + 1 >= keyframeMap.size -> keyframeMap.lastEntry()
-            else -> keyframeMap.entries.toMutableList()[keyIndex+1]
+        val frameIndex = floor(state.animationSeconds * fps).toInt()
+        try {
+            if (frameIndex >= frames.size && !loop) {
+                return DynamicTexture(NativeImage.read(resourceManager.getResourceOrThrow(frames.last()).open()))
+            }
+        } catch (e : Exception) {
+            return null
         }
+        val o = frameIndex % frames.size
+        val i = state.animationSeconds * fps - frameIndex
 
         val texture1 : NativeImage
-        var texture2 : NativeImage? = null
+        val texture2 : NativeImage
 
-        if (keyframe1.value.textureSlot == -1 && (keyframe2.value.textureSlot == -1 || keyframe1.value.interpolationType == TextureInterpolationType.STEP)) { // If both -1 we just return empty texture or if Step
-            val image1 = NativeImage.read(resourceManager.getResourceOrThrow(textures[0]).open())
-            return getEmptyTexture(image1.width, image1.height)
+        try { //Try getting images of the frames so we can use them to make a new one
+            texture1 = NativeImage.read(resourceManager.getResourceOrThrow(frames[o]).open())
+            val s = if (o == frames.size - 1) 0 else o + 1
+            texture2 = NativeImage.read(resourceManager.getResourceOrThrow(frames[s]).open())
+        } catch (e : Exception) {
+            return null
         }
 
-        var inverseInterp = false
-        if (keyframe1.value.textureSlot == -1) {
-            texture1 = NativeImage.read(resourceManager.getResourceOrThrow(textures[keyframe2.value.textureSlot]).open())
-            inverseInterp = true
-        } else if (keyframe2.value.textureSlot == -1) {
-            texture1 = NativeImage.read(resourceManager.getResourceOrThrow(textures[keyframe1.value.textureSlot]).open())
-        } else {
-            texture1 = NativeImage.read(resourceManager.getResourceOrThrow(textures[keyframe1.value.textureSlot]).open())
-            texture2 = NativeImage.read(resourceManager.getResourceOrThrow(textures[keyframe2.value.textureSlot]).open())
-        }
+        for (x in 0..<texture1.width) {
+            for (y in 0..<texture1.height) {
+                val color1 = texture1.getPixelRGBA(x,y).toRGBA()
+                val color2 = texture2.getPixelRGBA(x,y).toRGBA()
 
-        val i = (adjustedTime - keyframe1.key.toFloat()) / (keyframe2.key - keyframe1.key)
-        if (keyframe1.value.textureSlot != keyframe2.value.textureSlot && keyframe1.value.interpolationType == TextureInterpolationType.LINEAR) {
-            var interp = i
-            if (inverseInterp) interp = 1 - i
-            return getInterpolatedTexture(texture1, texture2, interp)
-        } else if (keyframe1.value.textureSlot != keyframe2.value.textureSlot && keyframe1.value.interpolationType == TextureInterpolationType.BEZIER) {
-            var cubicInterp = resolveCubicValues(keyframe1.value.cubicLerpFunctionValues, i)
-            if (inverseInterp) cubicInterp = 1 - cubicInterp
-            return getInterpolatedTexture(texture1, texture2, cubicInterp)
-        }
+                var newRed : Int
+                var newGreen : Int
+                var newBlue : Int
+                var newAlpha : Int
 
-        return NativeImage.read(resourceManager.getResourceOrThrow(textures[keyframe1.value.textureSlot]).open())
+                //Usually full transparent pixel is black, so this makes it copy the other texture colours to look better, however considering if we should allow to disable this feature
+                if (color1.w == 0F && color2.w == 1F) {
+                    newRed = floor(color2.x * 255).toInt()
+                    newGreen = floor(color2.y * 255).toInt()
+                    newBlue = floor(color2.z * 255).toInt()
+                } else if (color1.w == 1F && color2.w == 0F) {
+                    newRed = floor(color1.x * 255).toInt()
+                    newGreen = floor(color1.y * 255).toInt()
+                    newBlue = floor(color1.z * 255).toInt()
+                } else {
+                    newRed = floor((color1.x + (color2.x - color1.x) * i) * 255).toInt()
+                    newGreen = floor((color1.y + (color2.y - color1.y) * i) * 255).toInt()
+                    newBlue = floor((color1.z + (color2.z - color1.z) * i) * 255).toInt()
+                }
+
+                newAlpha = floor((color1.w + (color2.w - color1.w) * i) * 255).toInt()
+
+                val finalColor = (newAlpha shl 24) or (newRed shl 16) or (newGreen shl 8) or newBlue
+
+                texture1.setPixelRGBA(x,y,finalColor) //We aren't using texture 1 anymore so it's easier to override it
+            }
+        }
+        val newTexture = DynamicTexture(texture1)
+        newTexture.setFilter(false, false)
+        return newTexture
     }
 }
 
 class VariableModelTextureSupplier : ModelTextureSupplier {
-    override fun invoke(state: PosableState): RenderStateShard.EmptyTextureStateShard {
-        return RenderStateShard.TextureStateShard(getTexture(state), false, false)
-    }
-
-    override fun getTexture(state: PosableState): ResourceLocation {
+    override fun invoke(state: PosableState): ResourceLocation {
         return state.runtime.environment.variable.map["texture"]?.asString()?.asIdentifierDefaultingNamespace()
             ?: cobblemonResource("textures/npcs/default.png")
     }
@@ -433,75 +295,4 @@ class ModelLayer {
 enum class SpriteType {
     PORTRAIT,
     PROFILE
-}
-
-private fun getInterpolatedTexture(texture1: NativeImage, texture2: NativeImage?, i: Double): NativeImage {
-    for (x in 0..<texture1.width) {
-        for (y in 0..<texture1.height) {
-            val color1 = texture1.getPixelRGBA(x,y).toRGBA()
-            val color2 = texture2?.getPixelRGBA(x,y)?.toRGBA() ?: Vector4f(0F,0F,0F,0F)
-
-            var newRed : Int
-            var newGreen : Int
-            var newBlue : Int
-
-            //Usually full transparent pixel is black, so this makes it copy the other texture colours to look better, however considering if we should allow to disable this feature
-            if (color1.w == 0F && color2.w > 0F) {
-                newRed = floor(color2.x * 255).toInt()
-                newGreen = floor(color2.y * 255).toInt()
-                newBlue = floor(color2.z * 255).toInt()
-            } else if (color1.w > 0F && color2.w == 0F) {
-                newRed = floor(color1.x * 255).toInt()
-                newGreen = floor(color1.y * 255).toInt()
-                newBlue = floor(color1.z * 255).toInt()
-            } else {
-                newRed = floor((color1.x + (color2.x - color1.x) * i) * 255).toInt()
-                newGreen = floor((color1.y + (color2.y - color1.y) * i) * 255).toInt()
-                newBlue = floor((color1.z + (color2.z - color1.z) * i) * 255).toInt()
-            }
-
-            val newAlpha = floor((color1.w + (color2.w - color1.w) * i) * 255).toInt()
-
-            val finalColor = (newAlpha shl 24) or (newRed shl 16) or (newGreen shl 8) or newBlue
-
-            texture1.setPixelRGBA(x,y,finalColor) //We aren't using texture 1 anymore so it's easier to override it
-        }
-    }
-    return texture1
-}
-
-private fun getEmptyTexture(width: Int, height: Int): NativeImage {
-    return NativeImage(width, height, false)
-}
-
-private fun resolveCubicValues(clampedCubicValues : MutableList<Double>, i: Double): Double {
-    for (value in 0..<clampedCubicValues.size) {
-        clampedCubicValues[value] = Math.clamp(clampedCubicValues[value],0.0,1.0)
-    }
-
-    val points = mutableListOf<Vector2d>()
-    for (o in 0..200) {
-        val t = o/200.0
-        val omt = (1.0-t)
-
-        val point = Vector2d()
-        point.x = 3.0 * omt * omt * t * clampedCubicValues[0] + 3.0 * omt * t * t * clampedCubicValues[2] + t * t * t
-        point.y = 3.0 * omt * omt * t * clampedCubicValues[1] + 3.0 * omt * t * t * clampedCubicValues[3] + t * t * t
-
-        points.add(point)
-    }
-
-    var beforePoint = Vector2d(0.0,0.0)
-    var afterPoint = Vector2d(1.0, 1.0)
-
-    for (point in points) {
-        if (point.x > beforePoint.x && point.x < i) {
-            beforePoint = point
-        }
-        if (point.x < afterPoint.x && point.x > i) {
-            afterPoint = point
-        }
-    }
-
-    return beforePoint.y + (afterPoint.y - beforePoint.y) * ((i - beforePoint.x) / (afterPoint.x - beforePoint.x))
 }

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/JsonPose.kt

@@ -16,7 +16,6 @@ import com.cobblemon.mod.common.client.ClientMoLangFunctions.setupClient
 import com.cobblemon.mod.common.client.render.models.blockbench.animation.ActiveAnimation
 import com.cobblemon.mod.common.client.render.models.blockbench.animation.PoseAnimation
 import com.cobblemon.mod.common.client.render.models.blockbench.animation.SingleBoneLookAnimation
-import com.cobblemon.mod.common.client.render.models.blockbench.bedrock.animation.TextureInterpolationType
 import com.cobblemon.mod.common.client.render.models.blockbench.frame.HeadedFrame
 import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
 import com.cobblemon.mod.common.client.render.models.blockbench.quirk.SimpleQuirk
@@ -178,38 +177,4 @@ class JsonPose(model: PosableModel, json: JsonObject) {
     val transitions = json.get("transitions")?.takeIf { it is JsonObject }?.asJsonObject?.entrySet()?.map { (key, value) ->
         JsonPoseTransition(key, value.asString.asExpressionLike())
     } ?: emptyList()
-
-    val texturePhaseIn = json.get("texturePhaseIn")?.takeIf { it is JsonObject }?.asJsonObject?.let { theObject ->
-        val interpolationType = when(theObject.get("interpolation")?.asString) {
-            "step" -> TextureInterpolationType.STEP
-            "linear" -> TextureInterpolationType.LINEAR
-            "bezier" -> TextureInterpolationType.BEZIER
-            else -> TextureInterpolationType.STEP
-        }
-        val cubicValues = (theObject.get("cubicValues")?.asString ?: "0.0, 0.0, 1.0, 1.0").let { values ->
-            val list = mutableListOf<Double>()
-            values.split(",").forEach {
-                list.add(it.toDouble())
-            }
-            list
-        }
-        Pair(interpolationType, cubicValues)
-    } ?: Pair(TextureInterpolationType.STEP, mutableListOf(0.0, 0.0, 1.0, 1.0))
-
-    val texturePhaseOut = json.get("texturePhaseOut")?.takeIf { it is JsonObject }?.asJsonObject?.let { theObject ->
-        val interpolationType = when(theObject.get("interpolation")?.asString) {
-            "step" -> TextureInterpolationType.STEP
-            "linear" -> TextureInterpolationType.LINEAR
-            "bezier" -> TextureInterpolationType.BEZIER
-            else -> TextureInterpolationType.STEP
-        }
-        val cubicValues = (theObject.get("cubicValues")?.asString ?: "0.0, 0.0, 1.0, 1.0").let { values ->
-            val list = mutableListOf<Double>()
-            values.split(",").forEach {
-                list.add(it.toDouble())
-            }
-            list
-        }
-        Pair(interpolationType, cubicValues)
-    }
 }

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/PosableModel.kt

@@ -19,13 +19,11 @@ import com.cobblemon.mod.common.client.ClientMoLangFunctions.animationFunctions
 import com.cobblemon.mod.common.client.ClientMoLangFunctions.setupClient
 import com.cobblemon.mod.common.client.entity.PokemonClientDelegate
 import com.cobblemon.mod.common.client.render.AnimatedModelTextureSupplier
-import com.cobblemon.mod.common.client.render.KeyframableTextureSupplier
 import com.cobblemon.mod.common.client.render.ModelLayer
 import com.cobblemon.mod.common.client.render.models.blockbench.animation.*
 import com.cobblemon.mod.common.client.render.models.blockbench.bedrock.animation.BedrockActiveAnimation
 import com.cobblemon.mod.common.client.render.models.blockbench.bedrock.animation.BedrockAnimationRepository
 import com.cobblemon.mod.common.client.render.models.blockbench.bedrock.animation.BedrockPoseAnimation
-import com.cobblemon.mod.common.client.render.models.blockbench.bedrock.animation.TextureInterpolationType
 import com.cobblemon.mod.common.client.render.models.blockbench.frame.ModelFrame
 import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.CryProvider
 import com.cobblemon.mod.common.client.render.models.blockbench.pose.Bone
@@ -278,9 +276,7 @@ open class PosableModel(@Transient override val rootPart: Bone) : ModelFrame {
         onTransitionedInto: (PosableState) -> Unit = {},
         animations: Array<PoseAnimation> = emptyArray(),
         transformedParts: Array<ModelPartTransformation> = emptyArray(),
-        quirks: Array<ModelQuirk<*>> = emptyArray(),
-        texturePhaseIn: Pair<TextureInterpolationType, MutableList<Double>> = Pair(TextureInterpolationType.STEP, mutableListOf(0.0, 0.0, 1.0, 1.0)),
-        texturePhaseOut: Pair<TextureInterpolationType, MutableList<Double>>? = null
+        quirks: Array<ModelQuirk<*>> = emptyArray()
     ): Pose {
         return Pose(
             poseType.name,
@@ -292,9 +288,7 @@ open class PosableModel(@Transient override val rootPart: Bone) : ModelFrame {
             namedAnimations,
             animations,
             transformedParts,
-            quirks,
-            texturePhaseIn,
-            texturePhaseOut
+            quirks
         ).also {
             poses[poseType.name] = it
         }
@@ -310,9 +304,7 @@ open class PosableModel(@Transient override val rootPart: Bone) : ModelFrame {
         onTransitionedInto: (PosableState) -> Unit = {},
         animations: Array<PoseAnimation> = emptyArray(),
         transformedParts: Array<ModelPartTransformation> = emptyArray(),
-        quirks: Array<ModelQuirk<*>> = emptyArray(),
-        texturePhaseIn: Pair<TextureInterpolationType, MutableList<Double>> = Pair(TextureInterpolationType.STEP, mutableListOf(0.0, 0.0, 1.0, 1.0)),
-        texturePhaseOut: Pair<TextureInterpolationType, MutableList<Double>>? = null
+        quirks: Array<ModelQuirk<*>> = emptyArray()
     ): Pose {
         return Pose(
             poseName,
@@ -324,9 +316,7 @@ open class PosableModel(@Transient override val rootPart: Bone) : ModelFrame {
             namedAnimations,
             animations,
             transformedParts,
-            quirks,
-            texturePhaseIn,
-            texturePhaseOut
+            quirks
         ).also {
             poses[poseName] = it
         }
@@ -342,9 +332,7 @@ open class PosableModel(@Transient override val rootPart: Bone) : ModelFrame {
         onTransitionedInto: (PosableState) -> Unit = {},
         animations: Array<PoseAnimation> = emptyArray(),
         transformedParts: Array<ModelPartTransformation> = emptyArray(),
-        quirks: Array<ModelQuirk<*>> = emptyArray(),
-        texturePhaseIn: Pair<TextureInterpolationType, MutableList<Double>> = Pair(TextureInterpolationType.STEP, mutableListOf(0.0, 0.0, 1.0, 1.0)),
-        texturePhaseOut: Pair<TextureInterpolationType, MutableList<Double>>? = null
+        quirks: Array<ModelQuirk<*>> = emptyArray()
     ): Pose {
         return Pose(
             poseName,
@@ -356,9 +344,7 @@ open class PosableModel(@Transient override val rootPart: Bone) : ModelFrame {
             namedAnimations,
             animations,
             transformedParts,
-            quirks,
-            texturePhaseIn,
-            texturePhaseOut
+            quirks
         ).also {
             poses[poseName] = it
         }
@@ -426,6 +412,13 @@ open class PosableModel(@Transient override val rootPart: Bone) : ModelFrame {
 
     fun registerRelevantPart(pairing: Pair<String, ModelPart>) = registerRelevantPart(pairing.first, pairing.second)
 
+    /** Needed a custom one, so I can make it take in a dynamic texture instead of resource location */
+    class DynamicStateShard(texture: DynamicTexture) : RenderStateShard.EmptyTextureStateShard(Runnable {
+        RenderSystem.setShaderTexture(0, texture.id)
+    }, Runnable {
+        texture.close() // Cleanup
+    })
+
     /** Renders the model. Assumes rotations have been set. Will simply render the base model and then any extra layers. */
     fun render(
         context: RenderContext,
@@ -460,9 +453,16 @@ open class PosableModel(@Transient override val rootPart: Bone) : ModelFrame {
         val provider = bufferProvider
         if (provider != null) {
             for (layer in currentLayers) {
-                (layer.texture as? KeyframableTextureSupplier)?.layerName = layer.name
-                val texture = layer.texture?.invoke(currentState ?: FloatingState()) ?: continue
-                val renderLayer = makeLayer(texture, layer.emissive, layer.translucent, layer.translucent_cull)
+                var renderLayer : RenderType
+                if (layer.texture is AnimatedModelTextureSupplier && layer.texture.interpolation) {
+                    //Handle Interpolation
+                    val texture = layer.texture.interpolatedTexture(currentState ?: FloatingState()) ?: continue
+                    renderLayer = makeLayer(DynamicStateShard(texture), layer.emissive, layer.translucent, layer.translucent_cull)
+                }
+                else {
+                    val texture = layer.texture?.invoke(currentState ?: FloatingState()) ?: continue
+                    renderLayer = getLayer(texture, layer.emissive, layer.translucent, layer.translucent_cull)
+                }
                 val consumer = provider.getBuffer(renderLayer)
                 val tint = layer.tint
                 val tintRed = (tint.x * r2 * 255).toInt()

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/PoseAdapter.kt

@@ -90,9 +90,7 @@ class PoseAdapter(
             animations = pose.idleAnimations,
             transformedParts = pose.transformedParts,
             quirks = pose.quirks.toTypedArray(),
-            namedAnimations = pose.animations,
-            texturePhaseIn = pose.texturePhaseIn,
-            texturePhaseOut = pose.texturePhaseOut
+            namedAnimations = pose.animations
         ).also {
             it.transitions.putAll(
                 pose.transitions

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/bedrock/animation/BedrockAnimation.kt

@@ -132,9 +132,7 @@ data class BedrockAnimation(
     val shouldLoop: Boolean,
     val animationLength: Double,
     val effects: List<BedrockEffectKeyframe>,
-    val boneTimelines: Map<String, BedrockBoneTimeline>,
-    //This is custom data added by our custom BB plugin
-    val cobblemonTextures: MutableMap<String, TreeMap<Double, CobblemonBedrockTextureKeyframe>>
+    val boneTimelines: Map<String, BedrockBoneTimeline>
 ) {
     fun checkForErrors() {
         boneTimelines.forEach { (_, timeline) ->
@@ -398,14 +396,4 @@ enum class InterpolationType {
 
 enum class Transformation {
     POSITION, ROTATION, SCALE
-}
-
-data class CobblemonBedrockTextureKeyframe(
-    val textureSlot: Int,
-    val cubicLerpFunctionValues: MutableList<Double>,
-    val interpolationType: TextureInterpolationType
-)
-
-enum class TextureInterpolationType {
-    STEP, LINEAR, BEZIER
 }

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/bedrock/animation/BedrockAnimationAdapter.kt

@@ -20,7 +20,6 @@ import com.google.gson.JsonElement
 import com.google.gson.JsonObject
 import com.google.gson.JsonPrimitive
 import java.lang.reflect.Type
-import java.util.TreeMap
 
 /**
  * Gson adapter for converting bedrock/blockbench json data into a friendlier object model.
@@ -90,27 +89,7 @@ object BedrockAnimationAdapter : JsonDeserializer<BedrockAnimation> {
                 )
             }
 
-            //Custom Data reading added by our custom BB plugin
-            val cobblemonTextures = mutableMapOf<String, TreeMap<Double, CobblemonBedrockTextureKeyframe>>()
-            json["cobblemon_texture"]?.asJsonObject?.entrySet()?.forEach { (texture, timeline) ->
-                val textureTimeline = TreeMap<Double, CobblemonBedrockTextureKeyframe>()
-                timeline.asJsonObject.entrySet().forEach { (frame, values) ->
-                    val lerpFunctionValues = mutableListOf<Double>()
-                    values.asJsonObject["cobblemon_cubic_lerp_function"].asString.split(",").forEach {
-                        lerpFunctionValues.add(it.toDouble())
-                    }
-                    val interpolation = when(values.asJsonObject["cobblemon_interpolation"].asString) {
-                        "step" -> TextureInterpolationType.STEP
-                        "linear" -> TextureInterpolationType.LINEAR
-                        "bezier" -> TextureInterpolationType.BEZIER
-                        else -> TextureInterpolationType.STEP
-                    }
-                    textureTimeline[frame.toDouble()] = CobblemonBedrockTextureKeyframe(values.asJsonObject["cobblemon_texture_slot"].asInt, lerpFunctionValues, interpolation)
-                }
-                cobblemonTextures[texture] = textureTimeline
-            }
-
-            return BedrockAnimation(shouldLoop, animationLength, effects, boneTimelines, cobblemonTextures)
+            return BedrockAnimation(shouldLoop, animationLength, effects, boneTimelines)
         }
         else {
             throw IllegalStateException("animation json could not be parsed")

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pose/Pose.kt

@@ -13,7 +13,6 @@ import com.cobblemon.mod.common.client.render.models.blockbench.PosableModel
 import com.cobblemon.mod.common.client.render.models.blockbench.PosableState
 import com.cobblemon.mod.common.client.render.models.blockbench.animation.ActiveAnimation
 import com.cobblemon.mod.common.client.render.models.blockbench.animation.PoseAnimation
-import com.cobblemon.mod.common.client.render.models.blockbench.bedrock.animation.TextureInterpolationType
 import com.cobblemon.mod.common.client.render.models.blockbench.quirk.ModelQuirk
 import com.cobblemon.mod.common.client.render.models.blockbench.repository.RenderContext
 import com.cobblemon.mod.common.entity.PoseType
@@ -40,10 +39,7 @@ class Pose(
     val namedAnimations: MutableMap<String, ExpressionLike> = mutableMapOf(),
     val animations: Array<PoseAnimation>,
     val transformedParts: Array<ModelPartTransformation>,
-    val quirks: Array<ModelQuirk<*>>,
-    /** These are very specific to the animated texture**/
-    val texturePhaseIn: Pair<TextureInterpolationType, MutableList<Double>>,
-    val texturePhaseOut: Pair<TextureInterpolationType, MutableList<Double>>?,
+    val quirks: Array<ModelQuirk<*>>
 ) {
     fun isSuitable(state: PosableState) = condition?.invoke(state) ?: true
 

common/src/main/kotlin/com/cobblemon/mod/common/command/CheckSpawnsCommand.kt

@@ -8,11 +8,10 @@
 
 package com.cobblemon.mod.common.command
 
-import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.Cobblemon.config
 import com.cobblemon.mod.common.api.permission.CobblemonPermissions
+import com.cobblemon.mod.common.api.spawning.CobblemonWorldSpawnerManager
 import com.cobblemon.mod.common.api.spawning.SpawnCause
-import com.cobblemon.mod.common.api.spawning.position.calculators.SpawnablePositionCalculator.Companion.prioritizedAreaCalculators
 import com.cobblemon.mod.common.api.spawning.spawner.SpawningZoneInput
 import com.cobblemon.mod.common.api.text.add
 import com.cobblemon.mod.common.api.text.green
@@ -25,7 +24,6 @@ import com.cobblemon.mod.common.api.text.yellow
 import com.cobblemon.mod.common.command.argument.SpawnBucketArgumentType
 import com.cobblemon.mod.common.util.lang
 import com.cobblemon.mod.common.util.permission
-import com.cobblemon.mod.common.util.spawner
 import com.mojang.brigadier.Command
 import com.mojang.brigadier.CommandDispatcher
 import com.mojang.brigadier.context.CommandContext
@@ -58,11 +56,11 @@ object CheckSpawnsCommand {
             return 0
         }
 
-        val spawner = player.spawner
+        val spawner = CobblemonWorldSpawnerManager.spawnersForPlayers[player.uuid] ?: return Command.SINGLE_SUCCESS
         val bucket = SpawnBucketArgumentType.getSpawnBucket(context, name = "bucket")
         val cause = SpawnCause(spawner, player)
 
-        val slice = Cobblemon.spawningZoneGenerator.generate(
+        val slice = spawner.spawningZoneGenerator.generate(
             spawner = spawner,
             input = SpawningZoneInput(
                 cause = cause,
@@ -76,9 +74,9 @@ object CheckSpawnsCommand {
             )
         )
 
-        val contexts = Cobblemon.areaSpawnablePositionResolver.resolve(spawner, prioritizedAreaCalculators, slice)
+        val contexts = spawner.spawnablePositionResolver.resolve(spawner, spawner.spawnablePositionCalculators, slice)
 
-        val spawnProbabilities = spawner.selector.getProbabilities(spawner, bucket, contexts)
+        val spawnProbabilities = spawner.getSpawningSelector().getProbabilities(spawner, bucket, contexts)
 
         val spawnNames = mutableMapOf<String, MutableComponent>()
         val namedProbabilities = mutableMapOf<MutableComponent, Float>()

common/src/main/kotlin/com/cobblemon/mod/common/command/SpawnPokemonFromPool.kt

@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.command
 
 import com.cobblemon.mod.common.api.permission.CobblemonPermissions
+import com.cobblemon.mod.common.api.spawning.CobblemonWorldSpawnerManager
 import com.cobblemon.mod.common.api.spawning.SpawnCause
 import com.cobblemon.mod.common.api.spawning.detail.EntitySpawnResult
 import com.cobblemon.mod.common.api.spawning.position.AreaSpawnablePosition
@@ -18,7 +19,6 @@ import com.cobblemon.mod.common.util.alias
 import com.cobblemon.mod.common.util.commandLang
 import com.cobblemon.mod.common.util.effectiveName
 import com.cobblemon.mod.common.util.permission
-import com.cobblemon.mod.common.util.spawner
 import com.mojang.brigadier.CommandDispatcher
 import com.mojang.brigadier.arguments.IntegerArgumentType
 import com.mojang.brigadier.context.CommandContext
@@ -31,7 +31,7 @@ import net.minecraft.commands.Commands.literal
  *
  * `/spawnpokemonfrompool [amount]` or the alias `/forcespawn [amount]`
  *
- * This command can fail if the randomly selected spawn region has no possible [AreaSpawnablePosition]. For example if
+ * This command can fail if the randomly selection spawn region has no possible [AreaSpawnablePosition]. For example if
  *   you are flying in the air
  */
 object SpawnPokemonFromPool {
@@ -54,26 +54,47 @@ object SpawnPokemonFromPool {
 
     private fun execute(context: CommandContext<CommandSourceStack>, amount: Int): Int {
         val player = context.source.playerOrException
-        val spawner = player.spawner
+        val spawner = CobblemonWorldSpawnerManager.spawnersForPlayers.getValue(player.uuid)
 
         var spawnsTriggered = 0
 
-        repeat(times = amount) {
-            val spawnCause = SpawnCause(spawner = spawner, entity = player)
-            val results = spawner.runForArea(spawner.getZoneInput(spawnCause) ?: return@repeat, maxSpawns = 1)
-            if (results.isEmpty()) {
+        // This could instead directly use a [Spawner] method if refactored, as it is currently it has
+        //   entity counting coupled to the generation of an entity to spawn. Might be a good future change?
+        for (i in 1..amount) {
+            val spawnCause = SpawnCause(spawner = spawner, entity = spawner.getCauseEntity())
+
+            val zoneInput = spawner.getZoneInput(spawnCause) ?: continue
+            val zone = spawner.spawningZoneGenerator.generate(spawner, zoneInput)
+            val contexts = spawner.spawnablePositionResolver.resolve(spawner, spawner.spawnablePositionCalculators, zone)
+            val influences = spawner.getAllInfluences() + zone.unconditionalInfluences
+
+            // This has a chance to fail, if you get a spawning zone that has no associated contexts.
+            //   but as it was selected at random by the Spawning Zone Generator, it could just be a miss which
+            //   means two attempts to spawn in the same location can have differing results (which is expected for
+            //   randomness).
+            if (contexts.isEmpty()) {
                 player.sendSystemMessage(UNABLE_TO_SPAWN.red())
-                return@repeat
+                continue
             }
 
-            results.forEach {
+            val bucket = spawner.chooseBucket(spawnCause, influences)
+
+            val spawnAction = spawner.getSpawningSelector().select(spawner, bucket, contexts, max = 1).firstOrNull() // one at a time
+            if (spawnAction == null) {
+                player.sendSystemMessage(UNABLE_TO_SPAWN.red())
+                continue
+            }
+
+            spawnAction.future.thenApply {
                 if (it is EntitySpawnResult) {
                     for (entity in it.entities) {
-                        spawnsTriggered++
-                        player.sendSystemMessage(commandLang("spawnpokemonfrompool", entity.effectiveName()).green())
+                        player.sendSystemMessage(commandLang("spawnpokemonfrompool.success", entity.effectiveName()).green())
                     }
                 }
             }
+
+            spawnAction.complete()
+            spawnsTriggered++
         }
 
         return spawnsTriggered

common/src/main/kotlin/com/cobblemon/mod/common/config/CobblemonConfig.kt

@@ -155,9 +155,6 @@ class CobblemonConfig {
     @CobblemonConfigField(Category.Spawning, lang = "pokemon_per_chunk", SERVER)
     var pokemonPerChunk = 1F
 
-    @CobblemonConfigField(Category.Spawning, lang = "poke_snack_pokemon_per_chunk", SERVER)
-    var pokeSnackPokemonPerChunk = 2F
-
     @CobblemonConfigField(Category.PassiveStatus, lang = "passive_statuses", SERVER)
     var passiveStatuses = mutableMapOf(
         Statuses.POISON.configEntry(),
@@ -276,7 +273,7 @@ class CobblemonConfig {
     var summaryPokemonFollowCursor = true
 
     @CobblemonConfigField(Category.Interface, lang = "party_portrait_animations", CLIENT)
-    var partyPortraitAnimations = PortraitStyle.ANIMATE_SELECTED
+    var partyPortraitAnimations = PortraitStyle.NEVER_ANIMATE
 
     @CobblemonConfigField(Category.Riding, lang = "third_person_view_bobbing", CLIENT)
     var thirdPersonViewBobbing = true

common/src/main/kotlin/com/cobblemon/mod/common/entity/fishing/PokeRodFishingBobberEntity.kt

@@ -26,7 +26,6 @@ import com.cobblemon.mod.common.api.spawning.fishing.FishingSpawnCause
 import com.cobblemon.mod.common.api.spawning.influence.BucketNormalizingInfluence
 import com.cobblemon.mod.common.api.spawning.influence.PlayerLevelRangeInfluence
 import com.cobblemon.mod.common.api.spawning.influence.PlayerLevelRangeInfluence.Companion.TYPICAL_VARIATION
-import com.cobblemon.mod.common.api.spawning.position.FishingSpawnablePosition
 import com.cobblemon.mod.common.api.text.red
 import com.cobblemon.mod.common.client.sound.EntitySoundTracker
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
@@ -772,16 +771,11 @@ class PokeRodFishingBobberEntity(type: EntityType<out PokeRodFishingBobberEntity
             lureLevel = lureLevel,
         )
 
-        val spawnablePosition = FishingSpawnablePosition(
+        val result = spawner.getSpawnAction(
             cause = spawnCause,
             world = level() as ServerLevel,
             pos = position().toBlockPos(),
-            influences = mutableListOf(PlayerLevelRangeInfluence(player, TYPICAL_VARIATION), bucketInfluence)
-        )
-
-        val result = spawner.calculateSpawnActionForPosition(
-            cause = spawnCause,
-            spawnablePosition = spawnablePosition
+            influences = listOf(PlayerLevelRangeInfluence(player, TYPICAL_VARIATION), bucketInfluence)
         )
 
         this.plannedSpawnAction = result

common/src/main/kotlin/com/cobblemon/mod/common/events/ServerTickHandler.kt

@@ -8,6 +8,7 @@
 
 package com.cobblemon.mod.common.events
 
+import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.battles.BattleRegistry
 import com.cobblemon.mod.common.util.party
 import net.minecraft.server.MinecraftServer
@@ -16,6 +17,7 @@ object ServerTickHandler {
     private var secondsTick = 0
 
     fun onTick(server: MinecraftServer) {
+        Cobblemon.bestSpawner.spawnerManagers.forEach { it.onServerTick() }
         BattleRegistry.tick()
 
         secondsTick++

common/src/main/kotlin/com/cobblemon/mod/common/integration/jei/cooking/CampfirePotRecipeCategory.kt

@@ -85,7 +85,6 @@ class CampfirePotRecipeCategory(registration: IRecipeCategoryRegistration) : IRe
         if (recipe.seasoningProcessors.isNotEmpty()) {
             val processedSeasonings = EXAMPLE_SEASONINGS.filter { item ->
                 var valid = true
-                if (!item.`is`(recipe.seasoningTag)) return@filter false
                 recipe.seasoningProcessors.forEach {
                     if (!it.consumesItem(item)) {
                         valid = false

common/src/main/kotlin/com/cobblemon/mod/common/item/crafting/CookingPotRecipe.kt

@@ -10,23 +10,15 @@ package com.cobblemon.mod.common.item.crafting
 
 import com.cobblemon.mod.common.CobblemonRecipeSerializers
 import com.cobblemon.mod.common.CobblemonRecipeTypes
-import com.cobblemon.mod.common.api.tags.CobblemonItemTags
 import com.cobblemon.mod.common.util.codec.CodecUtils.createByStringCodec
-import com.cobblemon.mod.common.util.readIdentifier
 import com.cobblemon.mod.common.util.readString
-import com.cobblemon.mod.common.util.writeIdentifier
 import com.cobblemon.mod.common.util.writeString
 import com.mojang.serialization.Codec
 import com.mojang.serialization.MapCodec
 import com.mojang.serialization.codecs.RecordCodecBuilder
 import net.minecraft.core.NonNullList
-import net.minecraft.core.registries.Registries
 import net.minecraft.network.RegistryFriendlyByteBuf
 import net.minecraft.network.codec.StreamCodec
-import net.minecraft.resources.ResourceKey
-import net.minecraft.tags.TagEntry
-import net.minecraft.tags.TagKey
-import net.minecraft.world.item.Item
 import net.minecraft.world.item.ItemStack
 import net.minecraft.world.item.crafting.CraftingInput
 import net.minecraft.world.item.crafting.Ingredient
@@ -39,7 +31,6 @@ class CookingPotRecipe(
     override val result: ItemStack,
     override val groupName: String,
     override val category: CookingPotBookCategory,
-    override val seasoningTag: TagKey<Item>,
     override val seasoningProcessors: List<SeasoningProcessor>
 ) : CookingPotRecipeBase {
     override fun getType() = CobblemonRecipeTypes.COOKING_POT_COOKING
@@ -65,8 +56,7 @@ class CookingPotRecipe(
                     ShapedRecipePattern.MAP_CODEC.forGetter { recipe -> recipe.pattern },
                     ItemStack.STRICT_CODEC.fieldOf("result").forGetter { recipe -> recipe.result },
                     Codec.STRING.optionalFieldOf("group", "").forGetter { recipe -> recipe.group },
-                    CookingPotBookCategory.CODEC.fieldOf("category").orElse(CookingPotBookCategory.MISC).forGetter { recipe -> recipe.category },
-                    TagKey.codec(Registries.ITEM).fieldOf("seasoningTag").orElse(CobblemonItemTags.EMPTY).forGetter { recipe -> recipe.seasoningTag },
+                    CookingPotBookCategory.Companion.CODEC.fieldOf("category").orElse(CookingPotBookCategory.MISC).forGetter { recipe -> recipe.category },
                     createByStringCodec<SeasoningProcessor>(
                         { SeasoningProcessor.processors[it] },
                         { it.type },
@@ -80,20 +70,18 @@ class CookingPotRecipe(
             private fun fromNetwork(buffer: RegistryFriendlyByteBuf): CookingPotRecipe {
                 val group = buffer.readUtf()
                 val category = buffer.readEnum(CookingPotBookCategory::class.java)
-                val seasoningTag = TagKey.create(Registries.ITEM, buffer.readIdentifier())
                 val pattern = ShapedRecipePattern.STREAM_CODEC.decode(buffer)
                 val result = ItemStack.STREAM_CODEC.decode(buffer)
                 val seasoningProcessors = buffer.readList {
                     val type = buffer.readString()
                     SeasoningProcessor.processors[type] ?: error("Unknown seasoning processor: $type")
                 }
-                return CookingPotRecipe(pattern, result, group, category, seasoningTag, seasoningProcessors)
+                return CookingPotRecipe(pattern, result, group, category, seasoningProcessors)
             }
 
             private fun toNetwork(buffer: RegistryFriendlyByteBuf, recipe: CookingPotRecipe) {
                 buffer.writeUtf(recipe.groupName)
                 buffer.writeEnum(recipe.category)
-                buffer.writeIdentifier(recipe.seasoningTag.location)
                 ShapedRecipePattern.STREAM_CODEC.encode(buffer, recipe.pattern)
                 ItemStack.STREAM_CODEC.encode(buffer, recipe.result)
                 buffer.writeCollection(recipe.seasoningProcessors) { _, it ->

common/src/main/kotlin/com/cobblemon/mod/common/item/crafting/CookingPotRecipeBase.kt

@@ -10,8 +10,6 @@ package com.cobblemon.mod.common.item.crafting
 
 import com.cobblemon.mod.common.CobblemonItems
 import net.minecraft.core.HolderLookup
-import net.minecraft.tags.TagKey
-import net.minecraft.world.item.Item
 import net.minecraft.world.item.ItemStack
 import net.minecraft.world.item.crafting.CraftingInput
 import net.minecraft.world.item.crafting.Recipe
@@ -21,7 +19,6 @@ interface CookingPotRecipeBase : Recipe<CraftingInput> {
     val result: ItemStack
     val groupName: String
     val category: CookingPotBookCategory
-    val seasoningTag: TagKey<Item>
     val seasoningProcessors: List<SeasoningProcessor>
 
     override fun getGroup() = groupName

common/src/main/kotlin/com/cobblemon/mod/common/item/crafting/CookingPotShapelessRecipe.kt

@@ -10,22 +10,16 @@ package com.cobblemon.mod.common.item.crafting
 
 import com.cobblemon.mod.common.CobblemonRecipeSerializers
 import com.cobblemon.mod.common.CobblemonRecipeTypes
-import com.cobblemon.mod.common.api.tags.CobblemonItemTags
 import com.cobblemon.mod.common.util.codec.CodecUtils.createByStringCodec
-import com.cobblemon.mod.common.util.readIdentifier
 import com.cobblemon.mod.common.util.readString
-import com.cobblemon.mod.common.util.writeIdentifier
 import com.cobblemon.mod.common.util.writeString
 import com.mojang.serialization.Codec
 import com.mojang.serialization.DataResult
 import com.mojang.serialization.MapCodec
 import com.mojang.serialization.codecs.RecordCodecBuilder
 import net.minecraft.core.NonNullList
-import net.minecraft.core.registries.Registries
 import net.minecraft.network.RegistryFriendlyByteBuf
 import net.minecraft.network.codec.StreamCodec
-import net.minecraft.tags.TagKey
-import net.minecraft.world.item.Item
 import net.minecraft.world.item.ItemStack
 import net.minecraft.world.item.crafting.*
 import net.minecraft.world.level.Level
@@ -35,7 +29,6 @@ class CookingPotShapelessRecipe(
     override val category: CookingPotBookCategory,
     override val result: ItemStack,
     private val ingredients: NonNullList<Ingredient>,
-    override val seasoningTag: TagKey<Item>,
     override val seasoningProcessors: List<SeasoningProcessor>
 ) : Recipe<CraftingInput>, CookingPotRecipeBase {
     override fun getType(): RecipeType<CookingPotShapelessRecipe> = CobblemonRecipeTypes.COOKING_POT_SHAPELESS
@@ -75,7 +68,6 @@ class CookingPotShapelessRecipe(
                             else -> DataResult.success(NonNullList.of(Ingredient.EMPTY, *ingredients))
                         }
                     }, { DataResult.success(it) }).forGetter { it.ingredients },
-                    TagKey.codec(Registries.ITEM).fieldOf("seasoningTag").orElse(CobblemonItemTags.EMPTY).forGetter { recipe -> recipe.seasoningTag },
                     createByStringCodec<SeasoningProcessor>(
                         { SeasoningProcessor.processors[it] },
                         { it.type },
@@ -90,7 +82,6 @@ class CookingPotShapelessRecipe(
             private fun fromNetwork(buffer: RegistryFriendlyByteBuf): CookingPotShapelessRecipe {
                 val group = buffer.readUtf()
                 val category = buffer.readEnum(CookingPotBookCategory::class.java)
-                val seasoningTag = TagKey.create(Registries.ITEM, buffer.readIdentifier())
                 val size = buffer.readVarInt()
                 val ingredients = NonNullList.withSize(size, Ingredient.EMPTY)
                 ingredients.replaceAll { Ingredient.CONTENTS_STREAM_CODEC.decode(buffer) }
@@ -99,13 +90,12 @@ class CookingPotShapelessRecipe(
                     val type = buffer.readString()
                     SeasoningProcessor.processors[type] ?: error("Unknown seasoning processor: $type")
                 }
-                return CookingPotShapelessRecipe(group, category, result, ingredients, seasoningTag, seasoningProcessors)
+                return CookingPotShapelessRecipe(group, category, result, ingredients, seasoningProcessors)
             }
 
             private fun toNetwork(buffer: RegistryFriendlyByteBuf, recipe: CookingPotShapelessRecipe) {
                 buffer.writeUtf(recipe.group)
                 buffer.writeEnum(recipe.category)
-                buffer.writeIdentifier(recipe.seasoningTag.location)
                 buffer.writeVarInt(recipe.ingredients.size)
                 recipe.ingredients.forEach { ingredient ->
                     Ingredient.CONTENTS_STREAM_CODEC.encode(buffer, ingredient)

common/src/main/kotlin/com/cobblemon/mod/common/util/DataKeys.kt

@@ -156,10 +156,6 @@ object DataKeys {
     const val BAIT_EFFECTS = "BaitEffects"
     const val INGREDIENTS = "Ingredients"
 
-    const val PLACED_BY = "PlacedBy"
-
-    const val TICKS_UNTIL_NEXT_SPAWN = "TicksUntilNextSpawn"
-
     // Pokémon Item
     const val POKEMON_ITEM_SPECIES = "species"
     const val POKEMON_ITEM_ASPECTS = "aspects"

common/src/main/kotlin/com/cobblemon/mod/common/util/PlayerExtensions.kt

@@ -10,7 +10,6 @@ package com.cobblemon.mod.common.util
 
 import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.CobblemonSounds
-import com.cobblemon.mod.common.PlayerSpawnerGetter
 import com.cobblemon.mod.common.api.battles.model.PokemonBattle
 import com.cobblemon.mod.common.api.battles.model.actor.BattleActor
 import com.cobblemon.mod.common.api.dialogue.ActiveDialogue
@@ -18,7 +17,6 @@ import com.cobblemon.mod.common.api.dialogue.Dialogue
 import com.cobblemon.mod.common.api.dialogue.DialogueManager
 import com.cobblemon.mod.common.api.reactive.Observable.Companion.filter
 import com.cobblemon.mod.common.api.reactive.Observable.Companion.takeFirst
-import com.cobblemon.mod.common.api.spawning.spawner.PlayerSpawner
 import com.cobblemon.mod.common.battles.BattleRegistry
 import com.cobblemon.mod.common.battles.TeamManager
 import com.cobblemon.mod.common.net.messages.client.storage.pc.wallpaper.RequestPCBoxWallpapersPacket
@@ -100,8 +98,6 @@ fun ServerPlayer.didSleep(): Boolean {
 }
 
 fun ServerPlayer.isInBattle() = BattleRegistry.getBattleByParticipatingPlayer(this) != null
-val ServerPlayer.spawner: PlayerSpawner
-    get() = (this as PlayerSpawnerGetter).getPlayerSpawner()
 fun ServerPlayer.getBattleState(): Pair<PokemonBattle, BattleActor>? {
     val battle = BattleRegistry.getBattleByParticipatingPlayer(this)
     if (battle != null) {

common/src/main/kotlin/com/cobblemon/mod/common/util/adapters/ModelTextureSupplierAdapter.kt

@@ -8,8 +8,10 @@
 
 package com.cobblemon.mod.common.util.adapters
 
-import com.cobblemon.mod.common.client.render.*
-import com.google.gson.JsonArray
+import com.cobblemon.mod.common.client.render.AnimatedModelTextureSupplier
+import com.cobblemon.mod.common.client.render.ModelTextureSupplier
+import com.cobblemon.mod.common.client.render.StaticModelTextureSupplier
+import com.cobblemon.mod.common.client.render.VariableModelTextureSupplier
 import com.google.gson.JsonDeserializationContext
 import com.google.gson.JsonDeserializer
 import com.google.gson.JsonElement
@@ -45,13 +47,6 @@ object ModelTextureSupplierAdapter : JsonDeserializer<ModelTextureSupplier> {
                 frames = frames,
                 interpolation = interpolation
             )
-        } else if (json.isJsonArray) {
-            val jsonArray = json as JsonArray
-            val textures = mutableListOf<ResourceLocation>()
-            jsonArray.forEach {
-                textures.add(ResourceLocation.parse(it.asString))
-            }
-            return KeyframableTextureSupplier(textures)
         } else {
             throw IllegalArgumentException("Invalid JSON provided for model texture, it was of type ${json::class.simpleName} instead of a String or Object.")
         }

common/src/main/resources/assets/cobblemon/lang/en_us.json

@@ -2480,8 +2480,6 @@
   "cobblemon.config.ui.experience_multiplier.tooltip": "Additional Exp. multiplier for Exp. calculation.",
   "cobblemon.config.ui.pokemon_per_chunk": "Pokémon per Chunk",
   "cobblemon.config.ui.pokemon_per_chunk.tooltip": "The amount of Pokémon allowed within a Chunk when spawning.",
-  "cobblemon.config.ui.poke_snack_pokemon_per_chunk": "Poké Snack Pokémon per Chunk",
-  "cobblemon.config.ui.poke_snack_pokemon_per_chunk.tooltip": "The amount of Pokémon allowed within a Chunk when spawning via Poké Snacks.",
   "cobblemon.config.ui.passive_statuses": "Passive Statuses",
   "cobblemon.config.ui.passive_statuses.tooltip": "Range of seconds before clearing the status effect. The value is selected randomly from the range each time an effect is applied.",
   "cobblemon.config.ui.infinite_healer_charge": "Infinite Healer Charge",
@@ -3446,7 +3444,7 @@
   "tag.item.cobblemon.held.power_weight": "Power Weights",
   "tag.item.cobblemon.held.terrain_seeds": "Terrain Seeds",
   "tag.item.cobblemon.herbs": "Herbs",
-  "tag.item.cobblemon.mint_leaves": "Mint Leaves",
+  "tag.item.cobblemon.mint_leaf": "Mint Leaves",
   "tag.item.cobblemon.mints": "Mints",
   "tag.item.cobblemon.mint_seeds": "Mint Seeds",
   "tag.item.cobblemon.berries.mutation_result": "Mutation Berries",
@@ -3537,12 +3535,7 @@
   "tag.item.cobblemon.small_flowers": "Small Flowers",
   "tag.item.cobblemon.held.blacklisted_items_to_hold": "Blacklisted Held Items",
   "tag.item.cobblemon.held.whitelisted_items_to_hold": "Whitelisted Held Items",
-  "tag.item.cobblemon.recipe_filters.poke_puff_seasoner": "Poké Puff Berries",
-  "tag.item.cobblemon.recipe_filters.bait_seasoning": "Baits",
-  "tag.item.cobblemon.recipe_filters.effect_seasoning": "Effect Seasoning Items",
-  "tag.item.cobblemon.recipe_filters.nutrition_seasoning": "Nutrition Seasoning Items",
-  "tag.item.cobblemon.recipe_filters.flavour_seasoning": "Flavour Seasoning Items",
-  "tag.item.cobblemon.recipe_filters.colour_seasoning": "Colour Seasoning Items",
+  "tag.item.cobblemon.poke_puff_berries": "Poké Puff Berries",
   "tag.item.cobblemon.candies": "Candies",
   "tag.item.cobblemon.experience_candies": "Experience Candies",
   "tag.item.cobblemon.iv_candies": "Hyper Training Candies",

common/src/main/resources/data/c/tags/item/crops/mint.json

@@ -1,6 +1,6 @@
 {
   "replace": false,
   "values": [
-    "#cobblemon:mint_leaves"
+    "#cobblemon:mint_leaf"
   ]
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/antidote_in_campfire_pot.json

@@ -12,6 +12,5 @@
     "result": {
         "id": "cobblemon:antidote"
     },
-    "seasoningTag": "cobblemon:empty",
     "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/awakening_in_campfire_pot.json

@@ -12,6 +12,5 @@
     "result": {
         "id": "cobblemon:awakening"
     },
-    "seasoningTag": "cobblemon:empty",
     "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/beetroot_soup_in_campfire_pot.json

@@ -28,6 +28,5 @@
         "id": "minecraft:beetroot_soup",
         "count": 1
     },
-    "seasoningTag": "cobblemon:empty",
     "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/berry_sweet.json

@@ -16,6 +16,5 @@
     "result": {
         "id": "cobblemon:berry_sweet"
     },
-    "seasoningTag": "cobblemon:empty",
     "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/big_malasada.json

@@ -18,6 +18,5 @@
     "result": {
         "id": "cobblemon:big_malasada"
     },
-    "seasoningTag": "cobblemon:empty",
     "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/black_aprijuice.json

@@ -13,7 +13,6 @@
     "result": {
         "id": "cobblemon:aprijuice_black"
     },
-    "seasoningTag": "cobblemon:recipe_filters/flavour_seasoning",
     "seasoningProcessors": [
         "flavour"
     ]

common/src/main/resources/data/cobblemon/recipe/campfire_pot/blue_aprijuice.json

@@ -13,7 +13,6 @@
     "result": {
         "id": "cobblemon:aprijuice_blue"
     },
-    "seasoningTag": "cobblemon:recipe_filters/flavour_seasoning",
     "seasoningProcessors": [
         "flavour"
     ]

common/src/main/resources/data/cobblemon/recipe/campfire_pot/brittle_candy_l.json

@@ -21,6 +21,5 @@
   "result": {
     "id": "cobblemon:brittle_candy"
   },
-  "seasoningTag": "cobblemon:empty",
   "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/brittle_candy_xl.json

@@ -22,6 +22,5 @@
     "count": 3,
     "id": "cobblemon:brittle_candy"
   },
-  "seasoningTag": "cobblemon:empty",
   "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/burn_heal_in_campfire_pot.json

@@ -12,6 +12,5 @@
     "result": {
         "id": "cobblemon:burn_heal"
     },
-    "seasoningTag": "cobblemon:empty",
     "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/cake_in_campfire_pot.json

@@ -23,6 +23,5 @@
     "result": {
         "id": "minecraft:cake"
     },
-    "seasoningTag": "cobblemon:empty",
     "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/calcium_in_campfire_pot.json

@@ -28,6 +28,5 @@
     "result": {
         "id": "cobblemon:calcium"
     },
-    "seasoningTag": "cobblemon:empty",
     "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/candied_apple.json

@@ -21,6 +21,5 @@
         "id": "cobblemon:candied_apple",
         "count": 1
     },
-    "seasoningTag": "cobblemon:empty",
     "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/candied_berry.json

@@ -22,6 +22,5 @@
         "id": "cobblemon:candied_berry",
         "count": 1
     },
-    "seasoningTag": "cobblemon:empty",
     "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/carbos_in_campfire_pot.json

@@ -28,6 +28,5 @@
     "result": {
         "id": "cobblemon:carbos"
     },
-    "seasoningTag": "cobblemon:empty",
     "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/casteliacone.json

@@ -18,6 +18,5 @@
     "result": {
         "id": "cobblemon:casteliacone"
     },
-    "seasoningTag": "cobblemon:empty",
     "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/clever_mochi.json

@@ -17,6 +17,5 @@
         "id": "cobblemon:clever_mochi",
         "count": 3
     },
-    "seasoningTag": "cobblemon:empty",
     "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/clover_sweet.json

@@ -16,6 +16,5 @@
     "result": {
         "id": "cobblemon:clover_sweet"
     },
-    "seasoningTag": "cobblemon:empty",
     "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/courage_candy_l.json

@@ -21,6 +21,5 @@
   "result": {
     "id": "cobblemon:courage_candy"
   },
-  "seasoningTag": "cobblemon:empty",
   "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/courage_candy_xl.json

@@ -22,6 +22,5 @@
     "count": 3,
     "id": "cobblemon:courage_candy"
   },
-  "seasoningTag": "cobblemon:empty",
   "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/coward_candy_l.json

@@ -21,6 +21,5 @@
   "result": {
     "id": "cobblemon:coward_candy"
   },
-  "seasoningTag": "cobblemon:empty",
   "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/coward_candy_xl.json

@@ -22,6 +22,5 @@
     "count": 3,
     "id": "cobblemon:coward_candy"
   },
-  "seasoningTag": "cobblemon:empty",
   "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/dire_hit.json

@@ -20,6 +20,5 @@
         "id": "cobblemon:dire_hit",
         "count": 4
     },
-    "seasoningTag": "cobblemon:empty",
     "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/elixir_in_campfire_pot.json

@@ -12,6 +12,5 @@
     "result": {
         "id": "cobblemon:elixir"
     },
-    "seasoningTag": "cobblemon:empty",
     "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/ether_in_campfire_pot.json

@@ -12,6 +12,5 @@
     "result": {
         "id": "cobblemon:ether"
     },
-    "seasoningTag": "cobblemon:empty",
     "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/exp_candy_l.json

@@ -15,6 +15,5 @@
     "result": {
         "id": "cobblemon:exp_candy_l"
     },
-    "seasoningTag": "cobblemon:empty",
     "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/exp_candy_m.json

@@ -15,6 +15,5 @@
     "result": {
         "id": "cobblemon:exp_candy_m"
     },
-    "seasoningTag": "cobblemon:empty",
     "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/exp_candy_s.json

@@ -24,6 +24,5 @@
     "result": {
         "id": "cobblemon:exp_candy_s"
     },
-    "seasoningTag": "cobblemon:empty",
     "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/exp_candy_xl.json

@@ -15,6 +15,5 @@
     "result": {
         "id": "cobblemon:exp_candy_xl"
     },
-    "seasoningTag": "cobblemon:empty",
     "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/exp_candy_xs.json

@@ -12,6 +12,5 @@
     "result": {
         "id": "cobblemon:exp_candy_xs"
     },
-    "seasoningTag": "cobblemon:empty",
     "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/flower_sweet.json

@@ -16,6 +16,5 @@
     "result": {
         "id": "cobblemon:flower_sweet"
     },
-    "seasoningTag": "cobblemon:empty",
     "seasoningProcessors": []
 }

common/src/main/resources/data/cobblemon/recipe/campfire_pot/fresh_start_mochi.json

@@ -17,6 +17,5 @@
         "id": "cobblemon:fresh_start_mochi",
         "count": 3
     },
-    "seasoningTag": "cobblemon:empty",
     "seasoningProcessors": []
 }