Added first VERY rough draft of jumpy bug, creeping horror, lurking terror

.tmp_neoforge_src_lookup/net/neoforged/neoforge/entity/PartEntity.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) Forge Development LLC and contributors
+ * SPDX-License-Identifier: LGPL-2.1-only
+ */
+
+package net.neoforged.neoforge.entity;
+
+import net.minecraft.network.protocol.Packet;
+import net.minecraft.network.protocol.game.ClientGamePacketListener;
+import net.minecraft.server.level.ServerEntity;
+import net.minecraft.world.entity.Entity;
+
+public abstract class PartEntity<T extends Entity> extends Entity {
+    private final T parent;
+
+    public PartEntity(T parent) {
+        super(parent.getType(), parent.level());
+        this.parent = parent;
+    }
+
+    public T getParent() {
+        return parent;
+    }
+
+    @Override
+    public Packet<ClientGamePacketListener> getAddEntityPacket(ServerEntity entity) {
+        throw new UnsupportedOperationException();
+    }
+}

.tmp_neoforge_src_lookup/software/bernie/geckolib/util/Color.java

@@ -0,0 +1,230 @@
+/*
+    Direct copy of https://github.com/shedaniel/cloth-basic-math/blob/master/src/main/java/me/shedaniel/math/Color.java under the unlicense.
+ */
+package software.bernie.geckolib.util;
+
+/**
+ * Color holder object for storing a packed int argb value.
+ */
+public record Color(int argbInt) {
+	public static final Color WHITE = new Color(0xFFFFFFFF);
+	public static final Color LIGHT_GRAY = new Color(0xFFC0C0C0);
+	public static final Color GRAY = new Color(0xFF808080);
+	public static final Color DARK_GRAY = new Color(0xFF404040);
+	public static final Color BLACK = new Color(0xFF000000);
+	public static final Color RED = new Color(0xFFFF0000);
+	public static final Color PINK = new Color(0xFFFFAFAF);
+	public static final Color ORANGE = new Color(0xFFFFC800);
+	public static final Color YELLOW = new Color(0xFFFFFF00);
+	public static final Color GREEN = new Color(0xFF00FF00);
+	public static final Color MAGENTA = new Color(0xFFFF00FF);
+	public static final Color CYAN = new Color(0xFF00FFFF);
+	public static final Color BLUE = new Color(0xFF0000FF);
+
+	/**
+	 * Creates a new {@code Color} instance from RGB values, ensuring 100% opacity
+	 */
+	public static Color ofOpaque(int color) {
+		return new Color(0xFF000000 | color);
+	}
+
+	/**
+	 * Creates a new {@code Color} instance from RGB values with 100% opacity
+	 */
+	public static Color ofRGB(float red, float green, float blue) {
+		return ofRGBA(red, green, blue, 1f);
+	}
+
+	/**
+	 * Creates a new {@code Color} instance from RGB values with 100% opacity
+	 */
+	public static Color ofRGB(int r, int g, int b) {
+		return ofRGBA(r, g, b, 255);
+	}
+
+	/**
+	 * Creates a new {@code Color} instance from RGBA values
+	 */
+	public static Color ofRGBA(float r, float g, float b, float a) {
+		return ofRGBA((int)(r * 255f + 0.5), (int)(g * 255f + 0.5f), (int)(b * 255f + 0.5f), (int)(a * 255f + 0.5f));
+	}
+
+	/**
+	 * Creates a new {@code Color} instance from RGBA values
+	 */
+	public static Color ofRGBA(int r, int g, int b, int a) {
+		return new Color(((a & 0xFF) << 24) | ((r & 0xFF) << 16) | ((g & 0xFF) << 8) | (b & 0xFF));
+	}
+
+	/**
+	 * Creates a new {@code Color} instance from ARGB values
+	 */
+	public static Color ofARGB(float a, float r, float g, float b) {
+		return ofARGB((int)(a * 255f + 0.5f), (int)(r * 255f + 0.5), (int)(g * 255f + 0.5f), (int)(b * 255f + 0.5f));
+	}
+
+	/**
+	 * Creates a new {@code Color} instance from ARGB values
+	 */
+	public static Color ofARGB(int a, int r, int g, int b) {
+		return new Color(((a & 0xFF) << 24) | ((r & 0xFF) << 16) | ((g & 0xFF) << 8) | (b & 0xFF));
+	}
+
+	/**
+	 * Creates a new {@code Color} instance from HSB values with 100% opacity
+	 */
+	public static Color ofHSB(float hue, float saturation, float brightness) {
+		return ofOpaque(HSBtoARGB(hue, saturation, brightness));
+	}
+
+	/**
+	 * Converts a HSB value triplet to a packed ARGB int
+	 */
+	public static int HSBtoARGB(float hue, float saturation, float brightness) {
+		int r = 0;
+		int g = 0;
+		int b = 0;
+
+		if (saturation == 0) {
+			r = g = b = (int) (brightness * 255f + 0.5f);
+		}
+		else {
+			float h = (hue - (float)Math.floor(hue)) * 6f;
+			float f = h - (float)Math.floor(h);
+			float p = brightness * (1 - saturation);
+			float q = brightness * (1 - saturation * f);
+			float t = brightness * (1 - (saturation * (1 - f)));
+
+			switch ((int)h) {
+				case 0 -> {
+					r = (int) (brightness * 255f + 0.5f);
+					g = (int) (t * 255f + 0.5f);
+					b = (int) (p * 255f + 0.5f);
+				}
+				case 1 -> {
+					r = (int) (q * 255f + 0.5f);
+					g = (int) (brightness * 255f + 0.5f);
+					b = (int) (p * 255f + 0.5f);
+				}
+				case 2 -> {
+					r = (int) (p * 255f + 0.5f);
+					g = (int) (brightness * 255f + 0.5f);
+					b = (int) (t * 255f + 0.5f);
+				}
+				case 3 -> {
+					r = (int) (p * 255f + 0.5f);
+					g = (int) (q * 255f + 0.5f);
+					b = (int) (brightness * 255f + 0.5f);
+				}
+				case 4 -> {
+					r = (int) (t * 255f + 0.5f);
+					g = (int) (p * 255f + 0.5f);
+					b = (int) (brightness * 255f + 0.5f);
+				}
+				case 5 -> {
+					r = (int) (brightness * 255f + 0.5f);
+					g = (int) (p * 255f + 0.5f);
+					b = (int) (q * 255f + 0.5f);
+				}
+			}
+		}
+
+		return 0xFF000000 | (r << 16) | (g << 8) | b;
+	}
+
+	public int getColor() {
+		return this.argbInt;
+	}
+
+	public int getAlpha() {
+		return this.argbInt >> 24 & 0xFF;
+	}
+
+	public float getAlphaFloat() {
+		return getAlpha() / 255f;
+	}
+
+	public int getRed() {
+		return this.argbInt >> 16 & 0xFF;
+	}
+
+	public float getRedFloat() {
+		return getRed() / 255f;
+	}
+
+	public int getGreen() {
+		return this.argbInt >> 8 & 0xFF;
+	}
+
+	public float getGreenFloat() {
+		return getGreen() / 255f;
+	}
+
+	public int getBlue() {
+		return this.argbInt & 0xFF;
+	}
+
+	public float getBlueFloat() {
+		return getBlue() / 255f;
+	}
+
+	/**
+	 * Returns a brighter variant of the same color
+	 *
+	 * @param factor The factor for shading
+	 */
+	public Color brighter(double factor) {
+		int r = getRed();
+		int g = getGreen();
+		int b = getBlue();
+		int i = (int)(1 / (1 - (1 / factor)));
+
+		if (r == 0 && g == 0 && b == 0)
+			return ofRGBA(i, i, i, getAlpha());
+
+		if (r > 0 && r < i)
+			r = i;
+
+		if (g > 0 && g < i)
+			g = i;
+
+		if (b > 0 && b < i)
+			b = i;
+
+		return ofRGBA(Math.min((int) (r / (1 / factor)), 255), Math.min((int) (g / (1 / factor)), 255),
+				Math.min((int) (b / (1 / factor)), 255), getAlpha());
+	}
+
+	/**
+	 * Returns a darker variant of the same color
+	 *
+	 * @param factor The factor for shading. The value provided is an inversely relative multiplier.<br>
+	 *                  E.G. input=2 -> 2x as dark.<br>
+	 *                  E.G. input=0.5 -> 0.5x as dark (brighter)
+	 */
+	public Color darker(float factor) {
+		return ofRGBA(Math.max((int)(getRed() * (1 / factor)), 0), Math.max((int)(getGreen() * (1 / factor)), 0),
+				Math.max((int)(getBlue() * (1 / factor)), 0), getAlpha());
+	}
+
+	@Override
+	public boolean equals(Object other) {
+		if (this == other)
+			return true;
+
+		if (getClass() != other.getClass())
+			return false;
+
+		return hashCode() == other.hashCode();
+	}
+
+	@Override
+	public int hashCode() {
+		return this.argbInt;
+	}
+
+	@Override
+	public String toString() {
+		return String.valueOf(this.argbInt);
+	}
+}

common/src/main/java/com/craisinlord/antarchy/config/AntarchySettings.java

@@ -271,6 +271,10 @@ public final class AntarchySettings {
     private static double bedBugAttackLungeHorizontalSpeed = 0.42D;
     private static double bedBugAttackLungeVerticalSpeed = 0.1D;
     private static float bedBugHealAmount = 2.0F;
+    private static double jumpyBugHealth = 12.0D;
+    private static double jumpyBugPounceDamage = 2.0D;
+    private static double jumpyBugLatchDamage = 1.0D;
+    private static double jumpyBugCamouflageAlpha = 0.18D;
     private static double brutalflyArmor = 10.0D;
     private static double brutalflyArmorToughness = 4.0D;
     private static double brutalflyKnockbackResistance = 0.7D;
@@ -451,11 +455,16 @@ public final class AntarchySettings {
     private static double toreterrorSpinDamage = 8.0D;
     private static double toreterrorSpinKnockback = 1.5D;
     private static double toreterrorRangedWaterBombChance = 0.5D;
+    private static double toreterrorProjectileDamageMultiplier = 0.5D;
     private static double waterBombDamage = 6.0D;
     private static int waterBombLifetimeTicks = 120;
     private static double waterBombGravity = 0.12D;
     private static double waterBombKnockback = 1.2D;
     private static double waterCannonCooldownSeconds = 1.5D;
+    private static double creepingHorrorHealth = 15.0D;
+    private static double creepingHorrorAttackDamage = 6.0D;
+    private static double lurkingTerrorHealth = 15.0D;
+    private static double lurkingTerrorAttackDamage = 6.0D;
 
     private AntarchySettings() {
     }
@@ -1811,6 +1820,18 @@ public final class AntarchySettings {
     public static float bedBugHealAmount() { return bedBugHealAmount; }
     public static void setBedBugHealAmount(float value) { bedBugHealAmount = value; }
 
+    public static double jumpyBugHealth() { return jumpyBugHealth; }
+    public static void setJumpyBugHealth(double value) { jumpyBugHealth = value; }
+
+    public static double jumpyBugPounceDamage() { return jumpyBugPounceDamage; }
+    public static void setJumpyBugPounceDamage(double value) { jumpyBugPounceDamage = value; }
+
+    public static double jumpyBugLatchDamage() { return jumpyBugLatchDamage; }
+    public static void setJumpyBugLatchDamage(double value) { jumpyBugLatchDamage = value; }
+
+    public static double jumpyBugCamouflageAlpha() { return jumpyBugCamouflageAlpha; }
+    public static void setJumpyBugCamouflageAlpha(double value) { jumpyBugCamouflageAlpha = value; }
+
     public static double brutalflyArmor() { return brutalflyArmor; }
     public static void setBrutalflyArmor(double value) { brutalflyArmor = value; }
 
@@ -2334,6 +2355,8 @@ public final class AntarchySettings {
     public static void setToreterrorSpinKnockback(double v) { toreterrorSpinKnockback = v; }
     public static double toreterrorRangedWaterBombChance() { return toreterrorRangedWaterBombChance; }
     public static void setToreterrorRangedWaterBombChance(double v) { toreterrorRangedWaterBombChance = v; }
+    public static double toreterrorProjectileDamageMultiplier() { return toreterrorProjectileDamageMultiplier; }
+    public static void setToreterrorProjectileDamageMultiplier(double v) { toreterrorProjectileDamageMultiplier = v; }
     public static double waterBombDamage() { return waterBombDamage; }
     public static void setWaterBombDamage(double v) { waterBombDamage = v; }
     public static int waterBombLifetimeTicks() { return waterBombLifetimeTicks; }
@@ -2344,4 +2367,13 @@ public final class AntarchySettings {
     public static void setWaterBombKnockback(double v) { waterBombKnockback = v; }
     public static double waterCannonCooldownSeconds() { return waterCannonCooldownSeconds; }
     public static void setWaterCannonCooldownSeconds(double v) { waterCannonCooldownSeconds = v; }
+
+    public static double creepingHorrorHealth() { return creepingHorrorHealth; }
+    public static void setCreepingHorrorHealth(double v) { creepingHorrorHealth = v; }
+    public static double creepingHorrorAttackDamage() { return creepingHorrorAttackDamage; }
+    public static void setCreepingHorrorAttackDamage(double v) { creepingHorrorAttackDamage = v; }
+    public static double lurkingTerrorHealth() { return lurkingTerrorHealth; }
+    public static void setLurkingTerrorHealth(double v) { lurkingTerrorHealth = v; }
+    public static double lurkingTerrorAttackDamage() { return lurkingTerrorAttackDamage; }
+    public static void setLurkingTerrorAttackDamage(double v) { lurkingTerrorAttackDamage = v; }
 }

common/src/main/java/com/craisinlord/antarchy/content/AntarchyObjects.java

@@ -8,6 +8,8 @@ import com.craisinlord.antarchy.content.entity.EasterBunnyEntity;
 import com.craisinlord.antarchy.content.entity.HushProjectileEntity;
 import com.craisinlord.antarchy.content.entity.WaterBombEntity;
 import com.craisinlord.antarchy.content.entity.TriffidEntity;
+import com.craisinlord.antarchy.content.entity.CreepingHorrorEntity;
+import com.craisinlord.antarchy.content.entity.LurkingTerrorEntity;
 import com.craisinlord.antarchy.content.entity.ToreterrorEntity;
 import com.craisinlord.antarchy.content.entity.WaspEntity;
 import com.craisinlord.antarchy.content.entity.brutalfly.BrutalflyEntity;
@@ -79,6 +81,10 @@ public final class AntarchyObjects {
     @SuppressWarnings("unchecked")
     public static Supplier<EntityType<WaterBombEntity>> WATER_BOMB = (Supplier<EntityType<WaterBombEntity>>) UNBOUND;
     @SuppressWarnings("unchecked")
+    public static Supplier<EntityType<CreepingHorrorEntity>> CREEPING_HORROR = (Supplier<EntityType<CreepingHorrorEntity>>) UNBOUND;
+    @SuppressWarnings("unchecked")
+    public static Supplier<EntityType<LurkingTerrorEntity>> LURKING_TERROR = (Supplier<EntityType<LurkingTerrorEntity>>) UNBOUND;
+    @SuppressWarnings("unchecked")
     public static Supplier<Block> DUPLICATOR_LOG = (Supplier<Block>) UNBOUND;
     @SuppressWarnings("unchecked")
     public static Supplier<Block> DUPLICATOR_SAPLING = (Supplier<Block>) UNBOUND;
@@ -185,6 +191,10 @@ public final class AntarchyObjects {
     @SuppressWarnings("unchecked")
     public static Supplier<Block> BED_BUG_EGG = (Supplier<Block>) UNBOUND;
     @SuppressWarnings("unchecked")
+    public static Supplier<Block> CREEPING_HORROR_EGGS = (Supplier<Block>) UNBOUND;
+    @SuppressWarnings("unchecked")
+    public static Supplier<Block> LURKING_TERROR_EGGS = (Supplier<Block>) UNBOUND;
+    @SuppressWarnings("unchecked")
     public static Supplier<Block> WASP_NEST = (Supplier<Block>) UNBOUND;
     @SuppressWarnings("unchecked")
     public static Supplier<Block> HUSHWEED = (Supplier<Block>) UNBOUND;
@@ -222,6 +232,8 @@ public final class AntarchyObjects {
             Supplier<EntityType<HushProjectileEntity>> hushProjectile,
             Supplier<EntityType<ToreterrorEntity>> toreterror,
             Supplier<EntityType<WaterBombEntity>> waterBomb,
+            Supplier<EntityType<CreepingHorrorEntity>> creepingHorror,
+            Supplier<EntityType<LurkingTerrorEntity>> lurkingTerror,
             Supplier<Block> duplicatorLog,
             Supplier<Block> duplicatorSapling,
             Supplier<Block> ductTape,
@@ -272,6 +284,8 @@ public final class AntarchyObjects {
             Supplier<Block> pinkMilkweed,
             Supplier<Block> torchflowerBush,
             Supplier<Block> bedBugEggs,
+            Supplier<Block> creepingHorrorEggs,
+            Supplier<Block> lurkingTerrorEggs,
             Supplier<Block> waspNest,
             Supplier<Block> hushweed,
             Supplier<Block> squirrelNestBlock,
@@ -302,6 +316,8 @@ public final class AntarchyObjects {
         HUSH_PROJECTILE = hushProjectile;
         TORETERROR = toreterror;
         WATER_BOMB = waterBomb;
+        CREEPING_HORROR = creepingHorror;
+        LURKING_TERROR = lurkingTerror;
         DUPLICATOR_LOG = duplicatorLog;
         DUPLICATOR_SAPLING = duplicatorSapling;
         DUCT_TAPE = ductTape;
@@ -352,6 +368,8 @@ public final class AntarchyObjects {
         PINK_MILKWEED = pinkMilkweed;
         TORCHFLOWER_BUSH = torchflowerBush;
         BED_BUG_EGG = bedBugEggs;
+        CREEPING_HORROR_EGGS = creepingHorrorEggs;
+        LURKING_TERROR_EGGS = lurkingTerrorEggs;
         WASP_NEST = waspNest;
         HUSHWEED = hushweed;
         SQUIRREL_NEST_BLOCK = squirrelNestBlock;

common/src/main/java/com/craisinlord/antarchy/content/block/CreepingHorrorEggBlock.java

@@ -0,0 +1,190 @@
+package com.craisinlord.antarchy.content.block;
+
+import com.craisinlord.antarchy.content.AntarchyObjects;
+import com.craisinlord.antarchy.content.entity.CreepingHorrorEntity;
+import com.mojang.serialization.MapCodec;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.sounds.SoundEvents;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.tags.BlockTags;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.ambient.Bat;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.context.BlockPlaceContext;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.GameRules;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.LevelAccessor;
+import net.minecraft.world.level.LevelReader;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockBehaviour;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.StateDefinition;
+import net.minecraft.world.level.block.state.properties.BlockStateProperties;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import net.minecraft.world.phys.shapes.CollisionContext;
+import net.minecraft.world.phys.shapes.VoxelShape;
+
+public class CreepingHorrorEggBlock extends Block {
+    public static final MapCodec<CreepingHorrorEggBlock> CODEC = Block.simpleCodec(CreepingHorrorEggBlock::new);
+    public static final IntegerProperty HATCH = BlockStateProperties.HATCH;
+    public static final IntegerProperty EGGS = BlockStateProperties.EGGS;
+    private static final int MAX_HATCH = 2;
+    private static final int MAX_EGGS = 4;
+    private static final VoxelShape SINGLE_SHAPE = Block.box(3.0D, 0.0D, 3.0D, 13.0D, 7.0D, 13.0D);
+    private static final VoxelShape MULTI_SHAPE = Block.box(1.0D, 0.0D, 1.0D, 15.0D, 7.0D, 15.0D);
+
+    public CreepingHorrorEggBlock(BlockBehaviour.Properties properties) {
+        super(properties);
+        this.registerDefaultState(this.stateDefinition.any().setValue(HATCH, 0).setValue(EGGS, 1));
+    }
+
+    @Override
+    public MapCodec<CreepingHorrorEggBlock> codec() {
+        return CODEC;
+    }
+
+    @Override
+    protected VoxelShape getShape(BlockState state, BlockGetter level, BlockPos pos, CollisionContext context) {
+        return state.getValue(EGGS) > 1 ? MULTI_SHAPE : SINGLE_SHAPE;
+    }
+
+    @Override
+    protected boolean canSurvive(BlockState state, LevelReader level, BlockPos pos) {
+        return level.getBlockState(pos.below()).isFaceSturdy(level, pos.below(), Direction.UP);
+    }
+
+    @Override
+    protected BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor level, BlockPos pos, BlockPos neighborPos) {
+        return state.canSurvive(level, pos) ? super.updateShape(state, direction, neighborState, level, pos, neighborPos) : Blocks.AIR.defaultBlockState();
+    }
+
+    @Override
+    protected boolean canBeReplaced(BlockState state, BlockPlaceContext context) {
+        return !context.isSecondaryUseActive()
+                && context.getItemInHand().is(this.asItem())
+                && state.getValue(EGGS) < MAX_EGGS;
+    }
+
+    @Override
+    public BlockState getStateForPlacement(BlockPlaceContext context) {
+        BlockState existingState = context.getLevel().getBlockState(context.getClickedPos());
+        if (existingState.is(this)) {
+            return existingState.setValue(EGGS, Math.min(MAX_EGGS, existingState.getValue(EGGS) + 1));
+        }
+        return this.defaultBlockState();
+    }
+
+    @Override
+    protected boolean isRandomlyTicking(BlockState state) {
+        return true;
+    }
+
+    @Override
+    protected void randomTick(BlockState state, ServerLevel level, BlockPos pos, RandomSource random) {
+        if (!this.shouldUpdateHatchLevel(level) || !hasHatchSupport(level, pos)) {
+            return;
+        }
+
+        int hatch = state.getValue(HATCH);
+        if (hatch < MAX_HATCH) {
+            level.setBlock(pos, state.setValue(HATCH, hatch + 1), 2);
+            level.playSound(null, pos, SoundEvents.TURTLE_EGG_CRACK, SoundSource.BLOCKS, 0.7F, 0.95F + random.nextFloat() * 0.1F);
+            return;
+        }
+
+        this.hatchEggs(level, pos, state, random);
+    }
+
+    @Override
+    public void stepOn(Level level, BlockPos pos, BlockState state, Entity entity) {
+        if (!entity.isSteppingCarefully()) {
+            this.destroyEgg(level, state, pos, entity, 100);
+        }
+        super.stepOn(level, pos, state, entity);
+    }
+
+    @Override
+    public void fallOn(Level level, BlockState state, BlockPos pos, Entity entity, float fallDistance) {
+        this.destroyEgg(level, state, pos, entity, 3);
+        super.fallOn(level, state, pos, entity, fallDistance);
+    }
+
+    @Override
+    protected void onPlace(BlockState state, Level level, BlockPos pos, BlockState oldState, boolean isMoving) {
+        if (hasHatchSupport(level, pos) && !level.isClientSide) {
+            level.levelEvent(2012, pos, 15);
+        }
+    }
+
+    @Override
+    public void playerDestroy(Level level, Player player, BlockPos pos, BlockState state, BlockEntity blockEntity, net.minecraft.world.item.ItemStack stack) {
+        super.playerDestroy(level, player, pos, state, blockEntity, stack);
+        this.decreaseEggs(level, pos, state);
+    }
+
+    @Override
+    protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockState> builder) {
+        builder.add(HATCH, EGGS);
+    }
+
+    public static boolean hasHatchSupport(BlockGetter level, BlockPos pos) {
+        return isSupportedGround(level, pos.below());
+    }
+
+    public static boolean isSupportedGround(BlockGetter level, BlockPos pos) {
+        return level.getBlockState(pos).is(BlockTags.SAND) || level.getBlockState(pos).blocksMotion();
+    }
+
+    private void destroyEgg(Level level, BlockState state, BlockPos pos, Entity entity, int chance) {
+        if (level.isClientSide || !this.canDestroyEgg(level, entity) || level.random.nextInt(chance) != 0) {
+            return;
+        }
+        level.playSound(null, pos, SoundEvents.TURTLE_EGG_BREAK, SoundSource.BLOCKS, 0.7F, 0.9F + level.random.nextFloat() * 0.2F);
+        this.decreaseEggs(level, pos, state);
+    }
+
+    private void hatchEggs(ServerLevel level, BlockPos pos, BlockState state, RandomSource random) {
+        level.removeBlock(pos, false);
+        level.playSound(null, pos, SoundEvents.TURTLE_EGG_HATCH, SoundSource.BLOCKS, 0.75F, 0.95F + random.nextFloat() * 0.1F);
+
+        for (int i = 0; i < state.getValue(EGGS); i++) {
+            CreepingHorrorEntity entity = AntarchyObjects.CREEPING_HORROR.get().create(level);
+            if (entity == null) {
+                continue;
+            }
+            double spawnX = pos.getX() + 0.25D + random.nextDouble() * 0.5D;
+            double spawnZ = pos.getZ() + 0.25D + random.nextDouble() * 0.5D;
+            entity.moveTo(spawnX, pos.getY() + 0.1D, spawnZ, random.nextFloat() * 360.0F, 0.0F);
+            level.addFreshEntity(entity);
+        }
+    }
+
+    private void decreaseEggs(Level level, BlockPos pos, BlockState state) {
+        int eggs = state.getValue(EGGS);
+        if (eggs <= 1) {
+            level.destroyBlock(pos, false);
+            return;
+        }
+        level.setBlock(pos, state.setValue(EGGS, eggs - 1), 2);
+    }
+
+    private boolean shouldUpdateHatchLevel(Level level) {
+        return level.random.nextInt(500) == 0;
+    }
+
+    private boolean canDestroyEgg(Level level, Entity entity) {
+        if (entity instanceof CreepingHorrorEntity || entity instanceof Bat) {
+            return false;
+        }
+        if (entity instanceof net.minecraft.world.entity.LivingEntity) {
+            return entity instanceof Player || level.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING);
+        }
+        return false;
+    }
+}

common/src/main/java/com/craisinlord/antarchy/content/block/LurkingTerrorEggBlock.java

@@ -0,0 +1,190 @@
+package com.craisinlord.antarchy.content.block;
+
+import com.craisinlord.antarchy.content.AntarchyObjects;
+import com.craisinlord.antarchy.content.entity.LurkingTerrorEntity;
+import com.mojang.serialization.MapCodec;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.sounds.SoundEvents;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.tags.BlockTags;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.ambient.Bat;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.context.BlockPlaceContext;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.GameRules;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.LevelAccessor;
+import net.minecraft.world.level.LevelReader;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockBehaviour;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.StateDefinition;
+import net.minecraft.world.level.block.state.properties.BlockStateProperties;
+import net.minecraft.world.level.block.state.properties.IntegerProperty;
+import net.minecraft.world.phys.shapes.CollisionContext;
+import net.minecraft.world.phys.shapes.VoxelShape;
+
+public class LurkingTerrorEggBlock extends Block {
+    public static final MapCodec<LurkingTerrorEggBlock> CODEC = Block.simpleCodec(LurkingTerrorEggBlock::new);
+    public static final IntegerProperty HATCH = BlockStateProperties.HATCH;
+    public static final IntegerProperty EGGS = BlockStateProperties.EGGS;
+    private static final int MAX_HATCH = 2;
+    private static final int MAX_EGGS = 4;
+    private static final VoxelShape SINGLE_SHAPE = Block.box(3.0D, 0.0D, 3.0D, 13.0D, 7.0D, 13.0D);
+    private static final VoxelShape MULTI_SHAPE = Block.box(1.0D, 0.0D, 1.0D, 15.0D, 7.0D, 15.0D);
+
+    public LurkingTerrorEggBlock(BlockBehaviour.Properties properties) {
+        super(properties);
+        this.registerDefaultState(this.stateDefinition.any().setValue(HATCH, 0).setValue(EGGS, 1));
+    }
+
+    @Override
+    public MapCodec<LurkingTerrorEggBlock> codec() {
+        return CODEC;
+    }
+
+    @Override
+    protected VoxelShape getShape(BlockState state, BlockGetter level, BlockPos pos, CollisionContext context) {
+        return state.getValue(EGGS) > 1 ? MULTI_SHAPE : SINGLE_SHAPE;
+    }
+
+    @Override
+    protected boolean canSurvive(BlockState state, LevelReader level, BlockPos pos) {
+        return level.getBlockState(pos.below()).isFaceSturdy(level, pos.below(), Direction.UP);
+    }
+
+    @Override
+    protected BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor level, BlockPos pos, BlockPos neighborPos) {
+        return state.canSurvive(level, pos) ? super.updateShape(state, direction, neighborState, level, pos, neighborPos) : Blocks.AIR.defaultBlockState();
+    }
+
+    @Override
+    protected boolean canBeReplaced(BlockState state, BlockPlaceContext context) {
+        return !context.isSecondaryUseActive()
+                && context.getItemInHand().is(this.asItem())
+                && state.getValue(EGGS) < MAX_EGGS;
+    }
+
+    @Override
+    public BlockState getStateForPlacement(BlockPlaceContext context) {
+        BlockState existingState = context.getLevel().getBlockState(context.getClickedPos());
+        if (existingState.is(this)) {
+            return existingState.setValue(EGGS, Math.min(MAX_EGGS, existingState.getValue(EGGS) + 1));
+        }
+        return this.defaultBlockState();
+    }
+
+    @Override
+    protected boolean isRandomlyTicking(BlockState state) {
+        return true;
+    }
+
+    @Override
+    protected void randomTick(BlockState state, ServerLevel level, BlockPos pos, RandomSource random) {
+        if (!this.shouldUpdateHatchLevel(level) || !hasHatchSupport(level, pos)) {
+            return;
+        }
+
+        int hatch = state.getValue(HATCH);
+        if (hatch < MAX_HATCH) {
+            level.setBlock(pos, state.setValue(HATCH, hatch + 1), 2);
+            level.playSound(null, pos, SoundEvents.TURTLE_EGG_CRACK, SoundSource.BLOCKS, 0.7F, 0.95F + random.nextFloat() * 0.1F);
+            return;
+        }
+
+        this.hatchEggs(level, pos, state, random);
+    }
+
+    @Override
+    public void stepOn(Level level, BlockPos pos, BlockState state, Entity entity) {
+        if (!entity.isSteppingCarefully()) {
+            this.destroyEgg(level, state, pos, entity, 100);
+        }
+        super.stepOn(level, pos, state, entity);
+    }
+
+    @Override
+    public void fallOn(Level level, BlockState state, BlockPos pos, Entity entity, float fallDistance) {
+        this.destroyEgg(level, state, pos, entity, 3);
+        super.fallOn(level, state, pos, entity, fallDistance);
+    }
+
+    @Override
+    protected void onPlace(BlockState state, Level level, BlockPos pos, BlockState oldState, boolean isMoving) {
+        if (hasHatchSupport(level, pos) && !level.isClientSide) {
+            level.levelEvent(2012, pos, 15);
+        }
+    }
+
+    @Override
+    public void playerDestroy(Level level, Player player, BlockPos pos, BlockState state, BlockEntity blockEntity, net.minecraft.world.item.ItemStack stack) {
+        super.playerDestroy(level, player, pos, state, blockEntity, stack);
+        this.decreaseEggs(level, pos, state);
+    }
+
+    @Override
+    protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockState> builder) {
+        builder.add(HATCH, EGGS);
+    }
+
+    public static boolean hasHatchSupport(BlockGetter level, BlockPos pos) {
+        return isSupportedGround(level, pos.below());
+    }
+
+    public static boolean isSupportedGround(BlockGetter level, BlockPos pos) {
+        return level.getBlockState(pos).is(BlockTags.SAND) || level.getBlockState(pos).blocksMotion();
+    }
+
+    private void destroyEgg(Level level, BlockState state, BlockPos pos, Entity entity, int chance) {
+        if (level.isClientSide || !this.canDestroyEgg(level, entity) || level.random.nextInt(chance) != 0) {
+            return;
+        }
+        level.playSound(null, pos, SoundEvents.TURTLE_EGG_BREAK, SoundSource.BLOCKS, 0.7F, 0.9F + level.random.nextFloat() * 0.2F);
+        this.decreaseEggs(level, pos, state);
+    }
+
+    private void hatchEggs(ServerLevel level, BlockPos pos, BlockState state, RandomSource random) {
+        level.removeBlock(pos, false);
+        level.playSound(null, pos, SoundEvents.TURTLE_EGG_HATCH, SoundSource.BLOCKS, 0.75F, 0.95F + random.nextFloat() * 0.1F);
+
+        for (int i = 0; i < state.getValue(EGGS); i++) {
+            LurkingTerrorEntity entity = AntarchyObjects.LURKING_TERROR.get().create(level);
+            if (entity == null) {
+                continue;
+            }
+            double spawnX = pos.getX() + 0.25D + random.nextDouble() * 0.5D;
+            double spawnZ = pos.getZ() + 0.25D + random.nextDouble() * 0.5D;
+            entity.moveTo(spawnX, pos.getY() + 0.1D, spawnZ, random.nextFloat() * 360.0F, 0.0F);
+            level.addFreshEntity(entity);
+        }
+    }
+
+    private void decreaseEggs(Level level, BlockPos pos, BlockState state) {
+        int eggs = state.getValue(EGGS);
+        if (eggs <= 1) {
+            level.destroyBlock(pos, false);
+            return;
+        }
+        level.setBlock(pos, state.setValue(EGGS, eggs - 1), 2);
+    }
+
+    private boolean shouldUpdateHatchLevel(Level level) {
+        return level.random.nextInt(500) == 0;
+    }
+
+    private boolean canDestroyEgg(Level level, Entity entity) {
+        if (entity instanceof LurkingTerrorEntity || entity instanceof Bat) {
+            return false;
+        }
+        if (entity instanceof net.minecraft.world.entity.LivingEntity) {
+            return entity instanceof Player || level.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING);
+        }
+        return false;
+    }
+}

common/src/main/java/com/craisinlord/antarchy/content/client/model/CreepingHorrorModel.java

@@ -0,0 +1,23 @@
+package com.craisinlord.antarchy.content.client.model;
+
+import com.craisinlord.antarchy.Antarchy;
+import com.craisinlord.antarchy.content.entity.CreepingHorrorEntity;
+import net.minecraft.resources.ResourceLocation;
+import software.bernie.geckolib.model.GeoModel;
+
+public class CreepingHorrorModel extends GeoModel<CreepingHorrorEntity> {
+    @Override
+    public ResourceLocation getModelResource(CreepingHorrorEntity animatable) {
+        return ResourceLocation.fromNamespaceAndPath(Antarchy.MODID, "geo/creeping_horror.geo.json");
+    }
+
+    @Override
+    public ResourceLocation getTextureResource(CreepingHorrorEntity animatable) {
+        return ResourceLocation.fromNamespaceAndPath(Antarchy.MODID, "textures/entity/creeping_horror.png");
+    }
+
+    @Override
+    public ResourceLocation getAnimationResource(CreepingHorrorEntity animatable) {
+        return ResourceLocation.fromNamespaceAndPath(Antarchy.MODID, "animations/creeping_horror.animation.json");
+    }
+}

common/src/main/java/com/craisinlord/antarchy/content/client/model/JumpyBugModel.java

@@ -0,0 +1,23 @@
+package com.craisinlord.antarchy.content.client.model;
+
+import com.craisinlord.antarchy.Antarchy;
+import com.craisinlord.antarchy.content.entity.JumpyBugEntity;
+import net.minecraft.resources.ResourceLocation;
+import software.bernie.geckolib.model.GeoModel;
+
+public class JumpyBugModel extends GeoModel<JumpyBugEntity> {
+    @Override
+    public ResourceLocation getModelResource(JumpyBugEntity animatable) {
+        return ResourceLocation.fromNamespaceAndPath(Antarchy.MODID, "geo/jumpy_bug.geo.json");
+    }
+
+    @Override
+    public ResourceLocation getTextureResource(JumpyBugEntity animatable) {
+        return ResourceLocation.fromNamespaceAndPath(Antarchy.MODID, "textures/entity/jumpy_bug.png");
+    }
+
+    @Override
+    public ResourceLocation getAnimationResource(JumpyBugEntity animatable) {
+        return ResourceLocation.fromNamespaceAndPath(Antarchy.MODID, "animations/jumpy_bug.animation.json");
+    }
+}

common/src/main/java/com/craisinlord/antarchy/content/client/model/LurkingTerrorModel.java

@@ -0,0 +1,23 @@
+package com.craisinlord.antarchy.content.client.model;
+
+import com.craisinlord.antarchy.Antarchy;
+import com.craisinlord.antarchy.content.entity.LurkingTerrorEntity;
+import net.minecraft.resources.ResourceLocation;
+import software.bernie.geckolib.model.GeoModel;
+
+public class LurkingTerrorModel extends GeoModel<LurkingTerrorEntity> {
+    @Override
+    public ResourceLocation getModelResource(LurkingTerrorEntity animatable) {
+        return ResourceLocation.fromNamespaceAndPath(Antarchy.MODID, "geo/lurking_terror.geo.json");
+    }
+
+    @Override
+    public ResourceLocation getTextureResource(LurkingTerrorEntity animatable) {
+        return ResourceLocation.fromNamespaceAndPath(Antarchy.MODID, "textures/entity/lurking_terror.png");
+    }
+
+    @Override
+    public ResourceLocation getAnimationResource(LurkingTerrorEntity animatable) {
+        return ResourceLocation.fromNamespaceAndPath(Antarchy.MODID, "animations/lurking_terror.animation.json");
+    }
+}

common/src/main/java/com/craisinlord/antarchy/content/client/renderer/CreepingHorrorRenderer.java

@@ -0,0 +1,28 @@
+package com.craisinlord.antarchy.content.client.renderer;
+
+import com.craisinlord.antarchy.content.client.model.CreepingHorrorModel;
+import com.craisinlord.antarchy.content.entity.CreepingHorrorEntity;
+import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.blaze3d.vertex.VertexConsumer;
+import com.mojang.math.Axis;
+import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.client.renderer.entity.EntityRendererProvider;
+import org.jetbrains.annotations.Nullable;
+import software.bernie.geckolib.cache.object.BakedGeoModel;
+import software.bernie.geckolib.renderer.GeoEntityRenderer;
+
+public class CreepingHorrorRenderer extends GeoEntityRenderer<CreepingHorrorEntity> {
+    public CreepingHorrorRenderer(EntityRendererProvider.Context context) {
+        super(context, new CreepingHorrorModel());
+        this.shadowRadius = 0.5F;
+    }
+
+    @Override
+    public void preRender(PoseStack poseStack, CreepingHorrorEntity animatable, BakedGeoModel model, @Nullable MultiBufferSource bufferSource, @Nullable VertexConsumer buffer, boolean isReRender, float partialTick, int packedLight, int packedOverlay, int colour) {
+        super.preRender(poseStack, animatable, model, bufferSource, buffer, isReRender, partialTick, packedLight, packedOverlay, colour);
+        if (animatable.isClimbing()) {
+            poseStack.mulPose(Axis.XP.rotationDegrees(-90.0F));
+            poseStack.translate(0, -0.5, 0.5);
+        }
+    }
+}

common/src/main/java/com/craisinlord/antarchy/content/client/renderer/JumpyBugRenderer.java

@@ -0,0 +1,44 @@
+package com.craisinlord.antarchy.content.client.renderer;
+
+import com.craisinlord.antarchy.content.client.model.JumpyBugModel;
+import com.craisinlord.antarchy.content.entity.JumpyBugEntity;
+import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.blaze3d.vertex.VertexConsumer;
+import com.mojang.math.Axis;
+import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.client.renderer.entity.EntityRendererProvider;
+import net.minecraft.resources.ResourceLocation;
+import org.jetbrains.annotations.Nullable;
+import software.bernie.geckolib.cache.object.BakedGeoModel;
+import software.bernie.geckolib.renderer.GeoEntityRenderer;
+import software.bernie.geckolib.util.Color;
+
+public class JumpyBugRenderer extends GeoEntityRenderer<JumpyBugEntity> {
+    public JumpyBugRenderer(EntityRendererProvider.Context context) {
+        super(context, new JumpyBugModel());
+        this.shadowRadius = 3.0F;
+    }
+
+    @Override
+    public RenderType getRenderType(JumpyBugEntity animatable, ResourceLocation texture, @Nullable MultiBufferSource bufferSource, float partialTick) {
+        return animatable.isCamouflaged() ? RenderType.entityTranslucent(texture) : RenderType.entityCutoutNoCull(texture);
+    }
+
+    @Override
+    public Color getRenderColor(JumpyBugEntity animatable, float partialTick, int packedLight) {
+        int alpha = Math.max(10, Math.min(255, Math.round(animatable.getVisualAlpha(partialTick) * 255.0F)));
+        return Color.ofRGBA(255, 255, 255, alpha);
+    }
+
+    @Override
+    public void preRender(PoseStack poseStack, JumpyBugEntity animatable, BakedGeoModel model, @Nullable MultiBufferSource bufferSource, @Nullable VertexConsumer buffer, boolean isReRender, float partialTick, int packedLight, int packedOverlay, int colour) {
+        super.preRender(poseStack, animatable, model, bufferSource, buffer, isReRender, partialTick, packedLight, packedOverlay, colour);
+        this.shadowRadius = animatable.isCamouflaged() ? 1.0F : 3.0F;
+
+        if (animatable.isClingingToCeiling()) {
+            poseStack.translate(0.0F, animatable.getBbHeight() + 0.05F, 0.0F);
+            poseStack.mulPose(Axis.ZP.rotationDegrees(180.0F));
+        }
+    }
+}

common/src/main/java/com/craisinlord/antarchy/content/client/renderer/LurkingTerrorRenderer.java

@@ -0,0 +1,13 @@
+package com.craisinlord.antarchy.content.client.renderer;
+
+import com.craisinlord.antarchy.content.client.model.LurkingTerrorModel;
+import com.craisinlord.antarchy.content.entity.LurkingTerrorEntity;
+import net.minecraft.client.renderer.entity.EntityRendererProvider;
+import software.bernie.geckolib.renderer.GeoEntityRenderer;
+
+public class LurkingTerrorRenderer extends GeoEntityRenderer<LurkingTerrorEntity> {
+    public LurkingTerrorRenderer(EntityRendererProvider.Context context) {
+        super(context, new LurkingTerrorModel());
+        this.shadowRadius = 0.5F;
+    }
+}

common/src/main/java/com/craisinlord/antarchy/content/entity/CreepingHorrorEntity.java

@@ -0,0 +1,130 @@
+package com.craisinlord.antarchy.content.entity;
+
+import com.craisinlord.antarchy.config.AntarchySettings;
+import net.minecraft.network.syncher.EntityDataAccessor;
+import net.minecraft.network.syncher.EntityDataSerializers;
+import net.minecraft.network.syncher.SynchedEntityData;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.Mob;
+import net.minecraft.world.entity.ai.attributes.AttributeSupplier;
+import net.minecraft.world.entity.ai.attributes.Attributes;
+import net.minecraft.world.entity.ai.goal.FloatGoal;
+import net.minecraft.world.entity.ai.goal.LookAtPlayerGoal;
+import net.minecraft.world.entity.ai.goal.MeleeAttackGoal;
+import net.minecraft.world.entity.ai.goal.RandomLookAroundGoal;
+import net.minecraft.world.entity.ai.goal.WaterAvoidingRandomStrollGoal;
+import net.minecraft.world.entity.ai.goal.target.HurtByTargetGoal;
+import net.minecraft.world.entity.ai.goal.target.NearestAttackableTargetGoal;
+import net.minecraft.world.entity.monster.Monster;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.Level;
+import software.bernie.geckolib.animatable.GeoEntity;
+import software.bernie.geckolib.animatable.instance.AnimatableInstanceCache;
+import software.bernie.geckolib.animation.AnimatableManager;
+import software.bernie.geckolib.animation.AnimationController;
+import software.bernie.geckolib.animation.AnimationState;
+import software.bernie.geckolib.animation.PlayState;
+import software.bernie.geckolib.animation.RawAnimation;
+import software.bernie.geckolib.util.GeckoLibUtil;
+
+public class CreepingHorrorEntity extends Monster implements GeoEntity {
+    private static final EntityDataAccessor<Boolean> CLIMBING =
+            SynchedEntityData.defineId(JumpyBugEntity.class, EntityDataSerializers.BOOLEAN);
+
+    private static final RawAnimation IDLE_ANIM = RawAnimation.begin().thenLoop("idle");
+    private static final RawAnimation WALK_ANIM = RawAnimation.begin().thenLoop("walk");
+    private static final RawAnimation ATTACK_ANIM = RawAnimation.begin().thenLoop("attack");
+    private static final byte ATTACK_ANIM_EVENT = 4;
+
+    private final AnimatableInstanceCache geoCache = GeckoLibUtil.createInstanceCache(this);
+    private int attackAnimTicks = 0;
+
+    public CreepingHorrorEntity(EntityType<? extends CreepingHorrorEntity> type, Level level) {
+        super(type, level);
+    }
+
+    @Override
+    public float maxUpStep() {
+        return 1.0F;
+    }
+
+    @Override
+    protected void defineSynchedData(SynchedEntityData.Builder builder) {
+        super.defineSynchedData(builder);
+        builder.define(CLIMBING, false);
+    }
+
+    public static AttributeSupplier.Builder createAttributes() {
+        return Mob.createMobAttributes()
+                .add(Attributes.MAX_HEALTH, AntarchySettings.creepingHorrorHealth())
+                .add(Attributes.MOVEMENT_SPEED, 0.30D)
+                .add(Attributes.ATTACK_DAMAGE, AntarchySettings.creepingHorrorAttackDamage())
+                .add(Attributes.FOLLOW_RANGE, 16.0D);
+    }
+
+    @Override
+    protected void registerGoals() {
+        this.goalSelector.addGoal(0, new FloatGoal(this));
+        this.goalSelector.addGoal(1, new MeleeAttackGoal(this, 1.0D, true));
+        this.goalSelector.addGoal(2, new WaterAvoidingRandomStrollGoal(this, 0.85D));
+        this.goalSelector.addGoal(3, new LookAtPlayerGoal(this, Player.class, 8.0F));
+        this.goalSelector.addGoal(4, new RandomLookAroundGoal(this));
+        this.targetSelector.addGoal(1, new HurtByTargetGoal(this));
+        this.targetSelector.addGoal(2, new NearestAttackableTargetGoal<>(this, Player.class, true));
+    }
+
+    @Override
+    public boolean onClimbable() {
+        return this.horizontalCollision;
+    }
+
+    @Override
+    public void registerControllers(AnimatableManager.ControllerRegistrar controllers) {
+        controllers.add(new AnimationController<>(this, "main_controller", 3, this::mainAnimController));
+    }
+
+    private PlayState mainAnimController(AnimationState<CreepingHorrorEntity> state) {
+        if (attackAnimTicks > 0) {
+            return state.setAndContinue(ATTACK_ANIM);
+        }
+        if (state.isMoving()) {
+            return state.setAndContinue(WALK_ANIM);
+        }
+        return state.setAndContinue(IDLE_ANIM);
+    }
+
+    @Override
+    public AnimatableInstanceCache getAnimatableInstanceCache() {
+        return geoCache;
+    }
+
+    @Override
+    public boolean doHurtTarget(net.minecraft.world.entity.Entity target) {
+        boolean result = super.doHurtTarget(target);
+        if (result) {
+            attackAnimTicks = 20;
+            this.level().broadcastEntityEvent(this, ATTACK_ANIM_EVENT);
+        }
+        return result;
+    }
+
+    @Override
+    public void handleEntityEvent(byte id) {
+        if (id == ATTACK_ANIM_EVENT) {
+            attackAnimTicks = 20;
+            return;
+        }
+        super.handleEntityEvent(id);
+    }
+
+    @Override
+    public void tick() {
+        super.tick();
+        if (attackAnimTicks > 0) attackAnimTicks--;
+    }
+
+    //TODO IT NEVER ACTUALLY SETS TO CLIMBING
+    public boolean isClimbing() {
+        return this.entityData.get(CLIMBING);
+    }
+}

common/src/main/java/com/craisinlord/antarchy/content/entity/JumpyBugEntity.java

@@ -0,0 +1,738 @@
+package com.craisinlord.antarchy.content.entity;
+
+import com.craisinlord.antarchy.config.AntarchySettings;
+import com.mojang.serialization.Codec;
+import net.minecraft.core.BlockPos;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.syncher.EntityDataAccessor;
+import net.minecraft.network.syncher.EntityDataSerializers;
+import net.minecraft.network.syncher.SynchedEntityData;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.sounds.SoundEvent;
+import net.minecraft.sounds.SoundEvents;
+import net.minecraft.util.ByIdMap;
+import net.minecraft.util.Mth;
+import net.minecraft.util.RandomSource;
+import net.minecraft.util.StringRepresentable;
+import net.minecraft.world.Difficulty;
+import net.minecraft.world.DifficultyInstance;
+import net.minecraft.world.damagesource.DamageSource;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.Mob;
+import net.minecraft.world.entity.MobSpawnType;
+import net.minecraft.world.entity.MoverType;
+import net.minecraft.world.entity.SpawnGroupData;
+import net.minecraft.world.entity.ai.attributes.AttributeSupplier;
+import net.minecraft.world.entity.ai.attributes.Attributes;
+import net.minecraft.world.entity.ai.goal.FloatGoal;
+import net.minecraft.world.entity.ai.goal.Goal;
+import net.minecraft.world.entity.ai.goal.LookAtPlayerGoal;
+import net.minecraft.world.entity.ai.goal.RandomLookAroundGoal;
+import net.minecraft.world.entity.ai.goal.RandomStrollGoal;
+import net.minecraft.world.entity.ai.goal.target.HurtByTargetGoal;
+import net.minecraft.world.entity.ai.goal.target.NearestAttackableTargetGoal;
+import net.minecraft.world.entity.monster.Monster;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.ServerLevelAccessor;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.levelgen.Heightmap;
+import net.minecraft.world.phys.Vec3;
+import org.jetbrains.annotations.Nullable;
+import software.bernie.geckolib.animatable.GeoEntity;
+import software.bernie.geckolib.animatable.instance.AnimatableInstanceCache;
+import software.bernie.geckolib.animation.AnimatableManager;
+import software.bernie.geckolib.animation.AnimationController;
+import software.bernie.geckolib.animation.AnimationState;
+import software.bernie.geckolib.animation.PlayState;
+import software.bernie.geckolib.animation.RawAnimation;
+import software.bernie.geckolib.util.GeckoLibUtil;
+
+import java.util.EnumSet;
+import java.util.function.IntFunction;
+
+public class JumpyBugEntity extends Monster implements GeoEntity {
+    private static final EntityDataAccessor<Boolean> CAMOUFLAGED =
+            SynchedEntityData.defineId(JumpyBugEntity.class, EntityDataSerializers.BOOLEAN);
+    private static final EntityDataAccessor<Boolean> CLINGING_TO_CEILING =
+            SynchedEntityData.defineId(JumpyBugEntity.class, EntityDataSerializers.BOOLEAN);
+    private static final EntityDataAccessor<Integer> LATCHED_TARGET_ID =
+            SynchedEntityData.defineId(JumpyBugEntity.class, EntityDataSerializers.INT);
+    private static final EntityDataAccessor<Integer> ATTACK_STATE =
+            SynchedEntityData.defineId(JumpyBugEntity.class, EntityDataSerializers.INT);
+
+    private static final String POUNCE_COOLDOWN_KEY = "PounceCooldown";
+    private static final String LATCH_COOLDOWN_KEY = "LatchCooldown";
+    private static final String LATCH_TICKS_KEY = "LatchTicksRemaining";
+    private static final String BITE_COOLDOWN_KEY = "BiteCooldown";
+    private static final String RECOVERY_TICKS_KEY = "RecoveryTicks";
+    private static final String POUNCE_TICKS_KEY = "PounceTicks";
+
+    private static final double DEFAULT_MOVEMENT_SPEED = 0.25D;
+    private static final double DEFAULT_FOLLOW_RANGE = 16.0D;
+    private static final double DEFAULT_POUNCE_RANGE = 8.0D;
+    private static final int DEFAULT_LATCH_DURATION = 80;
+    private static final int DEFAULT_BITE_INTERVAL = 15;
+    private static final int DEFAULT_POUNCE_COOLDOWN = 60;
+    private static final int DEFAULT_LATCH_COOLDOWN = 80;
+    private static final int DEFAULT_RECOVERY_TICKS = 20;
+    private static final double POUNCE_HORIZONTAL_SPEED = 0.92D;
+    private static final double POUNCE_UPWARD_SPEED = 0.45D;
+    private static final double QUICK_MOVE_SQR = 0.14D * 0.14D;
+    private static final double CLING_SEARCH_RANGE = 1.5D;
+    private static final double LATCH_CHECK_RANGE = 0.85D;
+
+    private static final RawAnimation IDLE_ANIM = RawAnimation.begin().thenLoop("idle");
+    private static final RawAnimation WALK_ANIM = RawAnimation.begin().thenLoop("walk");
+    private static final RawAnimation JUMP_ANIM = RawAnimation.begin().thenLoop("jump");
+    private static final RawAnimation ATTACK_ANIM = RawAnimation.begin().thenPlay("attack");
+
+    private final AnimatableInstanceCache geoCache = GeckoLibUtil.createInstanceCache(this);
+
+    private int pounceCooldownTicks;
+    private int latchCooldownTicks;
+    private int latchTicksRemaining;
+    private int biteCooldownTicks;
+    private int recoveryTicks;
+    private int pounceTicks;
+    private float visualAlpha = 1.0F;
+    private float previousVisualAlpha = 1.0F;
+
+    public JumpyBugEntity(EntityType<? extends JumpyBugEntity> entityType, Level level) {
+        super(entityType, level);
+        this.xpReward = 6;
+    }
+
+    public static AttributeSupplier.Builder createAttributes() {
+        return Mob.createMobAttributes()
+                .add(Attributes.MAX_HEALTH, AntarchySettings.jumpyBugHealth())
+                .add(Attributes.ATTACK_DAMAGE, AntarchySettings.jumpyBugPounceDamage())
+                .add(Attributes.MOVEMENT_SPEED, DEFAULT_MOVEMENT_SPEED)
+                .add(Attributes.FOLLOW_RANGE, DEFAULT_FOLLOW_RANGE);
+    }
+
+    public static boolean canSpawn(EntityType<JumpyBugEntity> entityType, ServerLevelAccessor level, MobSpawnType spawnReason, BlockPos pos, RandomSource random) {
+        if (spawnReason == MobSpawnType.SPAWN_EGG || spawnReason == MobSpawnType.SPAWNER || spawnReason == MobSpawnType.COMMAND) {
+            return true;
+        }
+
+        return level.getDifficulty() != Difficulty.PEACEFUL
+                && Monster.checkMonsterSpawnRules(entityType, level, spawnReason, pos, random);
+    }
+
+    @Override
+    protected void defineSynchedData(SynchedEntityData.Builder builder) {
+        super.defineSynchedData(builder);
+        builder.define(CAMOUFLAGED, false);
+        builder.define(CLINGING_TO_CEILING, false);
+        builder.define(LATCHED_TARGET_ID, -1);
+        builder.define(ATTACK_STATE, AttackState.GROUND.id());
+    }
+
+    @Override
+    protected void registerGoals() {
+        this.goalSelector.addGoal(0, new FloatGoal(this));
+        this.goalSelector.addGoal(1, new LatchedGoal());
+        this.goalSelector.addGoal(2, new PounceAttackGoal());
+        this.goalSelector.addGoal(3, new CeilingClingGoal());
+        this.goalSelector.addGoal(4, new ChaseTargetGoal());
+        this.goalSelector.addGoal(5, new WanderGoal());
+        this.goalSelector.addGoal(6, new LookAtPlayerGoal(this, Player.class, 10.0F));
+        this.goalSelector.addGoal(7, new RandomLookAroundGoal(this));
+        this.targetSelector.addGoal(1, new HurtByTargetGoal(this));
+        this.targetSelector.addGoal(2, new NearestAttackableTargetGoal<>(this, Player.class, true));
+    }
+
+    @Override
+    public void registerControllers(AnimatableManager.ControllerRegistrar controllers) {
+        controllers.add(new AnimationController<>(this, "main_controller", 2, this::mainAnimController));
+    }
+
+    @Override
+    public AnimatableInstanceCache getAnimatableInstanceCache() {
+        return this.geoCache;
+    }
+
+    @Override
+    public void addAdditionalSaveData(CompoundTag tag) {
+        super.addAdditionalSaveData(tag);
+        tag.putInt(POUNCE_COOLDOWN_KEY, this.pounceCooldownTicks);
+        tag.putInt(LATCH_COOLDOWN_KEY, this.latchCooldownTicks);
+        tag.putInt(LATCH_TICKS_KEY, this.latchTicksRemaining);
+        tag.putInt(BITE_COOLDOWN_KEY, this.biteCooldownTicks);
+        tag.putInt(RECOVERY_TICKS_KEY, this.recoveryTicks);
+        tag.putInt(POUNCE_TICKS_KEY, this.pounceTicks);
+    }
+
+    @Override
+    public void readAdditionalSaveData(CompoundTag tag) {
+        super.readAdditionalSaveData(tag);
+        this.pounceCooldownTicks = tag.getInt(POUNCE_COOLDOWN_KEY);
+        this.latchCooldownTicks = tag.getInt(LATCH_COOLDOWN_KEY);
+        this.latchTicksRemaining = tag.getInt(LATCH_TICKS_KEY);
+        this.biteCooldownTicks = tag.getInt(BITE_COOLDOWN_KEY);
+        this.recoveryTicks = tag.getInt(RECOVERY_TICKS_KEY);
+        this.pounceTicks = tag.getInt(POUNCE_TICKS_KEY);
+    }
+
+    @Override
+    @Nullable
+    public SpawnGroupData finalizeSpawn(ServerLevelAccessor level, DifficultyInstance difficulty, MobSpawnType spawnReason, @Nullable SpawnGroupData spawnGroupData) {
+        this.setHealth((float) AntarchySettings.jumpyBugHealth());
+        return super.finalizeSpawn(level, difficulty, spawnReason, spawnGroupData);
+    }
+
+    @Override
+    public void tick() {
+        this.previousVisualAlpha = this.visualAlpha;
+        this.visualAlpha += (this.getTargetVisualAlpha() - this.visualAlpha) * 0.25F;
+
+        super.tick();
+
+        if (this.level().isClientSide) {
+            return;
+        }
+
+        if (this.pounceCooldownTicks > 0) {
+            this.pounceCooldownTicks--;
+        }
+        if (this.latchCooldownTicks > 0) {
+            this.latchCooldownTicks--;
+        }
+        if (this.biteCooldownTicks > 0) {
+            this.biteCooldownTicks--;
+        }
+        if (this.recoveryTicks > 0) {
+            this.recoveryTicks--;
+        }
+
+        if (this.isLatched()) {
+            this.tickLatched();
+        } else if (this.isClingingToCeiling()) {
+            this.tickClinging();
+        } else if (this.isPouncing()) {
+            this.tickPouncing();
+        } else {
+            this.setNoGravity(false);
+            this.noPhysics = false;
+            if (this.getAttackState() != AttackState.RECOVERING || this.recoveryTicks <= 0) {
+                this.setAttackState(AttackState.GROUND);
+            }
+        }
+
+        this.updateCamouflage();
+    }
+
+    @Override
+    public void travel(Vec3 travelVector) {
+        if (this.isLatched() || this.isClingingToCeiling()) {
+            this.setDeltaMovement(Vec3.ZERO);
+            return;
+        }
+        super.travel(travelVector);
+    }
+
+    @Override
+    public boolean hurt(DamageSource source, float amount) {
+        boolean hurt = super.hurt(source, amount);
+        if (!hurt) {
+            return false;
+        }
+
+        this.setCamouflaged(false);
+        this.recoveryTicks = Math.max(this.recoveryTicks, DEFAULT_RECOVERY_TICKS);
+        if (this.isLatched()) {
+            this.detachFromTarget(true);
+        }
+        if (this.isClingingToCeiling()) {
+            this.stopClinging();
+        }
+        if (this.isPouncing()) {
+            this.finishPounce(false);
+        }
+        return true;
+    }
+
+    @Override
+    public boolean causeFallDamage(float fallDistance, float multiplier, DamageSource source) {
+        return false;
+    }
+
+    @Override
+    protected SoundEvent getAmbientSound() {
+        return SoundEvents.SPIDER_AMBIENT;
+    }
+
+    @Override
+    protected SoundEvent getHurtSound(DamageSource damageSource) {
+        return SoundEvents.SPIDER_HURT;
+    }
+
+    @Override
+    protected SoundEvent getDeathSound() {
+        return SoundEvents.SPIDER_DEATH;
+    }
+
+    @Override
+    protected void playStepSound(BlockPos pos, BlockState blockState) {
+        this.playSound(SoundEvents.SPIDER_STEP, 0.12F, 1.1F);
+    }
+
+    public boolean isCamouflaged() {
+        return this.entityData.get(CAMOUFLAGED);
+    }
+
+    public boolean isClingingToCeiling() {
+        return this.entityData.get(CLINGING_TO_CEILING);
+    }
+
+    public boolean isLatched() {
+        return this.entityData.get(LATCHED_TARGET_ID) != -1;
+    }
+
+    public boolean isLatchedTo(LivingEntity entity) {
+        return this.entityData.get(LATCHED_TARGET_ID) == entity.getId();
+    }
+
+    public boolean isPouncing() {
+        return this.getAttackState() == AttackState.POUNCING;
+    }
+
+    public float getVisualAlpha(float partialTick) {
+        return Mth.lerp(partialTick, this.previousVisualAlpha, this.visualAlpha);
+    }
+
+    public AttackState getAttackState() {
+        return AttackState.BY_ID.apply(this.entityData.get(ATTACK_STATE));
+    }
+
+    private void setCamouflaged(boolean value) {
+        this.entityData.set(CAMOUFLAGED, value);
+    }
+
+    private void setClingingToCeiling(boolean value) {
+        this.entityData.set(CLINGING_TO_CEILING, value);
+    }
+
+    private void setAttackState(AttackState state) {
+        this.entityData.set(ATTACK_STATE, state.id());
+    }
+
+    private float getTargetVisualAlpha() {
+        return this.isCamouflaged() ? (float) AntarchySettings.jumpyBugCamouflageAlpha() : 1.0F;
+    }
+
+    private PlayState mainAnimController(AnimationState<JumpyBugEntity> state) {
+        AttackState attackState = this.getAttackState();
+        if (attackState == AttackState.POUNCING || attackState == AttackState.LATCHED || attackState == AttackState.CLINGING) {
+            return state.setAndContinue(JUMP_ANIM);
+        }
+        if (attackState == AttackState.RECOVERING) {
+            return state.setAndContinue(ATTACK_ANIM);
+        }
+        return state.setAndContinue(state.isMoving() ? WALK_ANIM : IDLE_ANIM);
+    }
+
+    private void tickClinging() {
+        BlockPos clingPos = this.findClingBlockPos();
+        if (clingPos == null) {
+            this.stopClinging();
+            return;
+        }
+
+        this.setAttackState(AttackState.CLINGING);
+        this.setCamouflaged(true);
+        this.setNoGravity(true);
+        this.noPhysics = true;
+        this.getNavigation().stop();
+        this.setDeltaMovement(Vec3.ZERO);
+        this.move(MoverType.SELF, Vec3.ZERO);
+        this.setPos(this.getX(), clingPos.getY() - this.getBbHeight() - 0.01D, this.getZ());
+    }
+
+    private void tickPouncing() {
+        this.setAttackState(AttackState.POUNCING);
+        this.setCamouflaged(false);
+        this.pounceTicks++;
+        LivingEntity target = this.getTarget();
+        if (target != null && target.isAlive() && this.distanceToSqr(target) <= (this.getBbWidth() + target.getBbWidth() + LATCH_CHECK_RANGE) * (this.getBbWidth() + target.getBbWidth() + LATCH_CHECK_RANGE)) {
+            if (this.tryLatch(target)) {
+                return;
+            }
+        }
+
+        if (this.onGround() && this.pounceTicks > 4) {
+            this.finishPounce(false);
+        }
+    }
+
+    private void tickLatched() {
+        LivingEntity target = this.getLatchedTarget();
+        if (target == null || !target.isAlive() || target.level() != this.level() || target.isRemoved() || target.isInWater()) {
+            this.detachFromTarget(false);
+            return;
+        }
+
+        this.setAttackState(AttackState.LATCHED);
+        this.setCamouflaged(false);
+        this.setNoGravity(true);
+        this.noPhysics = true;
+        this.getNavigation().stop();
+        this.setDeltaMovement(Vec3.ZERO);
+
+        Vec3 latchPos = this.getLatchPosition(target);
+        this.setPos(latchPos.x, latchPos.y, latchPos.z);
+        this.yRotO = this.getYRot();
+        this.setYRot(target.getYHeadRot());
+        this.setYBodyRot(target.getYHeadRot());
+        this.setYHeadRot(target.getYHeadRot());
+        this.setXRot(-20.0F);
+
+        if (--this.latchTicksRemaining <= 0) {
+            this.detachFromTarget(true);
+            return;
+        }
+
+        if (this.biteCooldownTicks <= 0) {
+            target.hurt(this.damageSources().mobAttack(this), (float) AntarchySettings.jumpyBugLatchDamage());
+            this.biteCooldownTicks = DEFAULT_BITE_INTERVAL;
+            this.playSound(SoundEvents.SPIDER_HURT, 0.35F, 1.5F + this.random.nextFloat() * 0.2F);
+        }
+    }
+
+    private void updateCamouflage() {
+        if (this.isLatched() || this.isPouncing()) {
+            this.setCamouflaged(false);
+            return;
+        }
+
+        boolean idle = this.getTarget() == null && this.getDeltaMovement().horizontalDistanceSqr() < 0.003D;
+        boolean stalking = this.isClingingToCeiling();
+        boolean movingQuickly = this.getDeltaMovement().lengthSqr() > QUICK_MOVE_SQR;
+        boolean shouldCamouflage = !movingQuickly && (idle || stalking);
+        this.setCamouflaged(shouldCamouflage);
+    }
+
+    private boolean tryLatch(LivingEntity target) {
+        if (!(target instanceof Player) || this.latchCooldownTicks > 0 || this.isLatched()) {
+            return false;
+        }
+        if (this.level().getEntitiesOfClass(JumpyBugEntity.class, target.getBoundingBox().inflate(0.75D),
+                bug -> bug != this && bug.isLatchedTo(target)).isEmpty()) {
+            this.entityData.set(LATCHED_TARGET_ID, target.getId());
+            this.latchTicksRemaining = DEFAULT_LATCH_DURATION;
+            this.biteCooldownTicks = 0;
+            this.pounceTicks = 0;
+            this.setAttackState(AttackState.LATCHED);
+            this.setTarget(target);
+            target.hurt(this.damageSources().mobAttack(this), (float) AntarchySettings.jumpyBugPounceDamage());
+            return true;
+        }
+        return false;
+    }
+
+    private void detachFromTarget(boolean knockAway) {
+        LivingEntity target = this.getLatchedTarget();
+        this.entityData.set(LATCHED_TARGET_ID, -1);
+        this.latchTicksRemaining = 0;
+        this.biteCooldownTicks = DEFAULT_BITE_INTERVAL;
+        this.latchCooldownTicks = DEFAULT_LATCH_COOLDOWN;
+        this.setAttackState(AttackState.RECOVERING);
+        this.recoveryTicks = DEFAULT_RECOVERY_TICKS;
+        this.setNoGravity(false);
+        this.noPhysics = false;
+
+        if (knockAway && target != null) {
+            Vec3 away = this.position().subtract(target.position());
+            if (away.lengthSqr() < 1.0E-4D) {
+                away = target.getLookAngle().scale(-1.0D);
+            }
+            away = away.normalize();
+            this.setDeltaMovement(away.x * 0.35D, 0.25D, away.z * 0.35D);
+            this.hasImpulse = true;
+        }
+    }
+
+    @Nullable
+    private LivingEntity getLatchedTarget() {
+        int entityId = this.entityData.get(LATCHED_TARGET_ID);
+        if (entityId == -1) {
+            return null;
+        }
+
+        Entity entity = this.level().getEntity(entityId);
+        return entity instanceof LivingEntity livingEntity ? livingEntity : null;
+    }
+
+    private Vec3 getLatchPosition(LivingEntity target) {
+        Vec3 eyePos = target.position().add(0.0D, target.getEyeHeight() - 0.15D, 0.0D);
+        Vec3 backOffset = target.getLookAngle().normalize().scale(-0.16D);
+        return eyePos.add(backOffset).add(0.0D, -0.18D, 0.0D);
+    }
+
+    @Nullable
+    private BlockPos findClingBlockPos() {
+        BlockPos origin = this.blockPosition();
+        for (int dy = 1; dy <= 2; dy++) {
+            BlockPos candidate = origin.above(dy);
+            if (this.isCeilingBlock(candidate)) {
+                return candidate;
+            }
+        }
+        return null;
+    }
+
+    private boolean isCeilingBlock(BlockPos pos) {
+        return this.level().getBlockState(pos).isFaceSturdy(this.level(), pos, net.minecraft.core.Direction.DOWN);
+    }
+
+    private boolean canClingHere() {
+        return this.findClingBlockPos() != null;
+    }
+
+    private void beginClinging() {
+        this.setClingingToCeiling(true);
+        this.setAttackState(AttackState.CLINGING);
+        this.setNoGravity(true);
+        this.noPhysics = true;
+        this.getNavigation().stop();
+        this.setDeltaMovement(Vec3.ZERO);
+    }
+
+    private void stopClinging() {
+        this.setClingingToCeiling(false);
+        this.setAttackState(AttackState.GROUND);
+        this.setNoGravity(false);
+        this.noPhysics = false;
+    }
+
+    private void beginPounce(LivingEntity target) {
+        this.stopClinging();
+        this.setTarget(target);
+        this.setAttackState(AttackState.POUNCING);
+        this.setCamouflaged(false);
+        this.getNavigation().stop();
+        this.pounceCooldownTicks = DEFAULT_POUNCE_COOLDOWN;
+        this.pounceTicks = 0;
+
+        Vec3 from = this.position();
+        Vec3 to = target.getEyePosition().subtract(from);
+        Vec3 horizontal = new Vec3(to.x, 0.0D, to.z);
+        Vec3 direction = horizontal.lengthSqr() > 1.0E-4D ? horizontal.normalize() : target.getLookAngle();
+        double upward = POUNCE_UPWARD_SPEED + Mth.clamp(to.y * 0.08D, -0.04D, 0.22D);
+        this.setDeltaMovement(direction.x * POUNCE_HORIZONTAL_SPEED, upward, direction.z * POUNCE_HORIZONTAL_SPEED);
+        this.hasImpulse = true;
+    }
+
+    private void finishPounce(boolean keepMomentum) {
+        this.pounceTicks = 0;
+        if (!keepMomentum) {
+            Vec3 movement = this.getDeltaMovement();
+            this.setDeltaMovement(movement.x * 0.25D, Math.max(0.0D, movement.y), movement.z * 0.25D);
+        }
+        this.setAttackState(AttackState.RECOVERING);
+        this.recoveryTicks = DEFAULT_RECOVERY_TICKS;
+    }
+
+    private boolean canUseAmbush() {
+        return !this.isLatched()
+                && !this.isPouncing()
+                && this.recoveryTicks <= 0
+                && this.latchCooldownTicks <= 0;
+    }
+
+    private enum AttackState implements StringRepresentable {
+        GROUND(0, "ground"),
+        CLINGING(1, "clinging"),
+        POUNCING(2, "pouncing"),
+        LATCHED(3, "latched"),
+        RECOVERING(4, "recovering");
+
+        private static final IntFunction<AttackState> BY_ID = ByIdMap.continuous(AttackState::id, values(), ByIdMap.OutOfBoundsStrategy.ZERO);
+        public static final Codec<AttackState> CODEC = StringRepresentable.fromEnum(AttackState::values);
+
+        private final int id;
+        private final String name;
+
+        AttackState(int id, String name) {
+            this.id = id;
+            this.name = name;
+        }
+
+        public int id() {
+            return this.id;
+        }
+
+        @Override
+        public String getSerializedName() {
+            return this.name;
+        }
+    }
+
+    private final class LatchedGoal extends Goal {
+        private LatchedGoal() {
+            this.setFlags(EnumSet.of(Flag.MOVE, Flag.LOOK, Flag.JUMP));
+        }
+
+        @Override
+        public boolean canUse() {
+            return JumpyBugEntity.this.isLatched();
+        }
+
+        @Override
+        public boolean canContinueToUse() {
+            return JumpyBugEntity.this.isLatched();
+        }
+
+        @Override
+        public void tick() {
+            JumpyBugEntity.this.getNavigation().stop();
+        }
+    }
+
+    private final class PounceAttackGoal extends Goal {
+        private PounceAttackGoal() {
+            this.setFlags(EnumSet.of(Flag.MOVE, Flag.LOOK, Flag.JUMP));
+        }
+
+        @Override
+        public boolean canUse() {
+            LivingEntity target = JumpyBugEntity.this.getTarget();
+            return target != null
+                    && target.isAlive()
+                    && JumpyBugEntity.this.canUseAmbush()
+                    && JumpyBugEntity.this.pounceCooldownTicks <= 0
+                    && JumpyBugEntity.this.distanceToSqr(target) <= DEFAULT_POUNCE_RANGE * DEFAULT_POUNCE_RANGE
+                    && (JumpyBugEntity.this.hasLineOfSight(target) || JumpyBugEntity.this.distanceToSqr(target) <= 9.0D);
+        }
+
+        @Override
+        public boolean canContinueToUse() {
+            return JumpyBugEntity.this.isPouncing();
+        }
+
+        @Override
+        public void start() {
+            LivingEntity target = JumpyBugEntity.this.getTarget();
+            if (target != null) {
+                JumpyBugEntity.this.beginPounce(target);
+            }
+        }
+    }
+
+    private final class CeilingClingGoal extends Goal {
+        private CeilingClingGoal() {
+            this.setFlags(EnumSet.of(Flag.MOVE, Flag.LOOK, Flag.JUMP));
+        }
+
+        @Override
+        public boolean canUse() {
+            if (!JumpyBugEntity.this.canUseAmbush() || JumpyBugEntity.this.isClingingToCeiling()) {
+                return false;
+            }
+
+            LivingEntity target = JumpyBugEntity.this.getTarget();
+            if (target == null) {
+                return JumpyBugEntity.this.random.nextInt(40) == 0 && JumpyBugEntity.this.canClingHere();
+            }
+
+            return JumpyBugEntity.this.distanceToSqr(target) <= (DEFAULT_POUNCE_RANGE + CLING_SEARCH_RANGE) * (DEFAULT_POUNCE_RANGE + CLING_SEARCH_RANGE)
+                    && JumpyBugEntity.this.canClingHere();
+        }
+
+        @Override
+        public boolean canContinueToUse() {
+            return JumpyBugEntity.this.isClingingToCeiling();
+        }
+
+        @Override
+        public void start() {
+            JumpyBugEntity.this.beginClinging();
+        }
+
+        @Override
+        public void stop() {
+            if (JumpyBugEntity.this.isClingingToCeiling()) {
+                JumpyBugEntity.this.stopClinging();
+            }
+        }
+
+        @Override
+        public void tick() {
+            LivingEntity target = JumpyBugEntity.this.getTarget();
+            if (target == null) {
+                return;
+            }
+
+            JumpyBugEntity.this.getLookControl().setLookAt(target, 30.0F, 30.0F);
+            if (JumpyBugEntity.this.pounceCooldownTicks <= 0
+                    && JumpyBugEntity.this.distanceToSqr(target) <= DEFAULT_POUNCE_RANGE * DEFAULT_POUNCE_RANGE
+                    && (JumpyBugEntity.this.hasLineOfSight(target) || JumpyBugEntity.this.distanceToSqr(target) <= 4.0D)) {
+                JumpyBugEntity.this.stopClinging();
+                JumpyBugEntity.this.beginPounce(target);
+            }
+        }
+    }
+
+    private final class ChaseTargetGoal extends Goal {
+        private ChaseTargetGoal() {
+            this.setFlags(EnumSet.of(Flag.MOVE, Flag.LOOK));
+        }
+
+        @Override
+        public boolean canUse() {
+            LivingEntity target = JumpyBugEntity.this.getTarget();
+            return target != null
+                    && target.isAlive()
+                    && !JumpyBugEntity.this.isLatched()
+                    && !JumpyBugEntity.this.isClingingToCeiling()
+                    && !JumpyBugEntity.this.isPouncing()
+                    && JumpyBugEntity.this.recoveryTicks <= 0;
+        }
+
+        @Override
+        public boolean canContinueToUse() {
+            return this.canUse();
+        }
+
+        @Override
+        public void tick() {
+            LivingEntity target = JumpyBugEntity.this.getTarget();
+            if (target == null) {
+                return;
+            }
+
+            JumpyBugEntity.this.getLookControl().setLookAt(target, 30.0F, 30.0F);
+            if (JumpyBugEntity.this.distanceToSqr(target) > DEFAULT_POUNCE_RANGE * DEFAULT_POUNCE_RANGE) {
+                JumpyBugEntity.this.getNavigation().moveTo(target, 1.05D);
+            } else {
+                JumpyBugEntity.this.getNavigation().stop();
+            }
+        }
+    }
+
+    private final class WanderGoal extends RandomStrollGoal {
+        private WanderGoal() {
+            super(JumpyBugEntity.this, 0.8D);
+        }
+
+        @Override
+        public boolean canUse() {
+            return !JumpyBugEntity.this.isLatched()
+                    && !JumpyBugEntity.this.isClingingToCeiling()
+                    && !JumpyBugEntity.this.isPouncing()
+                    && JumpyBugEntity.this.getTarget() == null
+                    && super.canUse();
+        }
+
+        @Override
+        public boolean canContinueToUse() {
+            return !JumpyBugEntity.this.isLatched()
+                    && !JumpyBugEntity.this.isClingingToCeiling()
+                    && !JumpyBugEntity.this.isPouncing()
+                    && super.canContinueToUse();
+        }
+    }
+}

common/src/main/java/com/craisinlord/antarchy/content/entity/LurkingTerrorEntity.java

@@ -0,0 +1,126 @@
+package com.craisinlord.antarchy.content.entity;
+
+import com.craisinlord.antarchy.config.AntarchySettings;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.Mob;
+import net.minecraft.world.entity.ai.attributes.AttributeSupplier;
+import net.minecraft.world.entity.ai.attributes.Attributes;
+import net.minecraft.world.entity.ai.control.FlyingMoveControl;
+import net.minecraft.world.entity.ai.goal.FloatGoal;
+import net.minecraft.world.entity.ai.goal.LookAtPlayerGoal;
+import net.minecraft.world.entity.ai.goal.MeleeAttackGoal;
+import net.minecraft.world.entity.ai.goal.RandomLookAroundGoal;
+import net.minecraft.world.entity.ai.goal.WaterAvoidingRandomStrollGoal;
+import net.minecraft.world.entity.ai.goal.target.HurtByTargetGoal;
+import net.minecraft.world.entity.ai.goal.target.NearestAttackableTargetGoal;
+import net.minecraft.world.entity.ai.navigation.FlyingPathNavigation;
+import net.minecraft.world.entity.ai.navigation.PathNavigation;
+import net.minecraft.world.entity.monster.Monster;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.Level;
+import software.bernie.geckolib.animatable.GeoEntity;
+import software.bernie.geckolib.animatable.instance.AnimatableInstanceCache;
+import software.bernie.geckolib.animation.AnimatableManager;
+import software.bernie.geckolib.animation.AnimationController;
+import software.bernie.geckolib.animation.AnimationState;
+import software.bernie.geckolib.animation.PlayState;
+import software.bernie.geckolib.animation.RawAnimation;
+import software.bernie.geckolib.util.GeckoLibUtil;
+
+public class LurkingTerrorEntity extends Monster implements GeoEntity {
+    private static final RawAnimation IDLE_ANIM = RawAnimation.begin().thenLoop("idle");
+    private static final RawAnimation WALK_ANIM = RawAnimation.begin().thenLoop("walk");
+    private static final RawAnimation ATTACK_LAND_ANIM = RawAnimation.begin().thenLoop("attackland");
+    private static final RawAnimation ATTACK_AIR_ANIM = RawAnimation.begin().thenLoop("attackair");
+    private static final byte ATTACK_ANIM_EVENT = 5;
+
+    private final AnimatableInstanceCache geoCache = GeckoLibUtil.createInstanceCache(this);
+    private int attackAnimTicks = 0;
+
+    public LurkingTerrorEntity(EntityType<? extends LurkingTerrorEntity> type, Level level) {
+        super(type, level);
+        this.moveControl = new FlyingMoveControl(this, 10, true);
+    }
+
+    public static AttributeSupplier.Builder createAttributes() {
+        return Mob.createMobAttributes()
+                .add(Attributes.MAX_HEALTH, AntarchySettings.lurkingTerrorHealth())
+                .add(Attributes.MOVEMENT_SPEED, 0.25D)
+                .add(Attributes.ATTACK_DAMAGE, AntarchySettings.lurkingTerrorAttackDamage())
+                .add(Attributes.FOLLOW_RANGE, 16.0D)
+                .add(Attributes.FLYING_SPEED, 0.4D);
+    }
+
+    @Override
+    protected PathNavigation createNavigation(Level level) {
+        FlyingPathNavigation nav = new FlyingPathNavigation(this, level);
+        nav.setCanOpenDoors(false);
+        nav.setCanFloat(true);
+        nav.setCanPassDoors(true);
+        return nav;
+    }
+
+    @Override
+    protected void registerGoals() {
+        this.goalSelector.addGoal(0, new FloatGoal(this));
+        this.goalSelector.addGoal(1, new MeleeAttackGoal(this, 1.0D, true));
+        this.goalSelector.addGoal(2, new WaterAvoidingRandomStrollGoal(this, 0.85D));
+        this.goalSelector.addGoal(3, new LookAtPlayerGoal(this, Player.class, 8.0F));
+        this.goalSelector.addGoal(4, new RandomLookAroundGoal(this));
+        this.targetSelector.addGoal(1, new HurtByTargetGoal(this));
+        this.targetSelector.addGoal(2, new NearestAttackableTargetGoal<>(this, Player.class, true));
+    }
+
+    @Override
+    public void registerControllers(AnimatableManager.ControllerRegistrar controllers) {
+        controllers.add(new AnimationController<>(this, "main_controller", 3, this::mainAnimController));
+    }
+
+    private PlayState mainAnimController(AnimationState<LurkingTerrorEntity> state) {
+        if (attackAnimTicks > 0) {
+//            if (!this.isOnGround()) {
+//                return state.setAndContinue(ATTACK_AIR_ANIM);
+//            }
+            return state.setAndContinue(ATTACK_LAND_ANIM);
+        }
+        if (state.isMoving()) {
+            return state.setAndContinue(WALK_ANIM);
+        }
+        return state.setAndContinue(IDLE_ANIM);
+    }
+
+    @Override
+    public AnimatableInstanceCache getAnimatableInstanceCache() {
+        return geoCache;
+    }
+
+    @Override
+    public boolean doHurtTarget(net.minecraft.world.entity.Entity target) {
+        boolean result = super.doHurtTarget(target);
+        if (result) {
+            attackAnimTicks = 20;
+            this.level().broadcastEntityEvent(this, ATTACK_ANIM_EVENT);
+        }
+        return result;
+    }
+
+    @Override
+    public void handleEntityEvent(byte id) {
+        if (id == ATTACK_ANIM_EVENT) {
+            attackAnimTicks = 20;
+            return;
+        }
+        super.handleEntityEvent(id);
+    }
+
+    @Override
+    public void tick() {
+        super.tick();
+        if (attackAnimTicks > 0) attackAnimTicks--;
+    }
+
+    @Override
+    public boolean causeFallDamage(float fallDistance, float multiplier, net.minecraft.world.damagesource.DamageSource source) {
+        return false;
+    }
+}

common/src/main/java/com/craisinlord/antarchy/content/entity/ToreterrorEntity.java

@@ -16,6 +16,7 @@ import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.sounds.SoundEvents;
 import net.minecraft.world.BossEvent;
 import net.minecraft.world.Difficulty;
+import net.minecraft.tags.DamageTypeTags;
 import net.minecraft.world.damagesource.DamageSource;
 import net.minecraft.world.entity.EntityType;
 import net.minecraft.world.entity.LivingEntity;
@@ -219,6 +220,10 @@ public class ToreterrorEntity extends Monster implements GeoEntity {
 
     @Override
     public boolean hurt(DamageSource source, float amount) {
+        if (source.is(net.minecraft.world.damagesource.DamageTypes.DROWN)) return false;
+        if (source.is(DamageTypeTags.IS_PROJECTILE)) {
+            amount *= (float) AntarchySettings.toreterrorProjectileDamageMultiplier();
+        }
         if (!this.isPhase2()) {
             float halfHealth = this.getMaxHealth() * 0.5F;
             if (this.getHealth() - amount <= halfHealth) {

common/src/main/java/com/craisinlord/antarchy/content/item/JumpyBootsHelper.java

@@ -0,0 +1,20 @@
+package com.craisinlord.antarchy.content.item;
+
+public final class JumpyBootsHelper {
+    public static final int CHARGE_TICKS_MAX = 30;
+    public static final int PRIME_WINDOW_TICKS = 15;
+    public static final int COOLDOWN_TICKS = 40;
+
+    public static final float MAX_VERTICAL_BOOST = 2.0F;
+    public static final float SPRINT_FORWARD_BOOST = 0.3F;
+    public static final long FALL_PROTECTION_TICKS = 120L;
+    public static final String FALL_PROTECTION_NBT_KEY = "antarchy:jumpy_boots_protection_until";
+
+    private JumpyBootsHelper() {
+    }
+
+    public static float verticalBoostFor(int chargeTicks) {
+        float ratio = Math.min(chargeTicks / (float) CHARGE_TICKS_MAX, 1.0F);
+        return ratio * MAX_VERTICAL_BOOST;
+    }
+}

common/src/main/java/com/craisinlord/antarchy/content/item/JumpyBootsItem.java

@@ -0,0 +1,33 @@
+package com.craisinlord.antarchy.content.item;
+
+import net.minecraft.ChatFormatting;
+import net.minecraft.core.Holder;
+import net.minecraft.network.chat.Component;
+import net.minecraft.world.item.ArmorItem;
+import net.minecraft.world.item.ArmorMaterial;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.TooltipFlag;
+
+import java.util.List;
+
+public final class JumpyBootsItem extends ArmorItem {
+    public JumpyBootsItem(Holder<ArmorMaterial> material, Properties properties) {
+        super(material, Type.BOOTS, properties);
+    }
+
+    public static boolean isWearingJumpyBoots(net.minecraft.world.entity.LivingEntity entity) {
+        return entity != null && entity.getItemBySlot(net.minecraft.world.entity.EquipmentSlot.FEET).getItem() instanceof JumpyBootsItem;
+    }
+
+    @Override
+    public boolean isEnchantable(ItemStack stack) {
+        return stack.getCount() == 1;
+    }
+
+    @Override
+    public void appendHoverText(ItemStack stack, Item.TooltipContext context, List<Component> tooltipComponents, TooltipFlag tooltipFlag) {
+        tooltipComponents.add(Component.translatable("tooltip.antarchy.jumpy_boots").withStyle(ChatFormatting.DARK_RED));
+        super.appendHoverText(stack, context, tooltipComponents, tooltipFlag);
+    }
+}

common/src/main/java/com/craisinlord/antarchy/content/network/JumpyBootsLaunchPayload.java

@@ -0,0 +1,24 @@
+package com.craisinlord.antarchy.content.network;
+
+import com.craisinlord.antarchy.Antarchy;
+import io.netty.buffer.ByteBuf;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.ResourceLocation;
+
+public record JumpyBootsLaunchPayload(int chargeTicks, boolean sprinting) implements CustomPacketPayload {
+    public static final Type<JumpyBootsLaunchPayload> TYPE =
+            new Type<>(ResourceLocation.fromNamespaceAndPath(Antarchy.MODID, "jumpy_boots_launch"));
+    public static final StreamCodec<ByteBuf, JumpyBootsLaunchPayload> STREAM_CODEC =
+            StreamCodec.composite(
+                    ByteBufCodecs.VAR_INT, JumpyBootsLaunchPayload::chargeTicks,
+                    ByteBufCodecs.BOOL, JumpyBootsLaunchPayload::sprinting,
+                    JumpyBootsLaunchPayload::new
+            );
+
+    @Override
+    public Type<JumpyBootsLaunchPayload> type() {
+        return TYPE;
+    }
+}

common/src/main/resources/assets/antarchy/blockstates/creeping_horror_eggs.json

@@ -0,0 +1,76 @@
+{
+  "variants": {
+    "eggs=1,hatch=0": [
+      { "model": "antarchy:block/creeping_horror_eggs_1" },
+      { "model": "antarchy:block/creeping_horror_eggs_1", "y": 90 },
+      { "model": "antarchy:block/creeping_horror_eggs_1", "y": 180 },
+      { "model": "antarchy:block/creeping_horror_eggs_1", "y": 270 }
+    ],
+    "eggs=1,hatch=1": [
+      { "model": "antarchy:block/slightly_cracked_creeping_horror_eggs_1" },
+      { "model": "antarchy:block/slightly_cracked_creeping_horror_eggs_1", "y": 90 },
+      { "model": "antarchy:block/slightly_cracked_creeping_horror_eggs_1", "y": 180 },
+      { "model": "antarchy:block/slightly_cracked_creeping_horror_eggs_1", "y": 270 }
+    ],
+    "eggs=1,hatch=2": [
+      { "model": "antarchy:block/very_cracked_creeping_horror_eggs_1" },
+      { "model": "antarchy:block/very_cracked_creeping_horror_eggs_1", "y": 90 },
+      { "model": "antarchy:block/very_cracked_creeping_horror_eggs_1", "y": 180 },
+      { "model": "antarchy:block/very_cracked_creeping_horror_eggs_1", "y": 270 }
+    ],
+    "eggs=2,hatch=0": [
+      { "model": "antarchy:block/creeping_horror_eggs_2" },
+      { "model": "antarchy:block/creeping_horror_eggs_2", "y": 90 },
+      { "model": "antarchy:block/creeping_horror_eggs_2", "y": 180 },
+      { "model": "antarchy:block/creeping_horror_eggs_2", "y": 270 }
+    ],
+    "eggs=2,hatch=1": [
+      { "model": "antarchy:block/slightly_cracked_creeping_horror_eggs_2" },
+      { "model": "antarchy:block/slightly_cracked_creeping_horror_eggs_2", "y": 90 },
+      { "model": "antarchy:block/slightly_cracked_creeping_horror_eggs_2", "y": 180 },
+      { "model": "antarchy:block/slightly_cracked_creeping_horror_eggs_2", "y": 270 }
+    ],
+    "eggs=2,hatch=2": [
+      { "model": "antarchy:block/very_cracked_creeping_horror_eggs_2" },
+      { "model": "antarchy:block/very_cracked_creeping_horror_eggs_2", "y": 90 },
+      { "model": "antarchy:block/very_cracked_creeping_horror_eggs_2", "y": 180 },
+      { "model": "antarchy:block/very_cracked_creeping_horror_eggs_2", "y": 270 }
+    ],
+    "eggs=3,hatch=0": [
+      { "model": "antarchy:block/creeping_horror_eggs_3" },
+      { "model": "antarchy:block/creeping_horror_eggs_3", "y": 90 },
+      { "model": "antarchy:block/creeping_horror_eggs_3", "y": 180 },
+      { "model": "antarchy:block/creeping_horror_eggs_3", "y": 270 }
+    ],
+    "eggs=3,hatch=1": [
+      { "model": "antarchy:block/slightly_cracked_creeping_horror_eggs_3" },
+      { "model": "antarchy:block/slightly_cracked_creeping_horror_eggs_3", "y": 90 },
+      { "model": "antarchy:block/slightly_cracked_creeping_horror_eggs_3", "y": 180 },
+      { "model": "antarchy:block/slightly_cracked_creeping_horror_eggs_3", "y": 270 }
+    ],
+    "eggs=3,hatch=2": [
+      { "model": "antarchy:block/very_cracked_creeping_horror_eggs_3" },
+      { "model": "antarchy:block/very_cracked_creeping_horror_eggs_3", "y": 90 },
+      { "model": "antarchy:block/very_cracked_creeping_horror_eggs_3", "y": 180 },
+      { "model": "antarchy:block/very_cracked_creeping_horror_eggs_3", "y": 270 }
+    ],
+    "eggs=4,hatch=0": [
+      { "model": "antarchy:block/creeping_horror_eggs_4" },
+      { "model": "antarchy:block/creeping_horror_eggs_4", "y": 90 },
+      { "model": "antarchy:block/creeping_horror_eggs_4", "y": 180 },
+      { "model": "antarchy:block/creeping_horror_eggs_4", "y": 270 }
+    ],
+    "eggs=4,hatch=1": [
+      { "model": "antarchy:block/slightly_cracked_creeping_horror_eggs_4" },
+      { "model": "antarchy:block/slightly_cracked_creeping_horror_eggs_4", "y": 90 },
+      { "model": "antarchy:block/slightly_cracked_creeping_horror_eggs_4", "y": 180 },
+      { "model": "antarchy:block/slightly_cracked_creeping_horror_eggs_4", "y": 270 }
+    ],
+    "eggs=4,hatch=2": [
+      { "model": "antarchy:block/very_cracked_creeping_horror_eggs_4" },
+      { "model": "antarchy:block/very_cracked_creeping_horror_eggs_4", "y": 90 },
+      { "model": "antarchy:block/very_cracked_creeping_horror_eggs_4", "y": 180 },
+      { "model": "antarchy:block/very_cracked_creeping_horror_eggs_4", "y": 270 }
+    ]
+  }
+}

common/src/main/resources/assets/antarchy/blockstates/lurking_terror_eggs.json

@@ -0,0 +1,76 @@
+{
+  "variants": {
+    "eggs=1,hatch=0": [
+      { "model": "antarchy:block/lurking_terror_eggs_1" },
+      { "model": "antarchy:block/lurking_terror_eggs_1", "y": 90 },
+      { "model": "antarchy:block/lurking_terror_eggs_1", "y": 180 },
+      { "model": "antarchy:block/lurking_terror_eggs_1", "y": 270 }
+    ],
+    "eggs=1,hatch=1": [
+      { "model": "antarchy:block/slightly_cracked_lurking_terror_eggs_1" },
+      { "model": "antarchy:block/slightly_cracked_lurking_terror_eggs_1", "y": 90 },
+      { "model": "antarchy:block/slightly_cracked_lurking_terror_eggs_1", "y": 180 },
+      { "model": "antarchy:block/slightly_cracked_lurking_terror_eggs_1", "y": 270 }
+    ],
+    "eggs=1,hatch=2": [
+      { "model": "antarchy:block/very_cracked_lurking_terror_eggs_1" },
+      { "model": "antarchy:block/very_cracked_lurking_terror_eggs_1", "y": 90 },
+      { "model": "antarchy:block/very_cracked_lurking_terror_eggs_1", "y": 180 },
+      { "model": "antarchy:block/very_cracked_lurking_terror_eggs_1", "y": 270 }
+    ],
+    "eggs=2,hatch=0": [
+      { "model": "antarchy:block/lurking_terror_eggs_2" },
+      { "model": "antarchy:block/lurking_terror_eggs_2", "y": 90 },
+      { "model": "antarchy:block/lurking_terror_eggs_2", "y": 180 },
+      { "model": "antarchy:block/lurking_terror_eggs_2", "y": 270 }
+    ],
+    "eggs=2,hatch=1": [
+      { "model": "antarchy:block/slightly_cracked_lurking_terror_eggs_2" },
+      { "model": "antarchy:block/slightly_cracked_lurking_terror_eggs_2", "y": 90 },
+      { "model": "antarchy:block/slightly_cracked_lurking_terror_eggs_2", "y": 180 },
+      { "model": "antarchy:block/slightly_cracked_lurking_terror_eggs_2", "y": 270 }
+    ],
+    "eggs=2,hatch=2": [
+      { "model": "antarchy:block/very_cracked_lurking_terror_eggs_2" },
+      { "model": "antarchy:block/very_cracked_lurking_terror_eggs_2", "y": 90 },
+      { "model": "antarchy:block/very_cracked_lurking_terror_eggs_2", "y": 180 },
+      { "model": "antarchy:block/very_cracked_lurking_terror_eggs_2", "y": 270 }
+    ],
+    "eggs=3,hatch=0": [
+      { "model": "antarchy:block/lurking_terror_eggs_3" },
+      { "model": "antarchy:block/lurking_terror_eggs_3", "y": 90 },
+      { "model": "antarchy:block/lurking_terror_eggs_3", "y": 180 },
+      { "model": "antarchy:block/lurking_terror_eggs_3", "y": 270 }
+    ],
+    "eggs=3,hatch=1": [
+      { "model": "antarchy:block/slightly_cracked_lurking_terror_eggs_3" },
+      { "model": "antarchy:block/slightly_cracked_lurking_terror_eggs_3", "y": 90 },
+      { "model": "antarchy:block/slightly_cracked_lurking_terror_eggs_3", "y": 180 },
+      { "model": "antarchy:block/slightly_cracked_lurking_terror_eggs_3", "y": 270 }
+    ],
+    "eggs=3,hatch=2": [
+      { "model": "antarchy:block/very_cracked_lurking_terror_eggs_3" },
+      { "model": "antarchy:block/very_cracked_lurking_terror_eggs_3", "y": 90 },
+      { "model": "antarchy:block/very_cracked_lurking_terror_eggs_3", "y": 180 },
+      { "model": "antarchy:block/very_cracked_lurking_terror_eggs_3", "y": 270 }
+    ],
+    "eggs=4,hatch=0": [
+      { "model": "antarchy:block/lurking_terror_eggs_4" },
+      { "model": "antarchy:block/lurking_terror_eggs_4", "y": 90 },
+      { "model": "antarchy:block/lurking_terror_eggs_4", "y": 180 },
+      { "model": "antarchy:block/lurking_terror_eggs_4", "y": 270 }
+    ],
+    "eggs=4,hatch=1": [
+      { "model": "antarchy:block/slightly_cracked_lurking_terror_eggs_4" },
+      { "model": "antarchy:block/slightly_cracked_lurking_terror_eggs_4", "y": 90 },
+      { "model": "antarchy:block/slightly_cracked_lurking_terror_eggs_4", "y": 180 },
+      { "model": "antarchy:block/slightly_cracked_lurking_terror_eggs_4", "y": 270 }
+    ],
+    "eggs=4,hatch=2": [
+      { "model": "antarchy:block/very_cracked_lurking_terror_eggs_4" },
+      { "model": "antarchy:block/very_cracked_lurking_terror_eggs_4", "y": 90 },
+      { "model": "antarchy:block/very_cracked_lurking_terror_eggs_4", "y": 180 },
+      { "model": "antarchy:block/very_cracked_lurking_terror_eggs_4", "y": 270 }
+    ]
+  }
+}

common/src/main/resources/assets/antarchy/geo/creeping_horror.geo.json

@@ -0,0 +1,197 @@
+{
+	"format_version": "1.12.0",
+	"minecraft:geometry": [
+		{
+			"description": {
+				"identifier": "geometry.creepinghorror",
+				"texture_width": 256,
+				"texture_height": 256,
+				"visible_bounds_width": 9,
+				"visible_bounds_height": 2.5,
+				"visible_bounds_offset": [0, 0.75, 0]
+			},
+			"bones": [
+				{
+					"name": "root",
+					"pivot": [0, 0, 0]
+				},
+				{
+					"name": "body",
+					"parent": "root",
+					"pivot": [0, 0, 0],
+					"cubes": [
+						{"origin": [-6, 0, -7], "size": [12, 12, 14], "uv": [0, 0]},
+						{"origin": [-6, 0, -7], "size": [12, 12, 14], "inflate": 0.25, "uv": [0, 46]},
+						{"origin": [-6, 0, -7], "size": [12, 12, 14], "inflate": 0.5, "uv": [52, 0]},
+						{"origin": [-4, 2, -7], "size": [8, 8, 2], "uv": [104, 12]},
+						{"origin": [-6, 9.85673, -2.40373], "size": [12, 0, 5], "pivot": [0, 6, -7], "rotation": [50, 0, 0], "uv": [100, 84]},
+						{"origin": [-6, 10.24264, -0.75736], "size": [12, 0, 6], "pivot": [0, 6, -5], "rotation": [45, 0, 0], "uv": [100, 54]},
+						{"origin": [-6, 11.19615, 1], "size": [12, 0, 7], "pivot": [0, 6, -2], "rotation": [30, 0, 0], "uv": [100, 43]},
+						{"origin": [-6, 11.43785, 4.53571], "size": [12, 0, 8], "pivot": [0, 6, 2], "rotation": [25, 0, 0], "uv": [92, 35]},
+						{"origin": [-6, 11.79555, 8.55291], "size": [12, 0, 9], "pivot": [0, 6, 7], "rotation": [15, 0, 0], "uv": [92, 26]},
+						{"origin": [-6, 0, -7], "size": [12, 0, 5], "pivot": [0, 0, -7], "rotation": [30, 0, -180], "uv": [100, 84]},
+						{"origin": [-6, 0, -5], "size": [12, 0, 6], "pivot": [0, 0, -5], "rotation": [25, 0, -180], "uv": [100, 54]},
+						{"origin": [-6, 0, -2], "size": [12, 0, 7], "pivot": [0, 0, -2], "rotation": [15, 0, -180], "uv": [100, 43]},
+						{"origin": [-6, 0, 2], "size": [12, 0, 8], "pivot": [0, 0, 2], "rotation": [10, 0, -180], "uv": [92, 35]},
+						{"origin": [-6, 0, 7], "size": [12, 0, 9], "pivot": [0, 0, 7], "rotation": [0, 0, 180], "uv": [92, 26]},
+						{"origin": [-12, 6, -2], "size": [12, 0, 7], "pivot": [-6, 6, -2], "rotation": [20, 0, -90], "uv": [100, 43], "mirror": true},
+						{"origin": [-12, 6, 2], "size": [12, 0, 8], "pivot": [-6, 6, 2], "rotation": [10, 0, -90], "uv": [92, 35], "mirror": true},
+						{"origin": [-12, 6, 7], "size": [12, 0, 9], "pivot": [-6, 6, 7], "rotation": [5, 0, -90], "uv": [92, 26], "mirror": true},
+						{"origin": [0, 6, 2], "size": [12, 0, 8], "pivot": [6, 6, 2], "rotation": [10, 0, 90], "uv": [92, 35]},
+						{"origin": [0, 6, 7], "size": [12, 0, 9], "pivot": [6, 6, 7], "rotation": [5, 0, 90], "uv": [92, 26]},
+						{"origin": [0, 6, -2], "size": [12, 0, 7], "pivot": [6, 6, -2], "rotation": [20, 0, 90], "uv": [100, 43]}
+					]
+				},
+				{
+					"name": "rightjaw",
+					"parent": "body",
+					"pivot": [-6, 6, -7],
+					"cubes": [
+						{"origin": [-6, 3, -13], "size": [4, 6, 6], "uv": [104, 0]}
+					]
+				},
+				{
+					"name": "leftjaw",
+					"parent": "body",
+					"pivot": [6, 6, -7],
+					"cubes": [
+						{"origin": [2, 3, -13], "size": [4, 6, 6], "uv": [104, 0], "mirror": true}
+					]
+				},
+				{
+					"name": "tailbase",
+					"parent": "body",
+					"pivot": [0, 6, 7],
+					"cubes": [
+						{"origin": [-5, 1, 7], "size": [10, 10, 14], "uv": [52, 46]},
+						{"origin": [-5, 1, 7], "size": [10, 10, 14], "inflate": 0.25, "uv": [52, 70]},
+						{"origin": [-5, 1, 7], "size": [10, 10, 14], "inflate": 0.5, "uv": [0, 72]}
+					]
+				},
+				{
+					"name": "tailmiddle",
+					"parent": "tailbase",
+					"pivot": [0, 6, 21],
+					"cubes": [
+						{"origin": [-3.5, 2.5, 21], "size": [7, 7, 14], "uv": [48, 94]},
+						{"origin": [-3.5, 2.5, 21], "size": [7, 7, 14], "inflate": 0.25, "uv": [90, 94]},
+						{"origin": [-3.5, 2.5, 21], "size": [7, 7, 14], "inflate": 0.5, "uv": [0, 96]}
+					]
+				},
+				{
+					"name": "tailtip",
+					"parent": "tailmiddle",
+					"pivot": [0, 6, 35],
+					"cubes": [
+						{"origin": [-1.5, 4.5, 35], "size": [3, 3, 14], "uv": [58, 26]},
+						{"origin": [-4.5, 6, 39], "size": [9, 0, 20], "uv": [0, 26]}
+					]
+				},
+				{
+					"name": "rightfrontleg",
+					"parent": "root",
+					"pivot": [-6, 8, -3],
+					"cubes": [
+						{"origin": [-18, 6, -6], "size": [12, 4, 4], "uv": [100, 60]},
+						{"origin": [-18, 6, -6], "size": [12, 4, 4], "inflate": 0.25, "uv": [100, 68]},
+						{"origin": [-18, 6, -6], "size": [12, 4, 4], "inflate": 0.5, "uv": [100, 76]}
+					]
+				},
+				{
+					"name": "rightfrontknee",
+					"parent": "rightfrontleg",
+					"pivot": [-18, 6, -4],
+					"cubes": [
+						{"origin": [-18, 6, -5], "size": [3, 16, 2], "uv": [42, 115]}
+					]
+				},
+				{
+					"name": "rightfrontfoot",
+					"parent": "rightfrontknee",
+					"pivot": [-18, 18, -4],
+					"cubes": [
+						{"origin": [-35, 18, -4], "size": [20, 4, 0], "uv": [100, 50]}
+					]
+				},
+				{
+					"name": "rightbackleg",
+					"parent": "root",
+					"pivot": [-6, 8, 4],
+					"cubes": [
+						{"origin": [-18, 6, 3], "size": [12, 4, 4], "uv": [100, 60]},
+						{"origin": [-18, 6, 3], "size": [12, 4, 4], "inflate": 0.25, "uv": [100, 68]},
+						{"origin": [-18, 6, 3], "size": [12, 4, 4], "inflate": 0.5, "uv": [100, 76]}
+					]
+				},
+				{
+					"name": "rightbackknee",
+					"parent": "rightbackleg",
+					"pivot": [-18, 6, 5],
+					"cubes": [
+						{"origin": [-18, 6, 4], "size": [3, 16, 2], "uv": [42, 115]}
+					]
+				},
+				{
+					"name": "rightbackfoot",
+					"parent": "rightbackknee",
+					"pivot": [-18, 18, 5],
+					"cubes": [
+						{"origin": [-35, 18, 5], "size": [20, 4, 0], "uv": [100, 50]}
+					]
+				},
+				{
+					"name": "leftfrontleg",
+					"parent": "root",
+					"pivot": [6, 8, -3],
+					"cubes": [
+						{"origin": [6, 6, -6], "size": [12, 4, 4], "uv": [100, 60], "mirror": true},
+						{"origin": [6, 6, -6], "size": [12, 4, 4], "inflate": 0.25, "uv": [100, 68], "mirror": true},
+						{"origin": [6, 6, -6], "size": [12, 4, 4], "inflate": 0.5, "uv": [100, 76], "mirror": true}
+					]
+				},
+				{
+					"name": "leftfrontknee",
+					"parent": "leftfrontleg",
+					"pivot": [18, 6, -4],
+					"cubes": [
+						{"origin": [15, 6, -5], "size": [3, 16, 2], "uv": [42, 115], "mirror": true}
+					]
+				},
+				{
+					"name": "leftfrontfoot",
+					"parent": "leftfrontknee",
+					"pivot": [18, 18, -4],
+					"cubes": [
+						{"origin": [15, 18, -4], "size": [20, 4, 0], "uv": [100, 50], "mirror": true}
+					]
+				},
+				{
+					"name": "leftbackleg",
+					"parent": "root",
+					"pivot": [6, 8, 4],
+					"cubes": [
+						{"origin": [6, 6, 3], "size": [12, 4, 4], "uv": [100, 60], "mirror": true},
+						{"origin": [6, 6, 3], "size": [12, 4, 4], "inflate": 0.25, "uv": [100, 68], "mirror": true},
+						{"origin": [6, 6, 3], "size": [12, 4, 4], "inflate": 0.5, "uv": [100, 76], "mirror": true}
+					]
+				},
+				{
+					"name": "leftbackknee",
+					"parent": "leftbackleg",
+					"pivot": [18, 6, 5],
+					"cubes": [
+						{"origin": [15, 6, 4], "size": [3, 16, 2], "uv": [42, 115], "mirror": true}
+					]
+				},
+				{
+					"name": "leftbackfoot",
+					"parent": "leftbackknee",
+					"pivot": [18, 18, 5],
+					"cubes": [
+						{"origin": [15, 18, 5], "size": [20, 4, 0], "uv": [100, 50], "mirror": true}
+					]
+				}
+			]
+		}
+	]
+}

common/src/main/resources/assets/antarchy/geo/jumpy_bug.geo.json

@@ -0,0 +1,285 @@
+{
+	"format_version": "1.12.0",
+	"minecraft:geometry": [
+		{
+			"description": {
+				"identifier": "geometry.jumpybug",
+				"texture_width": 512,
+				"texture_height": 512,
+				"visible_bounds_width": 10,
+				"visible_bounds_height": 9.5,
+				"visible_bounds_offset": [0, 4.25, 0]
+			},
+			"bones": [
+				{
+					"name": "root",
+					"pivot": [0, 0, 0]
+				},
+				{
+					"name": "body",
+					"parent": "root",
+					"pivot": [0, 65, 0],
+					"cubes": [
+						{"origin": [-10, 65, -18], "size": [20, 32, 36], "uv": [0, 164]},
+						{"origin": [-12, 97, -46], "size": [24, 12, 80], "uv": [0, 0]},
+						{"origin": [-10, 81, 18], "size": [20, 16, 16], "uv": [224, 152]},
+						{"origin": [-8, 97, -78], "size": [16, 12, 32], "uv": [176, 92]},
+						{"origin": [-10, 109, -58], "size": [20, 4, 12], "uv": [224, 184]},
+						{"origin": [-4, 89, -78], "size": [8, 8, 4], "uv": [176, 152]},
+						{"origin": [-18, 67, -16], "size": [8, 24, 32], "uv": [208, 0]},
+						{"origin": [10, 67, -16], "size": [8, 24, 32], "uv": [112, 212]},
+						{"origin": [-10, 89, -26], "size": [20, 8, 8], "uv": [192, 252]},
+						{"origin": [-2, 79, -34], "size": [4, 4, 16], "uv": [228, 268]},
+						{"origin": [-10, 65, -26], "size": [20, 8, 8], "uv": [248, 252]},
+						{"origin": [-6, 65, -40], "size": [12, 6, 14], "uv": [64, 268]},
+						{"origin": [-12, 57, -42], "size": [24, 8, 64], "uv": [0, 92]},
+						{"origin": [-8, 57, -74], "size": [16, 8, 32], "uv": [192, 212]},
+						{"origin": [-4, 65, -74], "size": [8, 8, 4], "uv": [200, 152]}
+					]
+				},
+				{
+					"name": "rightEye",
+					"parent": "body",
+					"pivot": [-10, 82, -18],
+					"cubes": [
+						{"origin": [-14, 78, -22], "size": [8, 8, 8], "uv": [0, 272]}
+					]
+				},
+				{
+					"name": "leftEye",
+					"parent": "body",
+					"pivot": [10, 82, -18],
+					"cubes": [
+						{"origin": [6, 78, -22], "size": [8, 8, 8], "uv": [0, 272], "mirror": true}
+					]
+				},
+				{
+					"name": "rightGrip",
+					"parent": "body",
+					"pivot": [-18, 78, -16],
+					"cubes": [
+						{"origin": [-22, 76, -28], "size": [8, 4, 12], "uv": [268, 268]}
+					]
+				},
+				{
+					"name": "leftGrip",
+					"parent": "body",
+					"pivot": [18, 78, -16],
+					"cubes": [
+						{"origin": [14, 76, -28], "size": [8, 4, 12], "uv": [268, 268], "mirror": true}
+					]
+				},
+				{
+					"name": "rightAntenna",
+					"parent": "body",
+					"pivot": [-10, 95, 14],
+					"cubes": [
+						{"origin": [-42, 93, 14], "size": [32, 4, 4], "uv": [208, 77]}
+					]
+				},
+				{
+					"name": "leftAntenna",
+					"parent": "body",
+					"pivot": [10, 95, 14],
+					"cubes": [
+						{"origin": [10, 93, 14], "size": [32, 4, 4], "uv": [208, 77], "mirror": true}
+					]
+				},
+				{
+					"name": "rightArm",
+					"parent": "body",
+					"pivot": [-12, 93, -22],
+					"cubes": [
+						{"origin": [-14, 91, -40], "size": [4, 4, 20], "uv": [64, 232]}
+					]
+				},
+				{
+					"name": "rightElbow",
+					"parent": "rightArm",
+					"pivot": [-12, 95, -34],
+					"cubes": [
+						{"origin": [-15, 91, -40], "size": [6, 32, 6], "uv": [204, 268]}
+					]
+				},
+				{
+					"name": "rightClaw",
+					"parent": "rightElbow",
+					"pivot": [-12, 123, -40],
+					"cubes": [
+						{"origin": [-14, 115, -56], "size": [4, 8, 16], "uv": [164, 268]},
+						{"origin": [-12, 115, -88], "size": [0, 8, 32], "uv": [0, 232]}
+					]
+				},
+				{
+					"name": "leftArm",
+					"parent": "body",
+					"pivot": [12, 93, -22],
+					"cubes": [
+						{"origin": [10, 91, -40], "size": [4, 4, 20], "uv": [64, 232], "mirror": true}
+					]
+				},
+				{
+					"name": "leftElbow",
+					"parent": "leftArm",
+					"pivot": [12, 95, -34],
+					"cubes": [
+						{"origin": [9, 91, -40], "size": [6, 32, 6], "uv": [204, 268], "mirror": true}
+					]
+				},
+				{
+					"name": "leftClaw",
+					"parent": "leftElbow",
+					"pivot": [12, 123, -40],
+					"cubes": [
+						{"origin": [10, 115, -56], "size": [4, 8, 16], "uv": [164, 268], "mirror": true},
+						{"origin": [12, 115, -88], "size": [0, 8, 32], "uv": [0, 232], "mirror": true}
+					]
+				},
+				{
+					"name": "backRightThigh",
+					"parent": "root",
+					"pivot": [-12, 65, 14],
+					"cubes": [
+						{"origin": [-28, 57, 10], "size": [16, 8, 8], "uv": [116, 268]}
+					]
+				},
+				{
+					"name": "backRightKnee",
+					"parent": "backRightThigh",
+					"pivot": [-28, 65, 14],
+					"rotation": [0, 0, -90],
+					"cubes": [
+						{"origin": [-60, 55, 9], "size": [32, 11, 10], "inflate": 0.025, "uv": [208, 56]}
+					]
+				},
+				{
+					"name": "backRightLeg",
+					"parent": "backRightKnee",
+					"pivot": [-60, 57, 14],
+					"rotation": [0, 0, 90],
+					"cubes": [
+						{"origin": [-108, 57, 10], "size": [48, 8, 8], "uv": [176, 136]}
+					]
+				},
+				{
+					"name": "backRightFoot",
+					"parent": "backRightLeg",
+					"pivot": [-108, 64, 14],
+					"rotation": [0, 0, -90],
+					"cubes": [
+						{"origin": [-132, 60, 12], "size": [24, 4, 4], "inflate": 0.025, "uv": [224, 200]},
+						{"origin": [-148, 60, 14], "size": [16, 4, 0], "uv": [208, 85]}
+					]
+				},
+				{
+					"name": "backLeftThigh",
+					"parent": "root",
+					"pivot": [12, 65, 14],
+					"cubes": [
+						{"origin": [12, 57, 10], "size": [16, 8, 8], "uv": [116, 268], "mirror": true}
+					]
+				},
+				{
+					"name": "backLeftKnee",
+					"parent": "backLeftThigh",
+					"pivot": [28, 65, 14],
+					"rotation": [0, 0, 90],
+					"cubes": [
+						{"origin": [28, 55, 9], "size": [32, 11, 10], "inflate": 0.025, "uv": [208, 56], "mirror": true}
+					]
+				},
+				{
+					"name": "backLeftLeg",
+					"parent": "backLeftKnee",
+					"pivot": [60, 57, 14],
+					"rotation": [0, 0, -90],
+					"cubes": [
+						{"origin": [60, 57, 10], "size": [48, 8, 8], "uv": [176, 136], "mirror": true}
+					]
+				},
+				{
+					"name": "backLeftFoot",
+					"parent": "backLeftLeg",
+					"pivot": [108, 64, 14],
+					"rotation": [0, 0, 90],
+					"cubes": [
+						{"origin": [108, 60, 12], "size": [24, 4, 4], "inflate": 0.025, "uv": [224, 200], "mirror": true},
+						{"origin": [132, 60, 14], "size": [16, 4, 0], "uv": [208, 85], "mirror": true}
+					]
+				},
+				{
+					"name": "frontLeftThigh",
+					"parent": "root",
+					"pivot": [12, 65, -14],
+					"cubes": [
+						{"origin": [12, 57, -18], "size": [16, 8, 8], "uv": [116, 268], "mirror": true}
+					]
+				},
+				{
+					"name": "frontLeftKnee",
+					"parent": "frontLeftThigh",
+					"pivot": [28, 65, -14],
+					"rotation": [0, 0, 90],
+					"cubes": [
+						{"origin": [28, 55, -19], "size": [32, 11, 10], "inflate": 0.025, "uv": [208, 56], "mirror": true}
+					]
+				},
+				{
+					"name": "frontLeftLeg",
+					"parent": "frontLeftKnee",
+					"pivot": [60, 57, -14],
+					"rotation": [0, 0, -90],
+					"cubes": [
+						{"origin": [60, 57, -18], "size": [48, 8, 8], "uv": [176, 136], "mirror": true}
+					]
+				},
+				{
+					"name": "frontLeftFoot",
+					"parent": "frontLeftLeg",
+					"pivot": [108, 64, -14],
+					"rotation": [0, 0, 90],
+					"cubes": [
+						{"origin": [108, 60, -16], "size": [24, 4, 4], "inflate": 0.025, "uv": [224, 200], "mirror": true},
+						{"origin": [132, 60, -14], "size": [16, 4, 0], "uv": [208, 85], "mirror": true}
+					]
+				},
+				{
+					"name": "frontRightThigh",
+					"parent": "root",
+					"pivot": [-12, 65, -14],
+					"cubes": [
+						{"origin": [-28, 57, -18], "size": [16, 8, 8], "uv": [116, 268]}
+					]
+				},
+				{
+					"name": "frontRightKnee",
+					"parent": "frontRightThigh",
+					"pivot": [-28, 65, -14],
+					"rotation": [0, 0, -90],
+					"cubes": [
+						{"origin": [-60, 55, -19], "size": [32, 11, 10], "inflate": 0.025, "uv": [208, 56]}
+					]
+				},
+				{
+					"name": "frontRightLeg",
+					"parent": "frontRightKnee",
+					"pivot": [-60, 57, -14],
+					"rotation": [0, 0, 90],
+					"cubes": [
+						{"origin": [-108, 57, -18], "size": [48, 8, 8], "uv": [176, 136]}
+					]
+				},
+				{
+					"name": "frontRightFoot",
+					"parent": "frontRightLeg",
+					"pivot": [-108, 64, -14],
+					"rotation": [0, 0, -90],
+					"cubes": [
+						{"origin": [-132, 60, -16], "size": [24, 4, 4], "inflate": 0.025, "uv": [224, 200]},
+						{"origin": [-148, 60, -14], "size": [16, 4, 0], "uv": [208, 85]}
+					]
+				}
+			]
+		}
+	]
+}

common/src/main/resources/assets/antarchy/geo/lurking_terror.geo.json

@@ -0,0 +1,281 @@
+{
+	"format_version": "1.12.0",
+	"minecraft:geometry": [
+		{
+			"description": {
+				"identifier": "geometry.lurkingterror",
+				"texture_width": 128,
+				"texture_height": 128,
+				"visible_bounds_width": 7,
+				"visible_bounds_height": 3.5,
+				"visible_bounds_offset": [0, 1.25, 0]
+			},
+			"bones": [
+				{
+					"name": "root",
+					"pivot": [0, 0, 0]
+				},
+				{
+					"name": "body",
+					"parent": "root",
+					"pivot": [0, 0, 0],
+					"cubes": [
+						{"origin": [-6, 0, -7], "size": [12, 12, 14], "uv": [0, 0]}
+					]
+				},
+				{
+					"name": "upperRightJaw",
+					"parent": "body",
+					"pivot": [0, 6, -7],
+					"cubes": [
+						{"origin": [4.5, 13.5, -21], "size": [4, 3, 14], "pivot": [4, 5.5, -14], "rotation": [0, 0, -90], "uv": [0, 50]},
+						{"origin": [5.5, 16.5, -21], "size": [3, 3, 14], "pivot": [4, 8.5, -14], "rotation": [0, 0, -90], "uv": [0, 85]},
+						{"origin": [8.5, 15.5, -21], "size": [3, 4, 14], "pivot": [7, 8.5, -14], "rotation": [0, 0, -90], "uv": [64, 47]},
+						{"origin": [4.5, 15.5, -21], "size": [4, 4, 2], "pivot": [7, 8.5, -14], "rotation": [0, 0, -90], "uv": [34, 68]},
+						{"origin": [8.5, -1.5, -20], "size": [6, 1, 13], "pivot": [11, 9.5, -14], "rotation": [0, 0, 90], "uv": [64, 65]},
+						{"origin": [14.5, -7.5, -20], "size": [1, 6, 13], "pivot": [11, 9.5, -14], "rotation": [0, 0, 90], "uv": [34, 87]}
+					]
+				},
+				{
+					"name": "upperLeftJaw",
+					"parent": "body",
+					"pivot": [0, 6, -7],
+					"cubes": [
+						{"origin": [-8.5, 13.5, -21], "size": [4, 3, 14], "pivot": [-4, 5.5, -14], "rotation": [0, 0, 90], "uv": [0, 50]},
+						{"origin": [-8.5, 16.5, -21], "size": [3, 3, 14], "pivot": [-4, 8.5, -14], "rotation": [0, 0, 90], "uv": [0, 85]},
+						{"origin": [-11.5, 15.5, -21], "size": [3, 4, 14], "pivot": [-7, 8.5, -14], "rotation": [0, 0, 90], "uv": [0, 67]},
+						{"origin": [-8.5, 15.5, -21], "size": [4, 4, 2], "pivot": [-7, 8.5, -14], "rotation": [0, 0, 90], "uv": [34, 68]},
+						{"origin": [-14.5, -1.5, -20], "size": [6, 1, 13], "pivot": [-11, 9.5, -14], "rotation": [0, 0, -90], "uv": [64, 79]},
+						{"origin": [-15.5, -7.5, -20], "size": [1, 6, 13], "pivot": [-11, 9.5, -14], "rotation": [0, 0, -90], "uv": [88, 0]}
+					]
+				},
+				{
+					"name": "lowerRightJaw",
+					"parent": "body",
+					"pivot": [0, 6, -7],
+					"cubes": [
+						{"origin": [4.5, -4.5, -21], "size": [4, 3, 14], "pivot": [4, 6.5, -14], "rotation": [0, 0, 90], "uv": [52, 0]},
+						{"origin": [5.5, -7.5, -21], "size": [3, 3, 14], "pivot": [4, 3.5, -14], "rotation": [0, 0, 90], "uv": [0, 85]},
+						{"origin": [8.5, -7.5, -21], "size": [3, 4, 14], "pivot": [7, 3.5, -14], "rotation": [0, 0, 90], "uv": [64, 47]},
+						{"origin": [4.5, -7.5, -21], "size": [4, 4, 2], "pivot": [7, 3.5, -14], "rotation": [0, 0, 90], "uv": [34, 68]},
+						{"origin": [8.5, -7.5, -20], "size": [6, 1, 13], "pivot": [11, 3.5, -14], "rotation": [0, 0, 90], "uv": [64, 79]},
+						{"origin": [14.5, -6.5, -20], "size": [1, 6, 13], "pivot": [11, 10.5, -14], "rotation": [0, 0, 90], "uv": [88, 0]}
+					]
+				},
+				{
+					"name": "lowerLeftJaw",
+					"parent": "body",
+					"pivot": [0, 6, -7],
+					"cubes": [
+						{"origin": [-8.5, -4.5, -21], "size": [4, 3, 14], "pivot": [-4, 6.5, -14], "rotation": [0, 0, -90], "uv": [52, 0]},
+						{"origin": [-8.5, -7.5, -21], "size": [3, 3, 14], "pivot": [-4, 3.5, -14], "rotation": [0, 0, -90], "uv": [0, 85]},
+						{"origin": [-11.5, -7.5, -21], "size": [3, 4, 14], "pivot": [-7, 3.5, -14], "rotation": [0, 0, -90], "uv": [0, 67]},
+						{"origin": [-8.5, -7.5, -21], "size": [4, 4, 2], "pivot": [-7, 3.5, -14], "rotation": [0, 0, -90], "uv": [34, 68]},
+						{"origin": [-14.5, -7.5, -20], "size": [6, 1, 13], "pivot": [-11, 3.5, -14], "rotation": [0, 0, -90], "uv": [64, 65]},
+						{"origin": [-15.5, -6.5, -20], "size": [1, 6, 13], "pivot": [-11, 10.5, -14], "rotation": [0, 0, -90], "uv": [34, 87]}
+					]
+				},
+				{
+					"name": "tailbase",
+					"parent": "body",
+					"pivot": [0, 6, 7],
+					"cubes": [
+						{"origin": [-5, 1, 7], "size": [10, 10, 14], "uv": [0, 26]}
+					]
+				},
+				{
+					"name": "tailmiddle",
+					"parent": "tailbase",
+					"pivot": [0, 6, 21],
+					"cubes": [
+						{"origin": [-3.5, 2.5, 21], "size": [7, 7, 14], "uv": [48, 26]}
+					]
+				},
+				{
+					"name": "tailtip",
+					"parent": "tailmiddle",
+					"pivot": [0, 6, 35],
+					"cubes": [
+						{"origin": [-5, 1, 35], "size": [10, 10, 14], "uv": [0, 26]}
+					]
+				},
+				{
+					"name": "leftWing1",
+					"parent": "body",
+					"pivot": [-2, 12, -7],
+					"cubes": [
+						{"origin": [-2, 12, -7], "size": [0, 32, 8], "uv": [48, 47]}
+					]
+				},
+				{
+					"name": "leftWing2",
+					"parent": "body",
+					"pivot": [-3, 12, 0],
+					"cubes": [
+						{"origin": [-3, 12, 0], "size": [0, 27, 8], "uv": [48, 47]}
+					]
+				},
+				{
+					"name": "rightWing1",
+					"parent": "body",
+					"pivot": [2, 12, -7],
+					"cubes": [
+						{"origin": [2, 12, -7], "size": [0, 32, 8], "uv": [48, 47], "mirror": true}
+					]
+				},
+				{
+					"name": "rightWing2",
+					"parent": "body",
+					"pivot": [3, 12, 0],
+					"cubes": [
+						{"origin": [3, 12, 0], "size": [0, 27, 8], "uv": [48, 47], "mirror": true}
+					]
+				},
+				{
+					"name": "rightfrontleg",
+					"parent": "root",
+					"pivot": [-6, 8, -3],
+					"cubes": [
+						{"origin": [-18, 6, -6], "size": [12, 4, 4], "uv": [90, 23]}
+					]
+				},
+				{
+					"name": "rightfrontknee",
+					"parent": "rightfrontleg",
+					"pivot": [-18, 6, -4],
+					"cubes": [
+						{"origin": [-18, 6, -5], "size": [3, 16, 2], "uv": [36, 50]}
+					]
+				},
+				{
+					"name": "rightfrontfoot",
+					"parent": "rightfrontknee",
+					"pivot": [-18, 18, -4],
+					"cubes": [
+						{"origin": [-35, 18, -4], "size": [20, 4, 0], "uv": [52, 19]}
+					]
+				},
+				{
+					"name": "rightbackleg",
+					"parent": "root",
+					"pivot": [-6, 8, 4],
+					"cubes": [
+						{"origin": [-18, 6, 3], "size": [12, 4, 4], "uv": [90, 23]}
+					]
+				},
+				{
+					"name": "rightbackknee",
+					"parent": "rightbackleg",
+					"pivot": [-18, 6, 5],
+					"cubes": [
+						{"origin": [-18, 6, 4], "size": [3, 16, 2], "uv": [36, 50]}
+					]
+				},
+				{
+					"name": "rightbackfoot",
+					"parent": "rightbackknee",
+					"pivot": [-18, 18, 5],
+					"cubes": [
+						{"origin": [-35, 18, 5], "size": [20, 4, 0], "uv": [52, 19]}
+					]
+				},
+				{
+					"name": "leftfrontleg",
+					"parent": "root",
+					"pivot": [6, 8, -3],
+					"cubes": [
+						{"origin": [6, 6, -6], "size": [12, 4, 4], "uv": [90, 23], "mirror": true}
+					]
+				},
+				{
+					"name": "leftfrontknee",
+					"parent": "leftfrontleg",
+					"pivot": [18, 6, -4],
+					"cubes": [
+						{"origin": [15, 6, -5], "size": [3, 16, 2], "uv": [36, 50], "mirror": true}
+					]
+				},
+				{
+					"name": "leftfrontfoot",
+					"parent": "leftfrontknee",
+					"pivot": [18, 18, -4],
+					"cubes": [
+						{"origin": [15, 18, -4], "size": [20, 4, 0], "uv": [52, 19], "mirror": true}
+					]
+				},
+				{
+					"name": "leftmiddleleg",
+					"parent": "root",
+					"pivot": [6, 8, 1.5],
+					"cubes": [
+						{"origin": [6, 6, -1.5], "size": [12, 4, 4], "uv": [90, 23], "mirror": true}
+					]
+				},
+				{
+					"name": "leftmiddleknee",
+					"parent": "leftmiddleleg",
+					"pivot": [18, 6, 0.5],
+					"cubes": [
+						{"origin": [15, 6, -0.5], "size": [3, 16, 2], "uv": [36, 50], "mirror": true}
+					]
+				},
+				{
+					"name": "leftmiddlefoot",
+					"parent": "leftmiddleknee",
+					"pivot": [18, 18, 0.5],
+					"cubes": [
+						{"origin": [15, 18, 0.5], "size": [20, 4, 0], "uv": [52, 19], "mirror": true}
+					]
+				},
+				{
+					"name": "rightmiddleleg",
+					"parent": "root",
+					"pivot": [-6, 8, 1.5],
+					"cubes": [
+						{"origin": [-18, 6, -1.5], "size": [12, 4, 4], "uv": [90, 23]}
+					]
+				},
+				{
+					"name": "rightmiddleknee",
+					"parent": "rightmiddleleg",
+					"pivot": [-18, 6, 0.5],
+					"cubes": [
+						{"origin": [-18, 6, -0.5], "size": [3, 16, 2], "uv": [36, 50]}
+					]
+				},
+				{
+					"name": "rightmiddlefoot",
+					"parent": "rightmiddleknee",
+					"pivot": [-18, 18, 0.5],
+					"cubes": [
+						{"origin": [-35, 18, 0.5], "size": [20, 4, 0], "uv": [52, 19]}
+					]
+				},
+				{
+					"name": "leftbackleg",
+					"parent": "root",
+					"pivot": [6, 8, 4],
+					"cubes": [
+						{"origin": [6, 6, 3], "size": [12, 4, 4], "uv": [90, 23], "mirror": true}
+					]
+				},
+				{
+					"name": "leftbackknee",
+					"parent": "leftbackleg",
+					"pivot": [18, 6, 5],
+					"cubes": [
+						{"origin": [15, 6, 4], "size": [3, 16, 2], "uv": [36, 50], "mirror": true}
+					]
+				},
+				{
+					"name": "leftbackfoot",
+					"parent": "leftbackknee",
+					"pivot": [18, 18, 5],
+					"cubes": [
+						{"origin": [15, 18, 5], "size": [20, 4, 0], "uv": [52, 19], "mirror": true}
+					]
+				}
+			]
+		}
+	]
+}

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

@@ -92,6 +92,8 @@
   "block.antarchy.smooth_dream_sandstone_slab": "Smooth Dream Sandstone Slab",
   "block.antarchy.cut_dream_sandstone_slab": "Cut Dream Sandstone Slab",
   "block.antarchy.bed_bug_egg": "Bed Bug Egg",
+  "block.antarchy.creeping_horror_eggs": "Creeping Horror Eggs",
+  "block.antarchy.lurking_terror_eggs": "Lurking Terror Eggs",
   "block.antarchy.wasp_nest": "Wasp Nest",
   "block.antarchy.red_ant_nest": "Red Ant Nest",
   "block.antarchy.brown_ant_nest": "Brown Ant Nest",
@@ -144,6 +146,7 @@
   "entity.antarchy.missile_squid": "Missile Squid",
   "entity.antarchy.nightmare": "Nightmare",
   "entity.antarchy.bed_bug": "Bed Bug",
+  "entity.antarchy.jumpy_bug": "Jumpy Bug",
   "entity.antarchy.wasp": "Wasp",
   "entity.antarchy.bomber": "Bomber",
   "entity.antarchy.moleworm": "Moleworm",
@@ -152,6 +155,8 @@
   "entity.antarchy.triffid": "Triffid",
   "entity.antarchy.toreterror": "Toreterror",
   "entity.antarchy.water_bomb": "Water Bomb",
+  "entity.antarchy.creeping_horror": "Creeping Horror",
+  "entity.antarchy.lurking_terror": "Lurking Terror",
   "subtitles.antarchy.mantis_ambient": "Mantis clicks",
   "subtitles.antarchy.mantis_hurt": "Mantis screeches",
   "subtitles.antarchy.mantis_attack": "Mantis snaps",
@@ -160,6 +165,7 @@
   "item.antarchy.wasp_nest": "Wasp Nest",
   "item.antarchy.wasp_spawn_egg": "Wasp Spawn Egg",
   "item.antarchy.bomber_spawn_egg": "Bomber Spawn Egg",
+  "item.antarchy.jumpy_bug_spawn_egg": "Jumpy Bug Spawn Egg",
   "item.antarchy.big_bertha_blade": "Big Bertha Blade",
   "item.antarchy.big_bertha_handle": "Big Bertha Handle",
   "item.antarchy.big_bertha_hilt": "Big Bertha Hilt",
@@ -278,7 +284,11 @@
   "tooltip.antarchy.blood_crystal_katana.launch": "Launches you forward on hit.",
   "tooltip.antarchy.blood_crystal_katana.trail": "Leaves a crimson trail behind you.",
   "item.antarchy.mantis_claw": "Mantis Claw",
+  "item.antarchy.king_scale": "King Scale",
+  "item.antarchy.queen_scale": "Queen Scale",
   "item.antarchy.jumpy_bug_leg": "Jumpy Bug Leg",
+  "item.antarchy.jumpy_boots": "Jumpy Boots",
+  "tooltip.antarchy.jumpy_boots": "Sneak to charge, then jump to spring upward.",
   "item.antarchy.brutalfly_wing": "Brutalfly Wing",
   "item.antarchy.brutalfly_elytra": "Brutalfly Elytra",
   "tooltip.antarchy.brutalfly_elytra.flap": "While flying, hold %s to flap your wings",
@@ -348,6 +358,8 @@
   "item.antarchy.missile_squid_spawn_egg": "Missile Squid Spawn Egg",
   "item.antarchy.nightmare_spawn_egg": "Nightmare Spawn Egg",
   "item.antarchy.toreterror_spawn_egg": "Toreterror Spawn Egg",
+  "item.antarchy.creeping_horror_spawn_egg": "Creeping Horror Spawn Egg",
+  "item.antarchy.lurking_terror_spawn_egg": "Lurking Terror Spawn Egg",
   "item.antarchy.water_cannon": "Water Cannon",
   "item.antarchy.primordial_scute": "Primordial Scute",
   "item.antarchy.primordial_helmet": "Primordial Helmet",
@@ -459,6 +471,10 @@
   "advancements.antarchy.now_watch_me_whip.description": "Now watch me nae nae",
   "advancements.antarchy.kill_molevore.title": "Moley Poley",
   "advancements.antarchy.kill_molevore.description": "Kill a Molevore.",
+  "advancements.antarchy.water_cannon_craft.title": "Wetter is Better!",
+  "advancements.antarchy.water_cannon_craft.description": "Obtain a Water Cannon.",
+  "advancements.antarchy.kill_toreterror.title": "More like Tore-Terrible Aim!",
+  "advancements.antarchy.kill_toreterror.description": "Defeat the Toreterror.",
   "death.attack.bed_bug_bite": "%1$s got bit by the bed bugs",
   "death.attack.bed_bug_bite.player": "%1$s got bit by the bed bugs while fighting %2$s",
   "message.antarchy.dread_too_scared_to_sleep": "You are too scared to sleep.",
@@ -670,6 +686,10 @@
   "advancements.antarchy.ultimate_bow.description": "Obtain an Ultimate Bow.",
   "advancements.antarchy.kill_molevore.title": "Moley Poley",
   "advancements.antarchy.kill_molevore.description": "Kill a Molevore.",
+  "advancements.antarchy.water_cannon_craft.title": "Wetter is Better!",
+  "advancements.antarchy.water_cannon_craft.description": "Obtain a Water Cannon.",
+  "advancements.antarchy.kill_toreterror.title": "More like Tore-Terrible Aim!",
+  "advancements.antarchy.kill_toreterror.description": "Defeat the Toreterror.",
   "advancements.antarchy.cancel_out.title": "1 - 1 = ?",
   "advancements.antarchy.cancel_out.description": "Have Growth and Shrinking active at the same time.",
   "death.attack.bed_bug_bite": "%1$s got bit by the bed bugs",

common/src/main/resources/assets/antarchy/models/block/creeping_horror_eggs_1.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/template_turtle_egg",
+  "textures": {
+    "all": "antarchy:block/creeping_horror_eggs/creeping_horror_eggs"
+  }
+}

common/src/main/resources/assets/antarchy/models/block/creeping_horror_eggs_2.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/template_two_turtle_eggs",
+  "textures": {
+    "all": "antarchy:block/creeping_horror_eggs/creeping_horror_eggs"
+  }
+}

common/src/main/resources/assets/antarchy/models/block/creeping_horror_eggs_3.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/template_three_turtle_eggs",
+  "textures": {
+    "all": "antarchy:block/creeping_horror_eggs/creeping_horror_eggs"
+  }
+}

common/src/main/resources/assets/antarchy/models/block/creeping_horror_eggs_4.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/template_four_turtle_eggs",
+  "textures": {
+    "all": "antarchy:block/creeping_horror_eggs/creeping_horror_eggs"
+  }
+}

common/src/main/resources/assets/antarchy/models/block/lurking_terror_eggs_1.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/template_turtle_egg",
+  "textures": {
+    "all": "antarchy:block/lurking_terror_egg/lurking_terror_egg"
+  }
+}

common/src/main/resources/assets/antarchy/models/block/lurking_terror_eggs_2.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/template_two_turtle_eggs",
+  "textures": {
+    "all": "antarchy:block/lurking_terror_egg/lurking_terror_egg"
+  }
+}

common/src/main/resources/assets/antarchy/models/block/lurking_terror_eggs_3.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/template_three_turtle_eggs",
+  "textures": {
+    "all": "antarchy:block/lurking_terror_egg/lurking_terror_egg"
+  }
+}

common/src/main/resources/assets/antarchy/models/block/lurking_terror_eggs_4.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/template_four_turtle_eggs",
+  "textures": {
+    "all": "antarchy:block/lurking_terror_egg/lurking_terror_egg"
+  }
+}

common/src/main/resources/assets/antarchy/models/block/slightly_cracked_creeping_horror_eggs_1.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/template_turtle_egg",
+  "textures": {
+    "all": "antarchy:block/creeping_horror_eggs/creeping_horror_eggs_slightly_cracked"
+  }
+}

common/src/main/resources/assets/antarchy/models/block/slightly_cracked_creeping_horror_eggs_2.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/template_two_turtle_eggs",
+  "textures": {
+    "all": "antarchy:block/creeping_horror_eggs/creeping_horror_eggs_slightly_cracked"
+  }
+}

common/src/main/resources/assets/antarchy/models/block/slightly_cracked_creeping_horror_eggs_3.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/template_three_turtle_eggs",
+  "textures": {
+    "all": "antarchy:block/creeping_horror_eggs/creeping_horror_eggs_slightly_cracked"
+  }
+}

common/src/main/resources/assets/antarchy/models/block/slightly_cracked_creeping_horror_eggs_4.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/template_four_turtle_eggs",
+  "textures": {
+    "all": "antarchy:block/creeping_horror_eggs/creeping_horror_eggs_slightly_cracked"
+  }
+}

common/src/main/resources/assets/antarchy/models/block/slightly_cracked_lurking_terror_eggs_1.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/template_turtle_egg",
+  "textures": {
+    "all": "antarchy:block/lurking_terror_egg/lurking_terror_egg_slightly_cracked"
+  }
+}

common/src/main/resources/assets/antarchy/models/block/slightly_cracked_lurking_terror_eggs_2.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/template_two_turtle_eggs",
+  "textures": {
+    "all": "antarchy:block/lurking_terror_egg/lurking_terror_egg_slightly_cracked"
+  }
+}

common/src/main/resources/assets/antarchy/models/block/slightly_cracked_lurking_terror_eggs_3.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/template_three_turtle_eggs",
+  "textures": {
+    "all": "antarchy:block/lurking_terror_egg/lurking_terror_egg_slightly_cracked"
+  }
+}

common/src/main/resources/assets/antarchy/models/block/slightly_cracked_lurking_terror_eggs_4.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/template_four_turtle_eggs",
+  "textures": {
+    "all": "antarchy:block/lurking_terror_egg/lurking_terror_egg_slightly_cracked"
+  }
+}

common/src/main/resources/assets/antarchy/models/block/very_cracked_creeping_horror_eggs_1.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/template_turtle_egg",
+  "textures": {
+    "all": "antarchy:block/creeping_horror_eggs/creeping_horror_eggs_very_cracked"
+  }
+}

common/src/main/resources/assets/antarchy/models/block/very_cracked_creeping_horror_eggs_2.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/template_two_turtle_eggs",
+  "textures": {
+    "all": "antarchy:block/creeping_horror_eggs/creeping_horror_eggs_very_cracked"
+  }
+}

common/src/main/resources/assets/antarchy/models/block/very_cracked_creeping_horror_eggs_3.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/template_three_turtle_eggs",
+  "textures": {
+    "all": "antarchy:block/creeping_horror_eggs/creeping_horror_eggs_very_cracked"
+  }
+}

common/src/main/resources/assets/antarchy/models/block/very_cracked_creeping_horror_eggs_4.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/template_four_turtle_eggs",
+  "textures": {
+    "all": "antarchy:block/creeping_horror_eggs/creeping_horror_eggs_very_cracked"
+  }
+}

common/src/main/resources/assets/antarchy/models/block/very_cracked_lurking_terror_eggs_1.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/template_turtle_egg",
+  "textures": {
+    "all": "antarchy:block/lurking_terror_egg/lurking_terror_egg_very_cracked"
+  }
+}

common/src/main/resources/assets/antarchy/models/block/very_cracked_lurking_terror_eggs_2.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/template_two_turtle_eggs",
+  "textures": {
+    "all": "antarchy:block/lurking_terror_egg/lurking_terror_egg_very_cracked"
+  }
+}

common/src/main/resources/assets/antarchy/models/block/very_cracked_lurking_terror_eggs_3.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/template_three_turtle_eggs",
+  "textures": {
+    "all": "antarchy:block/lurking_terror_egg/lurking_terror_egg_very_cracked"
+  }
+}

common/src/main/resources/assets/antarchy/models/block/very_cracked_lurking_terror_eggs_4.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/template_four_turtle_eggs",
+  "textures": {
+    "all": "antarchy:block/lurking_terror_egg/lurking_terror_egg_very_cracked"
+  }
+}

common/src/main/resources/assets/antarchy/models/item/creeping_horror_eggs.json

@@ -0,0 +1,3 @@
+{
+  "parent": "antarchy:block/creeping_horror_eggs_1"
+}

common/src/main/resources/assets/antarchy/models/item/creeping_horror_spawn_egg.json

@@ -0,0 +1,3 @@
+{
+  "parent": "minecraft:item/template_spawn_egg"
+}

common/src/main/resources/assets/antarchy/models/item/jumpy_boots.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "antarchy:item/jumpy_boots"
+  }
+}

common/src/main/resources/assets/antarchy/models/item/jumpy_bug_spawn_egg.json

@@ -0,0 +1,3 @@
+{
+  "parent": "minecraft:item/template_spawn_egg"
+}

common/src/main/resources/assets/antarchy/models/item/king_scale.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "antarchy:item/king_scale"
+  }
+}

common/src/main/resources/assets/antarchy/models/item/lurking_terror_eggs.json

@@ -0,0 +1,3 @@
+{
+  "parent": "antarchy:block/lurking_terror_eggs_1"
+}

common/src/main/resources/assets/antarchy/models/item/lurking_terror_spawn_egg.json

@@ -0,0 +1,3 @@
+{
+  "parent": "minecraft:item/template_spawn_egg"
+}

common/src/main/resources/assets/antarchy/models/item/queen_scale.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:item/generated",
+  "textures": {
+    "layer0": "antarchy:item/queen_scale"
+  }
+}

common/src/main/resources/data/antarchy/advancement/kill_toreterror.json

@@ -0,0 +1,34 @@
+{
+  "parent": "minecraft:adventure/root",
+  "criteria": {
+    "kill_toreterror": {
+      "conditions": {
+        "entity": {
+          "type": "antarchy:toreterror"
+        }
+      },
+      "trigger": "minecraft:player_killed_entity"
+    }
+  },
+  "display": {
+    "announce_to_chat": true,
+    "description": {
+      "translate": "advancements.antarchy.kill_toreterror.description"
+    },
+    "frame": "challenge",
+    "icon": {
+      "count": 1,
+      "id": "antarchy:toreterror_spawn_egg"
+    },
+    "show_toast": true,
+    "title": {
+      "translate": "advancements.antarchy.kill_toreterror.title"
+    }
+  },
+  "requirements": [
+    [
+      "kill_toreterror"
+    ]
+  ],
+  "sends_telemetry_event": true
+}

common/src/main/resources/data/antarchy/advancement/water_cannon_craft.json

@@ -0,0 +1,36 @@
+{
+  "parent": "minecraft:adventure/root",
+  "criteria": {
+    "get_water_cannon": {
+      "conditions": {
+        "items": [
+          {
+            "items": "antarchy:water_cannon"
+          }
+        ]
+      },
+      "trigger": "minecraft:inventory_changed"
+    }
+  },
+  "display": {
+    "announce_to_chat": true,
+    "description": {
+      "translate": "advancements.antarchy.water_cannon_craft.description"
+    },
+    "frame": "task",
+    "icon": {
+      "count": 1,
+      "id": "antarchy:water_cannon"
+    },
+    "show_toast": true,
+    "title": {
+      "translate": "advancements.antarchy.water_cannon_craft.title"
+    }
+  },
+  "requirements": [
+    [
+      "get_water_cannon"
+    ]
+  ],
+  "sends_telemetry_event": true
+}

common/src/main/resources/data/antarchy/loot_table/blocks/creeping_horror_eggs.json

@@ -0,0 +1 @@
+{"type":"minecraft:block","pools":[]}

common/src/main/resources/data/antarchy/loot_table/blocks/lurking_terror_eggs.json

@@ -0,0 +1 @@
+{"type":"minecraft:block","pools":[]}

common/src/main/resources/data/antarchy/loot_table/entities/jumpy_bug.json

@@ -0,0 +1,33 @@
+{
+  "type": "minecraft:entity",
+  "pools": [
+    {
+      "rolls": 1,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "name": "antarchy:jumpy_bug_leg",
+          "functions": [
+            {
+              "function": "minecraft:set_count",
+              "count": {
+                "type": "minecraft:uniform",
+                "min": 1.0,
+                "max": 2.0
+              }
+            },
+            {
+              "function": "minecraft:enchanted_count_increase",
+              "enchantment": "minecraft:looting",
+              "count": {
+                "type": "minecraft:uniform",
+                "min": 0.0,
+                "max": 1.0
+              }
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

common/src/main/resources/data/antarchy/recipe/jumpy_boots.json

@@ -0,0 +1,20 @@
+{
+  "type": "minecraft:crafting_shaped",
+  "category": "equipment",
+  "pattern": [
+    "JBJ",
+    "J J"
+  ],
+  "key": {
+    "J": {
+      "item": "antarchy:jumpy_bug_leg"
+    },
+    "B": {
+      "item": "minecraft:netherite_boots"
+    }
+  },
+  "result": {
+    "id": "antarchy:jumpy_boots",
+    "count": 1
+  }
+}

fabric/src/main/java/com/craisinlord/antarchy/fabric/AntarchyFabricContent.java

@@ -55,6 +55,7 @@ import com.craisinlord.antarchy.content.entity.lucid.LucidEntity;
 import com.craisinlord.antarchy.content.entity.lucid.LucidBoltEntity;
 import com.craisinlord.antarchy.content.entity.lucid.LucidEyeProjectileEntity;
 import com.craisinlord.antarchy.content.entity.HushProjectileEntity;
+import com.craisinlord.antarchy.content.entity.JumpyBugEntity;
 import com.craisinlord.antarchy.content.entity.OuranwoodBoatEntity;
 import com.craisinlord.antarchy.content.entity.OuranwoodChestBoatEntity;
 import com.craisinlord.antarchy.content.entity.MantisEntity;
@@ -66,6 +67,8 @@ import com.craisinlord.antarchy.content.item.LucidPearlItem;
 import com.craisinlord.antarchy.content.entity.nightmare.NightmareEntity;
 import com.craisinlord.antarchy.content.entity.ToreterrorEntity;
 import com.craisinlord.antarchy.content.entity.WaterBombEntity;
+import com.craisinlord.antarchy.content.entity.CreepingHorrorEntity;
+import com.craisinlord.antarchy.content.entity.LurkingTerrorEntity;
 import com.craisinlord.antarchy.content.item.PrimordialArmorItem;
 import com.craisinlord.antarchy.content.item.WaterCannonItem;
 import com.craisinlord.antarchy.content.entity.kraken.KrakenEntity;
@@ -191,6 +194,7 @@ import net.minecraft.world.item.StandingAndWallBlockItem;
 import net.minecraft.world.food.FoodProperties;
 import net.minecraft.world.item.Tier;
 import net.minecraft.world.item.Tiers;
+import net.minecraft.world.item.alchemy.Potions;
 import net.minecraft.world.item.crafting.Ingredient;
 import net.minecraft.core.Direction;
 import net.minecraft.core.particles.ParticleType;
@@ -614,6 +618,22 @@ public final class AntarchyFabricContent {
             () -> new DreamFireBlock(BlockBehaviour.Properties.ofFullCopy(Blocks.SOUL_FIRE)));
     public static final DeferredBlock<DreamCeilingFireBlock> DREAM_CEILING_FIRE = BLOCKS.register("dream_fire_ceiling",
             () -> new DreamCeilingFireBlock(BlockBehaviour.Properties.ofFullCopy(Blocks.SOUL_FIRE)));
+    public static final DeferredBlock<CreepingHorrorEggBlock> CREEPING_HORROR_EGGS = BLOCKS.register("creeping_horror_eggs",
+            () -> new CreepingHorrorEggBlock(BlockBehaviour.Properties.of()
+                    .strength(0.15F)
+                    .sound(SoundType.METAL)
+                    .randomTicks()
+                    .noOcclusion()
+                    .noCollission()
+                    .replaceable()));
+    public static final DeferredBlock<LurkingTerrorEggBlock> LURKING_TERROR_EGGS = BLOCKS.register("lurking_terror_eggs",
+            () -> new LurkingTerrorEggBlock(BlockBehaviour.Properties.of()
+                    .strength(0.15F)
+                    .sound(SoundType.METAL)
+                    .randomTicks()
+                    .noOcclusion()
+                    .noCollission()
+                    .replaceable()));
     public static final DeferredBlock<BedBugEggBlock> BED_BUG_EGG = BLOCKS.register("bed_bug_egg",
             () -> new BedBugEggBlock(BlockBehaviour.Properties.of()
                     .strength(0.15F)
@@ -749,6 +769,11 @@ public final class AntarchyFabricContent {
                     .sized(0.55F, 0.75F)
                     .clientTrackingRange(8)
                     .build("bomber"));
+    public static final DeferredHolder<EntityType<?>, EntityType<JumpyBugEntity>> JUMPY_BUG = ENTITY_TYPES.register("jumpy_bug",
+            () -> EntityType.Builder.of(JumpyBugEntity::new, MobCategory.MONSTER)
+                    .sized(3.0F, 3.0F)
+                    .clientTrackingRange(8)
+                    .build("jumpy_bug"));
     public static final DeferredHolder<EntityType<?>, EntityType<SizeRayProjectileEntity>> SHRINK_RAY_PROJECTILE = ENTITY_TYPES.register("shrink_ray_projectile",
             () -> EntityType.Builder.<SizeRayProjectileEntity>of(SizeRayProjectileEntity::createShrink, MobCategory.MISC)
                     .sized(0.5F, 0.5F)
@@ -1112,6 +1137,8 @@ public final class AntarchyFabricContent {
             () -> new StandingAndWallBlockItem(DREAM_TORCH.get(), DREAM_WALL_TORCH.get(), new Item.Properties(), Direction.UP));
     public static final DeferredItem<net.minecraft.world.item.BlockItem> DREAM_LANTERN_ITEM = ITEMS.registerSimpleBlockItem(DREAM_LANTERN);
     public static final DeferredItem<net.minecraft.world.item.BlockItem> DREAM_CAMPFIRE_ITEM = ITEMS.registerSimpleBlockItem(DREAM_CAMPFIRE);
+    public static final DeferredItem<net.minecraft.world.item.BlockItem> CREEPING_HORROR_EGGS_ITEM = ITEMS.registerSimpleBlockItem(CREEPING_HORROR_EGGS);
+    public static final DeferredItem<net.minecraft.world.item.BlockItem> LURKING_TERROR_EGGS_ITEM = ITEMS.registerSimpleBlockItem(LURKING_TERROR_EGGS);
     public static final DeferredItem<net.minecraft.world.item.BlockItem> BED_BUG_EGG_ITEM = ITEMS.registerSimpleBlockItem(BED_BUG_EGG);
     public static final DeferredItem<net.minecraft.world.item.BlockItem> WASP_NEST_ITEM = ITEMS.registerSimpleBlockItem(WASP_NEST);
     public static final DeferredItem<net.minecraft.world.item.BlockItem> HUSHWEED_ITEM = ITEMS.registerSimpleBlockItem(HUSHWEED);
@@ -1148,8 +1175,26 @@ public final class AntarchyFabricContent {
                     -2.2F
             ));
     public static final DeferredItem<Item> MANTIS_CLAW = ITEMS.registerSimpleItem("mantis_claw", new Item.Properties().rarity(Rarity.UNCOMMON));
-    public static final DeferredItem<Item> JUMPY_BUG_LEG = ITEMS.register("jumpy_bug_leg",
+    public static final DeferredItem<Item> KING_SCALE = ITEMS.register("king_scale",
-            () -> new MobComingSoonTooltipItem(new Item.Properties().rarity(Rarity.UNCOMMON)));
+            () -> new MobComingSoonTooltipItem(new Item.Properties().rarity(Rarity.RARE)));
+    public static final DeferredItem<Item> QUEEN_SCALE = ITEMS.register("queen_scale",
+            () -> new MobComingSoonTooltipItem(new Item.Properties().rarity(Rarity.RARE)));
+    public static final DeferredItem<Item> JUMPY_BUG_LEG = ITEMS.registerSimpleItem("jumpy_bug_leg", new Item.Properties().rarity(Rarity.UNCOMMON));
+    private static final DeferredHolder<ArmorMaterial, ArmorMaterial> JUMPY_BOOTS_ARMOR_MATERIAL = ARMOR_MATERIALS.register("jumpy_boots",
+            () -> new ArmorMaterial(
+                    createJumpyBootsDefense(),
+                    15,
+                    net.minecraft.sounds.SoundEvents.ARMOR_EQUIP_NETHERITE,
+                    () -> Ingredient.of(net.minecraft.world.item.Items.NETHERITE_BOOTS),
+                    java.util.List.of(new ArmorMaterial.Layer(net.minecraft.resources.ResourceLocation.fromNamespaceAndPath(Antarchy.MODID, "jumpy_boots"))),
+                    3.0F,
+                    0.1F
+            ));
+    public static final DeferredItem<com.craisinlord.antarchy.content.item.JumpyBootsItem> JUMPY_BOOTS = ITEMS.register("jumpy_boots",
+            () -> new com.craisinlord.antarchy.content.item.JumpyBootsItem(
+                    net.minecraft.core.Holder.direct(JUMPY_BOOTS_ARMOR_MATERIAL.get()),
+                    new Item.Properties().stacksTo(1).rarity(Rarity.UNCOMMON).fireResistant().durability(ArmorItem.Type.BOOTS.getDurability(37))
+            ));
     public static final DeferredItem<Item> BRUTALFLY_WING = ITEMS.registerSimpleItem("brutalfly_wing", new Item.Properties().rarity(Rarity.UNCOMMON));
     public static final DeferredItem<BrutalflyElytraItem> BRUTALFLY_ELYTRA = ITEMS.register("brutalfly_elytra",
             () -> new BrutalflyElytraItem(new Item.Properties().rarity(Rarity.UNCOMMON).durability(480)));
@@ -1548,6 +1593,8 @@ public final class AntarchyFabricContent {
             () -> new DeferredSpawnEggItem(WASP, 0x111111, 0xF1D800, new Item.Properties()));
     public static final DeferredItem<DeferredSpawnEggItem> BOMBER_SPAWN_EGG = ITEMS.register("bomber_spawn_egg",
             () -> new DeferredSpawnEggItem(BOMBER, 0x7A7A7A, 0xB32020, new Item.Properties()));
+    public static final DeferredItem<DeferredSpawnEggItem> JUMPY_BUG_SPAWN_EGG = ITEMS.register("jumpy_bug_spawn_egg",
+            () -> new DeferredSpawnEggItem(JUMPY_BUG, 0x111111, 0xFF7A00, new Item.Properties()));
     public static final DeferredItem<DeferredSpawnEggItem> CLOUD_SHARK_SPAWN_EGG = ITEMS.register("cloud_shark_spawn_egg",
             () -> new DeferredSpawnEggItem(CLOUD_SHARK, 0xDDEAF4, 0x7F96A8, new Item.Properties()));
     public static final DeferredItem<DeferredSpawnEggItem> KRAKEN_SPAWN_EGG = ITEMS.register("kraken_spawn_egg",
@@ -1598,8 +1645,22 @@ public final class AntarchyFabricContent {
                     .clientTrackingRange(8)
                     .updateInterval(1)
                     .build("water_bomb"));
+    public static final DeferredHolder<EntityType<?>, EntityType<CreepingHorrorEntity>> CREEPING_HORROR = ENTITY_TYPES.register("creeping_horror",
+            () -> EntityType.Builder.of(CreepingHorrorEntity::new, MobCategory.MONSTER)
+                    .sized(0.7F, 0.5F)
+                    .clientTrackingRange(10)
+                    .build("creeping_horror"));
+    public static final DeferredHolder<EntityType<?>, EntityType<LurkingTerrorEntity>> LURKING_TERROR = ENTITY_TYPES.register("lurking_terror",
+            () -> EntityType.Builder.of(LurkingTerrorEntity::new, MobCategory.MONSTER)
+                    .sized(0.8F, 0.6F)
+                    .clientTrackingRange(10)
+                    .build("lurking_terror"));
     public static final DeferredItem<DeferredSpawnEggItem> TORETERROR_SPAWN_EGG = ITEMS.register("toreterror_spawn_egg",
             () -> new DeferredSpawnEggItem(TORETERROR, 0x90EE90, 0x5C4033, new Item.Properties().rarity(Rarity.EPIC)));
+    public static final DeferredItem<DeferredSpawnEggItem> CREEPING_HORROR_SPAWN_EGG = ITEMS.register("creeping_horror_spawn_egg",
+            () -> new DeferredSpawnEggItem(CREEPING_HORROR, 0x6B3A1F, 0x6B0000, new Item.Properties()));
+    public static final DeferredItem<DeferredSpawnEggItem> LURKING_TERROR_SPAWN_EGG = ITEMS.register("lurking_terror_spawn_egg",
+            () -> new DeferredSpawnEggItem(LURKING_TERROR, 0x2D5A1B, 0x8B0000, new Item.Properties()));
     public static final DeferredHolder<CreativeModeTab, CreativeModeTab> ANTARCHY_TAB = CREATIVE_MODE_TABS.register("antarchy",
             () -> CreativeModeTab.builder(CreativeModeTab.Row.TOP, 0)
                     .title(net.minecraft.network.chat.Component.translatable("itemGroup.antarchy.antarchy"))
@@ -1673,6 +1734,7 @@ public final class AntarchyFabricContent {
         FabricDefaultAttributeRegistry.register(BED_BUG.get(), BedBugEntity.createAttributes().build());
         FabricDefaultAttributeRegistry.register(WASP.get(), WaspEntity.createAttributes().build());
         FabricDefaultAttributeRegistry.register(BOMBER.get(), BomberEntity.createAttributes().build());
+        FabricDefaultAttributeRegistry.register(JUMPY_BUG.get(), JumpyBugEntity.createAttributes().build());
         FabricDefaultAttributeRegistry.register(MANTIS.get(), MantisEntity.createAttributes().build());
         FabricDefaultAttributeRegistry.register(TRIFFID.get(), TriffidEntity.createAttributes().build());
         FabricDefaultAttributeRegistry.register(LUCID.get(), LucidEntity.createAttributes().build());
@@ -1680,6 +1742,8 @@ public final class AntarchyFabricContent {
         FabricDefaultAttributeRegistry.register(BASILISK.get(), BasiliskEntity.createAttributes().build());
         FabricDefaultAttributeRegistry.register(EMPEROR_SCORPION.get(), EmperorScorpionEntity.createAttributes().build());
         FabricDefaultAttributeRegistry.register(TORETERROR.get(), ToreterrorEntity.createAttributes().build());
+        FabricDefaultAttributeRegistry.register(CREEPING_HORROR.get(), CreepingHorrorEntity.createAttributes().build());
+        FabricDefaultAttributeRegistry.register(LURKING_TERROR.get(), LurkingTerrorEntity.createAttributes().build());
 
         FabricDefaultAttributeRegistry.register(RED_ANT.get(), buildAntAttributes(
                 AntarchySettings.redAntHealth(),
@@ -1712,6 +1776,7 @@ public final class AntarchyFabricContent {
         SpawnPlacements.register(CLOUD_SHARK.get(), SpawnPlacementTypes.NO_RESTRICTIONS, Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, CloudSharkEntity::canSpawn);
         SpawnPlacements.register(WASP.get(), SpawnPlacementTypes.NO_RESTRICTIONS, Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, WaspEntity::canSpawn);
         SpawnPlacements.register(BOMBER.get(), SpawnPlacementTypes.ON_GROUND, Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, BomberEntity::canSpawn);
+        SpawnPlacements.register(JUMPY_BUG.get(), SpawnPlacementTypes.ON_GROUND, Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, JumpyBugEntity::canSpawn);
         SpawnPlacements.register(KRAKEN.get(), SpawnPlacementTypes.IN_WATER, Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, KrakenEntity::canSpawn);
         SpawnPlacements.register(MISSILE_SQUID.get(), SpawnPlacementTypes.IN_WATER, Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, MissileSquidEntity::canSpawn);
         SpawnPlacements.register(NIGHTMARE.get(), SpawnPlacementTypes.ON_GROUND, Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, NightmareEntity::canSpawn);
@@ -1813,11 +1878,14 @@ public final class AntarchyFabricContent {
                  "moleworm_spawn_egg", "mantis_spawn_egg", "molevore_spawn_egg", "triffid_spawn_egg",
                  "apple_cow_spawn_egg", "golden_apple_cow_spawn_egg", "enchanted_golden_apple_cow_spawn_egg",
                  "honeyed_apple_cow_spawn_egg", "dr_trayaurus_spawn_egg", "wasp_spawn_egg",
-                 "bomber_spawn_egg", "cloud_shark_spawn_egg", "kraken_spawn_egg", "missile_squid_spawn_egg",
+                 "bomber_spawn_egg", "jumpy_bug_spawn_egg", "cloud_shark_spawn_egg", "kraken_spawn_egg", "missile_squid_spawn_egg",
                  "nightmare_spawn_egg", "bed_bug_spawn_egg", "lucid_spawn_egg", "scorpion_spawn_egg",
-                 "basilisk_spawn_egg", "emperor_scorpion_spawn_egg", "toreterror_spawn_egg" -> 90;
+                 "basilisk_spawn_egg", "emperor_scorpion_spawn_egg", "toreterror_spawn_egg",
+                 "creeping_horror_spawn_egg", "lurking_terror_spawn_egg" -> 90;
             case "water_cannon" -> 52;
             case "primordial_helmet", "primordial_chestplate", "primordial_leggings", "primordial_boots" -> 53;
+            case "jumpy_boots" -> 54;
+            case "king_scale", "queen_scale" -> 22;
             default -> 50;
         };
     }
@@ -1972,6 +2040,16 @@ public final class AntarchyFabricContent {
         return defense;
     }
 
+    private static java.util.EnumMap<ArmorItem.Type, Integer> createJumpyBootsDefense() {
+        java.util.EnumMap<ArmorItem.Type, Integer> defense = new java.util.EnumMap<>(ArmorItem.Type.class);
+        defense.put(ArmorItem.Type.BOOTS, 3);
+        defense.put(ArmorItem.Type.LEGGINGS, 0);
+        defense.put(ArmorItem.Type.CHESTPLATE, 0);
+        defense.put(ArmorItem.Type.HELMET, 0);
+        defense.put(ArmorItem.Type.BODY, 0);
+        return defense;
+    }
+
     private static java.util.EnumMap<ArmorItem.Type, Integer> createBloodCrystalArmorDefense() {
         java.util.EnumMap<ArmorItem.Type, Integer> defense = new java.util.EnumMap<>(ArmorItem.Type.class);
         defense.put(ArmorItem.Type.BOOTS, 2);
@@ -2062,6 +2140,7 @@ public final class AntarchyFabricContent {
             builder.registerPotionRecipe(potionHolder(GROWING), Ingredient.of(Items.GLOWSTONE_DUST), potionHolder(STRONG_GROWING));
             builder.registerPotionRecipe(potionHolder(STRONG_GROWING), Ingredient.of(Items.GLOWSTONE_DUST), potionHolder(EXTREME_GROWING));
             builder.registerPotionRecipe(net.minecraft.world.item.alchemy.Potions.AWKWARD, Ingredient.of(CLOUD_SHARK_FIN.get()), net.minecraft.world.item.alchemy.Potions.SLOW_FALLING);
+            builder.registerPotionRecipe(net.minecraft.world.item.alchemy.Potions.AWKWARD, Ingredient.of(JUMPY_BUG_LEG.get()), Potions.LEAPING);
             builder.registerPotionRecipe(net.minecraft.world.item.alchemy.Potions.AWKWARD, Ingredient.of(CORNEA_EAR.get()), net.minecraft.world.item.alchemy.Potions.NIGHT_VISION);
         });
 
@@ -2218,6 +2297,8 @@ public final class AntarchyFabricContent {
                 HUSH_PROJECTILE,
                 TORETERROR,
                 WATER_BOMB,
+                CREEPING_HORROR,
+                LURKING_TERROR,
                 () -> DUPLICATOR_LOG.get(),
                 () -> DUPLICATOR_SAPLING.get(),
                 () -> DUCT_TAPE.get(),
@@ -2268,6 +2349,8 @@ public final class AntarchyFabricContent {
                 () -> PINK_MILKWEED.get(),
                 () -> TORCHFLOWER_BUSH.get(),
                 () -> BED_BUG_EGG.get(),
+                () -> CREEPING_HORROR_EGGS.get(),
+                () -> LURKING_TERROR_EGGS.get(),
                 () -> WASP_NEST.get(),
                 () -> HUSHWEED.get(),
                 () -> OURANWOOD_SQUIRREL_NEST.get(),

fabric/src/main/java/com/craisinlord/antarchy/fabric/AntarchyFabricEvents.java

@@ -10,6 +10,9 @@ import com.craisinlord.antarchy.content.entity.kraken.KrakenEntity;
 import com.craisinlord.antarchy.content.gravity.AntarchyGravityApi;
 import com.craisinlord.antarchy.content.gravity.AntarchyGravityDirection;
 import com.craisinlord.antarchy.content.gravity.AntarchyGravityTransition;
+import com.craisinlord.antarchy.content.command.CaterpillarCommand;
+import com.craisinlord.antarchy.content.command.GravityCommand;
+import net.fabricmc.fabric.api.command.v2.CommandRegistrationCallback;
 import net.fabricmc.fabric.api.entity.event.v1.ServerLivingEntityEvents;
 import net.fabricmc.fabric.api.event.lifecycle.v1.ServerTickEvents;
 import net.minecraft.server.level.ServerPlayer;
@@ -38,6 +41,11 @@ public final class AntarchyFabricEvents {
     }
 
     public static void register() {
+        CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) -> {
+            GravityCommand.register(dispatcher);
+            CaterpillarCommand.register(dispatcher);
+        });
+
         DispenserBlock.registerBehavior(AntarchyFabricContent.SQUIDZOOKA.get(), new SquidzookaDispenseBehavior());
         DispenserBlock.registerBehavior(AntarchyFabricContent.WATER_CANNON.get(), new WaterCannonDispenseBehavior());
 

fabric/src/main/java/com/craisinlord/antarchy/fabric/client/AntarchyFabricClientBootstrap.java

@@ -92,6 +92,7 @@ public final class AntarchyFabricClientBootstrap {
         EntityRendererRegistry.register(AntarchyFabricContent.BED_BUG.get(), BedBugRenderer::new);
         EntityRendererRegistry.register(AntarchyFabricContent.WASP.get(), WaspRenderer::new);
         EntityRendererRegistry.register(AntarchyFabricContent.BOMBER.get(), BomberRenderer::new);
+        EntityRendererRegistry.register(AntarchyFabricContent.JUMPY_BUG.get(), JumpyBugRenderer::new);
         EntityRendererRegistry.register(AntarchyFabricContent.BASILISK.get(), BasiliskRenderer::new);
         EntityRendererRegistry.register(AntarchyFabricContent.SHRINK_RAY_PROJECTILE.get(), SizeRayProjectileRenderer::new);
         EntityRendererRegistry.register(AntarchyFabricContent.GROWTH_RAY_PROJECTILE.get(), SizeRayProjectileRenderer::new);
@@ -104,6 +105,8 @@ public final class AntarchyFabricClientBootstrap {
         EntityRendererRegistry.register(AntarchyFabricContent.EMPEROR_SCORPION.get(), EmperorScorpionRenderer::new);
         EntityRendererRegistry.register(AntarchyFabricContent.TORETERROR.get(), ToreterrorRenderer::new);
         EntityRendererRegistry.register(AntarchyFabricContent.WATER_BOMB.get(), WaterBombRenderer::new);
+        EntityRendererRegistry.register(AntarchyFabricContent.CREEPING_HORROR.get(), CreepingHorrorRenderer::new);
+        EntityRendererRegistry.register(AntarchyFabricContent.LURKING_TERROR.get(), LurkingTerrorRenderer::new);
 
         EntityModelLayerRegistry.registerModelLayer(OuranwoodBoatRenderer.boatLayer(), BoatModel::createBodyModel);
         EntityModelLayerRegistry.registerModelLayer(OuranwoodBoatRenderer.chestBoatLayer(), ChestBoatModel::createBodyModel);
@@ -285,6 +288,7 @@ public final class AntarchyFabricClientBootstrap {
                 ParalyzedClientHandler.clampPlayerInput(client.player);
             }
             BrutalflyElytraClientHandler.tick();
+            JumpyBootsClientHandler.tick();
             DiamondMinecartClientHandler.tick();
             ParalyzedClientHandler.tick();
             DreadClientHandler.tick();
@@ -303,6 +307,7 @@ public final class AntarchyFabricClientBootstrap {
             DreadHudRenderer.render(guiGraphics);
             ParalyzedHudRenderer.render(guiGraphics);
             BrutalflyElytraHudRenderer.render(guiGraphics);
+            JumpyBootsHudRenderer.render(guiGraphics);
             BloodglassHudRenderer.render(guiGraphics);
             TriffidGooHudRenderer.render(guiGraphics);
         });

fabric/src/main/java/com/craisinlord/antarchy/fabric/client/JumpyBootsClientHandler.java

@@ -0,0 +1,84 @@
+package com.craisinlord.antarchy.fabric.client;
+
+import com.craisinlord.antarchy.content.item.JumpyBootsHelper;
+import com.craisinlord.antarchy.content.item.JumpyBootsItem;
+import com.craisinlord.antarchy.content.network.JumpyBootsLaunchPayload;
+import net.fabricmc.fabric.api.client.networking.v1.ClientPlayNetworking;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.player.LocalPlayer;
+
+public final class JumpyBootsClientHandler {
+    private static int chargeTicks = 0;
+    private static boolean wasCharging = false;
+    private static int primeWindowTicks = 0;
+    private static int storedChargeTicks = 0;
+
+    private JumpyBootsClientHandler() {
+    }
+
+    public static void tick() {
+        Minecraft mc = Minecraft.getInstance();
+        LocalPlayer player = mc.player;
+
+        if (player == null || mc.level == null || mc.screen != null) {
+            reset();
+            return;
+        }
+
+        if (!JumpyBootsItem.isWearingJumpyBoots(player)) {
+            reset();
+            return;
+        }
+
+        boolean onGround = player.onGround();
+        boolean sneaking = player.input.shiftKeyDown;
+        boolean jumpPressed = mc.options.keyJump.consumeClick();
+
+        if (primeWindowTicks > 0) {
+            primeWindowTicks--;
+            if (jumpPressed) {
+                ClientPlayNetworking.send(new JumpyBootsLaunchPayload(storedChargeTicks, player.isSprinting()));
+                reset();
+                return;
+            }
+            if (primeWindowTicks <= 0) {
+                reset();
+            }
+            return;
+        }
+
+        if (!onGround) {
+            chargeTicks = 0;
+            wasCharging = false;
+            return;
+        }
+
+        if (sneaking) {
+            chargeTicks = Math.min(chargeTicks + 1, JumpyBootsHelper.CHARGE_TICKS_MAX);
+            wasCharging = true;
+        } else if (wasCharging && chargeTicks > 0) {
+            storedChargeTicks = chargeTicks;
+            primeWindowTicks = JumpyBootsHelper.PRIME_WINDOW_TICKS;
+            chargeTicks = 0;
+            wasCharging = false;
+        } else {
+            chargeTicks = 0;
+            wasCharging = false;
+        }
+    }
+
+    private static void reset() {
+        chargeTicks = 0;
+        wasCharging = false;
+        primeWindowTicks = 0;
+        storedChargeTicks = 0;
+    }
+
+    public static boolean isCharging() {
+        return chargeTicks > 0;
+    }
+
+    public static int getChargeTicks() {
+        return chargeTicks;
+    }
+}

fabric/src/main/java/com/craisinlord/antarchy/fabric/client/JumpyBootsHudRenderer.java

@@ -0,0 +1,49 @@
+package com.craisinlord.antarchy.fabric.client;
+
+import com.craisinlord.antarchy.content.item.JumpyBootsHelper;
+import com.craisinlord.antarchy.content.item.JumpyBootsItem;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.util.Mth;
+import net.minecraft.world.entity.player.Player;
+
+public final class JumpyBootsHudRenderer {
+    private static final ResourceLocation JUMP_BAR_BACKGROUND = ResourceLocation.withDefaultNamespace("textures/gui/sprites/hud/jump_bar_background.png");
+    private static final ResourceLocation JUMP_BAR_PROGRESS = ResourceLocation.withDefaultNamespace("textures/gui/sprites/hud/jump_bar_progress.png");
+    private static final int BAR_WIDTH = 182;
+    private static final int BAR_HEIGHT = 5;
+
+    private JumpyBootsHudRenderer() {
+    }
+
+    public static void render(GuiGraphics guiGraphics) {
+        Minecraft mc = Minecraft.getInstance();
+        Player player = mc.player;
+        if (player == null || mc.screen != null || player.isDeadOrDying()) {
+            return;
+        }
+        if (!JumpyBootsItem.isWearingJumpyBoots(player)) {
+            return;
+        }
+        if (!JumpyBootsClientHandler.isCharging()) {
+            return;
+        }
+
+        int width = mc.getWindow().getGuiScaledWidth();
+        int height = mc.getWindow().getGuiScaledHeight();
+        int x0 = width / 2 - BAR_WIDTH / 2;
+        int y0 = height - 29;
+
+        guiGraphics.blit(JUMP_BAR_BACKGROUND, x0, y0, 0, 0, BAR_WIDTH, BAR_HEIGHT, BAR_WIDTH, BAR_HEIGHT);
+
+        int chargeTicks = JumpyBootsClientHandler.getChargeTicks();
+        float chargeRatio = Mth.clamp(chargeTicks / (float) JumpyBootsHelper.CHARGE_TICKS_MAX, 0.0F, 1.0F);
+        int filledWidth = Mth.clamp((int) (chargeRatio * BAR_WIDTH), 0, BAR_WIDTH);
+        if (filledWidth > 0) {
+            guiGraphics.setColor(1.0F, 1.0F, 1.0F, 0.35F + chargeRatio * 0.65F);
+            guiGraphics.blit(JUMP_BAR_PROGRESS, x0, y0, 0, 0, filledWidth, BAR_HEIGHT, BAR_WIDTH, BAR_HEIGHT);
+            guiGraphics.setColor(1.0F, 1.0F, 1.0F, 1.0F);
+        }
+    }
+}

fabric/src/main/java/com/craisinlord/antarchy/fabric/mixin/JumpyBootsFallDamageMixin.java

@@ -0,0 +1,22 @@
+package com.craisinlord.antarchy.fabric.mixin;
+
+import com.craisinlord.antarchy.content.item.JumpyBootsHelper;
+import com.craisinlord.antarchy.content.item.JumpyBootsItem;
+import net.minecraft.world.entity.LivingEntity;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.ModifyVariable;
+
+@Mixin(LivingEntity.class)
+public abstract class JumpyBootsFallDamageMixin {
+    @ModifyVariable(method = "causeFallDamage", at = @At("HEAD"), ordinal = 0, argsOnly = true)
+    private float antarchy$reduceJumpyBootsFallDamage(float fallDistance) {
+        LivingEntity self = (LivingEntity) (Object) this;
+        if (!JumpyBootsItem.isWearingJumpyBoots(self)) return fallDistance;
+        long protectionUntil = self.getPersistentData().getLong(JumpyBootsHelper.FALL_PROTECTION_NBT_KEY);
+        if (self.level().getGameTime() < protectionUntil) {
+            return fallDistance * 0.25F;
+        }
+        return fallDistance;
+    }
+}

fabric/src/main/java/com/craisinlord/antarchy/fabric/network/AntarchyFabricNetworking.java

@@ -7,8 +7,11 @@ import com.craisinlord.antarchy.content.entity.multipart.network.MultipartIntera
 import com.craisinlord.antarchy.content.gravity.AntarchyGravityApi;
 import com.craisinlord.antarchy.content.item.BrutalflyElytraFlightHelper;
 import com.craisinlord.antarchy.content.item.BrutalflyElytraItem;
+import com.craisinlord.antarchy.content.item.JumpyBootsHelper;
+import com.craisinlord.antarchy.content.item.JumpyBootsItem;
 import com.craisinlord.antarchy.content.item.GravityGunItem;
 import com.craisinlord.antarchy.content.network.*;
+import com.craisinlord.antarchy.content.network.JumpyBootsLaunchPayload;
 import com.craisinlord.antarchy.content.weather.ThoraxisWeatherSnapshot;
 import net.fabricmc.fabric.api.networking.v1.PayloadTypeRegistry;
 import net.fabricmc.fabric.api.networking.v1.PlayerLookup;
@@ -46,6 +49,7 @@ public final class AntarchyFabricNetworking {
         PayloadTypeRegistry.playC2S().register(GravityGunScrollPayload.TYPE, GravityGunScrollPayload.STREAM_CODEC);
         PayloadTypeRegistry.playC2S().register(DiamondMinecartInputPayload.TYPE, DiamondMinecartInputPayload.STREAM_CODEC);
         PayloadTypeRegistry.playC2S().register(BrutalflyElytraFlapPayload.TYPE, BrutalflyElytraFlapPayload.STREAM_CODEC);
+        PayloadTypeRegistry.playC2S().register(JumpyBootsLaunchPayload.TYPE, JumpyBootsLaunchPayload.STREAM_CODEC);
         PayloadTypeRegistry.playC2S().register(MultipartAttackPayload.TYPE, MultipartAttackPayload.STREAM_CODEC);
         PayloadTypeRegistry.playC2S().register(MultipartInteractPayload.TYPE, MultipartInteractPayload.STREAM_CODEC);
     }
@@ -59,6 +63,8 @@ public final class AntarchyFabricNetworking {
                 context.server().execute(() -> handleDiamondMinecartInput(context.player(), payload)));
         ServerPlayNetworking.registerGlobalReceiver(BrutalflyElytraFlapPayload.TYPE, (payload, context) ->
                 context.server().execute(() -> handleBrutalflyFlap(context.player(), payload)));
+        ServerPlayNetworking.registerGlobalReceiver(JumpyBootsLaunchPayload.TYPE, (payload, context) ->
+                context.server().execute(() -> handleJumpyBootsLaunch(context.player(), payload)));
         ServerPlayNetworking.registerGlobalReceiver(MultipartAttackPayload.TYPE, (payload, context) ->
                 context.server().execute(() -> handleMultipartAttack(context.player(), payload)));
         ServerPlayNetworking.registerGlobalReceiver(MultipartInteractPayload.TYPE, (payload, context) ->
@@ -262,4 +268,40 @@ public final class AntarchyFabricNetworking {
         InteractionHand hand = payload.handId() == 0 ? InteractionHand.MAIN_HAND : InteractionHand.OFF_HAND;
         owner.antarchy$interactMultipartPart(part, serverPlayer, part.position(), hand);
     }
+
+    private static void handleJumpyBootsLaunch(ServerPlayer player, JumpyBootsLaunchPayload payload) {
+        if (!JumpyBootsItem.isWearingJumpyBoots(player)) return;
+        if (player.isSpectator() || player.isPassenger()) return;
+
+        ItemStack boots = player.getItemBySlot(EquipmentSlot.FEET);
+        if (player.getCooldowns().isOnCooldown(boots.getItem())) return;
+
+        int clampedCharge = Math.min(payload.chargeTicks(), JumpyBootsHelper.CHARGE_TICKS_MAX);
+        if (clampedCharge <= 0) return;
+
+        float verticalBoost = JumpyBootsHelper.verticalBoostFor(clampedCharge);
+        Vec3 current = player.getDeltaMovement();
+        double newX = current.x;
+        double newZ = current.z;
+
+        if (payload.sprinting()) {
+            Vec3 look = player.getLookAngle();
+            newX += look.x * JumpyBootsHelper.SPRINT_FORWARD_BOOST;
+            newZ += look.z * JumpyBootsHelper.SPRINT_FORWARD_BOOST;
+        }
+
+        player.setDeltaMovement(newX, verticalBoost, newZ);
+        player.hasImpulse = true;
+        player.hurtMarked = true;
+        player.resetFallDistance();
+        player.connection.send(new ClientboundSetEntityMotionPacket(player));
+
+        player.level().playSound(null, player.blockPosition(), SoundEvents.SLIME_JUMP, SoundSource.PLAYERS,
+                1.0F, 0.6F + (clampedCharge / (float) JumpyBootsHelper.CHARGE_TICKS_MAX) * 0.6F);
+
+        player.getPersistentData().putLong(JumpyBootsHelper.FALL_PROTECTION_NBT_KEY,
+                player.level().getGameTime() + JumpyBootsHelper.FALL_PROTECTION_TICKS);
+
+        player.getCooldowns().addCooldown(boots.getItem(), JumpyBootsHelper.COOLDOWN_TICKS);
+    }
 }

fabric/src/main/resources/antarchy-fabric.mixins.json

@@ -14,6 +14,7 @@
     "BloodglassEffectMixin",
     "BloodglassRespawnMixin",
     "DreamCampfireBlockEntityMixin",
+    "JumpyBootsFallDamageMixin",
     "infinity.RandomSpringMixin",
     "infinity.PortalCreatorMixin"
   ],

neoforge/src/main/java/com/craisinlord/antarchy/neoforge/AntarchyConfigModuleNeoforge.java

@@ -74,6 +74,11 @@ public final class AntarchyConfigModuleNeoforge {
         AntarchySettings.setBomberExplosionDamage(AntarchyMobsConfig.bomberExplosionDamage());
         AntarchySettings.setBomberExplosionRadius(AntarchyMobsConfig.bomberExplosionRadius());
 
+        AntarchySettings.setJumpyBugHealth(AntarchyMobsConfig.jumpyBugHealth());
+        AntarchySettings.setJumpyBugPounceDamage(AntarchyMobsConfig.jumpyBugPounceDamage());
+        AntarchySettings.setJumpyBugLatchDamage(AntarchyMobsConfig.jumpyBugLatchDamage());
+        AntarchySettings.setJumpyBugCamouflageAlpha(AntarchyMobsConfig.jumpyBugCamouflageAlpha());
+
         AntarchySettings.setKrakenHealth(AntarchyMobsConfig.krakenHealth());
         AntarchySettings.setKrakenAttackDamage(AntarchyMobsConfig.krakenAttackDamage());
         AntarchySettings.setKrakenProjectileDamageTakenMultiplier(AntarchyMobsConfig.krakenProjectileDamageTakenMultiplier());
@@ -150,11 +155,17 @@ public final class AntarchyConfigModuleNeoforge {
         AntarchySettings.setToreterrorSpinDamage(AntarchyMobsConfig.toreterrorSpinDamage());
         AntarchySettings.setToreterrorSpinKnockback(AntarchyMobsConfig.toreterrorSpinKnockback());
         AntarchySettings.setToreterrorRangedWaterBombChance(AntarchyMobsConfig.toreterrorRangedWaterBombChance());
+        AntarchySettings.setToreterrorProjectileDamageMultiplier(AntarchyMobsConfig.toreterrorProjectileDamageMultiplier());
         AntarchySettings.setWaterBombDamage(AntarchyMobsConfig.waterBombDamage());
         AntarchySettings.setWaterBombLifetimeTicks(AntarchyMobsConfig.waterBombLifetimeTicks());
         AntarchySettings.setWaterBombGravity(AntarchyMobsConfig.waterBombGravity());
         AntarchySettings.setWaterBombKnockback(AntarchyMobsConfig.waterBombKnockback());
         AntarchySettings.setWaterCannonCooldownSeconds(AntarchyMobsConfig.waterCannonCooldownSeconds());
+
+        AntarchySettings.setCreepingHorrorHealth(AntarchyMobsConfig.creepingHorrorHealth());
+        AntarchySettings.setCreepingHorrorAttackDamage(AntarchyMobsConfig.creepingHorrorAttackDamage());
+        AntarchySettings.setLurkingTerrorHealth(AntarchyMobsConfig.lurkingTerrorHealth());
+        AntarchySettings.setLurkingTerrorAttackDamage(AntarchyMobsConfig.lurkingTerrorAttackDamage());
     }
 
     private static void bakeToolsConfig() {

neoforge/src/main/java/com/craisinlord/antarchy/neoforge/AntarchyMobsConfig.java

@@ -57,6 +57,14 @@ public final class AntarchyMobsConfig {
     private static final ModConfigSpec.DoubleValue BOMBER_EXPLOSION_RADIUS;
 
 
+    // Jumpy Bug
+
+    private static final ModConfigSpec.DoubleValue JUMPY_BUG_HEALTH;
+    private static final ModConfigSpec.DoubleValue JUMPY_BUG_POUNCE_DAMAGE;
+    private static final ModConfigSpec.DoubleValue JUMPY_BUG_LATCH_DAMAGE;
+    private static final ModConfigSpec.DoubleValue JUMPY_BUG_CAMOUFLAGE_ALPHA;
+
+
     // Kraken
 
     private static final ModConfigSpec.DoubleValue  KRAKEN_HEALTH;
@@ -154,6 +162,7 @@ public final class AntarchyMobsConfig {
     private static final ModConfigSpec.DoubleValue  TORETERROR_SPIN_DAMAGE;
     private static final ModConfigSpec.DoubleValue  TORETERROR_SPIN_KNOCKBACK;
     private static final ModConfigSpec.DoubleValue  TORETERROR_RANGED_WATER_BOMB_CHANCE;
+    private static final ModConfigSpec.DoubleValue  TORETERROR_PROJECTILE_DAMAGE_MULTIPLIER;
     private static final ModConfigSpec.DoubleValue  WATER_BOMB_DAMAGE;
     private static final ModConfigSpec.IntValue     WATER_BOMB_LIFETIME_TICKS;
     private static final ModConfigSpec.DoubleValue  WATER_BOMB_GRAVITY;
@@ -161,6 +170,18 @@ public final class AntarchyMobsConfig {
     private static final ModConfigSpec.DoubleValue  WATER_CANNON_COOLDOWN_SECONDS;
 
 
+    // Creeping Horror
+
+    private static final ModConfigSpec.DoubleValue CREEPING_HORROR_HEALTH;
+    private static final ModConfigSpec.DoubleValue CREEPING_HORROR_ATTACK_DAMAGE;
+
+
+    // Lurking Terror
+
+    private static final ModConfigSpec.DoubleValue LURKING_TERROR_HEALTH;
+    private static final ModConfigSpec.DoubleValue LURKING_TERROR_ATTACK_DAMAGE;
+
+
     // Lucid
 
     private static final ModConfigSpec.DoubleValue LUCID_ATTACK_RANGE;
@@ -288,6 +309,16 @@ public final class AntarchyMobsConfig {
         b.pop();
 
 
+        // Jumpy Bug
+
+        b.push("jumpyBug");
+        JUMPY_BUG_HEALTH = b.comment("Base max health.").defineInRange("health", 12.0D, 1.0D, 32768.0D);
+        JUMPY_BUG_POUNCE_DAMAGE = b.comment("Damage dealt on a successful pounce latch.").defineInRange("pounceDamage", 2.0D, 0.0D, 1024.0D);
+        JUMPY_BUG_LATCH_DAMAGE = b.comment("Damage dealt per bite while latched.").defineInRange("latchDamage", 1.0D, 0.0D, 1024.0D);
+        JUMPY_BUG_CAMOUFLAGE_ALPHA = b.comment("Renderer alpha while camouflaged.").defineInRange("camouflageAlpha", 0.18D, 0.01D, 1.0D);
+        b.pop();
+
+
         // Kraken
 
         b.push("kraken");
@@ -432,6 +463,16 @@ public final class AntarchyMobsConfig {
 
         b.pop(); // dread
 
+        b.push("creepingHorror");
+        CREEPING_HORROR_HEALTH        = b.comment("Base max health.").defineInRange("health", 15.0D, 1.0D, 32768.0D);
+        CREEPING_HORROR_ATTACK_DAMAGE = b.comment("Base attack damage.").defineInRange("attackDamage", 6.0D, 0.0D, 1024.0D);
+        b.pop();
+
+        b.push("lurkingTerror");
+        LURKING_TERROR_HEALTH        = b.comment("Base max health.").defineInRange("health", 15.0D, 1.0D, 32768.0D);
+        LURKING_TERROR_ATTACK_DAMAGE = b.comment("Base attack damage.").defineInRange("attackDamage", 6.0D, 0.0D, 1024.0D);
+        b.pop();
+
         b.push("toreterror");
         TORETERROR_HEALTH                  = b.comment("Base max health.").defineInRange("health", 300.0D, 1.0D, 32768.0D);
         TORETERROR_JUMP_ATTACK_DAMAGE      = b.comment("Damage dealt by the jump shockwave.").defineInRange("jumpAttackDamage", 14.0D, 0.0D, 1024.0D);
@@ -439,6 +480,7 @@ public final class AntarchyMobsConfig {
         TORETERROR_SPIN_DAMAGE             = b.comment("Damage per spin-attack tick.").defineInRange("spinDamage", 8.0D, 0.0D, 1024.0D);
         TORETERROR_SPIN_KNOCKBACK          = b.comment("Knockback strength of the spin attack.").defineInRange("spinKnockback", 1.5D, 0.0D, 10.0D);
         TORETERROR_RANGED_WATER_BOMB_CHANCE = b.comment("Chance (0.0-1.0) the ranged attack fires a Water Bomb instead of Bombers.").defineInRange("rangedWaterBombChance", 0.5D, 0.0D, 1.0D);
+        TORETERROR_PROJECTILE_DAMAGE_MULTIPLIER = b.comment("Damage multiplier applied to projectile hits on the Toreterror (0.5 = half damage).").defineInRange("projectileDamageMultiplier", 0.5D, 0.0D, 1.0D);
         WATER_BOMB_DAMAGE                  = b.comment("Damage dealt by a Water Bomb hit.").defineInRange("waterBombDamage", 6.0D, 0.0D, 1024.0D);
         WATER_BOMB_LIFETIME_TICKS          = b.comment("Ticks before a Water Bomb despawns.").defineInRange("waterBombLifetimeTicks", 120, 1, 6000);
         WATER_BOMB_GRAVITY                 = b.comment("Gravity applied to Water Bombs (higher = steeper arc).").defineInRange("waterBombGravity", 0.12D, 0.0D, 2.0D);
@@ -494,6 +536,11 @@ public final class AntarchyMobsConfig {
     static double  bomberExplosionDamage()                  { return BOMBER_EXPLOSION_DAMAGE.get(); }
     static double  bomberExplosionRadius()                  { return BOMBER_EXPLOSION_RADIUS.get(); }
 
+    static double  jumpyBugHealth()                         { return JUMPY_BUG_HEALTH.get(); }
+    static double  jumpyBugPounceDamage()                   { return JUMPY_BUG_POUNCE_DAMAGE.get(); }
+    static double  jumpyBugLatchDamage()                    { return JUMPY_BUG_LATCH_DAMAGE.get(); }
+    static double  jumpyBugCamouflageAlpha()                { return JUMPY_BUG_CAMOUFLAGE_ALPHA.get(); }
+
     static double  krakenHealth()                           { return KRAKEN_HEALTH.get(); }
     static double  krakenAttackDamage()                     { return KRAKEN_ATTACK_DAMAGE.get(); }
     static double  krakenProjectileDamageTakenMultiplier()  { return KRAKEN_PROJECTILE_DAMAGE_TAKEN_MULTIPLIER.get(); }
@@ -564,6 +611,7 @@ public final class AntarchyMobsConfig {
     static double  toreterrorSpinDamage()                   { return TORETERROR_SPIN_DAMAGE.get(); }
     static double  toreterrorSpinKnockback()                { return TORETERROR_SPIN_KNOCKBACK.get(); }
     static double  toreterrorRangedWaterBombChance()        { return TORETERROR_RANGED_WATER_BOMB_CHANCE.get(); }
+    static double  toreterrorProjectileDamageMultiplier()   { return TORETERROR_PROJECTILE_DAMAGE_MULTIPLIER.get(); }
     static double  waterBombDamage()                        { return WATER_BOMB_DAMAGE.get(); }
     static int     waterBombLifetimeTicks()                 { return WATER_BOMB_LIFETIME_TICKS.get(); }
     static double  waterBombGravity()                       { return WATER_BOMB_GRAVITY.get(); }
@@ -576,4 +624,9 @@ public final class AntarchyMobsConfig {
     static boolean dreadHallucinationMobsEnabled()          { return DREAD_HALLUCINATION_MOBS_ENABLED.get(); }
     static double  dreadHallucinationMobMinInterval()       { return DREAD_HALLUCINATION_MOB_MIN_INTERVAL.get(); }
     static double  dreadHallucinationMobMaxInterval()       { return DREAD_HALLUCINATION_MOB_MAX_INTERVAL.get(); }
+
+    static double  creepingHorrorHealth()                   { return CREEPING_HORROR_HEALTH.get(); }
+    static double  creepingHorrorAttackDamage()             { return CREEPING_HORROR_ATTACK_DAMAGE.get(); }
+    static double  lurkingTerrorHealth()                    { return LURKING_TERROR_HEALTH.get(); }
+    static double  lurkingTerrorAttackDamage()              { return LURKING_TERROR_ATTACK_DAMAGE.get(); }
 }

neoforge/src/main/java/com/craisinlord/antarchy/neoforge/AntarchyNeoforge.java

@@ -183,6 +183,8 @@ public class AntarchyNeoforge {
                 AntarchyNeoforgeEntites.HUSH_PROJECTILE,
                 AntarchyNeoforgeEntites.TORETERROR,
                 AntarchyNeoforgeEntites.WATER_BOMB,
+                AntarchyNeoforgeEntites.CREEPING_HORROR,
+                AntarchyNeoforgeEntites.LURKING_TERROR,
                 () -> AntarchyNeoforgeBlocks.DUPLICATOR_LOG.get(),
                 () -> AntarchyNeoforgeBlocks.DUPLICATOR_SAPLING.get(),
                 () -> AntarchyNeoforgeBlocks.DUCT_TAPE.get(),
@@ -233,6 +235,8 @@ public class AntarchyNeoforge {
                 () -> AntarchyNeoforgeBlocks.PINK_MILKWEED.get(),
                 () -> AntarchyNeoforgeBlocks.TORCHFLOWER_BUSH.get(),
                 () -> AntarchyNeoforgeBlocks.BED_BUG_EGG.get(),
+                () -> AntarchyNeoforgeBlocks.CREEPING_HORROR_EGGS.get(),
+                () -> AntarchyNeoforgeBlocks.LURKING_TERROR_EGGS.get(),
                 () -> AntarchyNeoforgeBlocks.WASP_NEST.get(),
                 () -> AntarchyNeoforgeBlocks.HUSHWEED.get(),
                 () -> AntarchyNeoforgeBlocks.OURANWOOD_SQUIRREL_NEST.get(),

neoforge/src/main/java/com/craisinlord/antarchy/neoforge/AntarchyNeoforgeEvents.java

@@ -0,0 +1,20 @@
+package com.craisinlord.antarchy.neoforge;
+
+import com.craisinlord.antarchy.Antarchy;
+import com.craisinlord.antarchy.content.command.CaterpillarCommand;
+import com.craisinlord.antarchy.content.command.GravityCommand;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
+import net.neoforged.neoforge.event.RegisterCommandsEvent;
+
+@EventBusSubscriber(modid = Antarchy.MODID)
+public final class AntarchyNeoforgeEvents {
+    private AntarchyNeoforgeEvents() {
+    }
+
+    @SubscribeEvent
+    public static void onRegisterCommands(RegisterCommandsEvent event) {
+        GravityCommand.register(event.getDispatcher());
+        CaterpillarCommand.register(event.getDispatcher());
+    }
+}