From 09add3e8ac3be54b1e6c068e87d4fb5143c6d785 Mon Sep 17 00:00:00 2001 From: Dream-Master Date: Tue, 21 Jun 2016 18:50:29 +0200 Subject: even with Blood asp experimental branch --- .../java/gregtech/common/covers/GT_Cover_Arm.java | 95 ++++++++++++++ .../common/covers/GT_Cover_Blastproof.java | 21 +++ .../common/covers/GT_Cover_ControlsWork.java | 73 +++++++++++ .../gregtech/common/covers/GT_Cover_Conveyor.java | 96 ++++++++++++++ .../gregtech/common/covers/GT_Cover_Crafting.java | 26 ++++ .../gregtech/common/covers/GT_Cover_DoesWork.java | 73 +++++++++++ .../gregtech/common/covers/GT_Cover_Drain.java | 87 +++++++++++++ .../gregtech/common/covers/GT_Cover_EUMeter.java | 144 +++++++++++++++++++++ .../common/covers/GT_Cover_EnergyOnly.java | 83 ++++++++++++ .../common/covers/GT_Cover_FluidRegulator.java | 129 ++++++++++++++++++ .../common/covers/GT_Cover_Fluidfilter.java | 74 +++++++++++ .../gregtech/common/covers/GT_Cover_ItemMeter.java | 79 +++++++++++ .../java/gregtech/common/covers/GT_Cover_Lens.java | 17 +++ .../common/covers/GT_Cover_LiquidMeter.java | 83 ++++++++++++ .../common/covers/GT_Cover_NeedMaintainance.java | 96 ++++++++++++++ .../common/covers/GT_Cover_PlayerDetector.java | 98 ++++++++++++++ .../java/gregtech/common/covers/GT_Cover_Pump.java | 139 ++++++++++++++++++++ .../common/covers/GT_Cover_RedstoneConductor.java | 66 ++++++++++ .../covers/GT_Cover_RedstoneReceiverExternal.java | 20 +++ .../covers/GT_Cover_RedstoneReceiverInternal.java | 19 +++ .../common/covers/GT_Cover_RedstoneSignalizer.java | 66 ++++++++++ .../GT_Cover_RedstoneTransmitterExternal.java | 20 +++ .../GT_Cover_RedstoneTransmitterInternal.java | 24 ++++ .../covers/GT_Cover_RedstoneWirelessBase.java | 81 ++++++++++++ .../gregtech/common/covers/GT_Cover_Screen.java | 65 ++++++++++ .../gregtech/common/covers/GT_Cover_Shutter.java | 67 ++++++++++ .../common/covers/GT_Cover_SolarPanel.java | 32 +++++ .../java/gregtech/common/covers/GT_Cover_Vent.java | 34 +++++ 28 files changed, 1907 insertions(+) create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_Arm.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_Blastproof.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_ControlsWork.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_Conveyor.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_Crafting.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_DoesWork.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_Drain.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_EUMeter.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_EnergyOnly.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_FluidRegulator.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_Fluidfilter.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_ItemMeter.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_Lens.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_LiquidMeter.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_NeedMaintainance.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_PlayerDetector.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_Pump.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_RedstoneConductor.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_RedstoneReceiverExternal.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_RedstoneReceiverInternal.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_RedstoneSignalizer.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_RedstoneTransmitterExternal.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_RedstoneTransmitterInternal.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_RedstoneWirelessBase.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_Screen.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_Shutter.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_SolarPanel.java create mode 100644 src/main/java/gregtech/common/covers/GT_Cover_Vent.java (limited to 'src/main/java/gregtech/common/covers') diff --git a/src/main/java/gregtech/common/covers/GT_Cover_Arm.java b/src/main/java/gregtech/common/covers/GT_Cover_Arm.java new file mode 100644 index 0000000000..7206bedccc --- /dev/null +++ b/src/main/java/gregtech/common/covers/GT_Cover_Arm.java @@ -0,0 +1,95 @@ +package gregtech.common.covers; + +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.interfaces.tileentity.IMachineProgress; +import gregtech.api.util.GT_CoverBehavior; +import gregtech.api.util.GT_Utility; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.fluids.Fluid; + +public class GT_Cover_Arm + extends GT_CoverBehavior { + public final int mTickRate; + + public GT_Cover_Arm(int aTickRate) { + this.mTickRate = aTickRate; + } + + public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) { + if ((aCoverVariable == 0) || (((aTileEntity instanceof IMachineProgress)) && (!((IMachineProgress) aTileEntity).isAllowedToWork()))) { + return aCoverVariable; + } + TileEntity tTileEntity = aTileEntity.getTileEntityAtSide(aSide); + //aTileEntity.decreaseStoredEnergyUnits(1L, true); + if (aTileEntity.getUniversalEnergyCapacity() >= 128L) { + if (aTileEntity.isUniversalEnergyStored(256L)) { + 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); + } + } else { + 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); + } + return aCoverVariable; + } + + public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { + if (GT_Utility.getClickedFacingCoords(aSide, aX, aY, aZ)[0] >= 0.5F) { + aCoverVariable += 16; + } else { + aCoverVariable -= 16; + } + GT_Utility.sendChatToPlayer(aPlayer, (aCoverVariable > 0 ? "Puts out into adjacent Slot #" : "Grabs in for own Slot #") + (Math.abs(aCoverVariable) - 1)); + return aCoverVariable; + } + + public boolean onCoverRightclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { + if (GT_Utility.getClickedFacingCoords(aSide, aX, aY, aZ)[0] >= 0.5F) { + aCoverVariable++; + } else { + aCoverVariable--; + } + GT_Utility.sendChatToPlayer(aPlayer, (aCoverVariable > 0 ? "Puts out into adjacent Slot #" : "Grabs in for own Slot #") + (Math.abs(aCoverVariable) - 1)); + aTileEntity.setCoverDataAtSide(aSide, aCoverVariable); + return true; + } + + public boolean letsRedstoneGoIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public boolean letsRedstoneGoOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return true; + } + + public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return true; + } + + public boolean letsItemsIn(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + return true; + } + + public boolean letsItemsOut(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + return true; + } + + public boolean alwaysLookConnected(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return this.mTickRate; + } +} diff --git a/src/main/java/gregtech/common/covers/GT_Cover_Blastproof.java b/src/main/java/gregtech/common/covers/GT_Cover_Blastproof.java new file mode 100644 index 0000000000..77647a43d8 --- /dev/null +++ b/src/main/java/gregtech/common/covers/GT_Cover_Blastproof.java @@ -0,0 +1,21 @@ +package gregtech.common.covers; + +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.util.GT_CoverBehavior; + +public class GT_Cover_Blastproof + extends GT_CoverBehavior { + private final float mLevel; + + public GT_Cover_Blastproof(float aLevel) { + this.mLevel = aLevel; + } + + public float getBlastProofLevel(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return this.mLevel; + } + + public boolean isSimpleCover() { + return true; + } +} diff --git a/src/main/java/gregtech/common/covers/GT_Cover_ControlsWork.java b/src/main/java/gregtech/common/covers/GT_Cover_ControlsWork.java new file mode 100644 index 0000000000..65ba326625 --- /dev/null +++ b/src/main/java/gregtech/common/covers/GT_Cover_ControlsWork.java @@ -0,0 +1,73 @@ +package gregtech.common.covers; + +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.interfaces.tileentity.IMachineProgress; +import gregtech.api.util.GT_CoverBehavior; +import gregtech.api.util.GT_Utility; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraftforge.fluids.Fluid; + +public class GT_Cover_ControlsWork + extends GT_CoverBehavior { + public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) { + if (aTileEntity instanceof IMachineProgress) { + if ((aInputRedstone > 0) == (aCoverVariable == 0) && aCoverVariable != 2) + ((IMachineProgress) aTileEntity).enableWorking(); + else + ((IMachineProgress) aTileEntity).disableWorking(); + ((IMachineProgress) aTileEntity).setWorkDataValue(aInputRedstone); + } + return aCoverVariable; + } + + public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return true; + } + + public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return true; + } + + public boolean letsItemsIn(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + return true; + } + + public boolean letsItemsOut(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + return true; + } + + public boolean onCoverRemoval(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, boolean aForced) { + if ((aTileEntity instanceof IMachineProgress)) { + ((IMachineProgress) aTileEntity).enableWorking(); + ((IMachineProgress) aTileEntity).setWorkDataValue((byte) 0); + } + return true; + } + + public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { + aCoverVariable = (aCoverVariable + (aPlayer.isSneaking()? -1 : 1)) % 3; + if(aCoverVariable <0){aCoverVariable = 2;} + if (aCoverVariable == 0) { + GT_Utility.sendChatToPlayer(aPlayer, "Normal"); + } + if (aCoverVariable == 1) { + GT_Utility.sendChatToPlayer(aPlayer, "Inverted"); + } + if (aCoverVariable == 2) { + GT_Utility.sendChatToPlayer(aPlayer, "No Work at all"); + } + return aCoverVariable; + } + + public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return 1; + } +} diff --git a/src/main/java/gregtech/common/covers/GT_Cover_Conveyor.java b/src/main/java/gregtech/common/covers/GT_Cover_Conveyor.java new file mode 100644 index 0000000000..8467506d97 --- /dev/null +++ b/src/main/java/gregtech/common/covers/GT_Cover_Conveyor.java @@ -0,0 +1,96 @@ +package gregtech.common.covers; + +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.interfaces.tileentity.IMachineProgress; +import gregtech.api.util.GT_CoverBehavior; +import gregtech.api.util.GT_Utility; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.fluids.Fluid; + +public class GT_Cover_Conveyor + extends GT_CoverBehavior { + public final int mTickRate; + + public GT_Cover_Conveyor(int aTickRate) { + this.mTickRate = aTickRate; + } + + public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) { + if ((aCoverVariable % 6 > 1) && ((aTileEntity instanceof IMachineProgress))) { + if (((IMachineProgress) aTileEntity).isAllowedToWork() != aCoverVariable % 6 < 4) { + return aCoverVariable; + } + } + TileEntity tTileEntity = aTileEntity.getTileEntityAtSide(aSide); + //aTileEntity.decreaseStoredEnergyUnits(1L, true); + if (((aCoverVariable % 2 != 1) || (aSide != 1)) && ((aCoverVariable % 2 != 0) || (aSide != 0)) && (aTileEntity.getUniversalEnergyCapacity() >= 128L)) { + if (aTileEntity.isUniversalEnergyStored(256L)) { + 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); + } + } else { + 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); + } + return aCoverVariable; + } + + public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { + aCoverVariable = (aCoverVariable + (aPlayer.isSneaking()? -1 : 1)) % 12; + if(aCoverVariable <0){aCoverVariable = 11;} + switch(aCoverVariable) { + case 0: GT_Utility.sendChatToPlayer(aPlayer, "Export"); break; + case 1: GT_Utility.sendChatToPlayer(aPlayer, "Import"); break; + case 2: GT_Utility.sendChatToPlayer(aPlayer, "Export (conditional)"); break; + case 3: GT_Utility.sendChatToPlayer(aPlayer, "Import (conditional)"); break; + case 4: GT_Utility.sendChatToPlayer(aPlayer, "Export (invert cond)"); break; + case 5: GT_Utility.sendChatToPlayer(aPlayer, "Import (invert cond)"); break; + case 6: GT_Utility.sendChatToPlayer(aPlayer, "Export allow Input"); break; + case 7: GT_Utility.sendChatToPlayer(aPlayer, "Import allow Output"); break; + case 8: GT_Utility.sendChatToPlayer(aPlayer, "Export allow Input (conditional)"); break; + case 9: GT_Utility.sendChatToPlayer(aPlayer, "Import allow Output (conditional)"); break; + case 10: GT_Utility.sendChatToPlayer(aPlayer, "Export allow Input (invert cond)"); break; + case 11: GT_Utility.sendChatToPlayer(aPlayer, "Import allow Output (invert cond)"); break; + } + return aCoverVariable; + } + + public boolean letsRedstoneGoIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public boolean letsRedstoneGoOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return true; + } + + public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return true; + } + + public boolean letsItemsIn(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + return (aCoverVariable >= 6) || (aCoverVariable % 2 != 0); + } + + public boolean letsItemsOut(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + return (aCoverVariable >= 6) || (aCoverVariable % 2 == 0); + } + + public boolean alwaysLookConnected(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return this.mTickRate; + } +} diff --git a/src/main/java/gregtech/common/covers/GT_Cover_Crafting.java b/src/main/java/gregtech/common/covers/GT_Cover_Crafting.java new file mode 100644 index 0000000000..adc84a0e94 --- /dev/null +++ b/src/main/java/gregtech/common/covers/GT_Cover_Crafting.java @@ -0,0 +1,26 @@ +package gregtech.common.covers; + +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.util.GT_CoverBehavior; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.inventory.ContainerWorkbench; +import net.minecraft.network.play.server.S2DPacketOpenWindow; + +public class GT_Cover_Crafting + extends GT_CoverBehavior { + public boolean onCoverRightclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { + if ((aPlayer instanceof EntityPlayerMP)) { + ((EntityPlayerMP) aPlayer).getNextWindowId(); + ((EntityPlayerMP) aPlayer).playerNetServerHandler.sendPacket(new S2DPacketOpenWindow(((EntityPlayerMP) aPlayer).currentWindowId, 1, "Crafting", 9, true)); + ((EntityPlayerMP) aPlayer).openContainer = new ContainerWorkbench(((EntityPlayerMP) aPlayer).inventory, ((EntityPlayerMP) aPlayer).worldObj, aTileEntity.getXCoord(), aTileEntity.getYCoord(), aTileEntity.getZCoord()) { + public boolean canInteractWith(EntityPlayer par1EntityPlayer) { + return true; + } + }; + ((EntityPlayerMP) aPlayer).openContainer.windowId = ((EntityPlayerMP) aPlayer).currentWindowId; + ((EntityPlayerMP) aPlayer).openContainer.addCraftingToCrafters((EntityPlayerMP) aPlayer); + } + return true; + } +} diff --git a/src/main/java/gregtech/common/covers/GT_Cover_DoesWork.java b/src/main/java/gregtech/common/covers/GT_Cover_DoesWork.java new file mode 100644 index 0000000000..08acc6faa1 --- /dev/null +++ b/src/main/java/gregtech/common/covers/GT_Cover_DoesWork.java @@ -0,0 +1,73 @@ +package gregtech.common.covers; + +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.interfaces.tileentity.IMachineProgress; +import gregtech.api.util.GT_CoverBehavior; +import gregtech.api.util.GT_Utility; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraftforge.fluids.Fluid; + +public class GT_Cover_DoesWork + extends GT_CoverBehavior { + public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) { + if ((aTileEntity instanceof IMachineProgress)) { + if (aCoverVariable < 2) { + int tScale = ((IMachineProgress) aTileEntity).getMaxProgress() / 15; + if ((tScale > 0) && (((IMachineProgress) aTileEntity).hasThingsToDo())) { + aTileEntity.setOutputRedstoneSignal(aSide, aCoverVariable % 2 == 0 ? (byte) (((IMachineProgress) aTileEntity).getProgress() / tScale) : (byte) (15 - ((IMachineProgress) aTileEntity).getProgress() / tScale)); + } else { + aTileEntity.setOutputRedstoneSignal(aSide, (byte) (aCoverVariable % 2 == 0 ? 0 : 15)); + } + } else { + aTileEntity.setOutputRedstoneSignal(aSide, (byte) ((aCoverVariable % 2 == 0 ? 1 : 0) != (((IMachineProgress) aTileEntity).getMaxProgress() == 0 ? 1 : 0) ? 0 : 15)); + } + } else { + aTileEntity.setOutputRedstoneSignal(aSide, (byte) 0); + } + return aCoverVariable; + } + + public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { + aCoverVariable = (aCoverVariable + (aPlayer.isSneaking()? -1 : 1)) % 4; + if(aCoverVariable <0){aCoverVariable = 3;} + switch(aCoverVariable) { + case 0: GT_Utility.sendChatToPlayer(aPlayer, "Normal"); break; + case 1: GT_Utility.sendChatToPlayer(aPlayer, "Inverted"); break; + case 2: GT_Utility.sendChatToPlayer(aPlayer, "Ready to work"); break; + case 3: GT_Utility.sendChatToPlayer(aPlayer, "Not ready to work"); break; + } + return aCoverVariable; + } + + public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return true; + } + + public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return true; + } + + public boolean letsItemsIn(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + return true; + } + + public boolean letsItemsOut(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + return true; + } + + public boolean manipulatesSidedRedstoneOutput(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return 5; + } +} diff --git a/src/main/java/gregtech/common/covers/GT_Cover_Drain.java b/src/main/java/gregtech/common/covers/GT_Cover_Drain.java new file mode 100644 index 0000000000..5aaef6fc2f --- /dev/null +++ b/src/main/java/gregtech/common/covers/GT_Cover_Drain.java @@ -0,0 +1,87 @@ +package gregtech.common.covers; + +import gregtech.api.enums.Materials; +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.interfaces.tileentity.IMachineProgress; +import gregtech.api.util.GT_CoverBehavior; +import gregtech.api.util.GT_Utility; +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.IFluidBlock; +import net.minecraftforge.fluids.IFluidHandler; + +public class GT_Cover_Drain + extends GT_CoverBehavior { + public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) { + if ((aCoverVariable % 3 > 1) && ((aTileEntity instanceof IMachineProgress))) { + if (((IMachineProgress) aTileEntity).isAllowedToWork() != aCoverVariable % 3 < 2) { + return aCoverVariable; + } + } + if (aSide != 6) { + Block tBlock = aTileEntity.getBlockAtSide(aSide); + if ((aCoverVariable < 3) && ((aTileEntity instanceof IFluidHandler))) { + if ((aSide == 1) && + (aTileEntity.getWorld().isRaining()) && + (aTileEntity.getWorld().getPrecipitationHeight(aTileEntity.getXCoord(), aTileEntity.getZCoord()) - 2 < aTileEntity.getYCoord())) { + int tAmount = (int) (aTileEntity.getBiome().rainfall * 10.0F); + if (tAmount > 0) { + ((IFluidHandler) aTileEntity).fill(ForgeDirection.getOrientation(aSide), Materials.Water.getFluid(aTileEntity.getWorld().isThundering() ? tAmount * 2 : tAmount), true); + } + } + FluidStack tLiquid = null; + if (tBlock != null) { + if (((tBlock == Blocks.water) || (tBlock == Blocks.flowing_water)) && (aTileEntity.getMetaIDAtSide(aSide) == 0)) { + tLiquid = Materials.Water.getFluid(1000L); + } else if (((tBlock == Blocks.lava) || (tBlock == Blocks.flowing_lava)) && (aTileEntity.getMetaIDAtSide(aSide) == 0)) { + tLiquid = Materials.Lava.getFluid(1000L); + } else if ((tBlock instanceof IFluidBlock)) { + tLiquid = ((IFluidBlock) tBlock).drain(aTileEntity.getWorld(), aTileEntity.getOffsetX(aSide, 1), aTileEntity.getOffsetY(aSide, 1), aTileEntity.getOffsetZ(aSide, 1), false); + } + if ((tLiquid != null) && (tLiquid.getFluid() != null) && ((aSide > 1) || ((aSide == 0) && (tLiquid.getFluid().getDensity() <= 0)) || ((aSide == 1) && (tLiquid.getFluid().getDensity() >= 0))) && + (((IFluidHandler) aTileEntity).fill(ForgeDirection.getOrientation(aSide), tLiquid, false) == tLiquid.amount)) { + ((IFluidHandler) aTileEntity).fill(ForgeDirection.getOrientation(aSide), tLiquid, true); + aTileEntity.getWorld().setBlockToAir(aTileEntity.getXCoord() + ForgeDirection.getOrientation(aSide).offsetX, aTileEntity.getYCoord() + ForgeDirection.getOrientation(aSide).offsetY, aTileEntity.getZCoord() + ForgeDirection.getOrientation(aSide).offsetZ); + } + } + } + if ((aCoverVariable >= 3) && (tBlock != null) && ( + (tBlock == Blocks.lava) || (tBlock == Blocks.flowing_lava) || (tBlock == Blocks.water) || (tBlock == Blocks.flowing_water) || ((tBlock instanceof IFluidBlock)))) { + aTileEntity.getWorld().setBlock(aTileEntity.getOffsetX(aSide, 1), aTileEntity.getOffsetY(aSide, 1), aTileEntity.getOffsetZ(aSide, 1), Blocks.air, 0, 0); + } + } + return aCoverVariable; + } + + public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { + aCoverVariable = (aCoverVariable + (aPlayer.isSneaking()? -1 : 1)) % 6; + if(aCoverVariable <0){aCoverVariable = 5;} + switch(aCoverVariable) { + case 0: GT_Utility.sendChatToPlayer(aPlayer, "Import"); break; + case 1: GT_Utility.sendChatToPlayer(aPlayer, "Import (conditional)"); break; + case 2: GT_Utility.sendChatToPlayer(aPlayer, "Import (invert cond)"); break; + case 3: GT_Utility.sendChatToPlayer(aPlayer, "Keep Liquids Away"); break; + case 4: GT_Utility.sendChatToPlayer(aPlayer, "Keep Liquids Away (conditional)"); break; + case 5: GT_Utility.sendChatToPlayer(aPlayer, "Keep Liquids Away (invert cond)"); break; + } + return aCoverVariable; + } + + public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + if ((aCoverVariable > 1) && ((aTileEntity instanceof IMachineProgress))) { + } + return ((IMachineProgress) aTileEntity).isAllowedToWork() == aCoverVariable < 2; + } + + public boolean alwaysLookConnected(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return aCoverVariable < 3 ? 50 : 1; + } +} diff --git a/src/main/java/gregtech/common/covers/GT_Cover_EUMeter.java b/src/main/java/gregtech/common/covers/GT_Cover_EUMeter.java new file mode 100644 index 0000000000..41a24767a7 --- /dev/null +++ b/src/main/java/gregtech/common/covers/GT_Cover_EUMeter.java @@ -0,0 +1,144 @@ +package gregtech.common.covers; + +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.items.GT_MetaBase_Item; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicBatteryBuffer; +import gregtech.api.util.GT_CoverBehavior; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_Utility; +import ic2.api.item.IElectricItem; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.Fluid; + +public class GT_Cover_EUMeter + extends GT_CoverBehavior { + public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) { + long tScale = 0L; + if (aCoverVariable < 2) { + tScale = aTileEntity.getUniversalEnergyCapacity() / 15L; + if (tScale > 0L) { + aTileEntity.setOutputRedstoneSignal(aSide, aCoverVariable % 2 == 0 ? (byte) (int) (aTileEntity.getUniversalEnergyStored() / tScale) : (byte) (int) (15L - aTileEntity.getUniversalEnergyStored() / tScale)); + } else { + aTileEntity.setOutputRedstoneSignal(aSide, (byte) (aCoverVariable % 2 == 0 ? 0 : 15)); + } + } else if (aCoverVariable < 4) { + tScale = aTileEntity.getEUCapacity() / 15L; + if (tScale > 0L) { + aTileEntity.setOutputRedstoneSignal(aSide, aCoverVariable % 2 == 0 ? (byte) (int) (aTileEntity.getStoredEU() / tScale) : (byte) (int) (15L - aTileEntity.getStoredEU() / tScale)); + } else { + aTileEntity.setOutputRedstoneSignal(aSide, (byte) (aCoverVariable % 2 == 0 ? 0 : 15)); + } + } else if (aCoverVariable < 6) { + tScale = aTileEntity.getSteamCapacity() / 15L; + if (tScale > 0L) { + aTileEntity.setOutputRedstoneSignal(aSide, aCoverVariable % 2 == 0 ? (byte) (int) (aTileEntity.getStoredSteam() / tScale) : (byte) (int) (15L - aTileEntity.getStoredSteam() / tScale)); + } else { + aTileEntity.setOutputRedstoneSignal(aSide, (byte) (aCoverVariable % 2 == 0 ? 0 : 15)); + } + } else if (aCoverVariable < 8) { + tScale = aTileEntity.getInputVoltage() * aTileEntity.getInputAmperage() / 15L; + if (tScale > 0L) { + aTileEntity.setOutputRedstoneSignal(aSide, aCoverVariable % 2 == 0 ? (byte) (int) (aTileEntity.getAverageElectricInput() / tScale) : (byte) (int) (15L - aTileEntity.getAverageElectricInput() / tScale)); + } else { + aTileEntity.setOutputRedstoneSignal(aSide, (byte) (aCoverVariable % 2 == 0 ? 0 : 15)); + } + } else if (aCoverVariable < 10) { + tScale = aTileEntity.getOutputVoltage() * aTileEntity.getOutputAmperage() / 15L; + if (tScale > 0L) { + aTileEntity.setOutputRedstoneSignal(aSide, aCoverVariable % 2 == 0 ? (byte) (int) (aTileEntity.getAverageElectricOutput() / tScale) : (byte) (int) (15L - aTileEntity.getAverageElectricOutput() / tScale)); + } else { + aTileEntity.setOutputRedstoneSignal(aSide, (byte) (aCoverVariable % 2 == 0 ? 0 : 15)); + } + } else if (aCoverVariable < 12) { + tScale = aTileEntity.getEUCapacity(); + long tStored = aTileEntity.getStoredEU(); + if (aTileEntity instanceof IGregTechTileEntity) { + IGregTechTileEntity tTileEntity = (IGregTechTileEntity) aTileEntity; + IMetaTileEntity mTileEntity = tTileEntity.getMetaTileEntity(); + if (mTileEntity instanceof GT_MetaTileEntity_BasicBatteryBuffer) { + GT_MetaTileEntity_BasicBatteryBuffer buffer = (GT_MetaTileEntity_BasicBatteryBuffer) mTileEntity; + if (buffer.mInventory != null) { + for (ItemStack aStack : buffer.mInventory) { + if (GT_ModHandler.isElectricItem(aStack)) { + + if (aStack.getItem() instanceof GT_MetaBase_Item) { + Long[] stats = ((GT_MetaBase_Item) aStack.getItem()).getElectricStats(aStack); + if (stats != null) { + tScale = tScale + stats[0]; + tStored = tStored + ((GT_MetaBase_Item) aStack.getItem()).getRealCharge(aStack); + } + } else if (aStack.getItem() instanceof IElectricItem) { + tStored = tStored + (long) ic2.api.item.ElectricItem.manager.getCharge(aStack); + tScale = tScale + (long) ((IElectricItem) aStack.getItem()).getMaxCharge(aStack); + } + } + } + + } + } + } + tScale = tScale / 15L; + if (tScale > 0L) { + aTileEntity.setOutputRedstoneSignal(aSide, aCoverVariable % 2 == 0 ? (byte) (int) (tStored / tScale) : (byte) (int) (15L - tStored / tScale)); + } else { + aTileEntity.setOutputRedstoneSignal(aSide, (byte) (aCoverVariable % 2 == 0 ? 0 : 15)); + } + } + return aCoverVariable; + } + + public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { + aCoverVariable = (aCoverVariable + (aPlayer.isSneaking()? -1 : 1)) % 12; + if(aCoverVariable <0){aCoverVariable = 11;} + switch(aCoverVariable) { + case 0: GT_Utility.sendChatToPlayer(aPlayer, "Normal Universal Storage"); break; + case 1: GT_Utility.sendChatToPlayer(aPlayer, "Inverted Universal Storage"); break; + case 2: GT_Utility.sendChatToPlayer(aPlayer, "Normal Electricity Storage"); break; + case 3: GT_Utility.sendChatToPlayer(aPlayer, "Inverted Electricity Storage"); break; + case 4: GT_Utility.sendChatToPlayer(aPlayer, "Normal Steam Storage"); break; + case 5: GT_Utility.sendChatToPlayer(aPlayer, "Inverted Steam Storage"); break; + case 6: GT_Utility.sendChatToPlayer(aPlayer, "Normal Average Electric Input"); break; + case 7: GT_Utility.sendChatToPlayer(aPlayer, "Inverted Average Electric Input"); break; + case 8: GT_Utility.sendChatToPlayer(aPlayer, "Normal Average Electric Output"); break; + case 9: GT_Utility.sendChatToPlayer(aPlayer, "Inverted Average Electric Output"); break; + case 10: GT_Utility.sendChatToPlayer(aPlayer, "Normal Electricity Storage(Including Batteries)"); break; + case 11: GT_Utility.sendChatToPlayer(aPlayer, "Inverted Electricity Storage(Including Batteries)"); break; + } + return aCoverVariable; + } + + public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return true; + } + + public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return true; + } + + public boolean letsItemsIn(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + return true; + } + + public boolean letsItemsOut(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + return true; + } + + public boolean manipulatesSidedRedstoneOutput(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return 20; + } +} diff --git a/src/main/java/gregtech/common/covers/GT_Cover_EnergyOnly.java b/src/main/java/gregtech/common/covers/GT_Cover_EnergyOnly.java new file mode 100644 index 0000000000..e90ca7afd5 --- /dev/null +++ b/src/main/java/gregtech/common/covers/GT_Cover_EnergyOnly.java @@ -0,0 +1,83 @@ +package gregtech.common.covers; + +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.interfaces.tileentity.IMachineProgress; +import gregtech.api.util.GT_CoverBehavior; +import gregtech.api.util.GT_Utility; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraftforge.fluids.Fluid; + +public class GT_Cover_EnergyOnly + extends GT_CoverBehavior { + public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { + aCoverVariable = (aCoverVariable + 1) % 3; + switch(aCoverVariable) { + case 0: GT_Utility.sendChatToPlayer(aPlayer, "Allow"); break; + case 1: GT_Utility.sendChatToPlayer(aPlayer, "Allow (conditional)"); break; + case 2: GT_Utility.sendChatToPlayer(aPlayer, "Disallow (conditional)"); break; + } + return aCoverVariable; + } + + public float getBlastProofLevel(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return 20.0F; + } + + public boolean letsRedstoneGoIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return false; + } + + public boolean letsRedstoneGoOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return false; + } + + public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + if ((aCoverVariable > 1) && ((aTileEntity instanceof IMachineProgress))) { + if (((IMachineProgress) aTileEntity).isAllowedToWork() != aCoverVariable < 2) { + return false; + } + } + return true; + } + + public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + if ((aCoverVariable > 1) && ((aTileEntity instanceof IMachineProgress))) { + if (((IMachineProgress) aTileEntity).isAllowedToWork() != aCoverVariable < 2) { + return false; + } + } + return true; + } + + public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return false; + } + + public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return false; + } + + public boolean letsItemsIn(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + return false; + } + + public boolean letsItemsOut(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + return false; + } + + public boolean isGUIClickable(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return false; + } + + public boolean manipulatesSidedRedstoneOutput(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return false; + } + + public boolean onCoverRightclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { + return false; + } + + public boolean onCoverRemoval(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, boolean aForced) { + return true; + } +} diff --git a/src/main/java/gregtech/common/covers/GT_Cover_FluidRegulator.java b/src/main/java/gregtech/common/covers/GT_Cover_FluidRegulator.java new file mode 100644 index 0000000000..e0057cf1a8 --- /dev/null +++ b/src/main/java/gregtech/common/covers/GT_Cover_FluidRegulator.java @@ -0,0 +1,129 @@ +package gregtech.common.covers; + +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.interfaces.tileentity.IMachineProgress; +import gregtech.api.util.GT_CoverBehavior; +import gregtech.api.util.GT_Utility; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.IFluidHandler; + +public class GT_Cover_FluidRegulator + extends GT_CoverBehavior { + public final int mTransferRate; + + public GT_Cover_FluidRegulator(int aTransferRate) { + this.mTransferRate = aTransferRate; + } + + public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) { + if(aCoverVariable==0){return aCoverVariable;} + if ((aTileEntity instanceof IFluidHandler)) { + IFluidHandler tTank2 = aTileEntity.getITankContainerAtSide(aSide); + if (tTank2 != null) { + IFluidHandler tTank1 = (IFluidHandler) aTileEntity; + if (aCoverVariable >0) { + FluidStack tLiquid = tTank1.drain(ForgeDirection.getOrientation(aSide), aCoverVariable, false); + if (tLiquid != null) { + tLiquid = tLiquid.copy(); + tLiquid.amount = tTank2.fill(ForgeDirection.getOrientation(aSide).getOpposite(), tLiquid, false); + if (tLiquid.amount > 0) { + if (aTileEntity.getUniversalEnergyCapacity() >= Math.min(1, tLiquid.amount / 10)) { + if (aTileEntity.isUniversalEnergyStored(Math.min(1, tLiquid.amount / 10))) { + aTileEntity.decreaseStoredEnergyUnits(Math.min(1, tLiquid.amount / 10), true); + tTank2.fill(ForgeDirection.getOrientation(aSide).getOpposite(), tTank1.drain(ForgeDirection.getOrientation(aSide), tLiquid.amount, true), true); + } + } else { + tTank2.fill(ForgeDirection.getOrientation(aSide).getOpposite(), tTank1.drain(ForgeDirection.getOrientation(aSide), tLiquid.amount, true), true); + } + } + } + } else { + FluidStack tLiquid = tTank2.drain(ForgeDirection.getOrientation(aSide).getOpposite(), Math.abs(aCoverVariable), false); + if (tLiquid != null) { + tLiquid = tLiquid.copy(); + tLiquid.amount = tTank1.fill(ForgeDirection.getOrientation(aSide), tLiquid, false); + if (tLiquid.amount > 0) { + if (aTileEntity.getUniversalEnergyCapacity() >= Math.min(1, tLiquid.amount / 10)) { + if (aTileEntity.isUniversalEnergyStored(Math.min(1, tLiquid.amount / 10))) { + aTileEntity.decreaseStoredEnergyUnits(Math.min(1, tLiquid.amount / 10), true); + tTank1.fill(ForgeDirection.getOrientation(aSide), tTank2.drain(ForgeDirection.getOrientation(aSide).getOpposite(), tLiquid.amount, true), true); + } + } else { + tTank1.fill(ForgeDirection.getOrientation(aSide), tTank2.drain(ForgeDirection.getOrientation(aSide).getOpposite(), tLiquid.amount, true), true); + } + } + } + } + } + } + return aCoverVariable; + } + + public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { + if (GT_Utility.getClickedFacingCoords(aSide, aX, aY, aZ)[0] >= 0.5F) { + aCoverVariable += 16; + } else { + aCoverVariable -= 16; + } + if(aCoverVariable>mTransferRate){aCoverVariable=mTransferRate;} + if(aCoverVariable<(0-mTransferRate)){aCoverVariable=(0-mTransferRate);} + GT_Utility.sendChatToPlayer(aPlayer, "Pump speed: "+aCoverVariable+"L/tick "+aCoverVariable*20+"L/sec"); + return aCoverVariable; + } + + public boolean onCoverRightclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { + if (GT_Utility.getClickedFacingCoords(aSide, aX, aY, aZ)[0] >= 0.5F) { + aCoverVariable++; + } else { + aCoverVariable--; + } + if(aCoverVariable>mTransferRate){aCoverVariable=mTransferRate;} + if(aCoverVariable<(0-mTransferRate)){aCoverVariable=(0-mTransferRate);} + GT_Utility.sendChatToPlayer(aPlayer, "Pump speed: "+aCoverVariable+"L/tick "+aCoverVariable*20+"L/sec"); + aTileEntity.setCoverDataAtSide(aSide, aCoverVariable); + return true; + } + + public boolean letsRedstoneGoIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public boolean letsRedstoneGoOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public boolean letsItemsIn(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + return true; + } + + public boolean letsItemsOut(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + return true; + } + + public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return false; + } + + public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return false; + } + + public boolean alwaysLookConnected(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return 1; + } +} diff --git a/src/main/java/gregtech/common/covers/GT_Cover_Fluidfilter.java b/src/main/java/gregtech/common/covers/GT_Cover_Fluidfilter.java new file mode 100644 index 0000000000..a1853b1aac --- /dev/null +++ b/src/main/java/gregtech/common/covers/GT_Cover_Fluidfilter.java @@ -0,0 +1,74 @@ +package gregtech.common.covers; + +import gregtech.api.GregTech_API; +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.interfaces.tileentity.IMachineProgress; +import gregtech.api.objects.ItemData; +import gregtech.api.util.GT_CoverBehavior; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidContainerRegistry; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidContainerRegistry.FluidContainerData; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTankInfo; +import net.minecraftforge.fluids.IFluidContainerItem; +import net.minecraftforge.fluids.IFluidHandler; + +public class GT_Cover_Fluidfilter + extends GT_CoverBehavior { + public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) { + return aCoverVariable; + } + + public boolean onCoverRightclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { + //System.out.println("rightclick"); + if (((aX > 0.375D) && (aX < 0.625D)) || ((aSide > 3) && (((aY > 0.375D) && (aY < 0.625D)) || ((aSide < 2) && (((aZ > 0.375D) && (aZ < 0.625D)) || (aSide == 2) || (aSide == 3)))))) { + ItemStack tStack = aPlayer.inventory.getCurrentItem(); + if(tStack!=null){ + FluidStack tFluid = FluidContainerRegistry.getFluidForFilledItem(tStack); + if(tFluid!=null){ + //System.out.println(tFluid.getLocalizedName()+" "+tFluid.getFluidID()); + aCoverVariable = tFluid.getFluidID(); + aTileEntity.setCoverDataAtSide(aSide, aCoverVariable); + FluidStack sFluid = new FluidStack(FluidRegistry.getFluid(aCoverVariable),1000); + GT_Utility.sendChatToPlayer(aPlayer, "Filter Fluid: " + sFluid.getLocalizedName()); + }else if(tStack.getItem() instanceof IFluidContainerItem){ + IFluidContainerItem tContainer = (IFluidContainerItem)tStack.getItem(); + if(tContainer.getFluid(tStack) != null) { + aCoverVariable = tContainer.getFluid(tStack).getFluidID(); + //System.out.println("fluidcontainer " + aCoverVariable); + FluidStack sFluid = new FluidStack(FluidRegistry.getFluid(aCoverVariable), 1000); + GT_Utility.sendChatToPlayer(aPlayer, "Filter Fluid: " + sFluid.getLocalizedName()); + } + } + } + return true; + } + return false; + } + + @Override + public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + if(aFluid==null){return true;} + return aFluid.getID() == aCoverVariable; + } + + @Override + public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + if(aFluid==null) return false; + return aFluid.getID() == aCoverVariable; + } + + public boolean alwaysLookConnected(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return 0; + } +} diff --git a/src/main/java/gregtech/common/covers/GT_Cover_ItemMeter.java b/src/main/java/gregtech/common/covers/GT_Cover_ItemMeter.java new file mode 100644 index 0000000000..b1f92da27b --- /dev/null +++ b/src/main/java/gregtech/common/covers/GT_Cover_ItemMeter.java @@ -0,0 +1,79 @@ +package gregtech.common.covers; + +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.util.GT_CoverBehavior; +import gregtech.api.util.GT_Utility; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.Fluid; + +public class GT_Cover_ItemMeter + extends GT_CoverBehavior { + public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) { + int[] tSlots; + if (aCoverVariable < 2) { + tSlots = aTileEntity.getAccessibleSlotsFromSide(aSide); + } else { + tSlots = new int[]{aCoverVariable - 2}; + } + int tAll = 0; + int tFull = 0; + for (int i : tSlots) { + if ((i > 0) && (i < aTileEntity.getSizeInventory())) { + tAll += 64; + ItemStack tStack = aTileEntity.getStackInSlot(i); + if (tStack != null) { + tFull += tStack.stackSize * 64 / tStack.getMaxStackSize(); + } + } + } + tAll /= 14; + if(tAll > 0) + aTileEntity.setOutputRedstoneSignal(aSide, aCoverVariable == 1 ? (byte)(15 - (tFull <= 0 ? 0 : tFull / tAll + 1)) : tFull <= 0 ? 0 : (byte)(tFull / tAll + 1)); + else + aTileEntity.setOutputRedstoneSignal(aSide, ((byte)(aCoverVariable == 1 ? 15 : 0))); + return aCoverVariable; + } + + public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { + aCoverVariable = (aCoverVariable + (aPlayer.isSneaking()? -1 : 1)) % (2 + aTileEntity.getSizeInventory()); + switch(aCoverVariable) { + case 0: GT_Utility.sendChatToPlayer(aPlayer, "Normal"); break; + case 1: GT_Utility.sendChatToPlayer(aPlayer, "Inverted"); break; + default: GT_Utility.sendChatToPlayer(aPlayer, "Slot: " + (aCoverVariable - 2)); break; + } + return aCoverVariable; + } + + public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return true; + } + + public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return true; + } + + public boolean letsItemsIn(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + return true; + } + + public boolean letsItemsOut(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + return true; + } + + public boolean manipulatesSidedRedstoneOutput(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return 5; + } +} diff --git a/src/main/java/gregtech/common/covers/GT_Cover_Lens.java b/src/main/java/gregtech/common/covers/GT_Cover_Lens.java new file mode 100644 index 0000000000..85f61e8b74 --- /dev/null +++ b/src/main/java/gregtech/common/covers/GT_Cover_Lens.java @@ -0,0 +1,17 @@ +package gregtech.common.covers; + +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.util.GT_CoverBehavior; + +public class GT_Cover_Lens + extends GT_CoverBehavior { + private final byte mColor; + + public GT_Cover_Lens(byte aColor) { + this.mColor = aColor; + } + + public byte getLensColor(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return this.mColor; + } +} diff --git a/src/main/java/gregtech/common/covers/GT_Cover_LiquidMeter.java b/src/main/java/gregtech/common/covers/GT_Cover_LiquidMeter.java new file mode 100644 index 0000000000..882c32e244 --- /dev/null +++ b/src/main/java/gregtech/common/covers/GT_Cover_LiquidMeter.java @@ -0,0 +1,83 @@ +package gregtech.common.covers; + +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.util.GT_CoverBehavior; +import gregtech.api.util.GT_Utility; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTankInfo; +import net.minecraftforge.fluids.IFluidHandler; + +public class GT_Cover_LiquidMeter + extends GT_CoverBehavior { + public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) { + if ((aTileEntity instanceof IFluidHandler)) { + FluidTankInfo[] tTanks = ((IFluidHandler) aTileEntity).getTankInfo(ForgeDirection.UNKNOWN); + long tAll = 0L; + long tFull = 0L; + if (tTanks != null) { + for (FluidTankInfo tTank : tTanks) { + if (tTank != null) { + tAll += tTank.capacity; + FluidStack tLiquid = tTank.fluid; + if (tLiquid != null) { + tFull += tLiquid.amount; + } + } + } + } + tAll /= 14L; + if (tAll > 0L) { + aTileEntity.setOutputRedstoneSignal(aSide, aCoverVariable != 0 ? (byte) (int) (15L - (tFull <= 0L ? 0L : tFull / tAll + 1L)) : tFull <= 0L ? 0 : (byte) (int) (tFull / tAll + 1L)); + } else { + aTileEntity.setOutputRedstoneSignal(aSide, ((byte) (aCoverVariable != 0 ? 15 : 0))); + } + } else { + aTileEntity.setOutputRedstoneSignal(aSide, (byte) 0); + } + return aCoverVariable; + } + + public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { + if (aCoverVariable == 0) { + GT_Utility.sendChatToPlayer(aPlayer, "Inverted"); + } else { + GT_Utility.sendChatToPlayer(aPlayer, "Normal"); + } + return aCoverVariable == 0 ? 1 : 0; + } + + public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public boolean letsFluidIn(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return true; + } + + public boolean letsFluidOut(byte aSide, int aCoverID, int aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return true; + } + + public boolean letsItemsIn(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + return true; + } + + public boolean letsItemsOut(byte aSide, int aCoverID, int aCoverVariable, int aSlot, ICoverable aTileEntity) { + return true; + } + + public boolean manipulatesSidedRedstoneOutput(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public int getTickRate(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return 5; + } +} \ No newline at end of file diff --git a/src/main/java/gregtech/common/covers/GT_Cover_NeedMaintainance.java b/src/main/java/gregtech/common/covers/GT_Cover_NeedMaintainance.java new file mode 100644 index 0000000000..83c37e35a4 --- /dev/null +++ b/src/main/java/gregtech/common/covers/GT_Cover_NeedMaintainance.java @@ -0,0 +1,96 @@ +package gregtech.common.covers; + +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase; +import gregtech.api.util.GT_CoverBehavior; +import gregtech.api.util.GT_Utility; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraftforge.fluids.Fluid; + +public class GT_Cover_NeedMaintainance extends GT_CoverBehavior { + + public int doCoverThings(byte aSide, byte aInputRedstone, int aCoverID, int aCoverVariable, ICoverable aTileEntity, long aTimer) { + boolean needsRepair = false; + if (aTileEntity instanceof IGregTechTileEntity) { + IGregTechTileEntity tTileEntity = (IGregTechTileEntity) aTileEntity; + IMetaTileEntity mTileEntity = tTileEntity.getMetaTileEntity(); + if (mTileEntity instanceof GT_MetaTileEntity_MultiBlockBase) { + GT_MetaTileEntity_MultiBlockBase multi = (GT_MetaTileEntity_MultiBlockBase) mTileEntity; + int ideal = multi.getIdealStatus(); + int real = multi.getRepairStatus(); + if ((aCoverVariable == 0 || aCoverVariable == 1) && (ideal - real > 0)) { + needsRepair = true; + } + if ((aCoverVariable == 2 || aCoverVariable == 3) && (ideal - real > 1)) { + needsRepair = true; + } + if ((aCoverVariable == 4 || aCoverVariable == 5) && (ideal - real > 2)) { + needsRepair = true; + } + if ((aCoverVariable == 6 || aCoverVariable == 7) && (ideal - real > 3)) { + needsRepair = true; + } + } + } + if (aCoverVariable % 2 == 0) { + needsRepair = !needsRepair; + } + + aTileEntity.setOutputRedstoneSignal(aSide, (byte) (needsRepair ? 0 : 15)); + aTileEntity.setOutputRedstoneSignal(GT_Utility.getOppositeSide(aSide), (byte) (needsRepair ? 0 : 15)); + return aCoverVariable; + } + + public int onCoverScrewdriverclick(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, float aY, float aZ) { + aCoverVariable = (aCoverVariable + (aPlayer.isSneaking()? -1 : 1)) % 10; + if(aCoverVariable <0){aCoverVariable = 9;} + switch(aCoverVariable) { + case 0: GT_Utility.sendChatToPlayer(aPlayer, "Emit if 1 Maintenance Needed"); break; + case 1: GT_Utility.sendChatToPlayer(aPlayer, "Emit if 1 Maintenance Needed(inverted)"); break; + case 2: GT_Utility.sendChatToPlayer(aPlayer, "Emit if 2 Maintenance Needed"); break; + case 3: GT_Utility.sendChatToPlayer(aPlayer, "Emit if 2 Maintenance Needed(inverted)"); break; + case 4: GT_Utility.sendChatToPlayer(aPlayer, "Emit if 3 Maintenance Needed"); break; + case 5: GT_Utility.sendChatToPlayer(aPlayer, "Emit if 3 Maintenance Needed(inverted)"); break; + case 6: GT_Utility.sendChatToPlayer(aPlayer, "Emit if 4 Maintenance Needed"); break; + case 7: GT_Utility.sendChatToPlayer(aPlayer, "Emit if 4 Maintenance Needed(inverted)"); break; + case 8: GT_Utility.sendChatToPlayer(aPlayer, "Emit if 5 Maintenance Needed"); break; + case 9: GT_Utility.sendChatToPlayer(aPlayer, "Emit if 5 Maintenance Needed(inverted)"); break; + } + return aCoverVariable; + } + + public boolean letsEnergyIn(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public boolean letsEnergyOut(byte aSide, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; +