Glued hatches

src/main/java/hellfirepvp/modularmachinery/common/block/BlockBus.java

@@ -9,6 +9,7 @@
 import hellfirepvp.modularmachinery.common.util.RedstoneHelper;
 import net.minecraft.block.SoundType;
 import net.minecraft.block.material.Material;
+import net.minecraft.block.properties.PropertyBool;
 import net.minecraft.block.properties.PropertyEnum;
 import net.minecraft.block.state.BlockStateContainer;
 import net.minecraft.block.state.IBlockState;
@@ -23,6 +24,7 @@
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.EnumHand;
 import net.minecraft.util.NonNullList;
+import net.minecraft.world.IBlockAccess;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.MathHelper;
 import net.minecraft.util.text.TextFormatting;
@@ -36,6 +38,7 @@
 
 public abstract class BlockBus extends BlockMachineComponent implements BlockCustomName, BlockVariants {
     protected static final PropertyEnum<ItemBusSize> BUS_TYPE = PropertyEnum.create("size", ItemBusSize.class);
+    protected static final PropertyBool              GLUED    = PropertyBool.create("glued");
 
     public BlockBus() {
         super(Material.IRON);
@@ -44,6 +47,7 @@ public BlockBus() {
         setSoundType(SoundType.METAL);
         setHarvestLevel("pickaxe", 1);
         setCreativeTab(CommonProxy.creativeTabModularMachinery);
+        setDefaultState(this.blockState.getBaseState().withProperty(BUS_TYPE, ItemBusSize.TINY).withProperty(GLUED, false));
     }
 
     @Override
@@ -105,24 +109,34 @@ public int damageDropped(IBlockState state) {
 
     @Override
     public IBlockState getStateFromMeta(int meta) {
-        return getDefaultState().withProperty(BUS_TYPE, ItemBusSize.values()[meta]);
+        return getDefaultState().withProperty(BUS_TYPE, ItemBusSize.values()[meta]).withProperty(GLUED, false);
     }
 
     @Override
     public int getMetaFromState(IBlockState state) {
         return state.getValue(BUS_TYPE).ordinal();
     }
 
+    @Override
+    public IBlockState getActualState(IBlockState state, IBlockAccess worldIn, BlockPos pos) {
+        TileEntity tileEntity = worldIn.getTileEntity(pos);
+        if (!(tileEntity instanceof TileItemBus)) {
+            return state.withProperty(GLUED, false);
+        }
+
+        return state.withProperty(GLUED, ((TileItemBus) tileEntity).isExternalIODisabled());
+    }
+
     @Override
     protected BlockStateContainer createBlockState() {
-        return new BlockStateContainer(this, BUS_TYPE);
+        return new BlockStateContainer(this, BUS_TYPE, GLUED);
     }
 
     @Override
     public Iterable<IBlockState> getValidStates() {
         List<IBlockState> ret = new LinkedList<>();
         for (ItemBusSize type : ItemBusSize.values()) {
-            ret.add(getDefaultState().withProperty(BUS_TYPE, type));
+            ret.add(getDefaultState().withProperty(BUS_TYPE, type).withProperty(GLUED, false));
         }
         return ret;
     }

src/main/java/hellfirepvp/modularmachinery/common/integration/theoneprobe/MMInfoProvider.java

@@ -17,6 +17,7 @@
 import hellfirepvp.modularmachinery.common.tiles.TileFactoryController;
 import hellfirepvp.modularmachinery.common.tiles.TileMachineController;
 import hellfirepvp.modularmachinery.common.tiles.TileParallelController;
+import hellfirepvp.modularmachinery.common.tiles.base.TileItemBus;
 import hellfirepvp.modularmachinery.common.tiles.base.TileMultiblockMachineController;
 import hellfirepvp.modularmachinery.common.util.MiscUtils;
 import io.netty.util.internal.ThrowableUtil;
@@ -41,6 +42,12 @@
 import java.util.concurrent.atomic.AtomicLong;
 
 public class MMInfoProvider implements IProbeInfoProvider {
+    private static void processItemBusTOP(TileItemBus itemBus, IProbeInfo probeInfo) {
+        if (itemBus.isExternalIODisabled()) {
+            probeInfo.text(TextFormatting.AQUA + "{*top.itembus.glued*}");
+        }
+    }
+
     private static void processParallelControllerTOP(TileParallelController parallelController, IProbeInfo probeInfo) {
         if (!ModIntegrationTOP.showParallelControllerInfo) {
             return;
@@ -409,6 +416,8 @@ public void addProbeInfo(ProbeMode mode, IProbeInfo probeInfo, EntityPlayer play
             }
         } else if (tileEntity instanceof TileParallelController parallelController) {
             processParallelControllerTOP(parallelController, probeInfo);
+        } else if (tileEntity instanceof TileItemBus itemBus) {
+            processItemBusTOP(itemBus, probeInfo);
         }
     }
 

src/main/java/hellfirepvp/modularmachinery/common/item/ItemBusIOToggle.java

@@ -0,0 +1,70 @@
+package hellfirepvp.modularmachinery.common.item;
+
+import hellfirepvp.modularmachinery.common.CommonProxy;
+import hellfirepvp.modularmachinery.common.tiles.base.TileItemBus;
+import net.minecraft.client.resources.I18n;
+import net.minecraft.client.util.ITooltipFlag;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.EnumActionResult;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.TextComponentTranslation;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import java.util.List;
+
+public abstract class ItemBusIOToggle extends Item {
+
+    private final boolean disableExternalIO;
+
+    protected ItemBusIOToggle(boolean disableExternalIO) {
+        this.disableExternalIO = disableExternalIO;
+        setMaxStackSize(1);
+        setCreativeTab(CommonProxy.creativeTabModularMachinery);
+    }
+
+    @Nonnull
+    @Override
+    public EnumActionResult onItemUseFirst(@Nonnull EntityPlayer player, @Nonnull World world, @Nonnull BlockPos pos,
+                                           @Nonnull EnumFacing facing, float hitX, float hitY, float hitZ,
+                                           @Nonnull EnumHand hand) {
+        TileEntity tileEntity = world.getTileEntity(pos);
+        if (!(tileEntity instanceof TileItemBus)) return EnumActionResult.PASS;
+
+        // Intercept the click before the bus GUI consumes it.
+        if (world.isRemote) return EnumActionResult.SUCCESS;
+
+        TileItemBus itemBus = (TileItemBus) tileEntity;
+        boolean changed = itemBus.setExternalIODisabled(disableExternalIO);
+        player.sendStatusMessage(new TextComponentTranslation(getMessageKey(changed)), true);
+        return EnumActionResult.SUCCESS;
+    }
+
+    @Override
+    @SideOnly(Side.CLIENT)
+    public void addInformation(ItemStack stack, @Nullable World worldIn, List<String> tooltip, ITooltipFlag flagIn) {
+        tooltip.add(I18n.format(getTooltipKey()));
+    }
+
+    private String getMessageKey(boolean changed) {
+        String prefix = "message.itembus.external_io.";
+        if (disableExternalIO) {
+            return changed ? prefix + "disabled" : prefix + "already_disabled";
+        }
+
+        return changed ? prefix + "enabled" : prefix + "already_enabled";
+    }
+
+    private String getTooltipKey() {
+        String prefix = "tooltip.itembus.external_io.";
+        return disableExternalIO ? prefix + "disable" : prefix + "enable";
+    }
+}

src/main/java/hellfirepvp/modularmachinery/common/item/ItemSolvent.java

@@ -0,0 +1,8 @@
+package hellfirepvp.modularmachinery.common.item;
+
+public class ItemSolvent extends ItemBusIOToggle {
+
+    public ItemSolvent() {
+        super(false);
+    }
+}

src/main/java/hellfirepvp/modularmachinery/common/item/ItemTubeOfGlue.java

@@ -0,0 +1,8 @@
+package hellfirepvp.modularmachinery.common.item;
+
+public class ItemTubeOfGlue extends ItemBusIOToggle {
+
+    public ItemTubeOfGlue() {
+        super(true);
+    }
+}

src/main/java/hellfirepvp/modularmachinery/common/lib/ItemsMM.java

@@ -11,6 +11,8 @@
 import hellfirepvp.modularmachinery.common.item.ItemBlueprint;
 import hellfirepvp.modularmachinery.common.item.ItemConstructTool;
 import hellfirepvp.modularmachinery.common.item.ItemModularium;
+import hellfirepvp.modularmachinery.common.item.ItemSolvent;
+import hellfirepvp.modularmachinery.common.item.ItemTubeOfGlue;
 import net.minecraft.item.Item;
 
 /**
@@ -25,6 +27,8 @@ public class ItemsMM {
     public static ItemBlueprint     blueprint;
     public static ItemModularium    modularium;
     public static ItemConstructTool constructTool;
+    public static ItemTubeOfGlue    tubeOfGlue;
+    public static ItemSolvent       solvent;
 
     // AppEng Compat
 

src/main/java/hellfirepvp/modularmachinery/common/registry/RegistryItems.java

@@ -12,9 +12,11 @@
 import hellfirepvp.modularmachinery.common.CommonProxy;
 import hellfirepvp.modularmachinery.common.item.ItemBlockCustomName;
 import hellfirepvp.modularmachinery.common.item.ItemBlueprint;
+import hellfirepvp.modularmachinery.common.item.ItemSolvent;
 import hellfirepvp.modularmachinery.common.item.ItemConstructTool;
 import hellfirepvp.modularmachinery.common.item.ItemDynamicColor;
 import hellfirepvp.modularmachinery.common.item.ItemModularium;
+import hellfirepvp.modularmachinery.common.item.ItemTubeOfGlue;
 import net.minecraft.item.Item;
 import youyihj.mmce.common.item.MachineProjector;
 
@@ -25,6 +27,8 @@
 import static hellfirepvp.modularmachinery.common.lib.ItemsMM.blueprint;
 import static hellfirepvp.modularmachinery.common.lib.ItemsMM.constructTool;
 import static hellfirepvp.modularmachinery.common.lib.ItemsMM.modularium;
+import static hellfirepvp.modularmachinery.common.lib.ItemsMM.solvent;
+import static hellfirepvp.modularmachinery.common.lib.ItemsMM.tubeOfGlue;
 
 /**
  * This class is part of the Modular Machinery Mod
@@ -44,6 +48,8 @@ public static void initialize() {
         blueprint = prepareRegister(new ItemBlueprint());
         modularium = prepareRegister(new ItemModularium());
         constructTool = prepareRegister(new ItemConstructTool());
+        tubeOfGlue = prepareRegister(new ItemTubeOfGlue());
+        solvent = prepareRegister(new ItemSolvent());
         prepareRegisterWithCustomName(MachineProjector.INSTANCE);
 
         registerItemBlocks();

src/main/java/hellfirepvp/modularmachinery/common/tiles/TileItemInputBus.java

@@ -48,7 +48,7 @@ public TileItemInputBus(ItemBusSize type) {
 
     @Override
     public void doRestrictedTick() {
-        if (getWorld().isRemote || !canWork(minWorkDelay, maxWorkDelay)) {
+        if (getWorld().isRemote || isExternalIODisabled() || !canWork(minWorkDelay, maxWorkDelay)) {
             return;
         }
 

src/main/java/hellfirepvp/modularmachinery/common/tiles/TileItemOutputBus.java

@@ -49,7 +49,7 @@ public TileItemOutputBus(ItemBusSize type) {
 
     @Override
     public void doRestrictedTick() {
-        if (getWorld().isRemote || !canWork(minWorkDelay, maxWorkDelay)) {
+        if (getWorld().isRemote || isExternalIODisabled() || !canWork(minWorkDelay, maxWorkDelay)) {
             return;
         }
 

src/main/java/hellfirepvp/modularmachinery/common/tiles/base/TileItemBus.java

@@ -20,9 +20,12 @@
  * Date: 09.07.2017 / 17:37
  */
 public abstract class TileItemBus extends TileInventory implements SelectiveUpdateTileEntity {
+    private static final String NBT_EXTERNAL_IO_DISABLED = "disableExternalIO";
+
     protected int         successCounter   = 0;
     protected boolean     inventoryChanged = false;
     private   ItemBusSize size;
+    private   boolean     externalIODisabled = false;
 
     public TileItemBus() {
     }
@@ -66,17 +69,39 @@ public ItemBusSize getSize() {
         return size;
     }
 
+    public boolean isExternalIODisabled() {
+        return externalIODisabled;
+    }
+
+    public boolean setExternalIODisabled(boolean externalIODisabled) {
+        if (this.externalIODisabled == externalIODisabled) return false;
+
+        this.externalIODisabled = externalIODisabled;
+        this.successCounter = 0;
+        this.inventoryChanged = true;
+
+        if (getWorld() != null && !getWorld().isRemote) markForUpdate();
+
+        return true;
+    }
+
     @Override
     public void readCustomNBT(NBTTagCompound compound) {
         super.readCustomNBT(compound);
 
         this.size = ItemBusSize.values()[MathHelper.clamp(compound.getInteger("busSize"), 0, ItemBusSize.values().length - 1)];
+        this.externalIODisabled = compound.getBoolean(NBT_EXTERNAL_IO_DISABLED);
     }
 
     @Override
     public void writeCustomNBT(NBTTagCompound compound) {
         super.writeCustomNBT(compound);
 
         compound.setInteger("busSize", this.size.ordinal());
+        if (this.externalIODisabled) {
+            compound.setBoolean(NBT_EXTERNAL_IO_DISABLED, true);
+        } else {
+            compound.removeTag(NBT_EXTERNAL_IO_DISABLED);
+        }
     }
 }

src/main/resources/assets/modularmachinery/blockstates/blockinputbus.json

@@ -1,11 +1,36 @@
 {
-    "variants": {
-        "size=tiny": { "model":"modularmachinery:blockinputbus_tiny" },
-        "size=small": { "model":"modularmachinery:blockinputbus_small" },
-        "size=normal": { "model":"modularmachinery:blockinputbus_normal" },
-        "size=reinforced": { "model":"modularmachinery:blockinputbus_reinforced" },
-        "size=big": { "model":"modularmachinery:blockinputbus_big" },
-        "size=huge": { "model":"modularmachinery:blockinputbus_huge" },
-        "size=ludicrous": { "model":"modularmachinery:blockinputbus_ludicrous" }
-    }
+    "multipart": [
+        {
+            "when": { "size": "tiny" },
+            "apply": { "model": "modularmachinery:blockinputbus_tiny" }
+        },
+        {
+            "when": { "size": "small" },
+            "apply": { "model": "modularmachinery:blockinputbus_small" }
+        },
+        {
+            "when": { "size": "normal" },
+            "apply": { "model": "modularmachinery:blockinputbus_normal" }
+        },
+        {
+            "when": { "size": "reinforced" },
+            "apply": { "model": "modularmachinery:blockinputbus_reinforced" }
+        },
+        {
+            "when": { "size": "big" },
+            "apply": { "model": "modularmachinery:blockinputbus_big" }
+        },
+        {
+            "when": { "size": "huge" },
+            "apply": { "model": "modularmachinery:blockinputbus_huge" }
+        },
+        {
+            "when": { "size": "ludicrous" },
+            "apply": { "model": "modularmachinery:blockinputbus_ludicrous" }
+        },
+        {
+            "when": { "glued": "true" },
+            "apply": { "model": "modularmachinery:blockbus_glued_overlay" }
+        }
+    ]
 }