From 7224ac4299098c70efae9dbd04c50a97e3f5f583 Mon Sep 17 00:00:00 2001 From: Blood Asp Date: Thu, 23 Apr 2015 18:14:22 +0200 Subject: Initial Commit --- main/java/gregtech/common/covers/GT_Cover_Arm.java | 118 +++++++++++++ .../common/covers/GT_Cover_Blastproof.java | 31 ++++ .../common/covers/GT_Cover_ControlsWork.java | 96 ++++++++++ .../gregtech/common/covers/GT_Cover_Conveyor.java | 139 +++++++++++++++ .../gregtech/common/covers/GT_Cover_Crafting.java | 41 +++++ .../gregtech/common/covers/GT_Cover_DoesWork.java | 100 +++++++++++ .../gregtech/common/covers/GT_Cover_Drain.java | 114 ++++++++++++ .../gregtech/common/covers/GT_Cover_EUMeter.java | 144 +++++++++++++++ .../common/covers/GT_Cover_EnergyOnly.java | 108 ++++++++++++ .../gregtech/common/covers/GT_Cover_ItemMeter.java | 99 +++++++++++ .../java/gregtech/common/covers/GT_Cover_Lens.java | 26 +++ .../common/covers/GT_Cover_LiquidMeter.java | 103 +++++++++++ .../java/gregtech/common/covers/GT_Cover_Pump.java | 193 +++++++++++++++++++++ .../common/covers/GT_Cover_RedstoneConductor.java | 90 ++++++++++ .../covers/GT_Cover_RedstoneReceiverExternal.java | 31 ++++ .../covers/GT_Cover_RedstoneReceiverInternal.java | 30 ++++ .../common/covers/GT_Cover_RedstoneSignalizer.java | 87 ++++++++++ .../GT_Cover_RedstoneTransmitterExternal.java | 31 ++++ .../GT_Cover_RedstoneTransmitterInternal.java | 31 ++++ .../covers/GT_Cover_RedstoneWirelessBase.java | 104 +++++++++++ .../gregtech/common/covers/GT_Cover_Screen.java | 86 +++++++++ .../gregtech/common/covers/GT_Cover_Shutter.java | 90 ++++++++++ .../common/covers/GT_Cover_SolarPanel.java | 47 +++++ .../java/gregtech/common/covers/GT_Cover_Vent.java | 46 +++++ 24 files changed, 1985 insertions(+) create mode 100644 main/java/gregtech/common/covers/GT_Cover_Arm.java create mode 100644 main/java/gregtech/common/covers/GT_Cover_Blastproof.java create mode 100644 main/java/gregtech/common/covers/GT_Cover_ControlsWork.java create mode 100644 main/java/gregtech/common/covers/GT_Cover_Conveyor.java create mode 100644 main/java/gregtech/common/covers/GT_Cover_Crafting.java create mode 100644 main/java/gregtech/common/covers/GT_Cover_DoesWork.java create mode 100644 main/java/gregtech/common/covers/GT_Cover_Drain.java create mode 100644 main/java/gregtech/common/covers/GT_Cover_EUMeter.java create mode 100644 main/java/gregtech/common/covers/GT_Cover_EnergyOnly.java create mode 100644 main/java/gregtech/common/covers/GT_Cover_ItemMeter.java create mode 100644 main/java/gregtech/common/covers/GT_Cover_Lens.java create mode 100644 main/java/gregtech/common/covers/GT_Cover_LiquidMeter.java create mode 100644 main/java/gregtech/common/covers/GT_Cover_Pump.java create mode 100644 main/java/gregtech/common/covers/GT_Cover_RedstoneConductor.java create mode 100644 main/java/gregtech/common/covers/GT_Cover_RedstoneReceiverExternal.java create mode 100644 main/java/gregtech/common/covers/GT_Cover_RedstoneReceiverInternal.java create mode 100644 main/java/gregtech/common/covers/GT_Cover_RedstoneSignalizer.java create mode 100644 main/java/gregtech/common/covers/GT_Cover_RedstoneTransmitterExternal.java create mode 100644 main/java/gregtech/common/covers/GT_Cover_RedstoneTransmitterInternal.java create mode 100644 main/java/gregtech/common/covers/GT_Cover_RedstoneWirelessBase.java create mode 100644 main/java/gregtech/common/covers/GT_Cover_Screen.java create mode 100644 main/java/gregtech/common/covers/GT_Cover_Shutter.java create mode 100644 main/java/gregtech/common/covers/GT_Cover_SolarPanel.java create mode 100644 main/java/gregtech/common/covers/GT_Cover_Vent.java (limited to 'main/java/gregtech/common/covers') diff --git a/main/java/gregtech/common/covers/GT_Cover_Arm.java b/main/java/gregtech/common/covers/GT_Cover_Arm.java new file mode 100644 index 0000000000..a3cfa3868f --- /dev/null +++ b/main/java/gregtech/common/covers/GT_Cover_Arm.java @@ -0,0 +1,118 @@ +/* 1: */ package gregtech.common.covers; +/* 2: */ +/* 3: */ import gregtech.api.interfaces.tileentity.ICoverable; +/* 4: */ import gregtech.api.interfaces.tileentity.IMachineProgress; +/* 5: */ import gregtech.api.util.GT_CoverBehavior; +/* 6: */ import gregtech.api.util.GT_Utility; +/* 7: */ import net.minecraft.entity.player.EntityPlayer; +/* 8: */ import net.minecraft.tileentity.TileEntity; +/* 9: */ import net.minecraftforge.fluids.Fluid; +/* 10: */ +/* 11: */ public class GT_Cover_Arm +/* 12: */ extends GT_CoverBehavior +/* 13: */ { +/* 14: */ public final int mTickRate; +/* 15: */ +/* 16: */ public GT_Cover_Arm(int aTickRate) +/* 17: */ { +/* 18:16 */ this.mTickRate = aTickRate; +/* 19: */ } +/* 20: */ +/* 21: */ public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) +/* 22: */ { +/* 23:21 */ if ((aCoverVariable == 0) || (((aTileEntity instanceof IMachineProgress)) && (!((IMachineProgress)aTileEntity).isAllowedToWork()))) { +/* 24:21 */ return aCoverVariable; +/* 25: */ } +/* 26:22 */ TileEntity tTileEntity = aTileEntity.getTileEntityAtSide(aSide); +/* 27:23 */ aTileEntity.decreaseStoredEnergyUnits(1L, true); +/* 28:24 */ if (aTileEntity.getUniversalEnergyCapacity() >= 128L) +/* 29: */ { +/* 30:25 */ if (aTileEntity.isUniversalEnergyStored(256L)) { +/* 31:26 */ aTileEntity.decreaseStoredEnergyUnits(4 * GT_Utility.moveOneItemStackIntoSlot(aCoverVariable > 0 ? aTileEntity : tTileEntity, aCoverVariable > 0 ? tTileEntity : aTileEntity, aCoverVariable > 0 ? aSide : GT_Utility.getOppositeSide(aSide), Math.abs(aCoverVariable) - 1, null, false, (byte)64, (byte)1, (byte)64, (byte)1), true); +/* 32: */ } +/* 33: */ } +/* 34: */ else { +/* 35:29 */ GT_Utility.moveOneItemStackIntoSlot(aCoverVariable > 0 ? aTileEntity : tTileEntity, aCoverVariable > 0 ? tTileEntity : aTileEntity, aCoverVariable > 0 ? aSide : GT_Utility.getOppositeSide(aSide), Math.abs(aCoverVariable) - 1, null, false, (byte)64, (byte)1, (byte)64, (byte)1); +/* 36: */ } +/* 37:31 */ return aCoverVariable; +/* 38: */ } +/* 39: */ +/* 40: */ public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) +/* 41: */ { +/* 42:36 */ if (GT_Utility.getClickedFacingCoords(aSide, aX, aY, aZ)[0] >= 0.5F) { +/* 43:36 */ aCoverVariable += 16; +/* 44: */ } else { +/* 45:36 */ aCoverVariable -= 16; +/* 46: */ } +/* 47:37 */ GT_Utility.sendChatToPlayer(aPlayer, (aCoverVariable > 0 ? "Puts out into adjacent Slot #" : "Grabs in for own Slot #") + (Math.abs(aCoverVariable) - 1)); +/* 48:38 */ return aCoverVariable; +/* 49: */ } +/* 50: */ +/* 51: */ public boolean onCoverRightclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) +/* 52: */ { +/* 53:43 */ if (GT_Utility.getClickedFacingCoords(aSide, aX, aY, aZ)[0] >= 0.5F) { +/* 54:43 */ aCoverVariable++; +/* 55: */ } else { +/* 56:43 */ aCoverVariable--; +/* 57: */ } +/* 58:44 */ GT_Utility.sendChatToPlayer(aPlayer, (aCoverVariable > 0 ? "Puts out into adjacent Slot #" : "Grabs in for own Slot #") + (Math.abs(aCoverVariable) - 1)); +/* 59:45 */ aTileEntity.setCoverDataAtSide(aSide, aCoverVariable); +/* 60:46 */ return true; +/* 61: */ } +/* 62: */ +/* 63: */ public boolean letsRedstoneGoIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 64: */ { +/* 65:51 */ return true; +/* 66: */ } +/* 67: */ +/* 68: */ public boolean letsRedstoneGoOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 69: */ { +/* 70:56 */ return true; +/* 71: */ } +/* 72: */ +/* 73: */ public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 74: */ { +/* 75:61 */ return true; +/* 76: */ } +/* 77: */ +/* 78: */ public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 79: */ { +/* 80:66 */ return true; +/* 81: */ } +/* 82: */ +/* 83: */ public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) +/* 84: */ { +/* 85:71 */ return true; +/* 86: */ } +/* 87: */ +/* 88: */ public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) +/* 89: */ { +/* 90:76 */ return true; +/* 91: */ } +/* 92: */ +/* 93: */ public boolean letsItemsIn(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) +/* 94: */ { +/* 95:81 */ return true; +/* 96: */ } +/* 97: */ +/* 98: */ public boolean letsItemsOut(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) +/* 99: */ { +/* :0:86 */ return true; +/* :1: */ } +/* :2: */ +/* :3: */ public boolean alwaysLookConnected(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* :4: */ { +/* :5:91 */ return true; +/* :6: */ } +/* :7: */ +/* :8: */ public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* :9: */ { +/* ;0:96 */ return this.mTickRate; +/* ;1: */ } +/* ;2: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.covers.GT_Cover_Arm + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/common/covers/GT_Cover_Blastproof.java b/main/java/gregtech/common/covers/GT_Cover_Blastproof.java new file mode 100644 index 0000000000..2cb74191b2 --- /dev/null +++ b/main/java/gregtech/common/covers/GT_Cover_Blastproof.java @@ -0,0 +1,31 @@ +/* 1: */ package gregtech.common.covers; +/* 2: */ +/* 3: */ import gregtech.api.interfaces.tileentity.ICoverable; +/* 4: */ import gregtech.api.util.GT_CoverBehavior; +/* 5: */ +/* 6: */ public class GT_Cover_Blastproof +/* 7: */ extends GT_CoverBehavior +/* 8: */ { +/* 9: */ private final float mLevel; +/* 10: */ +/* 11: */ public GT_Cover_Blastproof(float aLevel) +/* 12: */ { +/* 13:11 */ this.mLevel = aLevel; +/* 14: */ } +/* 15: */ +/* 16: */ public float getBlastProofLevel(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 17: */ { +/* 18:16 */ return this.mLevel; +/* 19: */ } +/* 20: */ +/* 21: */ public boolean isSimpleCover() +/* 22: */ { +/* 23:21 */ return true; +/* 24: */ } +/* 25: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.covers.GT_Cover_Blastproof + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/common/covers/GT_Cover_ControlsWork.java b/main/java/gregtech/common/covers/GT_Cover_ControlsWork.java new file mode 100644 index 0000000000..6367cf67a1 --- /dev/null +++ b/main/java/gregtech/common/covers/GT_Cover_ControlsWork.java @@ -0,0 +1,96 @@ +/* 1: */ package gregtech.common.covers; +/* 2: */ +/* 3: */ import gregtech.api.interfaces.tileentity.ICoverable; +/* 4: */ import gregtech.api.interfaces.tileentity.IMachineProgress; +/* 5: */ import gregtech.api.util.GT_CoverBehavior; +/* 6: */ import gregtech.api.util.GT_Utility; +/* 7: */ import net.minecraft.entity.player.EntityPlayer; +/* 8: */ import net.minecraftforge.fluids.Fluid; +/* 9: */ +/* 10: */ public class GT_Cover_ControlsWork +/* 11: */ extends GT_CoverBehavior +/* 12: */ { +/* 13: */ public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) +/* 14: */ { +/* 15:13 */ if ((aTileEntity instanceof IMachineProgress)) +/* 16: */ { +/* 17:14 */ if ((aInputRedstone > 0 ? 1 : 0) == (aCoverVariable == 0 ? 1 : 0)) { +/* 18:14 */ if (aCoverVariable != 2) +/* 19: */ { +/* 20:14 */ ((IMachineProgress)aTileEntity).enableWorking(); +/* 21: */ //break label59; +/* 22: */ } +/* 23: */ } +/* 24:14 */ ((IMachineProgress)aTileEntity).disableWorking(); +/* 25: */ //label59: +/* 26:15 */ ((IMachineProgress)aTileEntity).setWorkDataValue(aInputRedstone); +/* 27: */ } +/* 28:17 */ return aCoverVariable; +/* 29: */ } +/* 30: */ +/* 31: */ public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 32: */ { +/* 33:22 */ return true; +/* 34: */ } +/* 35: */ +/* 36: */ public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 37: */ { +/* 38:27 */ return true; +/* 39: */ } +/* 40: */ +/* 41: */ public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) +/* 42: */ { +/* 43:32 */ return true; +/* 44: */ } +/* 45: */ +/* 46: */ public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) +/* 47: */ { +/* 48:37 */ return true; +/* 49: */ } +/* 50: */ +/* 51: */ public boolean letsItemsIn(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) +/* 52: */ { +/* 53:42 */ return true; +/* 54: */ } +/* 55: */ +/* 56: */ public boolean letsItemsOut(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) +/* 57: */ { +/* 58:47 */ return true; +/* 59: */ } +/* 60: */ +/* 61: */ public boolean onCoverRemoval(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, boolean aForced) +/* 62: */ { +/* 63:52 */ if ((aTileEntity instanceof IMachineProgress)) +/* 64: */ { +/* 65:53 */ ((IMachineProgress)aTileEntity).enableWorking(); +/* 66:54 */ ((IMachineProgress)aTileEntity).setWorkDataValue((byte)0); +/* 67: */ } +/* 68:56 */ return true; +/* 69: */ } +/* 70: */ +/* 71: */ public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) +/* 72: */ { +/* 73:61 */ aCoverVariable = (aCoverVariable + 1) % 3; +/* 74:62 */ if (aCoverVariable == 0) { +/* 75:62 */ GT_Utility.sendChatToPlayer(aPlayer, "Normal"); +/* 76: */ } +/* 77:63 */ if (aCoverVariable == 1) { +/* 78:63 */ GT_Utility.sendChatToPlayer(aPlayer, "Inverted"); +/* 79: */ } +/* 80:64 */ if (aCoverVariable == 2) { +/* 81:64 */ GT_Utility.sendChatToPlayer(aPlayer, "No Work at all"); +/* 82: */ } +/* 83:65 */ return aCoverVariable; +/* 84: */ } +/* 85: */ +/* 86: */ public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 87: */ { +/* 88:70 */ return 1; +/* 89: */ } +/* 90: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.covers.GT_Cover_ControlsWork + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/common/covers/GT_Cover_Conveyor.java b/main/java/gregtech/common/covers/GT_Cover_Conveyor.java new file mode 100644 index 0000000000..266bdf7524 --- /dev/null +++ b/main/java/gregtech/common/covers/GT_Cover_Conveyor.java @@ -0,0 +1,139 @@ +/* 1: */ package gregtech.common.covers; +/* 2: */ +/* 3: */ import gregtech.api.interfaces.tileentity.ICoverable; +/* 4: */ import gregtech.api.interfaces.tileentity.IMachineProgress; +/* 5: */ import gregtech.api.util.GT_CoverBehavior; +/* 6: */ import gregtech.api.util.GT_Utility; +/* 7: */ import net.minecraft.entity.player.EntityPlayer; +/* 8: */ import net.minecraft.tileentity.TileEntity; +/* 9: */ import net.minecraftforge.fluids.Fluid; +/* 10: */ +/* 11: */ public class GT_Cover_Conveyor +/* 12: */ extends GT_CoverBehavior +/* 13: */ { +/* 14: */ public final int mTickRate; +/* 15: */ +/* 16: */ public GT_Cover_Conveyor(int aTickRate) +/* 17: */ { +/* 18:16 */ this.mTickRate = aTickRate; +/* 19: */ } +/* 20: */ +/* 21: */ public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) +/* 22: */ { +/* 23:21 */ if ((aCoverVariable % 6 > 1) && ((aTileEntity instanceof IMachineProgress))) { +/* 24:21 */ if (((IMachineProgress)aTileEntity).isAllowedToWork() != aCoverVariable % 6 < 4) { +/* 25:21 */ return aCoverVariable; +/* 26: */ } +/* 27: */ } +/* 28:22 */ TileEntity tTileEntity = aTileEntity.getTileEntityAtSide(aSide); +/* 29:23 */ aTileEntity.decreaseStoredEnergyUnits(1L, true); +/* 30:24 */ if (((aCoverVariable % 2 != 1) || (aSide != 1)) && ((aCoverVariable % 2 != 0) || (aSide != 0)) && (aTileEntity.getUniversalEnergyCapacity() >= 128L)) +/* 31: */ { +/* 32:25 */ if (aTileEntity.isUniversalEnergyStored(256L)) { +/* 33:26 */ aTileEntity.decreaseStoredEnergyUnits(4 * GT_Utility.moveOneItemStack(aCoverVariable % 2 == 0 ? aTileEntity : tTileEntity, aCoverVariable % 2 != 0 ? aTileEntity : tTileEntity, aCoverVariable % 2 != 0 ? GT_Utility.getOppositeSide(aSide) : aSide, aCoverVariable % 2 == 0 ? GT_Utility.getOppositeSide(aSide) : aSide, null, false, (byte)64, (byte)1, (byte)64, (byte)1), true); +/* 34: */ } +/* 35: */ } +/* 36: */ else { +/* 37:29 */ GT_Utility.moveOneItemStack(aCoverVariable % 2 == 0 ? aTileEntity : tTileEntity, aCoverVariable % 2 != 0 ? aTileEntity : tTileEntity, aCoverVariable % 2 != 0 ? GT_Utility.getOppositeSide(aSide) : aSide, aCoverVariable % 2 == 0 ? GT_Utility.getOppositeSide(aSide) : aSide, null, false, (byte)64, (byte)1, (byte)64, (byte)1); +/* 38: */ } +/* 39:31 */ return aCoverVariable; +/* 40: */ } +/* 41: */ +/* 42: */ public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) +/* 43: */ { +/* 44:36 */ aCoverVariable = (aCoverVariable + 1) % 12; +/* 45:37 */ if (aCoverVariable == 0) { +/* 46:37 */ GT_Utility.sendChatToPlayer(aPlayer, "Export"); +/* 47: */ } +/* 48:38 */ if (aCoverVariable == 1) { +/* 49:38 */ GT_Utility.sendChatToPlayer(aPlayer, "Import"); +/* 50: */ } +/* 51:39 */ if (aCoverVariable == 2) { +/* 52:39 */ GT_Utility.sendChatToPlayer(aPlayer, "Export (conditional)"); +/* 53: */ } +/* 54:40 */ if (aCoverVariable == 3) { +/* 55:40 */ GT_Utility.sendChatToPlayer(aPlayer, "Import (conditional)"); +/* 56: */ } +/* 57:41 */ if (aCoverVariable == 4) { +/* 58:41 */ GT_Utility.sendChatToPlayer(aPlayer, "Export (invert cond)"); +/* 59: */ } +/* 60:42 */ if (aCoverVariable == 5) { +/* 61:42 */ GT_Utility.sendChatToPlayer(aPlayer, "Import (invert cond)"); +/* 62: */ } +/* 63:43 */ if (aCoverVariable == 6) { +/* 64:43 */ GT_Utility.sendChatToPlayer(aPlayer, "Export allow Input"); +/* 65: */ } +/* 66:44 */ if (aCoverVariable == 7) { +/* 67:44 */ GT_Utility.sendChatToPlayer(aPlayer, "Import allow Output"); +/* 68: */ } +/* 69:45 */ if (aCoverVariable == 8) { +/* 70:45 */ GT_Utility.sendChatToPlayer(aPlayer, "Export allow Input (conditional)"); +/* 71: */ } +/* 72:46 */ if (aCoverVariable == 9) { +/* 73:46 */ GT_Utility.sendChatToPlayer(aPlayer, "Import allow Output (conditional)"); +/* 74: */ } +/* 75:47 */ if (aCoverVariable == 10) { +/* 76:47 */ GT_Utility.sendChatToPlayer(aPlayer, "Export allow Input (invert cond)"); +/* 77: */ } +/* 78:48 */ if (aCoverVariable == 11) { +/* 79:48 */ GT_Utility.sendChatToPlayer(aPlayer, "Import allow Output (invert cond)"); +/* 80: */ } +/* 81:49 */ return aCoverVariable; +/* 82: */ } +/* 83: */ +/* 84: */ public boolean letsRedstoneGoIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 85: */ { +/* 86:54 */ return true; +/* 87: */ } +/* 88: */ +/* 89: */ public boolean letsRedstoneGoOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 90: */ { +/* 91:59 */ return true; +/* 92: */ } +/* 93: */ +/* 94: */ public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 95: */ { +/* 96:64 */ return true; +/* 97: */ } +/* 98: */ +/* 99: */ public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* :0: */ { +/* :1:69 */ return true; +/* :2: */ } +/* :3: */ +/* :4: */ public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) +/* :5: */ { +/* :6:74 */ return true; +/* :7: */ } +/* :8: */ +/* :9: */ public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) +/* ;0: */ { +/* ;1:79 */ return true; +/* ;2: */ } +/* ;3: */ +/* ;4: */ public boolean letsItemsIn(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) +/* ;5: */ { +/* ;6:84 */ return (aCoverVariable >= 6) || (aCoverVariable % 2 != 0); +/* ;7: */ } +/* ;8: */ +/* ;9: */ public boolean letsItemsOut(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) +/* <0: */ { +/* <1:89 */ return (aCoverVariable >= 6) || (aCoverVariable % 2 == 0); +/* <2: */ } +/* <3: */ +/* <4: */ public boolean alwaysLookConnected(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* <5: */ { +/* <6:94 */ return true; +/* <7: */ } +/* <8: */ +/* <9: */ public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* =0: */ { +/* =1:99 */ return this.mTickRate; +/* =2: */ } +/* =3: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.covers.GT_Cover_Conveyor + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/common/covers/GT_Cover_Crafting.java b/main/java/gregtech/common/covers/GT_Cover_Crafting.java new file mode 100644 index 0000000000..a8955b3626 --- /dev/null +++ b/main/java/gregtech/common/covers/GT_Cover_Crafting.java @@ -0,0 +1,41 @@ +/* 1: */ package gregtech.common.covers; +/* 2: */ +/* 3: */ import gregtech.api.interfaces.tileentity.ICoverable; +/* 4: */ import gregtech.api.util.GT_CoverBehavior; +/* 5: */ import net.minecraft.entity.player.EntityPlayer; +/* 6: */ import net.minecraft.entity.player.EntityPlayerMP; +/* 7: */ import net.minecraft.entity.player.InventoryPlayer; +/* 8: */ import net.minecraft.inventory.Container; +/* 9: */ import net.minecraft.inventory.ContainerWorkbench; +/* 10: */ import net.minecraft.network.NetHandlerPlayServer; +/* 11: */ import net.minecraft.network.play.server.S2DPacketOpenWindow; +/* 12: */ import net.minecraft.world.World; +/* 13: */ +/* 14: */ public class GT_Cover_Crafting +/* 15: */ extends GT_CoverBehavior +/* 16: */ { +/* 17: */ public boolean onCoverRightclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) +/* 18: */ { +/* 19:13 */ if ((aPlayer instanceof EntityPlayerMP)) +/* 20: */ { +/* 21:14 */ ((EntityPlayerMP)aPlayer).getNextWindowId(); +/* 22:15 */ ((EntityPlayerMP)aPlayer).playerNetServerHandler.sendPacket(new S2DPacketOpenWindow(((EntityPlayerMP)aPlayer).currentWindowId, 1, "Crafting", 9, true)); +/* 23:16 */ ((EntityPlayerMP)aPlayer).openContainer = new ContainerWorkbench(((EntityPlayerMP)aPlayer).inventory, ((EntityPlayerMP)aPlayer).worldObj, aTileEntity.getXCoord(), aTileEntity.getYCoord(), aTileEntity.getZCoord()) +/* 24: */ { +/* 25: */ public boolean canInteractWith(EntityPlayer par1EntityPlayer) +/* 26: */ { +/* 27:19 */ return true; +/* 28: */ } +/* 29:21 */ }; +/* 30:22 */ ((EntityPlayerMP)aPlayer).openContainer.windowId = ((EntityPlayerMP)aPlayer).currentWindowId; +/* 31:23 */ ((EntityPlayerMP)aPlayer).openContainer.addCraftingToCrafters((EntityPlayerMP)aPlayer); +/* 32: */ } +/* 33:25 */ return true; +/* 34: */ } +/* 35: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.covers.GT_Cover_Crafting + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/common/covers/GT_Cover_DoesWork.java b/main/java/gregtech/common/covers/GT_Cover_DoesWork.java new file mode 100644 index 0000000000..1d3fe79b6b --- /dev/null +++ b/main/java/gregtech/common/covers/GT_Cover_DoesWork.java @@ -0,0 +1,100 @@ +/* 1: */ package gregtech.common.covers; +/* 2: */ +/* 3: */ import gregtech.api.interfaces.tileentity.ICoverable; +/* 4: */ import gregtech.api.interfaces.tileentity.IMachineProgress; +/* 5: */ import gregtech.api.util.GT_CoverBehavior; +/* 6: */ import gregtech.api.util.GT_Utility; +/* 7: */ import net.minecraft.entity.player.EntityPlayer; +/* 8: */ import net.minecraftforge.fluids.Fluid; +/* 9: */ +/* 10: */ public class GT_Cover_DoesWork +/* 11: */ extends GT_CoverBehavior +/* 12: */ { +/* 13: */ public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) +/* 14: */ { +/* 15:13 */ if ((aTileEntity instanceof IMachineProgress)) +/* 16: */ { +/* 17:14 */ if (aCoverVariable < 2) +/* 18: */ { +/* 19:15 */ int tScale = ((IMachineProgress)aTileEntity).getMaxProgress() / 15; +/* 20:16 */ if ((tScale > 0) && (((IMachineProgress)aTileEntity).hasThingsToDo())) { +/* 21:17 */ aTileEntity.setOutputRedstoneSignal(aSide, aCoverVariable % 2 == 0 ? (byte)(((IMachineProgress)aTileEntity).getProgress() / tScale) : (byte)(15 - ((IMachineProgress)aTileEntity).getProgress() / tScale)); +/* 22: */ } else { +/* 23:19 */ aTileEntity.setOutputRedstoneSignal(aSide, (byte)(aCoverVariable % 2 == 0 ? 0 : 15)); +/* 24: */ } +/* 25: */ } +/* 26: */ else +/* 27: */ { +/* 28:22 */ aTileEntity.setOutputRedstoneSignal(aSide, (byte)((aCoverVariable % 2 == 0 ? 1 : 0) != (((IMachineProgress)aTileEntity).getMaxProgress() == 0 ? 1 : 0) ? 0 : 15)); +/* 29: */ } +/* 30: */ } +/* 31: */ else { +/* 32:25 */ aTileEntity.setOutputRedstoneSignal(aSide, (byte)0); +/* 33: */ } +/* 34:27 */ return aCoverVariable; +/* 35: */ } +/* 36: */ +/* 37: */ public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) +/* 38: */ { +/* 39:32 */ aCoverVariable = (aCoverVariable + 1) % 4; +/* 40:33 */ if (aCoverVariable == 0) { +/* 41:33 */ GT_Utility.sendChatToPlayer(aPlayer, "Normal"); +/* 42: */ } +/* 43:34 */ if (aCoverVariable == 1) { +/* 44:34 */ GT_Utility.sendChatToPlayer(aPlayer, "Inverted"); +/* 45: */ } +/* 46:35 */ if (aCoverVariable == 2) { +/* 47:35 */ GT_Utility.sendChatToPlayer(aPlayer, "Ready to work"); +/* 48: */ } +/* 49:36 */ if (aCoverVariable == 3) { +/* 50:36 */ GT_Utility.sendChatToPlayer(aPlayer, "Not ready to work"); +/* 51: */ } +/* 52:37 */ return aCoverVariable; +/* 53: */ } +/* 54: */ +/* 55: */ public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 56: */ { +/* 57:42 */ return true; +/* 58: */ } +/* 59: */ +/* 60: */ public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 61: */ { +/* 62:47 */ return true; +/* 63: */ } +/* 64: */ +/* 65: */ public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) +/* 66: */ { +/* 67:52 */ return true; +/* 68: */ } +/* 69: */ +/* 70: */ public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) +/* 71: */ { +/* 72:57 */ return true; +/* 73: */ } +/* 74: */ +/* 75: */ public boolean letsItemsIn(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) +/* 76: */ { +/* 77:62 */ return true; +/* 78: */ } +/* 79: */ +/* 80: */ public boolean letsItemsOut(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) +/* 81: */ { +/* 82:67 */ return true; +/* 83: */ } +/* 84: */ +/* 85: */ public boolean manipulatesSidedRedstoneOutput(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 86: */ { +/* 87:72 */ return true; +/* 88: */ } +/* 89: */ +/* 90: */ public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 91: */ { +/* 92:77 */ return 5; +/* 93: */ } +/* 94: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.covers.GT_Cover_DoesWork + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/common/covers/GT_Cover_Drain.java b/main/java/gregtech/common/covers/GT_Cover_Drain.java new file mode 100644 index 0000000000..5c8a3e910f --- /dev/null +++ b/main/java/gregtech/common/covers/GT_Cover_Drain.java @@ -0,0 +1,114 @@ +/* 1: */ package gregtech.common.covers; +/* 2: */ +/* 3: */ import gregtech.api.enums.Materials; +/* 4: */ import gregtech.api.interfaces.tileentity.ICoverable; +/* 5: */ import gregtech.api.interfaces.tileentity.IMachineProgress; +/* 6: */ import gregtech.api.util.GT_CoverBehavior; +/* 7: */ import gregtech.api.util.GT_Utility; +/* 8: */ import net.minecraft.block.Block; +/* 9: */ import net.minecraft.entity.player.EntityPlayer; +/* 10: */ import net.minecraft.init.Blocks; +/* 11: */ import net.minecraft.world.World; +/* 12: */ import net.minecraft.world.biome.BiomeGenBase; +/* 13: */ import net.minecraftforge.common.util.ForgeDirection; +/* 14: */ import net.minecraftforge.fluids.Fluid; +/* 15: */ import net.minecraftforge.fluids.FluidStack; +/* 16: */ import net.minecraftforge.fluids.IFluidBlock; +/* 17: */ import net.minecraftforge.fluids.IFluidHandler; +/* 18: */ +/* 19: */ public class GT_Cover_Drain +/* 20: */ extends GT_CoverBehavior +/* 21: */ { +/* 22: */ public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) +/* 23: */ { +/* 24:20 */ if ((aCoverVariable % 3 > 1) && ((aTileEntity instanceof IMachineProgress))) { +/* 25:20 */ if (((IMachineProgress)aTileEntity).isAllowedToWork() != aCoverVariable % 3 < 2) { +/* 26:20 */ return aCoverVariable; +/* 27: */ } +/* 28: */ } +/* 29:21 */ if (aSide != 6) +/* 30: */ { +/* 31:22 */ Block tBlock = aTileEntity.getBlockAtSide(aSide); +/* 32:23 */ if ((aCoverVariable < 3) && ((aTileEntity instanceof IFluidHandler))) +/* 33: */ { +/* 34:24 */ if ((aSide == 1) && +/* 35:25 */ (aTileEntity.getWorld().isRaining()) && +/* 36:26 */ (aTileEntity.getWorld().getPrecipitationHeight(aTileEntity.getXCoord(), aTileEntity.getZCoord()) - 2 < aTileEntity.getYCoord())) +/* 37: */ { +/* 38:27 */ int tAmount = (int)(aTileEntity.getBiome().rainfall * 10.0F); +/* 39:28 */ if (tAmount > 0) { +/* 40:29 */ ((IFluidHandler)aTileEntity).fill(ForgeDirection.getOrientation(aSide), Materials.Water.getFluid(aTileEntity.getWorld().isThundering() ? tAmount * 2 : tAmount), true); +/* 41: */ } +/* 42: */ } +/* 43:34 */ FluidStack tLiquid = null; +/* 44:35 */ if (tBlock != null) +/* 45: */ { +/* 46:36 */ if (((tBlock == Blocks.water) || (tBlock == Blocks.flowing_water)) && (aTileEntity.getMetaIDAtSide(aSide) == 0)) { +/* 47:37 */ tLiquid = Materials.Water.getFluid(1000L); +/* 48:38 */ } else if (((tBlock == Blocks.lava) || (tBlock == Blocks.flowing_lava)) && (aTileEntity.getMetaIDAtSide(aSide) == 0)) { +/* 49:39 */ tLiquid = Materials.Lava.getFluid(1000L); +/* 50:40 */ } else if ((tBlock instanceof IFluidBlock)) { +/* 51:41 */ tLiquid = ((IFluidBlock)tBlock).drain(aTileEntity.getWorld(), aTileEntity.getOffsetX(aSide, 1), aTileEntity.getOffsetY(aSide, 1), aTileEntity.getOffsetZ(aSide, 1), false); +/* 52: */ } +/* 53:43 */ if ((tLiquid != null) && (tLiquid.getFluid() != null) && ((aSide > 1) || ((aSide == 0) && (tLiquid.getFluid().getDensity() <= 0)) || ((aSide == 1) && (tLiquid.getFluid().getDensity() >= 0))) && +/* 54:44 */ (((IFluidHandler)aTileEntity).fill(ForgeDirection.getOrientation(aSide), tLiquid, false) == tLiquid.amount)) +/* 55: */ { +/* 56:45 */ ((IFluidHandler)aTileEntity).fill(ForgeDirection.getOrientation(aSide), tLiquid, true); +/* 57:46 */ aTileEntity.getWorld().setBlockToAir(aTileEntity.getXCoord() + ForgeDirection.getOrientation(aSide).offsetX, aTileEntity.getYCoord() + ForgeDirection.getOrientation(aSide).offsetY, aTileEntity.getZCoord() + ForgeDirection.getOrientation(aSide).offsetZ); +/* 58: */ } +/* 59: */ } +/* 60: */ } +/* 61:51 */ if ((aCoverVariable >= 3) && (tBlock != null) && ( +/* 62:52 */ (tBlock == Blocks.lava) || (tBlock == Blocks.flowing_lava) || (tBlock == Blocks.water) || (tBlock == Blocks.flowing_water) || ((tBlock instanceof IFluidBlock)))) { +/* 63:53 */ aTileEntity.getWorld().setBlock(aTileEntity.getOffsetX(aSide, 1), aTileEntity.getOffsetY(aSide, 1), aTileEntity.getOffsetZ(aSide, 1), Blocks.air, 0, 0); +/* 64: */ } +/* 65: */ } +/* 66:57 */ return aCoverVariable; +/* 67: */ } +/* 68: */ +/* 69: */ public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) +/* 70: */ { +/* 71:62 */ aCoverVariable = (aCoverVariable + 1) % 6; +/* 72:63 */ if (aCoverVariable == 0) { +/* 73:63 */ GT_Utility.sendChatToPlayer(aPlayer, "Import"); +/* 74: */ } +/* 75:64 */ if (aCoverVariable == 1) { +/* 76:64 */ GT_Utility.sendChatToPlayer(aPlayer, "Import (conditional)"); +/* 77: */ } +/* 78:65 */ if (aCoverVariable == 2) { +/* 79:65 */ GT_Utility.sendChatToPlayer(aPlayer, "Import (invert cond)"); +/* 80: */ } +/* 81:66 */ if (aCoverVariable == 3) { +/* 82:66 */ GT_Utility.sendChatToPlayer(aPlayer, "Keep Liquids Away"); +/* 83: */ } +/* 84:67 */ if (aCoverVariable == 4) { +/* 85:67 */ GT_Utility.sendChatToPlayer(aPlayer, "Keep Liquids Away (conditional)"); +/* 86: */ } +/* 87:68 */ if (aCoverVariable == 5) { +/* 88:68 */ GT_Utility.sendChatToPlayer(aPlayer, "Keep Liquids Away (invert cond)"); +/* 89: */ } +/* 90:69 */ return aCoverVariable; +/* 91: */ } +/* 92: */ +/* 93: */ public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) +/* 94: */ { +/* 95:74 */ if ((aCoverVariable > 1) && ((aTileEntity instanceof IMachineProgress))) {} +/* 96:74 */ return ((IMachineProgress)aTileEntity).isAllowedToWork() == aCoverVariable < 2; +/* 97: */ } +/* 98: */ +/* 99: */ public boolean alwaysLookConnected(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* :0: */ { +/* :1:79 */ return true; +/* :2: */ } +/* :3: */ +/* :4: */ public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* :5: */ { +/* :6:84 */ return aCoverVariable < 3 ? 50 : 1; +/* :7: */ } +/* :8: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.covers.GT_Cover_Drain + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/common/covers/GT_Cover_EUMeter.java b/main/java/gregtech/common/covers/GT_Cover_EUMeter.java new file mode 100644 index 0000000000..57902edab6 --- /dev/null +++ b/main/java/gregtech/common/covers/GT_Cover_EUMeter.java @@ -0,0 +1,144 @@ +/* 1: */ package gregtech.common.covers; +/* 2: */ +/* 3: */ import gregtech.api.interfaces.tileentity.ICoverable; +/* 4: */ import gregtech.api.util.GT_CoverBehavior; +/* 5: */ import gregtech.api.util.GT_Utility; +/* 6: */ import net.minecraft.entity.player.EntityPlayer; +/* 7: */ import net.minecraftforge.fluids.Fluid; +/* 8: */ +/* 9: */ public class GT_Cover_EUMeter +/* 10: */ extends GT_CoverBehavior +/* 11: */ { +/* 12: */ public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) +/* 13: */ { +/* 14: 12 */ long tScale = 0L; +/* 15: 13 */ if (aCoverVariable < 2) +/* 16: */ { +/* 17: 14 */ tScale = aTileEntity.getUniversalEnergyCapacity() / 15L; +/* 18: 15 */ if (tScale > 0L) { +/* 19: 16 */ aTileEntity.setOutputRedstoneSignal(aSide, aCoverVariable % 2 == 0 ? (byte)(int)(aTileEntity.getUniversalEnergyStored() / tScale) : (byte)(int)(15L - aTileEntity.getUniversalEnergyStored() / tScale)); +/* 20: */ } else { +/* 21: 18 */ aTileEntity.setOutputRedstoneSignal(aSide, (byte)(aCoverVariable % 2 == 0 ? 0 : 15)); +/* 22: */ } +/* 23: */ } +/* 24: 20 */ else if (aCoverVariable < 4) +/* 25: */ { +/* 26: 21 */ tScale = aTileEntity.getEUCapacity() / 15L; +/* 27: 22 */ if (tScale > 0L) { +/* 28: 23 */ aTileEntity.setOutputRedstoneSignal(aSide, aCoverVariable % 2 == 0 ? (byte)(int)(aTileEntity.getStoredEU() / tScale) : (byte)(int)(15L - aTileEntity.getStoredEU() / tScale)); +/* 29: */ } else { +/* 30: 25 */ aTileEntity.setOutputRedstoneSignal(aSide, (byte)(aCoverVariable % 2 == 0 ? 0 : 15)); +/* 31: */ } +/* 32: */ } +/* 33: 27 */ else if (aCoverVariable < 6) +/* 34: */ { +/* 35: 28 */ tScale = aTileEntity.getSteamCapacity() / 15L; +/* 36: 29 */ if (tScale > 0L) { +/* 37: 30 */ aTileEntity.setOutputRedstoneSignal(aSide, aCoverVariable % 2 == 0 ? (byte)(int)(aTileEntity.getStoredSteam() / tScale) : (byte)(int)(15L - aTileEntity.getStoredSteam() / tScale)); +/* 38: */ } else { +/* 39: 32 */ aTileEntity.setOutputRedstoneSignal(aSide, (byte)(aCoverVariable % 2 == 0 ? 0 : 15)); +/* 40: */ } +/* 41: */ } +/* 42: 34 */ else if (aCoverVariable < 8) +/* 43: */ { +/* 44: 35 */ tScale = aTileEntity.getInputVoltage() * aTileEntity.getInputAmperage() / 15L; +/* 45: 36 */ if (tScale > 0L) { +/* 46: 37 */ aTileEntity.setOutputRedstoneSignal(aSide, aCoverVariable % 2 == 0 ? (byte)(int)(aTileEntity.getAverageElectricInput() / tScale) : (byte)(int)(15L - aTileEntity.getAverageElectricInput() / tScale)); +/* 47: */ } else { +/* 48: 39 */ aTileEntity.setOutputRedstoneSignal(aSide, (byte)(aCoverVariable % 2 == 0 ? 0 : 15)); +/* 49: */ } +/* 50: */ } +/* 51: 41 */ else if (aCoverVariable < 10) +/* 52: */ { +/* 53: 42 */ tScale = aTileEntity.getOutputVoltage() * aTileEntity.getOutputAmperage() / 15L; +/* 54: 43 */ if (tScale > 0L) { +/* 55: 44 */ aTileEntity.setOutputRedstoneSignal(aSide, aCoverVariable % 2 == 0 ? (byte)(int)(aTileEntity.getAverageElectricOutput() / tScale) : (byte)(int)(15L - aTileEntity.getAverageElectricOutput() / tScale)); +/* 56: */ } else { +/* 57: 46 */ aTileEntity.setOutputRedstoneSignal(aSide, (byte)(aCoverVariable % 2 == 0 ? 0 : 15)); +/* 58: */ } +/* 59: */ } +/* 60: 49 */ return aCoverVariable; +/* 61: */ } +/* 62: */ +/* 63: */ public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) +/* 64: */ { +/* 65: 54 */ aCoverVariable = (aCoverVariable + 1) % 10; +/* 66: 55 */ if (aCoverVariable == 0) { +/* 67: 55 */ GT_Utility.sendChatToPlayer(aPlayer, "Normal Universal Storage"); +/* 68: */ } +/* 69: 56 */ if (aCoverVariable == 1) { +/* 70: 56 */ GT_Utility.sendChatToPlayer(aPlayer, "Inverted Universal Storage"); +/* 71: */ } +/* 72: 57 */ if (aCoverVariable == 2) { +/* 73: 57 */ GT_Utility.sendChatToPlayer(aPlayer, "Normal Electricity Storage"); +/* 74: */ } +/* 75: 58 */ if (aCoverVariable == 3) { +/* 76: 58 */ GT_Utility.sendChatToPlayer(aPlayer, "Inverted Electricity Storage"); +/* 77: */ } +/* 78: 59 */ if (aCoverVariable == 4) { +/* 79: 59 */ GT_Utility.sendChatToPlayer(aPlayer, "Normal Steam Storage"); +/* 80: */ } +/* 81: 60 */ if (aCoverVariable == 5) { +/* 82: 60 */ GT_Utility.sendChatToPlayer(aPlayer, "Inverted Steam Storage"); +/* 83: */ } +/* 84: 61 */ if (aCoverVariable == 6) { +/* 85: 61 */ GT_Utility.sendChatToPlayer(aPlayer, "Normal Average Electric Input"); +/* 86: */ } +/* 87: 62 */ if (aCoverVariable == 7) { +/* 88: 62 */ GT_Utility.sendChatToPlayer(aPlayer, "Inverted Average Electric Input"); +/* 89: */ } +/* 90: 63 */ if (aCoverVariable == 8) { +/* 91: 63 */ GT_Utility.sendChatToPlayer(aPlayer, "Normal Average Electric Output"); +/* 92: */ } +/* 93: 64 */ if (aCoverVariable == 9) { +/* 94: 64 */ GT_Utility.sendChatToPlayer(aPlayer, "Inverted Average Electric Output"); +/* 95: */ } +/* 96: 65 */ return aCoverVariable; +/* 97: */ } +/* 98: */ +/* 99: */ public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 100: */ { +/* 101: 70 */ return true; +/* 102: */ } +/* 103: */ +/* 104: */ public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 105: */ { +/* 106: 75 */ return true; +/* 107: */ } +/* 108: */ +/* 109: */ public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) +/* 110: */ { +/* 111: 80 */ return true; +/* 112: */ } +/* 113: */ +/* 114: */ public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) +/* 115: */ { +/* 116: 85 */ return true; +/* 117: */ } +/* 118: */ +/* 119: */ public boolean letsItemsIn(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) +/* 120: */ { +/* 121: 90 */ return true; +/* 122: */ } +/* 123: */ +/* 124: */ public boolean letsItemsOut(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) +/* 125: */ { +/* 126: 95 */ return true; +/* 127: */ } +/* 128: */ +/* 129: */ public boolean manipulatesSidedRedstoneOutput(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 130: */ { +/* 131:100 */ return true; +/* 132: */ } +/* 133: */ +/* 134: */ public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 135: */ { +/* 136:105 */ return 5; +/* 137: */ } +/* 138: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.covers.GT_Cover_EUMeter + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/common/covers/GT_Cover_EnergyOnly.java b/main/java/gregtech/common/covers/GT_Cover_EnergyOnly.java new file mode 100644 index 0000000000..0e5071f7db --- /dev/null +++ b/main/java/gregtech/common/covers/GT_Cover_EnergyOnly.java @@ -0,0 +1,108 @@ +/* 1: */ package gregtech.common.covers; +/* 2: */ +/* 3: */ import gregtech.api.interfaces.tileentity.ICoverable; +/* 4: */ import gregtech.api.interfaces.tileentity.IMachineProgress; +/* 5: */ import gregtech.api.util.GT_CoverBehavior; +/* 6: */ import gregtech.api.util.GT_Utility; +/* 7: */ import net.minecraft.entity.player.EntityPlayer; +/* 8: */ import net.minecraftforge.fluids.Fluid; +/* 9: */ +/* 10: */ public class GT_Cover_EnergyOnly +/* 11: */ extends GT_CoverBehavior +/* 12: */ { +/* 13: */ public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) +/* 14: */ { +/* 15:13 */ aCoverVariable = (aCoverVariable + 1) % 3; +/* 16:14 */ if (aCoverVariable == 0) { +/* 17:14 */ GT_Utility.sendChatToPlayer(aPlayer, "Allow"); +/* 18: */ } +/* 19:15 */ if (aCoverVariable == 1) { +/* 20:15 */ GT_Utility.sendChatToPlayer(aPlayer, "Allow (conditional)"); +/* 21: */ } +/* 22:16 */ if (aCoverVariable == 2) { +/* 23:16 */ GT_Utility.sendChatToPlayer(aPlayer, "Disallow (conditional)"); +/* 24: */ } +/* 25:17 */ return aCoverVariable; +/* 26: */ } +/* 27: */ +/* 28: */ public float getBlastProofLevel(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 29: */ { +/* 30:22 */ return 20.0F; +/* 31: */ } +/* 32: */ +/* 33: */ public boolean letsRedstoneGoIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 34: */ { +/* 35:27 */ return false; +/* 36: */ } +/* 37: */ +/* 38: */ public boolean letsRedstoneGoOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 39: */ { +/* 40:32 */ return false; +/* 41: */ } +/* 42: */ +/* 43: */ public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 44: */ { +/* 45:37 */ if ((aCoverVariable > 1) && ((aTileEntity instanceof IMachineProgress))) { +/* 46:37 */ if (((IMachineProgress)aTileEntity).isAllowedToWork() != aCoverVariable < 2) { +/* 47:37 */ return false; +/* 48: */ } +/* 49: */ } +/* 50:38 */ return true; +/* 51: */ } +/* 52: */ +/* 53: */ public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 54: */ { +/* 55:43 */ if ((aCoverVariable > 1) && ((aTileEntity instanceof IMachineProgress))) { +/* 56:43 */ if (((IMachineProgress)aTileEntity).isAllowedToWork() != aCoverVariable < 2) { +/* 57:43 */ return false; +/* 58: */ } +/* 59: */ } +/* 60:44 */ return true; +/* 61: */ } +/* 62: */ +/* 63: */ public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) +/* 64: */ { +/* 65:49 */ return false; +/* 66: */ } +/* 67: */ +/* 68: */ public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) +/* 69: */ { +/* 70:54 */ return false; +/* 71: */ } +/* 72: */ +/* 73: */ public boolean letsItemsIn(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) +/* 74: */ { +/* 75:59 */ return false; +/* 76: */ } +/* 77: */ +/* 78: */ public boolean letsItemsOut(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) +/* 79: */ { +/* 80:64 */ return false; +/* 81: */ } +/* 82: */ +/* 83: */ public boolean isGUIClickable(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 84: */ { +/* 85:69 */ return false; +/* 86: */ } +/* 87: */ +/* 88: */ public boolean manipulatesSidedRedstoneOutput(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 89: */ { +/* 90:74 */ return false; +/* 91: */ } +/* 92: */ +/* 93: */ public boolean onCoverRightclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) +/* 94: */ { +/* 95:79 */ return false; +/* 96: */ } +/* 97: */ +/* 98: */ public boolean onCoverRemoval(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, boolean aForced) +/* 99: */ { +/* :0:84 */ return true; +/* :1: */ } +/* :2: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.covers.GT_Cover_EnergyOnly + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/common/covers/GT_Cover_ItemMeter.java b/main/java/gregtech/common/covers/GT_Cover_ItemMeter.java new file mode 100644 index 0000000000..92c72eead7 --- /dev/null +++ b/main/java/gregtech/common/covers/GT_Cover_ItemMeter.java @@ -0,0 +1,99 @@ +/* 1: */ package gregtech.common.covers; +/* 2: */ +/* 3: */ import gregtech.api.interfaces.tileentity.ICoverable; +/* 4: */ import gregtech.api.util.GT_CoverBehavior; +/* 5: */ import gregtech.api.util.GT_Utility; +/* 6: */ import net.minecraft.entity.player.EntityPlayer; +/* 7: */ import net.minecraft.item.ItemStack; +/* 8: */ import net.minecraftforge.fluids.Fluid; +/* 9: */ +/* 10: */ public class GT_Cover_ItemMeter +/* 11: */ extends GT_CoverBehavior +/* 12: */ { +/* 13: */ public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) +/* 14: */ { +/* 15: */ int[] tSlots; +/* 17:14 */ if (aCoverVariable < 2) { +/* 18:15 */ tSlots = aTileEntity.getAccessibleSlotsFromSide(aSide); +/* 19: */ } else { +/* 20:17 */ tSlots = new int[] { aCoverVariable - 2 }; +/* 21: */ } +/* 22:19 */ int tAll = 0;int tFull = 0; +/* 23:20 */ for (int i : tSlots) { +/* 24:21 */ if ((i > 0) && (i < aTileEntity.getSizeInventory())) +/* 25: */ { +/* 26:22 */ tAll += 64; +/* 27:23 */ ItemStack tStack = aTileEntity.getStackInSlot(i); +/* 28:24 */ if (tStack != null) { +/* 29:25 */ tFull += tStack.stackSize * 64 / tStack.getMaxStackSize(); +/* 30: */ } +/* 31: */ } +/* 32: */ } +/* 33:29 */ tAll /= 14; +/* 34:30 */ if (tAll > 0) { +/* 35:31 */ aTileEntity.setOutputRedstoneSignal(aSide, aCoverVariable != 1 ? 0 : tFull > 0 ? (byte)(tFull / tAll + 1) : (byte)(15 - (tFull > 0 ? tFull / tAll + 1 : 0))); +/* 36: */ } else { +/* 37:33 */ aTileEntity.setOutputRedstoneSignal(aSide, (byte)(aCoverVariable != 1 ? 0 : 15)); +/* 38: */ } +/* 39:35 */ return aCoverVariable; +/* 40: */ } +/* 41: */ +/* 42: */ public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) +/* 43: */ { +/* 44:40 */ aCoverVariable = (aCoverVariable + 1) % (2 + aTileEntity.getSizeInventory()); +/* 45:41 */ if (aCoverVariable == 0) { +/* 46:41 */ GT_Utility.sendChatToPlayer(aPlayer, "Normal"); +/* 47:42 */ } else if (aCoverVariable == 1) { +/* 48:42 */ GT_Utility.sendChatToPlayer(aPlayer, "Inverted"); +/* 49: */ } else { +/* 50:43 */ GT_Utility.sendChatToPlayer(aPlayer, "Slot: " + (aCoverVariable - 2)); +/* 51: */ } +/* 52:44 */ return aCoverVariable; +/* 53: */ } +/* 54: */ +/* 55: */ public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 56: */ { +/* 57:49 */ return true; +/* 58: */ } +/* 59: */ +/* 60: */ public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 61: */ { +/* 62:54 */ return true; +/* 63: */ } +/* 64: */ +/* 65: */ public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) +/* 66: */ { +/* 67:59 */ return true; +/* 68: */ } +/* 69: */ +/* 70: */ public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) +/* 71: */ { +/* 72:64 */ return true; +/* 73: */ } +/* 74: */ +/* 75: */ public boolean letsItemsIn(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) +/* 76: */ { +/* 77:69 */ return true; +/* 78: */ } +/* 79: */ +/* 80: */ public boolean letsItemsOut(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) +/* 81: */ { +/* 82:74 */ return true; +/* 83: */ } +/* 84: */ +/* 85: */ public boolean manipulatesSidedRedstoneOutput(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 86: */ { +/* 87:79 */ return true; +/* 88: */ } +/* 89: */ +/* 90: */ public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 91: */ { +/* 92:84 */ return 5; +/* 93: */ } +/* 94: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.covers.GT_Cover_ItemMeter + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/common/covers/GT_Cover_Lens.java b/main/java/gregtech/common/covers/GT_Cover_Lens.java new file mode 100644 index 0000000000..157e93f6d4 --- /dev/null +++ b/main/java/gregtech/common/covers/GT_Cover_Lens.java @@ -0,0 +1,26 @@ +/* 1: */ package gregtech.common.covers; +/* 2: */ +/* 3: */ import gregtech.api.interfaces.tileentity.ICoverable; +/* 4: */ import gregtech.api.util.GT_CoverBehavior; +/* 5: */ +/* 6: */ public class GT_Cover_Lens +/* 7: */ extends GT_CoverBehavior +/* 8: */ { +/* 9: */ private final byte mColor; +/* 10: */ +/* 11: */ public GT_Cover_Lens(byte aColor) +/* 12: */ { +/* 13:10 */ this.mColor = aColor; +/* 14: */ } +/* 15: */ +/* 16: */ public byte getLensColor(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 17: */ { +/* 18:15 */ return this.mColor; +/* 19: */ } +/* 20: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.covers.GT_Cover_Lens + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/common/covers/GT_Cover_LiquidMeter.java b/main/java/gregtech/common/covers/GT_Cover_LiquidMeter.java new file mode 100644 index 0000000000..7ee8b72384 --- /dev/null +++ b/main/java/gregtech/common/covers/GT_Cover_LiquidMeter.java @@ -0,0 +1,103 @@ +/* 1: */ package gregtech.common.covers; +/* 2: */ +/* 3: */ import gregtech.api.interfaces.tileentity.ICoverable; +/* 4: */ import gregtech.api.util.GT_CoverBehavior; +/* 5: */ import gregtech.api.util.GT_Utility; +/* 6: */ import net.minecraft.entity.player.EntityPlayer; +/* 7: */ import net.minecraftforge.common.util.ForgeDirection; +/* 8: */ import net.minecraftforge.fluids.Fluid; +/* 9: */ import net.minecraftforge.fluids.FluidStack; +/* 10: */ import net.minecraftforge.fluids.FluidTankInfo; +/* 11: */ import net.minecraftforge.fluids.IFluidHandler; +/* 12: */ +/* 13: */ public class GT_Cover_LiquidMeter +/* 14: */ extends GT_CoverBehavior +/* 15: */ { +/* 16: */ public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) +/* 17: */ { +/* 18:16 */ if ((aTileEntity instanceof IFluidHandler)) +/* 19: */ { +/* 20:17 */ FluidTankInfo[] tTanks = ((IFluidHandler)aTileEntity).getTankInfo(ForgeDirection.UNKNOWN); +/* 21:18 */ long tAll = 0L;long tFull = 0L; +/* 22:19 */ if (tTanks != null) { +/* 23:19 */ for (FluidTankInfo tTank : tTanks) { +/* 24:19 */ if (tTank != null) +/* 25: */ { +/* 26:20 */ tAll += tTank.capacity; +/* 27:21 */ FluidStack tLiquid = tTank.fluid; +/* 28:22 */ if (tLiquid != null) { +/* 29:23 */ tFull += tLiquid.amount; +/* 30: */ } +/* 31: */ } +/* 32: */ } +/* 33: */ } +/* 34:26 */ tAll /= 14L; +/* 35:27 */ if (tAll > 0L) { +/* 36:28 */ aTileEntity.setOutputRedstoneSignal(aSide, aCoverVariable == 0 ? 0 : tFull > 0L ? (byte)(int)(tFull / tAll + 1L) : (byte)(int)(15L - (tFull > 0L ? tFull / tAll + 1L : 0L))); +/* 37: */ } else { +/* 38:30 */ aTileEntity.setOutputRedstoneSignal(aSide, (byte)(aCoverVariable == 0 ? 0 : 15)); +/* 39: */ } +/* 40: */ } +/* 41: */ else +/* 42: */ { +/* 43:33 */ aTileEntity.setOutputRedstoneSignal(aSide, (byte)0); +/* 44: */ } +/* 45:35 */ return aCoverVariable; +/* 46: */ } +/* 47: */ +/* 48: */ public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) +/* 49: */ { +/* 50:40 */ if (aCoverVariable == 0) { +/* 51:41 */ GT_Utility.sendChatToPlayer(aPlayer, "Inverted"); +/* 52: */ } else { +/* 53:43 */ GT_Utility.sendChatToPlayer(aPlayer, "Normal"); +/* 54: */ } +/* 55:44 */ return aCoverVariable == 0 ? 1 : 0; +/* 56: */ } +/* 57: */ +/* 58: */ public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 59: */ { +/* 60:49 */ return true; +/* 61: */ } +/* 62: */ +/* 63: */ public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 64: */ { +/* 65:54 */ return true; +/* 66: */ } +/* 67: */ +/* 68: */ public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) +/* 69: */ { +/* 70:59 */ return true; +/* 71: */ } +/* 72: */ +/* 73: */ public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) +/* 74: */ { +/* 75:64 */ return true; +/* 76: */ } +/* 77: */ +/* 78: */ public boolean letsItemsIn(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) +/* 79: */ { +/* 80:69 */ return true; +/* 81: */ } +/* 82: */ +/* 83: */ public boolean letsItemsOut(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) +/* 84: */ { +/* 85:74 */ return true; +/* 86: */ } +/* 87: */ +/* 88: */ public boolean manipulatesSidedRedstoneOutput(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 89: */ { +/* 90:79 */ return true; +/* 91: */ } +/* 92: */ +/* 93: */ public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) +/* 94: */ { +/* 95:84 */ return 5; +/* 96: */ } +/* 97: */ } + + +/* Location: F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar + * Qualified Name: gregtech.common.covers.GT_Cover_LiquidMeter + * JD-Core Version: 0.7.0.1 + */ \ No newline at end of file diff --git a/main/java/gregtech/common/covers/GT_Cover_Pump.java b/main/java/gregtech/common/covers/GT_Cover_Pump.java new file mode 100644 index 0000000000..e3ec8674e6 --- /dev/null +++ b/main/java/gregtech/common/covers/GT_Cover_Pump.java @@ -0,0 +1,193 @@ +/* 1: */ package gregtech.common.covers; +/* 2: */ +/* 3: */ import gregtech.api.interfaces.tileentity.ICoverable; +/* 4: */ import gregtech.api.interfaces.tileentity.IMachineProgress; +/* 5: */ import gregtech.api.util.GT_CoverBehavior; +/* 6: */ import gregtech.api.util.GT_Utility; +/* 7: */ import net.minecraft.entity.player.EntityPlayer; +/* 8: */ import net.minecraftforge.common.util.ForgeDirection; +/* 9: */ import net.minecraftforge.fluids.Fluid; +/* 10: */ import net.minecraftforge.fluids.FluidStack; +/* 11: */ import net.minecraftforge.fluids.IFluidHandler; +/* 12: */ +/* 13: */ public class GT_Cover_Pump +/* 14: */ extends GT_CoverBehavior +/* 15: */ { +/* 16: */ public final int mTransferRate; +/* 17: */ +/* 18: */ public GT_Cover_Pump(int aTransferRate) +/* 19: */ { +/* 20: 18 */ this.mTransferRate = aTransferRate; +/* 21: */ } +/* 22: */ +/* 23: */ public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) +/* 24: */ { +/* 25: 23 */ if ((aCoverVariable % 6 > 1) && ((aTileEntity instanceof IMachineProgress))) { +/* 26: 23 */ if (((IMachineProgress)aTileEntity).isAllowedToWork() != aCoverVariable % 6 < 4) { +/* 27: 23 */ return aCoverVariable; +/* 28: */ } +/* 29: */ } +/* 30: 24 */ if ((aTileEntity instanceof IFluidHandler)) +/* 31: */ { +/* 32: 25 */ IFluidHandler tTank2 = aTileEntity.getITankContainerAtSide(aSide); +/* 33: 26 */ if (tTank2 != null) +/* 34: */ { +/* 35: 27 */ aTileEntity.decreaseStoredEnergyUnits(GT_Utility.getTier(this.mTransferRate), true); +/* 36: 28 */ IFluidHandler tTank1 = (IFluidHandler)aTileEntity; +/* 37: 29 */ if (aCoverVariable % 2 == 0) +/* 38: */ { +/* 39: 30 */ FluidStack tLiquid = tTank1.drain(ForgeDirection.getOrientation(aSide), this.mTransferRate, false); +/* 40: 31 */ if (tLiquid != null) +/* 41: */ { +/* 42: 32 */ tLiquid = tLiquid.copy(); +/* 43: 33 */ tLiquid.amount = tTank2.fill(ForgeDirection.getOrientation(aSide).getOpposite(), tLiquid, false); +/* 44: 34 */ if (tLiquid.amount > 0) { +/* 45: 35 */ if (((aCoverVariable % 2 != 1) || (aSide != 1)) && ((aCoverVariable % 2 != 0) || (aSide != 0)) && (aTileEntity.getUniversalEnergyCapacity() >= Math.min(1, tLiquid.amount / 10))) +/* 46: */ { +/* 47: 36 */ if (aTileEntity.isUniversalEnergyStored(Math.min(1, tLiquid.amount / 10))) +/* 48: */ { +/* 49: 37 */ aTileEntity.decreaseStoredEnergyUnits(Math.min(1, tLiquid.amount / 10), true); +/* 50: 38 */ tTank2.fill(ForgeDirection.getOrientation(aSide).getOpposite(), tTank1.drain(ForgeDirecti