Add support for block direction (facing/axis), not just position

Author: Ivans-11

README.md

@@ -19,21 +19,31 @@ Of course, this mod can also be used independently. As long as you can generate
 * Import blocks in bulk from JSON files located in the `config/mybuilds/` directory.
 * Players can use the `builder:anchor_block` to set the origin and orientation of the relative coordinate system, allowing precise control over the placement and facing of imported blocks.
 * Supports undo functionality to prevent mistakes. You can undo up to the last 3 build operations.
+* Supports exporting blocks from the current world to JSON files.
 
 ## Usage
 
 1. Create a specially formatted JSON file under the `config/mybuilds/` directory, e.g. [`example.json`](./example.json)
-
+   * You can use [**Minecraftify2.0**](https://github.com/Ivans-11/Minecraftify2/releases) to generate JSON files from 3D models. See its [repository documentation](https://github.com/Ivans-11/Minecraftify2) for details.
+   * You can also use the `/builder save` command to export JSON files from the current world. See the following content for specific usage.
    ```json
    {
        "minecraft:stone": [[1, 0, 0],[2, 0, 0],[3, 0, 0]],
-       "minecraft:oak_planks": [[0, 1, 1],[0, 1, 2]]
+       "minecraft:oak_planks": [[0, 1, 1],[0, 1, 2]],
+       "minecraft:spruce_stairs":[[2, 0, 1, 3]],
+       "minecraft:oak_log":[[3, 0, 1, -3],[4, 0, 1, -1]]
    }
    ```
-
    * Keys are block IDs, and values are arrays of relative coordinates.
-   * You can use [**Minecraftify2.0**](https://github.com/Ivans-11/Minecraftify2/releases) to generate JSON files from 3D models. See its [repository documentation](https://github.com/Ivans-11/Minecraftify2) for details.
-   * You can also use the `/builder save` command to export JSON files from the current world. See the following content for specific usage.
+   * Each element in the relative coordinate array represents a block's relative coordinates, in the format `[x, y, z, w]`.
+     * `x` represents the offset in the x-axis relative to the origin.
+     * `y` represents the offset in the y-axis relative to the origin.
+     * `z` represents the offset in the z-axis relative to the origin.
+     * `w` is an optional parameter, used to specify the direction of blocks with direction attributes.
+       * When positive, it represents the horizontal direction. The corresponding numeric values correspond to the following image (for example, stairs):
+        ![](image/stairs.png)
+       * When negative, it represents the axis direction. The corresponding numeric values correspond to the following image (for example, logs):
+        ![](image/log.png)
 
 2. Place a `builder:anchor_block` in the game world to define the reference origin and orientation.
 
@@ -62,7 +72,9 @@ Of course, this mod can also be used independently. As long as you can generate
    /builder save <x> <y> <z> <name>
    ```
    Where `<x> <y> <z>` represents the selected area range.
+
    The mod will use the nearest anchor block to the player as the starting point `(0,0,0)` and export the block data in the range from `(0,0,0)` to `(x,y,z)` to the `config/mybuilds/<name>.json` file.
+
    Note that the x-axis corresponds to the red axis, the y-axis corresponds to the green axis, and the z-axis corresponds to the blue axis. The format of the exported JSON file is the same as that of the imported one.
 
 ## Command List
@@ -92,7 +104,7 @@ Of course, this mod can also be used independently. As long as you can generate
 
 * Undo only applies to blocks placed using the `/builder place` command, and does not affect manually placed blocks.
 
-* Since JSON files only record the relative coordinates of blocks, it is not possible to import some special blocks (such as stairs, doors, etc., which contain more information) accurately.
+* Since JSON files only record the relative coordinates of blocks, it is not possible to import some special blocks (such as buttons, doors, etc., which contain more information) accurately.
 
 ## Acknowledgements
 

README_zh.md

@@ -18,20 +18,32 @@
 - 从 `config/mybuilds/` 目录下的 JSON 文件中批量导入方块。
 - 玩家可以使用 `builder:anchor_block`（锚点方块）设置相对坐标系原点和朝向，从而精确地控制导入方块的位置与朝向。
 - 支持撤回功能，避免误操作。最多可以撤回最近 3 次建造操作。
+- 支持导出功能，将当前世界的指定区域内的方块数据导出为 JSON 文件。
 
 ## 使用方法
 
 1. 在 `config/mybuilds/` 目录下创建特定格式的 JSON 文件，例如 [`example.json`](./example.json)
-
+   - 可使用工具 [**Minecraftify2.0**](https://github.com/Ivans-11/Minecraftify2/releases) 从三维模型文件生成，具体使用方法见其[仓库说明](https://github.com/Ivans-11/Minecraftify2)。
+   - 也可利用 `/builder save` 命令从当前世界导出 JSON 文件，具体使用方法见后文。
    ```json
     {
         "minecraft:stone": [[1, 0, 0],[2, 0, 0],[3, 0, 0]],
-        "minecraft:oak_planks": [[0, 1, 1],[0, 1, 2]]
+        "minecraft:oak_planks": [[0, 1, 1],[0, 1, 2]],
+        "minecraft:spruce_stairs":[[2, 0, 1, 3]],
+        "minecraft:oak_log":[[3, 0, 1, -3],[4, 0, 1, -1]]
     }
    ```
    - 其中，键为方块 ID，值为相对坐标数组。
-   - 可使用工具 [**Minecraftify2.0**](https://github.com/Ivans-11/Minecraftify2/releases) 从三维模型文件生成，具体使用方法见其[仓库说明](https://github.com/Ivans-11/Minecraftify2)。
-   - 也可利用 `/builder save` 命令从当前世界导出 JSON 文件，具体使用方法见后文。
+   - 相对坐标数组中的每个元素表示一个方块的相对坐标，格式为 `[x, y, z, w]`。
+     - `x` 表示相对于原点的 x 轴偏移量。
+     - `y` 表示相对于原点的 y 轴偏移量。
+     - `z` 表示相对于原点的 z 轴偏移量。
+     - `w` 为可选参数，用于指定 带方向属性方块 的朝向。
+       - 为正数时，代表水平朝向。具体数值对应关系如图（以楼梯为例）：
+         ![](image/stairs.png)
+       - 为负数时，代表轴向。具体数值对应关系如图（以原木为例）：
+         ![](image/log.png)
+
 2. 在游戏中放置一个 `builder:anchor_block`（锚点方块） ，用于确定参考坐标系原点和朝向。
 
     ![](image/anchor.png)
@@ -84,7 +96,7 @@
 
     ![](image/item_zh.png)
 - 撤回仅能恢复由 `/builder place` 命令生成的方块，不影响手动放置的方块。
-- 由于 JSON 文件只记录了方块的相对坐标，因此对于一些特殊的方块（如楼梯、门等包含更多信息的方块），无法做到精确导入。
+- 由于 JSON 文件只记录了方块的相对坐标和朝向，因此对于一些特殊的方块（如按钮、门等包含更多信息的方块），无法做到精确导入。
 
 ## 致谢
 

example.json

@@ -30,5 +30,12 @@
     [-1, 1, 8],
     [0, 1, 8],
     [1, 1, 8]
+  ],
+  "minecraft:spruce_stairs": [
+    [3, 0, 4, 3]
+  ],
+  "minecraft:oak_log":[
+    [3, 0, 5, -3],
+    [4, 0, 5, -1]
   ]
 }

gradle.properties

@@ -10,7 +10,7 @@ loader_version=0.16.14
 loom_version=1.11-SNAPSHOT
 
 # Mod Properties
-mod_version=1.0.1
+mod_version=1.0.2
 maven_group=com.example
 archives_base_name=builder
 

image/log.png

@@ -11,9 +11,11 @@
 import net.minecraft.util.Identifier;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Direction;
+import net.minecraft.util.math.Direction.Axis;
 import net.minecraft.registry.Registries;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.state.property.Properties;
+import net.minecraft.state.property.Property;
 import net.minecraft.text.Text;
 
 import java.io.FileReader;
@@ -117,38 +119,23 @@ public static void loadAndPlace(ServerCommandSource source, String filename) {
 
                 // If it is an anchor block, record the position
                 if (block instanceof AnchorBlock) {
-                    player.sendMessage(Text.literal("Anchor Block Found: " + origin), false);
-                    for (JsonElement coordEl : coords) {
-                        JsonArray arr = coordEl.getAsJsonArray();
-                        int dx = arr.get(0).getAsInt();
-                        int dy = arr.get(1).getAsInt();
-                        int dz = arr.get(2).getAsInt();
-
-                        BlockPos placePos = transformPos(origin, dx, dy, dz, facing);
-
-                        BlockState oldState = world.getBlockState(placePos);
-                        snapshots.add(new UndoManager.BlockSnapshot(placePos, oldState));
-                        world.setBlockState(placePos, block.getDefaultState());
-                        player.sendMessage(Text.literal("Anchor Block Placed: " + placePos), false);
-                        cache.add(placePos);
-                        player.sendMessage(Text.literal("Anchor Block Added: " + placePos), false);
-                    }
+                    handleAnchors(world, coords, block, facing, origin, snapshots, cache);
                     continue;
                 }
 
-                for (JsonElement coordEl : coords) {
-                    JsonArray arr = coordEl.getAsJsonArray();
-                    int dx = arr.get(0).getAsInt();
-                    int dy = arr.get(1).getAsInt();
-                    int dz = arr.get(2).getAsInt();
-
-                    BlockPos placePos = transformPos(origin, dx, dy, dz, facing);
-
-                    BlockState oldState = world.getBlockState(placePos);
-                    snapshots.add(new UndoManager.BlockSnapshot(placePos, oldState));
+                // If it is a block with facing
+                if (block.getDefaultState().contains(Properties.HORIZONTAL_FACING)) {
+                    handleFacing(world, coords, block, facing, origin, snapshots);
+                    continue;
+                }
 
-                    world.setBlockState(placePos, block.getDefaultState());
+                // If it is a block with axis
+                if (block.getDefaultState().contains(Properties.AXIS)) {
+                    handleAxis(world, coords, block, facing, origin, snapshots);
+                    continue;
                 }
+
+                handleNormal(world, coords, block, facing, origin, snapshots);
             }
 
             UndoManager.record(player, snapshots);// Record snapshots
@@ -198,6 +185,16 @@ public static void saveStructure(ServerCommandSource source, int x, int y, int z
                         arr.add(dx);
                         arr.add(dy);
                         arr.add(dz);
+
+                        // Record the rotation of the block
+                        if (state.contains(Properties.HORIZONTAL_FACING)) {
+                            Direction blockFacing = state.get(Properties.HORIZONTAL_FACING);
+                            arr.add(relativeDirection(facing, blockFacing));
+                        } else if (state.contains(Properties.AXIS)) {
+                            Axis blockAxis = state.get(Properties.AXIS);
+                            arr.add(relativeAxis(facing, blockAxis));
+                        }
+
                         if (obj.has(blockId)) {
                             obj.get(blockId).getAsJsonArray().add(arr);
                         } else {
@@ -221,6 +218,77 @@ public static void saveStructure(ServerCommandSource source, int x, int y, int z
         }
     }
 
+    // Place normal blocks
+    private static void handleNormal(ServerWorld world, JsonArray coords, Block block, Direction facing, BlockPos origin, List<UndoManager.BlockSnapshot> snapshots) {
+        for (JsonElement coordEl : coords) {
+            JsonArray arr = coordEl.getAsJsonArray();
+            int dx = arr.get(0).getAsInt();
+            int dy = arr.get(1).getAsInt();
+            int dz = arr.get(2).getAsInt();
+
+            BlockPos placePos = transformPos(origin, dx, dy, dz, facing);
+
+            BlockState oldState = world.getBlockState(placePos);
+            snapshots.add(new UndoManager.BlockSnapshot(placePos, oldState));
+
+            world.setBlockState(placePos, block.getDefaultState());
+        }
+    }
+
+    // Place anchor blocks
+    private static void handleAnchors(ServerWorld world, JsonArray coords, Block block, Direction facing, BlockPos origin, List<UndoManager.BlockSnapshot> snapshots, AnchorState cache) {
+        for (JsonElement coordEl : coords) {
+            JsonArray arr = coordEl.getAsJsonArray();
+            int dx = arr.get(0).getAsInt();
+            int dy = arr.get(1).getAsInt();
+            int dz = arr.get(2).getAsInt();
+            int rotation = arr.size() > 3 ? arr.get(3).getAsInt() : 0;
+
+            BlockPos placePos = transformPos(origin, dx, dy, dz, facing);
+
+            BlockState oldState = world.getBlockState(placePos);
+            snapshots.add(new UndoManager.BlockSnapshot(placePos, oldState));
+
+            world.setBlockState(placePos, block.getDefaultState().with(Properties.HORIZONTAL_FACING, absoluteDirection(facing, rotation)));
+            cache.add(placePos);// Add to cache
+        }
+    }
+
+    // Place blocks with facing
+    private static void handleFacing(ServerWorld world, JsonArray coords, Block block, Direction facing, BlockPos origin, List<UndoManager.BlockSnapshot> snapshots) {
+        for (JsonElement coordEl : coords) {
+            JsonArray arr = coordEl.getAsJsonArray();
+            int dx = arr.get(0).getAsInt();
+            int dy = arr.get(1).getAsInt();
+            int dz = arr.get(2).getAsInt();
+            int rotation = arr.size() > 3? arr.get(3).getAsInt() : 0;
+
+            BlockPos placePos = transformPos(origin, dx, dy, dz, facing);
+
+            BlockState oldState = world.getBlockState(placePos);
+            snapshots.add(new UndoManager.BlockSnapshot(placePos, oldState));
+
+            world.setBlockState(placePos, block.getDefaultState().with(Properties.HORIZONTAL_FACING, absoluteDirection(facing, rotation)));
+        }
+    }
+
+    // Place blocks with axis
+    private static void handleAxis(ServerWorld world, JsonArray coords, Block block, Direction facing, BlockPos origin, List<UndoManager.BlockSnapshot> snapshots) {
+        for (JsonElement coordEl : coords) {
+            JsonArray arr = coordEl.getAsJsonArray();
+            int dx = arr.get(0).getAsInt();
+            int dy = arr.get(1).getAsInt();
+            int dz = arr.get(2).getAsInt();
+            int axis = arr.size() > 3? arr.get(3).getAsInt() : 0;
+
+            BlockPos placePos = transformPos(origin, dx, dy, dz, facing);
+
+            BlockState oldState = world.getBlockState(placePos);
+            snapshots.add(new UndoManager.BlockSnapshot(placePos, oldState));
+
+            world.setBlockState(placePos, block.getDefaultState().with(Properties.AXIS, absoluteAxis(facing, axis)));
+        }
+    }
 
     // Transform position based on facing
     private static BlockPos transformPos(BlockPos origin, int dx, int dy, int dz, Direction facing) {
@@ -252,4 +320,64 @@ private static List<BlockPos> getAnchors(ServerWorld world) {
         // Get copy of anchors to avoid ConcurrentModificationException
         return new ArrayList<>(cache.getAnchors());
     }
+
+    // Get the relative direction of the block to the anchor (using positive numbers)
+    private static int relativeDirection(Direction anchorFacing, Direction blockFacing) {
+        int offset = intDirection(blockFacing) - intDirection(anchorFacing);
+        if (offset < 0) offset += 4;
+        return offset;
+    }
+
+    // Get the relative axis of the block to the anchor (using negative numbers)
+    private static int relativeAxis(Direction anchorFacing, Axis blockAxis) {
+        if (blockAxis == Axis.X) {
+            if (anchorFacing == Direction.NORTH || anchorFacing == Direction.SOUTH) return -1;
+            if (anchorFacing == Direction.EAST || anchorFacing == Direction.WEST) return -2;
+        } else if (blockAxis == Axis.Z) {
+            if (anchorFacing == Direction.NORTH || anchorFacing == Direction.SOUTH) return -2;
+            if (anchorFacing == Direction.EAST || anchorFacing == Direction.WEST) return -1;
+        }
+        return -3;
+    }
+
+    // Get the absolute direction of the block based on the anchor and the relative direction
+    private static Direction absoluteDirection(Direction anchorFacing, int relativeDirection) {
+        int absolute = intDirection(anchorFacing) + relativeDirection;
+        if (absolute >= 4) absolute -= 4;
+        return getDirection(absolute);
+    }
+
+    // Get the absolute axis of the block based on the anchor and the relative axis
+    private static Axis absoluteAxis(Direction anchorFacing, int relativeAxis) {
+        if (anchorFacing == Direction.NORTH || anchorFacing == Direction.SOUTH) {
+            if (relativeAxis == -1) return Axis.X;
+            if (relativeAxis == -2) return Axis.Z;
+        } else if (anchorFacing == Direction.EAST || anchorFacing == Direction.WEST) {
+            if (relativeAxis == -1) return Axis.Z;
+            if (relativeAxis == -2) return Axis.X;
+        }
+        return Axis.Y;
+    }
+
+    // Convert direction to integer
+    private static int intDirection(Direction dir) {
+        switch (dir) {
+            case NORTH: return 0;
+            case EAST: return 1;
+            case SOUTH: return 2;
+            case WEST: return 3;
+            default: return 0;
+        }
+    }
+
+    // Convert integer to direction
+    private static Direction getDirection(int dir) {
+        switch (dir) {
+            case 0: return Direction.NORTH;
+            case 1: return Direction.EAST;
+            case 2: return Direction.SOUTH;
+            case 3: return Direction.WEST;
+            default: return Direction.NORTH;
+        }
+    }
 }