1.0.1

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

@@ -1,17 +1,162 @@
 package com.craisinlord.antarchy.content.block;
 
+import com.craisinlord.antarchy.content.entity.UpwardFallingBlockEntity;
+import com.craisinlord.antarchy.content.gravity.AntarchyGravityApi;
 import com.mojang.serialization.MapCodec;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.entity.item.FallingBlockEntity;
+import net.minecraft.world.item.context.BlockPlaceContext;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.LevelReader;
+import net.minecraft.world.level.block.Block;
 import net.minecraft.world.level.block.ScaffoldingBlock;
 import net.minecraft.world.level.block.state.BlockBehaviour;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.StateDefinition;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.level.material.Fluids;
+import net.minecraft.world.phys.shapes.CollisionContext;
+import net.minecraft.world.phys.shapes.Shapes;
+import net.minecraft.world.phys.shapes.VoxelShape;
 
 public class AntimetalScaffoldingBlock extends ScaffoldingBlock {
 
     public static final MapCodec<AntimetalScaffoldingBlock> CODEC = simpleCodec(AntimetalScaffoldingBlock::new);
+    public static final BooleanProperty INVERTED = BooleanProperty.create("inverted");
 
-//    @Override
-//    public MapCodec<AntimetalScaffoldingBlock> codec() { return CODEC; }
+    private static final VoxelShape MIRRORED_STABLE_SHAPE;
+    private static final VoxelShape MIRRORED_UNSTABLE_SHAPE;
+
+    static {
+        VoxelShape frame = Block.box(0.0D, 0.0D, 0.0D, 16.0D, 2.0D, 16.0D);
+        VoxelShape post1 = Block.box(0.0D, 0.0D, 0.0D, 2.0D, 16.0D, 2.0D);
+        VoxelShape post2 = Block.box(14.0D, 0.0D, 0.0D, 16.0D, 16.0D, 2.0D);
+        VoxelShape post3 = Block.box(0.0D, 0.0D, 14.0D, 2.0D, 16.0D, 16.0D);
+        VoxelShape post4 = Block.box(14.0D, 0.0D, 14.0D, 16.0D, 16.0D, 16.0D);
+        MIRRORED_STABLE_SHAPE = Shapes.or(frame, post1, post2, post3, post4);
+
+        VoxelShape topSlab = Block.box(0.0D, 14.0D, 0.0D, 16.0D, 16.0D, 16.0D);
+        VoxelShape edge1 = Block.box(0.0D, 14.0D, 0.0D, 2.0D, 16.0D, 16.0D);
+        VoxelShape edge2 = Block.box(14.0D, 14.0D, 0.0D, 16.0D, 16.0D, 16.0D);
+        VoxelShape edge3 = Block.box(0.0D, 14.0D, 0.0D, 16.0D, 16.0D, 2.0D);
+        VoxelShape edge4 = Block.box(0.0D, 14.0D, 14.0D, 16.0D, 16.0D, 16.0D);
+        MIRRORED_UNSTABLE_SHAPE = Shapes.or(topSlab, MIRRORED_STABLE_SHAPE, edge1, edge2, edge3, edge4);
+    }
 
     public AntimetalScaffoldingBlock(BlockBehaviour.Properties properties) {
         super(properties);
+        this.registerDefaultState(this.stateDefinition.any()
+                .setValue(DISTANCE, 7)
+                .setValue(WATERLOGGED, false)
+                .setValue(BOTTOM, false)
+                .setValue(INVERTED, false));
+    }
+
+    @Override
+    protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockState> builder) {
+        super.createBlockStateDefinition(builder);
+        builder.add(INVERTED);
+    }
+
+    @Override
+    public BlockState getStateForPlacement(BlockPlaceContext context) {
+        BlockPos pos = context.getClickedPos();
+        Level level = context.getLevel();
+        boolean inverted = context.getPlayer() != null && AntarchyGravityApi.isGravityInverted(context.getPlayer());
+        int distance = getDistance(level, pos, inverted);
+        if (inverted && distance >= 7) {
+            return null;
+        }
+        return this.defaultBlockState()
+                .setValue(WATERLOGGED, level.getFluidState(pos).getType() == Fluids.WATER)
+                .setValue(DISTANCE, distance)
+                .setValue(BOTTOM, antarchy$isBottom(level, pos, distance, inverted))
+                .setValue(INVERTED, inverted);
+    }
+
+    @Override
+    protected boolean canSurvive(BlockState state, LevelReader level, BlockPos pos) {
+        return getDistance(level, pos, state.getValue(INVERTED)) < 7;
+    }
+
+    @Override
+    protected void tick(BlockState state, ServerLevel level, BlockPos pos, RandomSource random) {
+        boolean inverted = state.getValue(INVERTED);
+        int distance = getDistance(level, pos, inverted);
+        BlockState updated = state.setValue(DISTANCE, distance).setValue(BOTTOM, antarchy$isBottom(level, pos, distance, inverted));
+        if (updated.getValue(DISTANCE) == 7) {
+            if (state.getValue(DISTANCE) == 7) {
+                if (inverted) {
+                    UpwardFallingBlockEntity.fallUp(level, pos, updated);
+                } else {
+                    FallingBlockEntity.fall(level, pos, updated);
+                }
+            } else {
+                level.destroyBlock(pos, true);
+            }
+        } else if (state != updated) {
+            level.setBlock(pos, updated, 3);
+        }
+    }
+
+    @Override
+    protected VoxelShape getShape(BlockState state, BlockGetter level, BlockPos pos, CollisionContext context) {
+        if (!state.getValue(INVERTED)) {
+            return super.getShape(state, level, pos, context);
+        }
+        if (context.isHoldingItem(state.getBlock().asItem())) {
+            return Shapes.block();
+        }
+        return state.getValue(BOTTOM) ? MIRRORED_UNSTABLE_SHAPE : MIRRORED_STABLE_SHAPE;
+    }
+
+    @Override
+    protected VoxelShape getCollisionShape(BlockState state, BlockGetter level, BlockPos pos, CollisionContext context) {
+        if (!state.getValue(INVERTED)) {
+            return super.getCollisionShape(state, level, pos, context);
+        }
+        return this.getShape(state, level, pos, context);
+    }
+
+    private static boolean antarchy$isMatchingScaffold(BlockState state, boolean inverted) {
+        return state.getBlock() instanceof AntimetalScaffoldingBlock && state.getValue(INVERTED) == inverted;
+    }
+
+    public static int getDistance(LevelReader level, BlockPos pos, boolean inverted) {
+        Direction supportDirection = inverted ? Direction.UP : Direction.DOWN;
+        BlockPos.MutableBlockPos cursor = pos.mutable().move(supportDirection);
+        BlockState supportNeighbor = level.getBlockState(cursor);
+        int distance = 7;
+        if (antarchy$isMatchingScaffold(supportNeighbor, inverted)) {
+            distance = supportNeighbor.getValue(DISTANCE);
+        } else if (supportNeighbor.isFaceSturdy(level, cursor, supportDirection.getOpposite())) {
+            return 0;
+        }
+
+        for (Direction direction : Direction.Plane.HORIZONTAL) {
+            BlockPos.MutableBlockPos neighborPos = pos.mutable().move(direction);
+            BlockState neighbor = level.getBlockState(neighborPos);
+            if (!antarchy$isMatchingScaffold(neighbor, inverted)) {
+                continue;
+            }
+            distance = Math.min(distance, neighbor.getValue(DISTANCE) + 1);
+            if (distance == 1) {
+                break;
+            }
+        }
+
+        return distance;
+    }
+
+    private static boolean antarchy$isBottom(LevelReader level, BlockPos pos, int distance, boolean inverted) {
+        if (distance <= 0) {
+            return false;
+        }
+        Direction supportDirection = inverted ? Direction.UP : Direction.DOWN;
+        return !antarchy$isMatchingScaffold(level.getBlockState(pos.relative(supportDirection)), inverted);
     }
 }

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

@@ -124,12 +124,15 @@ public class UpwardFallingBlockEntity extends Entity {
             return 0.0F;
         }
 
-        float thicknessMultiplier = switch (state.getValue(PointedDripstoneBlock.THICKNESS)) {
-            case TIP, TIP_MERGE -> 2.0F;
-            case FRUSTUM -> 1.5F;
-            case MIDDLE -> 1.25F;
-            case BASE -> 1.0F;
-        };
+        float thicknessMultiplier = 1.0F;
+        if (state.hasProperty(PointedDripstoneBlock.THICKNESS)) {
+            thicknessMultiplier = switch (state.getValue(PointedDripstoneBlock.THICKNESS)) {
+                case TIP, TIP_MERGE -> 2.0F;
+                case FRUSTUM -> 1.5F;
+                case MIDDLE -> 1.25F;
+                case BASE -> 1.0F;
+            };
+        }
 
         return Math.min(baseDamage * thicknessMultiplier, 40.0F);
     }

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

@@ -1,13 +1,76 @@
 package com.craisinlord.antarchy.content.item;
 
-import net.minecraft.world.item.BlockItem;
+import com.craisinlord.antarchy.content.block.AntimetalScaffoldingBlock;
+import com.craisinlord.antarchy.content.gravity.AntarchyGravityApi;
+import java.util.List;
+import net.minecraft.ChatFormatting;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.network.chat.Component;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.ScaffoldingBlockItem;
 import net.minecraft.world.item.TooltipFlag;
+import net.minecraft.world.item.context.BlockPlaceContext;
+import net.minecraft.world.level.Level;
 import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.BlockState;
+import org.jetbrains.annotations.Nullable;
 
-public class AntimetalScaffoldingItem extends BlockItem {
-    public AntimetalScaffoldingItem(Block block, Properties properties) {
+public class AntimetalScaffoldingItem extends ScaffoldingBlockItem {
+    public AntimetalScaffoldingItem(Block block, Item.Properties properties) {
         super(block, properties);
     }
+
+//    @Override
+//    public void appendHoverText(ItemStack stack, Item.TooltipContext context, List<Component> tooltipComponents, TooltipFlag tooltipFlag) {
+//        tooltipComponents.add(Component.translatable("tooltip.antarchy.antimetal_scaffolding").withStyle(ChatFormatting.DARK_AQUA));
+//        super.appendHoverText(stack, context, tooltipComponents, tooltipFlag);
+//    }
+
+    @Nullable
+    @Override
+    public BlockPlaceContext updatePlacementContext(BlockPlaceContext context) {
+        BlockPos clickedPos = context.getClickedPos();
+        Level level = context.getLevel();
+        BlockState clickedState = level.getBlockState(clickedPos);
+        Block block = this.getBlock();
+        boolean inverted = context.getPlayer() != null && AntarchyGravityApi.isGravityInverted(context.getPlayer());
+
+        if (!clickedState.is(block)) {
+            return AntimetalScaffoldingBlock.getDistance(level, clickedPos, inverted) == 7 ? null : context;
+        }
+
+        Direction awayFromSupport = inverted ? Direction.DOWN : Direction.UP;
+        Direction direction;
+        if (context.isSecondaryUseActive()) {
+            direction = context.isInside() ? context.getClickedFace().getOpposite() : context.getClickedFace();
+        } else {
+            direction = context.getClickedFace() == awayFromSupport ? context.getHorizontalDirection() : awayFromSupport;
+        }
+
+        int steps = 0;
+        BlockPos.MutableBlockPos cursor = clickedPos.mutable().move(direction);
+
+        while (steps < 7) {
+            if (!level.isClientSide && !level.isInWorldBounds(cursor)) {
+                break;
+            }
+
+            BlockState state = level.getBlockState(cursor);
+            if (!state.is(block)) {
+                if (state.canBeReplaced(context)) {
+                    return BlockPlaceContext.at(context, cursor, direction);
+                }
+                break;
+            }
+
+            cursor.move(direction);
+            if (direction.getAxis().isHorizontal()) {
+                steps++;
+            }
+        }
+
+        return null;
+    }
 }

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

@@ -1,6 +1,8 @@
 {
   "multipart": [
-    { "when": { "bottom": "false" }, "apply": { "model": "antarchy:block/antimetal_scaffolding_stable" } },
-    { "when": { "bottom": "true"  }, "apply": { "model": "antarchy:block/antimetal_scaffolding_unstable" } }
+    { "when": { "bottom": "false", "inverted": "false" }, "apply": { "model": "antarchy:block/antimetal_scaffolding_stable" } },
+    { "when": { "bottom": "true",  "inverted": "false" }, "apply": { "model": "antarchy:block/antimetal_scaffolding_unstable" } },
+    { "when": { "bottom": "false", "inverted": "true"  }, "apply": { "model": "antarchy:block/antimetal_scaffolding_stable", "x": 180 } },
+    { "when": { "bottom": "true",  "inverted": "true"  }, "apply": { "model": "antarchy:block/antimetal_scaffolding_unstable", "x": 180 } }
   ]
 }

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

@@ -165,6 +165,7 @@
     "tooltip.antarchy.signal_saving_bulb":  "Toggles on/off. Has light level equal to the signal strength stored on it.",
     "tooltip.antarchy.bluestone_placement":  "Places below blocks",
     "tooltip.antarchy.ceiling_compatible_placement":  "Can also be placed on ceilings",
+    "tooltip.antarchy.antimetal_scaffolding":  "Acts as normal scaffolding, or inverted scaffolding while your gravity is flipped",
     "block.antarchy.bile":  "Bile",
     "block.antarchy.ichor":  "Ichor",
     "block.antarchy.antiwater":  "Antiwater",

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

@@ -2,75 +2,5 @@
   "parent": "minecraft:item/handheld",
   "textures": {
     "layer0": "antarchy:item/basilisk_dagger"
-  },
-  "display": {
-    "thirdperson_righthand": {
-      "rotation": [
-        0,
-        90,
-        0
-      ],
-      "translation": [
-        0,
-        4.0,
-        0.5
-      ],
-      "scale": [
-        0.85,
-        0.85,
-        0.85
-      ]
-    },
-    "thirdperson_lefthand": {
-      "rotation": [
-        0,
-        -90,
-        0
-      ],
-      "translation": [
-        0,
-        4.0,
-        0.5
-      ],
-      "scale": [
-        0.85,
-        0.85,
-        0.85
-      ]
-    },
-    "firstperson_righthand": {
-      "rotation": [
-        0,
-        90,
-        25
-      ],
-      "translation": [
-        1.13,
-        3.2,
-        1.13
-      ],
-      "scale": [
-        0.68,
-        0.68,
-        0.68
-      ]
-    },
-    "firstperson_lefthand": {
-      "rotation": [
-        0,
-        -90,
-        -25
-      ],
-      "translation": [
-        1.13,
-        3.2,
-        1.13
-      ],
-      "scale": [
-        0.68,
-        0.68,
-        0.68
-      ]
-    }
   }
 }

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

@@ -4,7 +4,7 @@
   "pattern": [
     "UGN",
     "UCT",
-    "  T"
+    " BT"
   ],
   "key": {
     "U": {
@@ -21,6 +21,9 @@
     },
     "C": {
       "item": "minecraft:comparator"
+    },
+    "B": {
+      "item": "antarchy:bluestone_comparator"
     }
   },
   "result": {

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

@@ -14,7 +14,7 @@
       "tag": "c:ingots/netherite"
     },
     "C": {
-      "item": "minecraft:comparator"
+      "item": "antarchy:bluestone_comparator"
     }
   },
   "result": {

common/src/main/resources/data/antarchy/worldgen/biome/elythia_coral_spikes.json

@@ -59,8 +59,7 @@
   "creature_spawn_probability": 0.04,
   "spawners": {
     "monster": [
-      { "type": "antarchy:missile_squid", "weight": 12, "minCount": 1, "maxCount": 3 },
-      { "type": "antarchy:octopus_bomb",  "weight": 4,  "minCount": 1, "maxCount": 2 }
+      { "type": "antarchy:missile_squid", "weight": 12, "minCount": 1, "maxCount": 3 }
     ],
     "creature": [
       { "type": "minecraft:turtle", "weight": 5, "minCount": 1, "maxCount": 2 }
@@ -68,7 +67,9 @@
     "ambient": [],
     "axolotls": [],
     "underground_water_creature": [],
-    "water_creature": [],
+    "water_creature": [
+      { "type": "antarchy:octopus_bomb", "weight": 4, "minCount": 1, "maxCount": 2 }
+    ],
     "water_ambient": [
       { "type": "minecraft:tropical_fish", "weight": 20, "minCount": 4, "maxCount": 8 }
     ],