lots of stuff

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/block/AntigravelBlock.java

@@ -0,0 +1,55 @@
+package com.craisinlord.antarchy.content.block;
+
+import com.craisinlord.antarchy.content.entity.UpwardFallingBlockEntity;
+import com.mojang.serialization.MapCodec;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.LevelAccessor;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.BlockBehaviour;
+import net.minecraft.world.level.block.state.BlockState;
+
+public class AntigravelBlock extends Block {
+    public static final MapCodec<AntigravelBlock> CODEC = simpleCodec(AntigravelBlock::new);
+
+    public AntigravelBlock(BlockBehaviour.Properties properties) {
+        super(properties);
+    }
+
+    @Override
+    public MapCodec<AntigravelBlock> codec() {
+        return CODEC;
+    }
+
+    @Override
+    protected void onPlace(BlockState state, Level level, BlockPos pos, BlockState oldState, boolean movedByPiston) {
+        super.onPlace(state, level, pos, oldState, movedByPiston);
+        if (!level.isClientSide) {
+            level.scheduleTick(pos, this, 2);
+        }
+    }
+
+    @Override
+    protected BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor level, BlockPos pos, BlockPos neighborPos) {
+        if (direction == Direction.UP) {
+            level.scheduleTick(pos, this, 2);
+        }
+        return super.updateShape(state, direction, neighborState, level, pos, neighborPos);
+    }
+
+    @Override
+    protected void tick(BlockState state, ServerLevel level, BlockPos pos, RandomSource random) {
+        if (!level.getBlockState(pos).is(this)) {
+            return;
+        }
+        BlockPos abovePos = pos.above();
+        BlockState above = level.getBlockState(abovePos);
+        boolean passable = above.isAir() || above.getCollisionShape(level, abovePos).isEmpty();
+        if (passable) {
+            UpwardFallingBlockEntity.fallUp(level, pos, state, false);
+        }
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/block/BluestoneLampBlock.java

@@ -0,0 +1,64 @@
+package com.craisinlord.antarchy.content.block;
+
+import com.mojang.serialization.MapCodec;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.item.context.BlockPlaceContext;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.Block;
+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.BooleanProperty;
+
+public class BluestoneLampBlock extends Block {
+    public static final MapCodec<BluestoneLampBlock> CODEC = simpleCodec(BluestoneLampBlock::new);
+    public static final BooleanProperty LIT = BlockStateProperties.LIT;
+
+    public BluestoneLampBlock(BlockBehaviour.Properties properties) {
+        super(properties);
+        registerDefaultState(this.stateDefinition.any().setValue(LIT, false));
+    }
+
+    @Override
+    public MapCodec<BluestoneLampBlock> codec() {
+        return CODEC;
+    }
+
+    @Override
+    protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockState> builder) {
+        builder.add(LIT);
+    }
+
+    @Override
+    public BlockState getStateForPlacement(BlockPlaceContext context) {
+        return this.defaultBlockState().setValue(LIT, shouldLight(context.getLevel(), context.getClickedPos()));
+    }
+
+    @Override
+    protected void neighborChanged(BlockState state, Level level, BlockPos pos, Block neighborBlock, BlockPos neighborPos, boolean movedByPiston) {
+        if (level.isClientSide) {
+            return;
+        }
+        boolean lit = state.getValue(LIT);
+        boolean powered = shouldLight(level, pos);
+        if (lit && !powered) {
+            level.scheduleTick(pos, this, 4);
+        } else if (!lit && powered) {
+            level.setBlock(pos, state.setValue(LIT, true), 2);
+        }
+    }
+
+    @Override
+    protected void tick(BlockState state, ServerLevel level, BlockPos pos, RandomSource random) {
+        if (state.getValue(LIT) && !shouldLight(level, pos)) {
+            level.setBlock(pos, state.setValue(LIT, false), 2);
+        }
+    }
+
+    private static boolean shouldLight(Level level, BlockPos pos) {
+        return level.hasNeighborSignal(pos) || BluestoneSignalHelper.getBestNeighborSignal(level, pos) > 0;
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/block/MucusBlock.java

@@ -0,0 +1,59 @@
+package com.craisinlord.antarchy.content.block;
+
+import com.mojang.serialization.MapCodec;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.GlowLichenBlock;
+import net.minecraft.world.level.block.MultifaceBlock;
+import net.minecraft.world.level.block.state.BlockBehaviour;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.Vec3;
+import net.minecraft.world.phys.shapes.CollisionContext;
+import net.minecraft.world.phys.shapes.Shapes;
+import net.minecraft.world.phys.shapes.VoxelShape;
+
+public class MucusBlock extends GlowLichenBlock {
+    public static final MapCodec<MucusBlock> CODEC = simpleCodec(MucusBlock::new);
+    private static final VoxelShape DOWN_COLLISION_SHAPE = Shapes.box(0.0D, 0.0D, 0.0D, 1.0D, 0.0625D, 1.0D);
+    private static final double SLIDE_ACCELERATION = 0.025D;
+    private static final double SLIDE_MAX_SPEED = 0.6D;
+    private static final double SLIDE_MIN_SPEED = 0.02D;
+
+    public MucusBlock(BlockBehaviour.Properties properties) {
+        super(properties);
+    }
+
+    @Override
+    public MapCodec<GlowLichenBlock> codec() {
+        return (MapCodec<GlowLichenBlock>) (MapCodec<?>) CODEC;
+    }
+
+    @Override
+    protected VoxelShape getCollisionShape(BlockState state, BlockGetter level, BlockPos pos, CollisionContext context) {
+        return state.getValue(MultifaceBlock.getFaceProperty(Direction.DOWN)) ? DOWN_COLLISION_SHAPE : Shapes.empty();
+    }
+
+    @Override
+    public void entityInside(BlockState state, Level level, BlockPos pos, Entity entity) {
+        super.entityInside(state, level, pos, entity);
+        if (level.isClientSide || !state.getValue(MultifaceBlock.getFaceProperty(Direction.DOWN))) {
+            return;
+        }
+
+        Vec3 delta = entity.getDeltaMovement();
+        Vec3 horizontal = new Vec3(delta.x, 0.0D, delta.z);
+        double speed = horizontal.length();
+        if (speed < SLIDE_MIN_SPEED) {
+            return;
+        }
+
+        Vec3 direction = horizontal.scale(1.0D / speed);
+        double boostedSpeed = Math.min(speed + SLIDE_ACCELERATION, SLIDE_MAX_SPEED);
+        entity.setDeltaMovement(direction.x * boostedSpeed, delta.y, direction.z * boostedSpeed);
+        entity.hurtMarked = true;
+        entity.hasImpulse = true;
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/block/NadirSaplingBlock.java

@@ -0,0 +1,53 @@
+package com.craisinlord.antarchy.content.block;
+
+import com.mojang.serialization.MapCodec;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.tags.BlockTags;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.LevelAccessor;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.BushBlock;
+import net.minecraft.world.level.block.state.BlockBehaviour;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.shapes.CollisionContext;
+import net.minecraft.world.phys.shapes.VoxelShape;
+
+public class NadirSaplingBlock extends BushBlock {
+    public static final MapCodec<NadirSaplingBlock> CODEC = Block.simpleCodec(NadirSaplingBlock::new);
+    private static final VoxelShape SHAPE = Block.box(2.0D, 0.0D, 2.0D, 14.0D, 12.0D, 14.0D);
+
+    public NadirSaplingBlock(BlockBehaviour.Properties properties) {
+        super(properties);
+    }
+
+    @Override
+    public MapCodec<NadirSaplingBlock> codec() {
+        return CODEC;
+    }
+
+    @Override
+    protected VoxelShape getShape(BlockState state, BlockGetter level, BlockPos pos, CollisionContext context) {
+        return SHAPE;
+    }
+
+    @Override
+    protected boolean mayPlaceOn(BlockState state, BlockGetter level, BlockPos pos) {
+        return state.is(BlockTags.DIRT) || state.is(Blocks.FARMLAND);
+    }
+
+    @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();
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/block/UpperBlock.java

@@ -0,0 +1,147 @@
+package com.craisinlord.antarchy.content.block;
+
+import com.craisinlord.antarchy.content.block.entity.UpperBlockEntity;
+import com.mojang.serialization.MapCodec;
+import java.util.function.Supplier;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.world.Containers;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.MenuProvider;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.context.BlockPlaceContext;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.BaseEntityBlock;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Mirror;
+import net.minecraft.world.level.block.RenderShape;
+import net.minecraft.world.level.block.Rotation;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.entity.BlockEntityTicker;
+import net.minecraft.world.level.block.entity.BlockEntityType;
+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.BooleanProperty;
+import net.minecraft.world.level.block.state.properties.DirectionProperty;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.phys.BlockHitResult;
+import net.minecraft.world.phys.shapes.CollisionContext;
+import net.minecraft.world.phys.shapes.Shapes;
+import net.minecraft.world.phys.shapes.VoxelShape;
+
+public class UpperBlock extends BaseEntityBlock {
+    public static final DirectionProperty FACING = DirectionProperty.create("facing", direction -> direction != Direction.DOWN);
+    public static final BooleanProperty ENABLED = BlockStateProperties.ENABLED;
+
+    private static final VoxelShape TOP = Block.box(0.0, 0.0, 0.0, 16.0, 6.0, 16.0);
+    private static final VoxelShape MIDDLE = Block.box(4.0, 6.0, 4.0, 12.0, 12.0, 12.0);
+    private static final VoxelShape BASE = Shapes.or(TOP, MIDDLE);
+    private static final VoxelShape UP_SHAPE = Shapes.or(BASE, Block.box(6.0, 12.0, 6.0, 10.0, 16.0, 10.0));
+    private static final VoxelShape NORTH_SHAPE = Shapes.or(BASE, Block.box(6.0, 8.0, 0.0, 10.0, 12.0, 4.0));
+    private static final VoxelShape SOUTH_SHAPE = Shapes.or(BASE, Block.box(6.0, 8.0, 12.0, 10.0, 12.0, 16.0));
+    private static final VoxelShape WEST_SHAPE = Shapes.or(BASE, Block.box(0.0, 8.0, 6.0, 4.0, 12.0, 10.0));
+    private static final VoxelShape EAST_SHAPE = Shapes.or(BASE, Block.box(12.0, 8.0, 6.0, 16.0, 12.0, 10.0));
+
+    private final Supplier<? extends BlockEntityType<UpperBlockEntity>> blockEntityTypeSupplier;
+    private final MapCodec<UpperBlock> codec;
+
+    public UpperBlock(Supplier<? extends BlockEntityType<UpperBlockEntity>> blockEntityTypeSupplier, BlockBehaviour.Properties properties) {
+        super(properties);
+        this.blockEntityTypeSupplier = blockEntityTypeSupplier;
+        this.codec = Block.simpleCodec(ignored -> this);
+        this.registerDefaultState(this.stateDefinition.any().setValue(FACING, Direction.UP).setValue(ENABLED, true));
+    }
+
+    @Override
+    public MapCodec<UpperBlock> codec() {
+        return this.codec;
+    }
+
+    @Override
+    protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockState> builder) {
+        builder.add(FACING, ENABLED);
+    }
+
+    @Override
+    public BlockState getStateForPlacement(BlockPlaceContext context) {
+        Direction opposite = context.getClickedFace().getOpposite();
+        Direction facing = opposite == Direction.DOWN ? Direction.UP : opposite;
+        return this.defaultBlockState()
+                .setValue(FACING, facing)
+                .setValue(ENABLED, !context.getLevel().hasNeighborSignal(context.getClickedPos()));
+    }
+
+    @Override
+    protected void neighborChanged(BlockState state, Level level, BlockPos pos, Block neighborBlock, BlockPos neighborPos, boolean movedByPiston) {
+        this.updateEnabled(level, pos, state);
+    }
+
+    private void updateEnabled(Level level, BlockPos pos, BlockState state) {
+        boolean shouldBeEnabled = !level.hasNeighborSignal(pos);
+        if (shouldBeEnabled != state.getValue(ENABLED)) {
+            level.setBlock(pos, state.setValue(ENABLED, shouldBeEnabled), Block.UPDATE_CLIENTS);
+        }
+    }
+
+    @Override
+    protected RenderShape getRenderShape(BlockState state) {
+        return RenderShape.MODEL;
+    }
+
+    @Override
+    protected VoxelShape getShape(BlockState state, BlockGetter level, BlockPos pos, CollisionContext context) {
+        return switch (state.getValue(FACING)) {
+            case UP -> UP_SHAPE;
+            case NORTH -> NORTH_SHAPE;
+            case SOUTH -> SOUTH_SHAPE;
+            case WEST -> WEST_SHAPE;
+            case EAST -> EAST_SHAPE;
+            default -> UP_SHAPE;
+        };
+    }
+
+    @Override
+    public BlockEntity newBlockEntity(BlockPos pos, BlockState state) {
+        return new UpperBlockEntity(pos, state, this.blockEntityTypeSupplier);
+    }
+
+    @Override
+    public <T extends BlockEntity> BlockEntityTicker<T> getTicker(Level level, BlockState state, BlockEntityType<T> blockEntityType) {
+        if (level.isClientSide) {
+            return null;
+        }
+        return createTickerHelper(blockEntityType, this.blockEntityTypeSupplier.get(), (tickLevel, tickPos, tickState, blockEntity) -> {
+            if (tickLevel instanceof net.minecraft.server.level.ServerLevel serverLevel) {
+                UpperBlockEntity.serverTick(serverLevel, tickPos, tickState, blockEntity);
+            }
+        });
+    }
+
+    @Override
+    protected InteractionResult useWithoutItem(BlockState state, Level level, BlockPos pos, Player player, BlockHitResult hitResult) {
+        if (level.getBlockEntity(pos) instanceof MenuProvider menuProvider) {
+            player.openMenu(menuProvider);
+        }
+        return InteractionResult.CONSUME;
+    }
+
+    @Override
+    protected void onRemove(BlockState state, Level level, BlockPos pos, BlockState newState, boolean movedByPiston) {
+        if (!state.is(newState.getBlock()) && level.getBlockEntity(pos) instanceof UpperBlockEntity blockEntity) {
+            Containers.dropContents(level, pos, blockEntity);
+        }
+        super.onRemove(state, level, pos, newState, movedByPiston);
+    }
+
+    @Override
+    protected BlockState rotate(BlockState state, Rotation rotation) {
+        return state.setValue(FACING, rotation.rotate(state.getValue(FACING)));
+    }
+
+    @Override
+    protected BlockState mirror(BlockState state, Mirror mirror) {
+        return state.rotate(mirror.getRotation(state.getValue(FACING)));
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/block/entity/UpperBlockEntity.java

@@ -0,0 +1,222 @@
+package com.craisinlord.antarchy.content.block.entity;
+
+import com.craisinlord.antarchy.content.block.UpperBlock;
+import java.util.List;
+import java.util.function.Supplier;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.core.HolderLookup;
+import net.minecraft.core.NonNullList;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.protocol.Packet;
+import net.minecraft.network.protocol.game.ClientGamePacketListener;
+import net.minecraft.network.protocol.game.ClientboundBlockEntityDataPacket;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.Container;
+import net.minecraft.world.ContainerHelper;
+import net.minecraft.world.entity.item.ItemEntity;
+import net.minecraft.world.entity.player.Inventory;
+import net.minecraft.world.inventory.AbstractContainerMenu;
+import net.minecraft.world.inventory.HopperMenu;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.entity.BlockEntityType;
+import net.minecraft.world.level.block.entity.RandomizableContainerBlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.AABB;
+
+public class UpperBlockEntity extends RandomizableContainerBlockEntity {
+    private static final int CONTAINER_SIZE = 5;
+    private static final int MOVE_ITEM_SPEED = 8;
+
+    private NonNullList<ItemStack> items = NonNullList.withSize(CONTAINER_SIZE, ItemStack.EMPTY);
+    private int cooldownTime = -1;
+
+    public UpperBlockEntity(BlockPos pos, BlockState state, Supplier<? extends BlockEntityType<UpperBlockEntity>> typeSupplier) {
+        super(typeSupplier.get(), pos, state);
+    }
+
+    public static void serverTick(ServerLevel level, BlockPos pos, BlockState state, UpperBlockEntity blockEntity) {
+        blockEntity.cooldownTime--;
+        if (!blockEntity.isOnCooldown()) {
+            blockEntity.setCooldown(0);
+            tryMoveItems(level, pos, state, blockEntity);
+        }
+    }
+
+    private boolean isOnCooldown() {
+        return this.cooldownTime > 0;
+    }
+
+    private void setCooldown(int cooldown) {
+        this.cooldownTime = cooldown;
+    }
+
+    private static boolean tryMoveItems(ServerLevel level, BlockPos pos, BlockState state, UpperBlockEntity upper) {
+        if (!state.getValue(UpperBlock.ENABLED)) {
+            return false;
+        }
+
+        boolean moved = false;
+        if (!upper.isEmpty()) {
+            moved = pushToDestination(level, pos, state, upper);
+        }
+        if (!moved) {
+            moved = pullFromBelow(level, pos, upper);
+        }
+        moved |= suckLooseItems(level, pos, upper);
+
+        if (moved) {
+            upper.setCooldown(MOVE_ITEM_SPEED);
+            upper.setChanged();
+            return true;
+        }
+        return false;
+    }
+
+    private static boolean pullFromBelow(ServerLevel level, BlockPos pos, UpperBlockEntity upper) {
+        Container source = getContainerAt(level, pos.below());
+        if (source == null) {
+            return false;
+        }
+        if (source instanceof UpperBlockEntity sourceUpper && sourceUpper.isOnCooldown()) {
+            return false;
+        }
+        return transferOneItem(source, upper);
+    }
+
+    private static boolean pushToDestination(ServerLevel level, BlockPos pos, BlockState state, UpperBlockEntity upper) {
+        Direction facing = state.getValue(UpperBlock.FACING);
+        Container destination = getContainerAt(level, pos.relative(facing));
+        if (destination == null) {
+            return false;
+        }
+        boolean pushed = transferOneItem(upper, destination);
+        if (pushed && destination instanceof UpperBlockEntity destinationUpper && !destinationUpper.isOnCooldown()) {
+            destinationUpper.setCooldown(MOVE_ITEM_SPEED);
+            destinationUpper.setChanged();
+        }
+        return pushed;
+    }
+
+    private static boolean suckLooseItems(ServerLevel level, BlockPos pos, UpperBlockEntity upper) {
+        AABB suckArea = new AABB(pos.below()).inflate(-0.05D, 0.0D, -0.05D);
+        List<ItemEntity> entities = level.getEntitiesOfClass(ItemEntity.class, suckArea, ItemEntity::isAlive);
+        boolean moved = false;
+        for (ItemEntity itemEntity : entities) {
+            ItemStack stack = itemEntity.getItem();
+            ItemStack remainder = addItem(upper, stack.copy());
+            if (remainder.isEmpty()) {
+                itemEntity.discard();
+                moved = true;
+            } else if (remainder.getCount() != stack.getCount()) {
+                itemEntity.setItem(remainder);
+                moved = true;
+            }
+        }
+        return moved;
+    }
+
+    private static Container getContainerAt(ServerLevel level, BlockPos pos) {
+        BlockEntity blockEntity = level.getBlockEntity(pos);
+        return blockEntity instanceof Container container ? container : null;
+    }
+
+    private static boolean transferOneItem(Container source, Container destination) {
+        for (int slot = 0; slot < source.getContainerSize(); slot++) {
+            ItemStack stack = source.getItem(slot);
+            if (stack.isEmpty()) {
+                continue;
+            }
+
+            ItemStack single = stack.copyWithCount(1);
+            ItemStack remainder = addItem(destination, single);
+            if (remainder.isEmpty()) {
+                stack.shrink(1);
+                source.setItem(slot, stack);
+                destination.setChanged();
+                source.setChanged();
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static ItemStack addItem(Container container, ItemStack stack) {
+        for (int slot = 0; slot < container.getContainerSize() && !stack.isEmpty(); slot++) {
+            ItemStack existing = container.getItem(slot);
+            if (!existing.isEmpty() && ItemStack.isSameItemSameComponents(existing, stack)) {
+                int limit = Math.min(existing.getMaxStackSize(), container.getMaxStackSize());
+                int room = limit - existing.getCount();
+                if (room > 0) {
+                    int moveCount = Math.min(room, stack.getCount());
+                    existing.grow(moveCount);
+                    stack.shrink(moveCount);
+                }
+            }
+        }
+        for (int slot = 0; slot < container.getContainerSize() && !stack.isEmpty(); slot++) {
+            ItemStack existing = container.getItem(slot);
+            if (existing.isEmpty() && container.canPlaceItem(slot, stack)) {
+                int moveCount = Math.min(stack.getMaxStackSize(), stack.getCount());
+                container.setItem(slot, stack.split(moveCount));
+            }
+        }
+        return stack;
+    }
+
+    @Override
+    public int getContainerSize() {
+        return CONTAINER_SIZE;
+    }
+
+    @Override
+    protected NonNullList<ItemStack> getItems() {
+        return this.items;
+    }
+
+    @Override
+    protected void setItems(NonNullList<ItemStack> items) {
+        this.items = items;
+    }
+
+    @Override
+    protected Component getDefaultName() {
+        return Component.translatable("container.antarchy.upper");
+    }
+
+    @Override
+    protected AbstractContainerMenu createMenu(int containerId, Inventory inventory) {
+        return new HopperMenu(containerId, inventory, this);
+    }
+
+    @Override
+    protected void saveAdditional(CompoundTag tag, HolderLookup.Provider registries) {
+        super.saveAdditional(tag, registries);
+        if (!this.trySaveLootTable(tag)) {
+            ContainerHelper.saveAllItems(tag, this.items, registries);
+        }
+        tag.putInt("Cooldown", this.cooldownTime);
+    }
+
+    @Override
+    protected void loadAdditional(CompoundTag tag, HolderLookup.Provider registries) {
+        super.loadAdditional(tag, registries);
+        this.items = NonNullList.withSize(this.getContainerSize(), ItemStack.EMPTY);
+        if (!this.tryLoadLootTable(tag)) {
+            ContainerHelper.loadAllItems(tag, this.items, registries);
+        }
+        this.cooldownTime = tag.getInt("Cooldown");
+    }
+
+    @Override
+    public CompoundTag getUpdateTag(HolderLookup.Provider registries) {
+        return this.saveCustomOnly(registries);
+    }
+
+    @Override
+    public Packet<ClientGamePacketListener> getUpdatePacket() {
+        return ClientboundBlockEntityDataPacket.create(this);
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/boss/BossCombatUtil.java

@@ -0,0 +1,22 @@
+package com.craisinlord.antarchy.content.boss;
+
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.Mob;
+
+public final class BossCombatUtil {
+    private BossCombatUtil() {}
+
+    public static boolean isOutOfDamageRange(Mob boss, double range) {
+        if (range <= 0.0D) {
+            return false;
+        }
+        return boss.level().getNearestPlayer(boss, range) == null;
+    }
+
+    public static void clampHalfHealthCrossing(LivingEntity boss, float preHitHealth) {
+        float halfHealth = boss.getMaxHealth() * 0.5F;
+        if (preHitHealth > halfHealth && boss.getHealth() < halfHealth) {
+            boss.setHealth(halfHealth);
+        }
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/client/GlimmeringHudRenderer.java

@@ -0,0 +1,39 @@
+package com.craisinlord.antarchy.content.client;
+
+import com.craisinlord.antarchy.content.AntarchyObjects;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.core.Holder;
+import net.minecraft.util.Mth;
+import net.minecraft.world.effect.MobEffect;
+import net.minecraft.world.entity.player.Player;
+
+public final class GlimmeringHudRenderer {
+    private static final int MAX_ALPHA = 0x40;
+    private static final int TINT_RGB = 0x66CCFF;
+    private static final float FADE_SPEED = 0.05F;
+
+    private static float fadeProgress = 0.0F;
+
+    private GlimmeringHudRenderer() {
+    }
+
+    public static void render(GuiGraphics guiGraphics) {
+        Minecraft minecraft = Minecraft.getInstance();
+        Player player = minecraft.player;
+        Holder<MobEffect> glimmering = AntarchyObjects.GLIMMERING_EFFECT.get();
+        boolean active = player != null && !player.isDeadOrDying() && glimmering != null && player.hasEffect(glimmering);
+
+        fadeProgress = active
+                ? Math.min(1.0F, fadeProgress + FADE_SPEED)
+                : Math.max(0.0F, fadeProgress - FADE_SPEED);
+        if (fadeProgress <= 0.0F) {
+            return;
+        }
+
+        int alpha = Mth.floor(MAX_ALPHA * fadeProgress);
+        int width = minecraft.getWindow().getGuiScaledWidth();
+        int height = minecraft.getWindow().getGuiScaledHeight();
+        guiGraphics.fill(0, 0, width, height, (alpha << 24) | TINT_RGB);
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/client/SizeRaySoundHandler.java

@@ -0,0 +1,116 @@
+package com.craisinlord.antarchy.content.client;
+
+import com.craisinlord.antarchy.config.AntarchySettings;
+import com.craisinlord.antarchy.content.item.SizeRayItem;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.player.LocalPlayer;
+import net.minecraft.client.resources.sounds.AbstractTickableSoundInstance;
+import net.minecraft.client.resources.sounds.SoundInstance;
+import net.minecraft.sounds.SoundEvent;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.util.RandomSource;
+
+public final class SizeRaySoundHandler {
+    private static SizeRayItem activeItem;
+    private static SizeRayUseSound chargeSound;
+    private static SizeRayUseSound loopSound;
+
+    private SizeRaySoundHandler() {
+    }
+
+    public static void tick(Minecraft minecraft) {
+        LocalPlayer player = minecraft.player;
+        if (minecraft.level == null || player == null || !AntarchySettings.sizeChangingRaysEnabled()) {
+            stopActive(minecraft);
+            return;
+        }
+
+        if (!(player.getUseItem().getItem() instanceof SizeRayItem sizeRayItem)) {
+            stopActive(minecraft);
+            return;
+        }
+
+        if (activeItem != sizeRayItem) {
+            stopActive(minecraft);
+            activeItem = sizeRayItem;
+        }
+
+        int useTicks = sizeRayItem.getUseDuration(player.getUseItem(), player) - player.getUseItemRemainingTicks();
+        if (useTicks >= SizeRayItem.LOOP_SOUND_START_TICKS) {
+            stopCharge(minecraft);
+            if (loopSound == null || !minecraft.getSoundManager().isActive(loopSound)) {
+                loopSound = new SizeRayUseSound(player, sizeRayItem.getLoopSound(), true);
+                minecraft.getSoundManager().play(loopSound);
+            }
+            return;
+        }
+
+        stopLoop(minecraft);
+        if (chargeSound == null) {
+            chargeSound = new SizeRayUseSound(player, sizeRayItem.getChargeSound(), false);
+            minecraft.getSoundManager().play(chargeSound);
+        }
+    }
+
+    private static void stopActive(Minecraft minecraft) {
+        stopCharge(minecraft);
+        stopLoop(minecraft);
+        activeItem = null;
+    }
+
+    private static void stopCharge(Minecraft minecraft) {
+        if (chargeSound != null) {
+            chargeSound.stopNow(minecraft);
+            chargeSound = null;
+        }
+    }
+
+    private static void stopLoop(Minecraft minecraft) {
+        if (loopSound != null) {
+            loopSound.stopNow(minecraft);
+            loopSound = null;
+        }
+    }
+
+    private static final class SizeRayUseSound extends AbstractTickableSoundInstance {
+        private final LocalPlayer player;
+
+        private SizeRayUseSound(LocalPlayer player, SoundEvent soundEvent, boolean loop) {
+            super(soundEvent, SoundSource.PLAYERS, RandomSource.create());
+            this.player = player;
+            this.looping = loop;
+            this.delay = 0;
+            this.relative = false;
+            this.attenuation = SoundInstance.Attenuation.LINEAR;
+            this.volume = 1.0F;
+            this.pitch = 1.0F;
+            this.x = player.getX();
+            this.y = player.getY();
+            this.z = player.getZ();
+        }
+
+        private void stopNow(Minecraft minecraft) {
+            minecraft.getSoundManager().stop(this);
+            this.stop();
+        }
+
+        @Override
+        public void tick() {
+            if (this.player.isRemoved()
+                    || !this.player.isAlive()
+                    || !(this.player.getUseItem().getItem() instanceof SizeRayItem)) {
+                this.stop();
+                return;
+            }
+
+            this.x = this.player.getX();
+            this.y = this.player.getY();
+            this.z = this.player.getZ();
+        }
+
+        @Override
+        public boolean canStartSilent() {
+            return true;
+        }
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/client/model/DimensionalTearModel.java

@@ -0,0 +1,25 @@
+package com.craisinlord.antarchy.content.client.model;
+
+import com.craisinlord.antarchy.Antarchy;
+import com.craisinlord.antarchy.content.entity.portal.DimensionalTearEntity;
+import net.minecraft.resources.ResourceLocation;
+import software.bernie.geckolib.model.GeoModel;
+
+public class DimensionalTearModel extends GeoModel<DimensionalTearEntity> {
+    public static final ResourceLocation TEXTURE = ResourceLocation.fromNamespaceAndPath(Antarchy.MODID, "textures/vfx/dimensional_tear.png");
+
+    @Override
+    public ResourceLocation getModelResource(DimensionalTearEntity animatable) {
+        return ResourceLocation.fromNamespaceAndPath(Antarchy.MODID, "geo/dimensional_tear.geo.json");
+    }
+
+    @Override
+    public ResourceLocation getTextureResource(DimensionalTearEntity animatable) {
+        return TEXTURE;
+    }
+
+    @Override
+    public ResourceLocation getAnimationResource(DimensionalTearEntity animatable) {
+        return ResourceLocation.fromNamespaceAndPath(Antarchy.MODID, "animations/dimensional_tear.animation.json");
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/client/particle/LucidBoltImpactParticle.java

@@ -0,0 +1,75 @@
+package com.craisinlord.antarchy.content.client.particle;
+
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.client.particle.Particle;
+import net.minecraft.client.particle.ParticleProvider;
+import net.minecraft.client.particle.ParticleRenderType;
+import net.minecraft.client.particle.SpriteSet;
+import net.minecraft.client.particle.TextureSheetParticle;
+import net.minecraft.client.renderer.LightTexture;
+import net.minecraft.core.particles.SimpleParticleType;
+import net.minecraft.util.Mth;
+
+public final class LucidBoltImpactParticle extends TextureSheetParticle {
+    private final SpriteSet sprites;
+
+    private LucidBoltImpactParticle(ClientLevel level, double x, double y, double z, double xd, double yd, double zd, SpriteSet sprites, float baseScale, int minLifetime, int randomLifetime) {
+        super(level, x, y, z, xd, yd, zd);
+        this.sprites = sprites;
+        this.friction = 0.88F;
+        this.gravity = 0.0F;
+        this.hasPhysics = false;
+        this.xd = xd;
+        this.yd = yd;
+        this.zd = zd;
+        this.quadSize = baseScale * (0.85F + this.random.nextFloat() * 0.3F);
+        this.lifetime = minLifetime + this.random.nextInt(randomLifetime);
+        this.setColor(0.94F, 0.95F, 1.0F);
+        this.setAlpha(0.95F);
+        this.pickSprite(sprites);
+    }
+
+    @Override
+    public void tick() {
+        super.tick();
+        this.pickSprite(this.sprites);
+        float life = (float) this.age / (float) this.lifetime;
+        this.setAlpha(Mth.clamp(1.0F - life, 0.0F, 1.0F) * 0.95F);
+    }
+
+    @Override
+    public int getLightColor(float partialTick) {
+        return LightTexture.FULL_BRIGHT;
+    }
+
+    @Override
+    public ParticleRenderType getRenderType() {
+        return ParticleRenderType.PARTICLE_SHEET_TRANSLUCENT;
+    }
+
+    public static final class SmallProvider implements ParticleProvider<SimpleParticleType> {
+        private final SpriteSet sprites;
+
+        public SmallProvider(SpriteSet sprites) {
+            this.sprites = sprites;
+        }
+
+        @Override
+        public Particle createParticle(SimpleParticleType type, ClientLevel level, double x, double y, double z, double xd, double yd, double zd) {
+            return new LucidBoltImpactParticle(level, x, y, z, xd, yd, zd, this.sprites, 0.1F, 8, 4);
+        }
+    }
+
+    public static final class LargeProvider implements ParticleProvider<SimpleParticleType> {
+        private final SpriteSet sprites;
+
+        public LargeProvider(SpriteSet sprites) {
+            this.sprites = sprites;
+        }
+
+        @Override
+        public Particle createParticle(SimpleParticleType type, ClientLevel level, double x, double y, double z, double xd, double yd, double zd) {
+            return new LucidBoltImpactParticle(level, x, y, z, xd, yd, zd, this.sprites, 0.22F, 10, 4);
+        }
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/client/renderer/DimensionalTearRenderer.java

@@ -0,0 +1,28 @@
+package com.craisinlord.antarchy.content.client.renderer;
+
+import com.craisinlord.antarchy.content.client.model.DimensionalTearModel;
+import com.craisinlord.antarchy.content.entity.portal.DimensionalTearEntity;
+import com.mojang.blaze3d.vertex.PoseStack;
+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.renderer.GeoEntityRenderer;
+
+public class DimensionalTearRenderer extends GeoEntityRenderer<DimensionalTearEntity> {
+    public DimensionalTearRenderer(EntityRendererProvider.Context context) {
+        super(context, new DimensionalTearModel());
+        this.shadowRadius = 0.0F;
+    }
+
+    @Override
+    public void render(DimensionalTearEntity entity, float entityYaw, float partialTick, PoseStack poseStack, MultiBufferSource bufferSource, int packedLight) {
+        super.render(entity, entityYaw, partialTick, poseStack, bufferSource, 0xF000F0);
+    }
+
+    @Override
+    public @Nullable RenderType getRenderType(DimensionalTearEntity animatable, ResourceLocation texture, @Nullable MultiBufferSource bufferSource, float partialTick) {
+        return RenderType.entityTranslucent(DimensionalTearModel.TEXTURE);
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/client/renderer/GlimmeringLivingLayer.java

@@ -0,0 +1,44 @@
+package com.craisinlord.antarchy.content.client.renderer;
+
+import com.craisinlord.antarchy.content.AntarchyObjects;
+import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.blaze3d.vertex.VertexConsumer;
+import net.minecraft.client.model.EntityModel;
+import net.minecraft.client.renderer.LightTexture;
+import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.client.renderer.entity.LivingEntityRenderer;
+import net.minecraft.client.renderer.entity.RenderLayerParent;
+import net.minecraft.client.renderer.entity.layers.RenderLayer;
+import net.minecraft.core.Holder;
+import net.minecraft.world.effect.MobEffect;
+import net.minecraft.world.entity.LivingEntity;
+
+public final class GlimmeringLivingLayer<T extends LivingEntity, M extends EntityModel<T>> extends RenderLayer<T, M> {
+    // High-alpha, luminance-preserving tint drawn straight over the skin (no scale-up) so it
+    // reads as the body itself recolored spirit-blue rather than a separate ghost shell.
+    private static final int GLIMMERING_TINT = 0x4266CCFF;
+
+    public GlimmeringLivingLayer(RenderLayerParent<T, M> renderer) {
+        super(renderer);
+    }
+
+    @Override
+    public void render(PoseStack poseStack, MultiBufferSource buffer, int packedLight, T entity,
+                       float limbSwing, float limbSwingAmount, float partialTick, float ageInTicks,
+                       float netHeadYaw, float headPitch) {
+        Holder<MobEffect> glimmering = AntarchyObjects.GLIMMERING_EFFECT.get();
+        if (glimmering == null || !entity.hasEffect(glimmering)) {
+            return;
+        }
+
+        VertexConsumer vertexConsumer = buffer.getBuffer(RenderType.entityTranslucentEmissive(this.getTextureLocation(entity)));
+        this.getParentModel().renderToBuffer(
+                poseStack,
+                vertexConsumer,
+                LightTexture.FULL_BRIGHT,
+                LivingEntityRenderer.getOverlayCoords(entity, 0.0F),
+                GLIMMERING_TINT
+        );
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/client/renderer/ThoraxisUndersideSkyRenderer.java

@@ -0,0 +1,256 @@
+package com.craisinlord.antarchy.content.client.renderer;
+
+import com.craisinlord.antarchy.Antarchy;
+import com.craisinlord.antarchy.content.worldgen.thoraxis.ThoraxisUndersideManager;
+import com.mojang.blaze3d.platform.GlStateManager;
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.vertex.BufferBuilder;
+import com.mojang.blaze3d.vertex.BufferUploader;
+import com.mojang.blaze3d.vertex.DefaultVertexFormat;
+import com.mojang.blaze3d.vertex.MeshData;
+import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.blaze3d.vertex.Tesselator;
+import com.mojang.blaze3d.vertex.VertexBuffer;
+import com.mojang.blaze3d.vertex.VertexFormat;
+import com.mojang.blaze3d.vertex.VertexSorting;
+import java.util.Random;
+import net.minecraft.client.Camera;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.ClientLevel;
+import net.minecraft.client.renderer.GameRenderer;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.util.Mth;
+import net.minecraft.world.level.Level;
+import org.joml.Matrix4f;
+import org.joml.Matrix4fStack;
+
+public final class ThoraxisUndersideSkyRenderer {
+    public static final ResourceKey<Level> THORAXIS = ResourceKey.create(
+            Registries.DIMENSION,
+            ResourceLocation.fromNamespaceAndPath(Antarchy.MODID, "thoraxis")
+    );
+    private static final ResourceLocation SUN_TEXTURE = ResourceLocation.withDefaultNamespace("textures/environment/sun.png");
+    private static final ResourceLocation MOON_TEXTURE = ResourceLocation.withDefaultNamespace("textures/environment/moon_phases.png");
+    private static final float SKY_RADIUS = 100.0F;
+    private static final float BODY_SIZE = 32.0F;
+    private static final float SKY_RED = 0.015F;
+    private static final float SKY_GREEN = 0.0F;
+    private static final float SKY_BLUE = 0.035F;
+
+    @org.jetbrains.annotations.Nullable
+    private static VertexBuffer redStarBuffer = null;
+
+    private ThoraxisUndersideSkyRenderer() {
+    }
+
+    public static boolean shouldRender(ClientLevel level, Camera camera) {
+        return level.dimension().equals(THORAXIS) && camera.getPosition().y < ThoraxisUndersideManager.GRAVITY_FLIP_Y;
+    }
+
+    public static void render(
+            Minecraft minecraft,
+            PoseStack poseStack,
+            Matrix4f projectionMatrix,
+            float partialTick,
+            Camera camera,
+            boolean isFoggy,
+            Runnable setupFog,
+            VertexBuffer skyBuffer
+    ) {
+        setupFog.run();
+        if (isFoggy || minecraft.options.hideLightningFlash().get() || minecraft.gameRenderer.getMainCamera() != camera) {
+            return;
+        }
+
+        RenderSystem.depthMask(false);
+        RenderSystem.setShaderColor(SKY_RED, SKY_GREEN, SKY_BLUE, 1.0F);
+        skyBuffer.bind();
+        skyBuffer.drawWithShader(poseStack.last().pose(), projectionMatrix, GameRenderer.getPositionShader());
+        VertexBuffer.unbind();
+        RenderSystem.setShaderColor(1.0F, 1.0F, 1.0F, 1.0F);
+
+        float timeOfDay = 0.72F + partialTick * 0.0F;
+        renderCelestialBodies(poseStack.last().pose(), projectionMatrix, timeOfDay);
+        renderRedStars(poseStack.last().pose(), projectionMatrix);
+
+        RenderSystem.depthMask(true);
+    }
+
+    private static void renderRedStars(Matrix4f modelViewMatrix, Matrix4f projectionMatrix) {
+        if (redStarBuffer == null) {
+            redStarBuffer = buildRedStarBuffer();
+        }
+
+        RenderSystem.enableBlend();
+        RenderSystem.defaultBlendFunc();
+        RenderSystem.setShaderColor(0.95F, 0.95F, 0.95F, 0.95F);
+        redStarBuffer.bind();
+        redStarBuffer.drawWithShader(modelViewMatrix, projectionMatrix, GameRenderer.getPositionColorShader());
+        VertexBuffer.unbind();
+        RenderSystem.setShaderColor(1.0F, 1.0F, 1.0F, 1.0F);
+        RenderSystem.disableBlend();
+    }
+
+    private static VertexBuffer buildRedStarBuffer() {
+        Random random = new Random(552031L);
+        BufferBuilder builder = Tesselator.getInstance().begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_COLOR);
+
+        for (int i = 0; i < 1800; i++) {
+            double x = random.nextFloat() * 2.0F - 1.0F;
+            double y = random.nextFloat() * 2.0F - 1.0F;
+            double z = random.nextFloat() * 2.0F - 1.0F;
+            double size = 0.13F + random.nextFloat() * 0.12F;
+            double lenSq = x * x + y * y + z * z;
+            if (lenSq < 1.0D && lenSq > 0.01D) {
+                double len = 1.0D / Math.sqrt(lenSq);
+                x *= len;
+                y *= len;
+                z *= len;
+                double sx = x * 100.0D;
+                double sy = y * 100.0D;
+                double sz = z * 100.0D;
+                double yaw = Math.atan2(x, z);
+                double sinYaw = Math.sin(yaw);
+                double cosYaw = Math.cos(yaw);
+                double pitch = Math.atan2(Math.sqrt(x * x + z * z), y);
+                double sinPitch = Math.sin(pitch);
+                double cosPitch = Math.cos(pitch);
+                double rot = random.nextDouble() * Math.PI * 2.0D;
+                double sinRot = Math.sin(rot);
+                double cosRot = Math.cos(rot);
+                float red = 0.75F + random.nextFloat() * 0.25F;
+                float green = 0.02F + random.nextFloat() * 0.05F;
+                float blue = 0.04F + random.nextFloat() * 0.08F;
+
+                for (int j = 0; j < 4; j++) {
+                    double u = (j & 2) - 1;
+                    double v = (j + 1 & 2) - 1;
+                    double px = u * cosRot - v * sinRot;
+                    double py = v * cosRot + u * sinRot;
+                    double qx = px * sinPitch;
+                    double qy = -px * cosPitch;
+                    double rx = qy * sinYaw - py * cosYaw;
+                    double ry = py * sinYaw + qy * cosYaw;
+                    builder.addVertex((float) (sx + rx * size), (float) (sy + qx * size), (float) (sz + ry * size))
+                            .setColor(red, green, blue, 1.0F);
+                }
+            }
+        }
+
+        MeshData mesh = builder.buildOrThrow();
+        VertexBuffer buffer = new VertexBuffer(VertexBuffer.Usage.STATIC);
+        buffer.bind();
+        buffer.upload(mesh);
+        VertexBuffer.unbind();
+        return buffer;
+    }
+
+    private static void renderCelestialBodies(Matrix4f modelViewMatrix, Matrix4f projectionMatrix, float timeOfDay) {
+        float t = timeOfDay * 360.0F;
+        renderBodyGlow(modelViewMatrix, projectionMatrix, t, -10.0F, 0xFF1F18, 86.0F);
+        renderTexturedBody(modelViewMatrix, projectionMatrix, t, -10.0F, 42.0F, 0xFF1F18, SUN_TEXTURE, false, 0, t * 0.6F);
+
+        float moonOrbit = t + 180.0F;
+        renderBodyGlow(modelViewMatrix, projectionMatrix, moonOrbit, 24.0F, 0x8F30FF, 76.0F);
+        renderTexturedBody(modelViewMatrix, projectionMatrix, moonOrbit, 24.0F, 26.0F, 0x8F30FF, MOON_TEXTURE, true, 0, -t * 0.35F);
+    }
+
+    private static void renderBodyGlow(Matrix4f modelViewMatrix, Matrix4f projectionMatrix, float orbitDegrees, float yawDegrees, int rgb, float glowRadius) {
+        RenderSystem.enableBlend();
+        RenderSystem.defaultBlendFunc();
+        RenderSystem.disableCull();
+        RenderSystem.setShader(GameRenderer::getPositionColorShader);
+        RenderSystem.backupProjectionMatrix();
+        RenderSystem.setProjectionMatrix(projectionMatrix, VertexSorting.DISTANCE_TO_ORIGIN);
+
+        Matrix4fStack modelViewStack = RenderSystem.getModelViewStack();
+        modelViewStack.pushMatrix();
+        modelViewStack.set(modelViewMatrix);
+        modelViewStack.rotateX((float) Math.toRadians(orbitDegrees));
+        modelViewStack.rotateZ((float) Math.toRadians(yawDegrees));
+        RenderSystem.applyModelViewMatrix();
+
+        float red = ((rgb >> 16) & 0xFF) / 255.0F;
+        float green = ((rgb >> 8) & 0xFF) / 255.0F;
+        float blue = (rgb & 0xFF) / 255.0F;
+        BufferBuilder buffer = Tesselator.getInstance().begin(VertexFormat.Mode.TRIANGLE_FAN, DefaultVertexFormat.POSITION_COLOR);
+        buffer.addVertex(0.0F, SKY_RADIUS, 0.0F).setColor(red, green, blue, 0.55F);
+        for (int i = 0; i <= 24; i++) {
+            float angle = i * Mth.TWO_PI / 24.0F;
+            buffer.addVertex(Mth.sin(angle) * glowRadius, SKY_RADIUS, Mth.cos(angle) * glowRadius).setColor(red, green, blue, 0.0F);
+        }
+        BufferUploader.drawWithShader(buffer.buildOrThrow());
+
+        modelViewStack.popMatrix();
+        RenderSystem.applyModelViewMatrix();
+        RenderSystem.restoreProjectionMatrix();
+        RenderSystem.enableCull();
+        RenderSystem.disableBlend();
+    }
+
+    private static void renderTexturedBody(
+            Matrix4f modelViewMatrix,
+            Matrix4f projectionMatrix,
+            float orbitDegrees,
+            float yawDegrees,
+            float radius,
+            int rgb,
+            ResourceLocation texture,
+            boolean usePhaseSheet,
+            int phaseIndex,
+            float selfRotationDegrees
+    ) {
+        RenderSystem.enableBlend();
+        RenderSystem.blendFuncSeparate(
+                GlStateManager.SourceFactor.ONE,
+                GlStateManager.DestFactor.ONE,
+                GlStateManager.SourceFactor.ONE,
+                GlStateManager.DestFactor.ZERO
+        );
+        RenderSystem.disableCull();
+        RenderSystem.setShaderColor(((rgb >> 16) & 0xFF) / 255.0F, ((rgb >> 8) & 0xFF) / 255.0F, (rgb & 0xFF) / 255.0F, 1.0F);
+        RenderSystem.setShader(GameRenderer::getPositionTexShader);
+        RenderSystem.setShaderTexture(0, texture);
+        RenderSystem.backupProjectionMatrix();
+        RenderSystem.setProjectionMatrix(projectionMatrix, VertexSorting.DISTANCE_TO_ORIGIN);
+
+        Matrix4fStack modelViewStack = RenderSystem.getModelViewStack();
+        modelViewStack.pushMatrix();
+        modelViewStack.set(modelViewMatrix);
+        modelViewStack.rotateX((float) Math.toRadians(orbitDegrees));
+        modelViewStack.rotateZ((float) Math.toRadians(yawDegrees));
+        modelViewStack.rotateY((float) Math.toRadians(selfRotationDegrees));
+        RenderSystem.applyModelViewMatrix();
+
+        float halfSize = BODY_SIZE * 0.5F * (radius / 22.0F);
+        float minU = 0.0F;
+        float maxU = 1.0F;
+        float minV = 0.0F;
+        float maxV = 1.0F;
+        if (usePhaseSheet) {
+            int phaseX = phaseIndex % 4;
+            int phaseY = phaseIndex / 4;
+            minU = phaseX / 4.0F;
+            maxU = (phaseX + 1) / 4.0F;
+            minV = phaseY / 2.0F;
+            maxV = (phaseY + 1) / 2.0F;
+        }
+
+        BufferBuilder buffer = Tesselator.getInstance().begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX);
+        buffer.addVertex(-halfSize, SKY_RADIUS, -halfSize).setUv(minU, minV);
+        buffer.addVertex(-halfSize, SKY_RADIUS, halfSize).setUv(minU, maxV);
+        buffer.addVertex(halfSize, SKY_RADIUS, halfSize).setUv(maxU, maxV);
+        buffer.addVertex(halfSize, SKY_RADIUS, -halfSize).setUv(maxU, minV);
+        BufferUploader.drawWithShader(buffer.buildOrThrow());
+
+        modelViewStack.popMatrix();
+        RenderSystem.applyModelViewMatrix();
+        RenderSystem.restoreProjectionMatrix();
+        RenderSystem.setShaderColor(1.0F, 1.0F, 1.0F, 1.0F);
+        RenderSystem.defaultBlendFunc();
+        RenderSystem.enableCull();
+        RenderSystem.disableBlend();
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/effect/GlimmeringMobEffect.java

@@ -0,0 +1,26 @@
+package com.craisinlord.antarchy.content.effect;
+
+import com.craisinlord.antarchy.content.client.particle.GlimmerParticles;
+import net.minecraft.world.effect.MobEffect;
+import net.minecraft.world.effect.MobEffectCategory;
+import net.minecraft.world.entity.LivingEntity;
+
+public final class GlimmeringMobEffect extends MobEffect {
+    public GlimmeringMobEffect() {
+        super(MobEffectCategory.BENEFICIAL, 0x66CCFF);
+    }
+
+    @Override
+    public boolean applyEffectTick(LivingEntity entity, int amplifier) {
+        if (!entity.level().isClientSide()) {
+            boolean running = entity.getDeltaMovement().horizontalDistanceSqr() > 1.0E-4D;
+            GlimmerParticles.tickAmbient(entity, running);
+        }
+        return true;
+    }
+
+    @Override
+    public boolean shouldApplyEffectTickThisTick(int duration, int amplifier) {
+        return true;
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/entity/CaterpillarEntity.java

@@ -97,8 +97,8 @@ public class CaterpillarEntity extends Animal implements GeoEntity {
     private static final RawAnimation WALK_ANIM = RawAnimation.begin().thenLoop("walk");
     private static final RawAnimation IDLE_ANIM = RawAnimation.begin().thenLoop("idle");
     private static final RawAnimation EAT_ANIM = RawAnimation.begin().thenPlay("eat");
-    private static final RawAnimation PUPATION_ANIM = RawAnimation.begin().thenPlay("Coocon");
-    private static final RawAnimation CHRYSALIS_ANIM = RawAnimation.begin().thenLoop("coocon");
+    private static final RawAnimation PUPATION_ANIM = RawAnimation.begin().thenPlay("cocoon");
+    private static final RawAnimation CHRYSALIS_ANIM = RawAnimation.begin().thenLoop("cocoon_chrysalis");
 
     private final AnimatableInstanceCache geoCache = GeckoLibUtil.createInstanceCache(this);
 

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

@@ -156,6 +156,8 @@ public class CreepingHorrorEntity extends Monster implements GeoEntity {
         attackAnimTicks = clamped;
         if (wasIdle && clamped > 0) {
             this.triggerAnim("main_controller", "attack");
+        } else if (!wasIdle && clamped <= 0) {
+            this.stopTriggeredAnim("main_controller", "attack");
         }
     }
 
@@ -177,7 +179,7 @@ public class CreepingHorrorEntity extends Monster implements GeoEntity {
     @Override
     public void handleEntityEvent(byte id) {
         if (id == ATTACK_ANIM_EVENT) {
-            attackAnimTicks = 20;
+            this.setAttackAnimTicks(20);
             return;
         }
         super.handleEntityEvent(id);
@@ -189,15 +191,14 @@ public class CreepingHorrorEntity extends Monster implements GeoEntity {
         super.tick();
         CavarynBurrowingMobBehavior.moveOutOfBlocks(this);
         if (attackAnimTicks > 0) {
-            attackAnimTicks--;
-            if (attackAnimTicks <= 0 && !this.level().isClientSide()) {
-                this.stopTriggeredAnim("main_controller", "attack");
-            }
+            this.setAttackAnimTicks(attackAnimTicks - 1);
         }
         if (this.level().isClientSide()) return;
 
         boolean climbing = this.horizontalCollision;
-        this.entityData.set(CLIMBING, climbing);
+        if (this.entityData.get(CLIMBING) != climbing) {
+            this.entityData.set(CLIMBING, climbing);
+        }
 
         if (climbing && this.getTarget() != null) {
             LivingEntity target = this.getTarget();

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

@@ -178,7 +178,7 @@ public class LurkingTerrorEntity extends Monster implements GeoEntity {
         if (!this.level().isClientSide() && !this.onGround() && this.tickCount % 80 == 0) {
             this.playSound(AntarchySoundEvents.LURKING_TERROR_FLY_LOOP.get(), 0.45F, 0.95F + this.random.nextFloat() * 0.1F);
         }
-        if (!this.level().isClientSide() && attackAnimTicks > 0) this.setAttackAnimTicks(attackAnimTicks - 1);
+        if (attackAnimTicks > 0) this.setAttackAnimTicks(attackAnimTicks - 1);
     }
 
     private void setAttackAnimTicks(int ticks) {

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/entity/NadirBoatEntity.java

@@ -0,0 +1,21 @@
+package com.craisinlord.antarchy.content.entity;
+
+import com.craisinlord.antarchy.Antarchy;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.vehicle.Boat;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.level.Level;
+
+public class NadirBoatEntity extends Boat {
+    public NadirBoatEntity(EntityType<? extends Boat> entityType, Level level) {
+        super(entityType, level);
+        this.setVariant(Type.OAK);
+    }
+
+    @Override
+    public Item getDropItem() {
+        return BuiltInRegistries.ITEM.get(ResourceLocation.fromNamespaceAndPath(Antarchy.MODID, "nadir_boat"));
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/entity/NadirChestBoatEntity.java

@@ -0,0 +1,22 @@
+package com.craisinlord.antarchy.content.entity;
+
+import com.craisinlord.antarchy.Antarchy;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.vehicle.Boat;
+import net.minecraft.world.entity.vehicle.ChestBoat;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.level.Level;
+
+public class NadirChestBoatEntity extends ChestBoat {
+    public NadirChestBoatEntity(EntityType<? extends Boat> entityType, Level level) {
+        super(entityType, level);
+        this.setVariant(Type.OAK);
+    }
+
+    @Override
+    public Item getDropItem() {
+        return BuiltInRegistries.ITEM.get(ResourceLocation.fromNamespaceAndPath(Antarchy.MODID, "nadir_chest_boat"));
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/entity/OctopusBombEntity.java

@@ -299,8 +299,6 @@ public class OctopusBombEntity extends Monster implements GeoEntity {
         tag.putInt("LastAttackState", this.lastAttackState);
         tag.putBoolean("CanFly", this.canFly());
         tag.putBoolean("SpawnedByKraken", this.spawnedByKraken);
-        if (this.grabbedTargetId >= 0) tag.putInt("GrabTarget", this.grabbedTargetId);
-        tag.putInt("AttackState", this.getAttackState());
         tag.putInt("AnimationState", this.getAnimationState());
     }
 
@@ -312,9 +310,10 @@ public class OctopusBombEntity extends Monster implements GeoEntity {
         this.lastAttackState = tag.contains("LastAttackState") ? tag.getInt("LastAttackState") : ATTACK_NONE;
         this.setCanFly(tag.getBoolean("CanFly"));
         this.spawnedByKraken = tag.getBoolean("SpawnedByKraken");
-        this.grabbedTargetId = tag.contains("GrabTarget") ? tag.getInt("GrabTarget") : -1;
-        this.entityData.set(ATTACK_STATE, tag.getInt("AttackState"));
-        this.entityData.set(ANIMATION_STATE, tag.contains("AnimationState") ? tag.getInt("AnimationState") : ANIM_IDLE);
+        this.grabbedTargetId = -1;
+        this.actionTicks = 0;
+        this.entityData.set(ATTACK_STATE, ATTACK_NONE);
+        this.entityData.set(ANIMATION_STATE, ANIM_IDLE);
     }
 
     public boolean canFly() {

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/entity/SpitBugEntity.java

@@ -24,7 +24,6 @@ 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.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;
@@ -59,7 +58,6 @@ public class SpitBugEntity extends Monster implements GeoEntity {
     private static final double ATTACK_DAMAGE = 5.0D;
     private static final double FOLLOW_RANGE = 24.0D;
     private static final double SPIT_RANGE_SQR = 14.0D * 14.0D;
-    private static final double MELEE_RANGE_SQR = 3.5D * 3.5D;
     private static final int SPIT_COOLDOWN_TICKS = 55;
     private static final int SPIT_ANIMATION_TICKS = 18;
     private static final int SPIT_RELEASE_TICKS = 8;
@@ -105,10 +103,9 @@ public class SpitBugEntity extends Monster implements GeoEntity {
     protected void registerGoals() {
         this.goalSelector.addGoal(0, new FloatGoal(this));
         this.goalSelector.addGoal(1, new SpitAttackGoal());
-        this.goalSelector.addGoal(2, new MeleeAttackGoal(this, 1.0D, false));
-        this.goalSelector.addGoal(3, new WaterAvoidingRandomStrollGoal(this, 0.9D));
-        this.goalSelector.addGoal(4, new LookAtPlayerGoal(this, Player.class, 12.0F));
-        this.goalSelector.addGoal(5, new RandomLookAroundGoal(this));
+        this.goalSelector.addGoal(2, new WaterAvoidingRandomStrollGoal(this, 0.9D));
+        this.goalSelector.addGoal(3, new LookAtPlayerGoal(this, Player.class, 12.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));
     }
@@ -193,8 +190,7 @@ public class SpitBugEntity extends Monster implements GeoEntity {
         return this.spitCooldownTicks <= 0
                 && this.spitAnimationTicks <= 0
                 && this.hasLineOfSight(target)
-                && this.distanceToSqr(target) <= SPIT_RANGE_SQR
-                && this.distanceToSqr(target) > MELEE_RANGE_SQR;
+                && this.distanceToSqr(target) <= SPIT_RANGE_SQR;
     }
 
     private void startSpitAttack() {
@@ -261,6 +257,11 @@ public class SpitBugEntity extends Monster implements GeoEntity {
 
             SpitBugEntity.this.getLookControl().setLookAt(target, 30.0F, 30.0F);
 
+            if (SpitBugEntity.this.spitAnimationTicks > 0) {
+                SpitBugEntity.this.getNavigation().stop();
+                return;
+            }
+
             if (SpitBugEntity.this.canSpitAt(target)) {
                 SpitBugEntity.this.getNavigation().stop();
                 SpitBugEntity.this.startSpitAttack();

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/entity/TriffidEntity.java

@@ -10,6 +10,7 @@ import java.util.Map;
 import java.util.UUID;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
+import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.syncher.EntityDataAccessor;
 import net.minecraft.network.syncher.EntityDataSerializers;
 import net.minecraft.network.syncher.SynchedEntityData;
@@ -147,6 +148,16 @@ public class TriffidEntity extends Monster implements GeoEntity {
         builder.define(AWAKE, false);
     }
 
+    @Override
+    public void readAdditionalSaveData(CompoundTag tag) {
+        super.readAdditionalSaveData(tag);
+        this.setActionState(ACTION_NONE);
+        this.actionTicks = 0;
+        this.grabTargetId = -1;
+        this.grabDamageApplied = false;
+        this.sweepHitCooldowns.clear();
+    }
+
     @Override
     protected void registerGoals() {
         this.goalSelector.addGoal(0, new FloatGoal(this));

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/entity/portal/DimensionalTearEntity.java

@@ -0,0 +1,376 @@
+package com.craisinlord.antarchy.content.entity.portal;
+
+import com.craisinlord.antarchy.config.AntarchySettings;
+import com.craisinlord.antarchy.content.AntarchyObjects;
+import com.craisinlord.antarchy.content.AntarchyTags;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Holder;
+import net.minecraft.core.HolderSet;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.core.particles.ParticleTypes;
+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.server.level.ServerPlayer;
+import net.minecraft.sounds.SoundEvents;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.world.Difficulty;
+import net.minecraft.world.damagesource.DamageSource;
+import net.minecraft.world.effect.MobEffectInstance;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.Mob;
+import net.minecraft.world.entity.MobSpawnType;
+import net.minecraft.world.level.Level;
+import net.minecraft.tags.TagKey;
+import net.minecraft.world.phys.AABB;
+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;
+
+public class DimensionalTearEntity extends Entity implements GeoEntity {
+    public enum TearState {
+        NORMAL,
+        UNSTABLE,
+        LUCID,
+        COLLAPSING,
+        OPENING
+    }
+
+    private static final EntityDataAccessor<Integer> STATE =
+            SynchedEntityData.defineId(DimensionalTearEntity.class, EntityDataSerializers.INT);
+    private static final RawAnimation ACTIVE_IDLE_ANIM = RawAnimation.begin().thenLoop("idle");
+    private static final RawAnimation CALM_IDLE_ANIM = RawAnimation.begin().thenLoop("idle2");
+    private static final RawAnimation OPENING_ANIM = RawAnimation.begin().thenPlay("opening").thenLoop("idle2");
+    private static final RawAnimation CLOSING_ANIM = RawAnimation.begin().thenPlayAndHold("closing");
+    private static final int DEFAULT_LIFETIME_TICKS = 20 * 60 * 20;
+    private static final int OPENING_ANIMATION_TICKS = 20;
+    private static final int CLOSING_ANIMATION_TICKS = 10;
+    private static final int EVENT_WARNING_TICKS = 80;
+    private static final int TELEPORT_COOLDOWN_TICKS = 60;
+    private static final double PORTAL_RADIUS = 1.35D;
+    private static final double EXIT_OFFSET = 2.4D;
+    private static final Map<UUID, Long> TELEPORT_COOLDOWNS = new HashMap<>();
+
+    private final AnimatableInstanceCache geoCache = GeckoLibUtil.createInstanceCache(this);
+    private UUID linkedTearId;
+    private Vec3 linkedFallbackPos = Vec3.ZERO;
+    private int ageTicks;
+    private int lifetimeTicks = DEFAULT_LIFETIME_TICKS;
+    private int eventTicks;
+    private int nextEventTicks;
+    private TearState pendingEvent = TearState.NORMAL;
+
+    public DimensionalTearEntity(EntityType<? extends DimensionalTearEntity> entityType, Level level) {
+        super(entityType, level);
+        this.setInvulnerable(true);
+        this.noPhysics = true;
+        this.noCulling = true;
+    }
+
+    public static DimensionalTearEntity create(ServerLevel level, Vec3 pos, float yaw, int lifetimeTicks) {
+        DimensionalTearEntity tear = new DimensionalTearEntity(AntarchyObjects.DIMENSIONAL_TEAR.get(), level);
+        tear.moveTo(pos.x, pos.y, pos.z, yaw, 0.0F);
+        tear.lifetimeTicks = lifetimeTicks;
+        tear.nextEventTicks = tear.randomEventDelay();
+        return tear;
+    }
+
+    public void linkTo(DimensionalTearEntity other) {
+        this.linkedTearId = other.getUUID();
+        this.linkedFallbackPos = other.position();
+    }
+
+    @Override
+    protected void defineSynchedData(SynchedEntityData.Builder builder) {
+        builder.define(STATE, TearState.NORMAL.ordinal());
+    }
+
+    @Override
+    public void tick() {
+        super.tick();
+        if (this.level().isClientSide) {
+            this.tickClientParticles();
+            return;
+        }
+
+        this.ageTicks++;
+        if (this.ageTicks < OPENING_ANIMATION_TICKS) {
+            this.setTearState(TearState.OPENING);
+        } else if (this.ageTicks >= this.lifetimeTicks - CLOSING_ANIMATION_TICKS) {
+            this.setTearState(TearState.COLLAPSING);
+        } else if (this.getTearState() == TearState.OPENING || this.getTearState() == TearState.COLLAPSING) {
+            this.setTearState(TearState.NORMAL);
+        }
+        if (this.ageTicks >= this.lifetimeTicks) {
+            this.removeLinkedPair();
+            return;
+        }
+
+        DimensionalTearEntity linked = this.findLinkedTear();
+        if (linked == null || !linked.isAlive()) {
+            this.discard();
+            return;
+        }
+
+        this.tickMobEvent((ServerLevel) this.level());
+        this.tickTeleport(linked);
+    }
+
+    private void tickMobEvent(ServerLevel level) {
+        TearState state = this.getTearState();
+        if (state == TearState.OPENING || state == TearState.COLLAPSING || level.getDifficulty() == Difficulty.PEACEFUL) {
+            return;
+        }
+
+        if (this.eventTicks > 0) {
+            this.eventTicks--;
+            if (this.eventTicks == 1) {
+                this.spawnEmergence(level, this.pendingEvent);
+                this.pendingEvent = TearState.NORMAL;
+                this.setTearState(TearState.NORMAL);
+                this.nextEventTicks = this.randomEventDelay();
+            }
+            return;
+        }
+
+        if (this.nextEventTicks > 0) {
+            this.nextEventTicks--;
+            return;
+        }
+
+        this.pendingEvent = this.random.nextFloat() < AntarchySettings.dimensionalTearLucidEventChance()
+                ? TearState.LUCID
+                : TearState.UNSTABLE;
+        this.eventTicks = EVENT_WARNING_TICKS;
+        this.setTearState(this.pendingEvent);
+        level.playSound(null, this.blockPosition(), SoundEvents.RESPAWN_ANCHOR_CHARGE, SoundSource.HOSTILE, 0.85F, this.pendingEvent == TearState.LUCID ? 1.35F : 0.65F);
+    }
+
+    private void spawnEmergence(ServerLevel level, TearState eventState) {
+        Vec3 exitPos = this.exitPosition();
+        TagKey<EntityType<?>> spawnTag = eventState == TearState.LUCID
+                ? AntarchyTags.Entities.DIMENSIONAL_TEAR_COMMON_SPAWNS
+                : AntarchyTags.Entities.DIMENSIONAL_TEAR_RARE_SPAWNS;
+        Mob mob = this.createTaggedMob(level, spawnTag);
+        if (mob == null || !level.noCollision(mob, mob.getType().getDimensions().makeBoundingBox(exitPos))) {
+            return;
+        }
+
+        mob.moveTo(exitPos.x, exitPos.y, exitPos.z, this.getYRot(), 0.0F);
+        mob.finalizeSpawn(level, level.getCurrentDifficultyAt(BlockPos.containing(exitPos)), MobSpawnType.MOB_SUMMONED, null);
+        mob.setDeltaMovement(this.getViewVector(1.0F).scale(0.35D).add(0.0D, 0.08D, 0.0D));
+        mob.setNoGravity(true);
+        level.addFreshEntity(mob);
+        level.playSound(null, this.blockPosition(), eventState == TearState.LUCID ? SoundEvents.AMETHYST_BLOCK_CHIME : SoundEvents.ENDERMAN_SCREAM, SoundSource.HOSTILE, 0.75F, eventState == TearState.LUCID ? 1.45F : 0.85F);
+    }
+
+    @Nullable
+    private Mob createTaggedMob(ServerLevel level, TagKey<EntityType<?>> tag) {
+        return BuiltInRegistries.ENTITY_TYPE.getTag(tag)
+                .flatMap((HolderSet.Named<EntityType<?>> entityTypes) -> entityTypes.getRandomElement(this.random))
+                .map(Holder::value)
+                .map(entityType -> entityType.create(level))
+                .filter(entity -> entity instanceof Mob)
+                .map(entity -> (Mob) entity)
+                .orElse(null);
+    }
+
+    private void tickTeleport(DimensionalTearEntity linked) {
+        AABB area = this.getBoundingBox().inflate(PORTAL_RADIUS);
+        List<Entity> entities = this.level().getEntities(this, area, this::canTeleportEntity);
+        for (Entity entity : entities) {
+            teleportEntity(entity, linked);
+        }
+    }
+
+    private boolean canTeleportEntity(Entity entity) {
+        if (!entity.isAlive() || entity instanceof DimensionalTearEntity || entity.isPassenger() || entity.isVehicle()) {
+            return false;
+        }
+        UUID uuid = entity.getUUID();
+        long gameTime = this.level().getGameTime();
+        long cooldownUntil = TELEPORT_COOLDOWNS.getOrDefault(uuid, 0L);
+        if (cooldownUntil <= gameTime) {
+            TELEPORT_COOLDOWNS.remove(uuid);
+            return true;
+        }
+        return false;
+    }
+
+    private void teleportEntity(Entity entity, DimensionalTearEntity destination) {
+        Vec3 motion = entity.getDeltaMovement();
+        Vec3 exitPos = destination.exitPosition();
+        TELEPORT_COOLDOWNS.put(entity.getUUID(), this.level().getGameTime() + TELEPORT_COOLDOWN_TICKS);
+
+        if (entity instanceof ServerPlayer player && destination.level() instanceof ServerLevel serverLevel) {
+            player.teleportTo(serverLevel, exitPos.x, exitPos.y, exitPos.z, player.getYRot(), player.getXRot());
+        } else {
+            entity.teleportTo(exitPos.x, exitPos.y, exitPos.z);
+        }
+
+        entity.setDeltaMovement(motion);
+        entity.hasImpulse = true;
+        if (entity instanceof LivingEntity living) {
+            living.addEffect(new MobEffectInstance(AntarchyObjects.INVERTED_EFFECT.get(), AntarchySettings.dimensionalTearInvertedDurationTicks(), 0));
+        }
+        this.level().playSound(null, this.blockPosition(), SoundEvents.ENDERMAN_TELEPORT, SoundSource.NEUTRAL, 0.7F, 0.65F + this.random.nextFloat() * 0.2F);
+    }
+
+    private Vec3 exitPosition() {
+        Vec3 facing = this.getViewVector(1.0F);
+        if (facing.lengthSqr() < 1.0E-4D) {
+            facing = new Vec3(0.0D, 0.0D, 1.0D);
+        }
+        return this.position().add(facing.normalize().scale(EXIT_OFFSET));
+    }
+
+    @Nullable
+    private DimensionalTearEntity findLinkedTear() {
+        if (!(this.level() instanceof ServerLevel serverLevel) || this.linkedTearId == null) {
+            return null;
+        }
+        Entity entity = serverLevel.getEntity(this.linkedTearId);
+        return entity instanceof DimensionalTearEntity tear ? tear : null;
+    }
+
+    private void removeLinkedPair() {
+        DimensionalTearEntity linked = this.findLinkedTear();
+        if (linked != null && linked.isAlive()) {
+            linked.discard();
+        }
+        this.discard();
+    }
+
+    private int randomEventDelay() {
+        int min = Math.max(20, AntarchySettings.dimensionalTearEmergenceMinIntervalTicks());
+        int max = Math.max(min, AntarchySettings.dimensionalTearEmergenceMaxIntervalTicks());
+        return min + this.random.nextInt(max - min + 1);
+    }
+
+    public TearState getTearState() {
+        int ordinal = this.entityData.get(STATE);
+        TearState[] values = TearState.values();
+        return ordinal >= 0 && ordinal < values.length ? values[ordinal] : TearState.NORMAL;
+    }
+
+    private void setTearState(TearState state) {
+        this.entityData.set(STATE, state.ordinal());
+    }
+
+    private void tickClientParticles() {
+        TearState state = this.getTearState();
+        if (this.random.nextInt(state == TearState.NORMAL ? 5 : 2) != 0) {
+            return;
+        }
+        double spread = state == TearState.NORMAL ? 0.65D : 1.15D;
+        this.level().addParticle(
+                state == TearState.LUCID ? ParticleTypes.END_ROD : ParticleTypes.PORTAL,
+                this.getX() + (this.random.nextDouble() - 0.5D) * spread,
+                this.getY() + 1.3D + (this.random.nextDouble() - 0.5D) * spread,
+                this.getZ() + (this.random.nextDouble() - 0.5D) * spread,
+                (this.random.nextDouble() - 0.5D) * 0.05D,
+                (this.random.nextDouble() - 0.5D) * 0.05D,
+                (this.random.nextDouble() - 0.5D) * 0.05D
+        );
+    }
+
+    @Override
+    public boolean isInvulnerableTo(DamageSource damageSource) {
+        return true;
+    }
+
+    @Override
+    public boolean fireImmune() {
+        return true;
+    }
+
+    @Override
+    public void lavaHurt() {
+    }
+
+    @Override
+    public boolean isPushable() {
+        return false;
+    }
+
+    @Override
+    public boolean canBeCollidedWith() {
+        return false;
+    }
+
+    @Override
+    public boolean isPickable() {
+        return false;
+    }
+
+    @Override
+    public void addAdditionalSaveData(CompoundTag tag) {
+        tag.putInt("AgeTicks", this.ageTicks);
+        tag.putInt("LifetimeTicks", this.lifetimeTicks);
+        tag.putInt("EventTicks", this.eventTicks);
+        tag.putInt("NextEventTicks", this.nextEventTicks);
+        tag.putInt("PendingEvent", this.pendingEvent.ordinal());
+        if (this.linkedTearId != null) {
+            tag.putUUID("LinkedTearId", this.linkedTearId);
+        }
+        tag.putDouble("LinkedX", this.linkedFallbackPos.x);
+        tag.putDouble("LinkedY", this.linkedFallbackPos.y);
+        tag.putDouble("LinkedZ", this.linkedFallbackPos.z);
+    }
+
+    @Override
+    public void readAdditionalSaveData(CompoundTag tag) {
+        this.ageTicks = tag.getInt("AgeTicks");
+        this.lifetimeTicks = tag.getInt("LifetimeTicks");
+        this.eventTicks = tag.getInt("EventTicks");
+        this.nextEventTicks = tag.getInt("NextEventTicks");
+        int event = tag.getInt("PendingEvent");
+        TearState[] states = TearState.values();
+        this.pendingEvent = event >= 0 && event < states.length ? states[event] : TearState.NORMAL;
+        if (tag.hasUUID("LinkedTearId")) {
+            this.linkedTearId = tag.getUUID("LinkedTearId");
+        }
+        this.linkedFallbackPos = new Vec3(tag.getDouble("LinkedX"), tag.getDouble("LinkedY"), tag.getDouble("LinkedZ"));
+    }
+
+    @Override
+    public void registerControllers(AnimatableManager.ControllerRegistrar controllers) {
+        controllers.add(new AnimationController<>(this, "tear_controller", 0, this::tearController));
+    }
+
+    private PlayState tearController(AnimationState<DimensionalTearEntity> state) {
+        TearState tearState = this.getTearState();
+        double speed = switch (tearState) {
+            case UNSTABLE -> 1.8D;
+            case LUCID -> 0.65D;
+            default -> 1.0D;
+        };
+        state.getController().setAnimationSpeed(speed);
+        return switch (tearState) {
+            case OPENING -> state.setAndContinue(OPENING_ANIM);
+            case COLLAPSING -> state.setAndContinue(CLOSING_ANIM);
+            case LUCID, UNSTABLE -> state.setAndContinue(ACTIVE_IDLE_ANIM);
+            default -> state.setAndContinue(CALM_IDLE_ANIM);
+        };
+    }
+
+    @Override
+    public AnimatableInstanceCache getAnimatableInstanceCache() {
+        return this.geoCache;
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/horde/CavarynCreatureSpawner.java

@@ -0,0 +1,227 @@
+package com.craisinlord.antarchy.content.horde;
+
+import com.craisinlord.antarchy.Antarchy;
+import com.craisinlord.antarchy.content.AntarchyObjects;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.util.Mth;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.Difficulty;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.Mob;
+import net.minecraft.world.entity.MobSpawnType;
+import net.minecraft.world.level.GameRules;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.phys.AABB;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Tops up stink bug / rolly polly populations near players in Cavaryn.
+ *
+ * Vanilla's NaturalSpawner picks a spawn Y uniformly at random between the dimension's min_y
+ * and a column's heightmap top. In Cavaryn that range spans the full 208-block dimension height,
+ * but any given column's actual floor only occupies a sliver of that, so the vanilla algorithm
+ * almost never lands on real ground even though floor itself is common. This scans a column
+ * directly for a real floor spot instead.
+ */
+public final class CavarynCreatureSpawner {
+    private static final ResourceKey<Level> CAVARYN = ResourceKey.create(
+            net.minecraft.core.registries.Registries.DIMENSION,
+            ResourceLocation.fromNamespaceAndPath(Antarchy.MODID, "cavaryn")
+    );
+
+    private static final int CHECK_INTERVAL_TICKS = 20 * 10;
+    private static final int AREA_COOLDOWN_TICKS = 20 * 60;
+    private static final int AREA_CELL_SIZE = 40;
+    private static final double NEARBY_RADIUS = 40.0D;
+    private static final int TARGET_NEARBY_COUNT = 4;
+    private static final double MIN_SPAWN_DISTANCE = 16.0D;
+    private static final double MAX_SPAWN_DISTANCE = 36.0D;
+    private static final int STINK_BUG_MIN_GROUP_SIZE = 1;
+    private static final int STINK_BUG_MAX_GROUP_SIZE = 5;
+    private static final int ROLLY_POLLY_MIN_GROUP_SIZE = 1;
+    private static final int ROLLY_POLLY_MAX_GROUP_SIZE = 3;
+    private static final int STINK_BUG_WEIGHT = 750;
+    private static final int ROLLY_POLLY_WEIGHT = 250;
+    private static final int MEMBER_JITTER_RADIUS = 4;
+    private static final int MEMBER_VERTICAL_SEARCH = 3;
+
+    private static final Map<Long, Long> AREA_COOLDOWNS = new HashMap<>();
+
+    private CavarynCreatureSpawner() {
+    }
+
+    public static void tick(ServerLevel level) {
+        if (!level.dimension().equals(CAVARYN)) {
+            return;
+        }
+        if (level.getDifficulty() == Difficulty.PEACEFUL || !level.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING)) {
+            return;
+        }
+
+        long gameTime = level.getGameTime();
+        if (gameTime % CHECK_INTERVAL_TICKS != 0L) {
+            return;
+        }
+
+        for (ServerPlayer player : level.players()) {
+            if (player.isSpectator() || player.isCreative() || !player.isAlive()) {
+                continue;
+            }
+            attemptSpawnNear(level, player, gameTime);
+        }
+    }
+
+    private static void attemptSpawnNear(ServerLevel level, ServerPlayer player, long gameTime) {
+        BlockPos playerPos = player.blockPosition();
+        long area = areaKey(playerPos);
+        Long cooldownUntil = AREA_COOLDOWNS.get(area);
+        if (cooldownUntil != null && gameTime < cooldownUntil) {
+            return;
+        }
+
+        EntityType<?> stinkBugType = AntarchyObjects.STINK_BUG.get();
+        EntityType<?> rollyPollyType = AntarchyObjects.ROLLY_POLLY.get();
+        int nearbyStinkBugs = countNearby(level, playerPos, stinkBugType);
+        int nearbyRollyPollies = countNearby(level, playerPos, rollyPollyType);
+        boolean needStinkBug = nearbyStinkBugs < TARGET_NEARBY_COUNT;
+        boolean needRollyPolly = nearbyRollyPollies < TARGET_NEARBY_COUNT;
+        if (!needStinkBug && !needRollyPolly) {
+            AREA_COOLDOWNS.put(area, gameTime + AREA_COOLDOWN_TICKS);
+            return;
+        }
+
+        RandomSource random = level.random;
+        BlockPos anchor = pickColumnNear(level, player, random);
+        if (anchor == null) {
+            return;
+        }
+
+        EntityType<?> chosenType = chooseType(needStinkBug, needRollyPolly, random);
+        boolean isStinkBug = chosenType == AntarchyObjects.STINK_BUG.get();
+        int minGroupSize = isStinkBug ? STINK_BUG_MIN_GROUP_SIZE : ROLLY_POLLY_MIN_GROUP_SIZE;
+        int maxGroupSize = isStinkBug ? STINK_BUG_MAX_GROUP_SIZE : ROLLY_POLLY_MAX_GROUP_SIZE;
+        int groupSize = minGroupSize + random.nextInt(maxGroupSize - minGroupSize + 1);
+        int spawned = 0;
+        for (int i = 0; i < groupSize; i++) {
+            BlockPos memberPos = jitter(anchor, random);
+            BlockPos memberFloor = findFloorNear(level, memberPos);
+            if (memberFloor == null) {
+                continue;
+            }
+            if (spawnMob(level, chosenType, memberFloor)) {
+                spawned++;
+            }
+        }
+
+        if (spawned > 0) {
+            AREA_COOLDOWNS.put(area, gameTime + AREA_COOLDOWN_TICKS);
+        }
+    }
+
+    private static int countNearby(ServerLevel level, BlockPos center, EntityType<?> type) {
+        AABB box = new AABB(center).inflate(NEARBY_RADIUS);
+        return level.getEntities(type, box, entity -> true).size();
+    }
+
+    private static EntityType<?> chooseType(boolean needStinkBug, boolean needRollyPolly, RandomSource random) {
+        if (needStinkBug && !needRollyPolly) {
+            return AntarchyObjects.STINK_BUG.get();
+        }
+        if (needRollyPolly && !needStinkBug) {
+            return AntarchyObjects.ROLLY_POLLY.get();
+        }
+        int roll = random.nextInt(STINK_BUG_WEIGHT + ROLLY_POLLY_WEIGHT);
+        return roll < STINK_BUG_WEIGHT ? AntarchyObjects.STINK_BUG.get() : AntarchyObjects.ROLLY_POLLY.get();
+    }
+
+    private static BlockPos pickColumnNear(ServerLevel level, ServerPlayer player, RandomSource random) {
+        BlockPos origin = player.blockPosition();
+        for (int attempt = 0; attempt < 12; attempt++) {
+            double angle = random.nextDouble() * Math.PI * 2.0D;
+            double distance = MIN_SPAWN_DISTANCE + random.nextDouble() * (MAX_SPAWN_DISTANCE - MIN_SPAWN_DISTANCE);
+            int x = origin.getX() + Mth.floor(Math.cos(angle) * distance);
+            int z = origin.getZ() + Mth.floor(Math.sin(angle) * distance);
+            if (!level.hasChunkAt(new BlockPos(x, origin.getY(), z))) {
+                continue;
+            }
+            BlockPos floor = scanColumnForFloor(level, x, z);
+            if (floor != null) {
+                return floor;
+            }
+        }
+        return null;
+    }
+
+    private static BlockPos scanColumnForFloor(ServerLevel level, int x, int z) {
+        int minY = level.getMinBuildHeight();
+        int maxY = level.getMaxBuildHeight() - 1;
+        BlockPos.MutableBlockPos cursor = new BlockPos.MutableBlockPos();
+        for (int y = minY; y <= maxY; y++) {
+            cursor.set(x, y, z);
+            if (isValidGroundSpawn(level, cursor)) {
+                return cursor.immutable();
+            }
+        }
+        return null;
+    }
+
+    private static BlockPos jitter(BlockPos anchor, RandomSource random) {
+        int dx = random.nextInt(MEMBER_JITTER_RADIUS * 2 + 1) - MEMBER_JITTER_RADIUS;
+        int dz = random.nextInt(MEMBER_JITTER_RADIUS * 2 + 1) - MEMBER_JITTER_RADIUS;
+        return anchor.offset(dx, 0, dz);
+    }
+
+    private static BlockPos findFloorNear(ServerLevel level, BlockPos start) {
+        BlockPos.MutableBlockPos cursor = new BlockPos.MutableBlockPos();
+        for (int dy = 0; dy <= MEMBER_VERTICAL_SEARCH; dy++) {
+            cursor.set(start.getX(), start.getY() - dy, start.getZ());
+            if (isValidGroundSpawn(level, cursor)) {
+                return cursor.immutable();
+            }
+            if (dy != 0) {
+                cursor.set(start.getX(), start.getY() + dy, start.getZ());
+                if (isValidGroundSpawn(level, cursor)) {
+                    return cursor.immutable();
+                }
+            }
+        }
+        return null;
+    }
+
+    private static boolean isValidGroundSpawn(ServerLevel level, BlockPos pos) {
+        BlockPos below = pos.below();
+        return level.getBlockState(pos).isAir()
+                && level.getBlockState(pos.above()).isAir()
+                && level.getFluidState(pos).isEmpty()
+                && level.getFluidState(pos.above()).isEmpty()
+                && level.getBlockState(below).isFaceSturdy(level, below, Direction.UP);
+    }
+
+    private static boolean spawnMob(ServerLevel level, EntityType<?> type, BlockPos pos) {
+        if (!level.noCollision(type.getSpawnAABB(pos.getX() + 0.5D, pos.getY(), pos.getZ() + 0.5D))) {
+            return false;
+        }
+        Entity entity = type.create(level);
+        if (!(entity instanceof Mob mob)) {
+            return false;
+        }
+        mob.moveTo(pos.getX() + 0.5D, pos.getY(), pos.getZ() + 0.5D, level.random.nextFloat() * 360.0F, 0.0F);
+        mob.finalizeSpawn(level, level.getCurrentDifficultyAt(pos), MobSpawnType.NATURAL, null);
+        return level.addFreshEntity(mob);
+    }
+
+    private static long areaKey(BlockPos pos) {
+        return BlockPos.asLong(
+                Math.floorDiv(pos.getX(), AREA_CELL_SIZE) * AREA_CELL_SIZE,
+                Math.floorDiv(pos.getY(), AREA_CELL_SIZE) * AREA_CELL_SIZE,
+                Math.floorDiv(pos.getZ(), AREA_CELL_SIZE) * AREA_CELL_SIZE
+        );
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/item/MucusBlockItem.java

@@ -0,0 +1,23 @@
+package com.craisinlord.antarchy.content.item;
+
+import java.util.List;
+
+import net.minecraft.ChatFormatting;
+import net.minecraft.network.chat.Component;
+import net.minecraft.world.item.BlockItem;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.level.block.Block;
+
+public class MucusBlockItem extends BlockItem {
+    public MucusBlockItem(Block block, Properties properties) {
+        super(block, properties);
+    }
+
+    @Override
+    public void appendHoverText(ItemStack stack, Item.TooltipContext context, List<Component> tooltipComponents, TooltipFlag tooltipFlag) {
+//        tooltipComponents.add(Component.translatable("tooltip.antarchy.mucus_slippery").withStyle(ChatFormatting.DARK_AQUA));
+        super.appendHoverText(stack, context, tooltipComponents, tooltipFlag);
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/item/NadirBoatOnlyItem.java

@@ -0,0 +1,31 @@
+package com.craisinlord.antarchy.content.item;
+
+import com.craisinlord.antarchy.content.entity.NadirBoatEntity;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.entity.vehicle.Boat;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.phys.HitResult;
+import net.minecraft.world.phys.Vec3;
+
+public class NadirBoatOnlyItem extends OuranwoodBoatItem {
+    private final EntityType<NadirBoatEntity> entityType;
+
+    public NadirBoatOnlyItem(EntityType<NadirBoatEntity> entityType, Properties properties) {
+        super(properties);
+        this.entityType = entityType;
+    }
+
+    @Override
+    protected Boat createBoat(Level level, HitResult hitResult, ItemStack stack, Player player) {
+        Vec3 pos = hitResult.getLocation();
+        NadirBoatEntity boat = new NadirBoatEntity(this.entityType, level);
+        boat.setPos(pos.x, pos.y, pos.z);
+        boat.xo = pos.x;
+        boat.yo = pos.y;
+        boat.zo = pos.z;
+        this.applyDefaultStackConfig(level, stack, player, boat);
+        return boat;
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/item/NadirChestBoatItem.java

@@ -0,0 +1,31 @@
+package com.craisinlord.antarchy.content.item;
+
+import com.craisinlord.antarchy.content.entity.NadirChestBoatEntity;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.entity.vehicle.Boat;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.phys.HitResult;
+import net.minecraft.world.phys.Vec3;
+
+public class NadirChestBoatItem extends OuranwoodBoatItem {
+    private final EntityType<NadirChestBoatEntity> entityType;
+
+    public NadirChestBoatItem(EntityType<NadirChestBoatEntity> entityType, Properties properties) {
+        super(properties);
+        this.entityType = entityType;
+    }
+
+    @Override
+    protected Boat createBoat(Level level, HitResult hitResult, ItemStack stack, Player player) {
+        Vec3 pos = hitResult.getLocation();
+        NadirChestBoatEntity boat = new NadirChestBoatEntity(this.entityType, level);
+        boat.setPos(pos.x, pos.y, pos.z);
+        boat.xo = pos.x;
+        boat.yo = pos.y;
+        boat.zo = pos.z;
+        this.applyDefaultStackConfig(level, stack, player, boat);
+        return boat;
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/portal/RainbowPortalIgniter.java

@@ -0,0 +1,90 @@
+package com.craisinlord.antarchy.content.portal;
+
+import com.craisinlord.antarchy.compat.infinity.InfinityCompat;
+import com.craisinlord.antarchy.content.AntarchyTags;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.sounds.SoundEvents;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.phys.AABB;
+import net.minecraft.world.phys.Vec3;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Converts an unlit obsidian frame near a killed rainbow ant into a real, permanent Infinite Dimensions
+ * portal to that ant's assigned dimension. Lights the frame as a normal vanilla Nether portal first, then
+ * hands it to Infinity's own portal-creation pipeline (the same one used when a book is thrown into a lit
+ * portal), so the result behaves exactly like any other physical Infinity portal from then on.
+ */
+public final class RainbowPortalIgniter {
+    private static final int SEARCH_RADIUS = 2;
+
+    private RainbowPortalIgniter() {
+    }
+
+    public static boolean tryIgnite(ServerLevel level, AABB deathBounds, ResourceLocation dimensionId) {
+        PermanentPortalShape shape = findInactiveShape(level, deathBounds);
+        if (shape == null) {
+            return false;
+        }
+
+        shape.fill(level);
+        BlockPos anyInteriorPos = firstInteriorPos(shape);
+        if (anyInteriorPos == null) {
+            return false;
+        }
+
+        boolean created = InfinityCompat.get().createPhysicalPortal(level, anyInteriorPos, dimensionId);
+        if (!created) {
+            return false;
+        }
+
+        Vec3 center = shape.center();
+        level.playSound(null, center.x, center.y, center.z, SoundEvents.END_PORTAL_SPAWN, SoundSource.BLOCKS, 0.9F, 0.9F);
+        return true;
+    }
+
+    @Nullable
+    private static PermanentPortalShape findInactiveShape(ServerLevel level, AABB bounds) {
+        int minX = (int) Math.floor(bounds.minX + 0.001D) - SEARCH_RADIUS;
+        int minY = (int) Math.floor(bounds.minY + 0.001D) - SEARCH_RADIUS;
+        int minZ = (int) Math.floor(bounds.minZ + 0.001D) - SEARCH_RADIUS;
+        int maxX = (int) Math.floor(bounds.maxX - 0.001D) + SEARCH_RADIUS;
+        int maxY = (int) Math.floor(bounds.maxY - 0.001D) + SEARCH_RADIUS;
+        int maxZ = (int) Math.floor(bounds.maxZ - 0.001D) + SEARCH_RADIUS;
+
+        for (int x = minX; x <= maxX; x++) {
+            for (int y = minY; y <= maxY; y++) {
+                for (int z = minZ; z <= maxZ; z++) {
+                    BlockPos candidate = new BlockPos(x, y, z);
+                    PermanentPortalShape xShape = PermanentPortalShape.findInactive(
+                            level, candidate, AntarchyTags.Blocks.RAINBOW_PORTAL_FRAMES, Blocks.NETHER_PORTAL, Direction.Axis.X);
+                    if (xShape != null && xShape.intersects(bounds)) {
+                        return xShape;
+                    }
+                    PermanentPortalShape zShape = PermanentPortalShape.findInactive(
+                            level, candidate, AntarchyTags.Blocks.RAINBOW_PORTAL_FRAMES, Blocks.NETHER_PORTAL, Direction.Axis.Z);
+                    if (zShape != null && zShape.intersects(bounds)) {
+                        return zShape;
+                    }
+                }
+            }
+        }
+
+        return null;
+    }
+
+    @Nullable
+    private static BlockPos firstInteriorPos(PermanentPortalShape shape) {
+        BlockPos[] holder = new BlockPos[1];
+        shape.forEachInterior(pos -> {
+            if (holder[0] == null) {
+                holder[0] = pos;
+            }
+        });
+        return holder[0];
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/worldgen/elythia/ElythiaCloudFeature.java

@@ -0,0 +1,114 @@
+package com.craisinlord.antarchy.content.worldgen.elythia;
+
+import com.craisinlord.antarchy.content.AntarchyObjects;
+import com.mojang.serialization.Codec;
+import net.minecraft.core.BlockPos;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.WorldGenLevel;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.levelgen.feature.Feature;
+import net.minecraft.world.level.levelgen.feature.FeaturePlaceContext;
+import net.minecraft.world.level.levelgen.feature.configurations.NoneFeatureConfiguration;
+
+/**
+ * Scatters solid puffs of {@link AntarchyObjects#CLOUD_BLOCK} sized and shaped
+ * anywhere from thin wispy veils to large, dense masses, with a softly feathered edge.
+ */
+public final class ElythiaCloudFeature extends Feature<NoneFeatureConfiguration> {
+    public ElythiaCloudFeature(Codec<NoneFeatureConfiguration> codec) {
+        super(codec);
+    }
+
+    private enum CloudSize {
+        WISPY,
+        SMALL,
+        LARGE
+    }
+
+    @Override
+    public boolean place(FeaturePlaceContext<NoneFeatureConfiguration> context) {
+        WorldGenLevel level = context.level();
+        BlockPos origin = context.origin();
+        RandomSource random = context.random();
+
+        CloudSize size = pickSize(random);
+        int banks = switch (size) {
+            case WISPY -> 1 + random.nextInt(2);
+            case SMALL -> 1;
+            case LARGE -> 3 + random.nextInt(3);
+        };
+        int spread = switch (size) {
+            case WISPY -> 20;
+            case SMALL -> 10;
+            case LARGE -> 28;
+        };
+
+        boolean placedAny = false;
+        for (int i = 0; i < banks; i++) {
+            BlockPos center = origin.offset(
+                    random.nextInt(spread * 2 + 1) - spread,
+                    random.nextInt(9) - 4,
+                    random.nextInt(spread * 2 + 1) - spread);
+            int[] radii = rollRadii(size, random);
+            placedAny |= placeBank(level, center, radii[0], radii[1], radii[2], size, random);
+        }
+
+        return placedAny;
+    }
+
+    private static CloudSize pickSize(RandomSource random) {
+        float roll = random.nextFloat();
+        if (roll < 0.40F) return CloudSize.WISPY;
+        if (roll < 0.75F) return CloudSize.SMALL;
+        return CloudSize.LARGE;
+    }
+
+    private static int[] rollRadii(CloudSize size, RandomSource random) {
+        return switch (size) {
+            case WISPY -> new int[]{5 + random.nextInt(5), 1, 5 + random.nextInt(5)};
+            case SMALL -> new int[]{2 + random.nextInt(2), 1 + random.nextInt(2), 2 + random.nextInt(2)};
+            case LARGE -> new int[]{6 + random.nextInt(6), 3 + random.nextInt(4), 6 + random.nextInt(6)};
+        };
+    }
+
+    private boolean placeBank(WorldGenLevel level, BlockPos center, int radiusX, int radiusY, int radiusZ, CloudSize size, RandomSource random) {
+        int xRange = Math.max(1, radiusX);
+        int yRange = Math.max(1, radiusY);
+        int zRange = Math.max(1, radiusZ);
+        BlockState cloud = AntarchyObjects.CLOUD_BLOCK.get().defaultBlockState();
+        // Clouds are solid puffs, not hollow shells — only the outer rind is feathered for a
+        // soft, ragged edge. Wispy clouds get a lower edge-fill chance so they read as thin
+        // and sparse without turning the whole body into visible holes.
+        float edgeFillChance = size == CloudSize.WISPY ? 0.55F : 0.85F;
+        double edgeStart = 0.7D;
+
+        boolean placedAny = false;
+        for (int x = -xRange; x <= xRange; x++) {
+            for (int y = -yRange; y <= yRange; y++) {
+                for (int z = -zRange; z <= zRange; z++) {
+                    double normalized = (x * x) / (double) (xRange * xRange)
+                            + (y * y) / (double) (yRange * yRange)
+                            + (z * z) / (double) (zRange * zRange);
+                    if (normalized > 1.0D + random.nextDouble() * 0.1D) {
+                        continue;
+                    }
+
+                    if (normalized > edgeStart && random.nextFloat() > edgeFillChance) {
+                        continue;
+                    }
+
+                    BlockPos target = center.offset(x, y, z);
+                    BlockState current = level.getBlockState(target);
+                    if (!current.isAir() && !current.canBeReplaced()) {
+                        continue;
+                    }
+
+                    level.setBlock(target, cloud, 2);
+                    placedAny = true;
+                }
+            }
+        }
+
+        return placedAny;
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/worldgen/thoraxis/DimensionalTearFeature.java

@@ -0,0 +1,112 @@
+package com.craisinlord.antarchy.content.worldgen.thoraxis;
+
+import com.craisinlord.antarchy.config.AntarchySettings;
+import com.craisinlord.antarchy.content.entity.portal.DimensionalTearEntity;
+import com.mojang.serialization.Codec;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.WorldGenRegion;
+import net.minecraft.util.Mth;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.ServerLevelAccessor;
+import net.minecraft.world.level.WorldGenLevel;
+import net.minecraft.world.level.levelgen.feature.Feature;
+import net.minecraft.world.level.levelgen.feature.FeaturePlaceContext;
+import net.minecraft.world.level.levelgen.feature.configurations.NoneFeatureConfiguration;
+import net.minecraft.world.phys.Vec3;
+import org.jetbrains.annotations.Nullable;
+
+public final class DimensionalTearFeature extends Feature<NoneFeatureConfiguration> {
+    private static final int MIN_LINK_RANGE = 50;
+    private static final int MAX_LINK_RANGE = 500;
+    private static final int LOCAL_SEARCH_ATTEMPTS = 18;
+    private static final int PARTNER_ORIGIN_ATTEMPTS = 12;
+    private static final int PARTNER_SEARCH_ATTEMPTS = 48;
+
+    public DimensionalTearFeature(Codec<NoneFeatureConfiguration> codec) {
+        super(codec);
+    }
+
+    @Override
+    public boolean place(FeaturePlaceContext<NoneFeatureConfiguration> context) {
+        WorldGenLevel level = context.level();
+        if (!(level instanceof ServerLevelAccessor serverLevelAccessor)) {
+            return false;
+        }
+
+        RandomSource random = context.random();
+        BlockPos first = findOpenPocket(level, context.origin(), random, LOCAL_SEARCH_ATTEMPTS);
+        if (first == null) {
+            return false;
+        }
+
+        BlockPos second = null;
+        for (int i = 0; i < PARTNER_ORIGIN_ATTEMPTS && second == null; i++) {
+            second = findOpenPocket(level, linkedOrigin(first, random), random, PARTNER_SEARCH_ATTEMPTS);
+        }
+        if (second == null) {
+            return false;
+        }
+
+        ServerLevel serverLevel = serverLevelAccessor.getLevel();
+        int lifetime = Math.max(1200, AntarchySettings.dimensionalTearLifetimeTicks());
+        float yawA = random.nextFloat() * 360.0F;
+        float yawB = Mth.wrapDegrees(yawA + 140.0F + random.nextFloat() * 80.0F);
+        DimensionalTearEntity tearA = DimensionalTearEntity.create(serverLevel, center(first), yawA, lifetime);
+        DimensionalTearEntity tearB = DimensionalTearEntity.create(serverLevel, center(second), yawB, lifetime);
+        tearA.linkTo(tearB);
+        tearB.linkTo(tearA);
+        serverLevel.addFreshEntity(tearA);
+        serverLevel.addFreshEntity(tearB);
+        return true;
+    }
+
+    private static BlockPos linkedOrigin(BlockPos first, RandomSource random) {
+        double angle = random.nextDouble() * Math.PI * 2.0D;
+        int distance = Mth.nextInt(random, MIN_LINK_RANGE, MAX_LINK_RANGE);
+        int dx = Mth.floor(Math.cos(angle) * distance);
+        int dz = Mth.floor(Math.sin(angle) * distance);
+        int dy = Mth.nextInt(random, -36, 36);
+        return first.offset(dx, dy, dz);
+    }
+
+    @Nullable
+    private static BlockPos findOpenPocket(WorldGenLevel level, BlockPos origin, RandomSource random, int attempts) {
+        int minY = level.getMinBuildHeight() + 8;
+        int maxY = level.getMaxBuildHeight() - 8;
+        for (int i = 0; i < attempts; i++) {
+            BlockPos candidate = origin.offset(
+                    Mth.nextInt(random, -16, 16),
+                    Mth.nextInt(random, -24, 24),
+                    Mth.nextInt(random, -16, 16)
+            );
+            candidate = new BlockPos(candidate.getX(), Mth.clamp(candidate.getY(), minY, maxY), candidate.getZ());
+            if (isUsablePocket(level, candidate)) {
+                return candidate;
+            }
+        }
+        return null;
+    }
+
+    private static boolean isUsablePocket(WorldGenLevel level, BlockPos pos) {
+        for (int dx = -2; dx <= 2; dx++) {
+            for (int dy = -2; dy <= 3; dy++) {
+                for (int dz = -4; dz <= 4; dz++) {
+                    BlockPos checkPos = pos.offset(dx, dy, dz);
+                    if (!canAccess(level, checkPos) || !level.getBlockState(checkPos).getCollisionShape(level, checkPos).isEmpty()) {
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+
+    private static boolean canAccess(WorldGenLevel level, BlockPos pos) {
+        return !(level instanceof WorldGenRegion region) || region.ensureCanWrite(pos);
+    }
+
+    private static Vec3 center(BlockPos pos) {
+        return new Vec3(pos.getX() + 0.5D, pos.getY() + 0.5D, pos.getZ() + 0.5D);
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/worldgen/thoraxis/ThoraxisBiomeSource.java

@@ -39,6 +39,10 @@ public final class ThoraxisBiomeSource extends BiomeSource {
             Registries.BIOME,
             ResourceLocation.fromNamespaceAndPath(Antarchy.MODID, "lucid_pools")
     );
+    private static final ResourceKey<Biome> UNDERSIDE = ResourceKey.create(
+            Registries.BIOME,
+            ResourceLocation.fromNamespaceAndPath(Antarchy.MODID, "thoraxis_underside")
+    );
 
     public static final MapCodec<ThoraxisBiomeSource> CODEC = RecordCodecBuilder.mapCodec(instance -> instance.group(
             MultiNoiseBiomeSource.DIRECT_CODEC.forGetter(ThoraxisBiomeSource::parameters),
@@ -60,6 +64,7 @@ public final class ThoraxisBiomeSource extends BiomeSource {
     private Holder<Biome> dreamDunesBiome;
     private Holder<Biome> umbralHillsBiome;
     private Holder<Biome> lucidPoolsBiome;
+    private Holder<Biome> undersideBiome;
 
     private static final ThreadLocal<Long2DoubleOpenHashMap> REGION_CACHE =
             ThreadLocal.withInitial(() -> new Long2DoubleOpenHashMap(512));
@@ -89,6 +94,7 @@ public final class ThoraxisBiomeSource extends BiomeSource {
             this.dreamDunesBiome = this.findBiome(DREAM_DUNES);
             this.umbralHillsBiome = this.findBiome(UMBRAL_HILLS);
             this.lucidPoolsBiome = this.findBiome(LUCID_POOLS);
+            this.undersideBiome = this.findBiome(UNDERSIDE);
             this.biomesResolved = true;
         }
     }
@@ -122,6 +128,10 @@ public final class ThoraxisBiomeSource extends BiomeSource {
     @Override
     public Holder<Biome> getNoiseBiome(int x, int y, int z, Climate.Sampler sampler) {
         this.resolveBiomesIfNeeded();
+        if (y < 0 && this.undersideBiome != null) {
+            return this.undersideBiome;
+        }
+
         if (y >= this.lucidPoolsMinQuartY && this.lucidPoolsBiome != null) {
             return this.lucidPoolsBiome;
         }

common-1.21.1/src/main/java/com/craisinlord/antarchy/content/worldgen/thoraxis/ThoraxisUndersideManager.java

@@ -0,0 +1,74 @@
+package com.craisinlord.antarchy.content.worldgen.thoraxis;
+
+import com.craisinlord.antarchy.Antarchy;
+import com.craisinlord.antarchy.content.AntarchyObjects;
+import com.craisinlord.antarchy.content.gravity.AntarchyGravityApi;
+import com.craisinlord.antarchy.content.gravity.AntarchyGravityDirection;
+import com.craisinlord.antarchy.content.gravity.AntarchyGravityTransition;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.LivingEntity;
+
+public final class ThoraxisUndersideManager {
+    public static final int GRAVITY_FLIP_Y = 0;
+    private static final ResourceLocation THORAXIS_DIMENSION = ResourceLocation.fromNamespaceAndPath(Antarchy.MODID, "thoraxis");
+    private static final AntarchyGravityTransition TRANSITION = new AntarchyGravityTransition(12);
+    private static final Set<UUID> UNDERSIDE_FORCED_GRAVITY = new HashSet<>();
+
+    private ThoraxisUndersideManager() {
+    }
+
+    public static void tick(ServerLevel level) {
+        if (!isThoraxis(level)) {
+            return;
+        }
+
+        Set<UUID> activeThisTick = new HashSet<>();
+        for (Entity entity : level.getAllEntities()) {
+            if (!entity.isAlive() || entity.isSpectator()) {
+                continue;
+            }
+
+            UUID uuid = entity.getUUID();
+            if (entity.getY() < GRAVITY_FLIP_Y) {
+                activeThisTick.add(uuid);
+                UNDERSIDE_FORCED_GRAVITY.add(uuid);
+                if (AntarchyGravityApi.getGravityDirection(entity) != AntarchyGravityDirection.UP
+                        || !AntarchyGravityApi.isGravityForced(entity)) {
+                    AntarchyGravityApi.setForcedGravityDirection(entity, AntarchyGravityDirection.UP, TRANSITION);
+                }
+                continue;
+            }
+
+            if (!UNDERSIDE_FORCED_GRAVITY.remove(uuid)) {
+                continue;
+            }
+
+            if (shouldReleaseGravity(entity)) {
+                AntarchyGravityApi.setGravityDirection(entity, AntarchyGravityDirection.DOWN, false, TRANSITION);
+            }
+        }
+
+        UNDERSIDE_FORCED_GRAVITY.retainAll(activeThisTick);
+    }
+
+    private static boolean shouldReleaseGravity(Entity entity) {
+        if (AntarchyGravityApi.getGravityDirection(entity) != AntarchyGravityDirection.UP) {
+            return false;
+        }
+
+        if (entity instanceof LivingEntity living && living.hasEffect(AntarchyObjects.INVERTED_EFFECT.get())) {
+            return false;
+        }
+
+        return AntarchyGravityApi.isGravityForced(entity);
+    }
+
+    public static boolean isThoraxis(ServerLevel level) {
+        return level.dimension().location().equals(THORAXIS_DIMENSION);
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/mixins/GlimmeringDamageImmunityMixin.java

@@ -0,0 +1,33 @@
+package com.craisinlord.antarchy.mixins;
+
+import com.craisinlord.antarchy.content.AntarchyObjects;
+import net.minecraft.core.Holder;
+import net.minecraft.tags.DamageTypeTags;
+import net.minecraft.world.damagesource.DamageSource;
+import net.minecraft.world.effect.MobEffect;
+import net.minecraft.world.entity.LivingEntity;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(LivingEntity.class)
+public abstract class GlimmeringDamageImmunityMixin {
+    // Magic damage (potions, spells) is tagged bypasses_armor, so it's excluded
+    @Inject(method = "hurt", at = @At("HEAD"), cancellable = true)
+    private void antarchy$glimmeringIgnoresAttacks(DamageSource source, float amount, CallbackInfoReturnable<Boolean> cir) {
+        LivingEntity self = (LivingEntity) (Object) this;
+        if (self.level().isClientSide()) {
+            return;
+        }
+
+        if (source.getEntity() == null || source.is(DamageTypeTags.BYPASSES_ARMOR)) {
+            return;
+        }
+
+        Holder<MobEffect> glimmering = AntarchyObjects.GLIMMERING_EFFECT.get();
+        if (glimmering != null && self.hasEffect(glimmering)) {
+            cir.setReturnValue(false);
+        }
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/mixins/GlimmeringPushEntitiesMixin.java

@@ -0,0 +1,22 @@
+package com.craisinlord.antarchy.mixins;
+
+import com.craisinlord.antarchy.content.AntarchyObjects;
+import net.minecraft.core.Holder;
+import net.minecraft.world.effect.MobEffect;
+import net.minecraft.world.entity.LivingEntity;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(LivingEntity.class)
+public abstract class GlimmeringPushEntitiesMixin {
+    @Inject(method = "pushEntities", at = @At("HEAD"), cancellable = true)
+    private void antarchy$glimmeringSkipsPushingOthers(CallbackInfo ci) {
+        LivingEntity self = (LivingEntity) (Object) this;
+        Holder<MobEffect> glimmering = AntarchyObjects.GLIMMERING_EFFECT.get();
+        if (glimmering != null && self.hasEffect(glimmering)) {
+            ci.cancel();
+        }
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/mixins/GlimmeringPushableMixin.java

@@ -0,0 +1,44 @@
+package com.craisinlord.antarchy.mixins;
+
+import com.craisinlord.antarchy.content.AntarchyObjects;
+import net.minecraft.core.Holder;
+import net.minecraft.world.effect.MobEffect;
+import net.minecraft.world.entity.LivingEntity;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+// LivingEntity.isPushable()/isPickable() are full overrides of Entity's versions (they don't call
+// super), so this has to target LivingEntity directly, not Entity, or the injected code never runs.
+@Mixin(LivingEntity.class)
+public abstract class GlimmeringPushableMixin {
+    @Inject(method = "isPushable", at = @At("RETURN"), cancellable = true)
+    private void antarchy$glimmeringNotPushable(CallbackInfoReturnable<Boolean> cir) {
+        if (!cir.getReturnValueZ()) {
+            return;
+        }
+
+        LivingEntity self = (LivingEntity) (Object) this;
+        Holder<MobEffect> glimmering = AntarchyObjects.GLIMMERING_EFFECT.get();
+        if (glimmering != null && self.hasEffect(glimmering)) {
+            cir.setReturnValue(false);
+        }
+    }
+
+    // Projectiles (and entity-picking in general) skip targets that aren't isPickable(), so this
+    // is what actually lets arrows/tridents/etc. pass through a glimmering entity instead of
+    // colliding with it; the damage-immunity mixin alone only stopped the damage, not the impact.
+    @Inject(method = "isPickable", at = @At("RETURN"), cancellable = true)
+    private void antarchy$glimmeringNotPickable(CallbackInfoReturnable<Boolean> cir) {
+        if (!cir.getReturnValueZ()) {
+            return;
+        }
+
+        LivingEntity self = (LivingEntity) (Object) this;
+        Holder<MobEffect> glimmering = AntarchyObjects.GLIMMERING_EFFECT.get();
+        if (glimmering != null && self.hasEffect(glimmering)) {
+            cir.setReturnValue(false);
+        }
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/mixins/NightmareArmorEffectImmunityMixin.java

@@ -0,0 +1,23 @@
+package com.craisinlord.antarchy.mixins;
+
+import com.craisinlord.antarchy.content.AntarchyObjects;
+import com.craisinlord.antarchy.content.item.NightmareArmorItem;
+import net.minecraft.world.effect.MobEffectInstance;
+import net.minecraft.world.effect.MobEffects;
+import net.minecraft.world.entity.LivingEntity;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(LivingEntity.class)
+public abstract class NightmareArmorEffectImmunityMixin {
+    @Inject(method = "canBeAffected", at = @At("HEAD"), cancellable = true)
+    private void antarchy$blockNightmareArmorEffects(MobEffectInstance effectInstance, CallbackInfoReturnable<Boolean> cir) {
+        LivingEntity livingEntity = (LivingEntity) (Object) this;
+        if (NightmareArmorItem.isWearingFullSet(livingEntity)
+                && (effectInstance.is(MobEffects.WITHER) || effectInstance.is(AntarchyObjects.DREAD.get()))) {
+            cir.setReturnValue(false);
+        }
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/mixins/client/ElythiaSkyMixin.java

@@ -1,6 +1,7 @@
 package com.craisinlord.antarchy.mixins.client;
 
 import com.craisinlord.antarchy.content.client.renderer.ElythiaSkyRenderer;
+import com.craisinlord.antarchy.content.client.renderer.ThoraxisUndersideSkyRenderer;
 import com.mojang.blaze3d.vertex.PoseStack;
 import com.mojang.blaze3d.vertex.VertexBuffer;
 import net.minecraft.client.Camera;
@@ -38,6 +39,23 @@ public abstract class ElythiaSkyMixin {
 
     @Inject(method = "renderSky", at = @At("HEAD"), cancellable = true)
     private void antarchy$renderElythiaSky(Matrix4f modelViewMatrix, Matrix4f projectionMatrix, float partialTick, Camera camera, boolean isFoggy, Runnable setupFog, CallbackInfo ci) {
+        if (this.level != null && ThoraxisUndersideSkyRenderer.shouldRender(this.level, camera)) {
+            PoseStack poseStack = new PoseStack();
+            poseStack.mulPose(modelViewMatrix);
+            ThoraxisUndersideSkyRenderer.render(
+                    this.minecraft,
+                    poseStack,
+                    projectionMatrix,
+                    partialTick,
+                    camera,
+                    isFoggy,
+                    setupFog,
+                    this.skyBuffer
+            );
+            ci.cancel();
+            return;
+        }
+
         if (this.level == null || !ElythiaSkyRenderer.shouldRender(this.level)) {
             return;
         }

common-1.21.1/src/main/java/com/craisinlord/antarchy/mixins/client/GlimmeringTranslucencyMixin.java

@@ -0,0 +1,73 @@
+package com.craisinlord.antarchy.mixins.client;
+
+import com.craisinlord.antarchy.content.AntarchyObjects;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.client.renderer.entity.LivingEntityRenderer;
+import net.minecraft.core.Holder;
+import net.minecraft.world.effect.MobEffect;
+import net.minecraft.world.entity.LivingEntity;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.ModifyArg;
+import org.spongepowered.asm.mixin.injection.Redirect;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(LivingEntityRenderer.class)
+public abstract class GlimmeringTranslucencyMixin<T extends LivingEntity> {
+    // Vertex-color alpha applied to the base skin render while glimmering, on top of the recolor
+    // overlay, so the body itself reads as see-through rather than just tinted.
+    private static final int GLIMMERING_ALPHA = 0x40;
+
+    @Unique
+    private boolean antarchy$glimmeringActive;
+
+    @Inject(
+            method = "render(Lnet/minecraft/world/entity/LivingEntity;FFLcom/mojang/blaze3d/vertex/PoseStack;Lnet/minecraft/client/renderer/MultiBufferSource;I)V",
+            at = @At("HEAD")
+    )
+    private void antarchy$captureGlimmering(LivingEntity entity, float limbSwing, float partialTick,
+                                             com.mojang.blaze3d.vertex.PoseStack poseStack,
+                                             net.minecraft.client.renderer.MultiBufferSource buffer,
+                                             int packedLight, CallbackInfo ci) {
+        Holder<MobEffect> glimmering = AntarchyObjects.GLIMMERING_EFFECT.get();
+        this.antarchy$glimmeringActive = glimmering != null && entity.hasEffect(glimmering);
+    }
+
+    @Redirect(
+            method = "render(Lnet/minecraft/world/entity/LivingEntity;FFLcom/mojang/blaze3d/vertex/PoseStack;Lnet/minecraft/client/renderer/MultiBufferSource;I)V",
+            at = @At(
+                    value = "INVOKE",
+                    target = "Lnet/minecraft/client/renderer/entity/LivingEntityRenderer;getRenderType(Lnet/minecraft/world/entity/LivingEntity;ZZZ)Lnet/minecraft/client/renderer/RenderType;"
+            )
+    )
+    private RenderType antarchy$forceTranslucentRenderType(LivingEntityRenderer<T, ?> self, LivingEntity entity,
+                                                             boolean bodyVisible, boolean translucent, boolean glowingEffect) {
+        if (this.antarchy$glimmeringActive) {
+            var texture = Minecraft.getInstance().getEntityRenderDispatcher().getRenderer(entity).getTextureLocation(entity);
+            return RenderType.entityTranslucent(texture);
+        }
+        return this.getRenderType((T) entity, bodyVisible, translucent, glowingEffect);
+    }
+
+    @Shadow
+    protected abstract RenderType getRenderType(T entity, boolean bodyVisible, boolean translucent, boolean glowingEffect);
+
+    @ModifyArg(
+            method = "render(Lnet/minecraft/world/entity/LivingEntity;FFLcom/mojang/blaze3d/vertex/PoseStack;Lnet/minecraft/client/renderer/MultiBufferSource;I)V",
+            at = @At(
+                    value = "INVOKE",
+                    target = "Lnet/minecraft/client/model/EntityModel;renderToBuffer(Lcom/mojang/blaze3d/vertex/PoseStack;Lcom/mojang/blaze3d/vertex/VertexConsumer;III)V"
+            ),
+            index = 4
+    )
+    private int antarchy$applyGlimmeringAlpha(int color) {
+        if (!this.antarchy$glimmeringActive) {
+            return color;
+        }
+        return (color & 0x00FFFFFF) | (GLIMMERING_ALPHA << 24);
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/mixins/client/TigerEyeArmorHideMixin.java

@@ -0,0 +1,35 @@
+package com.craisinlord.antarchy.mixins.client;
+
+import com.craisinlord.antarchy.content.client.TigerEyeCamouflageClientState;
+import com.craisinlord.antarchy.content.item.TigerEyeArmorUtil;
+import com.mojang.blaze3d.vertex.PoseStack;
+import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.client.renderer.entity.layers.HumanoidArmorLayer;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(HumanoidArmorLayer.class)
+public abstract class TigerEyeArmorHideMixin {
+    @Inject(
+            method = "render(Lcom/mojang/blaze3d/vertex/PoseStack;Lnet/minecraft/client/renderer/MultiBufferSource;ILnet/minecraft/world/entity/LivingEntity;FFFFFF)V",
+            at = @At("HEAD"),
+            cancellable = true
+    )
+    private void antarchy$hideArmorWhileCamouflaged(PoseStack poseStack, MultiBufferSource buffer, int packedLight,
+                                                      LivingEntity entity, float limbSwing, float limbSwingAmount,
+                                                      float partialTick, float ageInTicks, float netHeadYaw,
+                                                      float headPitch, CallbackInfo ci) {
+        if (!(entity instanceof Player player) || !TigerEyeArmorUtil.hasFullSet(player)) {
+            return;
+        }
+
+        TigerEyeCamouflageClientState.CamouflageState state = TigerEyeCamouflageClientState.get(player.getId());
+        if (state != null && state.active()) {
+            ci.cancel();
+        }
+    }
+}

common-1.21.1/src/main/java/com/craisinlord/antarchy/mixins/client/TigerEyeNameTagHideMixin.java

@@ -0,0 +1,30 @@
+package com.craisinlord.antarchy.mixins.client;
+
+import com.craisinlord.antarchy.content.client.TigerEyeCamouflageClientState;
+import com.craisinlord.antarchy.content.item.TigerEyeArmorUtil;
+import net.minecraft.client.renderer.entity.LivingEntityRenderer;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(LivingEntityRenderer.class)
+public abstract class TigerEyeNameTagHideMixin {
+    @Inject(
+            method = "shouldShowName(Lnet/minecraft/world/entity/LivingEntity;)Z",
+            at = @At("HEAD"),
+            cancellable = true
+    )
+    private void antarchy$hideNameWhileCamouflaged(LivingEntity entity, CallbackInfoReturnable<Boolean> cir) {
+        if (!(entity instanceof Player player) || !TigerEyeArmorUtil.hasFullSet(player)) {
+            return;
+        }
+
+        TigerEyeCamouflageClientState.CamouflageState state = TigerEyeCamouflageClientState.get(player.getId());
+        if (state != null && state.active()) {
+            cir.setReturnValue(false);
+        }
+    }
+}

common-1.21.1/src/main/resources/assets/antarchy/animations/caterpillar.animation.json

@@ -848,7 +848,7 @@
 				}
 			}
 		},
-		"Coocon": {
+		"cocoon": {
 			"loop": "hold_on_last_frame",
 			"animation_length": 2,
 			"bones": {
@@ -1350,7 +1350,7 @@
 				}
 			}
 		},
-		"coocon": {
+		"cocoon_chrysalis": {
 			"loop": true,
 			"animation_length": 2.5,
 			"bones": {

common-1.21.1/src/main/resources/assets/antarchy/animations/lucid_bolt.animation.json

@@ -0,0 +1,222 @@
+{
+	"format_version": "1.8.0",
+	"animations": {
+		"idle": {
+			"loop": true,
+			"animation_length": 0.5,
+			"bones": {
+				"projectile": {
+					"rotation": {
+						"vector": [0, 0, 0]
+					},
+					"scale": {
+						"0.0": {
+							"post": {
+								"vector": [1, 1, 1]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.125": {
+							"post": {
+								"vector": [1, 1, 1.2]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.25": {
+							"post": {
+								"vector": [1, 1, 1]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.375": {
+							"post": {
+								"vector": [1, 1, 1.2]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.5": {
+							"post": {
+								"vector": [1, 1, 1]
+							},
+							"lerp_mode": "catmullrom"
+						}
+					}
+				},
+				"particle_right": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.2917": {
+							"vector": [0, 0, 5]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 0.7, 1]
+						},
+						"0.2917": {
+							"vector": [1, 0, 1]
+						}
+					}
+				},
+				"particle_right2": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.125": {
+							"vector": [0, 0, 4]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 0.7, 1]
+						},
+						"0.125": {
+							"vector": [1, 0, 1]
+						}
+					}
+				},
+				"particle_right3": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.5": {
+							"vector": [0, 0, 8]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 0.7, 1]
+						},
+						"0.25": {
+							"vector": [1, 0, 1]
+						}
+					}
+				},
+				"particle_right4": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.125": {
+							"vector": [0, 0, 4]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 0.7, 1]
+						},
+						"0.125": {
+							"vector": [1, 0, 1]
+						}
+					}
+				},
+				"particle_left4": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.125": {
+							"vector": [0, 0, 4]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 0.7, 1]
+						},
+						"0.125": {
+							"vector": [1, 0, 1]
+						}
+					}
+				},
+				"particle_left2": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.125": {
+							"vector": [0, 0, 4]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 0.7, 1]
+						},
+						"0.125": {
+							"vector": [1, 0, 1]
+						}
+					}
+				},
+				"particle_left": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.2917": {
+							"vector": [0, 0, 5]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 0.7, 1]
+						},
+						"0.2917": {
+							"vector": [1, 0, 1]
+						}
+					}
+				},
+				"particle_left3": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.5": {
+							"vector": [0, 0, 8]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 0.7, 1]
+						},
+						"0.25": {
+							"vector": [1, 0, 1]
+						}
+					}
+				},
+				"ring": {
+					"rotation": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.5": {
+							"vector": [0, 0, 360]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"post": {
+								"vector": [1, 1, 1]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.25": {
+							"post": {
+								"vector": [0.8, 0.8, 1]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.5": {
+							"post": {
+								"vector": [1, 1, 1]
+							},
+							"lerp_mode": "catmullrom"
+						}
+					}
+				}
+			}
+		}
+	}
+}

common-1.21.1/src/main/resources/assets/antarchy/animations/lucid_bolt_impact.animation.json

@@ -0,0 +1,700 @@
+{
+	"format_version": "1.8.0",
+	"animations": {
+		"animation": {
+			"animation_length": 1.5,
+			"bones": {
+				"eye": {
+					"rotation": {
+						"0.25": {
+							"pre": {
+								"vector": [72.5, 0, 0]
+							},
+							"post": {
+								"vector": [72.5, 0, 0]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.5": {
+							"post": {
+								"vector": [-15, 0, 0]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.625": {
+							"post": {
+								"vector": [0, 0, 0]
+							},
+							"lerp_mode": "catmullrom"
+						}
+					},
+					"position": {
+						"0.25": {
+							"pre": {
+								"vector": [0, -10, 0]
+							},
+							"post": {
+								"vector": [0, -10, 0]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.5": {
+							"post": {
+								"vector": [0, 0, 0]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.625": {
+							"vector": [0, 0, 0]
+						},
+						"0.6667": {
+							"vector": [1, 0, 0]
+						},
+						"0.7083": {
+							"vector": [0, 0, 0]
+						},
+						"0.75": {
+							"vector": [1, 0, 0]
+						},
+						"0.7917": {
+							"vector": [0, 0, 0]
+						},
+						"0.8333": {
+							"vector": [1, 0, 0]
+						},
+						"0.875": {
+							"vector": [0, 0, 0]
+						},
+						"0.9167": {
+							"vector": [1, 0, 0]
+						},
+						"0.9583": {
+							"vector": [0, 0, 0]
+						},
+						"1.0": {
+							"vector": [1, 0, 0]
+						},
+						"1.0417": {
+							"vector": [0, 0, 0]
+						},
+						"1.0833": {
+							"vector": [1, 0, 0]
+						},
+						"1.125": {
+							"vector": [0, 0, 0]
+						},
+						"1.1667": {
+							"vector": [1, 0, 0]
+						},
+						"1.2083": {
+							"vector": [0, 0, 0]
+						},
+						"1.25": {
+							"vector": [1, 0, 0]
+						},
+						"1.2917": {
+							"vector": [0, 0, 0]
+						},
+						"1.3333": {
+							"vector": [1, 0, 0]
+						},
+						"1.375": {
+							"vector": [0, 0, 0]
+						}
+					},
+					"scale": {
+						"0.25": {
+							"pre": {
+								"vector": [0, 0, 0]
+							},
+							"post": {
+								"vector": [0, 0, 0]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.625": {
+							"vector": [1, 1, 1]
+						},
+						"1.375": {
+							"vector": [1, 1, 1]
+						},
+						"1.5": {
+							"vector": [0, 0, 0]
+						}
+					}
+				},
+				"Iris": {
+					"scale": {
+						"0.25": {
+							"vector": [1, 1, 1]
+						},
+						"0.6667": {
+							"vector": [1, 1, 1]
+						},
+						"0.7917": {
+							"vector": [0.3, 0.3, 1]
+						},
+						"1.2917": {
+							"vector": [0.3, 0.3, 1]
+						},
+						"1.375": {
+							"vector": [1, 1, 1]
+						}
+					}
+				},
+				"particle": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.3333": {
+							"vector": [0, 15, 0]
+						},
+						"0.5": {
+							"vector": [0, 25, 0]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"post": {
+								"vector": [0, 0, 0]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.1667": {
+							"post": {
+								"vector": [1, 0.8, 1]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.625": {
+							"post": {
+								"vector": [0, 0, 0]
+							},
+							"lerp_mode": "catmullrom"
+						}
+					}
+				},
+				"particle2": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.3333": {
+							"vector": [0, 25, 0]
+						},
+						"0.4583": {
+							"vector": [0, 35, 0]
+						},
+						"0.5833": {
+							"vector": [0, 44, 0]
+						}
+					},
+					"scale": {
+						"0.125": {
+							"pre": {
+								"vector": [0, 0, 0]
+							},
+							"post": {
+								"vector": [0, 0, 0]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.2917": {
+							"post": {
+								"vector": [1, 0.8, 1]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.625": {
+							"post": {
+								"vector": [0, 0, 0]
+							},
+							"lerp_mode": "catmullrom"
+						}
+					}
+				},
+				"particle3": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.3333": {
+							"vector": [0, 33, 0]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"post": {
+								"vector": [0.2, 0.2, 1]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.1667": {
+							"post": {
+								"vector": [1, 0.8, 1]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.4583": {
+							"post": {
+								"vector": [0, 0, 0]
+							},
+							"lerp_mode": "catmullrom"
+						}
+					}
+				},
+				"particle4": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.3333": {
+							"vector": [0, 25, 0]
+						},
+						"0.4583": {
+							"vector": [0, 35, 0]
+						},
+						"0.5833": {
+							"vector": [0, 44, 0]
+						}
+					},
+					"scale": {
+						"0.125": {
+							"pre": {
+								"vector": [0, 0, 0]
+							},
+							"post": {
+								"vector": [0, 0, 0]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.2917": {
+							"post": {
+								"vector": [1, 0.8, 1]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.625": {
+							"post": {
+								"vector": [0, 0, 0]
+							},
+							"lerp_mode": "catmullrom"
+						}
+					}
+				},
+				"particle5": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.3333": {
+							"vector": [0, 33, 0]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"post": {
+								"vector": [0.2, 0.2, 1]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.1667": {
+							"post": {
+								"vector": [1, 0.8, 1]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.4583": {
+							"post": {
+								"vector": [0, 0, 0]
+							},
+							"lerp_mode": "catmullrom"
+						}
+					}
+				},
+				"particle6": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.3333": {
+							"vector": [0, 25, 0]
+						},
+						"0.4583": {
+							"vector": [0, 35, 0]
+						},
+						"0.5833": {
+							"vector": [0, 44, 0]
+						}
+					},
+					"scale": {
+						"0.125": {
+							"pre": {
+								"vector": [0, 0, 0]
+							},
+							"post": {
+								"vector": [0, 0, 0]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.2917": {
+							"post": {
+								"vector": [1, 0.8, 1]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.625": {
+							"post": {
+								"vector": [0, 0, 0]
+							},
+							"lerp_mode": "catmullrom"
+						}
+					}
+				},
+				"impact_particle": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.1667": {
+							"vector": [-14, -5, -24]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 1, 1]
+						},
+						"0.1667": {
+							"vector": [0, 0, 0]
+						}
+					}
+				},
+				"impact_particle2": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.1667": {
+							"vector": [19, 0, -30]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 1, 1]
+						},
+						"0.1667": {
+							"vector": [0, 0, 0]
+						}
+					}
+				},
+				"impact_particle3": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.1667": {
+							"vector": [-14, -5, -36]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 1, 1]
+						},
+						"0.1667": {
+							"vector": [0, 0, 0]
+						}
+					}
+				},
+				"impact_particle4": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.1667": {
+							"vector": [-14, -5, -25]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 1, 1]
+						},
+						"0.1667": {
+							"vector": [0, 0, 0]
+						}
+					}
+				},
+				"impact_particle5": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.1667": {
+							"vector": [19, 0, -38]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 1, 1]
+						},
+						"0.1667": {
+							"vector": [0, 0, 0]
+						}
+					}
+				},
+				"impact_particle6": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.1667": {
+							"vector": [19, 0, -20]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 1, 1]
+						},
+						"0.1667": {
+							"vector": [0, 0, 0]
+						}
+					}
+				},
+				"impact_particle7": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.1667": {
+							"vector": [-14, -5, -32]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 1, 1]
+						},
+						"0.1667": {
+							"vector": [0, 0, 0]
+						}
+					}
+				},
+				"impact_particle8": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.1667": {
+							"vector": [-14, -5, -24]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 1, 1]
+						},
+						"0.1667": {
+							"vector": [0, 0, 0]
+						}
+					}
+				},
+				"impact_particle9": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.1667": {
+							"vector": [-14, -5, -36]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 1, 1]
+						},
+						"0.1667": {
+							"vector": [0, 0, 0]
+						}
+					}
+				},
+				"impact_particle10": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.1667": {
+							"vector": [-14, -5, -25]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 1, 1]
+						},
+						"0.1667": {
+							"vector": [0, 0, 0]
+						}
+					}
+				},
+				"impact_particle11": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.1667": {
+							"vector": [19, 0, -30]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 1, 1]
+						},
+						"0.1667": {
+							"vector": [0, 0, 0]
+						}
+					}
+				},
+				"impact_particle12": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.1667": {
+							"vector": [19, 0, -38]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 1, 1]
+						},
+						"0.1667": {
+							"vector": [0, 0, 0]
+						}
+					}
+				},
+				"impact_particle13": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.1667": {
+							"vector": [19, 0, -20]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 1, 1]
+						},
+						"0.1667": {
+							"vector": [0, 0, 0]
+						}
+					}
+				},
+				"impact_particle20": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.1667": {
+							"vector": [-14, -5, -24]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 1, 1]
+						},
+						"0.1667": {
+							"vector": [0, 0, 0]
+						}
+					}
+				},
+				"impact_particle21": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.1667": {
+							"vector": [-14, -5, -36]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 1, 1]
+						},
+						"0.1667": {
+							"vector": [0, 0, 0]
+						}
+					}
+				},
+				"impact_particle22": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.1667": {
+							"vector": [-14, -5, -25]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 1, 1]
+						},
+						"0.1667": {
+							"vector": [0, 0, 0]
+						}
+					}
+				},
+				"impact_particle23": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.1667": {
+							"vector": [19, 0, -30]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 1, 1]
+						},
+						"0.1667": {
+							"vector": [0, 0, 0]
+						}
+					}
+				},
+				"impact_particle24": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.1667": {
+							"vector": [19, 0, -38]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 1, 1]
+						},
+						"0.1667": {
+							"vector": [0, 0, 0]
+						}
+					}
+				},
+				"impact_particle25": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.1667": {
+							"vector": [19, 0, -20]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 1, 1]
+						},
+						"0.1667": {
+							"vector": [0, 0, 0]
+						}
+					}
+				}
+			}
+		}
+	}
+}

common-1.21.1/src/main/resources/assets/antarchy/animations/nightmare_bite.animation.json

@@ -0,0 +1,308 @@
+{
+	"format_version": "1.8.0",
+	"animations": {
+		"bite": {
+			"animation_length": 1.5,
+			"bones": {
+				"upper_jaw": {
+					"position": {
+						"0.0": {
+							"post": {
+								"vector": [0, 0, 0]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.375": {
+							"post": {
+								"vector": [0, 6, 0]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.5": {
+							"post": {
+								"vector": [0, -7, 0]
+							},
+							"lerp_mode": "catmullrom"
+						}
+					}
+				},
+				"lower_jaw": {
+					"position": {
+						"0.0": {
+							"post": {
+								"vector": [0, 0, 0]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.375": {
+							"post": {
+								"vector": [0, -6, 0]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.5": {
+							"post": {
+								"vector": [0, 7, 0]
+							},
+							"lerp_mode": "catmullrom"
+						}
+					}
+				},
+				"Bite": {
+					"rotation": {
+						"0.0": {
+							"post": {
+								"vector": [0, 0, 0]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.1667": {
+							"post": {
+								"vector": [-5, 0, 0]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.375": {
+							"post": {
+								"vector": [-5, 0, 0]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.5": {
+							"post": {
+								"vector": [0, 0, 0]
+							},
+							"lerp_mode": "catmullrom"
+						}
+					},
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.4583": {
+							"vector": [0, 0, 0]
+						},
+						"0.5": {
+							"vector": [0, -12, 0]
+						},
+						"0.5417": {
+							"vector": [0, 0, 0]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [1, 1, 1]
+						},
+						"1.25": {
+							"pre": {
+								"vector": [1, 1, 1]
+							},
+							"post": {
+								"vector": [1, 1, 1]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"1.5": {
+							"post": {
+								"vector": [1, 0, 1]
+							},
+							"lerp_mode": "catmullrom"
+						}
+					}
+				},
+				"impact": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.5": {
+							"vector": [0, -2, 6]
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.4583": {
+							"vector": [0, 0, 0]
+						},
+						"0.5": {
+							"vector": [0.4, 1, 1]
+						},
+						"0.75": {
+							"pre": {
+								"vector": [3.4, 1, 1]
+							},
+							"post": {
+								"vector": [3.4, 1, 1]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"1.25": {
+							"post": {
+								"vector": [2.2667, 0, 1]
+							},
+							"lerp_mode": "catmullrom"
+						}
+					}
+				},
+				"particles_left": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"1.0": {
+							"pre": {
+								"vector": [14.14214, 14.14214, 0]
+							},
+							"post": {
+								"vector": [14.14214, 14.14214, 0]
+							},
+							"lerp_mode": "catmullrom"
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.5": {
+							"vector": [0, 0, 0]
+						},
+						"0.5417": {
+							"pre": {
+								"vector": [1, 1, 1]
+							},
+							"post": {
+								"vector": [1, 1, 1]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"1.0": {
+							"post": {
+								"vector": [1, 0, 1]
+							},
+							"lerp_mode": "catmullrom"
+						}
+					}
+				},
+				"particles_right": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"1.0": {
+							"pre": {
+								"vector": [-14.14214, 14.14214, 0]
+							},
+							"post": {
+								"vector": [-14.14214, 14.14214, 0]
+							},
+							"lerp_mode": "catmullrom"
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.5": {
+							"vector": [0, 0, 0]
+						},
+						"0.5417": {
+							"pre": {
+								"vector": [1, 1, 1]
+							},
+							"post": {
+								"vector": [1, 1, 1]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"1.0": {
+							"post": {
+								"vector": [1, 0, 1]
+							},
+							"lerp_mode": "catmullrom"
+						}
+					}
+				},
+				"particles_left_bottom": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"1.0": {
+							"pre": {
+								"vector": [14.02043, -14.01429, -2.65088]
+							},
+							"post": {
+								"vector": [14.02043, -14.01429, -2.65088]
+							},
+							"lerp_mode": "catmullrom"
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.5": {
+							"vector": [0, 0, 0]
+						},
+						"0.5417": {
+							"pre": {
+								"vector": [1, 1, 1]
+							},
+							"post": {
+								"vector": [1, 1, 1]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"1.0": {
+							"post": {
+								"vector": [1, 0, 0.8]
+							},
+							"lerp_mode": "catmullrom"
+						}
+					}
+				},
+				"particles_right_bottom": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"1.0": {
+							"pre": {
+								"vector": [-14.02043, -14.01429, -2.65088]
+							},
+							"post": {
+								"vector": [-14.02043, -14.01429, -2.65088]
+							},
+							"lerp_mode": "catmullrom"
+						}
+					},
+					"scale": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.5": {
+							"vector": [0, 0, 0]
+						},
+						"0.5417": {
+							"pre": {
+								"vector": [1, 1, 1]
+							},
+							"post": {
+								"vector": [1, 1, 1]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"1.0": {
+							"post": {
+								"vector": [1, 0, 0.8]
+							},
+							"lerp_mode": "catmullrom"
+						}
+					}
+				}
+			}
+		}
+	}
+}

common-1.21.1/src/main/resources/assets/antarchy/animations/water_bomb.animation.json

@@ -0,0 +1,82 @@
+{
+	"format_version": "1.8.0",
+	"animations": {
+		"idle": {
+			"loop": true,
+			"animation_length": 0.8333,
+			"bones": {
+				"Water_projectile": {
+					"scale": {
+						"0.0": {
+							"post": {
+								"vector": [1, 1, 1]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.2083": {
+							"post": {
+								"vector": [1, 0.6, 0.9]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.4167": {
+							"post": {
+								"vector": [1, 1, 1]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.625": {
+							"post": {
+								"vector": [1, 0.6, 0.9]
+							},
+							"lerp_mode": "catmullrom"
+						},
+						"0.8333": {
+							"post": {
+								"vector": [1, 1, 1]
+							},
+							"lerp_mode": "catmullrom"
+						}
+					}
+				},
+				"water_ring": {
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.0833": {
+							"vector": [0, 0, 13]
+						},
+						"0.1667": {
+							"vector": [0, 0, 0]
+						},
+						"0.25": {
+							"vector": [0, 0, 13]
+						},
+						"0.3333": {
+							"vector": [0, 0, 0]
+						},
+						"0.4167": {
+							"vector": [0, 0, 13]
+						},
+						"0.5": {
+							"vector": [0, 0, 0]
+						},
+						"0.5833": {
+							"vector": [0, 0, 13]
+						},
+						"0.6667": {
+							"vector": [0, 0, 0]
+						},
+						"0.75": {
+							"vector": [0, 0, 13]
+						},
+						"0.8333": {
+							"vector": [0, 0, 0]
+						}
+					}
+				}
+			}
+		}
+	}
+}

common-1.21.1/src/main/resources/assets/antarchy/blockstates/antigravel.json

@@ -0,0 +1,7 @@
+{
+  "variants": {
+    "": {
+      "model": "antarchy:block/antigravel"
+    }
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/blockstates/antimetal_slab.json

@@ -0,0 +1,13 @@
+{
+  "variants": {
+    "type=double": {
+      "model": "antarchy:block/antimetal"
+    },
+    "type=bottom": {
+      "model": "antarchy:block/antimetal_slab"
+    },
+    "type=top": {
+      "model": "antarchy:block/antimetal_slab_top"
+    }
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/blockstates/antimetal_stairs.json

@@ -0,0 +1,209 @@
+{
+  "variants": {
+    "facing=east,half=bottom,shape=inner_left": {
+      "model": "antarchy:block/antimetal_stairs_inner",
+      "uvlock": true,
+      "y": 270
+    },
+    "facing=east,half=bottom,shape=inner_right": {
+      "model": "antarchy:block/antimetal_stairs_inner"
+    },
+    "facing=east,half=bottom,shape=outer_left": {
+      "model": "antarchy:block/antimetal_stairs_outer",
+      "uvlock": true,
+      "y": 270
+    },
+    "facing=east,half=bottom,shape=outer_right": {
+      "model": "antarchy:block/antimetal_stairs_outer"
+    },
+    "facing=east,half=bottom,shape=straight": {
+      "model": "antarchy:block/antimetal_stairs"
+    },
+    "facing=east,half=top,shape=inner_left": {
+      "model": "antarchy:block/antimetal_stairs_inner",
+      "uvlock": true,
+      "x": 180
+    },
+    "facing=east,half=top,shape=inner_right": {
+      "model": "antarchy:block/antimetal_stairs_inner",
+      "uvlock": true,
+      "x": 180,
+      "y": 90
+    },
+    "facing=east,half=top,shape=outer_left": {
+      "model": "antarchy:block/antimetal_stairs_outer",
+      "uvlock": true,
+      "x": 180
+    },
+    "facing=east,half=top,shape=outer_right": {
+      "model": "antarchy:block/antimetal_stairs_outer",
+      "uvlock": true,
+      "x": 180,
+      "y": 90
+    },
+    "facing=east,half=top,shape=straight": {
+      "model": "antarchy:block/antimetal_stairs",
+      "uvlock": true,
+      "x": 180
+    },
+    "facing=north,half=bottom,shape=inner_left": {
+      "model": "antarchy:block/antimetal_stairs_inner",
+      "uvlock": true,
+      "y": 180
+    },
+    "facing=north,half=bottom,shape=inner_right": {
+      "model": "antarchy:block/antimetal_stairs_inner",
+      "uvlock": true,
+      "y": 270
+    },
+    "facing=north,half=bottom,shape=outer_left": {
+      "model": "antarchy:block/antimetal_stairs_outer",
+      "uvlock": true,
+      "y": 180
+    },
+    "facing=north,half=bottom,shape=outer_right": {
+      "model": "antarchy:block/antimetal_stairs_outer",
+      "uvlock": true,
+      "y": 270
+    },
+    "facing=north,half=bottom,shape=straight": {
+      "model": "antarchy:block/antimetal_stairs",
+      "uvlock": true,
+      "y": 270
+    },
+    "facing=north,half=top,shape=inner_left": {
+      "model": "antarchy:block/antimetal_stairs_inner",
+      "uvlock": true,
+      "x": 180,
+      "y": 270
+    },
+    "facing=north,half=top,shape=inner_right": {
+      "model": "antarchy:block/antimetal_stairs_inner",
+      "uvlock": true,
+      "x": 180
+    },
+    "facing=north,half=top,shape=outer_left": {
+      "model": "antarchy:block/antimetal_stairs_outer",
+      "uvlock": true,
+      "x": 180,
+      "y": 270
+    },
+    "facing=north,half=top,shape=outer_right": {
+      "model": "antarchy:block/antimetal_stairs_outer",
+      "uvlock": true,
+      "x": 180
+    },
+    "facing=north,half=top,shape=straight": {
+      "model": "antarchy:block/antimetal_stairs",
+      "uvlock": true,
+      "x": 180,
+      "y": 270
+    },
+    "facing=south,half=bottom,shape=inner_left": {
+      "model": "antarchy:block/antimetal_stairs_inner"
+    },
+    "facing=south,half=bottom,shape=inner_right": {
+      "model": "antarchy:block/antimetal_stairs_inner",
+      "uvlock": true,
+      "y": 90
+    },
+    "facing=south,half=bottom,shape=outer_left": {
+      "model": "antarchy:block/antimetal_stairs_outer"
+    },
+    "facing=south,half=bottom,shape=outer_right": {
+      "model": "antarchy:block/antimetal_stairs_outer",
+      "uvlock": true,
+      "y": 90
+    },
+    "facing=south,half=bottom,shape=straight": {
+      "model": "antarchy:block/antimetal_stairs",
+      "uvlock": true,
+      "y": 90
+    },
+    "facing=south,half=top,shape=inner_left": {
+      "model": "antarchy:block/antimetal_stairs_inner",
+      "uvlock": true,
+      "x": 180,
+      "y": 90
+    },
+    "facing=south,half=top,shape=inner_right": {
+      "model": "antarchy:block/antimetal_stairs_inner",
+      "uvlock": true,
+      "x": 180,
+      "y": 180
+    },
+    "facing=south,half=top,shape=outer_left": {
+      "model": "antarchy:block/antimetal_stairs_outer",
+      "uvlock": true,
+      "x": 180,
+      "y": 90
+    },
+    "facing=south,half=top,shape=outer_right": {
+      "model": "antarchy:block/antimetal_stairs_outer",
+      "uvlock": true,
+      "x": 180,
+      "y": 180
+    },
+    "facing=south,half=top,shape=straight": {
+      "model": "antarchy:block/antimetal_stairs",
+      "uvlock": true,
+      "x": 180,
+      "y": 90
+    },
+    "facing=west,half=bottom,shape=inner_left": {
+      "model": "antarchy:block/antimetal_stairs_inner",
+      "uvlock": true,
+      "y": 90
+    },
+    "facing=west,half=bottom,shape=inner_right": {
+      "model": "antarchy:block/antimetal_stairs_inner",
+      "uvlock": true,
+      "y": 180
+    },
+    "facing=west,half=bottom,shape=outer_left": {
+      "model": "antarchy:block/antimetal_stairs_outer",
+      "uvlock": true,
+      "y": 90
+    },
+    "facing=west,half=bottom,shape=outer_right": {
+      "model": "antarchy:block/antimetal_stairs_outer",
+      "uvlock": true,
+      "y": 180
+    },
+    "facing=west,half=bottom,shape=straight": {
+      "model": "antarchy:block/antimetal_stairs",
+      "uvlock": true,
+      "y": 180
+    },
+    "facing=west,half=top,shape=inner_left": {
+      "model": "antarchy:block/antimetal_stairs_inner",
+      "uvlock": true,
+      "x": 180,
+      "y": 180
+    },
+    "facing=west,half=top,shape=inner_right": {
+      "model": "antarchy:block/antimetal_stairs_inner",
+      "uvlock": true,
+      "x": 180,
+      "y": 270
+    },
+    "facing=west,half=top,shape=outer_left": {
+      "model": "antarchy:block/antimetal_stairs_outer",
+      "uvlock": true,
+      "x": 180,
+      "y": 180
+    },
+    "facing=west,half=top,shape=outer_right": {
+      "model": "antarchy:block/antimetal_stairs_outer",
+      "uvlock": true,
+      "x": 180,
+      "y": 270
+    },
+    "facing=west,half=top,shape=straight": {
+      "model": "antarchy:block/antimetal_stairs",
+      "uvlock": true,
+      "x": 180,
+      "y": 180
+    }
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/blockstates/bluestone_lamp.json

@@ -0,0 +1,10 @@
+{
+  "variants": {
+    "lit=false": {
+      "model": "antarchy:block/bluestone_lamp"
+    },
+    "lit=true": {
+      "model": "antarchy:block/bluestone_lamp_on"
+    }
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/blockstates/broodstone_pillar.json

@@ -0,0 +1,16 @@
+{
+  "variants": {
+    "axis=x": {
+      "model": "antarchy:block/broodstone_pillar",
+      "x": 90,
+      "y": 90
+    },
+    "axis=y": {
+      "model": "antarchy:block/broodstone_pillar"
+    },
+    "axis=z": {
+      "model": "antarchy:block/broodstone_pillar",
+      "x": 90
+    }
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/blockstates/loam.json

@@ -0,0 +1,7 @@
+{
+  "variants": {
+    "": {
+      "model": "antarchy:block/loam"
+    }
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/blockstates/mucus.json

@@ -0,0 +1,150 @@
+{
+  "multipart": [
+    {
+      "apply": {
+        "model": "antarchy:block/mucus"
+      },
+      "when": {
+        "north": "true"
+      }
+    },
+    {
+      "apply": {
+        "model": "antarchy:block/mucus"
+      },
+      "when": {
+        "down": "false",
+        "east": "false",
+        "north": "false",
+        "south": "false",
+        "up": "false",
+        "west": "false"
+      }
+    },
+    {
+      "apply": {
+        "model": "antarchy:block/mucus",
+        "uvlock": true,
+        "y": 90
+      },
+      "when": {
+        "east": "true"
+      }
+    },
+    {
+      "apply": {
+        "model": "antarchy:block/mucus",
+        "uvlock": true,
+        "y": 90
+      },
+      "when": {
+        "down": "false",
+        "east": "false",
+        "north": "false",
+        "south": "false",
+        "up": "false",
+        "west": "false"
+      }
+    },
+    {
+      "apply": {
+        "model": "antarchy:block/mucus",
+        "uvlock": true,
+        "y": 180
+      },
+      "when": {
+        "south": "true"
+      }
+    },
+    {
+      "apply": {
+        "model": "antarchy:block/mucus",
+        "uvlock": true,
+        "y": 180
+      },
+      "when": {
+        "down": "false",
+        "east": "false",
+        "north": "false",
+        "south": "false",
+        "up": "false",
+        "west": "false"
+      }
+    },
+    {
+      "apply": {
+        "model": "antarchy:block/mucus",
+        "uvlock": true,
+        "y": 270
+      },
+      "when": {
+        "west": "true"
+      }
+    },
+    {
+      "apply": {
+        "model": "antarchy:block/mucus",
+        "uvlock": true,
+        "y": 270
+      },
+      "when": {
+        "down": "false",
+        "east": "false",
+        "north": "false",
+        "south": "false",
+        "up": "false",
+        "west": "false"
+      }
+    },
+    {
+      "apply": {
+        "model": "antarchy:block/mucus",
+        "uvlock": true,
+        "x": 270
+      },
+      "when": {
+        "up": "true"
+      }
+    },
+    {
+      "apply": {
+        "model": "antarchy:block/mucus",
+        "uvlock": true,
+        "x": 270
+      },
+      "when": {
+        "down": "false",
+        "east": "false",
+        "north": "false",
+        "south": "false",
+        "up": "false",
+        "west": "false"
+      }
+    },
+    {
+      "apply": {
+        "model": "antarchy:block/mucus",
+        "uvlock": true,
+        "x": 90
+      },
+      "when": {
+        "down": "true"
+      }
+    },
+    {
+      "apply": {
+        "model": "antarchy:block/mucus",
+        "uvlock": true,
+        "x": 90
+      },
+      "when": {
+        "down": "false",
+        "east": "false",
+        "north": "false",
+        "south": "false",
+        "up": "false",
+        "west": "false"
+      }
+    }
+  ]
+}

common-1.21.1/src/main/resources/assets/antarchy/blockstates/nadir_button.json

@@ -0,0 +1,119 @@
+{
+  "variants": {
+    "face=ceiling,facing=east,powered=false": {
+      "model": "antarchy:block/nadir_button",
+      "x": 180,
+      "y": 270
+    },
+    "face=ceiling,facing=east,powered=true": {
+      "model": "antarchy:block/nadir_button_pressed",
+      "x": 180,
+      "y": 270
+    },
+    "face=ceiling,facing=north,powered=false": {
+      "model": "antarchy:block/nadir_button",
+      "x": 180,
+      "y": 180
+    },
+    "face=ceiling,facing=north,powered=true": {
+      "model": "antarchy:block/nadir_button_pressed",
+      "x": 180,
+      "y": 180
+    },
+    "face=ceiling,facing=south,powered=false": {
+      "model": "antarchy:block/nadir_button",
+      "x": 180
+    },
+    "face=ceiling,facing=south,powered=true": {
+      "model": "antarchy:block/nadir_button_pressed",
+      "x": 180
+    },
+    "face=ceiling,facing=west,powered=false": {
+      "model": "antarchy:block/nadir_button",
+      "x": 180,
+      "y": 90
+    },
+    "face=ceiling,facing=west,powered=true": {
+      "model": "antarchy:block/nadir_button_pressed",
+      "x": 180,
+      "y": 90
+    },
+    "face=floor,facing=east,powered=false": {
+      "model": "antarchy:block/nadir_button",
+      "y": 90
+    },
+    "face=floor,facing=east,powered=true": {
+      "model": "antarchy:block/nadir_button_pressed",
+      "y": 90
+    },
+    "face=floor,facing=north,powered=false": {
+      "model": "antarchy:block/nadir_button"
+    },
+    "face=floor,facing=north,powered=true": {
+      "model": "antarchy:block/nadir_button_pressed"
+    },
+    "face=floor,facing=south,powered=false": {
+      "model": "antarchy:block/nadir_button",
+      "y": 180
+    },
+    "face=floor,facing=south,powered=true": {
+      "model": "antarchy:block/nadir_button_pressed",
+      "y": 180
+    },
+    "face=floor,facing=west,powered=false": {
+      "model": "antarchy:block/nadir_button",
+      "y": 270
+    },
+    "face=floor,facing=west,powered=true": {
+      "model": "antarchy:block/nadir_button_pressed",
+      "y": 270
+    },
+    "face=wall,facing=east,powered=false": {
+      "model": "antarchy:block/nadir_button",
+      "uvlock": true,
+      "x": 90,
+      "y": 90
+    },
+    "face=wall,facing=east,powered=true": {
+      "model": "antarchy:block/nadir_button_pressed",
+      "uvlock": true,
+      "x": 90,
+      "y": 90
+    },
+    "face=wall,facing=north,powered=false": {
+      "model": "antarchy:block/nadir_button",
+      "uvlock": true,
+      "x": 90
+    },
+    "face=wall,facing=north,powered=true": {
+      "model": "antarchy:block/nadir_button_pressed",
+      "uvlock": true,
+      "x": 90
+    },
+    "face=wall,facing=south,powered=false": {
+      "model": "antarchy:block/nadir_button",
+      "uvlock": true,
+      "x": 90,
+      "y": 180
+    },
+    "face=wall,facing=south,powered=true": {
+      "model": "antarchy:block/nadir_button_pressed",
+      "uvlock": true,
+      "x": 90,
+      "y": 180
+    },
+    "face=wall,facing=west,powered=false": {
+      "model": "antarchy:block/nadir_button",
+      "uvlock": true,
+      "x": 90,
+      "y": 270
+    },
+    "face=wall,facing=west,powered=true": {
+      "model": "antarchy:block/nadir_button_pressed",
+      "uvlock": true,
+      "x": 90,
+      "y": 270
+    }
+  }
+}
+

common-1.21.1/src/main/resources/assets/antarchy/blockstates/nadir_door.json

@@ -0,0 +1,125 @@
+{
+  "variants": {
+    "facing=east,half=lower,hinge=left,open=false": {
+      "model": "antarchy:block/nadir_door_bottom_left"
+    },
+    "facing=east,half=lower,hinge=left,open=true": {
+      "model": "antarchy:block/nadir_door_bottom_left_open",
+      "y": 90
+    },
+    "facing=east,half=lower,hinge=right,open=false": {
+      "model": "antarchy:block/nadir_door_bottom_right"
+    },
+    "facing=east,half=lower,hinge=right,open=true": {
+      "model": "antarchy:block/nadir_door_bottom_right_open",
+      "y": 270
+    },
+    "facing=east,half=upper,hinge=left,open=false": {
+      "model": "antarchy:block/nadir_door_top_left"
+    },
+    "facing=east,half=upper,hinge=left,open=true": {
+      "model": "antarchy:block/nadir_door_top_left_open",
+      "y": 90
+    },
+    "facing=east,half=upper,hinge=right,open=false": {
+      "model": "antarchy:block/nadir_door_top_right"
+    },
+    "facing=east,half=upper,hinge=right,open=true": {
+      "model": "antarchy:block/nadir_door_top_right_open",
+      "y": 270
+    },
+    "facing=north,half=lower,hinge=left,open=false": {
+      "model": "antarchy:block/nadir_door_bottom_left",
+      "y": 270
+    },
+    "facing=north,half=lower,hinge=left,open=true": {
+      "model": "antarchy:block/nadir_door_bottom_left_open"
+    },
+    "facing=north,half=lower,hinge=right,open=false": {
+      "model": "antarchy:block/nadir_door_bottom_right",
+      "y": 270
+    },
+    "facing=north,half=lower,hinge=right,open=true": {
+      "model": "antarchy:block/nadir_door_bottom_right_open",
+      "y": 180
+    },
+    "facing=north,half=upper,hinge=left,open=false": {
+      "model": "antarchy:block/nadir_door_top_left",
+      "y": 270
+    },
+    "facing=north,half=upper,hinge=left,open=true": {
+      "model": "antarchy:block/nadir_door_top_left_open"
+    },
+    "facing=north,half=upper,hinge=right,open=false": {
+      "model": "antarchy:block/nadir_door_top_right",
+      "y": 270
+    },
+    "facing=north,half=upper,hinge=right,open=true": {
+      "model": "antarchy:block/nadir_door_top_right_open",
+      "y": 180
+    },
+    "facing=south,half=lower,hinge=left,open=false": {
+      "model": "antarchy:block/nadir_door_bottom_left",
+      "y": 90
+    },
+    "facing=south,half=lower,hinge=left,open=true": {
+      "model": "antarchy:block/nadir_door_bottom_left_open",
+      "y": 180
+    },
+    "facing=south,half=lower,hinge=right,open=false": {
+      "model": "antarchy:block/nadir_door_bottom_right",
+      "y": 90
+    },
+    "facing=south,half=lower,hinge=right,open=true": {
+      "model": "antarchy:block/nadir_door_bottom_right_open"
+    },
+    "facing=south,half=upper,hinge=left,open=false": {
+      "model": "antarchy:block/nadir_door_top_left",
+      "y": 90
+    },
+    "facing=south,half=upper,hinge=left,open=true": {
+      "model": "antarchy:block/nadir_door_top_left_open",
+      "y": 180
+    },
+    "facing=south,half=upper,hinge=right,open=false": {
+      "model": "antarchy:block/nadir_door_top_right",
+      "y": 90
+    },
+    "facing=south,half=upper,hinge=right,open=true": {
+      "model": "antarchy:block/nadir_door_top_right_open"
+    },
+    "facing=west,half=lower,hinge=left,open=false": {
+      "model": "antarchy:block/nadir_door_bottom_left",
+      "y": 180
+    },
+    "facing=west,half=lower,hinge=left,open=true": {
+      "model": "antarchy:block/nadir_door_bottom_left_open",
+      "y": 270
+    },
+    "facing=west,half=lower,hinge=right,open=false": {
+      "model": "antarchy:block/nadir_door_bottom_right",
+      "y": 180
+    },
+    "facing=west,half=lower,hinge=right,open=true": {
+      "model": "antarchy:block/nadir_door_bottom_right_open",
+      "y": 90
+    },
+    "facing=west,half=upper,hinge=left,open=false": {
+      "model": "antarchy:block/nadir_door_top_left",
+      "y": 180
+    },
+    "facing=west,half=upper,hinge=left,open=true": {
+      "model": "antarchy:block/nadir_door_top_left_open",
+      "y": 270
+    },
+    "facing=west,half=upper,hinge=right,open=false": {
+      "model": "antarchy:block/nadir_door_top_right",
+      "y": 180
+    },
+    "facing=west,half=upper,hinge=right,open=true": {
+      "model": "antarchy:block/nadir_door_top_right_open",
+      "y": 90
+    }
+  }
+}
+

common-1.21.1/src/main/resources/assets/antarchy/blockstates/nadir_fence.json

@@ -0,0 +1,49 @@
+{
+  "multipart": [
+    {
+      "apply": {
+        "model": "antarchy:block/nadir_fence_post"
+      }
+    },
+    {
+      "apply": {
+        "model": "antarchy:block/nadir_fence_side",
+        "uvlock": true
+      },
+      "when": {
+        "north": "true"
+      }
+    },
+    {
+      "apply": {
+        "model": "antarchy:block/nadir_fence_side",
+        "uvlock": true,
+        "y": 90
+      },
+      "when": {
+        "east": "true"
+      }
+    },
+    {
+      "apply": {
+        "model": "antarchy:block/nadir_fence_side",
+        "uvlock": true,
+        "y": 180
+      },
+      "when": {
+        "south": "true"
+      }
+    },
+    {
+      "apply": {
+        "model": "antarchy:block/nadir_fence_side",
+        "uvlock": true,
+        "y": 270
+      },
+      "when": {
+        "west": "true"
+      }
+    }
+  ]
+}
+

common-1.21.1/src/main/resources/assets/antarchy/blockstates/nadir_fence_gate.json

@@ -0,0 +1,81 @@
+{
+  "variants": {
+    "facing=east,in_wall=false,open=false": {
+      "model": "antarchy:block/nadir_fence_gate",
+      "uvlock": true,
+      "y": 270
+    },
+    "facing=east,in_wall=false,open=true": {
+      "model": "antarchy:block/nadir_fence_gate_open",
+      "uvlock": true,
+      "y": 270
+    },
+    "facing=east,in_wall=true,open=false": {
+      "model": "antarchy:block/nadir_fence_gate_wall",
+      "uvlock": true,
+      "y": 270
+    },
+    "facing=east,in_wall=true,open=true": {
+      "model": "antarchy:block/nadir_fence_gate_wall_open",
+      "uvlock": true,
+      "y": 270
+    },
+    "facing=north,in_wall=false,open=false": {
+      "model": "antarchy:block/nadir_fence_gate",
+      "uvlock": true,
+      "y": 180
+    },
+    "facing=north,in_wall=false,open=true": {
+      "model": "antarchy:block/nadir_fence_gate_open",
+      "uvlock": true,
+      "y": 180
+    },
+    "facing=north,in_wall=true,open=false": {
+      "model": "antarchy:block/nadir_fence_gate_wall",
+      "uvlock": true,
+      "y": 180
+    },
+    "facing=north,in_wall=true,open=true": {
+      "model": "antarchy:block/nadir_fence_gate_wall_open",
+      "uvlock": true,
+      "y": 180
+    },
+    "facing=south,in_wall=false,open=false": {
+      "model": "antarchy:block/nadir_fence_gate",
+      "uvlock": true
+    },
+    "facing=south,in_wall=false,open=true": {
+      "model": "antarchy:block/nadir_fence_gate_open",
+      "uvlock": true
+    },
+    "facing=south,in_wall=true,open=false": {
+      "model": "antarchy:block/nadir_fence_gate_wall",
+      "uvlock": true
+    },
+    "facing=south,in_wall=true,open=true": {
+      "model": "antarchy:block/nadir_fence_gate_wall_open",
+      "uvlock": true
+    },
+    "facing=west,in_wall=false,open=false": {
+      "model": "antarchy:block/nadir_fence_gate",
+      "uvlock": true,
+      "y": 90
+    },
+    "facing=west,in_wall=false,open=true": {
+      "model": "antarchy:block/nadir_fence_gate_open",
+      "uvlock": true,
+      "y": 90
+    },
+    "facing=west,in_wall=true,open=false": {
+      "model": "antarchy:block/nadir_fence_gate_wall",
+      "uvlock": true,
+      "y": 90
+    },
+    "facing=west,in_wall=true,open=true": {
+      "model": "antarchy:block/nadir_fence_gate_wall_open",
+      "uvlock": true,
+      "y": 90
+    }
+  }
+}
+

common-1.21.1/src/main/resources/assets/antarchy/blockstates/nadir_hanging_sign.json

@@ -0,0 +1,7 @@
+{
+  "variants": {
+    "": {
+      "model": "antarchy:block/nadir_hanging_sign"
+    }
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/blockstates/nadir_log.json

@@ -0,0 +1,17 @@
+{
+  "variants": {
+    "axis=x": {
+      "model": "antarchy:block/nadir_log_horizontal",
+      "x": 90,
+      "y": 90
+    },
+    "axis=y": {
+      "model": "antarchy:block/nadir_log"
+    },
+    "axis=z": {
+      "model": "antarchy:block/nadir_log_horizontal",
+      "x": 90
+    }
+  }
+}
+

common-1.21.1/src/main/resources/assets/antarchy/blockstates/nadir_planks.json

@@ -0,0 +1,8 @@
+{
+  "variants": {
+    "": {
+      "model": "antarchy:block/nadir_planks"
+    }
+  }
+}
+

common-1.21.1/src/main/resources/assets/antarchy/blockstates/nadir_pressure_plate.json

@@ -0,0 +1,11 @@
+{
+  "variants": {
+    "powered=false": {
+      "model": "antarchy:block/nadir_pressure_plate"
+    },
+    "powered=true": {
+      "model": "antarchy:block/nadir_pressure_plate_down"
+    }
+  }
+}
+

common-1.21.1/src/main/resources/assets/antarchy/blockstates/nadir_sapling.json

@@ -0,0 +1,7 @@
+{
+  "variants": {
+    "": {
+      "model": "antarchy:block/nadir_sapling"
+    }
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/blockstates/nadir_sign.json

@@ -0,0 +1,7 @@
+{
+  "variants": {
+    "": {
+      "model": "antarchy:block/nadir_sign"
+    }
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/blockstates/nadir_slab.json

@@ -0,0 +1,14 @@
+{
+  "variants": {
+    "type=bottom": {
+      "model": "antarchy:block/nadir_slab"
+    },
+    "type=double": {
+      "model": "antarchy:block/nadir_planks"
+    },
+    "type=top": {
+      "model": "antarchy:block/nadir_slab_top"
+    }
+  }
+}
+

common-1.21.1/src/main/resources/assets/antarchy/blockstates/nadir_stairs.json

@@ -0,0 +1,210 @@
+{
+  "variants": {
+    "facing=east,half=bottom,shape=inner_left": {
+      "model": "antarchy:block/nadir_stairs_inner",
+      "uvlock": true,
+      "y": 270
+    },
+    "facing=east,half=bottom,shape=inner_right": {
+      "model": "antarchy:block/nadir_stairs_inner"
+    },
+    "facing=east,half=bottom,shape=outer_left": {
+      "model": "antarchy:block/nadir_stairs_outer",
+      "uvlock": true,
+      "y": 270
+    },
+    "facing=east,half=bottom,shape=outer_right": {
+      "model": "antarchy:block/nadir_stairs_outer"
+    },
+    "facing=east,half=bottom,shape=straight": {
+      "model": "antarchy:block/nadir_stairs"
+    },
+    "facing=east,half=top,shape=inner_left": {
+      "model": "antarchy:block/nadir_stairs_inner",
+      "uvlock": true,
+      "x": 180
+    },
+    "facing=east,half=top,shape=inner_right": {
+      "model": "antarchy:block/nadir_stairs_inner",
+      "uvlock": true,
+      "x": 180,
+      "y": 90
+    },
+    "facing=east,half=top,shape=outer_left": {
+      "model": "antarchy:block/nadir_stairs_outer",
+      "uvlock": true,
+      "x": 180
+    },
+    "facing=east,half=top,shape=outer_right": {
+      "model": "antarchy:block/nadir_stairs_outer",
+      "uvlock": true,
+      "x": 180,
+      "y": 90
+    },
+    "facing=east,half=top,shape=straight": {
+      "model": "antarchy:block/nadir_stairs",
+      "uvlock": true,
+      "x": 180
+    },
+    "facing=north,half=bottom,shape=inner_left": {
+      "model": "antarchy:block/nadir_stairs_inner",
+      "uvlock": true,
+      "y": 180
+    },
+    "facing=north,half=bottom,shape=inner_right": {
+      "model": "antarchy:block/nadir_stairs_inner",
+      "uvlock": true,
+      "y": 270
+    },
+    "facing=north,half=bottom,shape=outer_left": {
+      "model": "antarchy:block/nadir_stairs_outer",
+      "uvlock": true,
+      "y": 180
+    },
+    "facing=north,half=bottom,shape=outer_right": {
+      "model": "antarchy:block/nadir_stairs_outer",
+      "uvlock": true,
+      "y": 270
+    },
+    "facing=north,half=bottom,shape=straight": {
+      "model": "antarchy:block/nadir_stairs",
+      "uvlock": true,
+      "y": 270
+    },
+    "facing=north,half=top,shape=inner_left": {
+      "model": "antarchy:block/nadir_stairs_inner",
+      "uvlock": true,
+      "x": 180,
+      "y": 270
+    },
+    "facing=north,half=top,shape=inner_right": {
+      "model": "antarchy:block/nadir_stairs_inner",
+      "uvlock": true,
+      "x": 180
+    },
+    "facing=north,half=top,shape=outer_left": {
+      "model": "antarchy:block/nadir_stairs_outer",
+      "uvlock": true,
+      "x": 180,
+      "y": 270
+    },
+    "facing=north,half=top,shape=outer_right": {
+      "model": "antarchy:block/nadir_stairs_outer",
+      "uvlock": true,
+      "x": 180
+    },
+    "facing=north,half=top,shape=straight": {
+      "model": "antarchy:block/nadir_stairs",
+      "uvlock": true,
+      "x": 180,
+      "y": 270
+    },
+    "facing=south,half=bottom,shape=inner_left": {
+      "model": "antarchy:block/nadir_stairs_inner"
+    },
+    "facing=south,half=bottom,shape=inner_right": {
+      "model": "antarchy:block/nadir_stairs_inner",
+      "uvlock": true,
+      "y": 90
+    },
+    "facing=south,half=bottom,shape=outer_left": {
+      "model": "antarchy:block/nadir_stairs_outer"
+    },
+    "facing=south,half=bottom,shape=outer_right": {
+      "model": "antarchy:block/nadir_stairs_outer",
+      "uvlock": true,
+      "y": 90
+    },
+    "facing=south,half=bottom,shape=straight": {
+      "model": "antarchy:block/nadir_stairs",
+      "uvlock": true,
+      "y": 90
+    },
+    "facing=south,half=top,shape=inner_left": {
+      "model": "antarchy:block/nadir_stairs_inner",
+      "uvlock": true,
+      "x": 180,
+      "y": 90
+    },
+    "facing=south,half=top,shape=inner_right": {
+      "model": "antarchy:block/nadir_stairs_inner",
+      "uvlock": true,
+      "x": 180,
+      "y": 180
+    },
+    "facing=south,half=top,shape=outer_left": {
+      "model": "antarchy:block/nadir_stairs_outer",
+      "uvlock": true,
+      "x": 180,
+      "y": 90
+    },
+    "facing=south,half=top,shape=outer_right": {
+      "model": "antarchy:block/nadir_stairs_outer",
+      "uvlock": true,
+      "x": 180,
+      "y": 180
+    },
+    "facing=south,half=top,shape=straight": {
+      "model": "antarchy:block/nadir_stairs",
+      "uvlock": true,
+      "x": 180,
+      "y": 90
+    },
+    "facing=west,half=bottom,shape=inner_left": {
+      "model": "antarchy:block/nadir_stairs_inner",
+      "uvlock": true,
+      "y": 90
+    },
+    "facing=west,half=bottom,shape=inner_right": {
+      "model": "antarchy:block/nadir_stairs_inner",
+      "uvlock": true,
+      "y": 180
+    },
+    "facing=west,half=bottom,shape=outer_left": {
+      "model": "antarchy:block/nadir_stairs_outer",
+      "uvlock": true,
+      "y": 90
+    },
+    "facing=west,half=bottom,shape=outer_right": {
+      "model": "antarchy:block/nadir_stairs_outer",
+      "uvlock": true,
+      "y": 180
+    },
+    "facing=west,half=bottom,shape=straight": {
+      "model": "antarchy:block/nadir_stairs",
+      "uvlock": true,
+      "y": 180
+    },
+    "facing=west,half=top,shape=inner_left": {
+      "model": "antarchy:block/nadir_stairs_inner",
+      "uvlock": true,
+      "x": 180,
+      "y": 180
+    },
+    "facing=west,half=top,shape=inner_right": {
+      "model": "antarchy:block/nadir_stairs_inner",
+      "uvlock": true,
+      "x": 180,
+      "y": 270
+    },
+    "facing=west,half=top,shape=outer_left": {
+      "model": "antarchy:block/nadir_stairs_outer",
+      "uvlock": true,
+      "x": 180,
+      "y": 180
+    },
+    "facing=west,half=top,shape=outer_right": {
+      "model": "antarchy:block/nadir_stairs_outer",
+      "uvlock": true,
+      "x": 180,
+      "y": 270
+    },
+    "facing=west,half=top,shape=straight": {
+      "model": "antarchy:block/nadir_stairs",
+      "uvlock": true,
+      "x": 180,
+      "y": 180
+    }
+  }
+}
+

common-1.21.1/src/main/resources/assets/antarchy/blockstates/nadir_trapdoor.json

@@ -0,0 +1,70 @@
+{
+  "variants": {
+    "facing=east,half=bottom,open=false": {
+      "model": "antarchy:block/nadir_trapdoor_bottom",
+      "y": 90
+    },
+    "facing=east,half=bottom,open=true": {
+      "model": "antarchy:block/nadir_trapdoor_open",
+      "y": 90
+    },
+    "facing=east,half=top,open=false": {
+      "model": "antarchy:block/nadir_trapdoor_top",
+      "y": 90
+    },
+    "facing=east,half=top,open=true": {
+      "model": "antarchy:block/nadir_trapdoor_open",
+      "x": 180,
+      "y": 270
+    },
+    "facing=north,half=bottom,open=false": {
+      "model": "antarchy:block/nadir_trapdoor_bottom"
+    },
+    "facing=north,half=bottom,open=true": {
+      "model": "antarchy:block/nadir_trapdoor_open"
+    },
+    "facing=north,half=top,open=false": {
+      "model": "antarchy:block/nadir_trapdoor_top"
+    },
+    "facing=north,half=top,open=true": {
+      "model": "antarchy:block/nadir_trapdoor_open",
+      "x": 180,
+      "y": 180
+    },
+    "facing=south,half=bottom,open=false": {
+      "model": "antarchy:block/nadir_trapdoor_bottom",
+      "y": 180
+    },
+    "facing=south,half=bottom,open=true": {
+      "model": "antarchy:block/nadir_trapdoor_open",
+      "y": 180
+    },
+    "facing=south,half=top,open=false": {
+      "model": "antarchy:block/nadir_trapdoor_top",
+      "y": 180
+    },
+    "facing=south,half=top,open=true": {
+      "model": "antarchy:block/nadir_trapdoor_open",
+      "x": 180,
+      "y": 0
+    },
+    "facing=west,half=bottom,open=false": {
+      "model": "antarchy:block/nadir_trapdoor_bottom",
+      "y": 270
+    },
+    "facing=west,half=bottom,open=true": {
+      "model": "antarchy:block/nadir_trapdoor_open",
+      "y": 270
+    },
+    "facing=west,half=top,open=false": {
+      "model": "antarchy:block/nadir_trapdoor_top",
+      "y": 270
+    },
+    "facing=west,half=top,open=true": {
+      "model": "antarchy:block/nadir_trapdoor_open",
+      "x": 180,
+      "y": 90
+    }
+  }
+}
+

common-1.21.1/src/main/resources/assets/antarchy/blockstates/nadir_veil.json

@@ -0,0 +1,6 @@
+{
+  "variants": {
+    "": { "model": "antarchy:block/nadir_veil" }
+  }
+}
+

common-1.21.1/src/main/resources/assets/antarchy/blockstates/nadir_wall_hanging_sign.json

@@ -0,0 +1,7 @@
+{
+  "variants": {
+    "": {
+      "model": "antarchy:block/nadir_wall_hanging_sign"
+    }
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/blockstates/nadir_wall_sign.json

@@ -0,0 +1,7 @@
+{
+  "variants": {
+    "": {
+      "model": "antarchy:block/nadir_wall_sign"
+    }
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/blockstates/nadir_wood.json

@@ -0,0 +1,17 @@
+{
+  "variants": {
+    "axis=x": {
+      "model": "antarchy:block/nadir_wood",
+      "x": 90,
+      "y": 90
+    },
+    "axis=y": {
+      "model": "antarchy:block/nadir_wood"
+    },
+    "axis=z": {
+      "model": "antarchy:block/nadir_wood",
+      "x": 90
+    }
+  }
+}
+

common-1.21.1/src/main/resources/assets/antarchy/blockstates/nyxite_pillar.json

@@ -0,0 +1,16 @@
+{
+  "variants": {
+    "axis=x": {
+      "model": "antarchy:block/nyxite_pillar",
+      "x": 90,
+      "y": 90
+    },
+    "axis=y": {
+      "model": "antarchy:block/nyxite_pillar"
+    },
+    "axis=z": {
+      "model": "antarchy:block/nyxite_pillar",
+      "x": 90
+    }
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/blockstates/polished_antimetal_slab.json

@@ -0,0 +1,13 @@
+{
+  "variants": {
+    "type=double": {
+      "model": "antarchy:block/polished_antimetal"
+    },
+    "type=bottom": {
+      "model": "antarchy:block/polished_antimetal_slab"
+    },
+    "type=top": {
+      "model": "antarchy:block/polished_antimetal_slab_top"
+    }
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/blockstates/polished_antimetal_stairs.json

@@ -0,0 +1,209 @@
+{
+  "variants": {
+    "facing=east,half=bottom,shape=inner_left": {
+      "model": "antarchy:block/polished_antimetal_stairs_inner",
+      "uvlock": true,
+      "y": 270
+    },
+    "facing=east,half=bottom,shape=inner_right": {
+      "model": "antarchy:block/polished_antimetal_stairs_inner"
+    },
+    "facing=east,half=bottom,shape=outer_left": {
+      "model": "antarchy:block/polished_antimetal_stairs_outer",
+      "uvlock": true,
+      "y": 270
+    },
+    "facing=east,half=bottom,shape=outer_right": {
+      "model": "antarchy:block/polished_antimetal_stairs_outer"
+    },
+    "facing=east,half=bottom,shape=straight": {
+      "model": "antarchy:block/polished_antimetal_stairs"
+    },
+    "facing=east,half=top,shape=inner_left": {
+      "model": "antarchy:block/polished_antimetal_stairs_inner",
+      "uvlock": true,
+      "x": 180
+    },
+    "facing=east,half=top,shape=inner_right": {
+      "model": "antarchy:block/polished_antimetal_stairs_inner",
+      "uvlock": true,
+      "x": 180,
+      "y": 90
+    },
+    "facing=east,half=top,shape=outer_left": {
+      "model": "antarchy:block/polished_antimetal_stairs_outer",
+      "uvlock": true,
+      "x": 180
+    },
+    "facing=east,half=top,shape=outer_right": {
+      "model": "antarchy:block/polished_antimetal_stairs_outer",
+      "uvlock": true,
+      "x": 180,
+      "y": 90
+    },
+    "facing=east,half=top,shape=straight": {
+      "model": "antarchy:block/polished_antimetal_stairs",
+      "uvlock": true,
+      "x": 180
+    },
+    "facing=north,half=bottom,shape=inner_left": {
+      "model": "antarchy:block/polished_antimetal_stairs_inner",
+      "uvlock": true,
+      "y": 180
+    },
+    "facing=north,half=bottom,shape=inner_right": {
+      "model": "antarchy:block/polished_antimetal_stairs_inner",
+      "uvlock": true,
+      "y": 270
+    },
+    "facing=north,half=bottom,shape=outer_left": {
+      "model": "antarchy:block/polished_antimetal_stairs_outer",
+      "uvlock": true,
+      "y": 180
+    },
+    "facing=north,half=bottom,shape=outer_right": {
+      "model": "antarchy:block/polished_antimetal_stairs_outer",
+      "uvlock": true,
+      "y": 270
+    },
+    "facing=north,half=bottom,shape=straight": {
+      "model": "antarchy:block/polished_antimetal_stairs",
+      "uvlock": true,
+      "y": 270
+    },
+    "facing=north,half=top,shape=inner_left": {
+      "model": "antarchy:block/polished_antimetal_stairs_inner",
+      "uvlock": true,
+      "x": 180,
+      "y": 270
+    },
+    "facing=north,half=top,shape=inner_right": {
+      "model": "antarchy:block/polished_antimetal_stairs_inner",
+      "uvlock": true,
+      "x": 180
+    },
+    "facing=north,half=top,shape=outer_left": {
+      "model": "antarchy:block/polished_antimetal_stairs_outer",
+      "uvlock": true,
+      "x": 180,
+      "y": 270
+    },
+    "facing=north,half=top,shape=outer_right": {
+      "model": "antarchy:block/polished_antimetal_stairs_outer",
+      "uvlock": true,
+      "x": 180
+    },
+    "facing=north,half=top,shape=straight": {
+      "model": "antarchy:block/polished_antimetal_stairs",
+      "uvlock": true,
+      "x": 180,
+      "y": 270
+    },
+    "facing=south,half=bottom,shape=inner_left": {
+      "model": "antarchy:block/polished_antimetal_stairs_inner"
+    },
+    "facing=south,half=bottom,shape=inner_right": {
+      "model": "antarchy:block/polished_antimetal_stairs_inner",
+      "uvlock": true,
+      "y": 90
+    },
+    "facing=south,half=bottom,shape=outer_left": {
+      "model": "antarchy:block/polished_antimetal_stairs_outer"
+    },
+    "facing=south,half=bottom,shape=outer_right": {
+      "model": "antarchy:block/polished_antimetal_stairs_outer",
+      "uvlock": true,
+      "y": 90
+    },
+    "facing=south,half=bottom,shape=straight": {
+      "model": "antarchy:block/polished_antimetal_stairs",
+      "uvlock": true,
+      "y": 90
+    },
+    "facing=south,half=top,shape=inner_left": {
+      "model": "antarchy:block/polished_antimetal_stairs_inner",
+      "uvlock": true,
+      "x": 180,
+      "y": 90
+    },
+    "facing=south,half=top,shape=inner_right": {
+      "model": "antarchy:block/polished_antimetal_stairs_inner",
+      "uvlock": true,
+      "x": 180,
+      "y": 180
+    },
+    "facing=south,half=top,shape=outer_left": {
+      "model": "antarchy:block/polished_antimetal_stairs_outer",
+      "uvlock": true,
+      "x": 180,
+      "y": 90
+    },
+    "facing=south,half=top,shape=outer_right": {
+      "model": "antarchy:block/polished_antimetal_stairs_outer",
+      "uvlock": true,
+      "x": 180,
+      "y": 180
+    },
+    "facing=south,half=top,shape=straight": {
+      "model": "antarchy:block/polished_antimetal_stairs",
+      "uvlock": true,
+      "x": 180,
+      "y": 90
+    },
+    "facing=west,half=bottom,shape=inner_left": {
+      "model": "antarchy:block/polished_antimetal_stairs_inner",
+      "uvlock": true,
+      "y": 90
+    },
+    "facing=west,half=bottom,shape=inner_right": {
+      "model": "antarchy:block/polished_antimetal_stairs_inner",
+      "uvlock": true,
+      "y": 180
+    },
+    "facing=west,half=bottom,shape=outer_left": {
+      "model": "antarchy:block/polished_antimetal_stairs_outer",
+      "uvlock": true,
+      "y": 90
+    },
+    "facing=west,half=bottom,shape=outer_right": {
+      "model": "antarchy:block/polished_antimetal_stairs_outer",
+      "uvlock": true,
+      "y": 180
+    },
+    "facing=west,half=bottom,shape=straight": {
+      "model": "antarchy:block/polished_antimetal_stairs",
+      "uvlock": true,
+      "y": 180
+    },
+    "facing=west,half=top,shape=inner_left": {
+      "model": "antarchy:block/polished_antimetal_stairs_inner",
+      "uvlock": true,
+      "x": 180,
+      "y": 180
+    },
+    "facing=west,half=top,shape=inner_right": {
+      "model": "antarchy:block/polished_antimetal_stairs_inner",
+      "uvlock": true,
+      "x": 180,
+      "y": 270
+    },
+    "facing=west,half=top,shape=outer_left": {
+      "model": "antarchy:block/polished_antimetal_stairs_outer",
+      "uvlock": true,
+      "x": 180,
+      "y": 180
+    },
+    "facing=west,half=top,shape=outer_right": {
+      "model": "antarchy:block/polished_antimetal_stairs_outer",
+      "uvlock": true,
+      "x": 180,
+      "y": 270
+    },
+    "facing=west,half=top,shape=straight": {
+      "model": "antarchy:block/polished_antimetal_stairs",
+      "uvlock": true,
+      "x": 180,
+      "y": 180
+    }
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/blockstates/potted_nadir_sapling.json

@@ -0,0 +1,7 @@
+{
+  "variants": {
+    "": {
+      "model": "antarchy:block/potted_nadir_sapling"
+    }
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/blockstates/shellstone_pillar.json

@@ -0,0 +1,16 @@
+{
+  "variants": {
+    "axis=x": {
+      "model": "antarchy:block/shellstone_pillar",
+      "x": 90,
+      "y": 90
+    },
+    "axis=y": {
+      "model": "antarchy:block/shellstone_pillar"
+    },
+    "axis=z": {
+      "model": "antarchy:block/shellstone_pillar",
+      "x": 90
+    }
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/blockstates/stripped_nadir_log.json

@@ -0,0 +1,16 @@
+{
+  "variants": {
+    "axis=x": {
+      "model": "antarchy:block/stripped_nadir_log_horizontal",
+      "x": 90,
+      "y": 90
+    },
+    "axis=y": {
+      "model": "antarchy:block/stripped_nadir_log"
+    },
+    "axis=z": {
+      "model": "antarchy:block/stripped_nadir_log_horizontal",
+      "x": 90
+    }
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/blockstates/stripped_nadir_wood.json

@@ -0,0 +1,7 @@
+{
+  "variants": {
+    "": {
+      "model": "antarchy:block/stripped_nadir_wood"
+    }
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/blockstates/upper.json

@@ -0,0 +1,9 @@
+{
+  "variants": {
+    "facing=up": { "model": "antarchy:block/upper", "x": 180 },
+    "facing=north": { "model": "antarchy:block/upper_side" },
+    "facing=west": { "model": "antarchy:block/upper_side_west" },
+    "facing=south": { "model": "antarchy:block/upper_side_south" },
+    "facing=east": { "model": "antarchy:block/upper_side_east" }
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/geo/dimensional_tear.geo.json

@@ -0,0 +1,59 @@
+{
+	"format_version": "1.12.0",
+	"minecraft:geometry": [
+		{
+			"description": {
+				"identifier": "geometry.unknown",
+				"texture_width": 512,
+				"texture_height": 512,
+				"visible_bounds_width": 11,
+				"visible_bounds_height": 10,
+				"visible_bounds_offset": [0, 1, 0]
+			},
+			"bones": [
+				{
+					"name": "tear",
+					"pivot": [1.83622, 14.33358, -8.27273],
+					"cubes": [
+						{"origin": [-40, -41, 1], "size": [80, 80, 0], "uv": [0, 80]},
+						{"origin": [-40, -41, 4], "size": [80, 80, 0], "inflate": 2, "uv": [0, 0]}
+					]
+				},
+				{
+					"name": "group",
+					"parent": "tear",
+					"pivot": [0, 4, 10],
+					"cubes": [
+						{"origin": [-75, -45, 10], "size": [150, 98, 0], "uv": [178, 14]}
+					]
+				},
+				{
+					"name": "content",
+					"parent": "tear",
+					"pivot": [13, 0, 0],
+					"cubes": [
+						{"origin": [-40, -41, -3], "size": [80, 80, 0], "uv": [0, 160]},
+						{"origin": [-60, -60, -9], "size": [80, 80, 0], "uv": [0, 160]},
+						{"origin": [-11, -6, -9], "size": [80, 80, 0], "uv": [0, 160]}
+					]
+				},
+				{
+					"name": "light_left",
+					"parent": "tear",
+					"pivot": [0, 7, 1],
+					"cubes": [
+						{"origin": [0, 6, -63], "size": [0, 2, 64], "uv": [162, 67]}
+					]
+				},
+				{
+					"name": "light_right",
+					"parent": "tear",
+					"pivot": [0, 7, 1],
+					"cubes": [
+						{"origin": [0, 6, -63], "size": [0, 2, 64], "uv": [162, 67], "mirror": true}
+					]
+				}
+			]
+		}
+	]
+}

common-1.21.1/src/main/resources/assets/antarchy/geo/lucid_bolt.geo.json

@@ -0,0 +1,96 @@
+{
+	"format_version": "1.12.0",
+	"minecraft:geometry": [
+		{
+			"description": {
+				"identifier": "geometry.unknown",
+				"texture_width": 32,
+				"texture_height": 32,
+				"visible_bounds_width": 2,
+				"visible_bounds_height": 2.5,
+				"visible_bounds_offset": [0, 0.75, 0]
+			},
+			"bones": [
+				{
+					"name": "projectile",
+					"pivot": [0, 6.5, -0.5],
+					"cubes": [
+						{"origin": [-1.5, 5, -5], "size": [3, 3, 9], "uv": [0, 0]}
+					]
+				},
+				{
+					"name": "ring",
+					"parent": "projectile",
+					"pivot": [0, 6.5, -2],
+					"cubes": [
+						{"origin": [-3.5, 3, -2], "size": [7, 7, 0], "uv": [0, 12]}
+					]
+				},
+				{
+					"name": "particle_right",
+					"parent": "projectile",
+					"pivot": [-3.5, 6, 2.5],
+					"cubes": [
+						{"origin": [-3.5, 5, 1], "size": [0, 2, 3], "uv": [0, -1]}
+					]
+				},
+				{
+					"name": "particle_left",
+					"parent": "projectile",
+					"pivot": [3.5, 6, 2.5],
+					"cubes": [
+						{"origin": [3.5, 5, 1], "size": [0, 2, 3], "uv": [0, -1], "mirror": true}
+					]
+				},
+				{
+					"name": "particle_right3",
+					"parent": "projectile",
+					"pivot": [-2.5, 4, 4.5],
+					"cubes": [
+						{"origin": [-2.5, 3, 3], "size": [0, 2, 3], "uv": [0, 1]}
+					]
+				},
+				{
+					"name": "particle_left3",
+					"parent": "projectile",
+					"pivot": [2.5, 4, 4.5],
+					"cubes": [
+						{"origin": [2.5, 3, 3], "size": [0, 2, 3], "uv": [0, 1], "mirror": true}
+					]
+				},
+				{
+					"name": "particle_right2",
+					"parent": "projectile",
+					"pivot": [-3.5, 8, 6.5],
+					"cubes": [
+						{"origin": [-3.5, 7, 5], "size": [0, 2, 3], "uv": [0, -3]}
+					]
+				},
+				{
+					"name": "particle_left2",
+					"parent": "projectile",
+					"pivot": [3.5, 8, 6.5],
+					"cubes": [
+						{"origin": [3.5, 7, 5], "size": [0, 2, 3], "uv": [0, -3], "mirror": true}
+					]
+				},
+				{
+					"name": "particle_right4",
+					"parent": "projectile",
+					"pivot": [-1.5, 10, 3.5],
+					"cubes": [
+						{"origin": [-1.5, 9, 2], "size": [0, 2, 3], "uv": [0, -3]}
+					]
+				},
+				{
+					"name": "particle_left4",
+					"parent": "projectile",
+					"pivot": [1.5, 10, 3.5],
+					"cubes": [
+						{"origin": [1.5, 9, 2], "size": [0, 2, 3], "uv": [0, -3], "mirror": true}
+					]
+				}
+			]
+		}
+	]
+}

common-1.21.1/src/main/resources/assets/antarchy/geo/lucid_bolt_impact.geo.json

@@ -0,0 +1,284 @@
+{
+	"format_version": "1.12.0",
+	"minecraft:geometry": [
+		{
+			"description": {
+				"identifier": "geometry.unknown",
+				"texture_width": 64,
+				"texture_height": 64,
+				"visible_bounds_width": 5,
+				"visible_bounds_height": 3.5,
+				"visible_bounds_offset": [0, 1.25, 0]
+			},
+			"bones": [
+				{
+					"name": "impact",
+					"pivot": [0, 0, 0]
+				},
+				{
+					"name": "impact_particle7",
+					"parent": "impact",
+					"pivot": [-2, 10, -14],
+					"cubes": [
+						{"origin": [-6, 7, -13], "size": [5, 5, 0], "uv": [0, 36]}
+					]
+				},
+				{
+					"name": "impact_group",
+					"parent": "impact",
+					"pivot": [-6, 3, -14]
+				},
+				{
+					"name": "impact_particle",
+					"parent": "impact_group",
+					"pivot": [-20, 19, -14],
+					"cubes": [
+						{"origin": [-24, 16, -13], "size": [5, 5, 0], "uv": [0, 36]}
+					]
+				},
+				{
+					"name": "impact_particle3",
+					"parent": "impact_group",
+					"pivot": [-15, 29, -14],
+					"cubes": [
+						{"origin": [-19, 26, -13], "size": [5, 5, 0], "uv": [0, 36]}
+					]
+				},
+				{
+					"name": "impact_particle4",
+					"parent": "impact_group",
+					"pivot": [-15, 29, -14],
+					"cubes": [
+						{"origin": [-19, 26, -13], "size": [5, 5, 0], "uv": [0, 36]}
+					]
+				},
+				{
+					"name": "impact_particle2",
+					"parent": "impact_group",
+					"pivot": [-2, 19, -14],
+					"cubes": [
+						{"origin": [-3, 16, -13], "size": [5, 5, 0], "uv": [0, 36], "mirror": true}
+					]
+				},
+				{
+					"name": "impact_particle5",
+					"parent": "impact_group",
+					"pivot": [-9, 31, -14],
+					"cubes": [
+						{"origin": [-10, 28, -13], "size": [5, 5, 0], "uv": [0, 36], "mirror": true}
+					]
+				},
+				{
+					"name": "impact_particle6",
+					"parent": "impact_group",
+					"pivot": [-6, 6, -14],
+					"cubes": [
+						{"origin": [-7, 3, -13], "size": [5, 5, 0], "uv": [0, 36], "mirror": true}
+					]
+				},
+				{
+					"name": "impact_group3",
+					"parent": "impact",
+					"pivot": [-13, 3, -8]
+				},
+				{
+					"name": "impact_particle20",
+					"parent": "impact_group3",
+					"pivot": [-27, 19, -8],
+					"cubes": [
+						{"origin": [-31, 16, -7], "size": [5, 5, 0], "uv": [0, 36]}
+					]
+				},
+				{
+					"name": "impact_particle21",
+					"parent": "impact_group3",
+					"pivot": [-22, 29, -8],
+					"cubes": [
+						{"origin": [-26, 26, -7], "size": [5, 5, 0], "uv": [0, 36]}
+					]
+				},
+				{
+					"name": "impact_particle22",
+					"parent": "impact_group3",
+					"pivot": [-22, 29, -8],
+					"cubes": [
+						{"origin": [-26, 26, -7], "size": [5, 5, 0], "uv": [0, 36]}
+					]
+				},
+				{
+					"name": "impact_particle23",
+					"parent": "impact_group3",
+					"pivot": [-9, 19, -8],
+					"cubes": [
+						{"origin": [-10, 16, -7], "size": [5, 5, 0], "uv": [0, 36], "mirror": true}
+					]
+				},
+				{
+					"name": "impact_particle24",
+					"parent": "impact_group3",
+					"pivot": [-16, 31, -8],
+					"cubes": [
+						{"origin": [-17, 28, -7], "size": [5, 5, 0], "uv": [0, 36], "mirror": true}
+					]
+				},
+				{
+					"name": "impact_particle25",
+					"parent": "impact_group3",
+					"pivot": [-13, 6, -8],
+					"cubes": [
+						{"origin": [-14, 3, -7], "size": [5, 5, 0], "uv": [0, 36], "mirror": true}
+					]
+				},
+				{
+					"name": "impact_group2",
+					"parent": "impact",
+					"pivot": [17, 6, -17]
+				},
+				{
+					"name": "impact_particle8",
+					"parent": "impact_group2",
+					"pivot": [3, 22, -17],
+					"cubes": [
+						{"origin": [-1, 19, -16], "size": [5, 5, 0], "uv": [0, 36]}
+					]
+				},
+				{
+					"name": "impact_particle9",
+					"parent": "impact_group2",
+					"pivot": [8, 32, -17],
+					"cubes": [
+						{"origin": [4, 29, -16], "size": [5, 5, 0], "uv": [0, 36]}
+					]
+				},
+				{
+					"name": "impact_particle10",
+					"parent": "impact_group2",
+					"pivot": [8, 32, -17],
+					"cubes": [
+						{"origin": [4, 29, -16], "size": [5, 5, 0], "uv": [0, 36]}
+					]
+				},
+				{
+					"name": "impact_particle11",
+					"parent": "impact_group2",
+					"pivot": [21, 22, -17],
+					"cubes": [
+						{"origin": [20, 19, -16], "size": [5, 5, 0], "uv": [0, 36], "mirror": true}
+					]
+				},
+				{
+					"name": "impact_particle12",
+					"parent": "impact_group2",
+					"pivot": [14, 34, -17],
+					"cubes": [
+						{"origin": [13, 31, -16], "size": [5, 5, 0], "uv": [0, 36], "mirror": true}
+					]
+				},
+				{
+					"name": "impact_particle13",
+					"parent": "impact_group2",
+					"pivot": [17, 9, -17],
+					"cubes": [
+						{"origin": [16, 6, -16], "size": [5, 5, 0], "uv": [0, 36], "mirror": true}
+					]
+				},
+				{
+					"name": "particle3",
+					"parent": "impact",
+					"pivot": [-5, 26.5, -10],
+					"cubes": [
+						{"origin": [-10, 21, -10], "size": [10, 11, 0], "uv": [0, 23]}
+					]
+				},
+				{
+					"name": "particle5",
+					"parent": "impact",
+					"pivot": [21, 10.5, -10],
+					"cubes": [
+						{"origin": [16, 5, -10], "size": [10, 11, 0], "uv": [0, 23]}
+					]
+				},
+				{
+					"name": "particle2",
+					"parent": "impact",
+					"pivot": [6, 16.5, -10],
+					"cubes": [
+						{"origin": [1, 11, -10], "size": [10, 11, 0], "uv": [0, 23]}
+					]
+				},
+				{
+					"name": "particle6",
+					"parent": "impact",
+					"pivot": [20, 30.5, -10],
+					"cubes": [
+						{"origin": [15, 25, -10], "size": [10, 11, 0], "uv": [0, 23]}
+					]
+				},
+				{
+					"name": "particle4",
+					"parent": "impact",
+					"pivot": [-18, 16.5, -10],
+					"cubes": [
+						{"origin": [-23, 11, -10], "size": [10, 11, 0], "uv": [0, 23]}
+					]
+				},
+				{
+					"name": "particle",
+					"parent": "impact",
+					"pivot": [-5, 5.5, -10],
+					"cubes": [
+						{"origin": [-10, 0, -10], "size": [10, 11, 0], "uv": [0, 23]}
+					]
+				},
+				{
+					"name": "eye",
+					"parent": "impact",
+					"pivot": [0, 38.66667, -0.66667],
+					"cubes": [
+						{"origin": [-6, 34, -2], "size": [12, 8, 4], "uv": [0, 11]}
+					]
+				},
+				{
+					"name": "Iris",
+					"parent": "eye",
+					"pivot": [0, 37.5, -2],
+					"cubes": [
+						{"origin": [-2, 35.5, -2], "size": [4, 4, 0], "inflate": 0.01, "uv": [0, 0]}
+					]
+				},
+				{
+					"name": "eyelid",
+					"parent": "eye",
+					"pivot": [0, 40.5, 0],
+					"cubes": [
+						{"origin": [-6, 39, -2], "size": [12, 3, 4], "inflate": 0.1, "uv": [0, 4]}
+					]
+				},
+				{
+					"name": "impact_particle14",
+					"pivot": [-20, 19, -14]
+				},
+				{
+					"name": "impact_particle15",
+					"pivot": [-15, 29, -14]
+				},
+				{
+					"name": "impact_particle16",
+					"pivot": [-15, 29, -14]
+				},
+				{
+					"name": "impact_particle17",
+					"pivot": [-2, 19, -14]
+				},
+				{
+					"name": "impact_particle18",
+					"pivot": [-9, 31, -14]
+				},
+				{
+					"name": "impact_particle19",
+					"pivot": [-6, 6, -14]
+				}
+			]
+		}
+	]
+}

common-1.21.1/src/main/resources/assets/antarchy/geo/nightmare_bite.geo.json

@@ -0,0 +1,82 @@
+{
+	"format_version": "1.12.0",
+	"minecraft:geometry": [
+		{
+			"description": {
+				"identifier": "geometry.unknown",
+				"texture_width": 128,
+				"texture_height": 64,
+				"visible_bounds_width": 4,
+				"visible_bounds_height": 4.5,
+				"visible_bounds_offset": [0, 1.75, 0]
+			},
+			"bones": [
+				{
+					"name": "Bite",
+					"pivot": [0, 23, 0.5]
+				},
+				{
+					"name": "particles_left",
+					"parent": "Bite",
+					"pivot": [7.5, 33.5, -5],
+					"rotation": [0, 0, -45],
+					"cubes": [
+						{"origin": [6, 32, -5], "size": [5, 3, 0], "uv": [52, 0]}
+					]
+				},
+				{
+					"name": "particles_left_bottom",
+					"parent": "Bite",
+					"pivot": [7.5, 16.5, -5],
+					"rotation": [9.30219, 7.61662, 44.98747],
+					"cubes": [
+						{"origin": [6, 15, -5], "size": [5, 3, 0], "uv": [52, 0]}
+					]
+				},
+				{
+					"name": "particles_right_bottom",
+					"parent": "Bite",
+					"pivot": [-7.5, 16.5, -5],
+					"rotation": [9.30219, -7.61662, -44.98747],
+					"cubes": [
+						{"origin": [-11, 15, -5], "size": [5, 3, 0], "uv": [52, 0], "mirror": true}
+					]
+				},
+				{
+					"name": "particles_right",
+					"parent": "Bite",
+					"pivot": [-7.5, 33.5, -5],
+					"rotation": [0, 0, 45],
+					"cubes": [
+						{"origin": [-11, 32, -5], "size": [5, 3, 0], "uv": [52, 0], "mirror": true}
+					]
+				},
+				{
+					"name": "impact",
+					"parent": "Bite",
+					"pivot": [0, 25.5, -7.75],
+					"cubes": [
+						{"origin": [-18.5, 23, -8], "size": [37, 5, 0], "uv": [0, 30]},
+						{"origin": [-18.5, 23, -7.5], "size": [37, 5, 0], "pivot": [0, 25.5, -8], "rotation": [0, 0, 90], "uv": [0, 30]}
+					]
+				},
+				{
+					"name": "lower_jaw",
+					"parent": "Bite",
+					"pivot": [0, 13.5, 1],
+					"cubes": [
+						{"origin": [-13, 6, 1], "size": [26, 15, 0], "uv": [0, 0]}
+					]
+				},
+				{
+					"name": "upper_jaw",
+					"parent": "Bite",
+					"pivot": [0, 32.5, 0],
+					"cubes": [
+						{"origin": [-13, 25, 0], "size": [26, 15, 0], "uv": [0, 15]}
+					]
+				}
+			]
+		}
+	]
+}

common-1.21.1/src/main/resources/assets/antarchy/geo/nightmare_portal.geo.json

@@ -0,0 +1,109 @@
+{
+	"format_version": "1.12.0",
+	"minecraft:geometry": [
+		{
+			"description": {
+				"identifier": "geometry.unknown",
+				"texture_width": 256,
+				"texture_height": 256,
+				"visible_bounds_width": 6,
+				"visible_bounds_height": 5,
+				"visible_bounds_offset": [0, 1.5, 0]
+			},
+			"bones": [
+				{
+					"name": "Beam",
+					"pivot": [-1.5, 21, 5.25],
+					"cubes": [
+						{"origin": [-30, 20, -0.75], "size": [60, 5, 0], "uv": [0, 223]}
+					]
+				},
+				{
+					"name": "Portal",
+					"pivot": [0, 21, 4]
+				},
+				{
+					"name": "particle_left",
+					"parent": "Portal",
+					"pivot": [25.24264, 46.57107, -3.75],
+					"cubes": [
+						{"origin": [13.24264, 39.07107, -3.75], "size": [24, 15, 0], "uv": [0, 208]}
+					]
+				},
+				{
+					"name": "particle_right",
+					"parent": "Portal",
+					"pivot": [-25.24264, 46.57107, -3.75],
+					"cubes": [
+						{"origin": [-37.24264, 39.07107, -3.75], "size": [24, 15, 0], "uv": [0, 208], "mirror": true}
+					]
+				},
+				{
+					"name": "particle_right_bottom",
+					"parent": "Portal",
+					"pivot": [-25.24264, -2.57107, -3.75],
+					"cubes": [
+						{"origin": [-37.24264, -10.07107, -3.75], "size": [24, 15, 0], "uv": [0, 208], "mirror": true}
+					]
+				},
+				{
+					"name": "particle_left_bottom",
+					"parent": "Portal",
+					"pivot": [25.24264, -2.57107, -3.75],
+					"cubes": [
+						{"origin": [13.24264, -10.07107, -3.75], "size": [24, 15, 0], "uv": [0, 208]}
+					]
+				},
+				{
+					"name": "Portal_Layer_Highlight",
+					"parent": "Portal",
+					"pivot": [0, 21, -1],
+					"cubes": [
+						{"origin": [-20, 1, -2.75], "size": [37, 40, 0], "uv": [0, 168]},
+						{"origin": [-21, 0, -1], "size": [42, 42, 0], "uv": [0, 126]}
+					]
+				},
+				{
+					"name": "Back_Portal_Layer",
+					"parent": "Portal",
+					"pivot": [0, 21, 5],
+					"cubes": [
+						{"origin": [-21, 0, 5], "size": [42, 42, 0], "uv": [0, 42]}
+					]
+				},
+				{
+					"name": "Back_Portal_Layer2",
+					"parent": "Portal",
+					"pivot": [0, 21, 7],
+					"cubes": [
+						{"origin": [-21, 0, 7], "size": [42, 42, 0], "uv": [0, 42]}
+					]
+				},
+				{
+					"name": "Back_Portal_Layer3",
+					"parent": "Portal",
+					"pivot": [0, 21, 11],
+					"cubes": [
+						{"origin": [-21, 0, 11], "size": [42, 42, 0], "uv": [0, 42]}
+					]
+				},
+				{
+					"name": "Portal_Layer",
+					"parent": "Portal",
+					"pivot": [0, 21, 0],
+					"cubes": [
+						{"origin": [-21, 0, 0], "size": [42, 42, 0], "uv": [0, 84]}
+					]
+				},
+				{
+					"name": "Portal_Layer2",
+					"parent": "Portal",
+					"pivot": [0, 21, 2],
+					"cubes": [
+						{"origin": [-21, 0, 2], "size": [42, 42, 0], "uv": [84, 0]}
+					]
+				}
+			]
+		}
+	]
+}

common-1.21.1/src/main/resources/assets/antarchy/geo/water_bomb.geo.json

@@ -0,0 +1,32 @@
+{
+	"format_version": "1.12.0",
+	"minecraft:geometry": [
+		{
+			"description": {
+				"identifier": "geometry.unknown",
+				"texture_width": 64,
+				"texture_height": 128,
+				"visible_bounds_width": 3,
+				"visible_bounds_height": 2.5,
+				"visible_bounds_offset": [0, 0.75, 0]
+			},
+			"bones": [
+				{
+					"name": "Water_projectile",
+					"pivot": [0, 8, 0],
+					"cubes": [
+						{"origin": [-8, 0, -8], "size": [16, 16, 16], "uv": [0, 0]}
+					]
+				},
+				{
+					"name": "water_ring",
+					"parent": "Water_projectile",
+					"pivot": [7, 0, 4],
+					"cubes": [
+						{"origin": [-8, 0, -11], "size": [16, 16, 8], "inflate": 1, "uv": [8, 40]}
+					]
+				}
+			]
+		}
+	]
+}

common-1.21.1/src/main/resources/assets/antarchy/geo/worm_large.geo.json

@@ -0,0 +1,109 @@
+{
+	"format_version": "1.12.0",
+	"minecraft:geometry": [
+		{
+			"description": {
+				"identifier": "geometry.largeworm",
+				"texture_width": 128,
+				"texture_height": 128,
+				"visible_bounds_width": 3,
+				"visible_bounds_height": 6.5,
+				"visible_bounds_offset": [0, 2.75, 0]
+			},
+			"bones": [
+				{
+					"name": "root",
+					"pivot": [0, 0, 0]
+				},
+				{
+					"name": "body",
+					"parent": "root",
+					"pivot": [0, 36, 0],
+					"cubes": [
+						{"origin": [-6, 20, -6], "size": [12, 32, 12], "uv": [0, 40]}
+					]
+				},
+				{
+					"name": "head",
+					"parent": "body",
+					"pivot": [0, 52, 0],
+					"cubes": [
+						{"origin": [-8, 52, -8], "size": [16, 24, 16], "uv": [0, 0]}
+					]
+				},
+				{
+					"name": "tooth1",
+					"parent": "head",
+					"pivot": [-6.64264, 76, 6.64264],
+					"cubes": [
+						{"origin": [-3, 76, -7], "size": [4, 8, 4], "pivot": [-1, 80, 1], "rotation": [-180, 45, 180], "uv": [64, 68]}
+					]
+				},
+				{
+					"name": "tooth2",
+					"parent": "head",
+					"pivot": [0, 76, 8],
+					"cubes": [
+						{"origin": [-2, 76, 4], "size": [4, 8, 4], "uv": [80, 24]}
+					]
+				},
+				{
+					"name": "tooth3",
+					"parent": "head",
+					"pivot": [6.64264, 76, 6.64264],
+					"cubes": [
+						{"origin": [-1, 76, -7], "size": [4, 8, 4], "pivot": [1, 80, 1], "rotation": [-180, -45, -180], "uv": [80, 0]}
+					]
+				},
+				{
+					"name": "tooth4",
+					"parent": "head",
+					"pivot": [-8, 76, 0],
+					"cubes": [
+						{"origin": [-2, 76, -8], "size": [4, 8, 4], "pivot": [0, 80, 0], "rotation": [0, 90, 0], "uv": [64, 68]}
+					]
+				},
+				{
+					"name": "tooth5",
+					"parent": "head",
+					"pivot": [8, 76, 0],
+					"cubes": [
+						{"origin": [-2, 76, 4], "size": [4, 8, 4], "pivot": [0, 80, 0], "rotation": [0, 90, 0], "uv": [80, 24]}
+					]
+				},
+				{
+					"name": "tooth6",
+					"parent": "head",
+					"pivot": [-6.64264, 76, -6.64264],
+					"cubes": [
+						{"origin": [-3, 76, 3], "size": [4, 8, 4], "pivot": [-1, 80, -1], "rotation": [180, -45, 180], "uv": [80, 24]}
+					]
+				},
+				{
+					"name": "tooth7",
+					"parent": "head",
+					"pivot": [0, 76, -8],
+					"cubes": [
+						{"origin": [-2, 76, -8], "size": [4, 8, 4], "uv": [80, 0]}
+					]
+				},
+				{
+					"name": "tooth8",
+					"parent": "head",
+					"pivot": [6.64264, 76, -6.64264],
+					"cubes": [
+						{"origin": [-1, 76, 3], "size": [4, 8, 4], "pivot": [1, 80, -1], "rotation": [180, 45, -180], "uv": [80, 24]}
+					]
+				},
+				{
+					"name": "tail",
+					"parent": "body",
+					"pivot": [0, 20, 0],
+					"cubes": [
+						{"origin": [-4, 0, -4], "size": [8, 20, 8], "uv": [48, 40]}
+					]
+				}
+			]
+		}
+	]
+}

common-1.21.1/src/main/resources/assets/antarchy/models/block/antigravel.json

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

common-1.21.1/src/main/resources/assets/antarchy/models/block/antimetal_slab.json

@@ -0,0 +1,8 @@
+{
+  "parent": "minecraft:block/slab",
+  "textures": {
+    "bottom": "antarchy:block/antimetal/antimetal_block_top",
+    "side": "antarchy:block/antimetal/antimetal_block",
+    "top": "antarchy:block/antimetal/antimetal_block_top"
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/models/block/antimetal_slab_top.json

@@ -0,0 +1,8 @@
+{
+  "parent": "minecraft:block/slab_top",
+  "textures": {
+    "bottom": "antarchy:block/antimetal/antimetal_block_top",
+    "side": "antarchy:block/antimetal/antimetal_block",
+    "top": "antarchy:block/antimetal/antimetal_block_top"
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/models/block/antimetal_stairs.json

@@ -0,0 +1,8 @@
+{
+  "parent": "minecraft:block/stairs",
+  "textures": {
+    "bottom": "antarchy:block/antimetal/antimetal_block_top",
+    "side": "antarchy:block/antimetal/antimetal_block",
+    "top": "antarchy:block/antimetal/antimetal_block_top"
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/models/block/antimetal_stairs_inner.json

@@ -0,0 +1,8 @@
+{
+  "parent": "minecraft:block/inner_stairs",
+  "textures": {
+    "bottom": "antarchy:block/antimetal/antimetal_block_top",
+    "side": "antarchy:block/antimetal/antimetal_block",
+    "top": "antarchy:block/antimetal/antimetal_block_top"
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/models/block/antimetal_stairs_outer.json

@@ -0,0 +1,8 @@
+{
+  "parent": "minecraft:block/outer_stairs",
+  "textures": {
+    "bottom": "antarchy:block/antimetal/antimetal_block_top",
+    "side": "antarchy:block/antimetal/antimetal_block",
+    "top": "antarchy:block/antimetal/antimetal_block_top"
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/models/block/bluestone_lamp.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/cube_all",
+  "textures": {
+    "all": "antarchy:block/bluestone/bluestone_lamp"
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/models/block/bluestone_lamp_on.json

@@ -0,0 +1,6 @@
+{
+  "parent": "minecraft:block/cube_all",
+  "textures": {
+    "all": "antarchy:block/bluestone/bluestone_lamp_on"
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/models/block/broodstone_pillar.json

@@ -0,0 +1,7 @@
+{
+  "parent": "minecraft:block/cube_column",
+  "textures": {
+    "end": "antarchy:block/broodstone/broodstone_pillar_top",
+    "side": "antarchy:block/broodstone/broodstone_pillar"
+  }
+}

common-1.21.1/src/main/resources/assets/antarchy/models/block/loam.json

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

common-1.21.1/src/main/resources/assets/antarchy/models/block/lucid_anchor.json

@@ -0,0 +1,111 @@
+{
+	"format_version": "1.21.11",
+	"credit": "Made with Blockbench",
+	"texture_size": [64, 64],
+	"textures": {
+		"0": "antarchy:block/lucid_anchor",
+		"particle": "antarchy:block/lucid_anchor"
+	},
+	"elements": [
+		{
+			"name": "core",
+			"from": [3, 3, 3],
+			"to": [13, 13, 13],
+			"rotation": {"angle": 0, "axis": "y", "origin": [0, 3, 0]},
+			"faces": {
+				"north": {"uv": [8, 7, 10.5, 9.5], "texture": "#0"},
+				"east": {"uv": [8, 7, 10.5, 9.5], "texture": "#0"},
+				"south": {"uv": [8, 7, 10.5, 9.5], "texture": "#0"},
+				"west": {"uv": [8, 7, 10.5, 9.5], "texture": "#0"},
+				"up": {"uv": [2.5, 14, 0, 11.5], "texture": "#0"},
+				"down": {"uv": [5, 11.5, 2.5, 14], "texture": "#0"}
+			}
+		},
+		{
+			"from": [0, 13, 0],
+			"to": [16, 16, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [0, 14, 0]},
+			"faces": {
+				"north": {"uv": [12, 0, 16, 0.75], "texture": "#0"},
+				"east": {"uv": [12, 0, 16, 0.75], "texture": "#0"},
+				"south": {"uv": [12, 0, 16, 0.75], "texture": "#0"},
+				"west": {"uv": [12, 0, 16, 0.75], "texture": "#0"},
+				"up": {"uv": [4, 4, 0, 0], "texture": "#0"},
+				"down": {"uv": [4, 0, 0, 4], "texture": "#0"}
+			}
+		},
+		{
+			"from": [0, 0, 0],
+			"to": [16, 13, 16],
+			"faces": {
+				"north": {"uv": [0, 8.25, 4, 11.5], "texture": "#0"},
+				"east": {"uv": [0, 8.25, 4, 11.5], "texture": "#0"},
+				"south": {"uv": [0, 8.25, 4, 11.5], "texture": "#0"},
+				"west": {"uv": [0, 8.25, 4, 11.5], "texture": "#0"},
+				"down": {"uv": [4, 0, 8, 4], "texture": "#0"}
+			}
+		}
+	],
+	"display": {
+		"thirdperson_righthand": {
+			"rotation": [75, 45, 0],
+			"translation": [0, 2.5, 0],
+			"scale": [0.375, 0.375, 0.375]
+		},
+		"thirdperson_lefthand": {
+			"rotation": [75, 45, 0],
+			"translation": [0, 2.5, 0],
+			"scale": [0.375, 0.375, 0.375]
+		},
+		"firstperson_righthand": {
+			"rotation": [0, 45, 0],
+			"scale": [0.4, 0.4, 0.4]
+		},
+		"firstperson_lefthand": {
+			"rotation": [0, -135, 0],
+			"scale": [0.4, 0.4, 0.4]
+		},
+		"ground": {
+			"translation": [0, 3, 0],
+			"scale": [0.25, 0.25, 0.25]
+		},
+		"gui": {
+			"rotation": [30, -135, 0],
+			"scale": [0.625, 0.625, 0.625]
+		},
+		"fixed": {
+			"scale": [0.5, 0.5, 0.5]
+		}
+	},
+	"groups": [
+		{
+			"name": "lucid_anchor",
+			"origin": [0, 2, 0],
+			"scope": 0,
+			"color": 0,
+			"children": [
+				{
+					"name": "core",
+					"origin": [0, 2, 0],
+					"scope": 0,
+					"color": 0,
+					"children": [0]
+				},
+				{
+					"name": "base",
+					"origin": [0, 0, 0],
+					"scope": 0,
+					"color": 0,
+					"children": [1]
+				},
+				{
+					"name": "glass",
+					"origin": [0, 2, 0],
+					"scope": 0,
+					"color": 0,
+					"children": [2]
+				}
+			]
+		}
+	]
+}

common-1.21.1/src/main/resources/assets/antarchy/models/block/mucus.json

@@ -0,0 +1,17 @@
+{
+  "ambientocclusion": false,
+  "textures": {
+    "particle": "antarchy:block/mucus",
+    "glow_lichen": "antarchy:block/mucus"
+  },
+  "elements": [
+    {
+      "from": [0, 0, 0.1],
+      "to": [16, 16, 0.1],
+      "faces": {
+        "north": { "uv": [16, 0, 0, 16], "texture": "#glow_lichen" },
+        "south": { "uv": [0, 0, 16, 16], "texture": "#glow_lichen" }
+      }
+    }
+  ]
+}