Fixed DreamCampfireBlock not working with silk touch.

Added first draft of shellstone, water cannon, Toreterror, primordial armor

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

@@ -147,7 +147,7 @@ public final class AntarchySettings {
     private static boolean basiliskPetrifyingGazeEnabled = true;
     private static int basiliskSpawnMaxLightLevel = 5;
     private static double basiliskHealth = 150.0D;
-    private static double basiliskAttackDamage = 8.0D;
+    private static double basiliskAttackDamage = 36.0D;
     private static double basiliskMovementSpeed = 0.30D;
     private static double basiliskArmor = 6.0D;
     private static double basiliskKnockbackResistance = 0.5D;

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

@@ -0,0 +1,41 @@
+package com.craisinlord.antarchy.content;
+
+import com.craisinlord.antarchy.config.AntarchySettings;
+import com.craisinlord.antarchy.content.entity.MissileSquidEntity;
+import net.minecraft.core.Direction;
+import net.minecraft.core.Position;
+import net.minecraft.core.dispenser.BlockSource;
+import net.minecraft.core.dispenser.DefaultDispenseItemBehavior;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.phys.Vec3;
+import net.minecraft.world.level.block.DispenserBlock;
+
+public class SquidzookaDispenseBehavior extends DefaultDispenseItemBehavior {
+    @Override
+    protected ItemStack execute(BlockSource source, ItemStack stack) {
+        Direction direction = source.state().getValue(DispenserBlock.FACING);
+        Position position = DispenserBlock.getDispensePosition(source);
+
+        MissileSquidEntity squid = AntarchyObjects.MISSILE_SQUID.get().create(source.level());
+        if (squid == null) return super.execute(source, stack);
+
+        squid.setPos(position.x(), position.y(), position.z());
+        Vec3 vel = new Vec3(direction.getStepX(), direction.getStepY(), direction.getStepZ())
+                .normalize()
+                .scale(AntarchySettings.squidzookaLaunchVelocity());
+        squid.launchAsProjectile(null, vel);
+        source.level().addFreshEntity(squid);
+
+        if (stack.isDamageableItem()) {
+            int nextDamage = stack.getDamageValue() + 1;
+            if (nextDamage >= stack.getMaxDamage()) {
+                stack.shrink(1);
+            } else {
+                stack.setDamageValue(nextDamage);
+            }
+        } else {
+            stack.shrink(1);
+        }
+        return stack;
+    }
+}

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

@@ -0,0 +1,36 @@
+package com.craisinlord.antarchy.content;
+
+import com.craisinlord.antarchy.content.entity.WaterBombEntity;
+import com.craisinlord.antarchy.content.AntarchyObjects;
+import net.minecraft.core.Direction;
+import net.minecraft.core.Position;
+import net.minecraft.core.dispenser.BlockSource;
+import net.minecraft.core.dispenser.DefaultDispenseItemBehavior;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.block.DispenserBlock;
+
+public class WaterCannonDispenseBehavior extends DefaultDispenseItemBehavior {
+    @Override
+    protected ItemStack execute(BlockSource source, ItemStack stack) {
+        Direction direction = source.state().getValue(DispenserBlock.FACING);
+        Position position = DispenserBlock.getDispensePosition(source);
+
+        WaterBombEntity bomb = AntarchyObjects.WATER_BOMB.get().create(source.level());
+        if (bomb == null) return super.execute(source, stack);
+        bomb.setPos(position.x(), position.y(), position.z());
+        bomb.shoot(direction.getStepX(), direction.getStepY() + 0.1D, direction.getStepZ(), 1.5F, 0.0F);
+        source.level().addFreshEntity(bomb);
+
+        if (stack.isDamageableItem()) {
+            int nextDamage = stack.getDamageValue() + 1;
+            if (nextDamage >= stack.getMaxDamage()) {
+                stack.shrink(1);
+            } else {
+                stack.setDamageValue(nextDamage);
+            }
+        } else {
+            stack.shrink(1);
+        }
+        return stack;
+    }
+}

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

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

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

@@ -0,0 +1,19 @@
+package com.craisinlord.antarchy.content.client.renderer;
+
+import com.craisinlord.antarchy.content.client.model.ToreterrorModel;
+import com.craisinlord.antarchy.content.entity.ToreterrorEntity;
+import net.minecraft.client.renderer.entity.EntityRendererProvider;
+import software.bernie.geckolib.renderer.GeoEntityRenderer;
+
+public class ToreterrorRenderer extends GeoEntityRenderer<ToreterrorEntity> {
+
+    public ToreterrorRenderer(EntityRendererProvider.Context context) {
+        super(context, new ToreterrorModel());
+        this.shadowRadius = 2.0F;
+    }
+
+    @Override
+    protected float getDeathMaxRotation(ToreterrorEntity animatable) {
+        return 0.0F;
+    }
+}

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

@@ -0,0 +1,60 @@
+package com.craisinlord.antarchy.content.client.renderer;
+
+import com.craisinlord.antarchy.content.entity.WaterBombEntity;
+import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.blaze3d.vertex.VertexConsumer;
+import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.client.renderer.entity.EntityRenderer;
+import net.minecraft.client.renderer.entity.EntityRendererProvider;
+import net.minecraft.client.renderer.texture.OverlayTexture;
+import net.minecraft.core.BlockPos;
+import net.minecraft.resources.ResourceLocation;
+import org.joml.Matrix4f;
+
+public class WaterBombRenderer extends EntityRenderer<WaterBombEntity> {
+
+    private static final ResourceLocation WATER_TEXTURE = ResourceLocation.withDefaultNamespace("textures/block/water_still.png");
+
+    public WaterBombRenderer(EntityRendererProvider.Context context) {
+        super(context);
+    }
+
+    @Override
+    protected int getBlockLightLevel(WaterBombEntity entity, BlockPos pos) {
+        return 12;
+    }
+
+    @Override
+    public void render(WaterBombEntity entity, float entityYaw, float partialTick, PoseStack poseStack, MultiBufferSource buffer, int packedLight) {
+        poseStack.pushPose();
+        poseStack.mulPose(this.entityRenderDispatcher.cameraOrientation());
+        poseStack.scale(0.5F, 0.5F, 0.5F);
+
+        VertexConsumer vertexConsumer = buffer.getBuffer(RenderType.entityTranslucent(WATER_TEXTURE));
+        PoseStack.Pose pose = poseStack.last();
+        Matrix4f matrix4f = pose.pose();
+        addVertex(vertexConsumer, pose, matrix4f, -0.5F, -0.5F, 0.0F, 1.0F, packedLight);
+        addVertex(vertexConsumer, pose, matrix4f, 0.5F, -0.5F, 1.0F, 1.0F, packedLight);
+        addVertex(vertexConsumer, pose, matrix4f, 0.5F, 0.5F, 1.0F, 0.0F, packedLight);
+        addVertex(vertexConsumer, pose, matrix4f, -0.5F, 0.5F, 0.0F, 0.0F, packedLight);
+
+        poseStack.popPose();
+        super.render(entity, entityYaw, partialTick, poseStack, buffer, packedLight);
+    }
+
+    private static void addVertex(VertexConsumer vertexConsumer, PoseStack.Pose pose, Matrix4f matrix4f,
+                                   float x, float y, float u, float v, int packedLight) {
+        vertexConsumer.addVertex(matrix4f, x, y, 0.0F)
+                .setColor(0.05F, 0.15F, 0.6F, 0.9F)
+                .setUv(u, v)
+                .setOverlay(OverlayTexture.NO_OVERLAY)
+                .setLight(packedLight)
+                .setNormal(pose, 0.0F, 0.0F, 1.0F);
+    }
+
+    @Override
+    public ResourceLocation getTextureLocation(WaterBombEntity entity) {
+        return WATER_TEXTURE;
+    }
+}

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

@@ -0,0 +1,514 @@
+package com.craisinlord.antarchy.content.entity;
+
+import com.craisinlord.antarchy.config.AntarchySettings;
+import com.craisinlord.antarchy.content.AntarchyObjects;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.syncher.EntityDataAccessor;
+import net.minecraft.network.syncher.EntityDataSerializers;
+import net.minecraft.network.syncher.SynchedEntityData;
+import net.minecraft.server.level.ServerBossEvent;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.sounds.SoundEvents;
+import net.minecraft.world.BossEvent;
+import net.minecraft.world.Difficulty;
+import net.minecraft.world.damagesource.DamageSource;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.Mob;
+import net.minecraft.world.entity.MobSpawnType;
+import net.minecraft.world.entity.ai.attributes.AttributeSupplier;
+import net.minecraft.world.entity.ai.attributes.Attributes;
+import net.minecraft.world.entity.ai.goal.Goal;
+import net.minecraft.world.entity.ai.goal.LookAtPlayerGoal;
+import net.minecraft.world.entity.ai.goal.RandomLookAroundGoal;
+import net.minecraft.world.entity.ai.goal.WaterAvoidingRandomStrollGoal;
+import net.minecraft.world.entity.ai.goal.target.HurtByTargetGoal;
+import net.minecraft.world.entity.ai.goal.target.NearestAttackableTargetGoal;
+import net.minecraft.world.entity.monster.Monster;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.ServerLevelAccessor;
+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;
+
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+public class ToreterrorEntity extends Monster implements GeoEntity {
+
+    private static final EntityDataAccessor<Integer> ANIMATION_STATE = SynchedEntityData.defineId(ToreterrorEntity.class, EntityDataSerializers.INT);
+
+    private static final int ANIM_IDLE = 0;
+    private static final int ANIM_WALK = 1;
+    private static final int ANIM_SHOOT = 2;
+    private static final int ANIM_JUMP_ATTACK = 3;
+    private static final int ANIM_SPIN = 4;
+    private static final int ANIM_DEATH = 5;
+
+    private static final int DEATH_TICKS = 60;
+    private static final int SHOOT_TOTAL_TICKS = 80;
+    private static final int SHOOT_FIRE_START_TICK = 12;
+    private static final int SHOOT_FIRE_END_TICK = 68;
+    private static final int SHOOT_FIRE_INTERVAL = 8;
+    private static final int SHOOT_BOMBER_TICK = 12;
+    private static final int JUMP_TOTAL_TICKS = 40;
+    private static final int JUMP_LAUNCH_TICK = 10;
+    private static final int SPIN_TOTAL_TICKS = 40;
+    private static final int SPIN_START_TICK = 3;
+    private static final int SPIN_END_TICK = 22;
+    private static final int SPIN_HIT_INTERVAL = 5;
+
+    private static final double RANGED_MIN_RANGE_SQR = 9.0D;
+    private static final double RANGED_MAX_RANGE_SQR = 625.0D;
+    private static final double MELEE_RANGE_SQR = 9.0D;
+    private static final double SPIN_RADIUS = 4.5D;
+    private static final double JUMP_SHOCKWAVE_RADIUS = 6.0D;
+
+    private static final RawAnimation IDLE_ANIM = RawAnimation.begin().thenLoop("Idle");
+    private static final RawAnimation WALK_ANIM = RawAnimation.begin().thenLoop("walk");
+    private static final RawAnimation SHOOT_ANIM = RawAnimation.begin().thenPlay("shoot").thenLoop("Idle");
+    private static final RawAnimation JUMP_ANIM = RawAnimation.begin().thenPlay("jump_attack").thenLoop("Idle");
+    private static final RawAnimation SPIN_ANIM = RawAnimation.begin().thenPlay("spin_attack").thenLoop("Idle");
+    private static final RawAnimation DEATH_ANIM = RawAnimation.begin().thenPlayAndHold("death");
+
+    private final AnimatableInstanceCache geoCache = GeckoLibUtil.createInstanceCache(this);
+    private final ServerBossEvent bossEvent = new ServerBossEvent(Component.translatable("entity.antarchy.toreterror"), BossEvent.BossBarColor.GREEN, BossEvent.BossBarOverlay.PROGRESS);
+
+    private int shootAnimTicks;
+    private int jumpAnimTicks;
+    private int spinAnimTicks;
+    private int shootCooldown;
+    private int jumpCooldown;
+    private int spinCooldown;
+    private boolean jumpLaunched;
+    private boolean shockwaveApplied;
+    private boolean shootUseWaterBombs;
+    private boolean shootBomberFired;
+    private int shootNextFireElapsed;
+    private final Map<UUID, Integer> spinHitCooldowns = new HashMap<>();
+
+    public ToreterrorEntity(EntityType<? extends ToreterrorEntity> entityType, Level level) {
+        super(entityType, level);
+        this.xpReward = 50;
+    }
+
+    public static AttributeSupplier.Builder createAttributes() {
+        return Mob.createMobAttributes()
+                .add(Attributes.MAX_HEALTH, AntarchySettings.toreterrorHealth())
+                .add(Attributes.ATTACK_DAMAGE, 8.0D)
+                .add(Attributes.MOVEMENT_SPEED, 0.25D)
+                .add(Attributes.FOLLOW_RANGE, 48.0D)
+                .add(Attributes.KNOCKBACK_RESISTANCE, 0.85D)
+                .add(Attributes.ARMOR, 10.0D);
+    }
+
+    public static boolean canSpawn(EntityType<ToreterrorEntity> entityType, ServerLevelAccessor level, MobSpawnType spawnReason, BlockPos pos, net.minecraft.util.RandomSource random) {
+        boolean sturdy = level.getBlockState(pos.below()).isFaceSturdy(level, pos.below(), Direction.UP);
+        return level.getDifficulty() != Difficulty.PEACEFUL && sturdy;
+    }
+
+    @Override
+    protected void defineSynchedData(SynchedEntityData.Builder builder) {
+        super.defineSynchedData(builder);
+        builder.define(ANIMATION_STATE, ANIM_IDLE);
+    }
+
+    @Override
+    protected void registerGoals() {
+        this.goalSelector.addGoal(1, new ToreterrorRangedGoal());
+        this.goalSelector.addGoal(2, new ToreterrorJumpGoal());
+        this.goalSelector.addGoal(3, new ToreterrorSpinGoal());
+        this.goalSelector.addGoal(5, new LookAtPlayerGoal(this, Player.class, 16.0F));
+        this.goalSelector.addGoal(6, new RandomLookAroundGoal(this));
+        this.goalSelector.addGoal(7, new WaterAvoidingRandomStrollGoal(this, 0.6D));
+        this.targetSelector.addGoal(1, new HurtByTargetGoal(this).setAlertOthers());
+        this.targetSelector.addGoal(2, new NearestAttackableTargetGoal<>(this, Player.class, 10, true, false, this::canTargetEntity));
+    }
+
+    @Override
+    public void registerControllers(AnimatableManager.ControllerRegistrar controllers) {
+        controllers.add(new AnimationController<>(this, "main_controller", 0, this::mainAnimController));
+    }
+
+    private PlayState mainAnimController(AnimationState<ToreterrorEntity> state) {
+        int animState = this.getAnimationState();
+        return switch (animState) {
+            case ANIM_WALK -> state.setAndContinue(WALK_ANIM);
+            case ANIM_SHOOT -> state.setAndContinue(SHOOT_ANIM);
+            case ANIM_JUMP_ATTACK -> state.setAndContinue(JUMP_ANIM);
+            case ANIM_SPIN -> state.setAndContinue(SPIN_ANIM);
+            case ANIM_DEATH -> state.setAndContinue(DEATH_ANIM);
+            default -> state.setAndContinue(IDLE_ANIM);
+        };
+    }
+
+    @Override
+    public AnimatableInstanceCache getAnimatableInstanceCache() {
+        return this.geoCache;
+    }
+
+    @Override
+    public void tick() {
+        super.tick();
+        if (this.level().isClientSide) return;
+
+        if (this.shootCooldown > 0) this.shootCooldown--;
+        if (this.jumpCooldown > 0) this.jumpCooldown--;
+        if (this.spinCooldown > 0) this.spinCooldown--;
+
+        this.spinHitCooldowns.replaceAll((uuid, cd) -> cd - 1);
+        this.spinHitCooldowns.entrySet().removeIf(e -> e.getValue() <= 0);
+
+        if (this.isDeadOrDying()) {
+            this.setAnimationState(ANIM_DEATH);
+            return;
+        }
+
+        if (this.shootAnimTicks > 0) {
+            this.tickShootAnimation();
+        } else if (this.jumpAnimTicks > 0) {
+            this.tickJumpAnimation();
+        } else if (this.spinAnimTicks > 0) {
+            this.tickSpinAnimation();
+        } else {
+            this.updateIdleAnimation();
+        }
+
+        this.bossEvent.setProgress(this.getHealth() / this.getMaxHealth());
+    }
+
+    @Override
+    public void startSeenByPlayer(ServerPlayer player) {
+        super.startSeenByPlayer(player);
+        this.bossEvent.addPlayer(player);
+    }
+
+    @Override
+    public void stopSeenByPlayer(ServerPlayer player) {
+        super.stopSeenByPlayer(player);
+        this.bossEvent.removePlayer(player);
+    }
+
+    @Override
+    public boolean causeFallDamage(float fallDistance, float multiplier, DamageSource source) {
+        return false;
+    }
+
+    @Override
+    protected void checkFallDamage(double y, boolean onGround, net.minecraft.world.level.block.state.BlockState state, BlockPos pos) {
+    }
+
+    @Override
+    public boolean removeWhenFarAway(double distanceToClosestPlayer) {
+        return false;
+    }
+
+    @Override
+    public void addAdditionalSaveData(CompoundTag tag) {
+        super.addAdditionalSaveData(tag);
+        tag.putInt("AnimationState", this.getAnimationState());
+        tag.putInt("ShootCooldown", this.shootCooldown);
+        tag.putInt("JumpCooldown", this.jumpCooldown);
+        tag.putInt("SpinCooldown", this.spinCooldown);
+    }
+
+    @Override
+    public void readAdditionalSaveData(CompoundTag tag) {
+        super.readAdditionalSaveData(tag);
+        this.entityData.set(ANIMATION_STATE, tag.contains("AnimationState") ? tag.getInt("AnimationState") : ANIM_IDLE);
+        this.shootCooldown = tag.getInt("ShootCooldown");
+        this.jumpCooldown = tag.getInt("JumpCooldown");
+        this.spinCooldown = tag.getInt("SpinCooldown");
+    }
+
+    @Override
+    public void die(DamageSource damageSource) {
+        if (!this.level().isClientSide) {
+            this.setAnimationState(ANIM_DEATH);
+            this.shootAnimTicks = 0;
+            this.jumpAnimTicks = 0;
+            this.spinAnimTicks = 0;
+            this.setDeltaMovement(Vec3.ZERO);
+            this.getNavigation().stop();
+        }
+        super.die(damageSource);
+    }
+
+    @Override
+    protected void tickDeath() {
+        this.deathTime++;
+        if (this.deathTime == 1) {
+            this.setAnimationState(ANIM_DEATH);
+        }
+        if (this.deathTime >= DEATH_TICKS) {
+            this.remove(RemovalReason.KILLED);
+            this.dropExperience(this);
+        }
+    }
+
+    public int getAnimationState() {
+        return this.entityData.get(ANIMATION_STATE);
+    }
+
+    private void setAnimationState(int state) {
+        if (this.entityData.get(ANIMATION_STATE) != state) {
+            this.entityData.set(ANIMATION_STATE, state);
+        }
+    }
+
+    private void updateIdleAnimation() {
+        Vec3 vel = this.getDeltaMovement();
+        boolean moving = (vel.x * vel.x + vel.z * vel.z) > 0.0004D;
+        this.setAnimationState(moving ? ANIM_WALK : ANIM_IDLE);
+    }
+
+    private boolean isInAttackAnimation() {
+        return this.shootAnimTicks > 0 || this.jumpAnimTicks > 0 || this.spinAnimTicks > 0;
+    }
+
+    private void tickShootAnimation() {
+        this.setAnimationState(ANIM_SHOOT);
+        int elapsed = SHOOT_TOTAL_TICKS - this.shootAnimTicks;
+        if (this.shootUseWaterBombs) {
+            if (elapsed >= this.shootNextFireElapsed && this.shootNextFireElapsed <= SHOOT_FIRE_END_TICK) {
+                this.shootNextFireElapsed += SHOOT_FIRE_INTERVAL;
+                this.fireWaterBomb();
+            }
+        } else {
+            if (!this.shootBomberFired && elapsed >= SHOOT_BOMBER_TICK) {
+                this.shootBomberFired = true;
+                this.fireBomberBurst();
+            }
+        }
+        this.getNavigation().stop();
+        this.setDeltaMovement(this.getDeltaMovement().scale(0.85D));
+        if (this.getTarget() != null) {
+            this.getLookControl().setLookAt(this.getTarget(), 30.0F, 20.0F);
+        }
+        this.shootAnimTicks--;
+        if (this.shootAnimTicks <= 0) {
+            this.shootCooldown = 100 + this.random.nextInt(60);
+        }
+    }
+
+    private void tickJumpAnimation() {
+        this.setAnimationState(ANIM_JUMP_ATTACK);
+        int elapsed = JUMP_TOTAL_TICKS - this.jumpAnimTicks;
+        if (!this.jumpLaunched && elapsed >= JUMP_LAUNCH_TICK) {
+            this.jumpLaunched = true;
+            LivingEntity target = this.getTarget();
+            if (target != null) {
+                Vec3 toTarget = target.position().subtract(this.position()).normalize();
+                this.setDeltaMovement(toTarget.x * 0.6D, 0.85D, toTarget.z * 0.6D);
+                this.hasImpulse = true;
+            }
+        }
+        if (this.jumpLaunched && this.onGround() && elapsed > JUMP_LAUNCH_TICK + 3 && !this.shockwaveApplied) {
+            this.shockwaveApplied = true;
+            this.applyJumpShockwave();
+        }
+        this.jumpAnimTicks--;
+        if (this.jumpAnimTicks <= 0) {
+            this.jumpCooldown = 140 + this.random.nextInt(80);
+        }
+    }
+
+    private void tickSpinAnimation() {
+        this.setAnimationState(ANIM_SPIN);
+        int elapsed = SPIN_TOTAL_TICKS - this.spinAnimTicks;
+        this.getNavigation().stop();
+        this.setDeltaMovement(this.getDeltaMovement().multiply(0.7D, 1.0D, 0.7D));
+        if (elapsed >= SPIN_START_TICK && elapsed <= SPIN_END_TICK && elapsed % SPIN_HIT_INTERVAL == 0) {
+            this.applySpinDamage();
+        }
+        this.spinAnimTicks--;
+        if (this.spinAnimTicks <= 0) {
+            this.spinCooldown = 160 + this.random.nextInt(80);
+            this.spinHitCooldowns.clear();
+        }
+    }
+
+    private void fireWaterBomb() {
+        if (!(this.level() instanceof ServerLevel serverLevel)) return;
+        LivingEntity target = this.getTarget();
+        if (target == null) return;
+        WaterBombEntity bomb = new WaterBombEntity(this.level(), this);
+        bomb.moveTo(this.getX(), this.getEyeY(), this.getZ(), this.getYRot(), 0);
+        bomb.shootFromRotation(this, this.getXRot(), this.getYRot(), 0.0F, 1.4F, 1.5F);
+        serverLevel.addFreshEntity(bomb);
+    }
+
+    private void fireBomberBurst() {
+        if (!(this.level() instanceof ServerLevel serverLevel)) return;
+        LivingEntity target = this.getTarget();
+        if (target == null) return;
+        int count = 3;
+        for (int i = 0; i < count; i++) {
+            BomberEntity bomber = AntarchyObjects.BOMBER.get().create(this.level());
+            if (bomber == null) continue;
+            double spreadAngle = (i - count / 2.0D) * 20.0D;
+            double yaw = Math.toRadians(this.getYRot() + spreadAngle);
+            double vx = -Math.sin(yaw) * 1.2D;
+            double vy = 0.4D;
+            double vz = Math.cos(yaw) * 1.2D;
+            bomber.moveTo(this.getX() + vx * 0.5D, this.getEyeY(), this.getZ() + vz * 0.5D, this.getYRot(), 0);
+            bomber.setDeltaMovement(vx, vy, vz);
+            bomber.setTarget(target);
+            serverLevel.addFreshEntity(bomber);
+        }
+    }
+
+    private void applyJumpShockwave() {
+        if (!(this.level() instanceof ServerLevel serverLevel)) return;
+        AABB shockArea = this.getBoundingBox().inflate(JUMP_SHOCKWAVE_RADIUS, 2.0D, JUMP_SHOCKWAVE_RADIUS);
+        List<LivingEntity> victims = this.level().getEntitiesOfClass(LivingEntity.class, shockArea, this::canTargetEntity);
+        float damage = (float) AntarchySettings.toreterrorJumpAttackDamage();
+        for (LivingEntity victim : victims) {
+            victim.hurt(this.damageSources().mobAttack(this), damage);
+            Vec3 knockDir = victim.position().subtract(this.position()).normalize().add(0, 0.4D, 0);
+            double knockback = AntarchySettings.toreterrorJumpAttackKnockback();
+            victim.push(knockDir.x * knockback, 0.5D, knockDir.z * knockback);
+            victim.hurtMarked = true;
+        }
+        this.playSound(SoundEvents.GENERIC_EXPLODE.value(), 1.5F, 0.75F);
+        serverLevel.sendParticles(net.minecraft.core.particles.ParticleTypes.EXPLOSION, this.getX(), this.getY() + 0.5D, this.getZ(), 3, 1.0D, 0.3D, 1.0D, 0.0D);
+        serverLevel.sendParticles(net.minecraft.core.particles.ParticleTypes.SPLASH, this.getX(), this.getY() + 0.5D, this.getZ(), 40, 2.0D, 0.5D, 2.0D, 0.2D);
+    }
+
+    private void applySpinDamage() {
+        if (!(this.level() instanceof ServerLevel)) return;
+        AABB spinArea = this.getBoundingBox().inflate(SPIN_RADIUS, 2.0D, SPIN_RADIUS);
+        List<LivingEntity> victims = this.level().getEntitiesOfClass(LivingEntity.class, spinArea, this::canTargetEntity);
+        float damage = (float) AntarchySettings.toreterrorSpinDamage();
+        double knockback = AntarchySettings.toreterrorSpinKnockback();
+        for (LivingEntity victim : victims) {
+            UUID id = victim.getUUID();
+            if (this.spinHitCooldowns.getOrDefault(id, 0) > 0) continue;
+            if (victim.hurt(this.damageSources().mobAttack(this), damage)) {
+                this.spinHitCooldowns.put(id, 20);
+                Vec3 knockDir = victim.position().subtract(this.position()).normalize();
+                victim.push(knockDir.x * knockback, 0.35D, knockDir.z * knockback);
+                victim.hurtMarked = true;
+            }
+        }
+    }
+
+    private boolean canTargetEntity(@Nullable LivingEntity entity) {
+        if (entity == null || !entity.isAlive() || entity == this || entity.getType() == this.getType()) return false;
+        if (entity instanceof Player player) {
+            return !player.isCreative() && !player.isSpectator() && this.level().getDifficulty() != Difficulty.PEACEFUL;
+        }
+        return entity instanceof Mob && entity.isAttackable();
+    }
+
+    private final class ToreterrorRangedGoal extends Goal {
+        ToreterrorRangedGoal() {
+            this.setFlags(EnumSet.of(Flag.MOVE, Flag.LOOK));
+        }
+
+        @Override
+        public boolean canUse() {
+            LivingEntity target = ToreterrorEntity.this.getTarget();
+            if (target == null || ToreterrorEntity.this.isInAttackAnimation()) return false;
+            if (ToreterrorEntity.this.shootCooldown > 0) return false;
+            double distSqr = ToreterrorEntity.this.distanceToSqr(target);
+            return distSqr >= RANGED_MIN_RANGE_SQR && distSqr <= RANGED_MAX_RANGE_SQR
+                    && ToreterrorEntity.this.hasLineOfSight(target);
+        }
+
+        @Override
+        public void start() {
+            ToreterrorEntity.this.shootAnimTicks = SHOOT_TOTAL_TICKS;
+            ToreterrorEntity.this.shootUseWaterBombs = ToreterrorEntity.this.random.nextFloat() < (float) AntarchySettings.toreterrorRangedWaterBombChance();
+            ToreterrorEntity.this.shootNextFireElapsed = SHOOT_FIRE_START_TICK;
+            ToreterrorEntity.this.shootBomberFired = false;
+        }
+
+        @Override
+        public boolean canContinueToUse() {
+            return ToreterrorEntity.this.shootAnimTicks > 0;
+        }
+
+        @Override
+        public void stop() {
+            ToreterrorEntity.this.shootAnimTicks = 0;
+        }
+    }
+
+    private final class ToreterrorJumpGoal extends Goal {
+        ToreterrorJumpGoal() {
+            this.setFlags(EnumSet.of(Flag.MOVE, Flag.JUMP));
+        }
+
+        @Override
+        public boolean canUse() {
+            LivingEntity target = ToreterrorEntity.this.getTarget();
+            if (target == null || ToreterrorEntity.this.isInAttackAnimation()) return false;
+            if (ToreterrorEntity.this.jumpCooldown > 0) return false;
+            double distSqr = ToreterrorEntity.this.distanceToSqr(target);
+            return distSqr <= RANGED_MAX_RANGE_SQR && ToreterrorEntity.this.onGround();
+        }
+
+        @Override
+        public void start() {
+            ToreterrorEntity.this.jumpAnimTicks = JUMP_TOTAL_TICKS;
+            ToreterrorEntity.this.jumpLaunched = false;
+            ToreterrorEntity.this.shockwaveApplied = false;
+        }
+
+        @Override
+        public boolean canContinueToUse() {
+            return ToreterrorEntity.this.jumpAnimTicks > 0;
+        }
+
+        @Override
+        public void stop() {
+            ToreterrorEntity.this.jumpAnimTicks = 0;
+        }
+    }
+
+    private final class ToreterrorSpinGoal extends Goal {
+        ToreterrorSpinGoal() {
+            this.setFlags(EnumSet.of(Flag.MOVE));
+        }
+
+        @Override
+        public boolean canUse() {
+            LivingEntity target = ToreterrorEntity.this.getTarget();
+            if (target == null || ToreterrorEntity.this.isInAttackAnimation()) return false;
+            if (ToreterrorEntity.this.spinCooldown > 0) return false;
+            return ToreterrorEntity.this.distanceToSqr(target) <= MELEE_RANGE_SQR && ToreterrorEntity.this.onGround();
+        }
+
+        @Override
+        public void start() {
+            ToreterrorEntity.this.spinAnimTicks = SPIN_TOTAL_TICKS;
+        }
+
+        @Override
+        public boolean canContinueToUse() {
+            return ToreterrorEntity.this.spinAnimTicks > 0;
+        }
+
+        @Override
+        public void stop() {
+            ToreterrorEntity.this.spinAnimTicks = 0;
+        }
+    }
+}

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

@@ -0,0 +1,110 @@
+package com.craisinlord.antarchy.content.entity;
+
+import com.craisinlord.antarchy.config.AntarchySettings;
+import com.craisinlord.antarchy.content.AntarchyObjects;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.particles.ParticleTypes;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.projectile.ThrowableProjectile;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.LiquidBlock;
+import net.minecraft.world.level.material.Fluids;
+import net.minecraft.world.phys.BlockHitResult;
+import net.minecraft.world.phys.EntityHitResult;
+import net.minecraft.world.phys.Vec3;
+
+import net.minecraft.network.syncher.SynchedEntityData;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+public class WaterBombEntity extends ThrowableProjectile {
+
+    private int lifetimeTicks;
+    private final Map<UUID, Integer> hitCooldowns = new HashMap<>();
+
+    public WaterBombEntity(EntityType<? extends WaterBombEntity> entityType, Level level) {
+        super(entityType, level);
+        this.lifetimeTicks = AntarchySettings.waterBombLifetimeTicks();
+    }
+
+    public WaterBombEntity(Level level, LivingEntity owner) {
+        super(AntarchyObjects.WATER_BOMB.get(), owner, level);
+        this.lifetimeTicks = AntarchySettings.waterBombLifetimeTicks();
+    }
+
+    @Override
+    protected void defineSynchedData(SynchedEntityData.Builder builder) {
+    }
+
+    @Override
+    protected double getDefaultGravity() {
+        return AntarchySettings.waterBombGravity();
+    }
+
+    @Override
+    public void tick() {
+        super.tick();
+
+        this.hitCooldowns.replaceAll((uuid, cd) -> cd - 1);
+        this.hitCooldowns.entrySet().removeIf(e -> e.getValue() <= 0);
+
+        if (this.level() instanceof ServerLevel serverLevel) {
+            serverLevel.sendParticles(ParticleTypes.DRIPPING_WATER, this.getX(), this.getY(), this.getZ(), 3, 0.15D, 0.15D, 0.15D, 0.0D);
+            serverLevel.sendParticles(ParticleTypes.SPLASH, this.getX(), this.getY(), this.getZ(), 2, 0.1D, 0.1D, 0.1D, 0.01D);
+        }
+
+        this.lifetimeTicks--;
+        if (this.lifetimeTicks <= 0) {
+            this.discard();
+        }
+    }
+
+    @Override
+    protected void onHitEntity(EntityHitResult result) {
+        Entity entity = result.getEntity();
+        if (entity == this.getOwner()) return;
+        if (!(entity instanceof LivingEntity living)) return;
+
+        UUID id = entity.getUUID();
+        if (this.hitCooldowns.getOrDefault(id, 0) > 0) return;
+
+        float damage = (float) AntarchySettings.waterBombDamage();
+        if (living.hurt(this.damageSources().thrown(this, this.getOwner()), damage)) {
+            this.hitCooldowns.put(id, 15);
+            Vec3 knockDir = living.position().subtract(this.position()).normalize();
+            double knockback = AntarchySettings.waterBombKnockback();
+            living.push(knockDir.x * knockback, 0.3D, knockDir.z * knockback);
+            living.hurtMarked = true;
+        }
+    }
+
+    @Override
+    protected void onHitBlock(BlockHitResult result) {
+        BlockPos hitPos = result.getBlockPos().relative(result.getDirection());
+        Level level = this.level();
+        if (level.isEmptyBlock(hitPos) && level.getBlockState(hitPos.below()).isSolid()) {
+            level.setBlock(hitPos, Blocks.WATER.defaultBlockState().setValue(LiquidBlock.LEVEL, 2), 3);
+            level.scheduleTick(hitPos, Fluids.WATER, 2);
+        }
+        this.discard();
+    }
+
+    @Override
+    public void addAdditionalSaveData(CompoundTag tag) {
+        super.addAdditionalSaveData(tag);
+        tag.putInt("LifetimeTicks", this.lifetimeTicks);
+    }
+
+    @Override
+    public void readAdditionalSaveData(CompoundTag tag) {
+        super.readAdditionalSaveData(tag);
+        this.lifetimeTicks = tag.contains("LifetimeTicks") ? tag.getInt("LifetimeTicks") : AntarchySettings.waterBombLifetimeTicks();
+    }
+}

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

@@ -0,0 +1,12 @@
+package com.craisinlord.antarchy.content.item;
+
+import net.minecraft.core.Holder;
+import net.minecraft.world.item.ArmorItem;
+import net.minecraft.world.item.ArmorMaterial;
+
+public class PrimordialArmorItem extends ArmorItem {
+
+    public PrimordialArmorItem(Holder<ArmorMaterial> material, Type type, Properties properties) {
+        super(material, type, properties);
+    }
+}

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

@@ -0,0 +1,140 @@
+package com.craisinlord.antarchy.content.item;
+
+import com.craisinlord.antarchy.content.AntarchySoundEvents;
+import com.craisinlord.antarchy.content.client.model.ResourceBackedGeoItemModel;
+import com.craisinlord.antarchy.content.entity.WaterBombEntity;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.stats.Stats;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.InteractionResultHolder;
+import net.minecraft.world.entity.EquipmentSlot;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.entity.projectile.Projectile;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.ProjectileWeaponItem;
+import net.minecraft.world.item.UseAnim;
+import net.minecraft.world.level.Level;
+import software.bernie.geckolib.animatable.GeoItem;
+import software.bernie.geckolib.animatable.client.GeoRenderProvider;
+import software.bernie.geckolib.animatable.instance.AnimatableInstanceCache;
+import software.bernie.geckolib.animation.AnimatableManager;
+import software.bernie.geckolib.animation.AnimationController;
+import software.bernie.geckolib.animation.PlayState;
+import software.bernie.geckolib.animation.RawAnimation;
+import com.craisinlord.antarchy.content.client.renderer.AnimatedHeldItemRenderer;
+import software.bernie.geckolib.util.GeckoLibUtil;
+
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+
+public class WaterCannonItem extends ProjectileWeaponItem implements GeoItem {
+
+    private static final String FIRE_CONTROLLER = "fire_controller";
+    private static final String FIRE_ANIMATION = "water_cannon_fire";
+    private static final Predicate<ItemStack> NO_PROJECTILES = stack -> false;
+    private static final int FIRE_INTERVAL_TICKS = 8;
+    private static final ResourceLocation MODEL_LOCATION = ResourceLocation.fromNamespaceAndPath("antarchy", "geo/water_cannon.geo.json");
+    private static final ResourceLocation TEXTURE_LOCATION = ResourceLocation.fromNamespaceAndPath("antarchy", "textures/models/item/water_cannon.png");
+    private static final ResourceLocation ANIMATION_LOCATION = ResourceLocation.fromNamespaceAndPath("antarchy", "animations/water_cannon.animation.json");
+
+    private final AnimatableInstanceCache geoCache = GeckoLibUtil.createInstanceCache(this);
+
+    public WaterCannonItem(Properties properties) {
+        super(properties);
+        GeoItem.registerSyncedAnimatable(this);
+    }
+
+    @Override
+    public int getUseDuration(ItemStack stack, LivingEntity entity) {
+        return 72000;
+    }
+
+    @Override
+    public InteractionResultHolder<ItemStack> use(Level level, Player player, InteractionHand usedHand) {
+        player.startUsingItem(usedHand);
+        return InteractionResultHolder.consume(player.getItemInHand(usedHand));
+    }
+
+    @Override
+    public void onUseTick(Level level, LivingEntity livingEntity, ItemStack stack, int remainingUseTicks) {
+        if (!(livingEntity instanceof Player player)) return;
+        int usedTicks = getUseDuration(stack, livingEntity) - remainingUseTicks;
+        if (usedTicks % FIRE_INTERVAL_TICKS != 0) return;
+
+        level.playSound(null, player.getX(), player.getY(), player.getZ(),
+                AntarchySoundEvents.SQUIDZOOKA_FIRE.get(), SoundSource.PLAYERS,
+                0.8F, 0.9F + level.getRandom().nextFloat() * 0.2F);
+
+        if (!level.isClientSide()) {
+            WaterBombEntity bomb = new WaterBombEntity(level, player);
+            bomb.moveTo(player.getX(), player.getEyeY() - 0.1D, player.getZ(), player.getYRot(), player.getXRot());
+            bomb.shootFromRotation(player, player.getXRot(), player.getYRot(), 0.0F, 1.5F, 1.0F);
+            level.addFreshEntity(bomb);
+            stack.hurtAndBreak(1, player, player.getUsedItemHand() == InteractionHand.MAIN_HAND ? EquipmentSlot.MAINHAND : EquipmentSlot.OFFHAND);
+            if (level instanceof ServerLevel serverLevel) {
+                triggerFireAnimation(serverLevel, player, stack);
+            }
+        }
+
+        player.awardStat(Stats.ITEM_USED.get(this));
+    }
+
+    @Override
+    public UseAnim getUseAnimation(ItemStack stack) {
+        return UseAnim.NONE;
+    }
+
+    @Override
+    public Predicate<ItemStack> getSupportedHeldProjectiles() {
+        return NO_PROJECTILES;
+    }
+
+    @Override
+    public Predicate<ItemStack> getAllSupportedProjectiles() {
+        return NO_PROJECTILES;
+    }
+
+    @Override
+    public int getDefaultProjectileRange() {
+        return 0;
+    }
+
+    @Override
+    protected void shootProjectile(LivingEntity livingEntity, Projectile projectile, int i, float velocity, float inaccuracy, float angle, LivingEntity target) {
+        projectile.shootFromRotation(livingEntity, livingEntity.getXRot(), livingEntity.getYRot(), angle, velocity, inaccuracy);
+    }
+
+    @Override
+    public void registerControllers(AnimatableManager.ControllerRegistrar controllers) {
+        controllers.add(new AnimationController<>(this, FIRE_CONTROLLER, state -> PlayState.STOP)
+                .triggerableAnim(FIRE_ANIMATION, RawAnimation.begin().thenPlay(FIRE_ANIMATION)));
+    }
+
+    @Override
+    public AnimatableInstanceCache getAnimatableInstanceCache() {
+        return this.geoCache;
+    }
+
+    @Override
+    public void createGeoRenderer(Consumer<GeoRenderProvider> consumer) {
+        consumer.accept(new GeoRenderProvider() {
+            private AnimatedHeldItemRenderer<WaterCannonItem> renderer;
+
+            @Override
+            public net.minecraft.client.renderer.BlockEntityWithoutLevelRenderer getGeoItemRenderer() {
+                if (this.renderer == null) {
+                    this.renderer = new AnimatedHeldItemRenderer<>(new ResourceBackedGeoItemModel<>(MODEL_LOCATION, TEXTURE_LOCATION, ANIMATION_LOCATION));
+                }
+                return this.renderer;
+            }
+        });
+    }
+
+    private void triggerFireAnimation(ServerLevel level, LivingEntity livingEntity, ItemStack stack) {
+        long animatableId = GeoItem.getOrAssignId(stack, level);
+        triggerAnim(livingEntity, animatableId, FIRE_CONTROLLER, FIRE_ANIMATION);
+    }
+}

common/src/main/resources/assets/antarchy/animations/water_cannon.animation.json

@@ -0,0 +1,10 @@
+{
+  "format_version": "1.8.0",
+  "animations": {
+    "water_cannon_fire": {
+      "animation_length": 0.5,
+      "loop": false,
+      "bones": {}
+    }
+  }
+}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,14 @@
+{
+  "variants": {
+    "type=double": {
+      "model": "antarchy:block/polished_shellstone"
+    },
+    "type=bottom": {
+      "model": "antarchy:block/polished_shellstone_slab"
+    },
+    "type=top": {
+      "model": "antarchy:block/polished_shellstone_slab_top"
+    }
+  }
+}
+

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

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

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

@@ -0,0 +1,41 @@
+{
+  "multipart": [
+    {
+      "when": { "up": "true" },
+      "apply": { "model": "antarchy:block/polished_shellstone_wall_post" }
+    },
+    {
+      "when": { "north": "low" },
+      "apply": { "model": "antarchy:block/polished_shellstone_wall_side", "uvlock": true }
+    },
+    {
+      "when": { "east": "low" },
+      "apply": { "model": "antarchy:block/polished_shellstone_wall_side", "y": 90, "uvlock": true }
+    },
+    {
+      "when": { "south": "low" },
+      "apply": { "model": "antarchy:block/polished_shellstone_wall_side", "y": 180, "uvlock": true }
+    },
+    {
+      "when": { "west": "low" },
+      "apply": { "model": "antarchy:block/polished_shellstone_wall_side", "y": 270, "uvlock": true }
+    },
+    {
+      "when": { "north": "tall" },
+      "apply": { "model": "antarchy:block/polished_shellstone_wall_side_tall", "uvlock": true }
+    },
+    {
+      "when": { "east": "tall" },
+      "apply": { "model": "antarchy:block/polished_shellstone_wall_side_tall", "y": 90, "uvlock": true }
+    },
+    {
+      "when": { "south": "tall" },
+      "apply": { "model": "antarchy:block/polished_shellstone_wall_side_tall", "y": 180, "uvlock": true }
+    },
+    {
+      "when": { "west": "tall" },
+      "apply": { "model": "antarchy:block/polished_shellstone_wall_side_tall", "y": 270, "uvlock": true }
+    }
+  ]
+}
+

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

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

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

@@ -0,0 +1,14 @@
+{
+  "variants": {
+    "type=double": {
+      "model": "antarchy:block/shellstone_bricks"
+    },
+    "type=bottom": {
+      "model": "antarchy:block/shellstone_brick_slab"
+    },
+    "type=top": {
+      "model": "antarchy:block/shellstone_brick_slab_top"
+    }
+  }
+}
+

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

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

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

@@ -0,0 +1,41 @@
+{
+  "multipart": [
+    {
+      "when": { "up": "true" },
+      "apply": { "model": "antarchy:block/shellstone_brick_wall_post" }
+    },
+    {
+      "when": { "north": "low" },
+      "apply": { "model": "antarchy:block/shellstone_brick_wall_side", "uvlock": true }
+    },
+    {
+      "when": { "east": "low" },
+      "apply": { "model": "antarchy:block/shellstone_brick_wall_side", "y": 90, "uvlock": true }
+    },
+    {
+      "when": { "south": "low" },
+      "apply": { "model": "antarchy:block/shellstone_brick_wall_side", "y": 180, "uvlock": true }
+    },
+    {
+      "when": { "west": "low" },
+      "apply": { "model": "antarchy:block/shellstone_brick_wall_side", "y": 270, "uvlock": true }
+    },
+    {
+      "when": { "north": "tall" },
+      "apply": { "model": "antarchy:block/shellstone_brick_wall_side_tall", "uvlock": true }
+    },
+    {
+      "when": { "east": "tall" },
+      "apply": { "model": "antarchy:block/shellstone_brick_wall_side_tall", "y": 90, "uvlock": true }
+    },
+    {
+      "when": { "south": "tall" },
+      "apply": { "model": "antarchy:block/shellstone_brick_wall_side_tall", "y": 180, "uvlock": true }
+    },
+    {
+      "when": { "west": "tall" },
+      "apply": { "model": "antarchy:block/shellstone_brick_wall_side_tall", "y": 270, "uvlock": true }
+    }
+  ]
+}
+

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

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

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

@@ -0,0 +1,14 @@
+{
+  "variants": {
+    "type=double": {
+      "model": "antarchy:block/shellstone"
+    },
+    "type=bottom": {
+      "model": "antarchy:block/shellstone_slab"
+    },
+    "type=top": {
+      "model": "antarchy:block/shellstone_slab_top"
+    }
+  }
+}
+

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

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

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

@@ -0,0 +1,41 @@
+{
+  "multipart": [
+    {
+      "when": { "up": "true" },
+      "apply": { "model": "antarchy:block/shellstone_wall_post" }
+    },
+    {
+      "when": { "north": "low" },
+      "apply": { "model": "antarchy:block/shellstone_wall_side", "uvlock": true }
+    },
+    {
+      "when": { "east": "low" },
+      "apply": { "model": "antarchy:block/shellstone_wall_side", "y": 90, "uvlock": true }
+    },
+    {
+      "when": { "south": "low" },
+      "apply": { "model": "antarchy:block/shellstone_wall_side", "y": 180, "uvlock": true }
+    },
+    {
+      "when": { "west": "low" },
+      "apply": { "model": "antarchy:block/shellstone_wall_side", "y": 270, "uvlock": true }
+    },
+    {
+      "when": { "north": "tall" },
+      "apply": { "model": "antarchy:block/shellstone_wall_side_tall", "uvlock": true }
+    },
+    {
+      "when": { "east": "tall" },
+      "apply": { "model": "antarchy:block/shellstone_wall_side_tall", "y": 90, "uvlock": true }
+    },
+    {
+      "when": { "south": "tall" },
+      "apply": { "model": "antarchy:block/shellstone_wall_side_tall", "y": 180, "uvlock": true }
+    },
+    {
+      "when": { "west": "tall" },
+      "apply": { "model": "antarchy:block/shellstone_wall_side_tall", "y": 270, "uvlock": true }
+    }
+  ]
+}
+

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

@@ -0,0 +1,95 @@
+{
+	"format_version": "1.21.110",
+	"minecraft:geometry": [
+		{
+			"description": {
+				"identifier": "geometry.water_cannon - Converted",
+				"texture_width": 64,
+				"texture_height": 64,
+				"visible_bounds_width": 4,
+				"visible_bounds_height": 2.5,
+				"visible_bounds_offset": [0, 0.75, 0]
+			},
+			"bones": [
+				{
+					"name": "water_cannon",
+					"pivot": [1, 2.5, -24],
+					"cubes": [
+						{
+							"origin": [-3.5, 10, -24],
+							"size": [7, 7, 14],
+							"uv": {
+								"north": {"uv": [37, 19], "uv_size": [7, 7]},
+								"east": {"uv": [0, 14], "uv_size": [14, 7]},
+								"south": {"uv": [37, 26], "uv_size": [7, 7]},
+								"west": {"uv": [14, 14], "uv_size": [-14, 7]},
+								"up": {"uv": [0, 21], "uv_size": [7, 14]},
+								"down": {"uv": [7, 35], "uv_size": [7, -14]}
+							}
+						},
+						{
+							"origin": [-3.5, 3, -24],
+							"size": [7, 7, 0],
+							"uv": {
+								"north": {"uv": [57, 12], "uv_size": [7, 7]},
+								"east": {"uv": [57, 12], "uv_size": [7, 7]},
+								"south": {"uv": [64, 12], "uv_size": [-7, 7]},
+								"west": {"uv": [57, 12], "uv_size": [7, 7]},
+								"up": {"uv": [64, 19], "uv_size": [-7, -7]},
+								"down": {"uv": [64, 19], "uv_size": [-7, -7]}
+							}
+						},
+						{
+							"origin": [-4.5, 7, -10],
+							"size": [9, 11, 5],
+							"uv": {
+								"north": {"uv": [49, 0], "uv_size": [9, 11]},
+								"east": {"uv": [19, 36], "uv_size": [5, 11]},
+								"south": {"uv": [49, 0], "uv_size": [9, 11]},
+								"west": {"uv": [24, 36], "uv_size": [-5, 11]},
+								"up": {"uv": [29, 37], "uv_size": [9, 5]},
+								"down": {"uv": [29, 42], "uv_size": [9, -5]}
+							}
+						},
+						{
+							"origin": [-2.5, 11, -5],
+							"size": [5, 5, 18],
+							"uv": {
+								"north": {"uv": [42, 38], "uv_size": [5, 5]},
+								"east": {"uv": [28, 14], "uv_size": [18, 5]},
+								"south": {"uv": [42, 43], "uv_size": [5, 5]},
+								"west": {"uv": [46, 14], "uv_size": [-18, 5]},
+								"up": {"uv": [32, 19], "uv_size": [5, 18]},
+								"down": {"uv": [0, 53], "uv_size": [5, -18]}
+							}
+						},
+						{
+							"origin": [0, 4, -24],
+							"size": [0, 7, 41],
+							"uv": {
+								"north": {"uv": [0, 0], "uv_size": [0, 7]},
+								"east": {"uv": [0, 0], "uv_size": [41, 7]},
+								"south": {"uv": [0, 0], "uv_size": [0, 7]},
+								"west": {"uv": [0, 7], "uv_size": [41, 7]},
+								"up": {"uv": [0, 0], "uv_size": [0, 41]},
+								"down": {"uv": [0, 41], "uv_size": [0, -41]}
+							}
+						},
+						{
+							"origin": [-3.5, 8, 13],
+							"size": [7, 9, 4],
+							"uv": {
+								"north": {"uv": [5, 35], "uv_size": [7, 9]},
+								"east": {"uv": [38, 38], "uv_size": [4, 9]},
+								"south": {"uv": [12, 36], "uv_size": [7, 9]},
+								"west": {"uv": [41, 0], "uv_size": [4, 9]},
+								"up": {"uv": [41, 9], "uv_size": [7, 4]},
+								"down": {"uv": [29, 46], "uv_size": [7, -4]}
+							}
+						}
+					]
+				}
+			]
+		}
+	]
+}

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

@@ -0,0 +1,7 @@
+{
+  "parent": "minecraft:block/cube_all",
+  "textures": {
+    "all": "antarchy:block/shellstone/chiseled_shellstone"
+  }
+}
+

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

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

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

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

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

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

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

@@ -0,0 +1,7 @@
+{
+  "parent": "minecraft:block/cube_all",
+  "textures": {
+    "all": "antarchy:block/shellstone/polished_shellstone"
+  }
+}
+

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

@@ -0,0 +1,9 @@
+{
+  "parent": "minecraft:block/slab",
+  "textures": {
+    "bottom": "antarchy:block/shellstone/polished_shellstone",
+    "side": "antarchy:block/shellstone/polished_shellstone",
+    "top": "antarchy:block/shellstone/polished_shellstone"
+  }
+}
+

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

@@ -0,0 +1,9 @@
+{
+  "parent": "minecraft:block/slab_top",
+  "textures": {
+    "bottom": "antarchy:block/shellstone/polished_shellstone",
+    "side": "antarchy:block/shellstone/polished_shellstone",
+    "top": "antarchy:block/shellstone/polished_shellstone"
+  }
+}
+

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

@@ -0,0 +1,9 @@
+{
+  "parent": "minecraft:block/stairs",
+  "textures": {
+    "bottom": "antarchy:block/shellstone/polished_shellstone",
+    "side": "antarchy:block/shellstone/polished_shellstone",
+    "top": "antarchy:block/shellstone/polished_shellstone"
+  }
+}
+

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

@@ -0,0 +1,9 @@
+{
+  "parent": "minecraft:block/inner_stairs",
+  "textures": {
+    "bottom": "antarchy:block/shellstone/polished_shellstone",
+    "side": "antarchy:block/shellstone/polished_shellstone",
+    "top": "antarchy:block/shellstone/polished_shellstone"
+  }
+}
+

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

@@ -0,0 +1,9 @@
+{
+  "parent": "minecraft:block/outer_stairs",
+  "textures": {
+    "bottom": "antarchy:block/shellstone/polished_shellstone",
+    "side": "antarchy:block/shellstone/polished_shellstone",
+    "top": "antarchy:block/shellstone/polished_shellstone"
+  }
+}
+

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

@@ -0,0 +1,7 @@
+{
+  "parent": "minecraft:block/wall_inventory",
+  "textures": {
+    "wall": "antarchy:block/shellstone/polished_shellstone"
+  }
+}
+

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

@@ -0,0 +1,7 @@
+{
+  "parent": "minecraft:block/template_wall_post",
+  "textures": {
+    "wall": "antarchy:block/shellstone/polished_shellstone"
+  }
+}
+

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

@@ -0,0 +1,7 @@
+{
+  "parent": "minecraft:block/template_wall_side",
+  "textures": {
+    "wall": "antarchy:block/shellstone/polished_shellstone"
+  }
+}
+

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

@@ -0,0 +1,7 @@
+{
+  "parent": "minecraft:block/template_wall_side_tall",
+  "textures": {
+    "wall": "antarchy:block/shellstone/polished_shellstone"
+  }
+}
+

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

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

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

@@ -0,0 +1,9 @@
+{
+  "parent": "minecraft:block/slab",
+  "textures": {
+    "bottom": "antarchy:block/shellstone/shellstone_bricks",
+    "side": "antarchy:block/shellstone/shellstone_bricks",
+    "top": "antarchy:block/shellstone/shellstone_bricks"
+  }
+}
+

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

@@ -0,0 +1,9 @@
+{
+  "parent": "minecraft:block/slab_top",
+  "textures": {
+    "bottom": "antarchy:block/shellstone/shellstone_bricks",
+    "side": "antarchy:block/shellstone/shellstone_bricks",
+    "top": "antarchy:block/shellstone/shellstone_bricks"
+  }
+}
+

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

@@ -0,0 +1,9 @@
+{
+  "parent": "minecraft:block/stairs",
+  "textures": {
+    "bottom": "antarchy:block/shellstone/shellstone_bricks",
+    "side": "antarchy:block/shellstone/shellstone_bricks",
+    "top": "antarchy:block/shellstone/shellstone_bricks"
+  }
+}
+

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

@@ -0,0 +1,9 @@
+{
+  "parent": "minecraft:block/inner_stairs",
+  "textures": {
+    "bottom": "antarchy:block/shellstone/shellstone_bricks",
+    "side": "antarchy:block/shellstone/shellstone_bricks",
+    "top": "antarchy:block/shellstone/shellstone_bricks"
+  }
+}
+

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

@@ -0,0 +1,9 @@
+{
+  "parent": "minecraft:block/outer_stairs",
+  "textures": {
+    "bottom": "antarchy:block/shellstone/shellstone_bricks",
+    "side": "antarchy:block/shellstone/shellstone_bricks",
+    "top": "antarchy:block/shellstone/shellstone_bricks"
+  }
+}
+

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

@@ -0,0 +1,7 @@
+{
+  "parent": "minecraft:block/wall_inventory",
+  "textures": {
+    "wall": "antarchy:block/shellstone/shellstone_bricks"
+  }
+}
+

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

@@ -0,0 +1,7 @@
+{
+  "parent": "minecraft:block/template_wall_post",
+  "textures": {
+    "wall": "antarchy:block/shellstone/shellstone_bricks"
+  }
+}
+

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

@@ -0,0 +1,7 @@
+{
+  "parent": "minecraft:block/template_wall_side",
+  "textures": {
+    "wall": "antarchy:block/shellstone/shellstone_bricks"
+  }
+}
+

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

@@ -0,0 +1,7 @@
+{
+  "parent": "minecraft:block/template_wall_side_tall",
+  "textures": {
+    "wall": "antarchy:block/shellstone/shellstone_bricks"
+  }
+}
+

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

@@ -0,0 +1,7 @@
+{
+  "parent": "minecraft:block/cube_all",
+  "textures": {
+    "all": "antarchy:block/shellstone/shellstone_bricks"
+  }
+}
+

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

@@ -0,0 +1,9 @@
+{
+  "parent": "minecraft:block/slab",
+  "textures": {
+    "bottom": "antarchy:block/shellstone/shellstone",
+    "side": "antarchy:block/shellstone/shellstone",
+    "top": "antarchy:block/shellstone/shellstone"
+  }
+}
+

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

@@ -0,0 +1,9 @@
+{
+  "parent": "minecraft:block/slab_top",
+  "textures": {
+    "bottom": "antarchy:block/shellstone/shellstone",
+    "side": "antarchy:block/shellstone/shellstone",
+    "top": "antarchy:block/shellstone/shellstone"
+  }
+}
+

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

@@ -0,0 +1,9 @@
+{
+  "parent": "minecraft:block/stairs",
+  "textures": {
+    "bottom": "antarchy:block/shellstone/shellstone",
+    "side": "antarchy:block/shellstone/shellstone",
+    "top": "antarchy:block/shellstone/shellstone"
+  }
+}
+

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

@@ -0,0 +1,9 @@
+{
+  "parent": "minecraft:block/inner_stairs",
+  "textures": {
+    "bottom": "antarchy:block/shellstone/shellstone",
+    "side": "antarchy:block/shellstone/shellstone",
+    "top": "antarchy:block/shellstone/shellstone"
+  }
+}
+

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

@@ -0,0 +1,9 @@
+{
+  "parent": "minecraft:block/outer_stairs",
+  "textures": {
+    "bottom": "antarchy:block/shellstone/shellstone",
+    "side": "antarchy:block/shellstone/shellstone",
+    "top": "antarchy:block/shellstone/shellstone"
+  }
+}
+

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

@@ -0,0 +1,7 @@
+{
+  "parent": "minecraft:block/wall_inventory",
+  "textures": {
+    "wall": "antarchy:block/shellstone/shellstone"
+  }
+}
+

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

@@ -0,0 +1,7 @@
+{
+  "parent": "minecraft:block/template_wall_post",
+  "textures": {
+    "wall": "antarchy:block/shellstone/shellstone"
+  }
+}
+

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

@@ -0,0 +1,7 @@
+{
+  "parent": "minecraft:block/template_wall_side",
+  "textures": {
+    "wall": "antarchy:block/shellstone/shellstone"
+  }
+}
+

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

@@ -0,0 +1,7 @@
+{
+  "parent": "minecraft:block/template_wall_side_tall",
+  "textures": {
+    "wall": "antarchy:block/shellstone/shellstone"
+  }
+}
+

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,20 @@
+{
+  "type": "minecraft:block",
+  "pools": [
+    {
+      "rolls": 1,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "name": "antarchy:chiseled_shellstone"
+        }
+      ],
+      "conditions": [
+        {
+          "condition": "minecraft:survives_explosion"
+        }
+      ]
+    }
+  ],
+  "random_sequence": "antarchy:blocks/chiseled_shellstone"
+}

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

@@ -0,0 +1,20 @@
+{
+  "type": "minecraft:block",
+  "pools": [
+    {
+      "rolls": 1,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "name": "antarchy:cracked_shellstone_bricks"
+        }
+      ],
+      "conditions": [
+        {
+          "condition": "minecraft:survives_explosion"
+        }
+      ]
+    }
+  ],
+  "random_sequence": "antarchy:blocks/cracked_shellstone_bricks"
+}

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

@@ -0,0 +1,20 @@
+{
+  "type": "minecraft:block",
+  "pools": [
+    {
+      "rolls": 1,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "name": "antarchy:mossy_shellstone_bricks"
+        }
+      ],
+      "conditions": [
+        {
+          "condition": "minecraft:survives_explosion"
+        }
+      ]
+    }
+  ],
+  "random_sequence": "antarchy:blocks/mossy_shellstone_bricks"
+}

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

@@ -0,0 +1,20 @@
+{
+  "type": "minecraft:block",
+  "pools": [
+    {
+      "rolls": 1,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "name": "antarchy:polished_shellstone"
+        }
+      ],
+      "conditions": [
+        {
+          "condition": "minecraft:survives_explosion"
+        }
+      ]
+    }
+  ],
+  "random_sequence": "antarchy:blocks/polished_shellstone"
+}

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

@@ -0,0 +1,35 @@
+{
+  "type": "minecraft:block",
+  "pools": [
+    {
+      "bonus_rolls": 0.0,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "functions": [
+            {
+              "add": false,
+              "conditions": [
+                {
+                  "block": "antarchy:polished_shellstone_slab",
+                  "condition": "minecraft:block_state_property",
+                  "properties": {
+                    "type": "double"
+                  }
+                }
+              ],
+              "count": 2.0,
+              "function": "minecraft:set_count"
+            },
+            {
+              "function": "minecraft:explosion_decay"
+            }
+          ],
+          "name": "antarchy:polished_shellstone_slab"
+        }
+      ],
+      "rolls": 1.0
+    }
+  ],
+  "random_sequence": "antarchy:blocks/polished_shellstone_slab"
+}

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

@@ -0,0 +1,20 @@
+{
+  "type": "minecraft:block",
+  "pools": [
+    {
+      "rolls": 1,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "name": "antarchy:polished_shellstone_stairs"
+        }
+      ],
+      "conditions": [
+        {
+          "condition": "minecraft:survives_explosion"
+        }
+      ]
+    }
+  ],
+  "random_sequence": "antarchy:blocks/polished_shellstone_stairs"
+}

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

@@ -0,0 +1,20 @@
+{
+  "type": "minecraft:block",
+  "pools": [
+    {
+      "rolls": 1,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "name": "antarchy:polished_shellstone_wall"
+        }
+      ],
+      "conditions": [
+        {
+          "condition": "minecraft:survives_explosion"
+        }
+      ]
+    }
+  ],
+  "random_sequence": "antarchy:blocks/polished_shellstone_wall"
+}

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

@@ -0,0 +1,20 @@
+{
+  "type": "minecraft:block",
+  "pools": [
+    {
+      "rolls": 1,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "name": "antarchy:shellstone"
+        }
+      ],
+      "conditions": [
+        {
+          "condition": "minecraft:survives_explosion"
+        }
+      ]
+    }
+  ],
+  "random_sequence": "antarchy:blocks/shellstone"
+}

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

@@ -0,0 +1,35 @@
+{
+  "type": "minecraft:block",
+  "pools": [
+    {
+      "bonus_rolls": 0.0,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "functions": [
+            {
+              "add": false,
+              "conditions": [
+                {
+                  "block": "antarchy:shellstone_brick_slab",
+                  "condition": "minecraft:block_state_property",
+                  "properties": {
+                    "type": "double"
+                  }
+                }
+              ],
+              "count": 2.0,
+              "function": "minecraft:set_count"
+            },
+            {
+              "function": "minecraft:explosion_decay"
+            }
+          ],
+          "name": "antarchy:shellstone_brick_slab"
+        }
+      ],
+      "rolls": 1.0
+    }
+  ],
+  "random_sequence": "antarchy:blocks/shellstone_brick_slab"
+}

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

@@ -0,0 +1,20 @@
+{
+  "type": "minecraft:block",
+  "pools": [
+    {
+      "rolls": 1,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "name": "antarchy:shellstone_brick_stairs"
+        }
+      ],
+      "conditions": [
+        {
+          "condition": "minecraft:survives_explosion"
+        }
+      ]
+    }
+  ],
+  "random_sequence": "antarchy:blocks/shellstone_brick_stairs"
+}

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

@@ -0,0 +1,20 @@
+{
+  "type": "minecraft:block",
+  "pools": [
+    {
+      "rolls": 1,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "name": "antarchy:shellstone_brick_wall"
+        }
+      ],
+      "conditions": [
+        {
+          "condition": "minecraft:survives_explosion"
+        }
+      ]
+    }
+  ],
+  "random_sequence": "antarchy:blocks/shellstone_brick_wall"
+}

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

@@ -0,0 +1,20 @@
+{
+  "type": "minecraft:block",
+  "pools": [
+    {
+      "rolls": 1,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "name": "antarchy:shellstone_bricks"
+        }
+      ],
+      "conditions": [
+        {
+          "condition": "minecraft:survives_explosion"
+        }
+      ]
+    }
+  ],
+  "random_sequence": "antarchy:blocks/shellstone_bricks"
+}

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

@@ -0,0 +1,35 @@
+{
+  "type": "minecraft:block",
+  "pools": [
+    {
+      "bonus_rolls": 0.0,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "functions": [
+            {
+              "add": false,
+              "conditions": [
+                {
+                  "block": "antarchy:shellstone_slab",
+                  "condition": "minecraft:block_state_property",
+                  "properties": {
+                    "type": "double"
+                  }
+                }
+              ],
+              "count": 2.0,
+              "function": "minecraft:set_count"
+            },
+            {
+              "function": "minecraft:explosion_decay"
+            }
+          ],
+          "name": "antarchy:shellstone_slab"
+        }
+      ],
+      "rolls": 1.0
+    }
+  ],
+  "random_sequence": "antarchy:blocks/shellstone_slab"
+}

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

@@ -0,0 +1,20 @@
+{
+  "type": "minecraft:block",
+  "pools": [
+    {
+      "rolls": 1,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "name": "antarchy:shellstone_stairs"
+        }
+      ],
+      "conditions": [
+        {
+          "condition": "minecraft:survives_explosion"
+        }
+      ]
+    }
+  ],
+  "random_sequence": "antarchy:blocks/shellstone_stairs"
+}

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

@@ -0,0 +1,20 @@
+{
+  "type": "minecraft:block",
+  "pools": [
+    {
+      "rolls": 1,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "name": "antarchy:shellstone_wall"
+        }
+      ],
+      "conditions": [
+        {
+          "condition": "minecraft:survives_explosion"
+        }
+      ]
+    }
+  ],
+  "random_sequence": "antarchy:blocks/shellstone_wall"
+}

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

@@ -0,0 +1,56 @@
+{
+  "type": "minecraft:entity",
+  "pools": [
+    {
+      "bonus_rolls": 0.0,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "functions": [
+            {
+              "function": "minecraft:set_count",
+              "count": {
+                "type": "minecraft:uniform",
+                "min": 5.0,
+                "max": 10.0
+              }
+            },
+            {
+              "function": "minecraft:looting_enchant",
+              "count": {
+                "min": 0.0,
+                "max": 1.0
+              }
+            }
+          ],
+          "name": "antarchy:primordial_scute"
+        }
+      ],
+      "rolls": 1.0,
+      "conditions": [
+        {
+          "condition": "minecraft:killed_by_player"
+        }
+      ]
+    },
+    {
+      "bonus_rolls": 0.0,
+      "entries": [
+        {
+          "type": "minecraft:item",
+          "functions": [
+            {
+              "function": "minecraft:set_count",
+              "count": {
+                "type": "minecraft:constant",
+                "value": 1
+              }
+            }
+          ],
+          "name": "antarchy:water_cannon"
+        }
+      ],
+      "rolls": 1.0
+    }
+  ]
+}

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

@@ -0,0 +1,16 @@
+{
+  "type": "minecraft:crafting_shaped",
+  "category": "building",
+  "key": {
+    "#": {
+      "item": "antarchy:polished_shellstone_slab"
+    }
+  },
+  "pattern": [
+    "#",
+    "#"
+  ],
+  "result": {
+    "id": "antarchy:chiseled_shellstone"
+  }
+}