From 4e465dffd1d289e6d5757929252e66cf0eee3249 Mon Sep 17 00:00:00 2001 From: Christina Berchtold Date: Fri, 24 Apr 2020 20:14:42 +0200 Subject: moved blocks and TEs into 'common' package --- .../java/common/blocks/BaseGTUpdateableBlock.java | 29 ++ src/main/java/common/blocks/Block_ControlRod.java | 29 ++ src/main/java/common/blocks/Block_GDCUnit.java | 30 ++ src/main/java/common/blocks/Block_IchorJar.java | 46 ++ .../java/common/blocks/Block_ItemProxyCable.java | 45 ++ .../common/blocks/Block_ItemProxyEndpoint.java | 69 +++ .../java/common/blocks/Block_ItemProxySource.java | 69 +++ .../java/common/blocks/Block_ItemServerDrive.java | 59 +++ .../java/common/blocks/Block_ItemServerIOPort.java | 45 ++ .../common/blocks/Block_ItemServerRackCasing.java | 32 ++ .../common/blocks/Block_ReactorChamber_OFF.java | 30 ++ .../common/blocks/Block_ReactorChamber_ON.java | 35 ++ src/main/java/common/blocks/Block_TFFTCasing.java | 30 ++ .../java/common/blocks/Block_TFFTMultiHatch.java | 63 +++ .../blocks/Block_TFFTStorageFieldBlockT1.java | 36 ++ .../blocks/Block_TFFTStorageFieldBlockT2.java | 35 ++ .../blocks/Block_TFFTStorageFieldBlockT3.java | 35 ++ .../blocks/Block_TFFTStorageFieldBlockT4.java | 35 ++ .../blocks/Block_TFFTStorageFieldBlockT5.java | 35 ++ .../common/blocks/Block_ThaumiumReinforcedJar.java | 90 ++++ src/main/java/common/blocks/Block_YSZUnit.java | 30 ++ .../tileentities/GTMTE_FluidMultiStorage.java | 552 +++++++++++++++++++++ .../java/common/tileentities/GTMTE_ItemServer.java | 405 +++++++++++++++ .../tileentities/GTMTE_ModularNuclearReactor.java | 247 +++++++++ .../common/tileentities/GTMTE_SOFuelCellMK1.java | 335 +++++++++++++ .../common/tileentities/GTMTE_SOFuelCellMK2.java | 335 +++++++++++++ src/main/java/common/tileentities/TE_IchorJar.java | 10 + .../common/tileentities/TE_ItemProxyCable.java | 77 +++ .../common/tileentities/TE_ItemProxyEndpoint.java | 204 ++++++++ .../common/tileentities/TE_ItemProxySource.java | 101 ++++ .../common/tileentities/TE_ItemServerIOPort.java | 132 +++++ .../common/tileentities/TE_TFFTMultiHatch.java | 219 ++++++++ .../tileentities/TE_ThaumiumReinforcedJar.java | 10 + 33 files changed, 3534 insertions(+) create mode 100644 src/main/java/common/blocks/BaseGTUpdateableBlock.java create mode 100644 src/main/java/common/blocks/Block_ControlRod.java create mode 100644 src/main/java/common/blocks/Block_GDCUnit.java create mode 100644 src/main/java/common/blocks/Block_IchorJar.java create mode 100644 src/main/java/common/blocks/Block_ItemProxyCable.java create mode 100644 src/main/java/common/blocks/Block_ItemProxyEndpoint.java create mode 100644 src/main/java/common/blocks/Block_ItemProxySource.java create mode 100644 src/main/java/common/blocks/Block_ItemServerDrive.java create mode 100644 src/main/java/common/blocks/Block_ItemServerIOPort.java create mode 100644 src/main/java/common/blocks/Block_ItemServerRackCasing.java create mode 100644 src/main/java/common/blocks/Block_ReactorChamber_OFF.java create mode 100644 src/main/java/common/blocks/Block_ReactorChamber_ON.java create mode 100644 src/main/java/common/blocks/Block_TFFTCasing.java create mode 100644 src/main/java/common/blocks/Block_TFFTMultiHatch.java create mode 100644 src/main/java/common/blocks/Block_TFFTStorageFieldBlockT1.java create mode 100644 src/main/java/common/blocks/Block_TFFTStorageFieldBlockT2.java create mode 100644 src/main/java/common/blocks/Block_TFFTStorageFieldBlockT3.java create mode 100644 src/main/java/common/blocks/Block_TFFTStorageFieldBlockT4.java create mode 100644 src/main/java/common/blocks/Block_TFFTStorageFieldBlockT5.java create mode 100644 src/main/java/common/blocks/Block_ThaumiumReinforcedJar.java create mode 100644 src/main/java/common/blocks/Block_YSZUnit.java create mode 100644 src/main/java/common/tileentities/GTMTE_FluidMultiStorage.java create mode 100644 src/main/java/common/tileentities/GTMTE_ItemServer.java create mode 100644 src/main/java/common/tileentities/GTMTE_ModularNuclearReactor.java create mode 100644 src/main/java/common/tileentities/GTMTE_SOFuelCellMK1.java create mode 100644 src/main/java/common/tileentities/GTMTE_SOFuelCellMK2.java create mode 100644 src/main/java/common/tileentities/TE_IchorJar.java create mode 100644 src/main/java/common/tileentities/TE_ItemProxyCable.java create mode 100644 src/main/java/common/tileentities/TE_ItemProxyEndpoint.java create mode 100644 src/main/java/common/tileentities/TE_ItemProxySource.java create mode 100644 src/main/java/common/tileentities/TE_ItemServerIOPort.java create mode 100644 src/main/java/common/tileentities/TE_TFFTMultiHatch.java create mode 100644 src/main/java/common/tileentities/TE_ThaumiumReinforcedJar.java (limited to 'src/main/java/common') diff --git a/src/main/java/common/blocks/BaseGTUpdateableBlock.java b/src/main/java/common/blocks/BaseGTUpdateableBlock.java new file mode 100644 index 0000000000..8ca9a31fc0 --- /dev/null +++ b/src/main/java/common/blocks/BaseGTUpdateableBlock.java @@ -0,0 +1,29 @@ +package common.blocks; + + +import gregtech.api.GregTech_API; +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.world.World; + +public abstract class BaseGTUpdateableBlock extends Block { + + protected BaseGTUpdateableBlock(Material p_i45394_1_) { + super(p_i45394_1_); + GregTech_API.registerMachineBlock(this, -1); + } + + @Override + public void onBlockAdded(World aWorld, int aX, int aY, int aZ) { + if (GregTech_API.isMachineBlock(this, aWorld.getBlockMetadata(aX, aY, aZ))) { + GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ); + } + } + + @Override + public void breakBlock(World aWorld, int aX, int aY, int aZ, Block aBlock, int aMetaData) { + if (GregTech_API.isMachineBlock(this, aWorld.getBlockMetadata(aX, aY, aZ))) { + GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ); + } + } +} diff --git a/src/main/java/common/blocks/Block_ControlRod.java b/src/main/java/common/blocks/Block_ControlRod.java new file mode 100644 index 0000000000..abb9254f15 --- /dev/null +++ b/src/main/java/common/blocks/Block_ControlRod.java @@ -0,0 +1,29 @@ +package common.blocks; + +import cpw.mods.fml.common.registry.GameRegistry; +import kekztech.KekzCore; +import net.minecraft.block.material.Material; +import net.minecraft.creativetab.CreativeTabs; + +public class Block_ControlRod extends BaseGTUpdateableBlock { + + private static Block_ControlRod instance = new Block_ControlRod(); + + private Block_ControlRod() { + super(Material.iron); + } + + public static Block_ControlRod getInstance() { + return instance; + } + + public void registerBlock() { + final String blockName = "kekztech_controlrod_block"; + super.setBlockName(blockName); + super.setCreativeTab(CreativeTabs.tabMisc); + super.setBlockTextureName(KekzCore.MODID + ":" + "ControlRod"); + super.setHardness(5.0f); + super.setResistance(6.0f); + GameRegistry.registerBlock(getInstance(), blockName); + } +} diff --git a/src/main/java/common/blocks/Block_GDCUnit.java b/src/main/java/common/blocks/Block_GDCUnit.java new file mode 100644 index 0000000000..ec493eba90 --- /dev/null +++ b/src/main/java/common/blocks/Block_GDCUnit.java @@ -0,0 +1,30 @@ +package common.blocks; + +import cpw.mods.fml.common.registry.GameRegistry; +import kekztech.KekzCore; +import net.minecraft.block.material.Material; +import net.minecraft.creativetab.CreativeTabs; + +public class Block_GDCUnit extends BaseGTUpdateableBlock { + + private static Block_GDCUnit instance = new Block_GDCUnit(); + + private Block_GDCUnit() { + // I am a singleton + super(Material.iron); + } + + public static Block_GDCUnit getInstance() { + return instance; + } + + public void registerBlock() { + final String blockName = "kekztech_gdcceramicelectrolyteunit_block"; + super.setBlockName(blockName); + super.setCreativeTab(CreativeTabs.tabMisc); + super.setBlockTextureName(KekzCore.MODID + ":" + "GDCCeramicElectrolyteUnit"); + super.setHardness(5.0f); + super.setResistance(6.0f); + GameRegistry.registerBlock(getInstance(), blockName); + } +} diff --git a/src/main/java/common/blocks/Block_IchorJar.java b/src/main/java/common/blocks/Block_IchorJar.java new file mode 100644 index 0000000000..b5660f3d82 --- /dev/null +++ b/src/main/java/common/blocks/Block_IchorJar.java @@ -0,0 +1,46 @@ +package common.blocks; + +import common.tileentities.TE_IchorJar; +import cpw.mods.fml.common.registry.GameRegistry; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import thaumcraft.common.blocks.BlockJar; + +public class Block_IchorJar extends BlockJar { + + private static Block_IchorJar instance = new Block_IchorJar(); + + private Block_IchorJar() { + super(); + } + + public static Block_IchorJar getInstance() { + return instance; + } + + public void registerBlock() { + final String blockName = "kekztech_ichorjar_block"; + super.setBlockName(blockName); + GameRegistry.registerBlock(getInstance(), blockName); + } + + @Override + @SideOnly(Side.CLIENT) + public void registerBlockIcons(IIconRegister ir) { + super.iconLiquid = ir.registerIcon("thaumcraft:animatedglow"); + super.iconJarSide = ir.registerIcon("kekztech:ichor_jar_side"); + super.iconJarTop = ir.registerIcon("kekztech:ichor_jar_top"); + super.iconJarTopVoid = ir.registerIcon("kekztech:ichor_jar_top_void"); + super.iconJarSideVoid = ir.registerIcon("kekztech:jar_side_void"); + super.iconJarBottom = ir.registerIcon("kekztech:ichor_jar_bottom"); + } + + @Override + public TileEntity createTileEntity(World world, int meta) { + return new TE_IchorJar(); + } + +} diff --git a/src/main/java/common/blocks/Block_ItemProxyCable.java b/src/main/java/common/blocks/Block_ItemProxyCable.java new file mode 100644 index 0000000000..5dffc4d60d --- /dev/null +++ b/src/main/java/common/blocks/Block_ItemProxyCable.java @@ -0,0 +1,45 @@ +package common.blocks; + +import common.tileentities.TE_ItemProxyCable; +import cpw.mods.fml.common.registry.GameRegistry; +import itemBlocks.IB_ItemProxyCable; +import kekztech.KekzCore; +import net.minecraft.block.BlockContainer; +import net.minecraft.block.material.Material; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +public class Block_ItemProxyCable extends BlockContainer { + + private static Block_ItemProxyCable instance = new Block_ItemProxyCable(); + + private Block_ItemProxyCable() { + super(Material.glass); + } + + public static Block_ItemProxyCable getInstance() { + return instance; + } + + public void registerBlock() { + final String blockName = "kekztech_itemproxycable_block"; + super.setBlockName(blockName); + super.setCreativeTab(CreativeTabs.tabMisc); + super.setBlockTextureName(KekzCore.MODID + ":" + "TFFTCasing"); + super.setHardness(3.0f); + super.setResistance(2.0f); + GameRegistry.registerBlock(getInstance(), IB_ItemProxyCable.class, blockName); + } + + @Override + public boolean isOpaqueCube() { + return false; + } + + @Override + public TileEntity createNewTileEntity(World world, int p_149915_2_) { + return new TE_ItemProxyCable(); + } + +} diff --git a/src/main/java/common/blocks/Block_ItemProxyEndpoint.java b/src/main/java/common/blocks/Block_ItemProxyEndpoint.java new file mode 100644 index 0000000000..91d4ef5d29 --- /dev/null +++ b/src/main/java/common/blocks/Block_ItemProxyEndpoint.java @@ -0,0 +1,69 @@ +package common.blocks; + +import java.util.UUID; + +import common.tileentities.TE_ItemProxyEndpoint; +import cpw.mods.fml.common.registry.GameRegistry; +import itemBlocks.IB_ItemProxyEndpoint; +import items.Item_Configurator; +import kekztech.GuiHandler; +import kekztech.KekzCore; +import net.minecraft.block.BlockContainer; +import net.minecraft.block.material.Material; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +public class Block_ItemProxyEndpoint extends BlockContainer { + + private static Block_ItemProxyEndpoint instance = new Block_ItemProxyEndpoint(); + + private Block_ItemProxyEndpoint() { + super(Material.glass); + } + + public static Block_ItemProxyEndpoint getInstance() { + return instance; + } + + public void registerBlock() { + final String blockName = "kekztech_itemproxyendpoint_block"; + super.setBlockName(blockName); + super.setCreativeTab(CreativeTabs.tabMisc); + super.setBlockTextureName(KekzCore.MODID + ":" + "ItemProxyEndpoint"); + super.setHardness(3.0f); + super.setResistance(2.0f); + GameRegistry.registerBlock(getInstance(), IB_ItemProxyEndpoint.class, blockName); + } + + @Override + public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float lx, float ly, float lz) { + if(world.isRemote) { + return true; + } + + final TileEntity te = world.getTileEntity(x, y, z); + if(te != null && te instanceof TE_ItemProxyEndpoint) { + final TE_ItemProxyEndpoint endpoint = (TE_ItemProxyEndpoint) te; + if(player.inventory.getCurrentItem() != null && player.inventory.getCurrentItem().getItem() instanceof Item_Configurator) { + + final ItemStack held = player.inventory.getCurrentItem(); + if(held.hasTagCompound() && held.getTagCompound().hasKey("config")) { + endpoint.setChannel(UUID.fromString(held.getTagCompound().getString("config"))); + } + } else { + player.openGui(KekzCore.instance, GuiHandler.ITEM_PROXY_ENDPOINT, world, x, y, z); + } + return true; + } + return false; + } + + @Override + public TileEntity createNewTileEntity(World world, int p_149915_2_) { + return new TE_ItemProxyEndpoint(); + } + +} \ No newline at end of file diff --git a/src/main/java/common/blocks/Block_ItemProxySource.java b/src/main/java/common/blocks/Block_ItemProxySource.java new file mode 100644 index 0000000000..0158ae57e9 --- /dev/null +++ b/src/main/java/common/blocks/Block_ItemProxySource.java @@ -0,0 +1,69 @@ +package common.blocks; + +import common.tileentities.TE_ItemProxySource; +import cpw.mods.fml.common.registry.GameRegistry; +import itemBlocks.IB_ItemProxySource; +import items.Item_Configurator; +import kekztech.GuiHandler; +import kekztech.KekzCore; +import net.minecraft.block.BlockContainer; +import net.minecraft.block.material.Material; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +public class Block_ItemProxySource extends BlockContainer { + + private static Block_ItemProxySource instance = new Block_ItemProxySource(); + + private Block_ItemProxySource() { + super(Material.glass); + } + + public static Block_ItemProxySource getInstance() { + return instance; + } + + public void registerBlock() { + final String blockName = "kekztech_itemproxysource_block"; + super.setBlockName(blockName); + super.setCreativeTab(CreativeTabs.tabMisc); + super.setBlockTextureName(KekzCore.MODID + ":" + "ItemProxySource"); + super.setHardness(3.0f); + super.setResistance(2.0f); + GameRegistry.registerBlock(getInstance(), IB_ItemProxySource.class, blockName); + } + + @Override + public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float lx, float ly, float lz) { + if(world.isRemote) { + return true; + } + + final TileEntity te = world.getTileEntity(x, y, z); + if(te != null && te instanceof TE_ItemProxySource) { + final TE_ItemProxySource source = (TE_ItemProxySource) te; + if(player.inventory.getCurrentItem() != null && player.inventory.getCurrentItem().getItem() instanceof Item_Configurator) { + + final NBTTagCompound configNBT = new NBTTagCompound(); + configNBT.setString("config", source.getChannel().toString()); + final ItemStack held = player.inventory.getCurrentItem(); + held.setTagCompound(configNBT); + + } else { + player.openGui(KekzCore.instance, GuiHandler.ITEM_PROXY_SOURCE, world, x, y, z); + } + return true; + } + return false; + } + + @Override + public TileEntity createNewTileEntity(World world, int p_149915_2_) { + return new TE_ItemProxySource(); + } + +} diff --git a/src/main/java/common/blocks/Block_ItemServerDrive.java b/src/main/java/common/blocks/Block_ItemServerDrive.java new file mode 100644 index 0000000000..e35cc220db --- /dev/null +++ b/src/main/java/common/blocks/Block_ItemServerDrive.java @@ -0,0 +1,59 @@ +package common.blocks; + +import cpw.mods.fml.common.registry.GameRegistry; +import itemBlocks.IB_ItemServerDrive; +import kekztech.KekzCore; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.util.IIcon; + +public class Block_ItemServerDrive extends BaseGTUpdateableBlock{ + + private static Block_ItemServerDrive instance = new Block_ItemServerDrive(); + + private IIcon[] faces = new IIcon[6]; + + private Block_ItemServerDrive() { + // I am a singleton + super(Material.iron); + } + + public static Block_ItemServerDrive getInstance() { + return instance; + } + + public void registerBlock() { + final String blockName = "kekztech_itemserverdrive_block"; + super.setBlockName(blockName); + super.setCreativeTab(CreativeTabs.tabMisc); + super.setHardness(5.0f); + super.setResistance(6.0f); + GameRegistry.registerBlock(getInstance(), IB_ItemServerDrive.class, blockName); + } + + @Override + public void registerBlockIcons(IIconRegister reg) { + for(int i = 0; i < 6; i++) { + if(i == 0) { + faces[i] = reg.registerIcon(KekzCore.MODID + ":" + "ItemServerDrive_BOTTOM"); + } else if(i == 1) { + faces[i] = reg.registerIcon(KekzCore.MODID + ":" + "ItemServerDrive_TOP"); + } else { + faces[i] = reg.registerIcon(KekzCore.MODID + ":" + "ItemServerDrive"); + } + + } + } + + @Override + public IIcon getIcon(int side, int meta) { + return faces[side]; + } + + @Override + public int getLightValue() { + return 7; + } + +} diff --git a/src/main/java/common/blocks/Block_ItemServerIOPort.java b/src/main/java/common/blocks/Block_ItemServerIOPort.java new file mode 100644 index 0000000000..c7a3f4dce5 --- /dev/null +++ b/src/main/java/common/blocks/Block_ItemServerIOPort.java @@ -0,0 +1,45 @@ +package common.blocks; + +import common.tileentities.TE_ItemServerIOPort; +import cpw.mods.fml.common.registry.GameRegistry; +import itemBlocks.IB_ItemServerIOPort; +import kekztech.KekzCore; +import net.minecraft.block.material.Material; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +public class Block_ItemServerIOPort extends BaseGTUpdateableBlock { + + private static Block_ItemServerIOPort instance = new Block_ItemServerIOPort(); + + private Block_ItemServerIOPort() { + // I am a singleton + super(Material.iron); + } + + public static Block_ItemServerIOPort getInstance() { + return instance; + } + + public void registerBlock() { + final String blockName = "kekztech_itemserverioport_block"; + super.setBlockName(blockName); + super.setCreativeTab(CreativeTabs.tabMisc); + super.setBlockTextureName(KekzCore.MODID + ":" + "ItemServerIOPort"); + super.setHardness(5.0f); + super.setResistance(6.0f); + GameRegistry.registerBlock(getInstance(), IB_ItemServerIOPort.class, blockName); + } + + @Override + public boolean hasTileEntity(int metadata) { + return true; + } + + @Override + public TileEntity createTileEntity(World world, int metadata) { + return new TE_ItemServerIOPort(); + } + +} diff --git a/src/main/java/common/blocks/Block_ItemServerRackCasing.java b/src/main/java/common/blocks/Block_ItemServerRackCasing.java new file mode 100644 index 0000000000..e12262538b --- /dev/null +++ b/src/main/java/common/blocks/Block_ItemServerRackCasing.java @@ -0,0 +1,32 @@ +package common.blocks; + +import cpw.mods.fml.common.registry.GameRegistry; +import itemBlocks.IB_ItemServerRackCasing; +import kekztech.KekzCore; +import net.minecraft.block.material.Material; +import net.minecraft.creativetab.CreativeTabs; + +public class Block_ItemServerRackCasing extends BaseGTUpdateableBlock { + + private static Block_ItemServerRackCasing instance = new Block_ItemServerRackCasing(); + + private Block_ItemServerRackCasing() { + // I am a singleton + super(Material.iron); + } + + public static Block_ItemServerRackCasing getInstance() { + return instance; + } + + public void registerBlock() { + final String blockName = "kekztech_itemserverrackcasing_block"; + super.setBlockName(blockName); + super.setCreativeTab(CreativeTabs.tabMisc); + super.setBlockTextureName(KekzCore.MODID + ":" + "ItemServerRackCasing"); + super.setHardness(5.0f); + super.setResistance(6.0f); + GameRegistry.registerBlock(getInstance(), IB_ItemServerRackCasing.class, blockName); + } + +} diff --git a/src/main/java/common/blocks/Block_ReactorChamber_OFF.java b/src/main/java/common/blocks/Block_ReactorChamber_OFF.java new file mode 100644 index 0000000000..ab14e1d56c --- /dev/null +++ b/src/main/java/common/blocks/Block_ReactorChamber_OFF.java @@ -0,0 +1,30 @@ +package common.blocks; + +import cpw.mods.fml.common.registry.GameRegistry; +import kekztech.KekzCore; +import net.minecraft.block.material.Material; +import net.minecraft.creativetab.CreativeTabs; + +public class Block_ReactorChamber_OFF extends BaseGTUpdateableBlock { + + private static Block_ReactorChamber_OFF instance = new Block_ReactorChamber_OFF(); + + private Block_ReactorChamber_OFF() { + super(Material.iron); + } + + public static Block_ReactorChamber_OFF getInstance() { + return instance; + } + + public void registerBlock() { + final String blockName = "kekztech_reactorchamberoff_block"; + super.setBlockName(blockName); + super.setCreativeTab(CreativeTabs.tabMisc); + super.setBlockTextureName(KekzCore.MODID + ":" + "ReactorChamber_OFF"); + super.setHardness(10.0f); + super.setResistance(16.0f); + GameRegistry.registerBlock(getInstance(), blockName); + } + +} diff --git a/src/main/java/common/blocks/Block_ReactorChamber_ON.java b/src/main/java/common/blocks/Block_ReactorChamber_ON.java new file mode 100644 index 0000000000..fa6db02c8e --- /dev/null +++ b/src/main/java/common/blocks/Block_ReactorChamber_ON.java @@ -0,0 +1,35 @@ +package common.blocks; + +import cpw.mods.fml.common.registry.GameRegistry; +import kekztech.KekzCore; +import net.minecraft.block.material.Material; +import net.minecraft.creativetab.CreativeTabs; + +public class Block_ReactorChamber_ON extends BaseGTUpdateableBlock { + + private static Block_ReactorChamber_ON instance = new Block_ReactorChamber_ON(); + + private Block_ReactorChamber_ON() { + super(Material.iron); + } + + public static Block_ReactorChamber_ON getInstance() { + return instance; + } + + public void registerBlock() { + final String blockName = "kekztech_reactorchamberon_block"; + super.setBlockName(blockName); + super.setCreativeTab(CreativeTabs.tabMisc); + super.setBlockTextureName(KekzCore.MODID + ":" + "ReactorChamber_ON"); + super.setHardness(-1.0f); + super.setResistance(16.0f); + GameRegistry.registerBlock(getInstance(), blockName); + } + + @Override + public int getLightValue() { + return 15; + } + +} diff --git a/src/main/java/common/blocks/Block_TFFTCasing.java b/src/main/java/common/blocks/Block_TFFTCasing.java new file mode 100644 index 0000000000..86d4ed6182 --- /dev/null +++ b/src/main/java/common/blocks/Block_TFFTCasing.java @@ -0,0 +1,30 @@ +package common.blocks; + +import cpw.mods.fml.common.registry.GameRegistry; +import kekztech.KekzCore; +import net.minecraft.block.material.Material; +import net.minecraft.creativetab.CreativeTabs; + +public class Block_TFFTCasing extends BaseGTUpdateableBlock { + + private static Block_TFFTCasing instance = new Block_TFFTCasing(); + + private Block_TFFTCasing() { + // I am a singleton + super(Material.iron); + } + + public static Block_TFFTCasing getInstance() { + return instance; + } + + public void registerBlock() { + final String blockName = "kekztech_tfftcasingblock_block"; + super.setBlockName(blockName); + super.setCreativeTab(CreativeTabs.tabMisc); + super.setBlockTextureName(KekzCore.MODID + ":" + "TFFTCasing"); + super.setHardness(5.0f); + super.setResistance(6.0f); + GameRegistry.registerBlock(getInstance(), blockName); + } +} diff --git a/src/main/java/common/blocks/Block_TFFTMultiHatch.java b/src/main/java/common/blocks/Block_TFFTMultiHatch.java new file mode 100644 index 0000000000..c0cfab7777 --- /dev/null +++ b/src/main/java/common/blocks/Block_TFFTMultiHatch.java @@ -0,0 +1,63 @@ +package common.blocks; + +import common.tileentities.TE_TFFTMultiHatch; +import cpw.mods.fml.common.registry.GameRegistry; +import gregtech.api.GregTech_API; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_Utility; +import itemBlocks.IB_TFFTMultiHatch; +import kekztech.KekzCore; +import net.minecraft.block.material.Material; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +public class Block_TFFTMultiHatch extends BaseGTUpdateableBlock { + + private static Block_TFFTMultiHatch instance = new Block_TFFTMultiHatch(); + + private Block_TFFTMultiHatch() { + super(Material.iron); + } + + public static Block_TFFTMultiHatch getInstance() { + return instance; + } + + public void registerBlock() { + final String blockName = "kekztech_tfftmultihatch_block"; + super.setBlockName(blockName); + super.setCreativeTab(CreativeTabs.tabMisc); + super.setBlockTextureName(KekzCore.MODID + ":" + "TFFTMultiHatch"); + super.setHardness(5.0f); + super.setResistance(6.0f); + GameRegistry.registerBlock(getInstance(), IB_TFFTMultiHatch.class, blockName); + } + + @Override + public TileEntity createTileEntity(World world, int p_149915_2_) { + return new TE_TFFTMultiHatch(); + } + + @Override + public boolean hasTileEntity(int metadata) { + return true; + } + + @Override + public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int p_149727_6_, float p_149727_7_, float p_149727_8_, float p_149727_9_) { + // Code block taken from GregTech's BaseMetaTileEntity.class + if (GT_Utility.isStackInList(player.getHeldItem(), GregTech_API.sScrewdriverList)) { + if (GT_ModHandler.damageOrDechargeItem(player.getHeldItem(), 1, 200, player)) { + final TileEntity te = world.getTileEntity(x, y, z); + if(te != null && te instanceof TE_TFFTMultiHatch) { + ((TE_TFFTMultiHatch) te).toggleAutoOutput(); + GT_Utility.sendSoundToPlayers(world, (String) GregTech_API.sSoundList.get(100), 1.0F, -1.0F, x, y, z); + } + } + return true; + } + return false; + } +} diff --git a/src/main/java/common/blocks/Block_TFFTStorageFieldBlockT1.java b/src/main/java/common/blocks/Block_TFFTStorageFieldBlockT1.java new file mode 100644 index 0000000000..3bc390ce91 --- /dev/null +++ b/src/main/java/common/blocks/Block_TFFTStorageFieldBlockT1.java @@ -0,0 +1,36 @@ +package common.blocks; + +import cpw.mods.fml.common.registry.GameRegistry; +import itemBlocks.IB_TFFTStorageFieldBlockT1; +import kekztech.KekzCore; +import net.minecraft.block.material.Material; +import net.minecraft.creativetab.CreativeTabs; + +public class Block_TFFTStorageFieldBlockT1 extends BaseGTUpdateableBlock { + + private static Block_TFFTStorageFieldBlockT1 instance = new Block_TFFTStorageFieldBlockT1(); + + private Block_TFFTStorageFieldBlockT1() { + // I am a singleton + super(Material.iron); + } + + public static Block_TFFTStorageFieldBlockT1 getInstance() { + return instance; + } + + public static int getCapacity() { + return 500000; + } + + public void registerBlock() { + final String blockName = "kekztech_tfftstoragefieldblock1_block"; + super.setBlockName(blockName); + super.setCreativeTab(CreativeTabs.tabMisc); + super.setBlockTextureName(KekzCore.MODID + ":" + "TFFTStorageFieldBlock1"); + super.setHardness(5.0f); + super.setResistance(6.0f); + GameRegistry.registerBlock(getInstance(), IB_TFFTStorageFieldBlockT1.class, blockName); + } + +} diff --git a/src/main/java/common/blocks/Block_TFFTStorageFieldBlockT2.java b/src/main/java/common/blocks/Block_TFFTStorageFieldBlockT2.java new file mode 100644 index 0000000000..7ba7f25a88 --- /dev/null +++ b/src/main/java/common/blocks/Block_TFFTStorageFieldBlockT2.java @@ -0,0 +1,35 @@ +package common.blocks; + +import cpw.mods.fml.common.registry.GameRegistry; +import itemBlocks.IB_TFFTStorageFieldBlockT2; +import kekztech.KekzCore; +import net.minecraft.block.material.Material; +import net.minecraft.creativetab.CreativeTabs; + +public class Block_TFFTStorageFieldBlockT2 extends BaseGTUpdateableBlock { + + private static Block_TFFTStorageFieldBlockT2 instance = new Block_TFFTStorageFieldBlockT2(); + + private Block_TFFTStorageFieldBlockT2() { + // I am a singleton + super(Material.iron); + } + + public static Block_TFFTStorageFieldBlockT2 getInstance() { + return instance; + } + + public static int getCapacity() { + return 4000000; + } + + public void registerBlock() { + final String blockName = "kekztech_tfftstoragefieldblock2_block"; + super.setBlockName(blockName); + super.setCreativeTab(CreativeTabs.tabMisc); + super.setBlockTextureName(KekzCore.MODID + ":" + "TFFTStorageFieldBlock2"); + super.setHardness(5.0f); + super.setResistance(6.0f); + GameRegistry.registerBlock(getInstance(), IB_TFFTStorageFieldBlockT2.class, blockName); + } +} diff --git a/src/main/java/common/blocks/Block_TFFTStorageFieldBlockT3.java b/src/main/java/common/blocks/Block_TFFTStorageFieldBlockT3.java new file mode 100644 index 0000000000..51741dc4fa --- /dev/null +++ b/src/main/java/common/blocks/Block_TFFTStorageFieldBlockT3.java @@ -0,0 +1,35 @@ +package common.blocks; + +import cpw.mods.fml.common.registry.GameRegistry; +import itemBlocks.IB_TFFTStorageFieldBlockT3; +import kekztech.KekzCore; +import net.minecraft.block.material.Material; +import net.minecraft.creativetab.CreativeTabs; + +public class Block_TFFTStorageFieldBlockT3 extends BaseGTUpdateableBlock { + + private static Block_TFFTStorageFieldBlockT3 instance = new Block_TFFTStorageFieldBlockT3(); + + private Block_TFFTStorageFieldBlockT3() { + // I am a singleton + super(Material.iron); + } + + public static Block_TFFTStorageFieldBlockT3 getInstance() { + return instance; + } + + public static int getCapacity() { + return 16000000; + } + + public void registerBlock() { + final String blockName = "kekztech_tfftstoragefieldblock3_block"; + super.setBlockName(blockName); + super.setCreativeTab(CreativeTabs.tabMisc); + super.setBlockTextureName(KekzCore.MODID + ":" + "TFFTStorageFieldBlock3"); + super.setHardness(5.0f); + super.setResistance(6.0f); + GameRegistry.registerBlock(getInstance(), IB_TFFTStorageFieldBlockT3.class, blockName); + } +} diff --git a/src/main/java/common/blocks/Block_TFFTStorageFieldBlockT4.java b/src/main/java/common/blocks/Block_TFFTStorageFieldBlockT4.java new file mode 100644 index 0000000000..9a2bb9e3be --- /dev/null +++ b/src/main/java/common/blocks/Block_TFFTStorageFieldBlockT4.java @@ -0,0 +1,35 @@ +package common.blocks; + +import cpw.mods.fml.common.registry.GameRegistry; +import itemBlocks.IB_TFFTStorageFieldBlockT4; +import kekztech.KekzCore; +import net.minecraft.block.material.Material; +import net.minecraft.creativetab.CreativeTabs; + +public class Block_TFFTStorageFieldBlockT4 extends BaseGTUpdateableBlock { + + private static Block_TFFTStorageFieldBlockT4 instance = new Block_TFFTStorageFieldBlockT4(); + + private Block_TFFTStorageFieldBlockT4() { + // I am a singleton + super(Material.iron); + } + + public static Block_TFFTStorageFieldBlockT4 getInstance() { + return instance; + } + + public static int getCapacity() { + return 64000000; + } + + public void registerBlock() { + final String blockName = "kekztech_tfftstoragefieldblock4_block"; + super.setBlockName(blockName); + super.setCreativeTab(CreativeTabs.tabMisc); + super.setBlockTextureName(KekzCore.MODID + ":" + "TFFTStorageFieldBlock4"); + super.setHardness(5.0f); + super.setResistance(6.0f); + GameRegistry.registerBlock(getInstance(), IB_TFFTStorageFieldBlockT4.class, blockName); + } +} diff --git a/src/main/java/common/blocks/Block_TFFTStorageFieldBlockT5.java b/src/main/java/common/blocks/Block_TFFTStorageFieldBlockT5.java new file mode 100644 index 0000000000..437e0454f8 --- /dev/null +++ b/src/main/java/common/blocks/Block_TFFTStorageFieldBlockT5.java @@ -0,0 +1,35 @@ +package common.blocks; + +import cpw.mods.fml.common.registry.GameRegistry; +import itemBlocks.IB_TFFTStorageFieldBlockT5; +import kekztech.KekzCore; +import net.minecraft.block.material.Material; +import net.minecraft.creativetab.CreativeTabs; + +public class Block_TFFTStorageFieldBlockT5 extends BaseGTUpdateableBlock { + + private static Block_TFFTStorageFieldBlockT5 instance = new Block_TFFTStorageFieldBlockT5(); + + private Block_TFFTStorageFieldBlockT5() { + // I am a singleton + super(Material.iron); + } + + public static Block_TFFTStorageFieldBlockT5 getInstance() { + return instance; + } + + public static int getCapacity() { + return 256000000; + } + + public void registerBlock() { + final String blockName = "kekztech_tfftstoragefieldblock5_block"; + super.setBlockName(blockName); + super.setCreativeTab(CreativeTabs.tabMisc); + super.setBlockTextureName(KekzCore.MODID + ":" + "TFFTStorageFieldBlock5"); + super.setHardness(5.0f); + super.setResistance(6.0f); + GameRegistry.registerBlock(getInstance(), IB_TFFTStorageFieldBlockT5.class, blockName); + } +} \ No newline at end of file diff --git a/src/main/java/common/blocks/Block_ThaumiumReinforcedJar.java b/src/main/java/common/blocks/Block_ThaumiumReinforcedJar.java new file mode 100644 index 0000000000..246e3c9b05 --- /dev/null +++ b/src/main/java/common/blocks/Block_ThaumiumReinforcedJar.java @@ -0,0 +1,90 @@ +package common.blocks; + +import java.util.ArrayList; + +import common.tileentities.TE_ThaumiumReinforcedJar; +import cpw.mods.fml.common.registry.GameRegistry; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import items.Item_ThaumiumReinforcedJarFilled; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import thaumcraft.api.aspects.AspectList; +import thaumcraft.common.blocks.BlockJar; +import thaumcraft.common.blocks.ItemJarFilled; +import thaumcraft.common.tiles.TileJarFillable; +import thaumcraft.common.tiles.TileJarFillableVoid; + +public class Block_ThaumiumReinforcedJar extends BlockJar { + + private static Block_ThaumiumReinforcedJar instance = new Block_ThaumiumReinforcedJar(); + + private Block_ThaumiumReinforcedJar() { + super(); + } + + public static Block_ThaumiumReinforcedJar getInstance() { + return instance; + } + + public void registerBlock() { + final String blockName = "kekztech_thaumiumreinforcedjar_block"; + super.setBlockName(blockName); + GameRegistry.registerBlock(getInstance(), blockName); + } + + @Override + @SideOnly(Side.CLIENT) + public void registerBlockIcons(IIconRegister ir) { + super.iconLiquid = ir.registerIcon("thaumcraft:animatedglow"); + super.iconJarSide = ir.registerIcon("kekztech:jar_side"); + super.iconJarTop = ir.registerIcon("kekztech:jar_top"); + super.iconJarTopVoid = ir.registerIcon("kekztech:jar_top_void"); + super.iconJarSideVoid = ir.registerIcon("kekztech:jar_side_void"); + super.iconJarBottom = ir.registerIcon("kekztech:jar_bottom"); + } + + @Override + public TileEntity createTileEntity(World world, int meta) { + return new TE_ThaumiumReinforcedJar(); + } + + @Override + public ArrayList getDrops(World world, int x, int y, int z, int meta, int fortune) { + final ArrayList drops = new ArrayList<>(); + + TileEntity te; + ItemStack drop; + + te = world.getTileEntity(x, y, z); + if(te != null && te instanceof TileJarFillable) { + drop = new ItemStack(Item_ThaumiumReinforcedJarFilled.getInstance()); + // Empty and no label + if(((TileJarFillable) te).amount <= 0 && ((TileJarFillable) te).aspectFilter == null) { + drop = new ItemStack(this); + } + // If is void jar, set meta + if(te instanceof TileJarFillableVoid) { + drop.setItemDamage(3); + } + // Non empty, generate filled jar item with contents + if(((TileJarFillable) te).amount > 0) { + ((ItemJarFilled) drop.getItem()).setAspects(drop, + (new AspectList()).add(((TileJarFillable) te).aspect, ((TileJarFillable) te).amount)); + } + // has label + if(((TileJarFillable) te).aspectFilter != null) { + if(!drop.hasTagCompound()) { + drop.setTagCompound(new NBTTagCompound()); + } + drop.stackTagCompound.setString("AspectFilter", ((TileJarFillable) te).aspectFilter.getTag()); + } + drops.add(drop); + } + return drops; + } + +} diff --git a/src/main/java/common/blocks/Block_YSZUnit.java b/src/main/java/common/blocks/Block_YSZUnit.java new file mode 100644 index 0000000000..60b5603a3e --- /dev/null +++ b/src/main/java/common/blocks/Block_YSZUnit.java @@ -0,0 +1,30 @@ +package common.blocks; + +import cpw.mods.fml.common.registry.GameRegistry; +import kekztech.KekzCore; +import net.minecraft.block.material.Material; +import net.minecraft.creativetab.CreativeTabs; + +public class Block_YSZUnit extends BaseGTUpdateableBlock { + + private static Block_YSZUnit instance = new Block_YSZUnit(); + + private Block_YSZUnit() { + // I am a singleton + super(Material.iron); + } + + public static Block_YSZUnit getInstance() { + return instance; + } + + public void registerBlock() { + final String blockName = "kekztech_yszceramicelectrolyteunit_block"; + super.setBlockName(blockName); + super.setCreativeTab(CreativeTabs.tabMisc); + super.setBlockTextureName(KekzCore.MODID + ":" + "YSZCeramicElectrolyteUnit"); + super.setHardness(5.0f); + super.setResistance(6.0f); + GameRegistry.registerBlock(getInstance(), blockName); + } +} diff --git a/src/main/java/common/tileentities/GTMTE_FluidMultiStorage.java b/src/main/java/common/tileentities/GTMTE_FluidMultiStorage.java new file mode 100644 index 0000000000..d362342366 --- /dev/null +++ b/src/main/java/common/tileentities/GTMTE_FluidMultiStorage.java @@ -0,0 +1,552 @@ +package common.tileentities; + +import gregtech.api.enums.Textures.BlockIcons; +import gregtech.api.gui.GT_GUIContainer_MultiMachine; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Output; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase; +import gregtech.api.objects.GT_RenderedTexture; +import kekztech.MultiFluidHandler; +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.ChatComponentText; +import net.minecraft.util.EnumChatFormatting; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.FluidStack; +import org.lwjgl.input.Keyboard; + +import common.blocks.*; +import util.MultiBlockTooltipBuilder; +import util.Vector3i; +import util.Vector3ic; + +import java.util.ArrayList; +import java.util.HashSet; + +public class GTMTE_FluidMultiStorage extends GT_MetaTileEntity_MultiBlockBase { + + private final static String glassNameAE2 = "tile.appliedenergistics2.BlockQuartzGlass"; + private final static String glassNameStained = "tile.stainedGlass"; + private final static Block CASING = Block_TFFTCasing.getInstance(); + private final static Block_TFFTStorageFieldBlockT1 STORAGE_FIELD1 = Block_TFFTStorageFieldBlockT1.getInstance(); + private final static Block_TFFTStorageFieldBlockT2 STORAGE_FIELD2 = Block_TFFTStorageFieldBlockT2.getInstance(); + private final static Block_TFFTStorageFieldBlockT3 STORAGE_FIELD3 = Block_TFFTStorageFieldBlockT3.getInstance(); + private final static Block_TFFTStorageFieldBlockT4 STORAGE_FIELD4 = Block_TFFTStorageFieldBlockT4.getInstance(); + private final static Block_TFFTStorageFieldBlockT5 STORAGE_FIELD5 = Block_TFFTStorageFieldBlockT5.getInstance(); + private final static Block MULTI_HATCH = Block_TFFTMultiHatch.getInstance(); + private final static int CASING_TEXTURE_ID = 176; + + private MultiFluidHandler mfh; + private HashSet multiHatches = new HashSet<>(); + + private int runningCost = 0; + private boolean doVoidExcess = false; + + private byte fluidSelector = 0; + + public GTMTE_FluidMultiStorage(int aID, String aName, String aNameRegional) { + super(aID, aName, aNameRegional); + } + + public GTMTE_FluidMultiStorage(String aName) { + super(aName); + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity var1) { + return new GTMTE_FluidMultiStorage(super.mName); + } + + @Override + public String[] getDescription() { + final MultiBlockTooltipBuilder b = new MultiBlockTooltipBuilder(); + b.addInfo("High-Tech fluid tank that can hold up to 25 different fluids!") + .addInfo("Has 1/25th of the total capacity as capacity for each fluid.") + .addInfo("Rightclicking the controller with a screwdriver will turn on excess voiding.") + .addInfo("Fluid storage amount and running cost depends on the storage field blocks used.") + .addSeparator() + .addInfo("Note on hatch locking:") + .addInfo("Use an Integrated Circuit in the GUI slot to limit which fluid is output.") + .addInfo("The index of a stored fluid can be obtained through the Tricorder.") + .addSeparator() + .beginStructureBlock(5, 9, 5) + .addController("Top Center") + .addEnergyHatch("Any top or bottom casing") + .addOtherStructurePart("Inner 3x7x3 tube", "Storage Field Blocks") + .addOtherStructurePart("Outer 5x7x5 glass shell", "AE2 Quartz Glass of Vanilla Stained Glass") + .addMaintenanceHatch("Instead of any casing or glass, has to touch storage field.") + .addIOHatches("Instead of any casing or glass, have to touch storage field. True for the Multi-Hatch as well.") + .signAndFinalize("Kekzdealer"); + if (!Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) { + return b.getInformation(); + } else { + return b.getStructureInformation(); + } + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, + boolean aActive, boolean aRedstone) { + return aSide == aFacing + ? new ITexture[]{BlockIcons.casingTexturePages[1][48], + new GT_RenderedTexture(aActive + ? BlockIcons.OVERLAY_FRONT_LARGE_CHEMICAL_REACTOR_ACTIVE + : BlockIcons.OVERLAY_FRONT_LARGE_CHEMICAL_REACTOR)} + : new ITexture[]{BlockIcons.casingTexturePages[1][48]}; + } + + public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) { + return new GT_GUIContainer_MultiMachine(aPlayerInventory, aBaseMetaTileEntity, this.getLocalName(), + "MultiblockDisplay.png"); + } + + @Override + public boolean isCorrectMachinePart(ItemStack var1) { + return true; + } + + @Override + public boolean checkRecipe(ItemStack guiSlotItem) { + + super.mEfficiency = 10000 - (super.getIdealStatus() - super.getRepairStatus()) * 1000; + super.mEfficiencyIncrease = 10000; + super.mEUt = runningCost; + super.mMaxProgresstime = 10; + + if(guiSlotItem != null && guiSlotItem.getUnlocalizedName().equals("gt.integrated_circuit")) { + this.fluidSelector = (byte) guiSlotItem.getItemDamage(); + } + + // If there are no basic I/O hatches, let multi hatches handle it and skip a lot of code! + if (multiHatches.size() > 0 && super.mInputHatches.size() == 0 && super.mOutputHatches.size() == 0) { + return true; + } + + // Suck in fluids + final ArrayList inputHatchFluids = super.getStoredFluids(); + if (inputHatchFluids.size() > 0) { + + for (FluidStack fluidStack : inputHatchFluids) { + + final int pushed = mfh.pushFluid(fluidStack, true); + final FluidStack toDeplete = fluidStack.copy(); + toDeplete.amount = pushed; + super.depleteInput(toDeplete); + } + + // Void excess if that is turned on + if (doVoidExcess) { + for (GT_MetaTileEntity_Hatch_Input inputHatch : super.mInputHatches) { + inputHatch.setDrainableStack(null); + } + } + } + + // Push out fluids + if (guiSlotItem != null && guiSlotItem.getUnlocalizedName().equals("gt.integrated_circuit")) { + final FluidStack storedFluid = mfh.getFluid(fluidSelector); + // Sum available output capacity + int possibleOutput = 0; + for (GT_MetaTileEntity_Hatch_Output outputHatch : super.mOutputHatches) { + if (outputHatch.isFluidLocked() && outputHatch.getLockedFluidName().equals(storedFluid.getUnlocalizedName())) { + possibleOutput += outputHatch.getCapacity() - outputHatch.getFluidAmount(); + } else if (outputHatch.getFluid() != null && outputHatch.getFluid().getUnlocalizedName().equals(storedFluid.getUnlocalizedName())) { + possibleOutput += outputHatch.getCapacity() - outputHatch.getFluidAmount(); + } else if (outputHatch.getFluid() == null) { + possibleOutput += outputHatch.getCapacity() - outputHatch.getFluidAmount(); + } + } + // Output as much as possible + final FluidStack tempStack = storedFluid.copy(); + tempStack.amount = possibleOutput; + tempStack.amount = mfh.pullFluid(tempStack, fluidSelector, true); + super.addOutput(tempStack); + + } else { + for (FluidStack storedFluid : mfh.getFluids()) { + // Sum available output capacity + int possibleOutput = 0; + for (GT_MetaTileEntity_Hatch_Output outputHatch : super.mOutputHatches) { + if (outputHatch.isFluidLocked() && outputHatch.getLockedFluidName().equals(storedFluid.getUnlocalizedName())) { + possibleOutput += outputHatch.getCapacity() - outputHatch.getFluidAmount(); + } else if (outputHatch.getFluid() != null && outputHatch.getFluid().getUnlocalizedName().equals(storedFluid.getUnlocalizedName())) { + possibleOutput += outputHatch.getCapacity() - outputHatch.getFluidAmount(); + } else if (outputHatch.getFluid() == null) { + possibleOutput += outputHatch.getCapacity() - outputHatch.getFluidAmount(); + } + } + // output as much as possible + final FluidStack tempStack = storedFluid.copy(); + tempStack.amount = possibleOutput; + // TODO possible concurrent modification exception as pullFluid calls remove() without an iterator + tempStack.amount = mfh.pullFluid(tempStack, true); + super.addOutput(tempStack); + } + } + + return true; + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + super.onPostTick(aBaseMetaTileEntity, aTick); + + if (mfh != null) { + mfh.setLock(!super.getBaseMetaTileEntity().isActive()); + mfh.setFluidSelector(fluidSelector); + } + } + + public Vector3ic rotateOffsetVector(Vector3ic forgeDirection, int x, int y, int z) { + final Vector3i offset = new Vector3i(); + + // either direction on z-axis + if (forgeDirection.x() == 0 && forgeDirection.z() == -1) { + offset.x = x; + offset.y = y; + offset.z = z; + } + if (forgeDirection.x() == 0 && forgeDirection.z() == 1) { + offset.x = -x; + offset.y = y; + offset.z = -z; + } + // either direction on x-axis + if (forgeDirection.x() == -1 && forgeDirection.z() == 0) { + offset.x = z; + offset.y = y; + offset.z = -x; + } + if (forgeDirection.x() == 1 && forgeDirection.z() == 0) { + offset.x = -z; + offset.y = y; + offset.z = x; + } + // either direction on y-axis + if (forgeDirection.y() == -1) { + offset.x = x; + offset.y = z; + offset.z = y; + } + + return offset; + } + + /** + * Checks structural integrity and registers machine parts. + * Appears to often not run but can be jump started by forcing a block update on the controller. + * (Place a piece of dirt on the front face and remove it again. Dirty fix lol.) + * + * @param thisController Object reference to this controller block's Tile Entity. + * @param guiSlotItem References the item stack that can be placed in that GUI slot + * in the top right. + */ + @Override + public boolean checkMachine(IGregTechTileEntity thisController, ItemStack guiSlotItem) { + // Figure out the vector for the direction the back face of the controller is facing + final Vector3ic forgeDirection = new Vector3i( + ForgeDirection.getOrientation(thisController.getBackFacing()).offsetX, + ForgeDirection.getOrientation(thisController.getBackFacing()).offsetY, + ForgeDirection.getOrientation(thisController.getBackFacing()).offsetZ + ); + int minCasingAmount = 20; + boolean formationChecklist = true; // if this is still true at the end, machine is good to go :) + float runningCostAcc = 0; + double fluidCapacityAcc = 0; + + multiHatches.clear(); + + // Front slice + for (int X = -2; X <= 2; X++) { + for (int Y = -2; Y <= 2; Y++) { + if (X == 0 && Y == 0) { + continue; // is controller + } + + // Get next TE + final Vector3ic offset = rotateOffsetVector(forgeDirection, X, Y, 0); + IGregTechTileEntity currentTE = + thisController.getIGregTechTileEntityOffset(offset.x(), offset.y(), offset.z()); + + // Fluid hatches should touch the storage field. + // Maintenance/Energy hatch can go anywhere + if (X > -2 && X < 2 && Y > -2 && Y < 2) { + if (!super.addMaintenanceToMachineList(currentTE, CASING_TEXTURE_ID) + && !super.addInputToMachineList(currentTE, CASING_TEXTURE_ID) + && !super.addOutputToMachineList(currentTE, CASING_TEXTURE_ID) + && !super.addEnergyInputToMachineList(currentTE, CASING_TEXTURE_ID)) { + + Block b = thisController.getBlockOffset(offset.x(), offset.y(), offset.z()); + + // If it's not a hatch, is it the right casing for this machine? Check block and block meta. + // Also check for multi hatch + if (b == CASING) { + // Seems to be valid casing. Decrement counter. + minCasingAmount--; + } else if (b == MULTI_HATCH) { + final TE_TFFTMultiHatch mh = + (TE_TFFTMultiHatch) thisController.getWorld().getTileEntity( + thisController.getXCoord() + offset.x(), + thisController.getYCoord() + offset.y(), + thisController.getZCoord() + offset.z()); + multiHatches.add(mh); + } else { + formationChecklist = false; + } + } + } else { + if (!super.addMaintenanceToMachineList(currentTE, CASING_TEXTURE_ID) + && !super.addEnergyInputToMachineList(currentTE, CASING_TEXTURE_ID)) { + + // If it's not a hatch, is it the right casing for this machine? Check block and block meta. + if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == CASING) { + // Seems to be valid casing. Decrement counter. + minCasingAmount--; + } else { + formationChecklist = false; + } + } + } + } + } + + // Middle three slices + for (int X = -2; X <= 2; X++) { + for (int Y = -2; Y <= 2; Y++) { + for (int Z = -1; Z >= -7; Z--) { + final Vector3ic offset = rotateOffsetVector(forgeDirection, X, Y, Z); + if (X > -2 && X < 2 && Y > -2 && Y < 2) { + if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()).getUnlocalizedName() + .equals(STORAGE_FIELD1.getUnlocalizedName())) { + runningCostAcc += 0.5f; + fluidCapacityAcc += (float) Block_TFFTStorageFieldBlockT1.getCapacity(); + } else if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()).getUnlocalizedName() + .equals(STORAGE_FIELD2.getUnlocalizedName())) { + runningCostAcc += 1.0f; + fluidCapacityAcc += (float) Block_TFFTStorageFieldBlockT2.getCapacity(); + } else if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()).getUnlocalizedName() + .equals(STORAGE_FIELD3.getUnlocalizedName())) { + runningCostAcc += 2.0f; + fluidCapacityAcc += (float) Block_TFFTStorageFieldBlockT3.getCapacity(); + } else if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()).getUnlocalizedName() + .equals(STORAGE_FIELD4.getUnlocalizedName())) { + runningCostAcc += 4.0f; + fluidCapacityAcc += (float) Block_TFFTStorageFieldBlockT4.getCapacity(); + } else if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()).getUnlocalizedName() + .equals(STORAGE_FIELD5.getUnlocalizedName())) { + runningCostAcc += 8.0f; + fluidCapacityAcc += (float) Block_TFFTStorageFieldBlockT5.getCapacity(); + } else { + formationChecklist = false; + } + continue; + } + + // Get next TE + IGregTechTileEntity currentTE = + thisController.getIGregTechTileEntityOffset(offset.x(), offset.y(), offset.z());// x, y ,z + + // Corner allows only glass or casings + if (X == -2 && Y == -2 || X == 2 && Y == 2 || X == -2 && Y == 2 || X == 2 && Y == -2) { + if (!(thisController.getBlockOffset(offset.x(), offset.y(), offset.z()).getUnlocalizedName().equals(glassNameAE2) + || thisController.getBlockOffset(offset.x(), offset.y(), offset.z()).getUnlocalizedName().equals(glassNameStained) + || thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == CASING)) { + formationChecklist = false; // do nothing yet + } + } else { + // Tries to add TE as either of those kinds of hatches. + // The number is the texture index number for the texture that needs to be painted over the hatch texture (TAE for GT++) + if (!super.addInputToMachineList(currentTE, CASING_TEXTURE_ID) + && !super.addOutputToMachineList(currentTE, CASING_TEXTURE_ID)) { + + // If it's not a hatch, is it the right casing for this machine? Check block and block meta. + // Also check for multi hatch + if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == CASING) { + // Seems to be valid casing. Decrement counter. + minCasingAmount--; + } else if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == MULTI_HATCH) { + final TE_TFFTMultiHatch mh = + (TE_TFFTMultiHatch) thisController.getWorld().getTileEntity( + thisController.getXCoord() + offset.x(), + thisController.getYCoord() + offset.y(), + thisController.getZCoord() + offset.z()); + multiHatches.add(mh); + } else if (!thisController.getBlockOffset(offset.x(), offset.y(), offset.z()).getUnlocalizedName().equals(glassNameAE2) + && !thisController.getBlockOffset(offset.x(), offset.y(), offset.z()).getUnlocalizedName().equals(glassNameStained)) { + formationChecklist = false; + } + } + } + } + } + } + + // Back slice + for (int X = -2; X <= 2; X++) { + for (int Y = -2; Y <= 2; Y++) { + // Get next TE + final Vector3ic offset = rotateOffsetVector(forgeDirection, X, Y, -8); + IGregTechTileEntity currentTE = + thisController.getIGregTechTileEntityOffset(offset.x(), offset.y(), offset.z()); + + // Fluid hatches should touch the storage field. + // Maintenance/Energy hatch can go anywhere + if (X > -2 && X < 2 && Y > -2 && Y < 2) { + if (!super.addMaintenanceToMachineList(currentTE, CASING_TEXTURE_ID) + && !super.addInputToMachineList(currentTE, CASING_TEXTURE_ID) + && !super.addOutputToMachineList(currentTE, CASING_TEXTURE_ID) + && !super.addEnergyInputToMachineList(currentTE, CASING_TEXTURE_ID)) { + + // If it's not a hatch, is it the right casing for this machine? Check block and block meta. + if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == CASING) { + // Seems to be valid casing. Decrement counter. + minCasingAmount--; + } else if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == MULTI_HATCH) { + final TE_TFFTMultiHatch mh = + (TE_TFFTMultiHatch) thisController.getWorld().getTileEntity( + thisController.getXCoord() + offset.x(), + thisController.getYCoord() + offset.y(), + thisController.getZCoord() + offset.z()); + multiHatches.add(mh); + } else { + formationChecklist = false; + } + } + } else { + if (!super.addMaintenanceToMachineList(currentTE, CASING_TEXTURE_ID) + && !super.addEnergyInputToMachineList(currentTE, CASING_TEXTURE_ID)) { + + // If it's not a hatch, is it the right casing for this machine? Check block and block meta. + if (thisController.getBlockOffset(offset.x(), offset.y(), offset.z()) == CASING) { + // Seems to be valid casing. Decrement counter. + minCasingAmount--; + } else { + formationChecklist = false; + } + } + } + } + } + + if (this.mEnergyHatches.size() < 1) { + System.out.println("At least one energy hatch is required!"); + formationChecklist = false; + } + + if (this.mMaintenanceHatches.size() < 1) { + System.out.println("You need a maintenance hatch to do maintenance."); + formationChecklist = false; + } + + if (minCasingAmount > 0) { + formationChecklist = false; + } + + if (formationChecklist) { + runningCost = Math.round(-runningCostAcc); + // Update MultiFluidHandler in case storage cells have been changed + final int capacityPerFluid = (int) Math.round(fluidCapacityAcc / 25.0f); + if (mfh == null) { + mfh = new MultiFluidHandler(capacityPerFluid); + } else { + if (mfh.getCapacity() != capacityPerFluid) { + mfh = new MultiFluidHandler(capacityPerFluid, mfh.getFluids()); + } + } + for (TE_TFFTMultiHatch mh : multiHatches) { + mh.setMultiFluidHandler(mfh); + } + } + + return formationChecklist; + } + + @Override + public void onScrewdriverRightClick(byte aSide, EntityPlayer aPlayer, float aX, float aY, float aZ) { + if (doVoidExcess) { + doVoidExcess = false; + aPlayer.addChatComponentMessage(new ChatComponentText("Auto-voiding turned off")); + } else { + doVoidExcess = true; + aPlayer.addChatComponentMessage(new ChatComponentText("Auto-voiding turned on")); + } + } + + @Override + public String[] getInfoData() { + final ArrayList ll = mfh.getInfoData(); + + ll.add(EnumChatFormatting.YELLOW + "Operational Data:" + EnumChatFormatting.RESET); + ll.add("Auto-voiding: " + doVoidExcess); + ll.add("Per-Fluid Capacity: " + mfh.getCapacity() + "L"); + ll.add("Running Cost: " + // mEUt does not naturally reflect efficiency status. Do that here. + + ((-super.mEUt) * 10000 / Math.max(1000, super.mEfficiency)) + "EU/t"); + ll.add("Maintenance Status: " + ((super.getRepairStatus() == super.getIdealStatus()) + ? EnumChatFormatting.GREEN + "Working perfectly" + EnumChatFormatting.RESET + : EnumChatFormatting.RED + "Has Problems" + EnumChatFormatting.RESET)); + ll.add("---------------------------------------------"); + + final String[] a = new String[ll.size()]; + return ll.toArray(a); + } + + @Override + public void saveNBTData(NBTTagCompound nbt) { + nbt = (nbt == null) ? new NBTTagCompound() : nbt; + + nbt.setInteger("runningCost", runningCost); + nbt.setBoolean("doVoidExcess", doVoidExcess); + + nbt.setInteger("capacityPerFluid", mfh.getCapacity()); + nbt.setTag("fluids", mfh.saveNBTData(new NBTTagCompound())); + + super.saveNBTData(nbt); + } + + @Override + public void loadNBTData(NBTTagCompound nbt) { + nbt = (nbt == null) ? new NBTTagCompound() : nbt; + + runningCost = nbt.getInteger("runningCost"); + doVoidExcess = nbt.getBoolean("doVoidExcess"); + + mfh = new MultiFluidHandler(); + mfh.loadNBTData(nbt); + for (TE_TFFTMultiHatch mh : multiHatches) { + mh.setMultiFluidHandler(mfh); + } + super.loadNBTData(nbt); + } + + @Override + public boolean isGivingInformation() { + return true; + } + + @Override + public int getMaxEfficiency(ItemStack var1) { + return 10000; + } + + @Override + public int getPollutionPerTick(ItemStack var1) { + return 0; + } + + @Override + public int getDamageToComponent(ItemStack var1) { + return 0; + } + + @Override + public boolean explodesOnComponentBreak(ItemStack var1) { + return false; + } +} \ No newline at end of file diff --git a/src/main/java/common/tileentities/GTMTE_ItemServer.java b/src/main/java/common/tileentities/GTMTE_ItemServer.java new file mode 100644 index 0000000000..158207fd5c --- /dev/null +++ b/src/main/java/common/tileentities/GTMTE_ItemServer.java @@ -0,0 +1,405 @@ +package common.tileentities; + +import java.util.ArrayList; +import java.util.HashSet; + +import org.lwjgl.input.Keyboard; + +import common.blocks.Block_ItemServerDrive; +import common.blocks.Block_ItemServerIOPort; +import common.blocks.Block_ItemServerRackCasing; +import gregtech.api.enums.Textures.BlockIcons; +import gregtech.api.gui.GT_GUIContainer_MultiMachine; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase; +import gregtech.api.objects.GT_RenderedTexture; +import kekztech.MultiItemHandler; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraftforge.common.util.ForgeDirection; +import util.MultiBlockTooltipBuilder; +import util.Vector3i; +import util.Vector3ic; + +public class GTMTE_ItemServer extends GT_MetaTileEntity_MultiBlockBase { + + private static final int BASE_SLICE_ENERGY_COST = 1; + private static final int BASE_PER_ITEM_CAPACITY = 1024; + private static final int BASE_ITEM_TYPES_PER_SLICE = 128; + + private final Block_ItemServerDrive DRIVE = Block_ItemServerDrive.getInstance(); + private final Block_ItemServerRackCasing CASING = Block_ItemServerRackCasing.getInstance(); + private final Block_ItemServerIOPort IO_PORT = Block_ItemServerIOPort.getInstance(); + private final String ALU_FRAME_BOX_NAME = "gt.blockmachines"; + private final int ALU_FRAME_BOX_META = 6;//4115; + private final int CASING_TEXTURE_ID = 176; + + private MultiItemHandler mih; + private HashSet ioPorts = new HashSet<>(); + private int sliceCount = 0; + + public GTMTE_ItemServer(int aID, String aName, String aNameRegional) { + super(aID, aName, aNameRegional); + } + + public GTMTE_ItemServer(String aName) { + super(aName); + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity var1) { + return new GTMTE_ItemServer(super.mName); + } + + @Override + public String[] getDescription() { + final MultiBlockTooltipBuilder b = new MultiBlockTooltipBuilder(); + b.addInfo("[W.I.P - Probably doesn't work]") + .addInfo("High-Tech item storage!") + .addInfo("Variable length: Slices 2-4 can be repeated as long as the total length does not exceed 16 blocks.") + .addInfo("Each slice offers storage for 128 item types") + .addInfo("Storage capacity per item depends on the controller configuration.") + .addInfo("Insert an Integrated Circuit into the controller with your desired configuration.") + .add