From 7224ac4299098c70efae9dbd04c50a97e3f5f583 Mon Sep 17 00:00:00 2001 From: Blood Asp Date: Thu, 23 Apr 2015 18:14:22 +0200 Subject: Initial Commit --- .../automation/GT_MetaTileEntity_ChestBuffer.java | 81 ++++ .../automation/GT_MetaTileEntity_Filter.java | 94 +++++ .../automation/GT_MetaTileEntity_Regulator.java | 113 ++++++ .../automation/GT_MetaTileEntity_SuperBuffer.java | 51 +++ .../automation/GT_MetaTileEntity_TypeFilter.java | 141 +++++++ .../boilers/GT_MetaTileEntity_Boiler.java | 329 ++++++++++++++++ .../boilers/GT_MetaTileEntity_Boiler_Bronze.java | 176 +++++++++ .../boilers/GT_MetaTileEntity_Boiler_Lava.java | 166 +++++++++ .../boilers/GT_MetaTileEntity_Boiler_Solar.java | 157 ++++++++ .../boilers/GT_MetaTileEntity_Boiler_Steel.java | 186 ++++++++++ .../GT_MetaTileEntity_DieselGenerator.java | 132 +++++++ .../GT_MetaTileEntity_FluidNaquadahReactor.java | 106 ++++++ .../generators/GT_MetaTileEntity_GasTurbine.java | 118 ++++++ .../GT_MetaTileEntity_MagicEnergyConverter.java | 112 ++++++ .../GT_MetaTileEntity_PlasmaGenerator.java | 112 ++++++ .../GT_MetaTileEntity_SolidNaquadahReactor.java | 106 ++++++ .../generators/GT_MetaTileEntity_SteamTurbine.java | 129 +++++++ .../GT_MetaTileEntity_BasicHull_Bronze.java | 47 +++ .../GT_MetaTileEntity_BasicHull_BronzeBricks.java | 48 +++ .../GT_MetaTileEntity_BasicHull_Steel.java | 49 +++ .../GT_MetaTileEntity_BasicHull_SteelBricks.java | 49 +++ .../basic/GT_MetaTileEntity_Boxinator.java | 109 ++++++ .../basic/GT_MetaTileEntity_Disassembler.java | 71 ++++ .../basic/GT_MetaTileEntity_Massfabricator.java | 83 +++++ .../basic/GT_MetaTileEntity_PotionBrewer.java | 165 ++++++++ .../machines/basic/GT_MetaTileEntity_Printer.java | 71 ++++ .../basic/GT_MetaTileEntity_Replicator.java | 125 +++++++ .../basic/GT_MetaTileEntity_RockBreaker.java | 88 +++++ .../machines/basic/GT_MetaTileEntity_Scanner.java | 211 +++++++++++ .../GT_MetaTileEntity_BronzeBlastFurnace.java | 406 ++++++++++++++++++++ .../multi/GT_MetaTileEntity_DistillationTower.java | 176 +++++++++ .../GT_MetaTileEntity_ElectricBlastFurnace.java | 249 +++++++++++++ .../multi/GT_MetaTileEntity_FusionComputer.java | 413 +++++++++++++++++++++ .../multi/GT_MetaTileEntity_FusionComputer1.java | 46 +++ .../multi/GT_MetaTileEntity_FusionComputer2.java | 46 +++ .../multi/GT_MetaTileEntity_FusionComputer3.java | 47 +++ .../GT_MetaTileEntity_ImplosionCompressor.java | 180 +++++++++ .../multi/GT_MetaTileEntity_LargeBoiler.java | 251 +++++++++++++ .../GT_MetaTileEntity_LargeBoiler_Bronze.java | 81 ++++ .../multi/GT_MetaTileEntity_LargeBoiler_Steel.java | 81 ++++ .../GT_MetaTileEntity_LargeBoiler_Titanium.java | 81 ++++ ...T_MetaTileEntity_LargeBoiler_TungstenSteel.java | 81 ++++ .../multi/GT_MetaTileEntity_MultiFurnace.java | 195 ++++++++++ .../multi/GT_MetaTileEntity_ProcessingArray.java | 171 +++++++++ .../multi/GT_MetaTileEntity_VacuumFreezer.java | 175 +++++++++ .../GT_MetaTileEntity_AlloySmelter_Bronze.java | 122 ++++++ .../GT_MetaTileEntity_AlloySmelter_Steel.java | 122 ++++++ .../steam/GT_MetaTileEntity_Compressor_Bronze.java | 118 ++++++ .../steam/GT_MetaTileEntity_Compressor_Steel.java | 118 ++++++ .../steam/GT_MetaTileEntity_Extractor_Bronze.java | 118 ++++++ .../steam/GT_MetaTileEntity_Extractor_Steel.java | 118 ++++++ .../GT_MetaTileEntity_ForgeHammer_Bronze.java | 122 ++++++ .../steam/GT_MetaTileEntity_ForgeHammer_Steel.java | 122 ++++++ .../steam/GT_MetaTileEntity_Furnace_Bronze.java | 118 ++++++ .../steam/GT_MetaTileEntity_Furnace_Steel.java | 118 ++++++ .../steam/GT_MetaTileEntity_Macerator_Bronze.java | 130 +++++++ .../steam/GT_MetaTileEntity_Macerator_Steel.java | 130 +++++++ .../storage/GT_MetaTileEntity_Locker.java | 203 ++++++++++ .../storage/GT_MetaTileEntity_QuantumTank.java | 126 +++++++ 59 files changed, 7889 insertions(+) create mode 100644 main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_ChestBuffer.java create mode 100644 main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_Filter.java create mode 100644 main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_Regulator.java create mode 100644 main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_SuperBuffer.java create mode 100644 main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_TypeFilter.java create mode 100644 main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler.java create mode 100644 main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Bronze.java create mode 100644 main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Lava.java create mode 100644 main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Solar.java create mode 100644 main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Steel.java create mode 100644 main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_DieselGenerator.java create mode 100644 main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_FluidNaquadahReactor.java create mode 100644 main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_GasTurbine.java create mode 100644 main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_MagicEnergyConverter.java create mode 100644 main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_PlasmaGenerator.java create mode 100644 main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_SolidNaquadahReactor.java create mode 100644 main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_SteamTurbine.java create mode 100644 main/java/gregtech/common/tileentities/machines/GT_MetaTileEntity_BasicHull_Bronze.java create mode 100644 main/java/gregtech/common/tileentities/machines/GT_MetaTileEntity_BasicHull_BronzeBricks.java create mode 100644 main/java/gregtech/common/tileentities/machines/GT_MetaTileEntity_BasicHull_Steel.java create mode 100644 main/java/gregtech/common/tileentities/machines/GT_MetaTileEntity_BasicHull_SteelBricks.java create mode 100644 main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Boxinator.java create mode 100644 main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Disassembler.java create mode 100644 main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Massfabricator.java create mode 100644 main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_PotionBrewer.java create mode 100644 main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Printer.java create mode 100644 main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Replicator.java create mode 100644 main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_RockBreaker.java create mode 100644 main/java/gregtech/common/tileentities/machines/basic/GT_MetaTileEntity_Scanner.java create mode 100644 main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_BronzeBlastFurnace.java create mode 100644 main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_DistillationTower.java create mode 100644 main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_ElectricBlastFurnace.java create mode 100644 main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_FusionComputer.java create mode 100644 main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_FusionComputer1.java create mode 100644 main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_FusionComputer2.java create mode 100644 main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_FusionComputer3.java create mode 100644 main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_ImplosionCompressor.java create mode 100644 main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_LargeBoiler.java create mode 100644 main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_LargeBoiler_Bronze.java create mode 100644 main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_LargeBoiler_Steel.java create mode 100644 main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_LargeBoiler_Titanium.java create mode 100644 main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_LargeBoiler_TungstenSteel.java create mode 100644 main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_MultiFurnace.java create mode 100644 main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_ProcessingArray.java create mode 100644 main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_VacuumFreezer.java create mode 100644 main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_AlloySmelter_Bronze.java create mode 100644 main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_AlloySmelter_Steel.java create mode 100644 main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Compressor_Bronze.java create mode 100644 main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Compressor_Steel.java create mode 100644 main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Extractor_Bronze.java create mode 100644 main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Extractor_Steel.java create mode 100644 main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_ForgeHammer_Bronze.java create mode 100644 main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_ForgeHammer_Steel.java create mode 100644 main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Furnace_Bronze.java create mode 100644 main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Furnace_Steel.java create mode 100644 main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Macerator_Bronze.java create mode 100644 main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Macerator_Steel.java create mode 100644 main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_Locker.java create mode 100644 main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_QuantumTank.java (limited to 'main/java/gregtech/common/tileentities') diff --git a/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_ChestBuffer.java b/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_ChestBuffer.java new file mode 100644 index 0000000000..a14378f845 --- /dev/null +++ b/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_ChestBuffer.java @@ -0,0 +1,81 @@ +/* 1: */ package gregtech.common.tileentities.automation; +/* 2: */ +/* 3: */ import gregtech.api.enums.Textures; +import gregtech.api.enums.Textures.BlockIcons; +/* 4: */ import gregtech.api.interfaces.ITexture; +/* 5: */ import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +/* 6: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 7: */ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Buffer; +/* 8: */ import gregtech.api.objects.GT_RenderedTexture; +/* 9: */ import gregtech.api.util.GT_Utility; +/* 10: */ import gregtech.common.gui.GT_Container_ChestBuffer; +/* 11: */ import gregtech.common.gui.GT_GUIContainer_ChestBuffer; +/* 12: */ import net.minecraft.entity.player.InventoryPlayer; +/* 13: */ +/* 14: */ public class GT_MetaTileEntity_ChestBuffer +/* 15: */ extends GT_MetaTileEntity_Buffer +/* 16: */ { +/* 17: */ public GT_MetaTileEntity_ChestBuffer(int aID, String aName, String aNameRegional, int aTier) +/* 18: */ { +/* 19:16 */ super(aID, aName, aNameRegional, aTier, 28, "Buffering lots of incoming Items"); +/* 20: */ } +/* 21: */ +/* 22: */ public GT_MetaTileEntity_ChestBuffer(int aID, String aName, String aNameRegional, int aTier, int aInvSlotCount, String aDescription) +/* 23: */ { +/* 24:20 */ super(aID, aName, aNameRegional, aTier, aInvSlotCount, aDescription); +/* 25: */ } +/* 26: */ +/* 27: */ public GT_MetaTileEntity_ChestBuffer(String aName, int aTier, int aInvSlotCount, String aDescription, ITexture[][][] aTextures) +/* 28: */ { +/* 29:24 */ super(aName, aTier, aInvSlotCount, aDescription, aTextures); +/* 30: */ } +/* 31: */ +/* 32: */ public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 33: */ { +/* 34:29 */ return new GT_MetaTileEntity_ChestBuffer(this.mName, this.mTier, this.mInventory.length, this.mDescription, this.mTextures); +/* 35: */ } +/* 36: */ +/* 37: */ public ITexture getOverlayIcon() +/* 38: */ { +/* 39:34 */ return new GT_RenderedTexture(Textures.BlockIcons.AUTOMATION_CHESTBUFFER); +/* 40: */ } +/* 41: */ +/* 42: */ public boolean isValidSlot(int aIndex) +/* 43: */ { +/* 44:37 */ return aIndex < this.mInventory.length - 1; +/* 45: */ } +/* 46: */ +/* 47: */ protected void moveItems(IGregTechTileEntity aBaseMetaTileEntity, long aTimer) +/* 48: */ { +/* 49:41 */ fillStacksIntoFirstSlots(); +/* 50:42 */ super.moveItems(aBaseMetaTileEntity, aTimer); +/* 51:43 */ fillStacksIntoFirstSlots(); +/* 52: */ } +/* 53: */ +/* 54: */ protected void fillStacksIntoFirstSlots() +/* 55: */ { +/* 56:47 */ for (int i = 0; i < this.mInventory.length - 1; i++) { +/* 57:47 */ for (int j = i + 1; j < this.mInventory.length - 1; j++) { +/* 58:47 */ if ((this.mInventory[j] != null) && ((this.mInventory[i] == null) || (GT_Utility.areStacksEqual(this.mInventory[i], this.mInventory[j])))) { +/* 59:48 */ GT_Utility.moveStackFromSlotAToSlotB(getBaseMetaTileEntity(), getBaseMetaTileEntity(), j, i, (byte)64, (byte)1, (byte)64, (byte)1); +/* 60: */ } +/* 61: */ } +/* 62: */ } +/* 63: */ } +/* 64: */ +/* 65: */ public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 66: */ { +/* 67:54 */ return new GT_Container_ChestBuffer(aPlayerInventory, aBaseMetaTileEntity); +/* 68: */ } +/* 69: */ +/* 70: */ public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 71: */ { +/* 72:59 */ return new GT_GUIContainer_ChestBuffer(aPlayerInventory, aBaseMetaTileEntity); +/* 73: */ } +/* 74: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.automation.GT_MetaTileEntity_ChestBuffer + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_Filter.java b/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_Filter.java new file mode 100644 index 0000000000..15ec5a323c --- /dev/null +++ b/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_Filter.java @@ -0,0 +1,94 @@ +/* 1: */ package gregtech.common.tileentities.automation; +/* 2: */ +/* 3: */ import gregtech.api.enums.Textures; +import gregtech.api.enums.Textures.BlockIcons; +/* 4: */ import gregtech.api.interfaces.ITexture; +/* 5: */ import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +/* 6: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 7: */ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Buffer; +/* 8: */ import gregtech.api.objects.GT_RenderedTexture; +/* 9: */ import gregtech.api.util.GT_Utility; +/* 10: */ import gregtech.common.gui.GT_Container_Filter; +/* 11: */ import gregtech.common.gui.GT_GUIContainer_Filter; +/* 12: */ import net.minecraft.entity.player.InventoryPlayer; +/* 13: */ import net.minecraft.item.ItemStack; +/* 14: */ import net.minecraft.nbt.NBTTagCompound; +/* 15: */ +/* 16: */ public class GT_MetaTileEntity_Filter +/* 17: */ extends GT_MetaTileEntity_Buffer +/* 18: */ { +/* 19:17 */ public boolean bIgnoreNBT = false; +/* 20:17 */ public boolean bInvertFilter = false; +/* 21: */ +/* 22: */ public GT_MetaTileEntity_Filter(int aID, String aName, String aNameRegional, int aTier) +/* 23: */ { +/* 24:20 */ super(aID, aName, aNameRegional, aTier, 19, "Filtering incoming Items"); +/* 25: */ } +/* 26: */ +/* 27: */ public GT_MetaTileEntity_Filter(String aName, int aTier, int aInvSlotCount, String aDescription, ITexture[][][] aTextures) +/* 28: */ { +/* 29:24 */ super(aName, aTier, aInvSlotCount, aDescription, aTextures); +/* 30: */ } +/* 31: */ +/* 32: */ public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 33: */ { +/* 34:29 */ return new GT_MetaTileEntity_Filter(this.mName, this.mTier, this.mInventory.length, this.mDescription, this.mTextures); +/* 35: */ } +/* 36: */ +/* 37: */ public ITexture getOverlayIcon() +/* 38: */ { +/* 39:34 */ return new GT_RenderedTexture(Textures.BlockIcons.AUTOMATION_FILTER); +/* 40: */ } +/* 41: */ +/* 42: */ public boolean isValidSlot(int aIndex) +/* 43: */ { +/* 44:37 */ return aIndex < 9; +/* 45: */ } +/* 46: */ +/* 47: */ public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 48: */ { +/* 49:41 */ return new GT_Container_Filter(aPlayerInventory, aBaseMetaTileEntity); +/* 50: */ } +/* 51: */ +/* 52: */ public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 53: */ { +/* 54:46 */ return new GT_GUIContainer_Filter(aPlayerInventory, aBaseMetaTileEntity); +/* 55: */ } +/* 56: */ +/* 57: */ public void saveNBTData(NBTTagCompound aNBT) +/* 58: */ { +/* 59:51 */ super.saveNBTData(aNBT); +/* 60:52 */ aNBT.setBoolean("bInvertFilter", this.bInvertFilter); +/* 61:53 */ aNBT.setBoolean("bIgnoreNBT", this.bIgnoreNBT); +/* 62: */ } +/* 63: */ +/* 64: */ public void loadNBTData(NBTTagCompound aNBT) +/* 65: */ { +/* 66:58 */ super.loadNBTData(aNBT); +/* 67:59 */ this.bInvertFilter = aNBT.getBoolean("bInvertFilter"); +/* 68:60 */ this.bIgnoreNBT = aNBT.getBoolean("bIgnoreNBT"); +/* 69: */ } +/* 70: */ +/* 71: */ public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) +/* 72: */ { +/* 73:65 */ if (!super.allowPutStack(aBaseMetaTileEntity, aIndex, aSide, aStack)) { +/* 74:65 */ return false; +/* 75: */ } +/* 76:66 */ if (this.bInvertFilter) +/* 77: */ { +/* 78:67 */ for (byte i = 9; i < 18; i = (byte)(i + 1)) { +/* 79:67 */ if (GT_Utility.areStacksEqual(this.mInventory[i], aStack, this.bIgnoreNBT)) { +/* 80:67 */ return false; +/* 81: */ } +/* 82: */ } +/* 83:68 */ return true; +/* 84: */ } +/* 85:70 */ return GT_Utility.areStacksEqual(this.mInventory[(aIndex + 9)], aStack, this.bIgnoreNBT); +/* 86: */ } +/* 87: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.automation.GT_MetaTileEntity_Filter + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_Regulator.java b/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_Regulator.java new file mode 100644 index 0000000000..fda2e12630 --- /dev/null +++ b/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_Regulator.java @@ -0,0 +1,113 @@ +/* 1: */ package gregtech.common.tileentities.automation; +/* 2: */ +/* 3: */ import gregtech.api.enums.Textures; +import gregtech.api.enums.Textures.BlockIcons; +/* 4: */ import gregtech.api.interfaces.ITexture; +/* 5: */ import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +/* 6: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 7: */ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Buffer; +/* 8: */ import gregtech.api.objects.GT_RenderedTexture; +/* 9: */ import gregtech.api.util.GT_Utility; +/* 10: */ import gregtech.common.gui.GT_Container_Regulator; +/* 11: */ import gregtech.common.gui.GT_GUIContainer_Regulator; + +/* 12: */ import java.util.Arrays; + +/* 13: */ import net.minecraft.entity.player.InventoryPlayer; +/* 14: */ import net.minecraft.item.ItemStack; +/* 15: */ import net.minecraft.nbt.NBTTagCompound; +/* 16: */ +/* 17: */ public class GT_MetaTileEntity_Regulator +/* 18: */ extends GT_MetaTileEntity_Buffer +/* 19: */ { +/* 20:20 */ public int[] mTargetSlots = { 0, 0, 0, 0, 0, 0, 0, 0, 0 }; +/* 21: */ +/* 22: */ public GT_MetaTileEntity_Regulator(int aID, String aName, String aNameRegional, int aTier) +/* 23: */ { +/* 24:23 */ super(aID, aName, aNameRegional, aTier, 19, "Regulating incoming Items"); +/* 25: */ } +/* 26: */ +/* 27: */ public GT_MetaTileEntity_Regulator(String aName, int aTier, int aInvSlotCount, String aDescription, ITexture[][][] aTextures) +/* 28: */ { +/* 29:27 */ super(aName, aTier, aInvSlotCount, aDescription, aTextures); +/* 30: */ } +/* 31: */ +/* 32: */ public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 33: */ { +/* 34:32 */ return new GT_MetaTileEntity_Regulator(this.mName, this.mTier, this.mInventory.length, this.mDescription, this.mTextures); +/* 35: */ } +/* 36: */ +/* 37: */ public ITexture getOverlayIcon() +/* 38: */ { +/* 39:37 */ return new GT_RenderedTexture(Textures.BlockIcons.AUTOMATION_REGULATOR); +/* 40: */ } +/* 41: */ +/* 42: */ public boolean isValidSlot(int aIndex) +/* 43: */ { +/* 44:40 */ return aIndex < 9; +/* 45: */ } +/* 46: */ +/* 47: */ public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 48: */ { +/* 49:44 */ return new GT_Container_Regulator(aPlayerInventory, aBaseMetaTileEntity); +/* 50: */ } +/* 51: */ +/* 52: */ public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 53: */ { +/* 54:49 */ return new GT_GUIContainer_Regulator(aPlayerInventory, aBaseMetaTileEntity); +/* 55: */ } +/* 56: */ +/* 57: */ public void saveNBTData(NBTTagCompound aNBT) +/* 58: */ { +/* 59:54 */ super.saveNBTData(aNBT); +/* 60:55 */ aNBT.setInteger("mTargetSlot1", this.mTargetSlots[0]); +/* 61:56 */ aNBT.setInteger("mTargetSlot2", this.mTargetSlots[1]); +/* 62:57 */ aNBT.setInteger("mTargetSlot3", this.mTargetSlots[2]); +/* 63:58 */ aNBT.setInteger("mTargetSlot4", this.mTargetSlots[3]); +/* 64:59 */ aNBT.setInteger("mTargetSlot5", this.mTargetSlots[4]); +/* 65:60 */ aNBT.setInteger("mTargetSlot6", this.mTargetSlots[5]); +/* 66:61 */ aNBT.setInteger("mTargetSlot7", this.mTargetSlots[6]); +/* 67:62 */ aNBT.setInteger("mTargetSlot8", this.mTargetSlots[7]); +/* 68:63 */ aNBT.setInteger("mTargetSlot9", this.mTargetSlots[8]); +/* 69: */ } +/* 70: */ +/* 71: */ public void loadNBTData(NBTTagCompound aNBT) +/* 72: */ { +/* 73:68 */ super.loadNBTData(aNBT); +/* 74:69 */ this.mTargetSlots[0] = aNBT.getInteger("mTargetSlot1"); +/* 75:70 */ this.mTargetSlots[1] = aNBT.getInteger("mTargetSlot2"); +/* 76:71 */ this.mTargetSlots[2] = aNBT.getInteger("mTargetSlot3"); +/* 77:72 */ this.mTargetSlots[3] = aNBT.getInteger("mTargetSlot4"); +/* 78:73 */ this.mTargetSlots[4] = aNBT.getInteger("mTargetSlot5"); +/* 79:74 */ this.mTargetSlots[5] = aNBT.getInteger("mTargetSlot6"); +/* 80:75 */ this.mTargetSlots[6] = aNBT.getInteger("mTargetSlot7"); +/* 81:76 */ this.mTargetSlots[7] = aNBT.getInteger("mTargetSlot8"); +/* 82:77 */ this.mTargetSlots[8] = aNBT.getInteger("mTargetSlot9"); +/* 83: */ } +/* 84: */ +/* 85: */ public void moveItems(IGregTechTileEntity aBaseMetaTileEntity, long aTimer) +/* 86: */ { +/* 87:82 */ int i = 0; +/* 88:82 */ for (int tCosts = 0; i < 9; i++) { +/* 89:82 */ if (this.mInventory[(i + 9)] != null) +/* 90: */ { +/* 91:83 */ tCosts = GT_Utility.moveOneItemStackIntoSlot(getBaseMetaTileEntity(), getBaseMetaTileEntity().getTileEntityAtSide(getBaseMetaTileEntity().getBackFacing()), getBaseMetaTileEntity().getBackFacing(), this.mTargetSlots[i], Arrays.asList(new ItemStack[] { this.mInventory[(i + 9)] }), false, (byte)this.mInventory[(i + 9)].stackSize, (byte)this.mInventory[(i + 9)].stackSize, (byte)64, (byte)1) * 3; +/* 92:84 */ if (tCosts > 0) +/* 93: */ { +/* 94:84 */ this.mSuccess = 50;getBaseMetaTileEntity().decreaseStoredEnergyUnits(tCosts, true); break; +/* 95: */ } +/* 96: */ } +/* 97: */ } +/* 98: */ } +/* 99: */ +/* :0: */ public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) +/* :1: */ { +/* :2:90 */ return (super.allowPutStack(aBaseMetaTileEntity, aIndex, aSide, aStack)) && (GT_Utility.areStacksEqual(aStack, this.mInventory[(aIndex + 9)])); +/* :3: */ } +/* :4: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.automation.GT_MetaTileEntity_Regulator + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_SuperBuffer.java b/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_SuperBuffer.java new file mode 100644 index 0000000000..48f6bc8796 --- /dev/null +++ b/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_SuperBuffer.java @@ -0,0 +1,51 @@ +/* 1: */ package gregtech.common.tileentities.automation; +/* 2: */ +/* 3: */ import gregtech.api.enums.Textures; +import gregtech.api.enums.Textures.BlockIcons; +/* 4: */ import gregtech.api.interfaces.ITexture; +/* 5: */ import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +/* 6: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 7: */ import gregtech.api.objects.GT_RenderedTexture; +/* 8: */ import gregtech.common.gui.GT_Container_SuperBuffer; +/* 9: */ import gregtech.common.gui.GT_GUIContainer_SuperBuffer; +/* 10: */ import net.minecraft.entity.player.InventoryPlayer; +/* 11: */ +/* 12: */ public class GT_MetaTileEntity_SuperBuffer +/* 13: */ extends GT_MetaTileEntity_ChestBuffer +/* 14: */ { +/* 15: */ public GT_MetaTileEntity_SuperBuffer(int aID, String aName, String aNameRegional, int aTier) +/* 16: */ { +/* 17:14 */ super(aID, aName, aNameRegional, aTier, 257, "Buffering up to 256 Stacks"); +/* 18: */ } +/* 19: */ +/* 20: */ public GT_MetaTileEntity_SuperBuffer(String aName, int aTier, int aInvSlotCount, String aDescription, ITexture[][][] aTextures) +/* 21: */ { +/* 22:18 */ super(aName, aTier, aInvSlotCount, aDescription, aTextures); +/* 23: */ } +/* 24: */ +/* 25: */ public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 26: */ { +/* 27:23 */ return new GT_MetaTileEntity_SuperBuffer(this.mName, this.mTier, this.mInventory.length, this.mDescription, this.mTextures); +/* 28: */ } +/* 29: */ +/* 30: */ public ITexture getOverlayIcon() +/* 31: */ { +/* 32:28 */ return new GT_RenderedTexture(Textures.BlockIcons.AUTOMATION_SUPERBUFFER); +/* 33: */ } +/* 34: */ +/* 35: */ public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 36: */ { +/* 37:33 */ return new GT_Container_SuperBuffer(aPlayerInventory, aBaseMetaTileEntity); +/* 38: */ } +/* 39: */ +/* 40: */ public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 41: */ { +/* 42:38 */ return new GT_GUIContainer_SuperBuffer(aPlayerInventory, aBaseMetaTileEntity); +/* 43: */ } +/* 44: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.automation.GT_MetaTileEntity_SuperBuffer + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_TypeFilter.java b/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_TypeFilter.java new file mode 100644 index 0000000000..ae576638a5 --- /dev/null +++ b/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_TypeFilter.java @@ -0,0 +1,141 @@ +/* 1: */ package gregtech.common.tileentities.automation; +/* 2: */ +/* 3: */ import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.Textures; +/* 4: */ import gregtech.api.enums.Textures.BlockIcons; +/* 5: */ import gregtech.api.interfaces.ITexture; +/* 6: */ import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +/* 7: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 8: */ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Buffer; +/* 9: */ import gregtech.api.objects.GT_RenderedTexture; +/* 10: */ import gregtech.api.util.GT_Utility; +/* 11: */ import gregtech.common.gui.GT_Container_TypeFilter; +/* 12: */ import gregtech.common.gui.GT_GUIContainer_TypeFilter; + +/* 13: */ import java.util.ArrayList; + +/* 14: */ import net.minecraft.entity.player.InventoryPlayer; +/* 15: */ import net.minecraft.item.ItemStack; +/* 16: */ import net.minecraft.nbt.NBTTagCompound; +/* 17: */ +/* 18: */ public class GT_MetaTileEntity_TypeFilter +/* 19: */ extends GT_MetaTileEntity_Buffer +/* 20: */ { +/* 21: 19 */ public boolean bNBTAllowed = false; +/* 22: 19 */ public boolean bInvertFilter = false; +/* 23: 20 */ public int mRotationIndex = 0; +/* 24: 21 */ public OrePrefixes mPrefix = OrePrefixes.ore; +/* 25: */ +/* 26: */ public GT_MetaTileEntity_TypeFilter(int aID, String aName, String aNameRegional, int aTier) +/* 27: */ { +/* 28: 24 */ super(aID, aName, aNameRegional, aTier, 11, "Filtering incoming Items by Type"); +/* 29: */ } +/* 30: */ +/* 31: */ public GT_MetaTileEntity_TypeFilter(String aName, int aTier, int aInvSlotCount, String aDescription, ITexture[][][] aTextures) +/* 32: */ { +/* 33: 28 */ super(aName, aTier, aInvSlotCount, aDescription, aTextures); +/* 34: */ } +/* 35: */ +/* 36: */ public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 37: */ { +/* 38: 33 */ return new GT_MetaTileEntity_TypeFilter(this.mName, this.mTier, this.mInventory.length, this.mDescription, this.mTextures); +/* 39: */ } +/* 40: */ +/* 41: */ public ITexture getOverlayIcon() +/* 42: */ { +/* 43: 38 */ return new GT_RenderedTexture(Textures.BlockIcons.AUTOMATION_TYPEFILTER); +/* 44: */ } +/* 45: */ +/* 46: */ public boolean isValidSlot(int aIndex) +/* 47: */ { +/* 48: 41 */ return aIndex < 9; +/* 49: */ } +/* 50: */ +/* 51: */ public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 52: */ { +/* 53: 45 */ return new GT_Container_TypeFilter(aPlayerInventory, aBaseMetaTileEntity); +/* 54: */ } +/* 55: */ +/* 56: */ public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 57: */ { +/* 58: 50 */ return new GT_GUIContainer_TypeFilter(aPlayerInventory, aBaseMetaTileEntity); +/* 59: */ } +/* 60: */ +/* 61: */ public void clickTypeIcon(boolean aRightClick) +/* 62: */ { +/* 63: 54 */ if (getBaseMetaTileEntity().isServerSide()) +/* 64: */ { +/* 65: 55 */ for (int i = 0; i < OrePrefixes.values().length; i++) { +/* 66: 56 */ if (this.mPrefix == OrePrefixes.values()[i]) { +/* 67: 57 */ for (this.mPrefix = null; this.mPrefix == null; this.mPrefix = OrePrefixes.values()[i]) +/* 68: */ { +/* 70: 59 */ if (aRightClick) +/* 71: */ { +/* 72: 60 */ i--; +/* 73: 60 */ if (i < 0) { +/* 74: 60 */ i = OrePrefixes.values().length - 1; +/* 75: */ } +/* 76: */ } +/* 77: */ else +/* 78: */ { +/* 79: 62 */ i++; +/* 80: 62 */ if (i >= OrePrefixes.values().length) { +/* 81: 62 */ i = 0; +/* 82: */ } +/* 83: */ } +/* 84: 64 */ if ((OrePrefixes.values()[i].mPrefixedItems.isEmpty()) || (OrePrefixes.values()[i].mPrefixInto != OrePrefixes.values()[i])) { +/* 85: */ +/* 86: */ } +/* 87: */ } +/* 88: */ } +/* 89: */ } +/* 90: 69 */ this.mRotationIndex = 0; +/* 91: */ } +/* 92: */ } +/* 93: */ +/* 94: */ public void onPreTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) +/* 95: */ { +/* 96: 75 */ super.onPreTick(aBaseMetaTileEntity, aTick); +/* 97: 76 */ if ((getBaseMetaTileEntity().isServerSide()) && (aTick % 8L == 0L)) { +/* 98: 77 */ if (this.mPrefix.mPrefixedItems.isEmpty()) +/* 99: */ { +/* 100: 78 */ this.mInventory[9] = null; +/* 101: */ } +/* 102: */ else +/* 103: */ { +/* 104: 80 */ Object[] tmp63_60 = new Object[1]; int tmp90_89 = ((this.mRotationIndex + 1) % this.mPrefix.mPrefixedItems.size());this.mRotationIndex = tmp90_89;tmp63_60[0] = this.mPrefix.mPrefixedItems.get(tmp90_89);this.mInventory[9] = GT_Utility.copyAmount(1L, tmp63_60); +/* 105: 81 */ if (this.mInventory[9].getItemDamage() == 32767) { +/* 106: 81 */ this.mInventory[9].setItemDamage(0); +/* 107: */ } +/* 108: 82 */ this.mInventory[9].setStackDisplayName(this.mPrefix.toString()); +/* 109: */ } +/* 110: */ } +/* 111: */ } +/* 112: */ +/* 113: */ public void saveNBTData(NBTTagCompound aNBT) +/* 114: */ { +/* 115: 89 */ super.saveNBTData(aNBT); +/* 116: 90 */ aNBT.setString("mPrefix", this.mPrefix.toString()); +/* 117: 91 */ aNBT.setBoolean("bInvertFilter", this.bInvertFilter); +/* 118: 92 */ aNBT.setBoolean("bNBTAllowed", this.bNBTAllowed); +/* 119: */ } +/* 120: */ +/* 121: */ public void loadNBTData(NBTTagCompound aNBT) +/* 122: */ { +/* 123: 97 */ super.loadNBTData(aNBT); +/* 124: 98 */ this.mPrefix = OrePrefixes.getPrefix(aNBT.getString("mPrefix"), this.mPrefix); +/* 125: 99 */ this.bInvertFilter = aNBT.getBoolean("bInvertFilter"); +/* 126:100 */ this.bNBTAllowed = aNBT.getBoolean("bNBTAllowed"); +/* 127: */ } +/* 128: */ +/* 129: */ public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) +/* 130: */ { +/* 131:105 */ return (super.allowPutStack(aBaseMetaTileEntity, aIndex, aSide, aStack)) && ((this.bNBTAllowed) || (!aStack.hasTagCompound())) && (this.mPrefix.contains(aStack) != this.bInvertFilter); +/* 132: */ } +/* 133: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.automation.GT_MetaTileEntity_TypeFilter + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler.java b/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler.java new file mode 100644 index 0000000000..8852a6bde0 --- /dev/null +++ b/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler.java @@ -0,0 +1,329 @@ +package gregtech.common.tileentities.boilers; + +import gregtech.api.GregTech_API; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicTank; +import gregtech.api.objects.GT_ItemStack; +import gregtech.api.util.GT_CoverBehavior; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import java.util.Map; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.IFluidHandler; + +public abstract class GT_MetaTileEntity_Boiler + extends GT_MetaTileEntity_BasicTank +{ + public int mTemperature = 20; + public int mProcessingEnergy = 0; + public int mLossTimer = 0; + public FluidStack mSteam = null; + public boolean mHadNoWater = false; + + public GT_MetaTileEntity_Boiler(int aID, String aName, String aNameRegional, String aDescription, ITexture... aTextures) + { + super(aID, aName, aNameRegional, 0, 4, aDescription, aTextures); + } + + public GT_MetaTileEntity_Boiler(String aName, int aTier, String aDescription, ITexture[][][] aTextures) + { + super(aName, aTier, 4, aDescription, aTextures); + } + + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) + { + ITexture[] tmp = mTextures[(aSide==aFacing?(aActive?4:3):aSide==GT_Utility.getOppositeSide(aFacing)?2:aSide==0?0:aSide==1?1:2)][aColorIndex+1]; + if(aSide!=aFacing&&tmp.length==2){ + tmp = new ITexture[]{tmp[0]}; + } + return tmp; + } + + public boolean isElectric() + { + return false; + } + + public boolean isPneumatic() + { + return false; + } + + public boolean isSteampowered() + { + return false; + } + + public boolean isSimpleMachine() + { + return false; + } + + public boolean isFacingValid(byte aFacing) + { + return aFacing > 1; + } + + public boolean isAccessAllowed(EntityPlayer aPlayer) + { + return true; + } + + public boolean isValidSlot(int aIndex) + { + return true; + } + + public int getProgresstime() + { + return this.mTemperature; + } + + public int maxProgresstime() + { + return 500; + } + + public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) + { + if (aBaseMetaTileEntity.isClientSide()) { + return true; + } + if (aPlayer != null) { + if (GT_Utility.areStacksEqual(aPlayer.getCurrentEquippedItem(), new ItemStack(Items.water_bucket, 1))) + { + fill(Materials.Water.getFluid(1000 * aPlayer.getCurrentEquippedItem().stackSize), true); + aPlayer.getCurrentEquippedItem().func_150996_a(Items.bucket); + } + else + { + aBaseMetaTileEntity.openGUI(aPlayer); + } + } + return true; + } + + public boolean doesFillContainers() + { + return true; + } + + public boolean doesEmptyContainers() + { + return true; + } + + public boolean canTankBeFilled() + { + return true; + } + + public boolean canTankBeEmptied() + { + return true; + } + + public boolean displaysItemStack() + { + return false; + } + + public boolean displaysStackSize() + { + return false; + } + + public boolean isFluidInputAllowed(FluidStack aFluid) + { + return GT_ModHandler.isWater(aFluid); + } + + public FluidStack getDrainableStack() + { + return this.mSteam; + } + + public FluidStack setDrainableStack(FluidStack aFluid) + { + this.mSteam = aFluid;return this.mSteam; + } + + public boolean allowCoverOnSide(byte aSide, GT_ItemStack aCover) + { + return GregTech_API.getCoverBehavior(aCover.toStack()).isSimpleCover(); + } + + public void saveNBTData(NBTTagCompound aNBT) + { + super.saveNBTData(aNBT); + aNBT.setInteger("mLossTimer", this.mLossTimer); + aNBT.setInteger("mTemperature", this.mTemperature); + aNBT.setInteger("mProcessingEnergy", this.mProcessingEnergy); + if (this.mSteam != null) { + try + { + aNBT.setTag("mSteam", this.mSteam.writeToNBT(new NBTTagCompound())); + } + catch (Throwable e) {} + } + } + + public void loadNBTData(NBTTagCompound aNBT) + { + super.loadNBTData(aNBT); + this.mLossTimer = aNBT.getInteger("mLossTimer"); + this.mTemperature = aNBT.getInteger("mTemperature"); + this.mProcessingEnergy = aNBT.getInteger("mProcessingEnergy"); + this.mSteam = FluidStack.loadFluidStackFromNBT(aNBT.getCompoundTag("mSteam")); + } + + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) + { + if ((aBaseMetaTileEntity.isServerSide()) && (aTick > 20L)) + { + if (this.mTemperature <= 20) + { + this.mTemperature = 20; + this.mLossTimer = 0; + } + if (++this.mLossTimer > 40) + { + this.mTemperature -= 1; + this.mLossTimer = 0; + } + for (byte i = 1; (this.mSteam != null) && (i < 6); i = (byte)(i + 1)) { + if (i != aBaseMetaTileEntity.getFrontFacing()) + { + IFluidHandler tTileEntity = aBaseMetaTileEntity.getITankContainerAtSide(i); + if (tTileEntity != null) + { + FluidStack tDrained = aBaseMetaTileEntity.drain(ForgeDirection.getOrientation(i), Math.max(1, this.mSteam.amount / 2), false); + if (tDrained != null) + { + int tFilledAmount = tTileEntity.fill(ForgeDirection.getOrientation(i).getOpposite(), tDrained, false); + if (tFilledAmount > 0) { + tTileEntity.fill(ForgeDirection.getOrientation(i).getOpposite(), aBaseMetaTileEntity.drain(ForgeDirection.getOrientation(i), tFilledAmount, true), true); + } + } + } + } + } + if (aTick % 10L == 0L) { + if (this.mTemperature > 100) + { + if ((this.mFluid == null) || (!GT_ModHandler.isWater(this.mFluid)) || (this.mFluid.amount <= 0)) + { + this.mHadNoWater = true; + } + else + { + if (this.mHadNoWater) + { + aBaseMetaTileEntity.doExplosion(2048L); + return; + } + this.mFluid.amount -= 1; + if (this.mSteam == null) { + this.mSteam = GT_ModHandler.getSteam(150L); + } else if (GT_ModHandler.isSteam(this.mSteam)) { + this.mSteam.amount += 150; + } else { + this.mSteam = GT_ModHandler.getSteam(150L); + } + } + } + else { + this.mHadNoWater = false; + } + } + if ((this.mSteam != null) && + (this.mSteam.amount > 32000)) + { + sendSound((byte)1); + this.mSteam.amount = 24000; + } + if ((this.mProcessingEnergy <= 0) && (aBaseMetaTileEntity.isAllowedToWork()) && + (this.mInventory[2] != null)) { + if ((GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.gem.get(Materials.Coal))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dust.get(Materials.Coal))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dustImpure.get(Materials.Coal))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.crushed.get(Materials.Coal)))) + { + this.mProcessingEnergy += 160; + aBaseMetaTileEntity.decrStackSize(2, 1); + if (aBaseMetaTileEntity.getRandomNumber(3) == 0) { + aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 1L)); + } + } + else if (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.gem.get(Materials.Charcoal))) + { + this.mProcessingEnergy += 160; + aBaseMetaTileEntity.decrStackSize(2, 1); + if (aBaseMetaTileEntity.getRandomNumber(3) == 0) { + aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Ash, 1L)); + } + } + else if (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], "fuelCoke")) + { + this.mProcessingEnergy += 640; + aBaseMetaTileEntity.decrStackSize(2, 1); + if (aBaseMetaTileEntity.getRandomNumber(2) == 0) { + aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Ash, 1L)); + } + } + else if ((GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.gem.get(Materials.Lignite))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dust.get(Materials.Lignite))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dustImpure.get(Materials.Lignite))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.crushed.get(Materials.Lignite)))) + { + this.mProcessingEnergy += 40; + aBaseMetaTileEntity.decrStackSize(2, 1); + if (aBaseMetaTileEntity.getRandomNumber(8) == 0) { + aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 1L)); + } + } + } + if ((this.mTemperature < 1000) && (this.mProcessingEnergy > 0) && (aTick % 12L == 0L)) + { + this.mProcessingEnergy -= 2; + this.mTemperature += 1; + } + aBaseMetaTileEntity.setActive(this.mProcessingEnergy > 0); + } + } + + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) + { + return (aIndex == 1) || (aIndex == 3); + } + + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) + { + return aIndex == 2; + } + + public void doSound(byte aIndex, double aX, double aY, double aZ) + { + if (aIndex == 1) + { + GT_Utility.doSoundAtClient((String)GregTech_API.sSoundList.get(Integer.valueOf(4)), 2, 1.0F, aX, aY, aZ); + for (int l = 0; l < 8; l++) { + getBaseMetaTileEntity().getWorld().spawnParticle("largesmoke", aX - 0.5D + Math.random(), aY, aZ - 0.5D + Math.random(), 0.0D, 0.0D, 0.0D); + } + } + } + + public int getCapacity() + { + return 16000; + } + + public int getTankPressure() + { + return 100; + } +} diff --git a/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Bronze.java b/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Bronze.java new file mode 100644 index 0000000000..e683eb09aa --- /dev/null +++ b/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Bronze.java @@ -0,0 +1,176 @@ +package gregtech.common.tileentities.boilers; + +import gregtech.api.enums.Dyes; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.Textures; +import gregtech.api.enums.Textures.BlockIcons; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.objects.GT_RenderedTexture; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.common.gui.GT_Container_Boiler; +import gregtech.common.gui.GT_GUIContainer_Boiler; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.IFluidHandler; + +public class GT_MetaTileEntity_Boiler_Bronze + extends GT_MetaTileEntity_Boiler +{ + public GT_MetaTileEntity_Boiler_Bronze(int aID, String aName, String aNameRegional) + { + super(aID, aName, aNameRegional, "An early way to get Steam Power", new ITexture[0]); + } + + public GT_MetaTileEntity_Boiler_Bronze(String aName, int aTier, String aDescription, ITexture[][][] aTextures) + { + super(aName, aTier, aDescription, aTextures); + } + + public ITexture[][][] getTextureSet(ITexture[] aTextures) + { + ITexture[][][] rTextures = new ITexture[5][17][]; + for (byte i = -1; i < 16; i++) + { + rTextures[0][(i + 1)] = new ITexture[] { new GT_RenderedTexture(Textures.BlockIcons.MACHINE_BRONZEBRICKS_BOTTOM, Dyes.getModulation(i, Dyes._NULL.mRGBa)) }; + rTextures[1][(i + 1)] = new ITexture[] { new GT_RenderedTexture(Textures.BlockIcons.MACHINE_BRONZEBRICKS_TOP, Dyes.getModulation(i, Dyes._NULL.mRGBa)), new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE) }; + rTextures[2][(i + 1)] = new ITexture[] { new GT_RenderedTexture(Textures.BlockIcons.MACHINE_BRONZEBRICKS_SIDE, Dyes.getModulation(i, Dyes._NULL.mRGBa)), new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE) }; + rTextures[3][(i + 1)] = new ITexture[] { new GT_RenderedTexture(Textures.BlockIcons.MACHINE_BRONZEBRICKS_SIDE, Dyes.getModulation(i, Dyes._NULL.mRGBa)), new GT_RenderedTexture(Textures.BlockIcons.BOILER_FRONT) }; + rTextures[4][(i + 1)] = new ITexture[] { new GT_RenderedTexture(Textures.BlockIcons.MACHINE_BRONZEBRICKS_SIDE, Dyes.getModulation(i, Dyes._NULL.mRGBa)), new GT_RenderedTexture(Textures.BlockIcons.BOILER_FRONT_ACTIVE) }; + } + return rTextures; + } + + public int maxProgresstime() + { + return 500; + } + + public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) + { + return new GT_Container_Boiler(aPlayerInventory, aBaseMetaTileEntity, 16000); + } + + public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) + { + return new GT_GUIContainer_Boiler(aPlayerInventory, aBaseMetaTileEntity, "BronzeBoiler.png", 16000); + } + + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) + { + return new GT_MetaTileEntity_Boiler_Bronze(this.mName, this.mTier, this.mDescription, this.mTextures); + } + + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) + { + if ((aBaseMetaTileEntity.isServerSide()) && (aTick > 20L)) + { + if (this.mTemperature <= 20) + { + this.mTemperature = 20; + this.mLossTimer = 0; + } + if (++this.mLossTimer > 45) + { + this.mTemperature -= 1; + this.mLossTimer = 0; + } + for (byte i = 1; (this.mSteam != null) && (i < 6); i = (byte)(i + 1)) { + if (i != aBaseMetaTileEntity.getFrontFacing()) + { + IFluidHandler tTileEntity = aBaseMetaTileEntity.getITankContainerAtSide(i); + if (tTileEntity != null) + { + FluidStack tDrained = aBaseMetaTileEntity.drain(ForgeDirection.getOrientation(i), Math.max(1, this.mSteam.amount / 2), false); + if (tDrained != null) + { + int tFilledAmount = tTileEntity.fill(ForgeDirection.getOrientation(i).getOpposite(), tDrained, false); + if (tFilledAmount > 0) { + tTileEntity.fill(ForgeDirection.getOrientation(i).getOpposite(), aBaseMetaTileEntity.drain(ForgeDirection.getOrientation(i), tFilledAmount, true), true); + } + } + } + } + } + if (aTick % 25L == 0L) { + if (this.mTemperature > 100) + { + if ((this.mFluid == null) || (!GT_ModHandler.isWater(this.mFluid)) || (this.mFluid.amount <= 0)) + { + this.mHadNoWater = true; + } + else + { + if (this.mHadNoWater) + { + aBaseMetaTileEntity.doExplosion(2048L); + return; + } + this.mFluid.amount -= 1; + if (this.mSteam == null) { + this.mSteam = GT_ModHandler.getSteam(150L); + } else if (GT_ModHandler.isSteam(this.mSteam)) { + this.mSteam.amount += 150; + } else { + this.mSteam = GT_ModHandler.getSteam(150L); + } + } + } + else { + this.mHadNoWater = false; + } + } + if ((this.mSteam != null) && + (this.mSteam.amount > 16000)) + { + sendSound((byte)1); + this.mSteam.amount = 12000; + } + if ((this.mProcessingEnergy <= 0) && (aBaseMetaTileEntity.isAllowedToWork()) && + (this.mInventory[2] != null)) { + if ((GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.gem.get(Materials.Coal))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dust.get(Materials.Coal))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dustImpure.get(Materials.Coal))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.crushed.get(Materials.Coal)))) + { + this.mProcessingEnergy += 160; + aBaseMetaTileEntity.decrStackSize(2, 1); + if (aBaseMetaTileEntity.getRandomNumber(3) == 0) { + aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 1L)); + } + } + else if ((GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.gem.get(Materials.Charcoal))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dust.get(Materials.Charcoal))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dustImpure.get(Materials.Charcoal))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.crushed.get(Materials.Charcoal)))) + { + this.mProcessingEnergy += 160; + aBaseMetaTileEntity.decrStackSize(2, 1); + if (aBaseMetaTileEntity.getRandomNumber(3) == 0) { + aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Ash, 1L)); + } + } + else if (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], "fuelCoke")) + { + this.mProcessingEnergy += 640; + aBaseMetaTileEntity.decrStackSize(2, 1); + if (aBaseMetaTileEntity.getRandomNumber(2) == 0) { + aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Ash, 1L)); + } + } + else if ((GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.gem.get(Materials.Lignite))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dust.get(Materials.Lignite))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dustImpure.get(Materials.Lignite))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.crushed.get(Materials.Lignite)))) + { + this.mProcessingEnergy += 40; + aBaseMetaTileEntity.decrStackSize(2, 1); + if (aBaseMetaTileEntity.getRandomNumber(8) == 0) { + aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 1L)); + } + } + } + if ((this.mTemperature < 500) && (this.mProcessingEnergy > 0) && (aTick % 12L == 0L)) + { + this.mProcessingEnergy -= 1; + this.mTemperature += 1; + } + aBaseMetaTileEntity.setActive(this.mProcessingEnergy > 0); + } + } +} diff --git a/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Lava.java b/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Lava.java new file mode 100644 index 0000000000..5dee9e7746 --- /dev/null +++ b/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Lava.java @@ -0,0 +1,166 @@ +/* 1: */ package gregtech.common.tileentities.boilers; +/* 2: */ +/* 3: */ import gregtech.api.enums.Dyes; +/* 4: */ import gregtech.api.enums.Materials; +/* 5: */ import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.Textures; +/* 6: */ import gregtech.api.enums.Textures.BlockIcons; +/* 7: */ import gregtech.api.interfaces.ITexture; +/* 8: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 9: */ import gregtech.api.metatileentity.MetaTileEntity; +/* 10: */ import gregtech.api.objects.GT_RenderedTexture; +/* 11: */ import gregtech.api.util.GT_ModHandler; +/* 12: */ import gregtech.api.util.GT_OreDictUnificator; +/* 13: */ import gregtech.common.gui.GT_Container_Boiler; +/* 14: */ import gregtech.common.gui.GT_GUIContainer_Boiler; +/* 15: */ import net.minecraft.entity.player.InventoryPlayer; +/* 16: */ import net.minecraftforge.common.util.ForgeDirection; +/* 17: */ import net.minecraftforge.fluids.FluidStack; +/* 18: */ import net.minecraftforge.fluids.IFluidHandler; +/* 19: */ +/* 20: */ public class GT_MetaTileEntity_Boiler_Lava +/* 21: */ extends GT_MetaTileEntity_Boiler +/* 22: */ { +/* 23: */ public GT_MetaTileEntity_Boiler_Lava(int aID, String aName, String aNameRegional) +/* 24: */ { +/* 25: 22 */ super(aID, aName, aNameRegional, "A Boiler running off Lava", new ITexture[0]); +/* 26: */ } +/* 27: */ +/* 28: */ public GT_MetaTileEntity_Boiler_Lava(String aName, int aTier, String aDescription, ITexture[][][] aTextures) +/* 29: */ { +/* 30: 26 */ super(aName, aTier, aDescription, aTextures); +/* 31: */ } +/* 32: */ +/* 33: */ public ITexture[][][] getTextureSet(ITexture[] aTextures) +/* 34: */ { +/* 35: 31 */ ITexture[][][] rTextures = new ITexture[5][17][]; +/* 36: 32 */ for (byte i = -1; i < 16; i++){ +/* 38: 33 */ rTextures[0][(i + 1)] = new ITexture [] { new GT_RenderedTexture(Textures.BlockIcons.MACHINE_STEELBRICKS_BOTTOM, Dyes.getModulation(i, Dyes._NULL.mRGBa)) }; +/* 39: 34 */ rTextures[1][(i + 1)] = new ITexture [] { new GT_RenderedTexture(Textures.BlockIcons.MACHINE_STEELBRICKS_TOP, Dyes.getModulation(i, Dyes._NULL.mRGBa)), new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE) }; +/* 40: 35 */ rTextures[2][(i + 1)] = new ITexture [] { new GT_RenderedTexture(Textures.BlockIcons.MACHINE_STEELBRICKS_SIDE, Dyes.getModulation(i, Dyes._NULL.mRGBa)), new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE) }; +/* 41: 36 */ rTextures[3][(i + 1)] = new ITexture [] { new GT_RenderedTexture(Textures.BlockIcons.MACHINE_STEELBRICKS_SIDE, Dyes.getModulation(i, Dyes._NULL.mRGBa)), new GT_RenderedTexture(Textures.BlockIcons.BOILER_LAVA_FRONT) }; +/* 42: 37 */ rTextures[4][(i + 1)] = new ITexture [] { new GT_RenderedTexture(Textures.BlockIcons.MACHINE_STEELBRICKS_SIDE, Dyes.getModulation(i, Dyes._NULL.mRGBa)), new GT_RenderedTexture(Textures.BlockIcons.BOILER_LAVA_FRONT_ACTIVE) }; +/* 43: */ } +/* 44: 39 */ return rTextures; +/* 45: */ } +/* 46: */ +/* 47: */ public int maxProgresstime() +/* 48: */ { +/* 49: 42 */ return 1000; +/* 50: */ } +/* 51: */ +/* 52: */ public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 53: */ { +/* 54: 46 */ return new GT_Container_Boiler(aPlayerInventory, aBaseMetaTileEntity, 32000); +/* 55: */ } +/* 56: */ +/* 57: */ public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 58: */ { +/* 59: 51 */ return new GT_GUIContainer_Boiler(aPlayerInventory, aBaseMetaTileEntity, "SteelBoiler.png", 32000); +/* 60: */ } +/* 61: */ +/* 62: */ public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 63: */ { +/* 64: 56 */ return new GT_MetaTileEntity_Boiler_Lava(this.mName, this.mTier, this.mDescription, this.mTextures); +/* 65: */ } +/* 66: */ +/* 67: */ public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) +/* 68: */ { +/* 69: 61 */ if ((aBaseMetaTileEntity.isServerSide()) && (aTick > 20L)) +/* 70: */ { +/* 71: 62 */ if (this.mTemperature <= 20) +/* 72: */ { +/* 73: 63 */ this.mTemperature = 20; +/* 74: 64 */ this.mLossTimer = 0; +/* 75: */ } +/* 76: 67 */ if (++this.mLossTimer > 20) +/* 77: */ { +/* 78: 68 */ this.mTemperature -= 1; +/* 79: 69 */ this.mLossTimer = 0; +/* 80: */ } +/* 81: 72 */ for (byte i = 1; (this.mSteam != null) && (i < 6); i = (byte)(i + 1)) { +/* 82: 72 */ if (i != aBaseMetaTileEntity.getFrontFacing()) +/* 83: */ { +/* 84: 73 */ IFluidHandler tTileEntity = aBaseMetaTileEntity.getITankContainerAtSide(i); +/* 85: 74 */ if (tTileEntity != null) +/* 86: */ { +/* 87: 75 */ FluidStack tDrained = aBaseMetaTileEntity.drain(ForgeDirection.getOrientation(i), Math.max(1, this.mSteam.amount / 2), false); +/* 88: 76 */ if (tDrained != null) +/* 89: */ { +/* 90: 77 */ int tFilledAmount = tTileEntity.fill(ForgeDirection.getOrientation(i).getOpposite(), tDrained, false); +/* 91: 78 */ if (tFilledAmount > 0) { +/* 92: 79 */ tTileEntity.fill(ForgeDirection.getOrientation(i).getOpposite(), aBaseMetaTileEntity.drain(ForgeDirection.getOrientation(i), tFilledAmount, true), true); +/* 93: */ } +/* 94: */ } +/* 95: */ } +/* 96: */ } +/* 97: */ } +/* 98: 85 */ if (aTick % 10L == 0L) { +/* 99: 86 */ if (this.mTemperature > 100) +/* 100: */ { +/* 101: 87 */ if ((this.mFluid == null) || (!GT_ModHandler.isWater(this.mFluid)) || (this.mFluid.amount <= 0)) +/* 102: */ { +/* 103: 88 */ this.mHadNoWater = true; +/* 104: */ } +/* 105: */ else +/* 106: */ { +/* 107: 90 */ if (this.mHadNoWater) +/* 108: */ { +/* 109: 91 */ aBaseMetaTileEntity.doExplosion(2048L); +/* 110: 92 */ return; +/* 111: */ } +/* 112: 94 */ this.mFluid.amount -= 1; +/* 113: 95 */ if (this.mSteam == null) { +/* 114: 96 */ this.mSteam = GT_ModHandler.getSteam(300L); +/* 115: 98 */ } else if (GT_ModHandler.isSteam(this.mSteam)) { +/* 116: 99 */ this.mSteam.amount += 300; +/* 117: */ } else { +/* 118:101 */ this.mSteam = GT_ModHandler.getSteam(300L); +/* 119: */ } +/* 120: */ } +/* 121: */ } +/* 122: */ else { +/* 123:106 */ this.mHadNoWater = false; +/* 124: */ } +/* 125: */ } +/* 126:110 */ if ((this.mSteam != null) && +/* 127:111 */ (this.mSteam.amount > 32000)) +/* 128: */ { +/* 129:112 */ sendSound((byte)1); +/* 130:113 */ this.mSteam.amount = 24000; +/* 131: */ } +/* 132:117 */ if ((this.mProcessingEnergy <= 0) && (aBaseMetaTileEntity.isAllowedToWork()) && +/* 133:118 */ (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.bucket.get(Materials.Lava)))) +/* 134: */ {