From 0427ab89f1753a44b30cbc35ce021cbbdc845109 Mon Sep 17 00:00:00 2001 From: Foghrye4 Date: Thu, 10 Aug 2017 18:52:45 +0300 Subject: fix missing source folder --- .../automation/GT_MetaTileEntity_ChestBuffer.java | 86 +++++ .../automation/GT_MetaTileEntity_Filter.java | 101 ++++++ .../automation/GT_MetaTileEntity_Regulator.java | 120 +++++++ .../automation/GT_MetaTileEntity_SuperBuffer.java | 54 ++++ .../automation/GT_MetaTileEntity_TypeFilter.java | 145 +++++++++ .../boilers/GT_MetaTileEntity_Boiler.java | 356 +++++++++++++++++++++ .../boilers/GT_MetaTileEntity_Boiler_Bronze.java | 181 +++++++++++ .../boilers/GT_MetaTileEntity_Boiler_Lava.java | 172 ++++++++++ .../boilers/GT_MetaTileEntity_Boiler_Solar.java | 161 ++++++++++ .../boilers/GT_MetaTileEntity_Boiler_Steel.java | 191 +++++++++++ .../GT_MetaTileEntity_DieselGenerator.java | 145 +++++++++ .../GT_MetaTileEntity_FluidNaquadahReactor.java | 119 +++++++ .../generators/GT_MetaTileEntity_GasTurbine.java | 131 ++++++++ .../GT_MetaTileEntity_MagicEnergyConverter.java | 125 ++++++++ .../GT_MetaTileEntity_MagicalEnergyAbsorber.java | 264 +++++++++++++++ .../GT_MetaTileEntity_PlasmaGenerator.java | 125 ++++++++ .../GT_MetaTileEntity_SolidNaquadahReactor.java | 119 +++++++ .../generators/GT_MetaTileEntity_SteamTurbine.java | 144 +++++++++ .../GT_MetaTileEntity_BasicHull_Bronze.java | 48 +++ .../GT_MetaTileEntity_BasicHull_BronzeBricks.java | 51 +++ .../GT_MetaTileEntity_BasicHull_Steel.java | 50 +++ .../GT_MetaTileEntity_BasicHull_SteelBricks.java | 50 +++ .../GT_MetaTileEntity_AlloySmelter_Bronze.java | 130 ++++++++ .../GT_MetaTileEntity_AlloySmelter_Steel.java | 130 ++++++++ .../steam/GT_MetaTileEntity_Compressor_Bronze.java | 128 ++++++++ .../steam/GT_MetaTileEntity_Compressor_Steel.java | 128 ++++++++ .../steam/GT_MetaTileEntity_Extractor_Bronze.java | 128 ++++++++ .../steam/GT_MetaTileEntity_Extractor_Steel.java | 128 ++++++++ .../GT_MetaTileEntity_ForgeHammer_Bronze.java | 130 ++++++++ .../steam/GT_MetaTileEntity_ForgeHammer_Steel.java | 130 ++++++++ .../steam/GT_MetaTileEntity_Furnace_Bronze.java | 128 ++++++++ .../steam/GT_MetaTileEntity_Furnace_Steel.java | 128 ++++++++ .../steam/GT_MetaTileEntity_Macerator_Bronze.java | 135 ++++++++ .../steam/GT_MetaTileEntity_Macerator_Steel.java | 141 ++++++++ .../storage/GT_MetaTileEntity_Locker.java | 225 +++++++++++++ .../storage/GT_MetaTileEntity_QuantumChest.java | 202 ++++++++++++ .../storage/GT_MetaTileEntity_QuantumTank.java | 104 ++++++ 37 files changed, 5033 insertions(+) create mode 100644 src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_ChestBuffer.java create mode 100644 src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_Filter.java create mode 100644 src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_Regulator.java create mode 100644 src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_SuperBuffer.java create mode 100644 src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_TypeFilter.java create mode 100644 src/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler.java create mode 100644 src/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Bronze.java create mode 100644 src/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Lava.java create mode 100644 src/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Solar.java create mode 100644 src/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Steel.java create mode 100644 src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_DieselGenerator.java create mode 100644 src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_FluidNaquadahReactor.java create mode 100644 src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_GasTurbine.java create mode 100644 src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_MagicEnergyConverter.java create mode 100644 src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_MagicalEnergyAbsorber.java create mode 100644 src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_PlasmaGenerator.java create mode 100644 src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_SolidNaquadahReactor.java create mode 100644 src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_SteamTurbine.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/GT_MetaTileEntity_BasicHull_Bronze.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/GT_MetaTileEntity_BasicHull_BronzeBricks.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/GT_MetaTileEntity_BasicHull_Steel.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/GT_MetaTileEntity_BasicHull_SteelBricks.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_AlloySmelter_Bronze.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_AlloySmelter_Steel.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Compressor_Bronze.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Compressor_Steel.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Extractor_Bronze.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Extractor_Steel.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_ForgeHammer_Bronze.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_ForgeHammer_Steel.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Furnace_Bronze.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Furnace_Steel.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Macerator_Bronze.java create mode 100644 src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Macerator_Steel.java create mode 100644 src/main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_Locker.java create mode 100644 src/main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_QuantumChest.java create mode 100644 src/main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_QuantumTank.java (limited to 'src/main/java/gregtech/common/tileentities') diff --git a/src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_ChestBuffer.java b/src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_ChestBuffer.java new file mode 100644 index 0000000..b31f32d --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_ChestBuffer.java @@ -0,0 +1,86 @@ +/* 1: */ package gregtech.common.tileentities.automation; +/* 2: */ +/* 3: */ import gregtech.api.enums.Textures; +/* 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: */ @Override +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: */ @Override +public ITexture getOverlayIcon() +/* 38: */ { +/* 39:34 */ return new GT_RenderedTexture(Textures.BlockIcons.AUTOMATION_CHESTBUFFER); +/* 40: */ } +/* 41: */ +/* 42: */ @Override +public boolean isValidSlot(int aIndex) +/* 43: */ { +/* 44:37 */ return aIndex < this.mInventory.length - 1; +/* 45: */ } +/* 46: */ +/* 47: */ @Override +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: */ @Override +public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 66: */ { +/* 67:54 */ return new GT_Container_ChestBuffer(aPlayerInventory, aBaseMetaTileEntity); +/* 68: */ } +/* 69: */ +/* 70: */ @Override +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/src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_Filter.java b/src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_Filter.java new file mode 100644 index 0000000..6e6fcdc --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_Filter.java @@ -0,0 +1,101 @@ +/* 1: */ package gregtech.common.tileentities.automation; +/* 2: */ +/* 3: */ import gregtech.api.enums.Textures; +/* 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: */ @Override +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: */ @Override +public ITexture getOverlayIcon() +/* 38: */ { +/* 39:34 */ return new GT_RenderedTexture(Textures.BlockIcons.AUTOMATION_FILTER); +/* 40: */ } +/* 41: */ +/* 42: */ @Override +public boolean isValidSlot(int aIndex) +/* 43: */ { +/* 44:37 */ return aIndex < 9; +/* 45: */ } +/* 46: */ +/* 47: */ @Override +public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 48: */ { +/* 49:41 */ return new GT_Container_Filter(aPlayerInventory, aBaseMetaTileEntity); +/* 50: */ } +/* 51: */ +/* 52: */ @Override +public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 53: */ { +/* 54:46 */ return new GT_GUIContainer_Filter(aPlayerInventory, aBaseMetaTileEntity); +/* 55: */ } +/* 56: */ +/* 57: */ @Override +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: */ @Override +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: */ @Override +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/src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_Regulator.java b/src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_Regulator.java new file mode 100644 index 0000000..c03c2e1 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_Regulator.java @@ -0,0 +1,120 @@ +/* 1: */ package gregtech.common.tileentities.automation; +/* 12: */ import java.util.Arrays; + +/* 2: */ +/* 3: */ import gregtech.api.enums.Textures; +/* 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; +/* 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: */ @Override +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: */ @Override +public ITexture getOverlayIcon() +/* 38: */ { +/* 39:37 */ return new GT_RenderedTexture(Textures.BlockIcons.AUTOMATION_REGULATOR); +/* 40: */ } +/* 41: */ +/* 42: */ @Override +public boolean isValidSlot(int aIndex) +/* 43: */ { +/* 44:40 */ return aIndex < 9; +/* 45: */ } +/* 46: */ +/* 47: */ @Override +public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 48: */ { +/* 49:44 */ return new GT_Container_Regulator(aPlayerInventory, aBaseMetaTileEntity); +/* 50: */ } +/* 51: */ +/* 52: */ @Override +public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 53: */ { +/* 54:49 */ return new GT_GUIContainer_Regulator(aPlayerInventory, aBaseMetaTileEntity); +/* 55: */ } +/* 56: */ +/* 57: */ @Override +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: */ @Override +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: */ @Override +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: */ @Override +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/src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_SuperBuffer.java b/src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_SuperBuffer.java new file mode 100644 index 0000000..c5fc5a2 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_SuperBuffer.java @@ -0,0 +1,54 @@ +/* 1: */ package gregtech.common.tileentities.automation; +/* 2: */ +/* 3: */ import gregtech.api.enums.Textures; +/* 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: */ @Override +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: */ @Override +public ITexture getOverlayIcon() +/* 31: */ { +/* 32:28 */ return new GT_RenderedTexture(Textures.BlockIcons.AUTOMATION_SUPERBUFFER); +/* 33: */ } +/* 34: */ +/* 35: */ @Override +public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 36: */ { +/* 37:33 */ return new GT_Container_SuperBuffer(aPlayerInventory, aBaseMetaTileEntity); +/* 38: */ } +/* 39: */ +/* 40: */ @Override +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/src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_TypeFilter.java b/src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_TypeFilter.java new file mode 100644 index 0000000..8c42649 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/automation/GT_MetaTileEntity_TypeFilter.java @@ -0,0 +1,145 @@ +/* 1: */ package gregtech.common.tileentities.automation; +/* 2: */ +/* 3: */ import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.Textures; +/* 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; +/* 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: */ @Override +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: */ @Override +public ITexture getOverlayIcon() +/* 42: */ { +/* 43: 38 */ return new GT_RenderedTexture(Textures.BlockIcons.AUTOMATION_TYPEFILTER); +/* 44: */ } +/* 45: */ +/* 46: */ @Override +public boolean isValidSlot(int aIndex) +/* 47: */ { +/* 48: 41 */ return aIndex < 9; +/* 49: */ } +/* 50: */ +/* 51: */ @Override +public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 52: */ { +/* 53: 45 */ return new GT_Container_TypeFilter(aPlayerInventory, aBaseMetaTileEntity); +/* 54: */ } +/* 55: */ +/* 56: */ @Override +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]) + mPrefix = OrePrefixes.values()[i]; +/* 87: */ } +/* 88: */ } +/* 89: */ } +/* 90: 69 */ this.mRotationIndex = 0; +/* 91: */ } +/* 92: */ } +/* 93: */ +/* 94: */ @Override +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: */ @Override +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: */ @Override +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: */ @Override +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/src/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler.java b/src/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler.java new file mode 100644 index 0000000..8fce193 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler.java @@ -0,0 +1,356 @@ +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_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +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); + } + + @Override +public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) + { + ITexture[] tmp = mTextures[aSide >= 2 ? aSide != aFacing ? 2 : ((byte)(aActive ? 4 : 3)) : aSide][aColorIndex + 1]; + //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; + } + + @Override +public boolean isElectric() + { + return false; + } + + @Override +public boolean isPneumatic() + { + return false; + } + + @Override +public boolean isSteampowered() + { + return false; + } + + @Override +public boolean isSimpleMachine() + { + return false; + } + + @Override +public boolean isFacingValid(byte aFacing) + { + return aFacing > 1; + } + + @Override +public boolean isAccessAllowed(EntityPlayer aPlayer) + { + return true; + } + + @Override +public boolean isValidSlot(int aIndex) + { + return true; + } + + @Override +public int getProgresstime() + { + return this.mTemperature; + } + + @Override +public int maxProgresstime() + { + return 500; + } + + @Override +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; + } + + @Override +public boolean doesFillContainers() + { + return true; + } + + @Override +public boolean doesEmptyContainers() + { + return true; + } + + @Override +public boolean canTankBeFilled() + { + return true; + } + + @Override +public boolean canTankBeEmptied() + { + return true; + } + + @Override +public boolean displaysItemStack() + { + return false; + } + + @Override +public boolean displaysStackSize() + { + return false; + } + + @Override +public boolean isFluidInputAllowed(FluidStack aFluid) + { + return GT_ModHandler.isWater(aFluid); + } + + @Override +public FluidStack getDrainableStack() + { + return this.mSteam; + } + + @Override +public FluidStack setDrainableStack(FluidStack aFluid) + { + this.mSteam = aFluid;return this.mSteam; + } + + @Override +public boolean allowCoverOnSide(byte aSide, GT_ItemStack aCover) + { + return GregTech_API.getCoverBehavior(aCover.toStack()).isSimpleCover(); + } + + @Override +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) {} + } + } + + @Override +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")); + } + + @Override +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); + } + } + + @Override +public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) + { + return (aIndex == 1) || (aIndex == 3); + } + + @Override +public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) + { + return aIndex == 2; + } + + @Override +public void doSound(byte aIndex, double aX, double aY, double aZ) + { + if (aIndex == 1) + { + GT_Utility.doSoundAtClient(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); + } + } + } + + @Override +public int getCapacity() + { + return 16000; + } + + @Override +public int getTankPressure() + { + return 100; + } +} diff --git a/src/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Bronze.java b/src/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Bronze.java new file mode 100644 index 0000000..c0ef2e3 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Bronze.java @@ -0,0 +1,181 @@ +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.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); + } + + @Override +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; + } + + @Override +public int maxProgresstime() + { + return 500; + } + + @Override +public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) + { + return new GT_Container_Boiler(aPlayerInventory, aBaseMetaTileEntity, 16000); + } + + @Override +public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) + { + return new GT_GUIContainer_Boiler(aPlayerInventory, aBaseMetaTileEntity, "BronzeBoiler.png", 16000); + } + + @Override +public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) + { + return new GT_MetaTileEntity_Boiler_Bronze(this.mName, this.mTier, this.mDescription, this.mTextures); + } + + @Override +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/src/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Lava.java b/src/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Lava.java new file mode 100644 index 0000000..e9c654f --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Lava.java @@ -0,0 +1,172 @@ +/* 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; +/* 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: */ @Override +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: */ @Override +public int maxProgresstime() +/* 48: */ { +/* 49: 42 */ return 1000; +/* 50: */ } +/* 51: */ +/* 52: */ @Override +public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 53: */ { +/* 54: 46 */ return new GT_Container_Boiler(aPlayerInventory, aBaseMetaTileEntity, 32000); +/* 55: */ } +/* 56: */ +/* 57: */ @Override +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: */ @Override +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: */ @Override +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: */ { +/* 135:119 */ this.mProcessingEnergy += 1000; +/* 136:120 */ aBaseMetaTileEntity.decrStackSize(2, 1); +/* 137:121 */ aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.bucket, Materials.Empty, 1L)); +/* 138: */ } +/* 139:125 */ if ((this.mTemperature < 1000) && (this.mProcessingEnergy > 0) && (aTick % 8L == 0L)) +/* 140: */ { +/* 141:126 */ this.mProcessingEnergy -= 2; +/* 142:127 */ this.mTemperature += 1; +/* 143: */ } +/* 144:130 */ aBaseMetaTileEntity.setActive(this.mProcessingEnergy > 0); +/* 145: */ } +/* 146: */ } +/* 147: */ +/* 148: */ @Override +public final int fill(FluidStack aFluid, boolean doFill) +/* 149: */ { +/* 150:136 */ if ((GT_ModHandler.isLava(aFluid)) && (this.mProcessingEnergy < 50)) +/* 151: */ { +/* 152:137 */ int tFilledAmount = Math.min(50, aFluid.amount); +/* 153:138 */ if (doFill) { +/* 154:138 */ this.mProcessingEnergy += tFilledAmount; +/* 155: */ } +/* 156:139 */ return tFilledAmount; +/* 157: */ } +/* 158:141 */ return super.fill(aFluid, doFill); +/* 159: */ } +/* 160: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.boilers.GT_MetaTileEntity_Boiler_Lava + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Solar.java b/src/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Solar.java new file mode 100644 index 0000000..392951a --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Solar.java @@ -0,0 +1,161 @@ +/* 1: */ package gregtech.common.tileentities.boilers; +/* 2: */ +/* 3: */ import gregtech.api.enums.Dyes; +import gregtech.api.enums.Textures; +/* 5: */ import gregtech.api.interfaces.ITexture; +/* 6: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 7: */ import gregtech.api.metatileentity.MetaTileEntity; +/* 8: */ import gregtech.api.objects.GT_RenderedTexture; +/* 9: */ import gregtech.api.util.GT_ModHandler; +/* 10: */ import gregtech.common.gui.GT_Container_Boiler; +/* 11: */ import gregtech.common.gui.GT_GUIContainer_Boiler; +/* 12: */ import net.minecraft.entity.player.InventoryPlayer; +/* 15: */ import net.minecraftforge.common.util.ForgeDirection; +/* 16: */ import net.minecraftforge.fluids.FluidStack; +/* 17: */ import net.minecraftforge.fluids.IFluidHandler; +/* 18: */ +/* 19: */ public class GT_MetaTileEntity_Boiler_Solar +/* 20: */ extends GT_MetaTileEntity_Boiler +/* 21: */ { +/* 22: */ public GT_MetaTileEntity_Boiler_Solar(int aID, String aName, String aNameRegional) +/* 23: */ { +/* 24: 19 */ super(aID, aName, aNameRegional, "Steam Power by the Sun", new ITexture[0]); +/* 25: */ } +/* 26: */ +/* 27: */ public GT_MetaTileEntity_Boiler_Solar(String aName, int aTier, String aDescription, ITexture[][][] aTextures) +/* 28: */ { +/* 29: 23 */ super(aName, aTier, aDescription, aTextures); +/* 30: */ } +/* 31: */ +/* 32: */ @Override +public ITexture[][][] getTextureSet(ITexture[] aTextures) +/* 33: */ { +/* 34: 28 */ ITexture[][][] rTextures = new ITexture[4][17][]; +/* 35: 29 */ for (byte i = -1; i < 16; i = (byte)(i + 1)) +/* 36: */ {ITexture[] tmp0 ={ new GT_RenderedTexture(Textures.BlockIcons.MACHINE_BRONZEBRICKS_BOTTOM, Dyes.getModulation(i, Dyes._NULL.mRGBa)) }; +/* 37: 30 */ rTextures[0][(i + 1)] = tmp0; +/* 38: 31 */ ITexture[] tmp1 ={ new GT_RenderedTexture(Textures.BlockIcons.MACHINE_BRONZEBRICKS_TOP, Dyes.getModulation(i, Dyes._NULL.mRGBa)), new GT_RenderedTexture(Textures.BlockIcons.BOILER_SOLAR) }; + rTextures[1][(i + 1)] = tmp1; +/* 39: 32 */ ITexture[] tmp2 ={ new GT_RenderedTexture(Textures.BlockIcons.MACHINE_BRONZEBRICKS_SIDE, Dyes.getModulation(i, Dyes._NULL.mRGBa)) }; + rTextures[2][(i + 1)] = tmp2; +/* 40: 33 */ ITexture[] tmp3 ={ 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)] = tmp3; +/* 41: */ } +/* 42: 35 */ return rTextures; +/* 43: */ } +/* 44: */ +/* 45: */ @Override +public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) +/* 46: */ { + return mTextures[aSide >= 2 ? ((byte)(aSide != aFacing ? 2 : 3)) : aSide][aColorIndex + 1]; +/* 48: */ } +/* 49: */ +/* 50: */ @Override +public int maxProgresstime() +/* 51: */ { +/* 52: 43 */ return 500; +/* 53: */ } +/* 54: */ +/* 55: */ @Override +public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 56: */ { +/* 57: 47 */ return new GT_Container_Boiler(aPlayerInventory, aBaseMetaTileEntity, 16000); +/* 58: */ } +/* 59: */ +/* 60: */ @Override +public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 61: */ { +/* 62: 52 */ return new GT_GUIContainer_Boiler(aPlayerInventory, aBaseMetaTileEntity, "SolarBoiler.png", 16000); +/* 63: */ } +/* 64: */ +/* 65: */ @Override +public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 66: */ { +/* 67: 57 */ return new GT_MetaTileEntity_Boiler_Solar(this.mName, this.mTier, this.mDescription, this.mTextures); +/* 68: */ } +/* 69: */ +/* 70: */ @Override +public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) +/* 71: */ { +/* 72: 62 */ if ((aBaseMetaTileEntity.isServerSide()) && (aTick > 20L)) +/* 73: */ { +/* 74: 63 */ if (this.mTemperature <= 20) +/* 75: */ { +/* 76: 64 */ this.mTemperature = 20; +/* 77: 65 */ this.mLossTimer = 0; +/* 78: */ } +/* 79: 68 */ if (++this.mLossTimer > 45) +/* 80: */ { +/* 81: 69 */ this.mTemperature -= 1; +/* 82: 70 */ this.mLossTimer = 0; +/* 83: */ } +/* 84: 73 */ if (this.mSteam != null) +/* 85: */ { +/* 86: 74 */ byte i = aBaseMetaTileEntity.getFrontFacing(); +/* 87: 75 */ IFluidHandler tTileEntity = aBaseMetaTileEntity.getITankContainerAtSide(i); +/* 88: 76 */ if (tTileEntity != null) +/* 89: */ { +/* 90: 77 */ FluidStack tDrained = aBaseMetaTileEntity.drain(ForgeDirection.getOrientation(i), Math.max(1, this.mSteam.amount / 2), false); +/* 91: 78 */ if (tDrained != null) +/* 92: */ { +/* 93: 79 */ int tFilledAmount = tTileEntity.fill(ForgeDirection.getOrientation(i).getOpposite(), tDrained, false); +/* 94: 80 */ if (tFilledAmount > 0) { +/* 95: 81 */ tTileEntity.fill(ForgeDirection.getOrientation(i).getOpposite(), aBaseMetaTileEntity.drain(ForgeDirection.getOrientation(i), tFilledAmount, true), true); +/* 96: */ } +/* 97: */ } +/* 98: */ } +/* 99: */ } +/* 100: 87 */ if (aTick % 25L == 0L) { +/* 101: 88 */ if (this.mTemperature > 100) +/* 102: */ { +/* 103: 89 */ if ((this.mFluid == null) || (!GT_ModHandler.isWater(this.mFluid)) || (this.mFluid.amount <= 0)) +/* 104: */ { +/* 105: 90 */ this.mHadNoWater = true; +/* 106: */ } +/* 107: */ else +/* 108: */ { +/* 109: 92 */ if (this.mHadNoWater) +/* 110: */ { +/* 111: 93 */ aBaseMetaTileEntity.doExplosion(2048L); +/* 112: 94 */ return; +/* 113: */ } +/* 114: 96 */ this.mFluid.amount -= 1; +/* 115: 97 */ if (this.mSteam == null) { +/* 116: 98 */ this.mSteam = GT_ModHandler.getSteam(150L); +/* 117:100 */ } else if (GT_ModHandler.isSteam(this.mSteam)) { +/* 118:101 */ this.mSteam.amount += 150; +/* 119: */ } else { +/* 120:103 */ this.mSteam = GT_ModHandler.getSteam(150L); +/* 121: */ } +/* 122: */ } +/* 123: */ } +/* 124: */ else { +/* 125:108 */ this.mHadNoWater = false; +/* 126: */ } +/* 127: */ } +/* 128:112 */ if ((this.mSteam != null) && +/* 129:113 */ (this.mSteam.amount > 16000)) +/* 130: */ { +/* 131:114 */ sendSound((byte)1); +/* 132:115 */ this.mSteam.amount = 12000; +/* 133: */ } +/* 134:119 */ if ((this.mProcessingEnergy <= 0) && (aBaseMetaTileEntity.isAllowedToWork()) && (aTick % 256L == 0L) && (!aBaseMetaTileEntity.getWorld().isThundering())) +/* 135: */ { +/* 136:120 */ boolean bRain = (aBaseMetaTileEntity.getWorld().isRaining()) && (aBaseMetaTileEntity.getBiome().rainfall > 0.0F); +/* 137:121 */ this.mProcessingEnergy += (((!bRain) || (aBaseMetaTileEntity.getWorld().skylightSubtracted < 4)) && (aBaseMetaTileEntity.getSkyAtSide((byte)1)) ? 8 : (bRain) || (!aBaseMetaTileEntity.getWorld().isDaytime()) ? 1 : 0); +/* 138: */ } +/* 139:124 */ if ((this.mTemperature < 500) && (this.mProcessingEnergy > 0) && (aTick % 12L == 0L)) +/* 140: */ { +/* 141:125 */ this.mProcessingEnergy -= 1; +/* 142:126 */ this.mTemperature += 1; +/* 143: */ } +/* 144:129 */ aBaseMetaTileEntity.setActive(this.mProcessingEnergy > 0); +/* 145: */ } +/* 146: */ } +/* 147: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.boilers.GT_MetaTileEntity_Boiler_Solar + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Steel.java b/src/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Steel.java new file mode 100644 index 0000000..938577e --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/boilers/GT_MetaTileEntity_Boiler_Steel.java @@ -0,0 +1,191 @@ +/* 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; +/* 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_Steel +/* 21: */ extends GT_MetaTileEntity_Boiler +/* 22: */ { +/* 23: */ public GT_MetaTileEntity_Boiler_Steel(int aID, String aName, String aNameRegional) +/* 24: */ { +/* 25: 22 */ super(aID, aName, aNameRegional, "Faster than the Bronze Boiler", new ITexture[0]); +/* 26: */ } +/* 27: */ +/* 28: */ public GT_MetaTileEntity_Boiler_Steel(String aName, int aTier, String aDescription, ITexture[][][] aTextures) +/* 29: */ { +/* 30: 26 */ super(aName, aTier, aDescription, aTextures); +/* 31: */ } +/* 32: */ +/* 33: */ @Override +public ITexture[][][] getTextureSet(ITexture[] aTextures) +/* 34: */ { +/* 35: 31 */ ITexture[][][] rTextures = new ITexture[5][17][]; +/* 36: 32 */ for (byte i = -1; i < 16; i = (byte)(i + 1)) +/* 37: */ {ITexture[] tmp0 ={ new GT_RenderedTexture(Textures.BlockIcons.MACHINE_STEELBRICKS_BOTTOM, Dyes.getModulation(i, Dyes._NULL.mRGBa)) }; +/* 38: 33 */ rTextures[0][(i + 1)] = tmp0; +/* 39: 34 */ ITexture[] tmp1 ={ new GT_RenderedTexture(Textures.BlockIcons.MACHINE_STEELBRICKS_TOP, Dyes.getModulation(i, Dyes._NULL.mRGBa)), new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE) }; +rTextures[1][(i + 1)] = tmp1; +/* 40: 35 */ ITexture[] tmp2 ={ new GT_RenderedTexture(Textures.BlockIcons.MACHINE_STEELBRICKS_SIDE, Dyes.getModulation(i, Dyes._NULL.mRGBa)), new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE) }; +rTextures[2][(i + 1)] = tmp2; +/* 41: 36 */ ITexture[] tmp4 ={ new GT_RenderedTexture(Textures.BlockIcons.MACHINE_STEELBRICKS_SIDE, Dyes.getModulation(i, Dyes._NULL.mRGBa)), new GT_RenderedTexture(Textures.BlockIcons.BOILER_FRONT) }; +rTextures[3][(i + 1)] = tmp4; +/* 42: 37 */ ITexture[] tmp5 ={ new GT_RenderedTexture(Textures.BlockIcons.MACHINE_STEELBRICKS_SIDE, Dyes.getModulation(i, Dyes._NULL.mRGBa)), new GT_RenderedTexture(Textures.BlockIcons.BOILER_FRONT_ACTIVE) }; +rTextures[4][(i + 1)] = tmp5; +/* 43: */ } +/* 44: 39 */ return rTextures; +/* 45: */ } +/* 46: */ +/* 47: */ @Override +public int maxProgresstime() +/* 48: */ { +/* 49: 42 */ return 1000; +/* 50: */ } +/* 51: */ +/* 52: */ @Override +public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 53: */ { +/* 54: 46 */ return new GT_Container_Boiler(aPlayerInventory, aBaseMetaTileEntity, 32000); +/* 55: */ } +/* 56: */ +/* 57: */ @Override +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: */ @Override +public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 63: */ { +/* 64: 56 */ return new GT_MetaTileEntity_Boiler_Steel(this.mName, this.mTier, this.mDescription, this.mTextures); +/* 65: */ } +/* 66: */ +/* 67: */ @Override +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 > 40) +/* 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(150L); +/* 115: 98 */ } else if (GT_ModHandler.isSteam(this.mSteam)) { +/* 116: 99 */ this.mSteam.amount += 150; +/* 117: */ } else { +/* 118:101 */ this.mSteam = GT_ModHandler.getSteam(150L); +/* 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 */ (this.mInventory[2] != null)) { +/* 134:119 */ 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)))) +/* 135: */ { +/* 136:123 */ this.mProcessingEnergy += 160; +/* 137:124 */ aBaseMetaTileEntity.decrStackSize(2, 1); +/* 138:125 */ if (aBaseMetaTileEntity.getRandomNumber(3) == 0) { +/* 139:126 */ aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 1L)); +/* 140: */ } +/* 141: */ } +/* 142:129 */ 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)))) +/* 143: */ { +/* 144:133 */ this.mProcessingEnergy += 160; +/* 145:134 */ aBaseMetaTileEntity.decrStackSize(2, 1); +/* 146:135 */ if (aBaseMetaTileEntity.getRandomNumber(3) == 0) { +/* 147:136 */ aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Ash, 1L)); +/* 148: */ } +/* 149: */ } +/* 150:138 */ else if (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], "fuelCoke")) +/* 151: */ { +/* 152:139 */ this.mProcessingEnergy += 640; +/* 153:140 */ aBaseMetaTileEntity.decrStackSize(2, 1); +/* 154:141 */ if (aBaseMetaTileEntity.getRandomNumber(2) == 0) { +/* 155:142 */ aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Ash, 1L)); +/* 156: */ } +/* 157: */ } +/* 158:144 */ 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)))) +/* 159: */ { +/* 160:148 */ this.mProcessingEnergy += 40; +/* 161:149 */ aBaseMetaTileEntity.decrStackSize(2, 1); +/* 162:150 */ if (aBaseMetaTileEntity.getRandomNumber(8) == 0) { +/* 163:151 */ aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 1L)); +/* 164: */ } +/* 165: */ } +/* 166: */ } +/* 167:157 */ if ((this.mTemperature < 1000) && (this.mProcessingEnergy > 0) && (aTick % 12L == 0L)) +/* 168: */ { +/* 169:158 */ this.mProcessingEnergy -= 2; +/* 170:159 */ this.mTemperature += 1; +/* 171: */ } +/* 172:162 */ aBaseMetaTileEntity.setActive(this.mProcessingEnergy > 0); +/* 173: */ } +/* 174: */ } +/* 175: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.boilers.GT_MetaTileEntity_Boiler_Steel + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_DieselGenerator.java b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_DieselGenerator.java new file mode 100644 index 0000000..6f10baf --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_DieselGenerator.java @@ -0,0 +1,145 @@ +/* 1: */ package gregtech.common.tileentities.generators; +/* 2: */ +/* 3: */ import cpw.mods.fml.common.registry.GameRegistry; +import gregtech.api.GregTech_API; +import gregtech.api.enums.ConfigCategories; +/* 4: */ import gregtech.api.enums.ItemList; +import gregtech.api.enums.Textures; +/* 6: */ import gregtech.api.interfaces.ITexture; +/* 7: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 8: */ import gregtech.api.metatileentity.MetaTileEntity; +/* 9: */ +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicGenerator; +/* 10: */ import gregtech.api.objects.GT_RenderedTexture; +/* 11: */ import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_Recipe; +/* 13: */ import net.minecraft.item.ItemStack; +/* 14: */ +/* 15: */ public class GT_MetaTileEntity_DieselGenerator +/* 16: */ extends GT_MetaTileEntity_BasicGenerator +/* 17: */ { + + public int mEfficiency; +/* 18: */ @Override +public boolean isOutputFacing(byte aSide) +/* 19: */ { +/* 20:16 */ return aSide == getBaseMetaTileEntity().getFrontFacing(); +/* 21: */ } +/* 22: */ +/* 23: */ public GT_MetaTileEntity_DieselGenerator(int aID, String aName, String aNameRegional, int aTier) +/* 24: */ { +/* 25:19 */ super(aID, aName, aNameRegional, aTier, "Requires liquid Fuel", new ITexture[0]); + onConfigLoad(); +/* 26: */ } +/* 27: */ +/* 28: */ public GT_MetaTileEntity_DieselGenerator(String aName, int aTier, String aDescription, ITexture[][][] aTextures) +/* 29: */ { +/* 30:23 */ super(aName, aTier, aDescription, aTextures); + onConfigLoad(); +/* 31: */ } +/* 32: */ +/* 33: */ @Override +public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 34: */ { +/* 35:28 */ return new GT_MetaTileEntity_DieselGenerator(this.mName, this.mTier, this.mDescription, this.mTextures); +/* 36: */ } +/* 37: */ +/* 38: */ @Override +public GT_Recipe.GT_Recipe_Map getRecipes() +/* 39: */ { +/* 40:33 */ return GT_Recipe.GT_Recipe_Map.sDieselFuels; +/* 41: */ } +/* 42: */ +/* 43: */ @Override +public int getCapacity() +/* 44: */ { +/* 45:38 */ return 16000; +/* 46: */ } + +/* 47: */ public void onConfigLoad() +/* 39: */ { + this.mEfficiency =GregTech_API.sMachineFile.get(ConfigCategories.machineconfig, "DieselGenerator.efficiency.tier."+this.mTier, (100 - this.mTier * 10)); +} + +/* 48: */ @Override +public int getEfficiency() +/* 49: */ { +/* 50:43 */ return this.mEfficiency; +/* 51: */ } +/* 52: */ +/* 53: */ @Override +public int getFuelValue(ItemStack aStack) +/* 54: */ { +/* 55:48 */ int rValue = Math.max(GT_ModHandler.getFuelCanValue(aStack) * 6 / 5, super.getFuelValue(aStack)); +/* 56:49 */ if (ItemList.Fuel_Can_Plastic_Filled.isStackEqual(aStack, false, true)) { +/* 57:49 */ rValue = Math.max(rValue, GameRegistry.getFuelValue(aStack) * 3); +/* 58: */ } +/* 59:50 */ return rValue; +/* 60: */ } +/* 61: */ +/* 62: */ @Override +public ITexture[] getFront(byte aColor) +/* 63: */ { +/* 64:53 */ return new ITexture[] { super.getFront(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_FRONT), Textures.BlockIcons.OVERLAYS_ENERGY_OUT[this.mTier] }; +/* 65: */ } +/* 66: */ +/* 67: */ @Override +public ITexture[] getBack(byte aColor) +/* 68: */ { +/* 69:54 */ return new ITexture[] { super.getBack(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_BACK) }; +/* 70: */ } +/* 71: */ +/* 72: */ @Override +public ITexture[] getBottom(byte aColor) +/* 73: */ { +/* 74:55 */ return new ITexture[] { super.getBottom(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_BOTTOM) }; +/* 75: */ } +/* 76: */ +/* 77: */ @Override +public ITexture[] getTop(byte aColor) +/* 78: */ { +/* 79:56 */ return new ITexture[] { super.getTop(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_TOP) }; +/* 80: */ } +/* 81: */ +/* 82: */ @Override +public ITexture[] getSides(byte aColor) +/* 83: */ { +/* 84:57 */ return new ITexture[] { super.getSides(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_SIDE) }; +/* 85: */ } +/* 86: */ +/* 87: */ @Override +public ITexture[] getFrontActive(byte aColor) +/* 88: */ { +/* 89:58 */ return new ITexture[] { super.getFrontActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_FRONT_ACTIVE), Textures.BlockIcons.OVERLAYS_ENERGY_OUT[this.mTier] }; +/* 90: */ } +/* 91: */ +/* 92: */ @Override +public ITexture[] getBackActive(byte aColor) +/* 93: */ { +/* 94:59 */ return new ITexture[] { super.getBackActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_BACK_ACTIVE) }; +/* 95: */ } +/* 96: */ +/* 97: */ @Override +public ITexture[] getBottomActive(byte aColor) +/* 98: */ { +/* 99:60 */ return new ITexture[] { super.getBottomActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_BOTTOM_ACTIVE) }; +/* :0: */ } +/* :1: */ +/* :2: */ @Override +public ITexture[] getTopActive(byte aColor) +/* :3: */ { +/* :4:61 */ return new ITexture[] { super.getTopActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_TOP_ACTIVE) }; +/* :5: */ } +/* :6: */ +/* :7: */ @Override +public ITexture[] getSidesActive(byte aColor) +/* :8: */ { +/* :9:62 */ return new ITexture[] { super.getSidesActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.DIESEL_GENERATOR_SIDE_ACTIVE) }; +/* ;0: */ } +/* ;1: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.generators.GT_MetaTileEntity_DieselGenerator + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_FluidNaquadahReactor.java b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_FluidNaquadahReactor.java new file mode 100644 index 0000000..294abdf --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_FluidNaquadahReactor.java @@ -0,0 +1,119 @@ +/* 1: */ package gregtech.common.tileentities.generators; +/* 2: */ +/* 3: */ import gregtech.api.enums.Textures; +/* 4: */ import gregtech.api.interfaces.ITexture; +/* 5: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 6: */ import gregtech.api.metatileentity.MetaTileEntity; +/* 7: */ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicGenerator; +/* 8: */ import gregtech.api.objects.GT_RenderedTexture; +import gregtech.api.util.GT_Recipe; +/* 10: */ +/* 11: */ public class GT_MetaTileEntity_FluidNaquadahReactor +/* 12: */ extends GT_MetaTileEntity_BasicGenerator +/* 13: */ { +/* 14: */ @Override +public boolean isOutputFacing(byte aSide) +/* 15: */ { +/* 16:12 */ return (aSide > 1) && (aSide != getBaseMetaTileEntity().getFrontFacing()) && (aSide != getBaseMetaTileEntity().getBackFacing()); +/* 17: */ } +/* 18: */ +/* 19: */ public GT_MetaTileEntity_FluidNaquadahReactor(int aID, String aName, String aNameRegional, int aTier) +/* 20: */ { +/* 21:15 */ super(aID, aName, aNameRegional, aTier, "Requires Fluid Heavy Naquadah", new ITexture[0]); +/* 22: */ } +/* 23: */ +/* 24: */ public GT_MetaTileEntity_FluidNaquadahReactor(String aName, int aTier, String aDescription, ITexture[][][] aTextures) +/* 25: */ { +/* 26:19 */ super(aName, aTier, aDescription, aTextures); +/* 27: */ } +/* 28: */ +/* 29: */ @Override +public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 30: */ { +/* 31:24 */ return new GT_MetaTileEntity_FluidNaquadahReactor(this.mName, this.mTier, this.mDescription, this.mTextures); +/* 32: */ } +/* 33: */ +/* 34: */ @Override +public GT_Recipe.GT_Recipe_Map getRecipes() +/* 35: */ { +/* 36:29 */ return GT_Recipe.GT_Recipe_Map.sFluidNaquadahReactorFuels; +/* 37: */ } +/* 38: */ +/* 39: */ @Override +public int getCapacity() +/* 40: */ { +/* 41:34 */ return 16000; +/* 42: */ } +/* 43: */ +/* 44: */ @Override +public int getEfficiency() +/* 45: */ { +/* 46:39 */ return 100; +/* 47: */ } +/* 48: */ +/* 49: */ @Override +public ITexture[] getFront(byte aColor) +/* 50: */ { +/* 51:42 */ return new ITexture[] { super.getFront(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.NAQUADAH_REACTOR_FLUID_FRONT) }; +/* 52: */ } +/* 53: */ +/* 54: */ @Override +public ITexture[] getBack(byte aColor) +/* 55: */ { +/* 56:43 */ return new ITexture[] { super.getBack(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.NAQUADAH_REACTOR_FLUID_BACK) }; +/* 57: */ } +/* 58: */ +/* 59: */ @Override +public ITexture[] getBottom(byte aColor) +/* 60: */ { +/* 61:44 */ return new ITexture[] { super.getBottom(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.NAQUADAH_REACTOR_FLUID_BOTTOM) }; +/* 62: */ } +/* 63: */ +/* 64: */ @Override +public ITexture[] getTop(byte aColor) +/* 65: */ { +/* 66:45 */ return new ITexture[] { super.getTop(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.NAQUADAH_REACTOR_FLUID_TOP) }; +/* 67: */ } +/* 68: */ +/* 69: */ @Override +public ITexture[] getSides(byte aColor) +/* 70: */ { +/* 71:46 */ return new ITexture[] { super.getSides(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.NAQUADAH_REACTOR_FLUID_SIDE) }; +/* 72: */ } +/* 73: */ +/* 74: */ @Override +public ITexture[] getFrontActive(byte aColor) +/* 75: */ { +/* 76:47 */ return new ITexture[] { super.getFrontActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.NAQUADAH_REACTOR_FLUID_FRONT_ACTIVE) }; +/* 77: */ } +/* 78: */ +/* 79: */ @Override +public ITexture[] getBackActive(byte aColor) +/* 80: */ { +/* 81:48 */ return new ITexture[] { super.getBackActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.NAQUADAH_REACTOR_FLUID_BACK_ACTIVE) }; +/* 82: */ } +/* 83: */ +/* 84: */ @Override +public ITexture[] getBottomActive(byte aColor) +/* 85: */ { +/* 86:49 */ return new ITexture[] { super.getBottomActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.NAQUADAH_REACTOR_FLUID_BOTTOM_ACTIVE) }; +/* 87: */ } +/* 88: */ +/* 89: */ @Override +public ITexture[] getTopActive(byte aColor) +/* 90: */ { +/* 91:50 */ return new ITexture[] { super.getTopActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.NAQUADAH_REACTOR_FLUID_TOP_ACTIVE) }; +/* 92: */ } +/* 93: */ +/* 94: */ @Override +public ITexture[] getSidesActive(byte aColor) +/* 95: */ { +/* 96:51 */ return new ITexture[] { super.getSidesActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.NAQUADAH_REACTOR_FLUID_SIDE_ACTIVE) }; +/* 97: */ } +/* 98: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.generators.GT_MetaTileEntity_FluidNaquadahReactor + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_GasTurbine.java b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_GasTurbine.java new file mode 100644 index 0000000..f8683a0 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_GasTurbine.java @@ -0,0 +1,131 @@ +/* 1: */ package gregtech.common.tileentities.generators; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.ConfigCategories; +import gregtech.api.enums.Textures; +/* 4: */ import gregtech.api.interfaces.ITexture; +/* 5: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 6: */ import gregtech.api.metatileentity.MetaTileEntity; +/* 7: */ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicGenerator; +/* 8: */ import gregtech.api.objects.GT_RenderedTexture; +import gregtech.api.util.GT_Recipe; +/* 10: */ +/* 11: */ public class GT_MetaTileEntity_GasTurbine +/* 12: */ extends GT_MetaTileEntity_BasicGenerator +/* 13: */ { + + public int mEfficiency; +/* 14: */ @Override +public boolean isOutputFacing(byte aSide) +/* 15: */ { +/* 16:12 */ return aSide == getBaseMetaTileEntity().getFrontFacing(); +/* 17: */ } +/* 18: */ +/* 19: */ public GT_MetaTileEntity_GasTurbine(int aID, String aName, String aNameRegional, int aTier) +/* 20: */ { +/* 21:15 */ super(aID, aName, aNameRegional, aTier, "Requires flammable Gasses", new ITexture[0]); +onConfigLoad(); +/* 22: */ } +/* 23: */ +/* 24: */ public GT_MetaTileEntity_GasTurbine(String aName, int aTier, String aDescription, ITexture[][][] aTextures) +/* 25: */ { +/* 26:19 */ super(aName, aTier, aDescription, aTextures); +onConfigLoad(); +/* 27: */ } +/* 28: */ +/* 29: */ @Override +public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 30: */ { +/* 31:24 */ return new GT_MetaTileEntity_GasTurbine(this.mName, this.mTier, this.mDescription, this.mTextures); +/* 32: */ } +/* 33: */ +/* 34: */ @Override +public GT_Recipe.GT_Recipe_Map getRecipes() +/* 35: */ { +/* 36:29 */ return GT_Recipe.GT_Recipe_Map.sTurbineFuels; +/* 37: */ } +/* 38: */ +/* 39: */ @Override +public int getCapacity() +/* 40: */ { +/* 41:34 */ return 16000; +/* 42: */ } + +public void onConfigLoad() +/* 39: */ { + this.mEfficiency =GregTech_API.sMachineFile.get(ConfigCategories.machineconfig, "GasTurbine.efficiency.tier."+this.mTier, (100 - this.mTier * 10)); +} + +/* 43: */ +/* 44: */ @Override +public int getEfficiency() +/* 45: */ { +/* 46:39 */ return this.mEfficiency; +/* 47: */ } +/* 48: */ +/* 49: */ @Override +public ITexture[] getFront(byte aColor) +/* 50: */ { +/* 51:42 */ return new ITexture[] { super.getFront(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.GAS_TURBINE_FRONT), Textures.BlockIcons.OVERLAYS_ENERGY_OUT[this.mTier] }; +/* 52: */ } +/* 53: */ +/* 54: */ @Override +public ITexture[] getBack(byte aColor) +/* 55: */ { +/* 56:43 */ return new ITexture[] { super.getBack(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.GAS_TURBINE_BACK) }; +/* 57: */ } +/* 58: */ +/* 59: */ @Override +public ITexture[] getBottom(byte aColor) +/* 60: */ { +/* 61:44 */ return new ITexture[] { super.getBottom(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.GAS_TURBINE_BOTTOM) }; +/* 62: */ } +/* 63: */ +/* 64: */ @Override +public ITexture[] getTop(byte aColor) +/* 65: */ { +/* 66:45 */ return new ITexture[] { super.getTop(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.GAS_TURBINE_TOP) }; +/* 67: */ } +/* 68: */ +/* 69: */ @Override +public ITexture[] getSides(byte aColor) +/* 70: */ { +/* 71:46 */ return new ITexture[] { super.getSides(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.GAS_TURBINE_SIDE) }; +/* 72: */ } +/* 73: */ +/* 74: */ @Override +public ITexture[] getFrontActive(byte aColor) +/* 75: */ { +/* 76:47 */ return new ITexture[] { super.getFrontActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.GAS_TURBINE_FRONT_ACTIVE), Textures.BlockIcons.OVERLAYS_ENERGY_OUT[this.mTier] }; +/* 77: */ } +/* 78: */ +/* 79: */ @Override +public ITexture[] getBackActive(byte aColor) +/* 80: */ { +/* 81:48 */ return new ITexture[] { super.getBackActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.GAS_TURBINE_BACK_ACTIVE) }; +/* 82: */ } +/* 83: */ +/* 84: */ @Override +public ITexture[] getBottomActive(byte aColor) +/* 85: */ { +/* 86:49 */ return new ITexture[] { super.getBottomActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.GAS_TURBINE_BOTTOM_ACTIVE) }; +/* 87: */ } +/* 88: */ +/* 89: */ @Override +public ITexture[] getTopActive(byte aColor) +/* 90: */ { +/* 91:50 */ return new ITexture[] { super.getTopActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.GAS_TURBINE_TOP_ACTIVE) }; +/* 92: */ } +/* 93: */ +/* 94: */ @Override +public ITexture[] getSidesActive(byte aColor) +/* 95: */ { +/* 96:51 */ return new ITexture[] { super.getSidesActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.GAS_TURBINE_SIDE_ACTIVE) }; +/* 97: */ } +/* 98: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.generators.GT_MetaTileEntity_GasTurbine + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_MagicEnergyConverter.java b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_MagicEnergyConverter.java new file mode 100644 index 0000000..342b2ce --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_MagicEnergyConverter.java @@ -0,0 +1,125 @@ +package gregtech.common.tileentities.generators; + +/* 3: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.ConfigCategories; +import gregtech.api.enums.Textures; +/* 4: */ import gregtech.api.interfaces.ITexture; +/* 5: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 6: */ import gregtech.api.metatileentity.MetaTileEntity; +/* 7: */ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicGenerator; +/* 8: */ import gregtech.api.objects.GT_RenderedTexture; +import gregtech.api.util.GT_Recipe; +/* 10: */ +/* 11: */ public class GT_MetaTileEntity_MagicEnergyConverter +/* 12: */ extends GT_MetaTileEntity_BasicGenerator +/* 13: */ { + + public int mEfficiency; +/* 14: */ @Override +public boolean isOutputFacing(byte aSide) +/* 15: */ { +/* 16:12 */ return aSide == getBaseMetaTileEntity().getFrontFacing(); +/* 17: */ } +/* 18: */ +/* 19: */ public GT_MetaTileEntity_MagicEnergyConverter(int aID, String aName, String aNameRegional, int aTier) +/* 20: */ { +/* 21:15 */ super(aID, aName, aNameRegional, aTier, "Put your strange stuff in here", new ITexture[0]); +onConfigLoad(); +/* 22: */ } +/* 23: */ +/* 24: */ public GT_MetaTileEntity_MagicEnergyConverter(String aName, int aTier, String aDescription, ITexture[][][] aTextures) +/* 25: */ { +/* 26:19 */ super(aName, aTier, aDescription, aTextures); +onConfigLoad(); +/* 27: */ } +/* 28: */ +/* 29: */ @Override +public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 30: */ { +/* 31:24 */ return new GT_MetaTileEntity_MagicEnergyConverter(this.mName, this.mTier, this.mDescription, this.mTextures); +/* 32: */ } +/* 33: */ +/* 34: */ @Override +public GT_Recipe.GT_Recipe_Map getRecipes() +/* 35: */ { +/* 36:29 */ return GT_Recipe.GT_Recipe_Map.sMagicFuels; +/* 37: */ } +/* 38: */ +/* 39: */ @Override +public int getCapacity() +/* 40: */ { +/* 41:34 */ return 16000; +/* 42: */ } + +public void onConfigLoad() +/* 39: */ { + this.mEfficiency =GregTech_API.sMachineFile.get(ConfigCategories.machineconfig, "MagicEnergyConverter.efficiency.tier."+this.mTier, 100-this.mTier*10); +} + +/* 43: */ +/* 44: */ @Override +public int getEfficiency() +/* 45: */ { +/* 46:39 */ return this.mEfficiency; +/* 47: */ } +/* 48: */ +/* 49: */ @Override +public ITexture[] getFront(byte aColor) +/* 50: */ { +/* 51:42 */ return new ITexture[] { super.getFront(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_MAGIC), Textures.BlockIcons.OVERLAYS_ENERGY_OUT[this.mTier] }; +/* 52: */ } +/* 53: */ +/* 54: */ @Override +public ITexture[] getBack(byte aColor) +/* 55: */ { +/* 56:43 */ return new ITexture[] { super.getBack(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_MAGIC_FRONT) }; +/* 57: */ } +/* 58: */ +/* 59: */ @Override +public ITexture[] getBottom(byte aColor) +/* 60: */ { +/* 61:44 */ return new ITexture[] { super.getBottom(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_MAGIC) }; +/* 62: */ } +/* 63: */ +/* 64: */ @Override +public ITexture[] getTop(byte aColor) +/* 65: */ { +/* 66:45 */ return new ITexture[] { super.getTop(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_MAGIC) }; +/* 67: */ } +/* 68: */ +/* 69: */ @Override +public ITexture[] getSides(byte aColor) +/* 70: */ { +/* 71:46 */ return new ITexture[] { super.getSides(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_MAGIC) }; +/* 72: */ } +/* 73: */ +/* 74: */ @Override +public ITexture[] getFrontActive(byte aColor) +/* 75: */ { +/* 76:47 */ return new ITexture[] { super.getFrontActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_MAGIC_ACTIVE), Textures.BlockIcons.OVERLAYS_ENERGY_OUT[this.mTier] }; +/* 77: */ } +/* 78: */ +/* 79: */ @Override +public ITexture[] getBackActive(byte aColor) +/* 80: */ { +/* 81:48 */ return new ITexture[] { super.getBackActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_MAGIC_FRONT_ACTIVE) }; +/* 82: */ } +/* 83: */ +/* 84: */ @Override +public ITexture[] getBottomActive(byte aColor) +/* 85: */ { +/* 86:49 */ return new ITexture[] { super.getBottomActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_MAGIC_ACTIVE) }; +/* 87: */ } +/* 88: */ +/* 89: */ @Override +public ITexture[] getTopActive(byte aColor) +/* 90: */ { +/* 91:50 */ return new ITexture[] { super.getTopActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_MAGIC_ACTIVE) }; +/* 92: */ } +/* 93: */ +/* 94: */ @Override +public ITexture[] getSidesActive(byte aColor) +/* 95: */ { +/* 96:51 */ return new ITexture[] { super.getSidesActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_MAGIC_ACTIVE) }; +/* 97: */ } +/* 98: */ } \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_MagicalEnergyAbsorber.java b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_MagicalEnergyAbsorber.java new file mode 100644 index 0000000..9718dc1 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_MagicalEnergyAbsorber.java @@ -0,0 +1,264 @@ +package gregtech.common.tileentities.generators; + +/* 3: */ import java.util.ArrayList; + +import cpw.mods.fml.common.Loader; +import gregtech.api.GregTech_API; +import gregtech.api.enums.ConfigCategories; +import gregtech.api.enums.Textures; +/* 4: */ import gregtech.api.interfaces.ITexture; +/* 5: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 6: */ import gregtech.api.metatileentity.MetaTileEntity; +/* 7: */ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicGenerator; +/* 8: */ import gregtech.api.objects.GT_RenderedTexture; +import gregtech.api.util.GT_Recipe; +import net.minecraft.block.Block; +import net.minecraft.enchantment.Enchantment; +import net.minecraft.entity.item.EntityEnderCrystal; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemEnchantedBook; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagList; +import net.minecraft.util.AxisAlignedBB; +/* 10: */ +/* 11: */ public class GT_MetaTileEntity_MagicalEnergyAbsorber +/* 12: */ extends GT_MetaTileEntity_BasicGenerator +/* 13: */ { + + public int mEfficiency; + public static boolean sAllowMultipleEggs = true; + public static GT_MetaTileEntity_MagicalEnergyAbsorber mActiveSiphon = null; + public static int sEnergyPerEnderCrystal = 32; + public static int sEnergyFromVis = 12800; + public static final ArrayList sUsedDragonCrystalList = new ArrayList(); + public EntityEnderCrystal mTargetedCrystal; + public static int sDragonEggEnergyPerTick = 128; + public static boolean isThaumcraftLoaded; + +/* 14: */ @Override +public boolean isOutputFacing(byte aSide) +/* 15: */ { +/* 16:12 */ return aSide == getBaseMetaTileEntity().getFrontFacing(); +/* 17: */ } +/* 18: */ +/* 19: */ public GT_MetaTileEntity_MagicalEnergyAbsorber(int aID, String aName, String aNameRegional, int aTier) +/* 20: */ { +/* 21:15 */ super(aID, aName, aNameRegional, aTier, "Feasts on magic close to it", new ITexture[0]); + onConfigLoad(); +/* 22: */ } +/* 23: */ +/* 24: */ public GT_MetaTileEntity_MagicalEnergyAbsorber(String aName, int aTier, String aDescription, ITexture[][][] aTextures) +/* 25: */ { +/* 26:19 */ super(aName, aTier, aDescription, aTextures); + onConfigLoad(); +/* 27: */ } +/* 28: */ +/* 29: */ @Override +public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 30: */ { +/* 31:24 */ return new GT_MetaTileEntity_MagicalEnergyAbsorber(this.mName, this.mTier, this.mDescription, this.mTextures); +/* 32: */ } +/* 33: */ +/* 34: */ @Override +public GT_Recipe.GT_Recipe_Map getRecipes() +/* 35: */ { +/* 36:29 */ return GT_Recipe.GT_Recipe_Map.sMagicFuels; +/* 37: */ } +/* 38: */ +/* 39: */ @Override +public int getCapacity() +/* 40: */ { +/* 41:34 */ return 16000; +/* 42: */ } + + public void onConfigLoad() +/* 39: */ { + this.mEfficiency =GregTech_API.sMachineFile.get(ConfigCategories.machineconfig, "MagicEnergyAbsorber.efficiency.tier."+this.mTier, 100-this.mTier*10); + GT_MetaTileEntity_MagicalEnergyAbsorber.sAllowMultipleEggs = GregTech_API.sMachineFile.get(ConfigCategories.machineconfig, "MagicEnergyAbsorber.AllowMultipleEggs", false); + GT_MetaTileEntity_MagicalEnergyAbsorber.sEnergyPerEnderCrystal = GregTech_API.sMachineFile.get(ConfigCategories.machineconfig, "MagicEnergyAbsorber.EnergyPerTick.EnderCrystal", 32); + GT_MetaTileEntity_MagicalEnergyAbsorber.sEnergyFromVis = (GregTech_API.sMachineFile.get(ConfigCategories.machineconfig, "MagicEnergyAbsorber.EnergyPerVisDivisor", 2500)*10); + GT_MetaTileEntity_MagicalEnergyAbsorber.sDragonEggEnergyPerTick = GregTech_API.sMachineFile.get(ConfigCategories.machineconfig, "MagicEnergyAbsorber.EnergyPerTick", 2048); + GT_MetaTileEntity_MagicalEnergyAbsorber.isThaumcraftLoaded = Loader.isModLoaded("Thaumcraft"); + } + + @SuppressWarnings("unchecked") + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if (aBaseMetaTileEntity.isServerSide() && aBaseMetaTileEntity.isAllowedToWork() && aBaseMetaTileEntity.getUniversalEnergyStored() < maxEUOutput() + aBaseMetaTileEntity.getEUCapacity()) { + //Dragon Egg + if(hasEgg()&&aTick%10==0){ + getBaseMetaTileEntity().increaseStoredEnergyUnits(sDragonEggEnergyPerTick*getEfficiency()*10, false); + if ((mActiveSiphon != this) && (!sAllowMultipleEggs)) { + if ((mActiveSiphon == null) || (mActiveSiphon.getBaseMetaTileEntity() == null) || (mActiveSiphon.getBaseMetaTileEntity().isInvalidTileEntity()) || (!mActiveSiphon.hasEgg())) { + mActiveSiphon = this; + } else { + getBaseMetaTileEntity().doExplosion(Integer.MAX_VALUE); + } + } + } + //Energyzed node + //EnderCrystal + + if (sEnergyPerEnderCrystal > 0) { + if (this.mTargetedCrystal == null) + { + ArrayList tList = (ArrayList)getBaseMetaTileEntity().getWorld().getEntitiesWithinAABB(EntityEnderCrystal.class, AxisAlignedBB.getBoundingBox(getBaseMetaTileEntity().getXCoord() - 64, getBaseMetaTileEntity().getYCoord() - 64, getBaseMetaTileEntity().getZCoord() - 64, getBaseMetaTileEntity().getXCoord() + 64, getBaseMetaTileEntity().getYCoord() + 64, getBaseMetaTileEntity().getZCoord() + 64)); + if ((tList != null) && (!tList.isEmpty())) + { + tList.removeAll(sUsedDragonCrystalList); + if (tList.size() > 0) + { + this.mTargetedCrystal = (tList.get(0)); + if (this.mTargetedCrystal != null) { + sUsedDragonCrystalList.add(this.mTargetedCrystal); + } + } + } + } + else if (this.mTargetedCrystal.isEntityAlive()) + { + getBaseMetaTileEntity().increaseStoredEnergyUnits(sEnergyPerEnderCrystal * 10, false); + } + else + { + sUsedDragonCrystalList.remove(this.mTargetedCrystal); + this.mTargetedCrystal = null; + } + } + + //Absorb entchantments + + try + { + if ((this.mInventory[0] != null) && (this.mInventory[1] == null)) + { + if ((this.mInventory[0].isItemEnchanted()) && (this.mInventory[0].getItem().getItemEnchantability() > 0)) + { + NBTTagList tEnchantments = this.mInventory[0].getEnchantmentTagList(); + if (tEnchantments != null) + { + for (int i = 0; i < tEnchantments.tagCount(); i++) + { + short tID = tEnchantments.getCompoundTagAt(i).getShort("id"); + short tLevel = tEnchantments.getCompoundTagAt(i).getShort("lvl"); + if ((tID > -1) && (tID < Enchantment.enchantmentsList.length)) + { + Enchantment tEnchantment = Enchantment.enchantmentsList[tID]; + if (tEnchantment != null) { + getBaseMetaTileEntity().increaseStoredEnergyUnits(1000000 * tLevel / (tEnchantment.getMaxLevel() * tEnchantment.getWeight()), true); + } + } + } + this.mInventory[0].stackTagCompound.removeTag("ench"); + } + } + else if ((this.mInventory[0].getItem() instanceof ItemEnchantedBook)) + { + NBTTagList tEnchantments = ((ItemEnchantedBook)this.mInventory[0].getItem()).func_92110_g(this.mInventory[0]); + if (tEnchantments != null) + { + for (int i = 0; i < tEnchantments.tagCount(); i++) + { + short tID = tEnchantments.getCompoundTagAt(i).getShort("id"); + short tLevel = tEnchantments.getCompoundTagAt(i).getShort("lvl"); + if ((tID > -1) && (tID < Enchantment.enchantmentsBookList.length)) + { + Enchantment tEnchantment = Enchantment.enchantmentsBookList[tID]; + if (tEnchantment != null) { + getBaseMetaTileEntity().increaseStoredEnergyUnits(1000000 * tLevel / (tEnchantment.getMaxLevel() * tEnchantment.getWeight()), true); + } + } + } + this.mInventory[0] = new ItemStack(Items.book, 1); + } + } + this.mInventory[1] = this.mInventory[0]; + this.mInventory[0] = null; + } + } + catch (Throwable e){} + } + } + + @Override + public void inValidate() + { + if (mActiveSiphon == this) { + mActiveSiphon = null; + } + } + + public boolean hasEgg() + { + Block above = getBaseMetaTileEntity().getBlockOffset(0, 1, 0); + if(above==null||Blocks.air==above){return false;} + return Blocks.dragon_egg == above || above.getUnlocalizedName().equals("tile.dragonEgg"); + } +/* 43: */ +/* 44: */ @Override +public int getEfficiency() +/* 45: */ { +/* 46:39 */ return this.mEfficiency; +/* 47: */ } +/* 48: */ +/* 49: */ @Override +public ITexture[] getFront(byte aColor) +/* 50: */ { +/* 51:42 */ return new ITexture[] { super.getFront(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_MAGIC), Textures.BlockIcons.OVERLAYS_ENERGY_OUT[this.mTier] }; +/* 52: */ } +/* 53: */ +/* 54: */ @Override +public ITexture[] getBack(byte aColor) +/* 55: */ { +/* 56:43 */ return new ITexture[] { super.getBack(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_MAGIC_FRONT) }; +/* 57: */ } +/* 58: */ +/* 59: */ @Override +public ITexture[] getBottom(byte aColor) +/* 60: */ { +/* 61:44 */ return new ITexture[] { super.getBottom(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_MAGIC) }; +/* 62: */ } +/* 63: */ +/* 64: */ @Override +public ITexture[] getTop(byte aColor) +/* 65: */ { +/* 66:45 */ return new ITexture[] { super.getTop(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_DRAGONEGG) }; +/* 67: */ } +/* 68: */ +/* 69: */ @Override +public ITexture[] getSides(byte aColor) +/* 70: */ { +/* 71:46 */ return new ITexture[] { super.getSides(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_MAGIC) }; +/* 72: */ } +/* 73: */ +/* 74: */ @Override +public ITexture[] getFrontActive(byte aColor) +/* 75: */ { +/* 76:47 */ return new ITexture[] { super.getFrontActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_MAGIC_ACTIVE), Textures.BlockIcons.OVERLAYS_ENERGY_OUT[this.mTier] }; +/* 77: */ } +/* 78: */ +/* 79: */ @Override +public ITexture[] getBackActive(byte aColor) +/* 80: */ { +/* 81:48 */ return new ITexture[] { super.getBackActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_MAGIC_FRONT_ACTIVE) }; +/* 82: */ } +/* 83: */ +/* 84: */ @Override +public ITexture[] getBottomActive(byte aColor) +/* 85: */ { +/* 86:49 */ return new ITexture[] { super.getBottomActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_MAGIC_ACTIVE) }; +/* 87: */ } +/* 88: */ +/* 89: */ @Override +public ITexture[] getTopActive(byte aColor) +/* 90: */ { +/* 91:50 */ return new ITexture[] { super.getTopActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_DRAGONEGG) }; +/* 92: */ } +/* 93: */ +/* 94: */ @Override +public ITexture[] getSidesActive(byte aColor) +/* 95: */ { +/* 96:51 */ return new ITexture[] { super.getSidesActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_MAGIC_ACTIVE) }; +/* 97: */ } +/* 98: */ } \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_PlasmaGenerator.java b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_PlasmaGenerator.java new file mode 100644 index 0000000..26cd32f --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_PlasmaGenerator.java @@ -0,0 +1,125 @@ +package gregtech.common.tileentities.generators; + +/* 3: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.ConfigCategories; +import gregtech.api.enums.Textures; +/* 4: */ import gregtech.api.interfaces.ITexture; +/* 5: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 6: */ import gregtech.api.metatileentity.MetaTileEntity; +/* 7: */ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicGenerator; +/* 8: */ import gregtech.api.objects.GT_RenderedTexture; +import gregtech.api.util.GT_Recipe; +/* 10: */ +/* 11: */ public class GT_MetaTileEntity_PlasmaGenerator +/* 12: */ extends GT_MetaTileEntity_BasicGenerator +/* 13: */ { + + public int mEfficiency; +/* 14: */ @Override +public boolean isOutputFacing(byte aSide) +/* 15: */ { +/* 16:12 */ return aSide == getBaseMetaTileEntity().getFrontFacing(); +/* 17: */ } +/* 18: */ +/* 19: */ public GT_MetaTileEntity_PlasmaGenerator(int aID, String aName, String aNameRegional, int aTier) +/* 20: */ { +/* 21:15 */ super(aID, aName, aNameRegional, aTier, "Plasma into energy", new ITexture[0]); +onConfigLoad(); +/* 22: */ } +/* 23: */ +/* 24: */ public GT_MetaTileEntity_PlasmaGenerator(String aName, int aTier, String aDescription, ITexture[][][] aTextures) +/* 25: */ { +/* 26:19 */ super(aName, aTier, aDescription, aTextures); +onConfigLoad(); +/* 27: */ } +/* 28: */ +/* 29: */ @Override +public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 30: */ { +/* 31:24 */ return new GT_MetaTileEntity_PlasmaGenerator(this.mName, this.mTier, this.mDescription, this.mTextures); +/* 32: */ } +/* 33: */ +/* 34: */ @Override +public GT_Recipe.GT_Recipe_Map getRecipes() +/* 35: */ { +/* 36:29 */ return GT_Recipe.GT_Recipe_Map.sPlasmaFuels; +/* 37: */ } +/* 38: */ +/* 39: */ @Override +public int getCapacity() +/* 40: */ { +/* 41:34 */ return 16000; +/* 42: */ } + +public void onConfigLoad() +/* 39: */ { + this.mEfficiency =GregTech_API.sMachineFile.get(ConfigCategories.machineconfig, "PlasmaGenerator.efficiency.tier."+this.mTier, (10 + (this.mTier * 10))); +} + +/* 43: */ +/* 44: */ @Override +public int getEfficiency() +/* 45: */ { +/* 46:39 */ return this.mEfficiency; +/* 47: */ } +/* 48: */ +/* 49: */ @Override +public ITexture[] getFront(byte aColor) +/* 50: */ { +/* 51:42 */ return new ITexture[] { super.getFront(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS), Textures.BlockIcons.OVERLAYS_ENERGY_OUT[this.mTier] }; +/* 52: */ } +/* 53: */ +/* 54: */ @Override +public ITexture[] getBack(byte aColor) +/* 55: */ { +/* 56:43 */ return new ITexture[] { super.getBack(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS) }; +/* 57: */ } +/* 58: */ +/* 59: */ @Override +public ITexture[] getBottom(byte aColor) +/* 60: */ { +/* 61:44 */ return new ITexture[] { super.getBottom(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS) }; +/* 62: */ } +/* 63: */ +/* 64: */ @Override +public ITexture[] getTop(byte aColor) +/* 65: */ { +/* 66:45 */ return new ITexture[] { super.getTop(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS) }; +/* 67: */ } +/* 68: */ +/* 69: */ @Override +public ITexture[] getSides(byte aColor) +/* 70: */ { +/* 71:46 */ return new ITexture[] { super.getSides(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS) }; +/* 72: */ } +/* 73: */ +/* 74: */ @Override +public ITexture[] getFrontActive(byte aColor) +/* 75: */ { +/* 76:47 */ return new ITexture[] { super.getFrontActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS_YELLOW), Textures.BlockIcons.OVERLAYS_ENERGY_OUT[this.mTier] }; +/* 77: */ } +/* 78: */ +/* 79: */ @Override +public ITexture[] getBackActive(byte aColor) +/* 80: */ { +/* 81:48 */ return new ITexture[] { super.getBackActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS_YELLOW) }; +/* 82: */ } +/* 83: */ +/* 84: */ @Override +public ITexture[] getBottomActive(byte aColor) +/* 85: */ { +/* 86:49 */ return new ITexture[] { super.getBottomActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS_YELLOW) }; +/* 87: */ } +/* 88: */ +/* 89: */ @Override +public ITexture[] getTopActive(byte aColor) +/* 90: */ { +/* 91:50 */ return new ITexture[] { super.getTopActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS_YELLOW) }; +/* 92: */ } +/* 93: */ +/* 94: */ @Override +public ITexture[] getSidesActive(byte aColor) +/* 95: */ { +/* 96:51 */ return new ITexture[] { super.getSidesActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS_YELLOW) }; +/* 97: */ } +/* 98: */ } \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_SolidNaquadahReactor.java b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_SolidNaquadahReactor.java new file mode 100644 index 0000000..666c16f --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_SolidNaquadahReactor.java @@ -0,0 +1,119 @@ +/* 1: */ package gregtech.common.tileentities.generators; +/* 2: */ +/* 3: */ import gregtech.api.enums.Textures; +/* 4: */ import gregtech.api.interfaces.ITexture; +/* 5: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 6: */ import gregtech.api.metatileentity.MetaTileEntity; +/* 7: */ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicGenerator; +/* 8: */ import gregtech.api.objects.GT_RenderedTexture; +import gregtech.api.util.GT_Recipe; +/* 10: */ +/* 11: */ public class GT_MetaTileEntity_SolidNaquadahReactor +/* 12: */ extends GT_MetaTileEntity_BasicGenerator +/* 13: */ { +/* 14: */ @Override +public boolean isOutputFacing(byte aSide) +/* 15: */ { +/* 16:12 */ return (aSide > 1) && (aSide != getBaseMetaTileEntity().getFrontFacing()) && (aSide != getBaseMetaTileEntity().getBackFacing()); +/* 17: */ } +/* 18: */ +/* 19: */ public GT_MetaTileEntity_SolidNaquadahReactor(int aID, String aName, String aNameRegional, int aTier) +/* 20: */ { +/* 21:15 */ super(aID, aName, aNameRegional, aTier, "Requires Enriched Naquadah Bolts", new ITexture[0]); +/* 22: */ } +/* 23: */ +/* 24: */ public GT_MetaTileEntity_SolidNaquadahReactor(String aName, int aTier, String aDescription, ITexture[][][] aTextures) +/* 25: */ { +/* 26:19 */ super(aName, aTier, aDescription, aTextures); +/* 27: */ } +/* 28: */ +/* 29: */ @Override +public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 30: */ { +/* 31:24 */ return new GT_MetaTileEntity_SolidNaquadahReactor(this.mName, this.mTier, this.mDescription, this.mTextures); +/* 32: */ } +/* 33: */ +/* 34: */ @Override +public GT_Recipe.GT_Recipe_Map getRecipes() +/* 35: */ { +/* 36:29 */ return GT_Recipe.GT_Recipe_Map.sSmallNaquadahReactorFuels; +/* 37: */ } +/* 38: */ +/* 39: */ @Override +public int getCapacity() +/* 40: */ { +/* 41:34 */ return 0; +/* 42: */ } +/* 43: */ +/* 44: */ @Override +public int getEfficiency() +/* 45: */ { +/* 46:39 */ return 80; +/* 47: */ } +/* 48: */ +/* 49: */ @Override +public ITexture[] getFront(byte aColor) +/* 50: */ { +/* 51:42 */ return new ITexture[] { super.getFront(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.NAQUADAH_REACTOR_SOLID_FRONT) }; +/* 52: */ } +/* 53: */ +/* 54: */ @Override +public ITexture[] getBack(byte aColor) +/* 55: */ { +/* 56:43 */ return new ITexture[] { super.getBack(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.NAQUADAH_REACTOR_SOLID_BACK) }; +/* 57: */ } +/* 58: */ +/* 59: */ @Override +public ITexture[] getBottom(byte aColor) +/* 60: */ { +/* 61:44 */ return new ITexture[] { super.getBottom(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.NAQUADAH_REACTOR_SOLID_BOTTOM) }; +/* 62: */ } +/* 63: */ +/* 64: */ @Override +public ITexture[] getTop(byte aColor) +/* 65: */ { +/* 66:45 */ return new ITexture[] { super.getTop(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.NAQUADAH_REACTOR_SOLID_TOP) }; +/* 67: */ } +/* 68: */ +/* 69: */ @Override +public ITexture[] getSides(byte aColor) +/* 70: */ { +/* 71:46 */ return new ITexture[] { super.getSides(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.NAQUADAH_REACTOR_SOLID_SIDE) }; +/* 72: */ } +/* 73: */ +/* 74: */ @Override +public ITexture[] getFrontActive(byte aColor) +/* 75: */ { +/* 76:47 */ return new ITexture[] { super.getFrontActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.NAQUADAH_REACTOR_SOLID_FRONT_ACTIVE) }; +/* 77: */ } +/* 78: */ +/* 79: */ @Override +public ITexture[] getBackActive(byte aColor) +/* 80: */ { +/* 81:48 */ return new ITexture[] { super.getBackActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.NAQUADAH_REACTOR_SOLID_BACK_ACTIVE) }; +/* 82: */ } +/* 83: */ +/* 84: */ @Override +public ITexture[] getBottomActive(byte aColor) +/* 85: */ { +/* 86:49 */ return new ITexture[] { super.getBottomActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.NAQUADAH_REACTOR_SOLID_BOTTOM_ACTIVE) }; +/* 87: */ } +/* 88: */ +/* 89: */ @Override +public ITexture[] getTopActive(byte aColor) +/* 90: */ { +/* 91:50 */ return new ITexture[] { super.getTopActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.NAQUADAH_REACTOR_SOLID_TOP_ACTIVE) }; +/* 92: */ } +/* 93: */ +/* 94: */ @Override +public ITexture[] getSidesActive(byte aColor) +/* 95: */ { +/* 96:51 */ return new ITexture[] { super.getSidesActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.NAQUADAH_REACTOR_SOLID_SIDE_ACTIVE) }; +/* 97: */ } +/* 98: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.generators.GT_MetaTileEntity_SolidNaquadahReactor + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_SteamTurbine.java b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_SteamTurbine.java new file mode 100644 index 0000000..45aaa61 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/generators/GT_MetaTileEntity_SteamTurbine.java @@ -0,0 +1,144 @@ +/* 1: */ package gregtech.common.tileentities.generators; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.ConfigCategories; +import gregtech.api.enums.Textures; +/* 4: */ import gregtech.api.interfaces.ITexture; +/* 5: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 6: */ import gregtech.api.metatileentity.MetaTileEntity; +/* 7: */ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicGenerator; +/* 8: */ import gregtech.api.objects.GT_RenderedTexture; +/* 9: */ import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_Recipe; +/* 11: */ import net.minecraftforge.fluids.FluidStack; +/* 12: */ +/* 13: */ public class GT_MetaTileEntity_SteamTurbine +/* 14: */ extends GT_MetaTileEntity_BasicGenerator +/* 15: */ { + + public int mEfficiency; +/* 16: */ @Override +public boolean isOutputFacing(byte aSide) +/* 17: */ { +/* 18:14 */ return aSide == getBaseMetaTileEntity().getFrontFacing(); +/* 19: */ } +/* 20: */ +/* 21: */ public GT_MetaTileEntity_SteamTurbine(int aID, String aName, String aNameRegional, int aTier) +/* 22: */ { +/* 23:17 */ super(aID, aName, aNameRegional, aTier, "Requires Steam to run", new ITexture[0]); +onConfigLoad(); +/* 24: */ } +/* 25: */ +/* 26: */ public GT_MetaTileEntity_SteamTurbine(String aName, int aTier, String aDescription, ITexture[][][] aTextures) +/* 27: */ { +/* 28:21 */ super(aName, aTier, aDescription, aTextures); +onConfigLoad(); +/* 29: */ } +/* 30: */ +/* 31: */ @Override +public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 32: */ { +/* 33:26 */ return new GT_MetaTileEntity_SteamTurbine(this.mName, this.mTier, this.mDescription, this.mTextures); +/* 34: */ } +/* 35: */ +/* 36: */ @Override +public GT_Recipe.GT_Recipe_Map getRecipes() +/* 37: */ { +/* 38:31 */ return null; +/* 39: */ } +/* 40: */ +/* 41: */ @Override +public int getCapacity() +/* 42: */ { +/* 43:36 */ return 24000 * this.mTier; +/* 44: */ } + +public void onConfigLoad() +/* 39: */ { + this.mEfficiency =GregTech_API.sMachineFile.get(ConfigCategories.machineconfig, "SteamTurbine.efficiency.tier."+this.mTier, (200 / consumedFluidPerOperation(GT_ModHandler.getSteam(1L)))); +} +/* 45: */ +/* 46: */ @Override +public int getEfficiency() +/* 47: */ { +/* 48:41 */ return this.mEfficiency; +/* 49: */ } +/* 50: */ +/* 51: */ @Override +public int getFuelValue(FluidStack aLiquid) +/* 52: */ { +/* 53:46 */ return GT_ModHandler.isSteam(aLiquid) ? 1 : 0; +/* 54: */ } +/* 55: */ +/* 56: */ @Override +public int consumedFluidPerOperation(FluidStack aLiquid) +/* 57: */ { +/* 58:51 */ return 2 + this.mTier; +/* 59: */ } +/* 60: */ +/* 61: */ @Override +public ITexture[] getFront(byte aColor) +/* 62: */ { +/* 63:54 */ return new ITexture[] { super.getFront(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.STEAM_TURBINE_FRONT), Textures.BlockIcons.OVERLAYS_ENERGY_OUT[this.mTier] }; +/* 64: */ } +/* 65: */ +/* 66: */ @Override +public ITexture[] getBack(byte aColor) +/* 67: */ { +/* 68:55 */ return new ITexture[] { super.getBack(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.STEAM_TURBINE_BACK) }; +/* 69: */ } +/* 70: */ +/* 71: */ @Override +public ITexture[] getBottom(byte aColor) +/* 72: */ { +/* 73:56 */ return new ITexture[] { super.getBottom(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.STEAM_TURBINE_BOTTOM) }; +/* 74: */ } +/* 75: */ +/* 76: */ @Override +public ITexture[] getTop(byte aColor) +/* 77: */ { +/* 78:57 */ return new ITexture[] { super.getTop(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.STEAM_TURBINE_TOP) }; +/* 79: */ } +/* 80: */ +/* 81: */ @Override +public ITexture[] getSides(byte aColor) +/* 82: */ { +/* 83:58 */ return new ITexture[] { super.getSides(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.STEAM_TURBINE_SIDE) }; +/* 84: */ } +/* 85: */ +/* 86: */ @Override +public ITexture[] getFrontActive(byte aColor) +/* 87: */ { +/* 88:59 */ return new ITexture[] { super.getFrontActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.STEAM_TURBINE_FRONT_ACTIVE), Textures.BlockIcons.OVERLAYS_ENERGY_OUT[this.mTier] }; +/* 89: */ } +/* 90: */ +/* 91: */ @Override +public ITexture[] getBackActive(byte aColor) +/* 92: */ { +/* 93:60 */ return new ITexture[] { super.getBackActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.STEAM_TURBINE_BACK_ACTIVE) }; +/* 94: */ } +/* 95: */ +/* 96: */ @Override +public ITexture[] getBottomActive(byte aColor) +/* 97: */ { +/* 98:61 */ return new ITexture[] { super.getBottomActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.STEAM_TURBINE_BOTTOM_ACTIVE) }; +/* 99: */ } +/* :0: */ +/* :1: */ @Override +public ITexture[] getTopActive(byte aColor) +/* :2: */ { +/* :3:62 */ return new ITexture[] { super.getTopActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.STEAM_TURBINE_TOP_ACTIVE) }; +/* :4: */ } +/* :5: */ +/* :6: */ @Override +public ITexture[] getSidesActive(byte aColor) +/* :7: */ { +/* :8:63 */ return new ITexture[] { super.getSidesActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.STEAM_TURBINE_SIDE_ACTIVE) }; +/* :9: */ } +/* ;0: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.generators.GT_MetaTileEntity_SteamTurbine + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/machines/GT_MetaTileEntity_BasicHull_Bronze.java b/src/main/java/gregtech/common/tileentities/machines/GT_MetaTileEntity_BasicHull_Bronze.java new file mode 100644 index 0000000..b8f74d6 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/GT_MetaTileEntity_BasicHull_Bronze.java @@ -0,0 +1,48 @@ +/* 1: */ package gregtech.common.tileentities.machines; +/* 2: */ +/* 3: */ import gregtech.api.enums.Dyes; +import gregtech.api.enums.Textures; +/* 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_BasicHull_NonElectric; +/* 9: */ import gregtech.api.objects.GT_RenderedTexture; +/* 10: */ +/* 11: */ public class GT_MetaTileEntity_BasicHull_Bronze +/* 12: */ extends GT_MetaTileEntity_BasicHull_NonElectric +/* 13: */ { +/* 14: */ public GT_MetaTileEntity_BasicHull_Bronze(int aID, String aName, String aNameRegional, int aTier, String aDescription) +/* 15: */ { +/* 16:13 */ super(aID, aName, aNameRegional, aTier, aDescription); +/* 17: */ } +/* 18: */ +/* 19: */ public GT_MetaTileEntity_BasicHull_Bronze(String aName, int aTier, String aDescription, ITexture[][][] aTextures) +/* 20: */ { +/* 21:17 */ super(aName, aTier, aDescription, aTextures); +/* 22: */ } +/* 23: */ +/* 24: */ @Override +public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 25: */ { +/* 26:22 */ return new GT_MetaTileEntity_BasicHull_Bronze(this.mName, this.mTier, this.mDescription, this.mTextures); +/* 27: */ } +/* 28: */ +/* 29: */ @Override +public ITexture[][][] getTextureSet(ITexture[] aTextures) +/* 30: */ { +/* 31:27 */ ITexture[][][] rTextures = new ITexture[3][17][]; +/* 32:28 */ for (byte i = -1; i < 16; i = (byte)(i + 1)) +/* 33: */ { +/* 34:29 */ rTextures[0][(i + 1)] = new ITexture[] { new GT_RenderedTexture(Textures.BlockIcons.MACHINE_BRONZE_BOTTOM, Dyes.getModulation(i, Dyes._NULL.mRGBa)) }; +/* 35:30 */ rTextures[1][(i + 1)] = new ITexture[] { new GT_RenderedTexture(Textures.BlockIcons.MACHINE_BRONZE_TOP, Dyes.getModulation(i, Dyes._NULL.mRGBa)) }; +/* 36:31 */ rTextures[2][(i + 1)] = new ITexture[] { new GT_RenderedTexture(Textures.BlockIcons.MACHINE_BRONZE_SIDE, Dyes.getModulation(i, Dyes._NULL.mRGBa)) }; +/* 37: */ } +/* 38:33 */ return rTextures; +/* 39: */ } +/* 40: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.machines.GT_MetaTileEntity_BasicHull_Bronze + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/machines/GT_MetaTileEntity_BasicHull_BronzeBricks.java b/src/main/java/gregtech/common/tileentities/machines/GT_MetaTileEntity_BasicHull_BronzeBricks.java new file mode 100644 index 0000000..a952594 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/GT_MetaTileEntity_BasicHull_BronzeBricks.java @@ -0,0 +1,51 @@ +/* 1: */ package gregtech.common.tileentities.machines; +/* 2: */ +/* 3: */ +import gregtech.api.enums.Dyes; +import gregtech.api.enums.Textures; +/* 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_BasicHull_NonElectric; +/* 9: */ import gregtech.api.objects.GT_RenderedTexture; +/* 10: */ +/* 11: */ public class GT_MetaTileEntity_BasicHull_BronzeBricks +/* 12: */ extends GT_MetaTileEntity_BasicHull_NonElectric +/* 13: */ { +/* 14: */ public GT_MetaTileEntity_BasicHull_BronzeBricks(int aID, String aName, String aNameRegional, int aTier, String aDescription) +/* 15: */ { +/* 16:13 */ super(aID, aName, aNameRegional, aTier, aDescription); +/* 17: */ } +/* 18: */ +/* 19: */ public GT_MetaTileEntity_BasicHull_BronzeBricks(String aName, int aTier, String aDescription, ITexture[][][] aTextures) +/* 20: */ { +/* 21:17 */ super(aName, aTier, aDescription, aTextures); +/* 22: */ } +/* 23: */ +/* 24: */ @Override +public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 25: */ { +/* 26:22 */ return new GT_MetaTileEntity_BasicHull_BronzeBricks(this.mName, this.mTier, this.mDescription, this.mTextures); +/* 27: */ } +/* 28: */ +/* 29: */ @Override +public ITexture[][][] getTextureSet(ITexture[] aTextures) +/* 30: */ { +/* 31:27 */ ITexture[][][] rTextures = new ITexture[3][17][]; +/* 32:28 */ for (byte i = -1; i < 16; i = (byte)(i + 1)) +/* 33: */ {ITexture[] tmp0 ={ new GT_RenderedTexture(Textures.BlockIcons.MACHINE_BRONZEBRICKS_BOTTOM, Dyes.getModulation(i, Dyes._NULL.mRGBa)) }; +/* 34:29 */ rTextures[0][(i + 1)] = tmp0; +/* 35:30 */ ITexture[] tmp1 = { new GT_RenderedTexture(Textures.BlockIcons.MACHINE_BRONZEBRICKS_TOP, Dyes.getModulation(i, Dyes._NULL.mRGBa)) }; +rTextures[1][(i + 1)] =tmp1; +/* 36:31 */ ITexture[] tmp2 ={ new GT_RenderedTexture(Textures.BlockIcons.MACHINE_BRONZEBRICKS_SIDE, Dyes.getModulation(i, Dyes._NULL.mRGBa)) }; +rTextures[2][(i + 1)] = tmp2; +/* 37: */ } +/* 38:33 */ return rTextures; +/* 39: */ } +/* 40: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.machines.GT_MetaTileEntity_BasicHull_BronzeBricks + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/machines/GT_MetaTileEntity_BasicHull_Steel.java b/src/main/java/gregtech/common/tileentities/machines/GT_MetaTileEntity_BasicHull_Steel.java new file mode 100644 index 0000000..f923ace --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/GT_MetaTileEntity_BasicHull_Steel.java @@ -0,0 +1,50 @@ +/* 1: */ package gregtech.common.tileentities.machines; +/* 2: */ +/* 3: */ import gregtech.api.enums.Dyes; +import gregtech.api.enums.Textures; +/* 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_BasicHull_NonElectric; +/* 9: */ import gregtech.api.objects.GT_RenderedTexture; +/* 10: */ +/* 11: */ public class GT_MetaTileEntity_BasicHull_Steel +/* 12: */ extends GT_MetaTileEntity_BasicHull_NonElectric +/* 13: */ { +/* 14: */ public GT_MetaTileEntity_BasicHull_Steel(int aID, String aName, String aNameRegional, int aTier, String aDescription) +/* 15: */ { +/* 16:13 */ super(aID, aName, aNameRegional, aTier, aDescription); +/* 17: */ } +/* 18: */ +/* 19: */ public GT_MetaTileEntity_BasicHull_Steel(String aName, int aTier, String aDescription, ITexture[][][] aTextures) +/* 20: */ { +/* 21:17 */ super(aName, aTier, aDescription, aTextures); +/* 22: */ } +/* 23: */ +/* 24: */ @Override +public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 25: */ { +/* 26:22 */ return new GT_MetaTileEntity_BasicHull_Steel(this.mName, this.mTier, this.mDescription, this.mTextures); +/* 27: */ } +/* 28: */ +/* 29: */ @Override +public ITexture[][][] getTextureSet(ITexture[] aTextures) +/* 30: */ { +/* 31:27 */ ITexture[][][] rTextures = new ITexture[3][17][]; +/* 32:28 */ for (byte i = -1; i < 16; i = (byte)(i + 1)) +/* 33: */ {ITexture[] tmp0 ={ new GT_RenderedTexture(Textures.BlockIcons.MACHINE_STEEL_BOTTOM, Dyes.getModulation(i, Dyes._NULL.mRGBa)) }; +/* 34:29 */ rTextures[0][(i + 1)] = tmp0; +/* 35:30 */ ITexture[] tmp1 ={ new GT_RenderedTexture(Textures.BlockIcons.MACHINE_STEEL_TOP, Dyes.getModulation(i, Dyes._NULL.mRGBa)) }; +rTextures[1][(i + 1)] = tmp1; +/* 36:31 */ ITexture[] tmp2 = { new GT_RenderedTexture(Textures.BlockIcons.MACHINE_STEEL_SIDE, Dyes.getModulation(i, Dyes._NULL.mRGBa)) }; +rTextures[2][(i + 1)] =tmp2; +/* 37: */ } +/* 38:33 */ return rTextures; +/* 39: */ } +/* 40: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.machines.GT_MetaTileEntity_BasicHull_Steel + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/machines/GT_MetaTileEntity_BasicHull_SteelBricks.java b/src/main/java/gregtech/common/tileentities/machines/GT_MetaTileEntity_BasicHull_SteelBricks.java new file mode 100644 index 0000000..a4cb828 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/GT_MetaTileEntity_BasicHull_SteelBricks.java @@ -0,0 +1,50 @@ +/* 1: */ package gregtech.common.tileentities.machines; +/* 2: */ +/* 3: */ import gregtech.api.enums.Dyes; +import gregtech.api.enums.Textures; +/* 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_BasicHull_NonElectric; +/* 9: */ import gregtech.api.objects.GT_RenderedTexture; +/* 10: */ +/* 11: */ public class GT_MetaTileEntity_BasicHull_SteelBricks +/* 12: */ extends GT_MetaTileEntity_BasicHull_NonElectric +/* 13: */ { +/* 14: */ public GT_MetaTileEntity_BasicHull_SteelBricks(int aID, String aName, String aNameRegional, int aTier, String aDescription) +/* 15: */ { +/* 16:13 */ super(aID, aName, aNameRegional, aTier, aDescription); +/* 17: */ } +/* 18: */ +/* 19: */ public GT_MetaTileEntity_BasicHull_SteelBricks(String aName, int aTier, String aDescription, ITexture[][][] aTextures) +/* 20: */ { +/* 21:17 */ super(aName, aTier, aDescription, aTextures); +/* 22: */ } +/* 23: */ +/* 24: */ @Override +public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 25: */ { +/* 26:22 */ return new GT_MetaTileEntity_BasicHull_SteelBricks(this.mName, this.mTier, this.mDescription, this.mTextures); +/* 27: */ } +/* 28: */ +/* 29: */ @Override +public ITexture[][][] getTextureSet(ITexture[] aTextures) +/* 30: */ { +/* 31:27 */ ITexture[][][] rTextures = new ITexture[3][17][]; +/* 32:28 */ for (byte i = -1; i < 16; i = (byte)(i + 1)) +/* 33: */ {ITexture[] tmp0 ={ new GT_RenderedTexture(Textures.BlockIcons.MACHINE_STEELBRICKS_BOTTOM, Dyes.getModulation(i, Dyes._NULL.mRGBa)) }; +/* 34:29 */ rTextures[0][(i + 1)] = tmp0; +/* 35:30 */ ITexture[] tmp1 ={ new GT_RenderedTexture(Textures.BlockIcons.MACHINE_STEELBRICKS_TOP, Dyes.getModulation(i, Dyes._NULL.mRGBa)) }; +rTextures[1][(i + 1)] = tmp1; +/* 36:31 */ ITexture[] tmp2 ={ new GT_RenderedTexture(Textures.BlockIcons.MACHINE_STEELBRICKS_SIDE, Dyes.getModulation(i, Dyes._NULL.mRGBa)) }; +rTextures[2][(i + 1)] = tmp2; +/* 37: */ } +/* 38:33 */ return rTextures; +/* 39: */ } +/* 40: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.machines.GT_MetaTileEntity_BasicHull_SteelBricks + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_AlloySmelter_Bronze.java b/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_AlloySmelter_Bronze.java new file mode 100644 index 0000000..8576411 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_AlloySmelter_Bronze.java @@ -0,0 +1,130 @@ +/* 1: */ package gregtech.common.tileentities.machines.steam; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.Textures; +/* 5: */ import gregtech.api.gui.GT_GUIContainer_BasicMachine; +/* 6: */ import gregtech.api.interfaces.ITexture; +/* 7: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 8: */ import gregtech.api.metatileentity.MetaTileEntity; +/* 9: */ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicMachine_Bronze; +/* 10: */ import gregtech.api.objects.GT_RenderedTexture; +/* 11: */ import gregtech.api.util.GT_Recipe; +/* 13: */ import gregtech.api.util.GT_Utility; +/* 15: */ import net.minecraft.entity.player.InventoryPlayer; +/* 16: */ +/* 17: */ public class GT_MetaTileEntity_AlloySmelter_Bronze +/* 18: */ extends GT_MetaTileEntity_BasicMachine_Bronze +/* 19: */ { +/* 20: */ public GT_MetaTileEntity_AlloySmelter_Bronze(int aID, String aName, String aNameRegional) +/* 21: */ { +/* 22: 19 */ super(aID, aName, aNameRegional, "Combination Smelter", 2, 1, true); +/* 23: */ } +/* 24: */ +/* 25: */ public GT_MetaTileEntity_AlloySmelter_Bronze(String aName, String aDescription, ITexture[][][] aTextures) +/* 26: */ { +/* 27: 23 */ super(aName, aDescription, aTextures, 2, 1, true); +/* 28: */ } +/* 29: */ +/* 30: */ @Override +public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 31: */ { +/* 32: 28 */ return new GT_MetaTileEntity_AlloySmelter_Bronze(this.mName, this.mDescription, this.mTextures); +/* 33: */ } +/* 34: */ +/* 35: */ @Override +public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 36: */ { +/* 37: 33 */ return new GT_GUIContainer_BasicMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "BronzeAlloySmelter.png", GT_Recipe.GT_Recipe_Map.sAlloySmelterRecipes.mUnlocalizedName); +/* 38: */ } +/* 39: */ +/* 40: */ @Override +public int checkRecipe() +/* 41: */ { +/* 42: 38 */ GT_Recipe tRecipe = GT_Recipe.GT_Recipe_Map.sAlloySmelterRecipes.findRecipe(getBaseMetaTileEntity(), false, gregtech.api.enums.GT_Values.V[1], null, getAllInputs()); +/* 43: 39 */ if ((tRecipe != null) && (canOutput(tRecipe.mOutputs)) && (tRecipe.isRecipeInputEqual(true, null, getAllInputs()))) +/* 44: */ { +/* 45: 40 */ this.mOutputItems[0] = tRecipe.getOutput(0); +/* 46: 41 */ if (tRecipe.mEUt <= 16) +/* 47: */ { +/* 48: 42 */ this.mEUt = tRecipe.mEUt; +/* 49: 43 */ this.mMaxProgresstime = (tRecipe.mDuration * 2); +/* 50: */ } +/* 51: */ else +/* 52: */ { +/* 53: 45 */ this.mEUt = tRecipe.mEUt; +/* 54: 46 */ this.mMaxProgresstime = (tRecipe.mDuration * 2); +/* 55: */ } +/* 56: 48 */ return 2; +/* 57: */ } +/* 58: 50 */ return 0; +/* 59: */ } +/* 60: */ +/* 61: */ @Override +public void startSoundLoop(byte aIndex, double aX, double aY, double aZ) +/* 62: */ { +/* 63: 55 */ super.startSoundLoop(aIndex, aX, aY, aZ); +/* 64: 56 */ if (aIndex == 1) { +/* 65: 56 */ GT_Utility.doSoundAtClient(GregTech_API.sSoundList.get(Integer.valueOf(208)), 10, 1.0F, aX, aY, aZ); +/* 66: */ } +/* 67: */ } +/* 68: */ +/* 69: */ @Override +public void startProcess() +/* 70: */ { +/* 71: 61 */ sendLoopStart((byte)1); +/* 72: */ } +/* 73: */ +/* 74: */ @Override +public ITexture[] getSideFacingActive(byte aColor) +/* 75: */ { +/* 76: 66 */ return new ITexture[] { super.getSideFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_STEAM_ALLOY_SMELTER_ACTIVE) }; +/* 77: */ } +/* 78: */ +/* 79: */ @Override +public ITexture[] getSideFacingInactive(byte aColor) +/* 80: */ { +/* 81: 71 */ return new ITexture[] { super.getSideFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_STEAM_ALLOY_SMELTER) }; +/* 82: */ } +/* 83: */ +/* 84: */ @Override +public ITexture[] getFrontFacingActive(byte aColor) +/* 85: */ { +/* 86: 76 */ return new ITexture[] { super.getFrontFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_ALLOY_SMELTER_ACTIVE) }; +/* 87: */ } +/* 88: */ +/* 89: */ @Override +public ITexture[] getFrontFacingInactive(byte aColor) +/* 90: */ { +/* 91: 81 */ return new ITexture[] { super.getFrontFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_ALLOY_SMELTER) }; +/* 92: */ } +/* 93: */ +/* 94: */ @Override +public ITexture[] getTopFacingActive(byte aColor) +/* 95: */ { +/* 96: 86 */ return new ITexture[] { super.getTopFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_STEAM_ALLOY_SMELTER_ACTIVE) }; +/* 97: */ } +/* 98: */ +/* 99: */ @Override +public ITexture[] getTopFacingInactive(byte aColor) +/* 100: */ { +/* 101: 91 */ return new ITexture[] { super.getTopFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_STEAM_ALLOY_SMELTER) }; +/* 102: */ } +/* 103: */ +/* 104: */ @Override +public ITexture[] getBottomFacingActive(byte aColor) +/* 105: */ { +/* 106: 96 */ return new ITexture[] { super.getBottomFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_STEAM_ALLOY_SMELTER_ACTIVE) }; +/* 107: */ } +/* 108: */ +/* 109: */ @Override +public ITexture[] getBottomFacingInactive(byte aColor) +/* 110: */ { +/* 111:101 */ return new ITexture[] { super.getBottomFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_STEAM_ALLOY_SMELTER) }; +/* 112: */ } +/* 113: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_AlloySmelter_Bronze + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_AlloySmelter_Steel.java b/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_AlloySmelter_Steel.java new file mode 100644 index 0000000..9d44c8b --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_AlloySmelter_Steel.java @@ -0,0 +1,130 @@ +/* 1: */ package gregtech.common.tileentities.machines.steam; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.Textures; +/* 5: */ import gregtech.api.gui.GT_GUIContainer_BasicMachine; +/* 6: */ import gregtech.api.interfaces.ITexture; +/* 7: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 8: */ import gregtech.api.metatileentity.MetaTileEntity; +/* 9: */ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicMachine_Steel; +/* 10: */ import gregtech.api.objects.GT_RenderedTexture; +/* 11: */ import gregtech.api.util.GT_Recipe; +/* 13: */ import gregtech.api.util.GT_Utility; +/* 15: */ import net.minecraft.entity.player.InventoryPlayer; +/* 16: */ +/* 17: */ public class GT_MetaTileEntity_AlloySmelter_Steel +/* 18: */ extends GT_MetaTileEntity_BasicMachine_Steel +/* 19: */ { +/* 20: */ public GT_MetaTileEntity_AlloySmelter_Steel(int aID, String aName, String aNameRegional) +/* 21: */ { +/* 22: 19 */ super(aID, aName, aNameRegional, "Combination Smelter", 2, 1, true); +/* 23: */ } +/* 24: */ +/* 25: */ public GT_MetaTileEntity_AlloySmelter_Steel(String aName, String aDescription, ITexture[][][] aTextures) +/* 26: */ { +/* 27: 23 */ super(aName, aDescription, aTextures, 2, 1, true); +/* 28: */ } +/* 29: */ +/* 30: */ @Override +public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 31: */ { +/* 32: 28 */ return new GT_MetaTileEntity_AlloySmelter_Steel(this.mName, this.mDescription, this.mTextures); +/* 33: */ } +/* 34: */ +/* 35: */ @Override +public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 36: */ { +/* 37: 33 */ return new GT_GUIContainer_BasicMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "SteelAlloySmelter.png", GT_Recipe.GT_Recipe_Map.sAlloySmelterRecipes.mUnlocalizedName); +/* 38: */ } +/* 39: */ +/* 40: */ @Override +public int checkRecipe() +/* 41: */ { +/* 42: 38 */ GT_Recipe tRecipe = GT_Recipe.GT_Recipe_Map.sAlloySmelterRecipes.findRecipe(getBaseMetaTileEntity(), false, gregtech.api.enums.GT_Values.V[2], null, getAllInputs()); +/* 43: 39 */ if ((tRecipe != null) && (canOutput(tRecipe.mOutputs)) && (tRecipe.isRecipeInputEqual(true, null, getAllInputs()))) +/* 44: */ { +/* 45: 40 */ this.mOutputItems[0] = tRecipe.getOutput(0); +/* 46: 41 */ if (tRecipe.mEUt <= 16) +/* 47: */ { +/* 48: 42 */ this.mEUt = (tRecipe.mEUt * 3); +/* 49: 43 */ this.mMaxProgresstime = tRecipe.mDuration; +/* 50: */ } +/* 51: */ else +/* 52: */ { +/* 53: 45 */ this.mEUt = (tRecipe.mEUt * 3); +/* 54: 46 */ this.mMaxProgresstime = tRecipe.mDuration; +/* 55: */ } +/* 56: 48 */ return 2; +/* 57: */ } +/* 58: 50 */ return 0; +/* 59: */ } +/* 60: */ +/* 61: */ @Override +public void startSoundLoop(byte aIndex, double aX, double aY, double aZ) +/* 62: */ { +/* 63: 55 */ super.startSoundLoop(aIndex, aX, aY, aZ); +/* 64: 56 */ if (aIndex == 1) { +/* 65: 56 */ GT_Utility.doSoundAtClient(GregTech_API.sSoundList.get(Integer.valueOf(208)), 10, 1.0F, aX, aY, aZ); +/* 66: */ } +/* 67: */ } +/* 68: */ +/* 69: */ @Override +public void startProcess() +/* 70: */ { +/* 71: 61 */ sendLoopStart((byte)1); +/* 72: */ } +/* 73: */ +/* 74: */ @Override +public ITexture[] getSideFacingActive(byte aColor) +/* 75: */ { +/* 76: 66 */ return new ITexture[] { super.getSideFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_STEAM_ALLOY_SMELTER_ACTIVE) }; +/* 77: */ } +/* 78: */ +/* 79: */ @Override +public ITexture[] getSideFacingInactive(byte aColor) +/* 80: */ { +/* 81: 71 */ return new ITexture[] { super.getSideFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_STEAM_ALLOY_SMELTER) }; +/* 82: */ } +/* 83: */ +/* 84: */ @Override +public ITexture[] getFrontFacingActive(byte aColor) +/* 85: */ { +/* 86: 76 */ return new ITexture[] { super.getFrontFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_ALLOY_SMELTER_ACTIVE) }; +/* 87: */ } +/* 88: */ +/* 89: */ @Override +public ITexture[] getFrontFacingInactive(byte aColor) +/* 90: */ { +/* 91: 81 */ return new ITexture[] { super.getFrontFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_ALLOY_SMELTER) }; +/* 92: */ } +/* 93: */ +/* 94: */ @Override +public ITexture[] getTopFacingActive(byte aColor) +/* 95: */ { +/* 96: 86 */ return new ITexture[] { super.getTopFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_STEAM_ALLOY_SMELTER_ACTIVE) }; +/* 97: */ } +/* 98: */ +/* 99: */ @Override +public ITexture[] getTopFacingInactive(byte aColor) +/* 100: */ { +/* 101: 91 */ return new ITexture[] { super.getTopFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_STEAM_ALLOY_SMELTER) }; +/* 102: */ } +/* 103: */ +/* 104: */ @Override +public ITexture[] getBottomFacingActive(byte aColor) +/* 105: */ { +/* 106: 96 */ return new ITexture[] { super.getBottomFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_STEAM_ALLOY_SMELTER_ACTIVE) }; +/* 107: */ } +/* 108: */ +/* 109: */ @Override +public ITexture[] getBottomFacingInactive(byte aColor) +/* 110: */ { +/* 111:101 */ return new ITexture[] { super.getBottomFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_STEAM_ALLOY_SMELTER) }; +/* 112: */ } +/* 113: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_AlloySmelter_Steel + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Compressor_Bronze.java b/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Compressor_Bronze.java new file mode 100644 index 0000000..a728fd9 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Compressor_Bronze.java @@ -0,0 +1,128 @@ +/* 1: */ package gregtech.common.tileentities.machines.steam; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.Textures; +/* 5: */ import gregtech.api.gui.GT_GUIContainer_BasicMachine; +/* 6: */ import gregtech.api.interfaces.ITexture; +/* 7: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 8: */ import gregtech.api.metatileentity.MetaTileEntity; +/* 9: */ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicMachine_Bronze; +/* 10: */ import gregtech.api.objects.GT_RenderedTexture; +/* 11: */ import gregtech.api.util.GT_ModHandler; +/* 12: */ import gregtech.api.util.GT_Utility; +/* 14: */ import net.minecraft.entity.player.InventoryPlayer; +/* 15: */ import net.minecraft.item.ItemStack; +/* 16: */ +/* 17: */ public class GT_MetaTileEntity_Compressor_Bronze +/* 18: */ extends GT_MetaTileEntity_BasicMachine_Bronze +/* 19: */ { +/* 20: */ public GT_MetaTileEntity_Compressor_Bronze(int aID, String aName, String aNameRegional) +/* 21: */ { +/* 22:18 */ super(aID, aName, aNameRegional, "Compressing Items", 1, 1, false); +/* 23: */ } +/* 24: */ +/* 25: */ public GT_MetaTileEntity_Compressor_Bronze(String aName, String aDescription, ITexture[][][] aTextures) +/* 26: */ { +/* 27:22 */ super(aName, aDescription, aTextures, 1, 1, false); +/* 28: */ } +/* 29: */ +/* 30: */ @Override +public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 31: */ { +/* 32:27 */ return new GT_GUIContainer_BasicMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "BronzeCompressor.png", "ic2.compressor"); +/* 33: */ } +/* 34: */ +/* 35: */ @Override +public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 36: */ { +/* 37:32 */ return new GT_MetaTileEntity_Compressor_Bronze(this.mName, this.mDescription, this.mTextures); +/* 38: */ } +/* 39: */ +/* 40: */ @Override +public int checkRecipe() +/* 41: */ { +/* 42:37 */ if (null != (this.mOutputItems[0] = GT_ModHandler.getCompressorOutput(getInputAt(0), true, getOutputAt(0)))) +/* 43: */ { +/* 44:38 */ this.mEUt = 2; +/* 45:39 */ this.mMaxProgresstime = 800; +/* 46:40 */ return 2; +/* 47: */ } +/* 48:42 */ return 0; +/* 49: */ } +/* 50: */ +/* 51: */ @Override +public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) +/* 52: */ { + if (!super.allowPutStack(aBaseMetaTileEntity, aIndex, aSide, aStack)) {return false;} +/* 54:47 */ return GT_ModHandler.getCompressorOutput(GT_Utility.copyAmount(64L, new Object[] { aStack }), false, null) != null; +/* 55: */ } +/* 56: */ +/* 57: */ @Override +public void startSoundLoop(byte aIndex, double aX, double aY, double aZ) +/* 58: */ { +/* 59:52 */ super.startSoundLoop(aIndex, aX, aY, aZ); +/* 60:53 */ if (aIndex == 1) { +/* 61:53 */ GT_Utility.doSoundAtClient(GregTech_API.sSoundList.get(Integer.valueOf(203)), 10, 1.0F, aX, aY, aZ); +/* 62: */ } +/* 63: */ } +/* 64: */ +/* 65: */ @Override +public void startProcess() +/* 66: */ { +/* 67:58 */ sendLoopStart((byte)1); +/* 68: */ } +/* 69: */ +/* 70: */ @Override +public ITexture[] getSideFacingActive(byte aColor) +/* 71: */ { +/* 72:63 */ return new ITexture[] { super.getSideFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_STEAM_COMPRESSOR_ACTIVE) }; +/* 73: */ } +/* 74: */ +/* 75: */ @Override +public ITexture[] getSideFacingInactive(byte aColor) +/* 76: */ { +/* 77:68 */ return new ITexture[] { super.getSideFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_STEAM_COMPRESSOR) }; +/* 78: */ } +/* 79: */ +/* 80: */ @Override +public ITexture[] getFrontFacingActive(byte aColor) +/* 81: */ { +/* 82:73 */ return new ITexture[] { super.getFrontFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_COMPRESSOR_ACTIVE) }; +/* 83: */ } +/* 84: */ +/* 85: */ @Override +public ITexture[] getFrontFacingInactive(byte aColor) +/* 86: */ { +/* 87:78 */ return new ITexture[] { super.getFrontFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_COMPRESSOR) }; +/* 88: */ } +/* 89: */ +/* 90: */ @Override +public ITexture[] getTopFacingActive(byte aColor) +/* 91: */ { +/* 92:83 */ return new ITexture[] { super.getTopFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_STEAM_COMPRESSOR_ACTIVE) }; +/* 93: */ } +/* 94: */ +/* 95: */ @Override +public ITexture[] getTopFacingInactive(byte aColor) +/* 96: */ { +/* 97:88 */ return new ITexture[] { super.getTopFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_STEAM_COMPRESSOR) }; +/* 98: */ } +/* 99: */ +/* :0: */ @Override +public ITexture[] getBottomFacingActive(byte aColor) +/* :1: */ { +/* :2:93 */ return new ITexture[] { super.getBottomFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_STEAM_COMPRESSOR_ACTIVE) }; +/* :3: */ } +/* :4: */ +/* :5: */ @Override +public ITexture[] getBottomFacingInactive(byte aColor) +/* :6: */ { +/* :7:98 */ return new ITexture[] { super.getBottomFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_STEAM_COMPRESSOR) }; +/* :8: */ } +/* :9: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_Compressor_Bronze + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Compressor_Steel.java b/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Compressor_Steel.java new file mode 100644 index 0000000..00cf439 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Compressor_Steel.java @@ -0,0 +1,128 @@ +/* 1: */ package gregtech.common.tileentities.machines.steam; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.Textures; +/* 5: */ import gregtech.api.gui.GT_GUIContainer_BasicMachine; +/* 6: */ import gregtech.api.interfaces.ITexture; +/* 7: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 8: */ import gregtech.api.metatileentity.MetaTileEntity; +/* 9: */ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicMachine_Steel; +/* 10: */ import gregtech.api.objects.GT_RenderedTexture; +/* 11: */ import gregtech.api.util.GT_ModHandler; +/* 12: */ import gregtech.api.util.GT_Utility; +/* 14: */ import net.minecraft.entity.player.InventoryPlayer; +/* 15: */ import net.minecraft.item.ItemStack; +/* 16: */ +/* 17: */ public class GT_MetaTileEntity_Compressor_Steel +/* 18: */ extends GT_MetaTileEntity_BasicMachine_Steel +/* 19: */ { +/* 20: */ public GT_MetaTileEntity_Compressor_Steel(int aID, String aName, String aNameRegional) +/* 21: */ { +/* 22:18 */ super(aID, aName, aNameRegional, "Compressing Items", 1, 1, false); +/* 23: */ } +/* 24: */ +/* 25: */ public GT_MetaTileEntity_Compressor_Steel(String aName, String aDescription, ITexture[][][] aTextures) +/* 26: */ { +/* 27:22 */ super(aName, aDescription, aTextures, 1, 1, false); +/* 28: */ } +/* 29: */ +/* 30: */ @Override +public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 31: */ { +/* 32:27 */ return new GT_GUIContainer_BasicMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "SteelCompressor.png", "ic2.compressor"); +/* 33: */ } +/* 34: */ +/* 35: */ @Override +public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 36: */ { +/* 37:32 */ return new GT_MetaTileEntity_Compressor_Steel(this.mName, this.mDescription, this.mTextures); +/* 38: */ } +/* 39: */ +/* 40: */ @Override +public int checkRecipe() +/* 41: */ { +/* 42:37 */ if (null != (this.mOutputItems[0] = GT_ModHandler.getCompressorOutput(getInputAt(0), true, getOutputAt(0)))) +/* 43: */ { +/* 44:38 */ this.mEUt = 6; +/* 45:39 */ this.mMaxProgresstime = 400; +/* 46:40 */ return 2; +/* 47: */ } +/* 48:42 */ return 0; +/* 49: */ } +/* 50: */ +/* 51: */ @Override +public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) +/* 52: */ { + if (!super.allowPutStack(aBaseMetaTileEntity, aIndex, aSide, aStack)) {return false;} +/* 54:47 */ return GT_ModHandler.getCompressorOutput(GT_Utility.copyAmount(64L, new Object[] { aStack }), false, null) != null; +/* 55: */ } +/* 56: */ +/* 57: */ @Override +public void startSoundLoop(byte aIndex, double aX, double aY, double aZ) +/* 58: */ { +/* 59:52 */ super.startSoundLoop(aIndex, aX, aY, aZ); +/* 60:53 */ if (aIndex == 1) { +/* 61:53 */ GT_Utility.doSoundAtClient(GregTech_API.sSoundList.get(Integer.valueOf(203)), 10, 1.0F, aX, aY, aZ); +/* 62: */ } +/* 63: */ } +/* 64: */ +/* 65: */ @Override +public void startProcess() +/* 66: */ { +/* 67:58 */ sendLoopStart((byte)1); +/* 68: */ } +/* 69: */ +/* 70: */ @Override +public ITexture[] getSideFacingActive(byte aColor) +/* 71: */ { +/* 72:63 */ return new ITexture[] { super.getSideFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_STEAM_COMPRESSOR_ACTIVE) }; +/* 73: */ } +/* 74: */ +/* 75: */ @Override +public ITexture[] getSideFacingInactive(byte aColor) +/* 76: */ { +/* 77:68 */ return new ITexture[] { super.getSideFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_STEAM_COMPRESSOR) }; +/* 78: */ } +/* 79: */ +/* 80: */ @Override +public ITexture[] getFrontFacingActive(byte aColor) +/* 81: */ { +/* 82:73 */ return new ITexture[] { super.getFrontFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_COMPRESSOR_ACTIVE) }; +/* 83: */ } +/* 84: */ +/* 85: */ @Override +public ITexture[] getFrontFacingInactive(byte aColor) +/* 86: */ { +/* 87:78 */ return new ITexture[] { super.getFrontFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_COMPRESSOR) }; +/* 88: */ } +/* 89: */ +/* 90: */ @Override +public ITexture[] getTopFacingActive(byte aColor) +/* 91: */ { +/* 92:83 */ return new ITexture[] { super.getTopFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_STEAM_COMPRESSOR_ACTIVE) }; +/* 93: */ } +/* 94: */ +/* 95: */ @Override +public ITexture[] getTopFacingInactive(byte aColor) +/* 96: */ { +/* 97:88 */ return new ITexture[] { super.getTopFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_STEAM_COMPRESSOR) }; +/* 98: */ } +/* 99: */ +/* :0: */ @Override +public ITexture[] getBottomFacingActive(byte aColor) +/* :1: */ { +/* :2:93 */ return new ITexture[] { super.getBottomFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_STEAM_COMPRESSOR_ACTIVE) }; +/* :3: */ } +/* :4: */ +/* :5: */ @Override +public ITexture[] getBottomFacingInactive(byte aColor) +/* :6: */ { +/* :7:98 */ return new ITexture[] { super.getBottomFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_STEAM_COMPRESSOR) }; +/* :8: */ } +/* :9: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_Compressor_Steel + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Extractor_Bronze.java b/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Extractor_Bronze.java new file mode 100644 index 0000000..e74a25f --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Extractor_Bronze.java @@ -0,0 +1,128 @@ +/* 1: */ package gregtech.common.tileentities.machines.steam; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.Textures; +/* 5: */ import gregtech.api.gui.GT_GUIContainer_BasicMachine; +/* 6: */ import gregtech.api.interfaces.ITexture; +/* 7: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 8: */ import gregtech.api.metatileentity.MetaTileEntity; +/* 9: */ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicMachine_Bronze; +/* 10: */ import gregtech.api.objects.GT_RenderedTexture; +/* 11: */ import gregtech.api.util.GT_ModHandler; +/* 12: */ import gregtech.api.util.GT_Utility; +/* 14: */ import net.minecraft.entity.player.InventoryPlayer; +/* 15: */ import net.minecraft.item.ItemStack; +/* 16: */ +/* 17: */ public class GT_MetaTileEntity_Extractor_Bronze +/* 18: */ extends GT_MetaTileEntity_BasicMachine_Bronze +/* 19: */ { +/* 20: */ public GT_MetaTileEntity_Extractor_Bronze(int aID, String aName, String aNameRegional) +/* 21: */ { +/* 22:18 */ super(aID, aName, aNameRegional, "Extracting your first Rubber", 1, 1, false); +/* 23: */ } +/* 24: */ +/* 25: */ public GT_MetaTileEntity_Extractor_Bronze(String aName, String aDescription, ITexture[][][] aTextures) +/* 26: */ { +/* 27:22 */ super(aName, aDescription, aTextures, 1, 1, false); +/* 28: */ } +/* 29: */ +/* 30: */ @Override +public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 31: */ { +/* 32:27 */ return new GT_GUIContainer_BasicMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "BronzeExtractor.png", "ic2.extractor"); +/* 33: */ } +/* 34: */ +/* 35: */ @Override +public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 36: */ { +/* 37:32 */ return new GT_MetaTileEntity_Extractor_Bronze(this.mName, this.mDescription, this.mTextures); +/* 38: */ } +/* 39: */ +/* 40: */ @Override +public int checkRecipe() +/* 41: */ { +/* 42:37 */ if (null != (this.mOutputItems[0] = GT_ModHandler.getExtractorOutput(getInputAt(0), true, getOutputAt(0)))) +/* 43: */ { +/* 44:38 */ this.mEUt = 2; +/* 45:39 */ this.mMaxProgresstime = 800; +/* 46:40 */ return 2; +/* 47: */ } +/* 48:42 */ return 0; +/* 49: */ } +/* 50: */ +/* 51: */ @Override +public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) +/* 52: */ { + if (!super.allowPutStack(aBaseMetaTileEntity, aIndex, aSide, aStack)) {return false;} +/* 54:47 */ return GT_ModHandler.getExtractorOutput(GT_Utility.copyAmount(64L, new Object[] { aStack }), false, null) != null; +/* 55: */ } +/* 56: */ +/* 57: */ @Override +public void startSoundLoop(byte aIndex, double aX, double aY, double aZ) +/* 58: */ { +/* 59:52 */ super.startSoundLoop(aIndex, aX, aY, aZ); +/* 60:53 */ if (aIndex == 1) { +/* 61:53 */ GT_Utility.doSoundAtClient(GregTech_API.sSoundList.get(Integer.valueOf(200)), 10, 1.0F, aX, aY, aZ); +/* 62: */ } +/* 63: */ } +/* 64: */ +/* 65: */ @Override +public void startProcess() +/* 66: */ { +/* 67:58 */ sendLoopStart((byte)1); +/* 68: */ } +/* 69: */ +/* 70: */ @Override +public ITexture[] getSideFacingActive(byte aColor) +/* 71: */ { +/* 72:63 */ return new ITexture[] { super.getSideFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_STEAM_EXTRACTOR_ACTIVE) }; +/* 73: */ } +/* 74: */ +/* 75: */ @Override +public ITexture[] getSideFacingInactive(byte aColor) +/* 76: */ { +/* 77:68 */ return new ITexture[] { super.getSideFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_STEAM_EXTRACTOR) }; +/* 78: */ } +/* 79: */ +/* 80: */ @Override +public ITexture[] getFrontFacingActive(byte aColor) +/* 81: */ { +/* 82:73 */ return new ITexture[] { super.getFrontFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_EXTRACTOR_ACTIVE) }; +/* 83: */ } +/* 84: */ +/* 85: */ @Override +public ITexture[] getFrontFacingInactive(byte aColor) +/* 86: */ { +/* 87:78 */ return new ITexture[] { super.getFrontFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_EXTRACTOR) }; +/* 88: */ } +/* 89: */ +/* 90: */ @Override +public ITexture[] getTopFacingActive(byte aColor) +/* 91: */ { +/* 92:83 */ return new ITexture[] { super.getTopFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_STEAM_EXTRACTOR_ACTIVE) }; +/* 93: */ } +/* 94: */ +/* 95: */ @Override +public ITexture[] getTopFacingInactive(byte aColor) +/* 96: */ { +/* 97:88 */ return new ITexture[] { super.getTopFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_STEAM_EXTRACTOR) }; +/* 98: */ } +/* 99: */ +/* :0: */ @Override +public ITexture[] getBottomFacingActive(byte aColor) +/* :1: */ { +/* :2:93 */ return new ITexture[] { super.getBottomFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_STEAM_EXTRACTOR_ACTIVE) }; +/* :3: */ } +/* :4: */ +/* :5: */ @Override +public ITexture[] getBottomFacingInactive(byte aColor) +/* :6: */ { +/* :7:98 */ return new ITexture[] { super.getBottomFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_STEAM_EXTRACTOR) }; +/* :8: */ } +/* :9: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_Extractor_Bronze + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Extractor_Steel.java b/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Extractor_Steel.java new file mode 100644 index 0000000..43272cf --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Extractor_Steel.java @@ -0,0 +1,128 @@ +/* 1: */ package gregtech.common.tileentities.machines.steam; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.Textures; +/* 5: */ import gregtech.api.gui.GT_GUIContainer_BasicMachine; +/* 6: */ import gregtech.api.interfaces.ITexture; +/* 7: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 8: */ import gregtech.api.metatileentity.MetaTileEntity; +/* 9: */ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicMachine_Steel; +/* 10: */ import gregtech.api.objects.GT_RenderedTexture; +/* 11: */ import gregtech.api.util.GT_ModHandler; +/* 12: */ import gregtech.api.util.GT_Utility; +/* 14: */ import net.minecraft.entity.player.InventoryPlayer; +/* 15: */ import net.minecraft.item.ItemStack; +/* 16: */ +/* 17: */ public class GT_MetaTileEntity_Extractor_Steel +/* 18: */ extends GT_MetaTileEntity_BasicMachine_Steel +/* 19: */ { +/* 20: */ public GT_MetaTileEntity_Extractor_Steel(int aID, String aName, String aNameRegional) +/* 21: */ { +/* 22:18 */ super(aID, aName, aNameRegional, "Extracting your first Rubber", 1, 1, false); +/* 23: */ } +/* 24: */ +/* 25: */ public GT_MetaTileEntity_Extractor_Steel(String aName, String aDescription, ITexture[][][] aTextures) +/* 26: */ { +/* 27:22 */ super(aName, aDescription, aTextures, 1, 1, false); +/* 28: */ } +/* 29: */ +/* 30: */ @Override +public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 31: */ { +/* 32:27 */ return new GT_GUIContainer_BasicMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "SteelExtractor.png", "ic2.extractor"); +/* 33: */ } +/* 34: */ +/* 35: */ @Override +public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 36: */ { +/* 37:32 */ return new GT_MetaTileEntity_Extractor_Steel(this.mName, this.mDescription, this.mTextures); +/* 38: */ } +/* 39: */ +/* 40: */ @Override +public int checkRecipe() +/* 41: */ { +/* 42:37 */ if (null != (this.mOutputItems[0] = GT_ModHandler.getExtractorOutput(getInputAt(0), true, getOutputAt(0)))) +/* 43: */ { +/* 44:38 */ this.mEUt = 6; +/* 45:39 */ this.mMaxProgresstime = 400; +/* 46:40 */ return 2; +/* 47: */ } +/* 48:42 */ return 0; +/* 49: */ } +/* 50: */ +/* 51: */ @Override +public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) +/* 52: */ { + if (!super.allowPutStack(aBaseMetaTileEntity, aIndex, aSide, aStack)) {return false;} +/* 54:47 */ return GT_ModHandler.getExtractorOutput(GT_Utility.copyAmount(64L, new Object[] { aStack }), false, null) != null; +/* 55: */ } +/* 56: */ +/* 57: */ @Override +public void startSoundLoop(byte aIndex, double aX, double aY, double aZ) +/* 58: */ { +/* 59:52 */ super.startSoundLoop(aIndex, aX, aY, aZ); +/* 60:53 */ if (aIndex == 1) { +/* 61:53 */ GT_Utility.doSoundAtClient(GregTech_API.sSoundList.get(Integer.valueOf(200)), 10, 1.0F, aX, aY, aZ); +/* 62: */ } +/* 63: */ } +/* 64: */ +/* 65: */ @Override +public void startProcess() +/* 66: */ { +/* 67:58 */ sendLoopStart((byte)1); +/* 68: */ } +/* 69: */ +/* 70: */ @Override +public ITexture[] getSideFacingActive(byte aColor) +/* 71: */ { +/* 72:63 */ return new ITexture[] { super.getSideFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_STEAM_EXTRACTOR_ACTIVE) }; +/* 73: */ } +/* 74: */ +/* 75: */ @Override +public ITexture[] getSideFacingInactive(byte aColor) +/* 76: */ { +/* 77:68 */ return new ITexture[] { super.getSideFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_STEAM_EXTRACTOR) }; +/* 78: */ } +/* 79: */ +/* 80: */ @Override +public ITexture[] getFrontFacingActive(byte aColor) +/* 81: */ { +/* 82:73 */ return new ITexture[] { super.getFrontFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_EXTRACTOR_ACTIVE) }; +/* 83: */ } +/* 84: */ +/* 85: */ @Override +public ITexture[] getFrontFacingInactive(byte aColor) +/* 86: */ { +/* 87:78 */ return new ITexture[] { super.getFrontFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_EXTRACTOR) }; +/* 88: */ } +/* 89: */ +/* 90: */ @Override +public ITexture[] getTopFacingActive(byte aColor) +/* 91: */ { +/* 92:83 */ return new ITexture[] { super.getTopFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_STEAM_EXTRACTOR_ACTIVE) }; +/* 93: */ } +/* 94: */ +/* 95: */ @Override +public ITexture[] getTopFacingInactive(byte aColor) +/* 96: */ { +/* 97:88 */ return new ITexture[] { super.getTopFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_STEAM_EXTRACTOR) }; +/* 98: */ } +/* 99: */ +/* :0: */ @Override +public ITexture[] getBottomFacingActive(byte aColor) +/* :1: */ { +/* :2:93 */ return new ITexture[] { super.getBottomFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_STEAM_EXTRACTOR_ACTIVE) }; +/* :3: */ } +/* :4: */ +/* :5: */ @Override +public ITexture[] getBottomFacingInactive(byte aColor) +/* :6: */ { +/* :7:98 */ return new ITexture[] { super.getBottomFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_STEAM_EXTRACTOR) }; +/* :8: */ } +/* :9: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_Extractor_Steel + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_ForgeHammer_Bronze.java b/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_ForgeHammer_Bronze.java new file mode 100644 index 0000000..58eba4c --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_ForgeHammer_Bronze.java @@ -0,0 +1,130 @@ +/* 1: */ package gregtech.common.tileentities.machines.steam; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.Textures; +/* 5: */ import gregtech.api.gui.GT_GUIContainer_BasicMachine; +/* 6: */ import gregtech.api.interfaces.ITexture; +/* 7: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 8: */ import gregtech.api.metatileentity.MetaTileEntity; +/* 9: */ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicMachine_Bronze; +/* 10: */ import gregtech.api.objects.GT_RenderedTexture; +/* 11: */ import gregtech.api.util.GT_Recipe; +/* 13: */ import gregtech.api.util.GT_Utility; +/* 15: */ import net.minecraft.entity.player.InventoryPlayer; +/* 16: */ +/* 17: */ public class GT_MetaTileEntity_ForgeHammer_Bronze +/* 18: */ extends GT_MetaTileEntity_BasicMachine_Bronze +/* 19: */ { +/* 20: */ public GT_MetaTileEntity_ForgeHammer_Bronze(int aID, String aName, String aNameRegional) +/* 21: */ { +/* 22: 19 */ super(aID, aName, aNameRegional, "Forge Hammer", 1, 1, false); +/* 23: */ } +/* 24: */ +/* 25: */ public GT_MetaTileEntity_ForgeHammer_Bronze(String aName, String aDescription, ITexture[][][] aTextures) +/* 26: */ { +/* 27: 23 */ super(aName, aDescription, aTextures, 1, 1, false); +/* 28: */ } +/* 29: */ +/* 30: */ @Override +public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 31: */ { +/* 32: 28 */ return new GT_MetaTileEntity_ForgeHammer_Bronze(this.mName, this.mDescription, this.mTextures); +/* 33: */ } +/* 34: */ +/* 35: */ @Override +public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 36: */ { +/* 37: 33 */ return new GT_GUIContainer_BasicMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "BronzeHammer.png", GT_Recipe.GT_Recipe_Map.sHammerRecipes.mUnlocalizedName, (byte)6, (byte)3); +/* 38: */ } +/* 39: */ +/* 40: */ @Override +public int checkRecipe() +/* 41: */ { +/* 42: 38 */ GT_Recipe tRecipe = GT_Recipe.GT_Recipe_Map.sHammerRecipes.findRecipe(getBaseMetaTileEntity(), false, gregtech.api.enums.GT_Values.V[1], null, getAllInputs()); +/* 43: 39 */ if ((tRecipe != null) && (canOutput(tRecipe.mOutputs)) && (tRecipe.isRecipeInputEqual(true, null, getAllInputs()))) +/* 44: */ { +/* 45: 40 */ this.mOutputItems[0] = tRecipe.getOutput(0); +/* 46: 41 */ if (tRecipe.mEUt <= 16) +/* 47: */ { +/* 48: 42 */ this.mEUt = tRecipe.mEUt; +/* 49: 43 */ this.mMaxProgresstime = (tRecipe.mDuration * 2); +/* 50: */ } +/* 51: */ else +/* 52: */ { +/* 53: 45 */ this.mEUt = tRecipe.mEUt; +/* 54: 46 */ this.mMaxProgresstime = (tRecipe.mDuration * 2); +/* 55: */ } +/* 56: 48 */ return 2; +/* 57: */ } +/* 58: 50 */ return 0; +/* 59: */ } +/* 60: */ +/* 61: */ @Override +public void startSoundLoop(byte aIndex, double aX, double aY, double aZ) +/* 62: */ { +/* 63: 55 */ super.startSoundLoop(aIndex, aX, aY, aZ); +/* 64: 56 */ if (aIndex == 1) { +/* 65: 56 */ GT_Utility.doSoundAtClient(GregTech_API.sSoundList.get(Integer.valueOf(1)), 10, 1.0F, aX, aY, aZ); +/* 66: */ } +/* 67: */ } +/* 68: */ +/* 69: */ @Override +public void startProcess() +/* 70: */ { +/* 71: 61 */ sendLoopStart((byte)1); +/* 72: */ } +/* 73: */ +/* 74: */ @Override +public ITexture[] getSideFacingActive(byte aColor) +/* 75: */ { +/* 76: 66 */ return new ITexture[] { super.getSideFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_STEAM_HAMMER_ACTIVE) }; +/* 77: */ } +/* 78: */ +/* 79: */ @Override +public ITexture[] getSideFacingInactive(byte aColor) +/* 80: */ { +/* 81: 71 */ return new ITexture[] { super.getSideFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_STEAM_HAMMER) }; +/* 82: */ } +/* 83: */ +/* 84: */ @Override +public ITexture[] getFrontFacingActive(byte aColor) +/* 85: */ { +/* 86: 76 */ return new ITexture[] { super.getFrontFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_HAMMER_ACTIVE) }; +/* 87: */ } +/* 88: */ +/* 89: */ @Override +public ITexture[] getFrontFacingInactive(byte aColor) +/* 90: */ { +/* 91: 81 */ return new ITexture[] { super.getFrontFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_HAMMER) }; +/* 92: */ } +/* 93: */ +/* 94: */ @Override +public ITexture[] getTopFacingActive(byte aColor) +/* 95: */ { +/* 96: 86 */ return new ITexture[] { super.getTopFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_STEAM_HAMMER_ACTIVE) }; +/* 97: */ } +/* 98: */ +/* 99: */ @Override +public ITexture[] getTopFacingInactive(byte aColor) +/* 100: */ { +/* 101: 91 */ return new ITexture[] { super.getTopFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_STEAM_HAMMER) }; +/* 102: */ } +/* 103: */ +/* 104: */ @Override +public ITexture[] getBottomFacingActive(byte aColor) +/* 105: */ { +/* 106: 96 */ return new ITexture[] { super.getBottomFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_STEAM_HAMMER_ACTIVE) }; +/* 107: */ } +/* 108: */ +/* 109: */ @Override +public ITexture[] getBottomFacingInactive(byte aColor) +/* 110: */ { +/* 111:101 */ return new ITexture[] { super.getBottomFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_STEAM_HAMMER) }; +/* 112: */ } +/* 113: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_ForgeHammer_Bronze + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_ForgeHammer_Steel.java b/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_ForgeHammer_Steel.java new file mode 100644 index 0000000..8bd9ed7 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_ForgeHammer_Steel.java @@ -0,0 +1,130 @@ +/* 1: */ package gregtech.common.tileentities.machines.steam; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.Textures; +/* 5: */ import gregtech.api.gui.GT_GUIContainer_BasicMachine; +/* 6: */ import gregtech.api.interfaces.ITexture; +/* 7: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 8: */ import gregtech.api.metatileentity.MetaTileEntity; +/* 9: */ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicMachine_Steel; +/* 10: */ import gregtech.api.objects.GT_RenderedTexture; +/* 11: */ import gregtech.api.util.GT_Recipe; +/* 13: */ import gregtech.api.util.GT_Utility; +/* 15: */ import net.minecraft.entity.player.InventoryPlayer; +/* 16: */ +/* 17: */ public class GT_MetaTileEntity_ForgeHammer_Steel +/* 18: */ extends GT_MetaTileEntity_BasicMachine_Steel +/* 19: */ { +/* 20: */ public GT_MetaTileEntity_ForgeHammer_Steel(int aID, String aName, String aNameRegional) +/* 21: */ { +/* 22: 19 */ super(aID, aName, aNameRegional, "Forge Hammer", 1, 1, false); +/* 23: */ } +/* 24: */ +/* 25: */ public GT_MetaTileEntity_ForgeHammer_Steel(String aName, String aDescription, ITexture[][][] aTextures) +/* 26: */ { +/* 27: 23 */ super(aName, aDescription, aTextures, 1, 1, false); +/* 28: */ } +/* 29: */ +/* 30: */ @Override +public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 31: */ { +/* 32: 28 */ return new GT_MetaTileEntity_ForgeHammer_Steel(this.mName, this.mDescription, this.mTextures); +/* 33: */ } +/* 34: */ +/* 35: */ @Override +public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 36: */ { +/* 37: 33 */ return new GT_GUIContainer_BasicMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "SteelHammer.png", GT_Recipe.GT_Recipe_Map.sHammerRecipes.mUnlocalizedName, (byte)6, (byte)3); +/* 38: */ } +/* 39: */ +/* 40: */ @Override +public int checkRecipe() +/* 41: */ { +/* 42: 38 */ GT_Recipe tRecipe = GT_Recipe.GT_Recipe_Map.sHammerRecipes.findRecipe(getBaseMetaTileEntity(), false, gregtech.api.enums.GT_Values.V[2], null, getAllInputs()); +/* 43: 39 */ if ((tRecipe != null) && (canOutput(tRecipe.mOutputs)) && (tRecipe.isRecipeInputEqual(true, null, getAllInputs()))) +/* 44: */ { +/* 45: 40 */ this.mOutputItems[0] = tRecipe.getOutput(0); +/* 46: 41 */ if (tRecipe.mEUt <= 16) +/* 47: */ { +/* 48: 42 */ this.mEUt = (tRecipe.mEUt * 3); +/* 49: 43 */ this.mMaxProgresstime = tRecipe.mDuration; +/* 50: */ } +/* 51: */ else +/* 52: */ { +/* 53: 45 */ this.mEUt = (tRecipe.mEUt * 3); +/* 54: 46 */ this.mMaxProgresstime = tRecipe.mDuration; +/* 55: */ } +/* 56: 48 */ return 2; +/* 57: */ } +/* 58: 50 */ return 0; +/* 59: */ } +/* 60: */ +/* 61: */ @Override +public void startSoundLoop(byte aIndex, double aX, double aY, double aZ) +/* 62: */ { +/* 63: 55 */ super.startSoundLoop(aIndex, aX, aY, aZ); +/* 64: 56 */ if (aIndex == 1) { +/* 65: 56 */ GT_Utility.doSoundAtClient(GregTech_API.sSoundList.get(Integer.valueOf(1)), 10, 1.0F, aX, aY, aZ); +/* 66: */ } +/* 67: */ } +/* 68: */ +/* 69: */ @Override +public void startProcess() +/* 70: */ { +/* 71: 61 */ sendLoopStart((byte)1); +/* 72: */ } +/* 73: */ +/* 74: */ @Override +public ITexture[] getSideFacingActive(byte aColor) +/* 75: */ { +/* 76: 66 */ return new ITexture[] { super.getSideFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_STEAM_HAMMER_ACTIVE) }; +/* 77: */ } +/* 78: */ +/* 79: */ @Override +public ITexture[] getSideFacingInactive(byte aColor) +/* 80: */ { +/* 81: 71 */ return new ITexture[] { super.getSideFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_STEAM_HAMMER) }; +/* 82: */ } +/* 83: */ +/* 84: */ @Override +public ITexture[] getFrontFacingActive(byte aColor) +/* 85: */ { +/* 86: 76 */ return new ITexture[] { super.getFrontFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_HAMMER_ACTIVE) }; +/* 87: */ } +/* 88: */ +/* 89: */ @Override +public ITexture[] getFrontFacingInactive(byte aColor) +/* 90: */ { +/* 91: 81 */ return new ITexture[] { super.getFrontFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_HAMMER) }; +/* 92: */ } +/* 93: */ +/* 94: */ @Override +public ITexture[] getTopFacingActive(byte aColor) +/* 95: */ { +/* 96: 86 */ return new ITexture[] { super.getTopFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_STEAM_HAMMER_ACTIVE) }; +/* 97: */ } +/* 98: */ +/* 99: */ @Override +public ITexture[] getTopFacingInactive(byte aColor) +/* 100: */ { +/* 101: 91 */ return new ITexture[] { super.getTopFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_STEAM_HAMMER) }; +/* 102: */ } +/* 103: */ +/* 104: */ @Override +public ITexture[] getBottomFacingActive(byte aColor) +/* 105: */ { +/* 106: 96 */ return new ITexture[] { super.getBottomFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_STEAM_HAMMER_ACTIVE) }; +/* 107: */ } +/* 108: */ +/* 109: */ @Override +public ITexture[] getBottomFacingInactive(byte aColor) +/* 110: */ { +/* 111:101 */ return new ITexture[] { super.getBottomFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_STEAM_HAMMER) }; +/* 112: */ } +/* 113: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_ForgeHammer_Steel + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Furnace_Bronze.java b/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Furnace_Bronze.java new file mode 100644 index 0000000..d961830 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Furnace_Bronze.java @@ -0,0 +1,128 @@ +/* 1: */ package gregtech.common.tileentities.machines.steam; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.Textures; +/* 5: */ import gregtech.api.gui.GT_GUIContainer_BasicMachine; +/* 6: */ import gregtech.api.interfaces.ITexture; +/* 7: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 8: */ import gregtech.api.metatileentity.MetaTileEntity; +/* 9: */ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicMachine_Bronze; +/* 10: */ import gregtech.api.objects.GT_RenderedTexture; +/* 11: */ import gregtech.api.util.GT_ModHandler; +/* 12: */ import gregtech.api.util.GT_Utility; +/* 14: */ import net.minecraft.entity.player.InventoryPlayer; +/* 15: */ import net.minecraft.item.ItemStack; +/* 16: */ +/* 17: */ public class GT_MetaTileEntity_Furnace_Bronze +/* 18: */ extends GT_MetaTileEntity_BasicMachine_Bronze +/* 19: */ { +/* 20: */ public GT_MetaTileEntity_Furnace_Bronze(int aID, String aName, String aNameRegional) +/* 21: */ { +/* 22:18 */ super(aID, aName, aNameRegional, "Smelting things with compressed Steam", 1, 1, true); +/* 23: */ } +/* 24: */ +/* 25: */ public GT_MetaTileEntity_Furnace_Bronze(String aName, String aDescription, ITexture[][][] aTextures) +/* 26: */ { +/* 27:22 */ super(aName, aDescription, aTextures, 1, 1, true); +/* 28: */ } +/* 29: */ +/* 30: */ @Override +public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 31: */ { +/* 32:27 */ return new GT_GUIContainer_BasicMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "BronzeFurnace.png", "smelting"); +/* 33: */ } +/* 34: */ +/* 35: */ @Override +public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 36: */ { +/* 37:32 */ return new GT_MetaTileEntity_Furnace_Bronze(this.mName, this.mDescription, this.mTextures); +/* 38: */ } +/* 39: */ +/* 40: */ @Override +public int checkRecipe() +/* 41: */ { +/* 42:37 */ if (null != (this.mOutputItems[0] = GT_ModHandler.getSmeltingOutput(getInputAt(0), true, getOutputAt(0)))) +/* 43: */ { +/* 44:38 */ this.mEUt = 4; +/* 45:39 */ this.mMaxProgresstime = 256; +/* 46:40 */ return 2; +/* 47: */ } +/* 48:42 */ return 0; +/* 49: */ } +/* 50: */ +/* 51: */ @Override +public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) +/* 52: */ { + if (!super.allowPutStack(aBaseMetaTileEntity, aIndex, aSide, aStack)) {return false;} +/* 54:47 */ return GT_ModHandler.getSmeltingOutput(GT_Utility.copyAmount(64L, new Object[] { aStack }), false, null) != null; +/* 55: */ } +/* 56: */ +/* 57: */ @Override +public void startSoundLoop(byte aIndex, double aX, double aY, double aZ) +/* 58: */ { +/* 59:52 */ super.startSoundLoop(aIndex, aX, aY, aZ); +/* 60:53 */ if (aIndex == 1) { +/* 61:53 */ GT_Utility.doSoundAtClient(GregTech_API.sSoundList.get(Integer.valueOf(207)), 10, 1.0F, aX, aY, aZ); +/* 62: */ } +/* 63: */ } +/* 64: */ +/* 65: */ @Override +public void startProcess() +/* 66: */ { +/* 67:58 */ sendLoopStart((byte)1); +/* 68: */ } +/* 69: */ +/* 70: */ @Override +public ITexture[] getSideFacingActive(byte aColor) +/* 71: */ { +/* 72:63 */ return new ITexture[] { super.getSideFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_STEAM_FURNACE_ACTIVE) }; +/* 73: */ } +/* 74: */ +/* 75: */ @Override +public ITexture[] getSideFacingInactive(byte aColor) +/* 76: */ { +/* 77:68 */ return new ITexture[] { super.getSideFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_STEAM_FURNACE) }; +/* 78: */ } +/* 79: */ +/* 80: */ @Override +public ITexture[] getFrontFacingActive(byte aColor) +/* 81: */ { +/* 82:73 */ return new ITexture[] { super.getFrontFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_FURNACE_ACTIVE) }; +/* 83: */ } +/* 84: */ +/* 85: */ @Override +public ITexture[] getFrontFacingInactive(byte aColor) +/* 86: */ { +/* 87:78 */ return new ITexture[] { super.getFrontFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_FURNACE) }; +/* 88: */ } +/* 89: */ +/* 90: */ @Override +public ITexture[] getTopFacingActive(byte aColor) +/* 91: */ { +/* 92:83 */ return new ITexture[] { super.getTopFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_STEAM_FURNACE_ACTIVE) }; +/* 93: */ } +/* 94: */ +/* 95: */ @Override +public ITexture[] getTopFacingInactive(byte aColor) +/* 96: */ { +/* 97:88 */ return new ITexture[] { super.getTopFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_STEAM_FURNACE) }; +/* 98: */ } +/* 99: */ +/* :0: */ @Override +public ITexture[] getBottomFacingActive(byte aColor) +/* :1: */ { +/* :2:93 */ return new ITexture[] { super.getBottomFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_STEAM_FURNACE_ACTIVE) }; +/* :3: */ } +/* :4: */ +/* :5: */ @Override +public ITexture[] getBottomFacingInactive(byte aColor) +/* :6: */ { +/* :7:98 */ return new ITexture[] { super.getBottomFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_STEAM_FURNACE) }; +/* :8: */ } +/* :9: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_Furnace_Bronze + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Furnace_Steel.java b/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Furnace_Steel.java new file mode 100644 index 0000000..c286c19 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Furnace_Steel.java @@ -0,0 +1,128 @@ +/* 1: */ package gregtech.common.tileentities.machines.steam; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.Textures; +/* 5: */ import gregtech.api.gui.GT_GUIContainer_BasicMachine; +/* 6: */ import gregtech.api.interfaces.ITexture; +/* 7: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 8: */ import gregtech.api.metatileentity.MetaTileEntity; +/* 9: */ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicMachine_Steel; +/* 10: */ import gregtech.api.objects.GT_RenderedTexture; +/* 11: */ import gregtech.api.util.GT_ModHandler; +/* 12: */ import gregtech.api.util.GT_Utility; +/* 14: */ import net.minecraft.entity.player.InventoryPlayer; +/* 15: */ import net.minecraft.item.ItemStack; +/* 16: */ +/* 17: */ public class GT_MetaTileEntity_Furnace_Steel +/* 18: */ extends GT_MetaTileEntity_BasicMachine_Steel +/* 19: */ { +/* 20: */ public GT_MetaTileEntity_Furnace_Steel(int aID, String aName, String aNameRegional) +/* 21: */ { +/* 22:18 */ super(aID, aName, aNameRegional, "Smelting things with compressed Steam", 1, 1, true); +/* 23: */ } +/* 24: */ +/* 25: */ public GT_MetaTileEntity_Furnace_Steel(String aName, String aDescription, ITexture[][][] aTextures) +/* 26: */ { +/* 27:22 */ super(aName, aDescription, aTextures, 1, 1, true); +/* 28: */ } +/* 29: */ +/* 30: */ @Override +public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 31: */ { +/* 32:27 */ return new GT_GUIContainer_BasicMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "SteelFurnace.png", "smelting"); +/* 33: */ } +/* 34: */ +/* 35: */ @Override +public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 36: */ { +/* 37:32 */ return new GT_MetaTileEntity_Furnace_Steel(this.mName, this.mDescription, this.mTextures); +/* 38: */ } +/* 39: */ +/* 40: */ @Override +public int checkRecipe() +/* 41: */ { +/* 42:37 */ if (null != (this.mOutputItems[0] = GT_ModHandler.getSmeltingOutput(getInputAt(0), true, getOutputAt(0)))) +/* 43: */ { +/* 44:38 */ this.mEUt = 12; +/* 45:39 */ this.mMaxProgresstime = 128; +/* 46:40 */ return 2; +/* 47: */ } +/* 48:42 */ return 0; +/* 49: */ } +/* 50: */ +/* 51: */ @Override +public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) +/* 52: */ { + if (!super.allowPutStack(aBaseMetaTileEntity, aIndex, aSide, aStack)) {return false;} +/* 54:47 */ return GT_ModHandler.getSmeltingOutput(GT_Utility.copyAmount(64L, new Object[] { aStack }), false, null) != null; +/* 55: */ } +/* 56: */ +/* 57: */ @Override +public void startSoundLoop(byte aIndex, double aX, double aY, double aZ) +/* 58: */ { +/* 59:52 */ super.startSoundLoop(aIndex, aX, aY, aZ); +/* 60:53 */ if (aIndex == 1) { +/* 61:53 */ GT_Utility.doSoundAtClient(GregTech_API.sSoundList.get(Integer.valueOf(207)), 10, 1.0F, aX, aY, aZ); +/* 62: */ } +/* 63: */ } +/* 64: */ +/* 65: */ @Override +public void startProcess() +/* 66: */ { +/* 67:58 */ sendLoopStart((byte)1); +/* 68: */ } +/* 69: */ +/* 70: */ @Override +public ITexture[] getSideFacingActive(byte aColor) +/* 71: */ { +/* 72:63 */ return new ITexture[] { super.getSideFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_STEAM_FURNACE_ACTIVE) }; +/* 73: */ } +/* 74: */ +/* 75: */ @Override +public ITexture[] getSideFacingInactive(byte aColor) +/* 76: */ { +/* 77:68 */ return new ITexture[] { super.getSideFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_STEAM_FURNACE) }; +/* 78: */ } +/* 79: */ +/* 80: */ @Override +public ITexture[] getFrontFacingActive(byte aColor) +/* 81: */ { +/* 82:73 */ return new ITexture[] { super.getFrontFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_FURNACE_ACTIVE) }; +/* 83: */ } +/* 84: */ +/* 85: */ @Override +public ITexture[] getFrontFacingInactive(byte aColor) +/* 86: */ { +/* 87:78 */ return new ITexture[] { super.getFrontFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_FURNACE) }; +/* 88: */ } +/* 89: */ +/* 90: */ @Override +public ITexture[] getTopFacingActive(byte aColor) +/* 91: */ { +/* 92:83 */ return new ITexture[] { super.getTopFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_STEAM_FURNACE_ACTIVE) }; +/* 93: */ } +/* 94: */ +/* 95: */ @Override +public ITexture[] getTopFacingInactive(byte aColor) +/* 96: */ { +/* 97:88 */ return new ITexture[] { super.getTopFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_STEAM_FURNACE) }; +/* 98: */ } +/* 99: */ +/* :0: */ @Override +public ITexture[] getBottomFacingActive(byte aColor) +/* :1: */ { +/* :2:93 */ return new ITexture[] { super.getBottomFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_STEAM_FURNACE_ACTIVE) }; +/* :3: */ } +/* :4: */ +/* :5: */ @Override +public ITexture[] getBottomFacingInactive(byte aColor) +/* :6: */ { +/* :7:98 */ return new ITexture[] { super.getBottomFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_STEAM_FURNACE) }; +/* :8: */ } +/* :9: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_Furnace_Steel + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Macerator_Bronze.java b/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Macerator_Bronze.java new file mode 100644 index 0000000..d2e7772 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Macerator_Bronze.java @@ -0,0 +1,135 @@ +package gregtech.common.tileentities.machines.steam; + +import java.util.Random; + +import gregtech.api.GregTech_API; +import gregtech.api.enums.Textures; +import gregtech.api.gui.GT_GUIContainer_BasicMachine; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicMachine_Bronze; +import gregtech.api.objects.GT_RenderedTexture; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_Utility; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.item.ItemStack; + +public class GT_MetaTileEntity_Macerator_Bronze + extends GT_MetaTileEntity_BasicMachine_Bronze +{ + public GT_MetaTileEntity_Macerator_Bronze(int aID, String aName, String aNameRegional) + { + super(aID, aName, aNameRegional, "Macerating your Ores", 1, 1, false); + } + + public GT_MetaTileEntity_Macerator_Bronze(String aName, String aDescription, ITexture[][][] aTextures) + { + super(aName, aDescription, aTextures, 1, 1, false); + } + + @Override +public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) + { + return new GT_GUIContainer_BasicMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "BronzeMacerator.png", "ic2.macerator"); + } + + @Override +public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) + { + return new GT_MetaTileEntity_Macerator_Bronze(this.mName, this.mDescription, this.mTextures); + } + + @Override +public void onPreTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) + { + super.onPreTick(aBaseMetaTileEntity, aTick); + if ((aBaseMetaTileEntity.isClientSide()) && (aBaseMetaTileEntity.isActive()) && (aBaseMetaTileEntity.getFrontFacing() != 1) && (aBaseMetaTileEntity.getCoverIDAtSide((byte)1) == 0) && (!aBaseMetaTileEntity.getOpacityAtSide((byte)1))) + { + Random tRandom = aBaseMetaTileEntity.getWorld().rand; + aBaseMetaTileEntity.getWorld().spawnParticle("smoke", aBaseMetaTileEntity.getXCoord() + 0.8F - tRandom.nextFloat() * 0.6F, aBaseMetaTileEntity.getYCoord() + 0.9F + tRandom.nextFloat() * 0.2F, aBaseMetaTileEntity.getZCoord() + 0.8F - tRandom.nextFloat() * 0.6F, 0.0D, 0.0D, 0.0D); + } + } + + @Override +public int checkRecipe() + { + if (null != (this.mOutputItems[0] = GT_ModHandler.getMaceratorOutput(getInputAt(0), true, getOutputAt(0)))) + { + this.mEUt = 2; + this.mMaxProgresstime = 800; + return 2; + } + return 0; + } + + @Override +public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) + { + if (!super.allowPutStack(aBaseMetaTileEntity, aIndex, aSide, aStack)) {return false;} + return GT_ModHandler.getMaceratorOutput(GT_Utility.copyAmount(64L, new Object[] { aStack }), false, null) != null; + } + + @Override +public void startSoundLoop(byte aIndex, double aX, double aY, double aZ) + { + super.startSoundLoop(aIndex, aX, aY, aZ); + if (aIndex == 1) { + GT_Utility.doSoundAtClient(GregTech_API.sSoundList.get(Integer.valueOf(201)), 10, 1.0F, aX, aY, aZ); + } + } + + @Override +public void startProcess() + { + sendLoopStart((byte)1); + } + + @Override +public ITexture[] getSideFacingActive(byte aColor) + { + return new ITexture[] { super.getSideFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_STEAM_MACERATOR_ACTIVE) }; + } + + @Override +public ITexture[] getSideFacingInactive(byte aColor) + { + return new ITexture[] { super.getSideFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_STEAM_MACERATOR) }; + } + + @Override +public ITexture[] getFrontFacingActive(byte aColor) + { + return new ITexture[] { super.getFrontFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_MACERATOR_ACTIVE) }; + } + + @Override +public ITexture[] getFrontFacingInactive(byte aColor) + { + return new ITexture[] { super.getFrontFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_MACERATOR) }; + } + + @Override +public ITexture[] getTopFacingActive(byte aColor) + { + return new ITexture[] { super.getTopFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_STEAM_MACERATOR_ACTIVE) }; + } + + @Override +public ITexture[] getTopFacingInactive(byte aColor) + { + return new ITexture[] { super.getTopFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_STEAM_MACERATOR) }; + } + + @Override +public ITexture[] getBottomFacingActive(byte aColor) + { + return new ITexture[] { super.getBottomFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_STEAM_MACERATOR_ACTIVE) }; + } + + @Override +public ITexture[] getBottomFacingInactive(byte aColor) + { + return new ITexture[] { super.getBottomFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_STEAM_MACERATOR) }; + } +} diff --git a/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Macerator_Steel.java b/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Macerator_Steel.java new file mode 100644 index 0000000..427a40c --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/steam/GT_MetaTileEntity_Macerator_Steel.java @@ -0,0 +1,141 @@ +/* 1: */ package gregtech.common.tileentities.machines.steam; +/* 14: */ import java.util.Random; + +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.Textures; +/* 5: */ import gregtech.api.gui.GT_GUIContainer_BasicMachine; +/* 6: */ import gregtech.api.interfaces.ITexture; +/* 7: */ import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +/* 8: */ import gregtech.api.metatileentity.MetaTileEntity; +/* 9: */ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicMachine_Steel; +/* 10: */ import gregtech.api.objects.GT_RenderedTexture; +/* 11: */ import gregtech.api.util.GT_ModHandler; +/* 12: */ import gregtech.api.util.GT_Utility; +/* 15: */ import net.minecraft.entity.player.InventoryPlayer; +/* 16: */ import net.minecraft.item.ItemStack; +/* 18: */ +/* 19: */ public class GT_MetaTileEntity_Macerator_Steel +/* 20: */ extends GT_MetaTileEntity_BasicMachine_Steel +/* 21: */ { +/* 22: */ public GT_MetaTileEntity_Macerator_Steel(int aID, String aName, String aNameRegional) +/* 23: */ { +/* 24: 21 */ super(aID, aName, aNameRegional, "Macerating your Ores", 1, 1, false); +/* 25: */ } +/* 26: */ +/* 27: */ public GT_MetaTileEntity_Macerator_Steel(String aName, String aDescription, ITexture[][][] aTextures) +/* 28: */ { +/* 29: 25 */ super(aName, aDescription, aTextures, 1, 1, false); +/* 30: */ } +/* 31: */ +/* 32: */ @Override +public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) +/* 33: */ { +/* 34: 30 */ return new GT_GUIContainer_BasicMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "SteelMacerator.png", "ic2.macerator"); +/* 35: */ } +/* 36: */ +/* 37: */ @Override +public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 38: */ { +/* 39: 35 */ return new GT_MetaTileEntity_Macerator_Steel(this.mName, this.mDescription, this.mTextures); +/* 40: */ } +/* 41: */ +/* 42: */ @Override +public void onPreTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) +/* 43: */ { +/* 44: 40 */ super.onPreTick(aBaseMetaTileEntity, aTick); +/* 45: 41 */ if ((aBaseMetaTileEntity.isClientSide()) && (aBaseMetaTileEntity.isActive()) && (aBaseMetaTileEntity.getFrontFacing() != 1) && (aBaseMetaTileEntity.getCoverIDAtSide((byte)1) == 0) && (!aBaseMetaTileEntity.getOpacityAtSide((byte)1))) +/* 46: */ { +/* 47: 42 */ Random tRandom = aBaseMetaTileEntity.getWorld().rand; +/* 48: 43 */ aBaseMetaTileEntity.getWorld().spawnParticle("smoke", aBaseMetaTileEntity.getXCoord() + 0.8F - tRandom.nextFloat() * 0.6F, aBaseMetaTileEntity.getYCoord() + 0.9F + tRandom.nextFloat() * 0.2F, aBaseMetaTileEntity.getZCoord() + 0.8F - tRandom.nextFloat() * 0.6F, 0.0D, 0.0D, 0.0D); +/* 49: */ } +/* 50: */ } +/* 51: */ +/* 52: */ @Override +public int checkRecipe() +/* 53: */ { +/* 54: 49 */ if (null != (this.mOutputItems[0] = GT_ModHandler.getMaceratorOutput(getInputAt(0), true, getOutputAt(0)))) +/* 55: */ { +/* 56: 50 */ this.mEUt = 6; +/* 57: 51 */ this.mMaxProgresstime = 400; +/* 58: 52 */ return 2; +/* 59: */ } +/* 60: 54 */ return 0; +/* 61: */ } +/* 62: */ +/* 63: */ @Override +public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) +/* 64: */ { + if (!super.allowPutStack(aBaseMetaTileEntity, aIndex, aSide, aStack)) {return false;} +/* 66: 59 */ return GT_ModHandler.getMaceratorOutput(GT_Utility.copyAmount(64L, new Object[] { aStack }), false, null) != null; +/* 67: */ } +/* 68: */ +/* 69: */ @Override +public void startSoundLoop(byte aIndex, double aX, double aY, double aZ) +/* 70: */ { +/* 71: 64 */ super.startSoundLoop(aIndex, aX, aY, aZ); +/* 72: 65 */ if (aIndex == 1) { +/* 73: 65 */ GT_Utility.doSoundAtClient(GregTech_API.sSoundList.get(Integer.valueOf(201)), 10, 1.0F, aX, aY, aZ); +/* 74: */ } +/* 75: */ } +/* 76: */ +/* 77: */ @Override +public void startProcess() +/* 78: */ { +/* 79: 70 */ sendLoopStart((byte)1); +/* 80: */ } +/* 81: */ +/* 82: */ @Override +public ITexture[] getSideFacingActive(byte aColor) +/* 83: */ { +/* 84: 75 */ return new ITexture[] { super.getSideFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_STEAM_MACERATOR_ACTIVE) }; +/* 85: */ } +/* 86: */ +/* 87: */ @Override +public ITexture[] getSideFacingInactive(byte aColor) +/* 88: */ { +/* 89: 80 */ return new ITexture[] { super.getSideFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SIDE_STEAM_MACERATOR) }; +/* 90: */ } +/* 91: */ +/* 92: */ @Override +public ITexture[] getFrontFacingActive(byte aColor) +/* 93: */ { +/* 94: 85 */ return new ITexture[] { super.getFrontFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_MACERATOR_ACTIVE) }; +/* 95: */ } +/* 96: */ +/* 97: */ @Override +public ITexture[] getFrontFacingInactive(byte aColor) +/* 98: */ { +/* 99: 90 */ return new ITexture[] { super.getFrontFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_STEAM_MACERATOR) }; +/* 100: */ } +/* 101: */ +/* 102: */ @Override +public ITexture[] getTopFacingActive(byte aColor) +/* 103: */ { +/* 104: 95 */ return new ITexture[] { super.getTopFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_STEAM_MACERATOR_ACTIVE) }; +/* 105: */ } +/* 106: */ +/* 107: */ @Override +public ITexture[] getTopFacingInactive(byte aColor) +/* 108: */ { +/* 109:100 */ return new ITexture[] { super.getTopFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_TOP_STEAM_MACERATOR) }; +/* 110: */ } +/* 111: */ +/* 112: */ @Override +public ITexture[] getBottomFacingActive(byte aColor) +/* 113: */ { +/* 114:105 */ return new ITexture[] { super.getBottomFacingActive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_STEAM_MACERATOR_ACTIVE) }; +/* 115: */ } +/* 116: */ +/* 117: */ @Override +public ITexture[] getBottomFacingInactive(byte aColor) +/* 118: */ { +/* 119:110 */ return new ITexture[] { super.getBottomFacingInactive(aColor)[0], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_BOTTOM_STEAM_MACERATOR) }; +/* 120: */ } +/* 121: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.machines.steam.GT_MetaTileEntity_Macerator_Steel + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_Locker.java b/src/main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_Locker.java new file mode 100644 index 0000000..9cc60ce --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_Locker.java @@ -0,0 +1,225 @@ +/* 1: */ package gregtech.common.tileentities.storage; +/* 2: */ +/* 3: */ import gregtech.api.GregTech_API; +import gregtech.api.enums.Textures; +/* 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_TieredMachineBlock; +/* 9: */ import gregtech.api.objects.GT_ItemStack; +/* 10: */ import gregtech.api.objects.GT_RenderedTexture; +/* 11: */ import gregtech.api.util.GT_Utility; +/* 13: */ import net.minecraft.entity.player.EntityPlayer; +/* 15: */ import net.minecraft.item.ItemStack; +/* 16: */ import net.minecraft.nbt.NBTTagCompound; +/* 17: */ +/* 18: */ public class GT_MetaTileEntity_Locker +/* 19: */ extends GT_MetaTileEntity_TieredMachineBlock +/* 20: */ { +/* 21: 24 */ public byte mType = 0; +/* 22: */ +/* 23: */ public GT_MetaTileEntity_Locker(int aID, String aName, String aNameRegional, int aTier) +/* 24: */ { +/* 25: 27 */ super(aID, aName, aNameRegional, aTier, 4, "Stores and recharges Armor", new ITexture[0]); +/* 26: */ } +/* 27: */ +/* 28: */ public GT_MetaTileEntity_Locker(String aName, int aTier, String aDescription, ITexture[][][] aTextures) +/* 29: */ { +/* 30: 31 */ super(aName, aTier, 4, aDescription, aTextures); +/* 31: */ } +/* 32: */ +/* 33: */ @Override +public String[] getDescription() +/* 34: */ { +/* 35: 36 */ return new String[] { this.mDescription, "Click with Screwdriver to change Style" }; +/* 36: */ } +/* 37: */ +/* 38: */ @Override +public ITexture[][][] getTextureSet(ITexture[] aTextures) +/* 39: */ { +/* 40: 41 */ ITexture[][][] rTextures = new ITexture[3][17][]; +/* 41: 42 */ for (byte i = -1; i < 16; i = (byte)(i + 1)) +/* 42: */ {ITexture[] tmp0 ={ Textures.BlockIcons.MACHINE_CASINGS[this.mTier][(i + 1)] }; +/* 43: 43 */ rTextures[0][(i + 1)] = tmp0; +/* 44: 44 */ ITexture[] tmp1 ={ Textures.BlockIcons.MACHINE_CASINGS[this.mTier][(i + 1)], Textures.BlockIcons.OVERLAYS_ENERGY_IN[this.mTier] }; +rTextures[1][(i + 1)] = tmp1; +/* 45: 45 */ ITexture[] tmp2 = { Textures.BlockIcons.MACHINE_CASINGS[this.mTier][(i + 1)], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_LOCKER) }; +rTextures[2][(i + 1)] =tmp2; +/* 46: */ } +/* 47: 47 */ return rTextures; +/* 48: */ } +/* 49: */ +/* 50: */ @Override +public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) +/* 51: */ { +/* 52: 52 */ if (aSide == aFacing) { +/* 53: 52 */ return new ITexture[] { this.mTextures[2][(aColorIndex + 1)][0], this.mTextures[2][(aColorIndex + 1)][1], Textures.BlockIcons.LOCKERS[java.lang.Math.abs(this.mType % Textures.BlockIcons.LOCKERS.length)] }; +/* 54: */ } +/* 55: 53 */ return this.mTextures[0][(aColorIndex + 1)]; +/* 56: */ } +/* 57: */ +/* 58: */ @Override +public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) +/* 59: */ { +/* 60: 58 */ return new GT_MetaTileEntity_Locker(this.mName, this.mTier, this.mDescription, this.mTextures); +/* 61: */ } +/* 62: */ +/* 63: */ @Override +public boolean isSimpleMachine() +/* 64: */ { +/* 65: 61 */ return false; +/* 66: */ } +/* 67: */ +/* 68: */ @Override +public boolean isElectric() +/* 69: */ { +/* 70: 62 */ return true; +/* 71: */ } +/* 72: */ +/* 73: */ @Override +public boolean isValidSlot(int aIndex) +/* 74: */ { +/* 75: 63 */ return true; +/* 76: */ } +/* 77: */ +/* 78: */ @Override +public boolean isFacingValid(byte aFacing) +/* 79: */ { +/* 80: 64 */ return aFacing > 1; +/* 81: */ } +/* 82: */ +/* 83: */ @Override +public boolean isEnetInput() +/* 84: */ { +/* 85: 65 */ return true; +/* 86: */ } +/* 87: */ +/* 88: */ @Override +public boolean isInputFacing(byte aSide) +/* 89: */ { +/* 90: 66 */ return aSide == getBaseMetaTileEntity().getBackFacing(); +/* 91: */ } +/* 92: */ +/* 93: */ @Override +public boolean isTeleporterCompatible() +/* 94: */ { +/* 95: 67 */ return false; +/* 96: */ } +/* 97: */ +/* 98: */ @Override +public long maxEUStore() +/* 99: */ { +/* 100: 68 */ return gregtech.api.enums.GT_Values.V[this.mTier] * maxAmperesIn(); +/* 101: */ } +/* 102: */ +/* 103: */ @Override +public long maxEUInput() +/* 104: */ { +/* 105: 69 */ return gregtech.api.enums.GT_Values.V[this.mTier]; +/* 106: */ } +/* 107: */ +/* 108: */ @Override +public long maxAmperesIn() +/* 109: */ { +/* 110: 70 */ return this.mInventory.length * 2; +/* 111: */ } +/* 112: */ +/* 113: */ @Override +public int rechargerSlotStartIndex() +/* 114: */ { +/* 115: 71 */ return 0; +/* 116: */ } +/* 117: */ +/* 118: */ @Override +public int rechargerSlotCount() +/* 119: */ { +/* 120: 72 */ return getBaseMetaTileEntity().isAllowedToWork() ? this.mInventory.length : 0; +/* 121: */ } +/* 122: */ +/* 123: */ @Override +public boolean isAccessAllowed(EntityPlayer aPlayer) +/* 124: */ { +/* 125: 73 */ return true; +/* 126: */ } +/* 127: */ +/* 128: */ @Override +public void saveNBTData(NBTTagCompound aNBT) +/* 129: */ { +/* 130: 77 */ aNBT.setByte("mType", this.mType); +/* 131: */ } +/* 132: */ +/* 133: */ @Override +public void loadNBTData(NBTTagCompound aNBT) +/* 134: */ { +/* 135: 82 */ this.mType = aNBT.getByte("mType"); +/* 136: */ } +/* 137: */ +/* 138: */ @Override +public void onValueUpdate(byte aValue) +/* 139: */ { +/* 140: 87 */ this.mType = aValue; +/* 141: */ } +/* 142: */ +/* 143: */ @Override +public byte getUpdateData() +/* 144: */ { +/* 145: 92 */ return this.mType; +/* 146: */ } +/* 147: */ +/* 148: */ @Override +public void doSound(byte aIndex, double aX, double aY, double aZ) +/* 149: */ { +/* 150: 97 */ if (aIndex == 16) { +/* 151: 97 */ GT_Utility.doSoundAtClient(GregTech_API.sSoundList.get(Integer.valueOf(3)), 1, 1.0F); +/* 152: */ } +/* 153: */ } +/* 154: */ +/* 155: */ @Override +public void onScrewdriverRightClick(byte aSide, EntityPlayer aPlayer, float aX, float aY, float aZ) +/* 156: */ { +/* 157:102 */ if (aSide == getBaseMetaTileEntity().getFrontFacing()) { +/* 158:102 */ this.mType = ((byte)(this.mType + 1)); +/* 159: */ } +/* 160: */ } +/* 161: */ +/* 162: */ @Override +public boolean allowCoverOnSide(byte aSide, GT_ItemStack aStack) +/* 163: */ { +/* 164:107 */ return aSide != getBaseMetaTileEntity().getFrontFacing(); +/* 165: */ } +/* 166: */ +/* 167: */ @Override +public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, byte aSide, float aX, float aY, float aZ) +/* 168: */ { +/* 169:112 */ if ((aBaseMetaTileEntity.isServerSide()) && (aSide == aBaseMetaTileEntity.getFrontFacing())) +/* 170: */ { +/* 171:113 */ for (int i = 0; i < 4; i++) +/* 172: */ { +/* 173:114 */ ItemStack tSwapStack = this.mInventory[i]; +/* 174:115 */ this.mInventory[i] = aPlayer.inventory.armorInventory[i]; +/* 175:116 */ aPlayer.inventory.armorInventory[i] = tSwapStack; +/* 176: */ } +/* 177:118 */ aPlayer.inventoryContainer.detectAndSendChanges(); +/* 178:119 */ sendSound((byte)16); +/* 179: */ } +/* 180:121 */ return true; +/* 181: */ } +/* 182: */ +/* 183: */ @Override +public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) +/* 184: */ { +/* 185:126 */ return false; +/* 186: */ } +/* 187: */ +/* 188: */ @Override +public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) +/* 189: */ { +/* 190:131 */ return false; +/* 191: */ } +/* 192: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.tileentities.storage.GT_MetaTileEntity_Locker + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_QuantumChest.java b/src/main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_QuantumChest.java new file mode 100644 index 0000000..18a9bd3 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_QuantumChest.java @@ -0,0 +1,202 @@ +package gregtech.common.tileentities.storage; + +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_TieredMachineBlock; +import gregtech.api.objects.GT_RenderedTexture; +import gregtech.api.util.GT_Utility; +import gregtech.common.gui.GT_Container_QuantumChest; +import gregtech.common.gui.GT_GUIContainer_QuantumChest; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; + +public class GT_MetaTileEntity_QuantumChest extends GT_MetaTileEntity_TieredMachineBlock { + public GT_MetaTileEntity_QuantumChest(int aID, String aName, String aNameRegional, int aTier) { + super(aID, aName, aNameRegional, aTier, 3, "This Chest stores "+((int)((Math.pow(6, aTier))*270000))+" Blocks"); + } + + + public int mItemCount = 0; + public ItemStack mItemStack = null; + + public GT_MetaTileEntity_QuantumChest(String aName, int aTier, String aDescription, ITexture[][][] aTextures) { + super(aName, aTier, 3, aDescription, aTextures); + } + + @Override public boolean isSimpleMachine() {return true;} + @Override public boolean isFacingValid(byte aFacing) {return true;} + @Override public boolean isAccessAllowed(EntityPlayer aPlayer) {return true;} + @Override public boolean isValidSlot(int aIndex) {return true;} + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new GT_MetaTileEntity_QuantumChest(mName, mTier, mDescription, mTextures); + } + + @Override + public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) { + if (aBaseMetaTileEntity.isClientSide()) return true; + aBaseMetaTileEntity.openGUI(aPlayer); + return true; + } + +// public void onRightclick(EntityPlayer aPlayer) +// { +// ItemStack tPlayerItem = aPlayer.inventory.getCurrentItem(); +// if (tPlayerItem == null) +// { +// if (this.mItemID > 0) +// { +// for (int i = 0; (this.mItemCount < getMaxItemCount()) && (i < aPlayer.field_71071_by.func_70302_i_()); i++) +// { +// if ((aPlayer.field_71071_by.func_70301_a(i) != null) && (aPlayer.field_71071_by.func_70301_a(i).field_77993_c == this.mItemID) && (aPlayer.field_71071_by.func_70301_a(i).func_77960_j() == this.mItemMeta) && (!aPlayer.field_71071_by.func_70301_a(i).func_77942_o())) +// { +// this.mItemCount += aPlayer.field_71071_by.func_70301_a(i).field_77994_a; +// if (aPlayer.field_71071_by.func_70301_a(i).field_77994_a == 111) +// { +// this.mItemCount = (getMaxItemCount() + 192 - (this.mItemCount + (this.mInventory[0] == null ? 0 : this.mInventory[0].field_77994_a) + (this.mInventory[1] == null ? 0 : this.mInventory[1].field_77994_a) + (this.mInventory[2] == null ? 0 : this.mInventory[2].field_77994_a))); +// } +// else if (this.mItemCount > getMaxItemCount()) +// { +// aPlayer.field_71071_by.func_70301_a(i).field_77994_a = (this.mItemCount - getMaxItemCount()); +// this.mItemCount = getMaxItemCount(); +// } +// else +// { +// aPlayer.field_71071_by.func_70301_a(i).field_77994_a = 0; +// } +// } +// if ((aPlayer.field_71071_by.func_70301_a(i) != null) && (aPlayer.field_71071_by.func_70301_a(i).field_77994_a <= 0)) { +// aPlayer.field_71071_by.func_70299_a(i, null); +// } +// } +// GT_Utility.sendChatToPlayer(aPlayer, this.mItemCount + (this.mInventory[0] == null ? 0 : this.mInventory[0].field_77994_a) + (this.mInventory[1] == null ? 0 : this.mInventory[1].field_77994_a) + (this.mInventory[2] == null ? 0 : this.mInventory[2].field_77994_a) + " of " + new ItemStack(this.mItemID, 1, this.mItemMeta).func_82833_r()); +// } +// } +// if (aPlayer.field_71069_bz != null) { +// aPlayer.field_71069_bz.func_75142_b(); +// } +// } + + @Override + public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) { + return new GT_Container_QuantumChest(aPlayerInventory, aBaseMetaTileEntity); + } + + @Override + public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) { + return new GT_GUIContainer_QuantumChest(aPlayerInventory, aBaseMetaTileEntity, getLocalName()); + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTimer) { + + if (getBaseMetaTileEntity().isServerSide()&& getBaseMetaTileEntity().isAllowedToWork()) + { + if ((getItemCount() <= 0) ){ + this.mItemStack = null; + this.mItemCount = 0; + } + if (this.mItemStack == null&&this.mInventory[0]!=null) + { + this.mItemStack = mInventory[0].copy(); + } + if ((this.mInventory[0]!=null)&&(this.mItemCount < getMaxItemCount()) && GT_Utility.areStacksEqual(this.mInventory[0],this.mItemStack)) + { + this.mItemCount += this.mInventory[0].stackSize; + if (this.mItemCount > getMaxItemCount()) + { + this.mInventory[0].stackSize = (this.mItemCount - getMaxItemCount()); + this.mItemCount = getMaxItemCount(); + } + else + { + this.mInventory[0] = null; + } + } + if (this.mInventory[1] == null&&mItemStack!=null) + { + this.mInventory[1] = mItemStack.copy(); + this.mInventory[1].stackSize = Math.min(mItemStack.getMaxStackSize(), this.mItemCount); + this.mItemCount -= this.mInventory[1].stackSize; + } + else if ((this.mItemCount > 0) && GT_Utility.areStacksEqual(this.mInventory[1],this.mItemStack)&&this.mInventory[1].getMaxStackSize()>this.mInventory[1].stackSize) + { + int tmp = Math.min(this.mItemCount, this.mInventory[1].getMaxStackSize()-this.mInventory[1].stackSize); + this.mInventory[1].stackSize += tmp; + this.mItemCount -= tmp; + } + if(this.mItemStack!=null){ + this.mInventory[2]= this.mItemStack.copy(); + }else{this.mInventory[2]=null;} + } + } + + private int getItemCount() + { + return this.mItemCount; + } + + @Override + public int getProgresstime() + { + return this.mItemCount + (this.mInventory[0] == null ? 0 : this.mInventory[0].stackSize) + (this.mInventory[1] == null ? 0 : this.mInventory[1].stackSize); + } + + @Override + public int maxProgresstime() + { + return getMaxItemCount(); + } + + @Override + public int getMaxItemCount() + { + return (int) (((Math.pow(6, mTier))*270000) - 128); + } + + @Override + public void setItemCount(int aCount) + { + this.mItemCount = aCount; + } + + @Override + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + return true; + } + + @Override + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) { + return true; + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + aNBT.setInteger("mItemCount", this.mItemCount); + if(this.mItemStack!=null) + aNBT.setTag("mItemStack", this.mItemStack.writeToNBT(new NBTTagCompound())); + } + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + if(aNBT.hasKey("mItemCount")) + this.mItemCount = aNBT.getInteger("mItemCount"); + if(aNBT.hasKey("mItemStack")) + this.mItemStack = ItemStack.loadItemStackFromNBT((NBTTagCompound) aNBT.getTag("mItemStack")); + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity,byte aSide, byte aFacing, byte aColorIndex, boolean aActive,boolean aRedstone) { + return aSide == aBaseMetaTileEntity.getFrontFacing() ? new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex+1],new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SCREEN)} :new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex+1]};//aSide != aFacing ? mMachineBlock != 0 ? new ITexture[] {Textures.BlockIcons.CASING_BLOCKS[mMachineBlock]} : new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex+1]} : mMachineBlock != 0 ? aActive ? getTexturesActive(Textures.BlockIcons.CASING_BLOCKS[mMachineBlock]) : getTexturesInactive(Textures.BlockIcons.CASING_BLOCKS[mMachineBlock]) : aActive ? getTexturesActive(Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex+1]) : getTexturesInactive(Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex+1]); + } + + @Override + public ITexture[][][] getTextureSet(ITexture[] aTextures) { + return new ITexture[0][0][0]; + } +} \ No newline at end of file diff --git a/src/main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_QuantumTank.java b/src/main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_QuantumTank.java new file mode 100644 index 0000000..599da17 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/storage/GT_MetaTileEntity_QuantumTank.java @@ -0,0 +1,104 @@ +package gregtech.common.tileentities.storage; + +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicTank; +import gregtech.api.objects.GT_RenderedTexture; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.nbt.NBTTagCompound; + +public class GT_MetaTileEntity_QuantumTank + extends GT_MetaTileEntity_BasicTank +{ + public GT_MetaTileEntity_QuantumTank(int aID, String aName, String aNameRegional, int aTier) { + super(aID, aName, aNameRegional, aTier, 3, "Stores "+((int)(Math.pow(6, aTier)*267000))+"L of fluid"); + } + + public GT_MetaTileEntity_QuantumTank(String aName, int aTier, String aDescription, ITexture[][][] aTextures) { + super(aName, aTier, 3, aDescription, aTextures); + } + + @Override + public ITexture[][][] getTextureSet(ITexture[] aTextures) { + return new ITexture[0][0][0]; + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) { + return aSide ==1 ? new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex+1],new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_SCREEN)} :new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColorIndex+1]}; + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + super.saveNBTData(aNBT); + } + + @Override + public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) { + if (aBaseMetaTileEntity.isClientSide()) return true; + aBaseMetaTileEntity.openGUI(aPlayer); + return true; + } + + @Override public boolean isSimpleMachine() {return true;} + @Override public boolean isFacingValid(byte aFacing) {return true;} + @Override public boolean isAccessAllowed(EntityPlayer aPlayer) {return true;} + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + super.loadNBTData(aNBT); + } + + @Override + public final byte getUpdateData() { + return 0x00; + } + + @Override + public boolean doesFillContainers() { + return true; + } + + @Override + public boolean doesEmptyContainers() { + return true; + } + + @Override + public boolean canTankBeFilled() { + return true; + } + + @Override + public boolean canTankBeEmptied() { + return true; + } + + @Override + public boolean displaysItemStack() { + return true; + } + + @Override + public boolean displaysStackSize() { + return false; + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new GT_MetaTileEntity_QuantumTank(mName, mTier, mDescription, mTextures); + } + + @Override + public int getCapacity() { + return (int) (Math.pow(6, mTier)*267000); + } + + @Override + public int getTankPressure() { + return 100; + } + +} \ No newline at end of file -- cgit v1.2.3