From f5de46132440959743f5d3dd784fec4e424a6402 Mon Sep 17 00:00:00 2001 From: Gary Dunn Date: Thu, 26 Mar 2026 17:38:53 +0900 Subject: [PATCH 1/4] Add support for architecturecraft block state printing --- .../client/printer/SchematicPrinter.java | 17 +++ .../schematica/client/util/BlockList.java | 38 ++++-- .../ArchitectureCraftHelper.java | 109 ++++++++++++++++++ 3 files changed, 156 insertions(+), 8 deletions(-) create mode 100644 src/main/java/com/github/lunatrius/schematica/compat/architecturecraft/ArchitectureCraftHelper.java diff --git a/src/main/java/com/github/lunatrius/schematica/client/printer/SchematicPrinter.java b/src/main/java/com/github/lunatrius/schematica/client/printer/SchematicPrinter.java index 38156a62..50709ed6 100644 --- a/src/main/java/com/github/lunatrius/schematica/client/printer/SchematicPrinter.java +++ b/src/main/java/com/github/lunatrius/schematica/client/printer/SchematicPrinter.java @@ -14,6 +14,7 @@ import net.minecraft.item.ItemBucket; import net.minecraft.item.ItemStack; import net.minecraft.network.play.client.C0BPacketEntityAction; +import net.minecraft.tileentity.TileEntity; import net.minecraft.util.Vec3; import net.minecraft.world.World; import net.minecraftforge.common.util.ForgeDirection; @@ -27,6 +28,7 @@ import com.github.lunatrius.schematica.client.printer.registry.PlacementRegistry; import com.github.lunatrius.schematica.client.util.BlockToItemStack; import com.github.lunatrius.schematica.client.world.SchematicWorld; +import com.github.lunatrius.schematica.compat.architecturecraft.ArchitectureCraftHelper; import com.github.lunatrius.schematica.handler.ConfigurationHandler; import com.github.lunatrius.schematica.proxy.ClientProxy; import com.github.lunatrius.schematica.reference.Constants; @@ -44,6 +46,7 @@ public class SchematicPrinter { private boolean isEnabled; private boolean isPrinting; + private boolean currentBlockIsACShape; private SchematicWorld schematic = null; private byte[][][] timeout = null; @@ -178,9 +181,19 @@ private boolean placeBlock(World world, EntityPlayer player, int x, int y, int z return false; } + this.currentBlockIsACShape = ArchitectureCraftHelper.isLoaded() && ArchitectureCraftHelper.isShapeBlock(block); + if (placeBlock(world, player, wx, wy, wz, block, metadata, itemStack)) { this.timeout[x][y][z] = (byte) ConfigurationHandler.timeout; + if (this.currentBlockIsACShape) { + TileEntity schematicTE = this.schematic.getTileEntity(x, y, z); + if (schematicTE != null) { + byte[] orientation = ArchitectureCraftHelper.getOrientationFromTE(schematicTE); + ArchitectureCraftHelper.sendOrientationUpdate(wx, wy, wz, orientation[0], orientation[1]); + } + } + if (!ConfigurationHandler.placeInstantly) { return true; } @@ -404,6 +417,10 @@ private boolean swapToItem(InventoryPlayer inventory, ItemStack itemStack, boole private int getInventorySlotWithItem(final InventoryPlayer inventory, final ItemStack itemStack) { for (int i = 0; i < inventory.mainInventory.length; i++) { if (inventory.mainInventory[i] != null && inventory.mainInventory[i].isItemEqual(itemStack)) { + if (this.currentBlockIsACShape + && !ArchitectureCraftHelper.areShapeItemStacksEqual(itemStack, inventory.mainInventory[i])) { + continue; + } return i; } } diff --git a/src/main/java/com/github/lunatrius/schematica/client/util/BlockList.java b/src/main/java/com/github/lunatrius/schematica/client/util/BlockList.java index d23b0040..ec597d22 100644 --- a/src/main/java/com/github/lunatrius/schematica/client/util/BlockList.java +++ b/src/main/java/com/github/lunatrius/schematica/client/util/BlockList.java @@ -12,6 +12,7 @@ import com.github.lunatrius.core.entity.EntityHelper; import com.github.lunatrius.schematica.client.world.SchematicWorld; +import com.github.lunatrius.schematica.compat.architecturecraft.ArchitectureCraftHelper; import com.github.lunatrius.schematica.reference.Reference; public class BlockList { @@ -59,7 +60,12 @@ public List getList(final EntityPlayer player, final Schematic continue; } - final WrappedItemStack wrappedItemStack = findOrCreateWrappedItemStackFor(blockList, stack); + final boolean isACShape = ArchitectureCraftHelper.isLoaded() + && ArchitectureCraftHelper.isShapeBlock(block); + final WrappedItemStack wrappedItemStack = findOrCreateWrappedItemStackFor( + blockList, + stack, + isACShape); if (isPlaced) { wrappedItemStack.placed++; } @@ -69,25 +75,35 @@ public List getList(final EntityPlayer player, final Schematic } for (WrappedItemStack wrappedItemStack : blockList) { - if (player.capabilities.isCreativeMode) wrappedItemStack.inventory = -1; - else wrappedItemStack.inventory = EntityHelper.getItemCountInInventory( - player.inventory, - wrappedItemStack.itemStack.getItem(), - wrappedItemStack.itemStack.getItemDamage()); + if (player.capabilities.isCreativeMode) { + wrappedItemStack.inventory = -1; + } else if (wrappedItemStack.isACShape) { + wrappedItemStack.inventory = ArchitectureCraftHelper + .countShapeInInventory(player.inventory, wrappedItemStack.itemStack); + } else { + wrappedItemStack.inventory = EntityHelper.getItemCountInInventory( + player.inventory, + wrappedItemStack.itemStack.getItem(), + wrappedItemStack.itemStack.getItemDamage()); + } } return blockList; } private WrappedItemStack findOrCreateWrappedItemStackFor(final List blockList, - final ItemStack itemStack) { + final ItemStack itemStack, final boolean isACShape) { for (final WrappedItemStack wrappedItemStack : blockList) { if (wrappedItemStack.itemStack.isItemEqual(itemStack)) { + if (isACShape + && !ArchitectureCraftHelper.areShapeItemStacksEqual(wrappedItemStack.itemStack, itemStack)) { + continue; + } return wrappedItemStack; } } - final WrappedItemStack wrappedItemStack = new WrappedItemStack(itemStack.copy()); + final WrappedItemStack wrappedItemStack = new WrappedItemStack(itemStack.copy(), isACShape); blockList.add(wrappedItemStack); return wrappedItemStack; } @@ -98,9 +114,15 @@ public static class WrappedItemStack { public int placed; public int total; public int inventory; + public boolean isACShape; public WrappedItemStack(final ItemStack itemStack) { + this(itemStack, false); + } + + public WrappedItemStack(final ItemStack itemStack, final boolean isACShape) { this(itemStack, 0, 0); + this.isACShape = isACShape; } public WrappedItemStack(final ItemStack itemStack, final int placed, final int total) { diff --git a/src/main/java/com/github/lunatrius/schematica/compat/architecturecraft/ArchitectureCraftHelper.java b/src/main/java/com/github/lunatrius/schematica/compat/architecturecraft/ArchitectureCraftHelper.java new file mode 100644 index 00000000..1f26481a --- /dev/null +++ b/src/main/java/com/github/lunatrius/schematica/compat/architecturecraft/ArchitectureCraftHelper.java @@ -0,0 +1,109 @@ +package com.github.lunatrius.schematica.compat.architecturecraft; + +import java.io.DataOutput; +import java.lang.reflect.Method; + +import net.minecraft.block.Block; +import net.minecraft.inventory.IInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; + +import com.github.lunatrius.schematica.reference.Reference; + +import cpw.mods.fml.common.Loader; +import cpw.mods.fml.common.registry.GameData; + +public class ArchitectureCraftHelper { + + private static final String MOD_ID = "ArchitectureCraft"; + private static Boolean loaded = null; + + public static boolean isLoaded() { + if (loaded == null) { + loaded = Loader.isModLoaded(MOD_ID); + } + return loaded; + } + + public static boolean isShapeBlock(Block block) { + if (!isLoaded()) return false; + String name = GameData.getBlockRegistry() + .getNameForObject(block); + return "ArchitectureCraft:shape".equals(name) || "ArchitectureCraft:shapeSE".equals(name); + } + + /** + * Compare two AC shape item stacks by their shape-defining NBT tags (Shape ID, base material). + * Both stacks must already pass isItemEqual (same Item + damage). + */ + public static boolean areShapeItemStacksEqual(ItemStack a, ItemStack b) { + NBTTagCompound tagA = a.getTagCompound(); + NBTTagCompound tagB = b.getTagCompound(); + + if (tagA == null && tagB == null) return true; + if (tagA == null || tagB == null) return false; + + if (tagA.getInteger("Shape") != tagB.getInteger("Shape")) return false; + + String baseNameA = tagA.getString("BaseName"); + String baseNameB = tagB.getString("BaseName"); + if (!baseNameA.equals(baseNameB)) return false; + + if (tagA.getInteger("BaseData") != tagB.getInteger("BaseData")) return false; + + return true; + } + + /** + * Read orientation (side, turn) from a tile entity's NBT. + * Returns a 2-element byte array: [side, turn]. + */ + public static byte[] getOrientationFromTE(TileEntity te) { + NBTTagCompound nbt = new NBTTagCompound(); + te.writeToNBT(nbt); + return new byte[] { nbt.getByte("side"), nbt.getByte("turn") }; + } + + /** + * Count items in inventory that match the given AC shape item stack by NBT (Shape, BaseName, BaseData). + */ + public static int countShapeInInventory(IInventory inventory, ItemStack target) { + int count = 0; + for (int i = 0; i < inventory.getSizeInventory(); i++) { + ItemStack slot = inventory.getStackInSlot(i); + if (slot != null && slot.isItemEqual(target) && areShapeItemStacksEqual(target, slot)) { + count += slot.stackSize; + } + } + return count; + } + + /** + * Send a SetOrientation message to the server via ArchitectureCraft's DataChannel. + * Uses reflection to avoid a compile-time dependency on ArchitectureCraft. + */ + public static void sendOrientationUpdate(int x, int y, int z, byte side, byte turn) { + try { + Class acClass = Class.forName("gcewing.architecture.ArchitectureCraft"); + Object channel = acClass.getField("channel") + .get(null); + Method openServer = channel.getClass() + .getMethod("openServer", String.class); + Object out = openServer.invoke(channel, "SetOrientation"); + + DataOutput dataOut = (DataOutput) out; + dataOut.writeInt(x); + dataOut.writeInt(y); + dataOut.writeInt(z); + dataOut.writeByte(side); + dataOut.writeByte(turn); + + out.getClass() + .getMethod("close") + .invoke(out); + } catch (Exception e) { + Reference.logger.error("Failed to send AC orientation update", e); + } + } +} From 7b867a3de57e514e3bfdf92146bf6136a0e34a0c Mon Sep 17 00:00:00 2001 From: Gary Dunn Date: Thu, 26 Mar 2026 20:00:29 +0900 Subject: [PATCH 2/4] Fix reflection call --- .../compat/architecturecraft/ArchitectureCraftHelper.java | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/main/java/com/github/lunatrius/schematica/compat/architecturecraft/ArchitectureCraftHelper.java b/src/main/java/com/github/lunatrius/schematica/compat/architecturecraft/ArchitectureCraftHelper.java index 1f26481a..ebe0be33 100644 --- a/src/main/java/com/github/lunatrius/schematica/compat/architecturecraft/ArchitectureCraftHelper.java +++ b/src/main/java/com/github/lunatrius/schematica/compat/architecturecraft/ArchitectureCraftHelper.java @@ -81,7 +81,6 @@ public static int countShapeInInventory(IInventory inventory, ItemStack target) /** * Send a SetOrientation message to the server via ArchitectureCraft's DataChannel. - * Uses reflection to avoid a compile-time dependency on ArchitectureCraft. */ public static void sendOrientationUpdate(int x, int y, int z, byte side, byte turn) { try { @@ -99,8 +98,8 @@ public static void sendOrientationUpdate(int x, int y, int z, byte side, byte tu dataOut.writeByte(side); dataOut.writeByte(turn); - out.getClass() - .getMethod("close") + Class channelOutputClass = Class.forName("gcewing.architecture.common.network.ChannelOutput"); + channelOutputClass.getMethod("close") .invoke(out); } catch (Exception e) { Reference.logger.error("Failed to send AC orientation update", e); From de41de10360944320834c07fbb3b19c27ac480f2 Mon Sep 17 00:00:00 2001 From: Gary Dunn Date: Sun, 29 Mar 2026 15:42:29 +0900 Subject: [PATCH 3/4] Switch to direct AC usage instead of reflection --- dependencies.gradle | 1 + repositories.gradle | 1 + .../client/printer/SchematicPrinter.java | 4 +-- .../schematica/client/util/BlockList.java | 3 +- .../ArchitectureCraftBridge.java | 20 +++++++++++++ .../ArchitectureCraftHelper.java | 29 ++----------------- 6 files changed, 26 insertions(+), 32 deletions(-) create mode 100644 src/main/java/com/github/lunatrius/schematica/compat/architecturecraft/ArchitectureCraftBridge.java diff --git a/dependencies.gradle b/dependencies.gradle index 4dc8fb8a..d68ed63e 100644 --- a/dependencies.gradle +++ b/dependencies.gradle @@ -3,4 +3,5 @@ dependencies { implementation('com.github.GTNewHorizons:LunatriusCore:1.2.1-GTNH:dev') compileOnly rfg.deobf('curse.maven:lotr-423748:4091561') + compileOnly('com.github.GTNewHorizons:ArchitectureCraft:1.12.10-feat-set-orientation.1+a970489b85:dev') } diff --git a/repositories.gradle b/repositories.gradle index 6bbef196..e09fd684 100644 --- a/repositories.gradle +++ b/repositories.gradle @@ -1,6 +1,7 @@ // Add any additional repositories for your dependencies here repositories { + mavenLocal() maven { name 'GTNH Maven' url 'http://jenkins.usrv.eu:8081/nexus/content/groups/public/' diff --git a/src/main/java/com/github/lunatrius/schematica/client/printer/SchematicPrinter.java b/src/main/java/com/github/lunatrius/schematica/client/printer/SchematicPrinter.java index 50709ed6..c8c489ff 100644 --- a/src/main/java/com/github/lunatrius/schematica/client/printer/SchematicPrinter.java +++ b/src/main/java/com/github/lunatrius/schematica/client/printer/SchematicPrinter.java @@ -181,12 +181,10 @@ private boolean placeBlock(World world, EntityPlayer player, int x, int y, int z return false; } - this.currentBlockIsACShape = ArchitectureCraftHelper.isLoaded() && ArchitectureCraftHelper.isShapeBlock(block); - if (placeBlock(world, player, wx, wy, wz, block, metadata, itemStack)) { this.timeout[x][y][z] = (byte) ConfigurationHandler.timeout; - if (this.currentBlockIsACShape) { + if (ArchitectureCraftHelper.isShapeBlock(block)) { TileEntity schematicTE = this.schematic.getTileEntity(x, y, z); if (schematicTE != null) { byte[] orientation = ArchitectureCraftHelper.getOrientationFromTE(schematicTE); diff --git a/src/main/java/com/github/lunatrius/schematica/client/util/BlockList.java b/src/main/java/com/github/lunatrius/schematica/client/util/BlockList.java index ec597d22..27dd8789 100644 --- a/src/main/java/com/github/lunatrius/schematica/client/util/BlockList.java +++ b/src/main/java/com/github/lunatrius/schematica/client/util/BlockList.java @@ -60,8 +60,7 @@ public List getList(final EntityPlayer player, final Schematic continue; } - final boolean isACShape = ArchitectureCraftHelper.isLoaded() - && ArchitectureCraftHelper.isShapeBlock(block); + final boolean isACShape = ArchitectureCraftHelper.isShapeBlock(block); final WrappedItemStack wrappedItemStack = findOrCreateWrappedItemStackFor( blockList, stack, diff --git a/src/main/java/com/github/lunatrius/schematica/compat/architecturecraft/ArchitectureCraftBridge.java b/src/main/java/com/github/lunatrius/schematica/compat/architecturecraft/ArchitectureCraftBridge.java new file mode 100644 index 00000000..c7df58a8 --- /dev/null +++ b/src/main/java/com/github/lunatrius/schematica/compat/architecturecraft/ArchitectureCraftBridge.java @@ -0,0 +1,20 @@ +package com.github.lunatrius.schematica.compat.architecturecraft; + +import gcewing.architecture.ArchitectureCraft; +import gcewing.architecture.common.network.ChannelOutput; + +/** + * Isolates direct ArchitectureCraft class references. Do not use without checking if ArchitectureCraft is loaded. + */ +class ArchitectureCraftBridge { + + static void sendOrientationUpdate(int x, int y, int z, byte side, byte turn) { + ChannelOutput out = ArchitectureCraft.channel.openServer("SetOrientation"); + out.writeInt(x); + out.writeInt(y); + out.writeInt(z); + out.writeByte(side); + out.writeByte(turn); + out.close(); + } +} diff --git a/src/main/java/com/github/lunatrius/schematica/compat/architecturecraft/ArchitectureCraftHelper.java b/src/main/java/com/github/lunatrius/schematica/compat/architecturecraft/ArchitectureCraftHelper.java index ebe0be33..5aa56317 100644 --- a/src/main/java/com/github/lunatrius/schematica/compat/architecturecraft/ArchitectureCraftHelper.java +++ b/src/main/java/com/github/lunatrius/schematica/compat/architecturecraft/ArchitectureCraftHelper.java @@ -1,16 +1,11 @@ package com.github.lunatrius.schematica.compat.architecturecraft; -import java.io.DataOutput; -import java.lang.reflect.Method; - import net.minecraft.block.Block; import net.minecraft.inventory.IInventory; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.tileentity.TileEntity; -import com.github.lunatrius.schematica.reference.Reference; - import cpw.mods.fml.common.Loader; import cpw.mods.fml.common.registry.GameData; @@ -80,29 +75,9 @@ public static int countShapeInInventory(IInventory inventory, ItemStack target) } /** - * Send a SetOrientation message to the server via ArchitectureCraft's DataChannel. + * Fix block orientation via ArchitectureCraft's DataChannel. */ public static void sendOrientationUpdate(int x, int y, int z, byte side, byte turn) { - try { - Class acClass = Class.forName("gcewing.architecture.ArchitectureCraft"); - Object channel = acClass.getField("channel") - .get(null); - Method openServer = channel.getClass() - .getMethod("openServer", String.class); - Object out = openServer.invoke(channel, "SetOrientation"); - - DataOutput dataOut = (DataOutput) out; - dataOut.writeInt(x); - dataOut.writeInt(y); - dataOut.writeInt(z); - dataOut.writeByte(side); - dataOut.writeByte(turn); - - Class channelOutputClass = Class.forName("gcewing.architecture.common.network.ChannelOutput"); - channelOutputClass.getMethod("close") - .invoke(out); - } catch (Exception e) { - Reference.logger.error("Failed to send AC orientation update", e); - } + ArchitectureCraftBridge.sendOrientationUpdate(x, y, z, side, turn); } } From 8c56021cc1af72a1a614a756bc25f6119648bb81 Mon Sep 17 00:00:00 2001 From: Gary Dunn Date: Mon, 30 Mar 2026 13:05:05 +0900 Subject: [PATCH 4/4] Add support for transformation of AC blocks (flip, rotate) --- .../client/printer/SchematicPrinter.java | 2 + .../client/world/SchematicWorld.java | 38 +++++++ .../ArchitectureCraftHelper.java | 101 ++++++++++++++++++ 3 files changed, 141 insertions(+) diff --git a/src/main/java/com/github/lunatrius/schematica/client/printer/SchematicPrinter.java b/src/main/java/com/github/lunatrius/schematica/client/printer/SchematicPrinter.java index c8c489ff..884a4c31 100644 --- a/src/main/java/com/github/lunatrius/schematica/client/printer/SchematicPrinter.java +++ b/src/main/java/com/github/lunatrius/schematica/client/printer/SchematicPrinter.java @@ -241,6 +241,8 @@ private ForgeDirection[] getSolidSides(World world, int x, int y, int z) { private boolean placeBlock(World world, EntityPlayer player, int x, int y, int z, Block block, int metadata, ItemStack itemStack) { + this.currentBlockIsACShape = ArchitectureCraftHelper.isShapeBlock(block); + if (isBlacklisted(block, itemStack)) { return false; } diff --git a/src/main/java/com/github/lunatrius/schematica/client/world/SchematicWorld.java b/src/main/java/com/github/lunatrius/schematica/client/world/SchematicWorld.java index 42c4f52f..d622a9eb 100644 --- a/src/main/java/com/github/lunatrius/schematica/client/world/SchematicWorld.java +++ b/src/main/java/com/github/lunatrius/schematica/client/world/SchematicWorld.java @@ -21,6 +21,7 @@ import com.github.lunatrius.core.util.vector.Vector3f; import com.github.lunatrius.core.util.vector.Vector3i; import com.github.lunatrius.schematica.api.ISchematic; +import com.github.lunatrius.schematica.compat.architecturecraft.ArchitectureCraftHelper; import com.github.lunatrius.schematica.handler.ConfigurationHandler; import com.github.lunatrius.schematica.reference.Reference; import com.github.lunatrius.schematica.world.chunk.ChunkProviderSchematic; @@ -252,6 +253,12 @@ public void flip(ForgeDirection direction) { tileEntity.xCoord = width - 1 - tileEntity.xCoord; tileEntity.blockMetadata = schematicFlipped .getBlockMetadata(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord); + if (ArchitectureCraftHelper.isLoaded() && ArchitectureCraftHelper.isShapeBlock( + schematicFlipped.getBlock(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord))) { + byte[] ori = ArchitectureCraftHelper.getOrientationFromTE(tileEntity); + byte[] newOri = ArchitectureCraftHelper.transformOrientationFlip(ori[0], ori[1], direction); + ArchitectureCraftHelper.setOrientationOnTE(tileEntity, newOri[0], newOri[1]); + } schematicFlipped.setTileEntity(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord, tileEntity); } flipStateX++; @@ -274,6 +281,12 @@ public void flip(ForgeDirection direction) { tileEntity.zCoord = length - 1 - tileEntity.zCoord; tileEntity.blockMetadata = schematicFlipped .getBlockMetadata(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord); + if (ArchitectureCraftHelper.isLoaded() && ArchitectureCraftHelper.isShapeBlock( + schematicFlipped.getBlock(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord))) { + byte[] ori = ArchitectureCraftHelper.getOrientationFromTE(tileEntity); + byte[] newOri = ArchitectureCraftHelper.transformOrientationFlip(ori[0], ori[1], direction); + ArchitectureCraftHelper.setOrientationOnTE(tileEntity, newOri[0], newOri[1]); + } schematicFlipped.setTileEntity(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord, tileEntity); } flipStateZ++; @@ -297,6 +310,12 @@ public void flip(ForgeDirection direction) { tileEntity.yCoord = height - 1 - tileEntity.yCoord; tileEntity.blockMetadata = schematicFlipped .getBlockMetadata(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord); + if (ArchitectureCraftHelper.isLoaded() && ArchitectureCraftHelper.isShapeBlock( + schematicFlipped.getBlock(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord))) { + byte[] ori = ArchitectureCraftHelper.getOrientationFromTE(tileEntity); + byte[] newOri = ArchitectureCraftHelper.transformOrientationFlip(ori[0], ori[1], direction); + ArchitectureCraftHelper.setOrientationOnTE(tileEntity, newOri[0], newOri[1]); + } schematicFlipped.setTileEntity(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord, tileEntity); } flipStateY++; @@ -346,6 +365,12 @@ public void rotate(ForgeDirection direction) { tileEntity.zCoord = height - 1 - coord; tileEntity.blockMetadata = schematicRotated .getBlockMetadata(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord); + if (ArchitectureCraftHelper.isLoaded() && ArchitectureCraftHelper.isShapeBlock( + schematicRotated.getBlock(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord))) { + byte[] ori = ArchitectureCraftHelper.getOrientationFromTE(tileEntity); + byte[] newOri = ArchitectureCraftHelper.transformOrientationRotate(ori[0], ori[1], direction); + ArchitectureCraftHelper.setOrientationOnTE(tileEntity, newOri[0], newOri[1]); + } schematicRotated.setTileEntity(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord, tileEntity); } @@ -389,6 +414,13 @@ public void rotate(ForgeDirection direction) { skullTileEntity.func_145903_a((skullTileEntity.func_145906_b() + 12) & 15); } + if (ArchitectureCraftHelper.isLoaded() && ArchitectureCraftHelper.isShapeBlock( + schematicRotated.getBlock(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord))) { + byte[] ori = ArchitectureCraftHelper.getOrientationFromTE(tileEntity); + byte[] newOri = ArchitectureCraftHelper.transformOrientationRotate(ori[0], ori[1], direction); + ArchitectureCraftHelper.setOrientationOnTE(tileEntity, newOri[0], newOri[1]); + } + schematicRotated.setTileEntity(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord, tileEntity); } @@ -426,6 +458,12 @@ public void rotate(ForgeDirection direction) { tileEntity.yCoord = width - 1 - coord; tileEntity.blockMetadata = schematicRotated .getBlockMetadata(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord); + if (ArchitectureCraftHelper.isLoaded() && ArchitectureCraftHelper.isShapeBlock( + schematicRotated.getBlock(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord))) { + byte[] ori = ArchitectureCraftHelper.getOrientationFromTE(tileEntity); + byte[] newOri = ArchitectureCraftHelper.transformOrientationRotate(ori[0], ori[1], direction); + ArchitectureCraftHelper.setOrientationOnTE(tileEntity, newOri[0], newOri[1]); + } schematicRotated.setTileEntity(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord, tileEntity); } diff --git a/src/main/java/com/github/lunatrius/schematica/compat/architecturecraft/ArchitectureCraftHelper.java b/src/main/java/com/github/lunatrius/schematica/compat/architecturecraft/ArchitectureCraftHelper.java index 5aa56317..e60aff19 100644 --- a/src/main/java/com/github/lunatrius/schematica/compat/architecturecraft/ArchitectureCraftHelper.java +++ b/src/main/java/com/github/lunatrius/schematica/compat/architecturecraft/ArchitectureCraftHelper.java @@ -5,6 +5,7 @@ import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; import cpw.mods.fml.common.Loader; import cpw.mods.fml.common.registry.GameData; @@ -74,6 +75,106 @@ public static int countShapeInInventory(IInventory inventory, ItemStack target) return count; } + /** + * Update side/turn in a tile entity's NBT via writeToNBT/readFromNBT round-trip. + */ + public static void setOrientationOnTE(TileEntity te, byte side, byte turn) { + NBTTagCompound nbt = new NBTTagCompound(); + te.writeToNBT(nbt); + nbt.setByte("side", side); + nbt.setByte("turn", turn); + te.readFromNBT(nbt); + } + + // @formatter:off + // Rotation lookup tables: sideMap[oldSide] = newSide, turnDelta[oldSide] = delta + // newTurn = (oldTurn + turnDelta) % 4 + // Derived from Matrix3.sideRotations and turnRotations in ArchitectureCraft. + + // Rotate 90 CW around Y (ForgeDirection.UP) + private static final int[] ROTATE_Y_SIDE = { 0, 1, 5, 4, 2, 3 }; + private static final int[] ROTATE_Y_DELTA = { 3, 1, 0, 0, 0, 0 }; + + // Rotate 90 CW around X (ForgeDirection.EAST) + private static final int[] ROTATE_X_SIDE = { 3, 2, 0, 1, 4, 5 }; + private static final int[] ROTATE_X_DELTA = { 2, 0, 0, 2, 3, 1 }; + + // Rotate 90 CW around Z (ForgeDirection.SOUTH) + private static final int[] ROTATE_Z_SIDE = { 4, 5, 2, 3, 1, 0 }; + private static final int[] ROTATE_Z_DELTA = { 3, 3, 3, 1, 3, 3 }; + + // Flip lookup tables: sideMap[oldSide] = newSide + // Turn formulas vary per flip axis and sometimes per side. + + // Flip X (ForgeDirection.EAST): WEST<->EAST + private static final int[] FLIP_X_SIDE = { 0, 1, 2, 3, 5, 4 }; + + // Flip Y (ForgeDirection.UP): DOWN<->UP + private static final int[] FLIP_Y_SIDE = { 1, 0, 2, 3, 4, 5 }; + + // Flip Z (ForgeDirection.SOUTH): NORTH<->SOUTH + private static final int[] FLIP_Z_SIDE = { 0, 1, 3, 2, 4, 5 }; + // @formatter:on + + /** + * Transform AC orientation for a schematic rotation (90 CW around the given axis). + * Returns [newSide, newTurn]. + */ + public static byte[] transformOrientationRotate(byte side, byte turn, ForgeDirection axis) { + if (side < 0 || side > 5 || turn < 0 || turn > 3) return new byte[] { side, turn }; + final int[] sideMap; + final int[] turnDelta; + switch (axis) { + case UP: + sideMap = ROTATE_Y_SIDE; + turnDelta = ROTATE_Y_DELTA; + break; + case EAST: + sideMap = ROTATE_X_SIDE; + turnDelta = ROTATE_X_DELTA; + break; + case SOUTH: + sideMap = ROTATE_Z_SIDE; + turnDelta = ROTATE_Z_DELTA; + break; + default: + return new byte[] { side, turn }; + } + return new byte[] { (byte) sideMap[side], (byte) ((turn + turnDelta[side]) % 4) }; + } + + /** + * Transform AC orientation for a schematic flip (mirror along the given axis). + * Exact for bilaterally symmetric shapes; best-fit approximation for asymmetric shapes. + * Returns [newSide, newTurn]. + */ + public static byte[] transformOrientationFlip(byte side, byte turn, ForgeDirection axis) { + if (side < 0 || side > 5 || turn < 0 || turn > 3) return new byte[] { side, turn }; + final int newSide; + final int newTurn; + switch (axis) { + case EAST: // Flip X + newSide = FLIP_X_SIDE[side]; + newTurn = (4 - turn) % 4; + break; + case UP: // Flip Y + newSide = FLIP_Y_SIDE[side]; + newTurn = (6 - turn) % 4; + break; + case SOUTH: // Flip Z + newSide = FLIP_Z_SIDE[side]; + if (side <= 1) { + newTurn = (6 - turn) % 4; + } else { + newTurn = (4 - turn) % 4; + } + break; + default: + return new byte[] { side, turn }; + } + return new byte[] { (byte) newSide, (byte) newTurn }; + } + /** * Fix block orientation via ArchitectureCraft's DataChannel. */