From 1b820de08a05070909a267e17f033fcf58ac8710 Mon Sep 17 00:00:00 2001 From: NotAPenguin Date: Mon, 2 Sep 2024 23:17:17 +0200 Subject: The Great Renaming (#3014) * move kekztech to a single root dir * move detrav to a single root dir * move gtnh-lanthanides to a single root dir * move tectech and delete some gross reflection in gt++ * remove more reflection inside gt5u * delete more reflection in gt++ * fix imports * move bartworks and bwcrossmod * fix proxies * move galactigreg and ggfab * move gtneioreplugin * try to fix gt++ bee loader * apply the rename rules to BW * apply rename rules to bwcrossmod * apply rename rules to detrav scanner mod * apply rename rules to galacticgreg * apply rename rules to ggfab * apply rename rules to goodgenerator * apply rename rules to gtnh-lanthanides * apply rename rules to gt++ * apply rename rules to kekztech * apply rename rules to kubatech * apply rename rules to tectech * apply rename rules to gt apply the rename rules to gt * fix tt import * fix mui hopefully * fix coremod except intergalactic * rename assline recipe class * fix a class name i stumbled on * rename StructureUtility to GTStructureUtility to prevent conflict with structurelib * temporary rename of GTTooltipDataCache to old name * fix gt client/server proxy names --- src/main/java/gregtech/common/covers/CoverArm.java | 431 +++++++++++++++++ .../java/gregtech/common/covers/CoverChest.java | 274 +++++++++++ .../gregtech/common/covers/CoverControlsWork.java | 270 +++++++++++ .../java/gregtech/common/covers/CoverConveyor.java | 325 +++++++++++++ .../java/gregtech/common/covers/CoverCrafting.java | 56 +++ .../java/gregtech/common/covers/CoverDoesWork.java | 252 ++++++++++ .../java/gregtech/common/covers/CoverDrain.java | 140 ++++++ .../java/gregtech/common/covers/CoverEUMeter.java | 408 ++++++++++++++++ .../java/gregtech/common/covers/CoverFacadeAE.java | 31 ++ .../gregtech/common/covers/CoverFacadeBase.java | 396 ++++++++++++++++ .../gregtech/common/covers/CoverFluidLimiter.java | 202 ++++++++ .../common/covers/CoverFluidRegulator.java | 520 +++++++++++++++++++++ .../common/covers/CoverFluidStorageMonitor.java | 507 ++++++++++++++++++++ .../gregtech/common/covers/CoverFluidfilter.java | 414 ++++++++++++++++ .../java/gregtech/common/covers/CoverInfo.java | 26 +- .../gregtech/common/covers/CoverItemFilter.java | 298 ++++++++++++ .../gregtech/common/covers/CoverItemMeter.java | 384 +++++++++++++++ .../java/gregtech/common/covers/CoverLens.java | 28 ++ .../gregtech/common/covers/CoverLiquidMeter.java | 292 ++++++++++++ .../common/covers/CoverMetricsTransmitter.java | 211 +++++++++ .../common/covers/CoverNeedMaintainance.java | 297 ++++++++++++ .../common/covers/CoverPlayerDetector.java | 202 ++++++++ .../java/gregtech/common/covers/CoverPump.java | 331 +++++++++++++ .../common/covers/CoverRedstoneConductor.java | 101 ++++ .../covers/CoverRedstoneReceiverExternal.java | 41 ++ .../covers/CoverRedstoneReceiverInternal.java | 46 ++ .../common/covers/CoverRedstoneSignalizer.java | 98 ++++ .../covers/CoverRedstoneTransmitterExternal.java | 53 +++ .../covers/CoverRedstoneTransmitterInternal.java | 43 ++ .../common/covers/CoverRedstoneWirelessBase.java | 222 +++++++++ .../java/gregtech/common/covers/CoverScreen.java | 100 ++++ .../java/gregtech/common/covers/CoverShutter.java | 195 ++++++++ .../gregtech/common/covers/CoverSolarPanel.java | 139 ++++++ .../common/covers/CoverSteamRegulator.java | 18 + .../gregtech/common/covers/CoverSteamValve.java | 26 ++ .../java/gregtech/common/covers/CoverVent.java | 111 +++++ .../java/gregtech/common/covers/GT_Cover_Arm.java | 431 ----------------- .../gregtech/common/covers/GT_Cover_Chest.java | 274 ----------- .../common/covers/GT_Cover_ControlsWork.java | 270 ----------- .../gregtech/common/covers/GT_Cover_Conveyor.java | 328 ------------- .../gregtech/common/covers/GT_Cover_Crafting.java | 56 --- .../gregtech/common/covers/GT_Cover_DoesWork.java | 252 ---------- .../gregtech/common/covers/GT_Cover_Drain.java | 140 ------ .../gregtech/common/covers/GT_Cover_EUMeter.java | 410 ---------------- .../gregtech/common/covers/GT_Cover_FacadeAE.java | 31 -- .../common/covers/GT_Cover_FacadeBase.java | 396 ---------------- .../common/covers/GT_Cover_FluidLimiter.java | 202 -------- .../common/covers/GT_Cover_FluidRegulator.java | 520 --------------------- .../covers/GT_Cover_FluidStorageMonitor.java | 507 -------------------- .../common/covers/GT_Cover_Fluidfilter.java | 417 ----------------- .../common/covers/GT_Cover_ItemFilter.java | 298 ------------ .../gregtech/common/covers/GT_Cover_ItemMeter.java | 384 --------------- .../java/gregtech/common/covers/GT_Cover_Lens.java | 28 -- .../common/covers/GT_Cover_LiquidMeter.java | 292 ------------ .../covers/GT_Cover_Metrics_Transmitter.java | 212 --------- .../common/covers/GT_Cover_NeedMaintainance.java | 298 ------------ .../common/covers/GT_Cover_PlayerDetector.java | 202 -------- .../java/gregtech/common/covers/GT_Cover_Pump.java | 334 ------------- .../common/covers/GT_Cover_RedstoneConductor.java | 101 ---- .../covers/GT_Cover_RedstoneReceiverExternal.java | 41 -- .../covers/GT_Cover_RedstoneReceiverInternal.java | 46 -- .../common/covers/GT_Cover_RedstoneSignalizer.java | 99 ---- .../GT_Cover_RedstoneTransmitterExternal.java | 53 --- .../GT_Cover_RedstoneTransmitterInternal.java | 43 -- .../covers/GT_Cover_RedstoneWirelessBase.java | 228 --------- .../gregtech/common/covers/GT_Cover_Screen.java | 100 ---- .../gregtech/common/covers/GT_Cover_Shutter.java | 196 -------- .../common/covers/GT_Cover_SolarPanel.java | 139 ------ .../common/covers/GT_Cover_SteamRegulator.java | 18 - .../common/covers/GT_Cover_SteamValve.java | 26 -- .../java/gregtech/common/covers/GT_Cover_Vent.java | 111 ----- .../CoverAdvancedRedstoneReceiverBase.java | 202 ++++++++ .../CoverAdvancedRedstoneReceiverExternal.java | 35 ++ .../CoverAdvancedRedstoneReceiverInternal.java | 42 ++ .../CoverAdvancedRedstoneTransmitterBase.java | 188 ++++++++ .../CoverAdvancedRedstoneTransmitterExternal.java | 51 ++ .../CoverAdvancedRedstoneTransmitterInternal.java | 50 ++ .../CoverAdvancedWirelessRedstoneBase.java | 298 ++++++++++++ .../redstone/CoverWirelessDoesWorkDetector.java | 244 ++++++++++ .../redstone/CoverWirelessFluidDetector.java | 186 ++++++++ .../covers/redstone/CoverWirelessItemDetector.java | 262 +++++++++++ .../redstone/CoverWirelessMaintenanceDetector.java | 242 ++++++++++ .../GT_Cover_AdvancedRedstoneReceiverBase.java | 202 -------- .../GT_Cover_AdvancedRedstoneReceiverExternal.java | 35 -- .../GT_Cover_AdvancedRedstoneReceiverInternal.java | 42 -- .../GT_Cover_AdvancedRedstoneTransmitterBase.java | 188 -------- ..._Cover_AdvancedRedstoneTransmitterExternal.java | 51 -- ..._Cover_AdvancedRedstoneTransmitterInternal.java | 50 -- .../GT_Cover_AdvancedWirelessRedstoneBase.java | 298 ------------ .../GT_Cover_WirelessDoesWorkDetector.java | 245 ---------- .../redstone/GT_Cover_WirelessFluidDetector.java | 186 -------- .../redstone/GT_Cover_WirelessItemDetector.java | 262 ----------- .../GT_Cover_WirelessMaintenanceDetector.java | 242 ---------- 93 files changed, 9275 insertions(+), 9297 deletions(-) create mode 100644 src/main/java/gregtech/common/covers/CoverArm.java create mode 100644 src/main/java/gregtech/common/covers/CoverChest.java create mode 100644 src/main/java/gregtech/common/covers/CoverControlsWork.java create mode 100644 src/main/java/gregtech/common/covers/CoverConveyor.java create mode 100644 src/main/java/gregtech/common/covers/CoverCrafting.java create mode 100644 src/main/java/gregtech/common/covers/CoverDoesWork.java create mode 100644 src/main/java/gregtech/common/covers/CoverDrain.java create mode 100644 src/main/java/gregtech/common/covers/CoverEUMeter.java create mode 100644 src/main/java/gregtech/common/covers/CoverFacadeAE.java create mode 100644 src/main/java/gregtech/common/covers/CoverFacadeBase.java create mode 100644 src/main/java/gregtech/common/covers/CoverFluidLimiter.java create mode 100644 src/main/java/gregtech/common/covers/CoverFluidRegulator.java create mode 100644 src/main/java/gregtech/common/covers/CoverFluidStorageMonitor.java create mode 100644 src/main/java/gregtech/common/covers/CoverFluidfilter.java create mode 100644 src/main/java/gregtech/common/covers/CoverItemFilter.java create mode 100644 src/main/java/gregtech/common/covers/CoverItemMeter.java create mode 100644 src/main/java/gregtech/common/covers/CoverLens.java create mode 100644 src/main/java/gregtech/common/covers/CoverLiquidMeter.java create mode 100644 src/main/java/gregtech/common/covers/CoverMetricsTransmitter.java create mode 100644 src/main/java/gregtech/common/covers/CoverNeedMaintainance.java create mode 100644 src/main/java/gregtech/common/covers/CoverPlayerDetector.java create mode 100644 src/main/java/gregtech/common/covers/CoverPump.java create mode 100644 src/main/java/gregtech/common/covers/CoverRedstoneConductor.java create mode 100644 src/main/java/gregtech/common/covers/CoverRedstoneReceiverExternal.java create mode 100644 src/main/java/gregtech/common/covers/CoverRedstoneReceiverInternal.java create mode 100644 src/main/java/gregtech/common/covers/CoverRedstoneSignalizer.java create mode 100644 src/main/java/gregtech/common/covers/CoverRedstoneTransmitterExternal.java create mode 100644 src/main/java/gregtech/common/covers/CoverRedstoneTransmitterInternal.java create mode 100644 src/main/java/gregtech/common/covers/CoverRedstoneWirelessBase.java create mode 100644 src/main/java/gregtech/common/covers/CoverScreen.java create mode 100644 src/main/java/gregtech/common/covers/CoverShutter.java create mode 100644 src/main/java/gregtech/common/covers/CoverSolarPanel.java create mode 100644 src/main/java/gregtech/common/covers/CoverSteamRegulator.java create mode 100644 src/main/java/gregtech/common/covers/CoverSteamValve.java create mode 100644 src/main/java/gregtech/common/covers/CoverVent.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_Arm.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_Chest.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_ControlsWork.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_Conveyor.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_Crafting.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_DoesWork.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_Drain.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_EUMeter.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_FacadeAE.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_FacadeBase.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_FluidLimiter.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_FluidRegulator.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_FluidStorageMonitor.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_Fluidfilter.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_ItemFilter.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_ItemMeter.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_Lens.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_LiquidMeter.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_Metrics_Transmitter.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_NeedMaintainance.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_PlayerDetector.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_Pump.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_RedstoneConductor.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_RedstoneReceiverExternal.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_RedstoneReceiverInternal.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_RedstoneSignalizer.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_RedstoneTransmitterExternal.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_RedstoneTransmitterInternal.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_RedstoneWirelessBase.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_Screen.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_Shutter.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_SolarPanel.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_SteamRegulator.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_SteamValve.java delete mode 100644 src/main/java/gregtech/common/covers/GT_Cover_Vent.java create mode 100644 src/main/java/gregtech/common/covers/redstone/CoverAdvancedRedstoneReceiverBase.java create mode 100644 src/main/java/gregtech/common/covers/redstone/CoverAdvancedRedstoneReceiverExternal.java create mode 100644 src/main/java/gregtech/common/covers/redstone/CoverAdvancedRedstoneReceiverInternal.java create mode 100644 src/main/java/gregtech/common/covers/redstone/CoverAdvancedRedstoneTransmitterBase.java create mode 100644 src/main/java/gregtech/common/covers/redstone/CoverAdvancedRedstoneTransmitterExternal.java create mode 100644 src/main/java/gregtech/common/covers/redstone/CoverAdvancedRedstoneTransmitterInternal.java create mode 100644 src/main/java/gregtech/common/covers/redstone/CoverAdvancedWirelessRedstoneBase.java create mode 100644 src/main/java/gregtech/common/covers/redstone/CoverWirelessDoesWorkDetector.java create mode 100644 src/main/java/gregtech/common/covers/redstone/CoverWirelessFluidDetector.java create mode 100644 src/main/java/gregtech/common/covers/redstone/CoverWirelessItemDetector.java create mode 100644 src/main/java/gregtech/common/covers/redstone/CoverWirelessMaintenanceDetector.java delete mode 100644 src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverBase.java delete mode 100644 src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverExternal.java delete mode 100644 src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverInternal.java delete mode 100644 src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterBase.java delete mode 100644 src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterExternal.java delete mode 100644 src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterInternal.java delete mode 100644 src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedWirelessRedstoneBase.java delete mode 100644 src/main/java/gregtech/common/covers/redstone/GT_Cover_WirelessDoesWorkDetector.java delete mode 100644 src/main/java/gregtech/common/covers/redstone/GT_Cover_WirelessFluidDetector.java delete mode 100644 src/main/java/gregtech/common/covers/redstone/GT_Cover_WirelessItemDetector.java delete mode 100644 src/main/java/gregtech/common/covers/redstone/GT_Cover_WirelessMaintenanceDetector.java (limited to 'src/main/java/gregtech/common/covers') diff --git a/src/main/java/gregtech/common/covers/CoverArm.java b/src/main/java/gregtech/common/covers/CoverArm.java new file mode 100644 index 0000000000..fef9ef1327 --- /dev/null +++ b/src/main/java/gregtech/common/covers/CoverArm.java @@ -0,0 +1,431 @@ +package gregtech.common.covers; + +import java.text.FieldPosition; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.IInventory; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; + +import com.gtnewhorizons.modularui.api.NumberFormatMUI; +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.common.widget.TextWidget; + +import gregtech.api.gui.modularui.CoverUIBuildContext; +import gregtech.api.gui.modularui.GTUITextures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.interfaces.tileentity.IMachineProgress; +import gregtech.api.util.CoverBehavior; +import gregtech.api.util.GTUtility; +import gregtech.api.util.ISerializableObject; +import gregtech.common.gui.modularui.widget.CoverDataControllerWidget; +import gregtech.common.gui.modularui.widget.CoverDataFollowerNumericWidget; +import gregtech.common.gui.modularui.widget.CoverDataFollowerToggleButtonWidget; + +public class CoverArm extends CoverBehavior { + + public final int mTickRate; + // msb converted, 2nd : direction (1=export) + // right 14 bits: internalSlot, next 14 bits adjSlot, 0 = all, slot = -1 + protected static final int EXPORT_MASK = 0x40000000; + protected static final int SLOT_ID_MASK = 0x3FFF; + protected static final int SLOT_ID_MIN = 0; + protected static final int CONVERTED_BIT = 0x80000000; + + public CoverArm(int aTickRate, ITexture coverTexture) { + super(coverTexture); + this.mTickRate = aTickRate; + } + + @Override + public boolean isRedstoneSensitive(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity, + long aTimer) { + return false; + } + + @Override + public int doCoverThings(ForgeDirection side, byte aInputRedstone, int aCoverID, int aCoverVariable, + ICoverable aTileEntity, long aTimer) { + if ((((aTileEntity instanceof IMachineProgress)) && (!((IMachineProgress) aTileEntity).isAllowedToWork()))) { + return aCoverVariable; + } + + // Convert from ver. 5.09.33.50, check if 3 last bits are equal + if ((aCoverVariable >>> 29) == 0) { + aCoverVariable = CONVERTED_BIT | (((aCoverVariable + 1) & SLOT_ID_MASK) << 14) | EXPORT_MASK; + } else if ((aCoverVariable >>> 29) == 7) { + aCoverVariable = CONVERTED_BIT | Math.min(Math.abs(aCoverVariable - 1), SLOT_ID_MASK); + } + + final TileEntity toTile; + final TileEntity fromTile; + final int toSlot; + final int fromSlot; + + if ((aCoverVariable & EXPORT_MASK) > 0) { + fromTile = (TileEntity) aTileEntity; + toTile = aTileEntity.getTileEntityAtSide(side); + fromSlot = aCoverVariable & SLOT_ID_MASK; + toSlot = (aCoverVariable >> 14) & SLOT_ID_MASK; + } else { + fromTile = aTileEntity.getTileEntityAtSide(side); + toTile = (TileEntity) aTileEntity; + fromSlot = (aCoverVariable >> 14) & SLOT_ID_MASK; + toSlot = aCoverVariable & SLOT_ID_MASK; + } + + if (fromSlot > 0 && toSlot > 0) { + if (fromTile instanceof IInventory fromInventory && toTile instanceof IInventory toInventory) + GTUtility.moveFromSlotToSlot( + fromInventory, + toInventory, + fromSlot - 1, + toSlot - 1, + null, + false, + (byte) 64, + (byte) 1, + (byte) 64, + (byte) 1); + } else if (toSlot > 0) { + final ForgeDirection toSide; + if ((aCoverVariable & EXPORT_MASK) > 0) toSide = side; + else toSide = side.getOpposite(); + GTUtility.moveOneItemStackIntoSlot( + fromTile, + toTile, + toSide, + toSlot - 1, + null, + false, + (byte) 64, + (byte) 1, + (byte) 64, + (byte) 1); + } else if (fromSlot > 0) { + final ForgeDirection toSide; + if ((aCoverVariable & EXPORT_MASK) > 0) toSide = side; + else toSide = side.getOpposite(); + if (fromTile instanceof IInventory) GTUtility.moveFromSlotToSide( + (IInventory) fromTile, + toTile, + fromSlot - 1, + toSide, + null, + false, + (byte) 64, + (byte) 1, + (byte) 64, + (byte) 1); + } else { + final ForgeDirection fromSide; + final ForgeDirection toSide; + if ((aCoverVariable & EXPORT_MASK) > 0) { + fromSide = side; + toSide = side.getOpposite(); + } else { + fromSide = side.getOpposite(); + toSide = side; + } + GTUtility.moveOneItemStack( + fromTile, + toTile, + fromSide, + toSide, + null, + false, + (byte) 64, + (byte) 1, + (byte) 64, + (byte) 1); + } + + return aCoverVariable; + } + + @Override + public int onCoverScrewdriverclick(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity, + EntityPlayer aPlayer, float aX, float aY, float aZ) { + int step = 0; + if (GTUtility.getClickedFacingCoords(side, aX, aY, aZ)[0] >= 0.5F) { + step += aPlayer.isSneaking() ? 256 : 16; + } else { + step -= aPlayer.isSneaking() ? 256 : 16; + } + aCoverVariable = getNewVar(aCoverVariable, step); + sendMessageToPlayer(aPlayer, aCoverVariable); + return aCoverVariable; + } + + @Override + protected boolean onCoverRightClickImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, EntityPlayer aPlayer, float aX, + float aY, float aZ) { + int step = (GTUtility.getClickedFacingCoords(side, aX, aY, aZ)[0] >= 0.5F) ? 1 : -1; + int tCoverVariable = getNewVar(aCoverVariable.get(), step); + sendMessageToPlayer(aPlayer, tCoverVariable); + aCoverVariable.set(tCoverVariable); + return true; + } + + @Override + @SuppressWarnings("deprecation") + public boolean onCoverRightclick(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity, + EntityPlayer aPlayer, float aX, float aY, float aZ) { + final int step = (GTUtility.getClickedFacingCoords(side, aX, aY, aZ)[0] >= 0.5F) ? 1 : -1; + aCoverVariable = getNewVar(aCoverVariable, step); + sendMessageToPlayer(aPlayer, aCoverVariable); + aTileEntity.setCoverDataAtSide(side, aCoverVariable); + return true; + } + + @Override + protected boolean isGUIClickableImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity) { + return false; + } + + private void sendMessageToPlayer(EntityPlayer aPlayer, int var) { + if ((var & EXPORT_MASK) != 0) GTUtility.sendChatToPlayer( + aPlayer, + GTUtility.trans("001", "Puts out into adjacent Slot #") + (((var >> 14) & SLOT_ID_MASK) - 1)); + else GTUtility + .sendChatToPlayer(aPlayer, GTUtility.trans("002", "Grabs in for own Slot #") + ((var & SLOT_ID_MASK) - 1)); + } + + private int getNewVar(int var, int step) { + int intSlot = (var & SLOT_ID_MASK); + int adjSlot = (var >> 14) & SLOT_ID_MASK; + if ((var & EXPORT_MASK) == 0) { + int x = (intSlot + step); + if (x > SLOT_ID_MASK) return createVar(0, SLOT_ID_MASK, 0); + else if (x < 1) return createVar(-step - intSlot + 1, 0, EXPORT_MASK); + else return createVar(0, x, 0); + } else { + int x = (adjSlot - step); + if (x > SLOT_ID_MASK) return createVar(SLOT_ID_MASK, 0, EXPORT_MASK); + else if (x < 1) return createVar(0, step - adjSlot + 1, 0); + else return createVar(x, 0, EXPORT_MASK); + } + } + + private int createVar(int adjSlot, int intSlot, int export) { + return CONVERTED_BIT | export | ((adjSlot & SLOT_ID_MASK) << 14) | (intSlot & SLOT_ID_MASK); + } + + @Override + public boolean letsRedstoneGoIn(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsRedstoneGoOut(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsEnergyIn(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsEnergyOut(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsFluidIn(ForgeDirection side, int aCoverID, int aCoverVariable, Fluid aFluid, + ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsFluidOut(ForgeDirection side, int aCoverID, int aCoverVariable, Fluid aFluid, + ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsItemsIn(ForgeDirection side, int aCoverID, int aCoverVariable, int aSlot, + ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsItemsOut(ForgeDirection side, int aCoverID, int aCoverVariable, int aSlot, + ICoverable aTileEntity) { + return true; + } + + @Override + public boolean alwaysLookConnected(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public int getTickRate(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return this.mTickRate; + } + + // GUI stuff + + @Override + public boolean hasCoverGUI() { + return true; + } + + @Override + public ModularWindow createWindow(CoverUIBuildContext buildContext) { + return new ArmUIFactory(buildContext).createWindow(); + } + + private class ArmUIFactory extends UIFactory { + + private static final int startX = 10; + private static final int startY = 25; + private static final int spaceX = 18; + private static final int spaceY = 18; + + private int maxSlot; + + /** + * Display the text "Any" instead of a number when the slot is set to -1. + */ + protected static final NumberFormatMUI numberFormatAny = new NumberFormatMUI() { + + @Override + public StringBuffer format(double number, StringBuffer toAppendTo, FieldPosition pos) { + if (number < 0) { + return toAppendTo.append(GTUtility.trans("ANY", "Any")); + } else { + return super.format(number, toAppendTo, pos); + } + } + }; + + protected ArmUIFactory(CoverUIBuildContext buildContext) { + super(buildContext); + } + + @SuppressWarnings("PointlessArithmeticExpression") + @Override + protected void addUIWidgets(ModularWindow.Builder builder) { + maxSlot = getMaxSlot(); + builder.widget( + new CoverDataControllerWidget<>(this::getCoverData, this::setCoverData, CoverArm.this).addFollower( + CoverDataFollowerToggleButtonWidget.ofDisableable(), + coverData -> getFlagExport(convert(coverData)) > 0, + (coverData, state) -> { + if (state) { + return new ISerializableObject.LegacyCoverData( + convert(coverData) | EXPORT_MASK | CONVERTED_BIT); + } else { + return new ISerializableObject.LegacyCoverData( + convert(coverData) & ~EXPORT_MASK | CONVERTED_BIT); + } + }, + widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_EXPORT) + .addTooltip(GTUtility.trans("006", "Export")) + .setPos(spaceX * 0, spaceY * 0)) + .addFollower( + CoverDataFollowerToggleButtonWidget.ofDisableable(), + coverData -> getFlagExport(convert(coverData)) == 0, + (coverData, state) -> { + if (state) { + return new ISerializableObject.LegacyCoverData( + convert(coverData) & ~EXPORT_MASK | CONVERTED_BIT); + } else { + return new ISerializableObject.LegacyCoverData( + convert(coverData) | EXPORT_MASK | CONVERTED_BIT); + } + }, + widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_IMPORT) + .addTooltip(GTUtility.trans("007", "Import")) + .setPos(spaceX * 1, spaceY * 0)) + .addFollower( + new CoverDataFollowerNumericWidget<>(), + coverData -> (double) (getFlagInternalSlot(convert(coverData)) - 1), + (coverData, state) -> { + final int coverVariable = convert(coverData); + return new ISerializableObject.LegacyCoverData( + getFlagExport(coverVariable) | ((state.intValue() + 1) & SLOT_ID_MASK) + | (getFlagAdjacentSlot(coverVariable) << 14) + | CONVERTED_BIT); + }, + widget -> widget.setBounds(-1, maxSlot) + .setDefaultValue(-1) + .setScrollValues(1, 100, 10) + .setNumberFormat(numberFormatAny) + .setPos(spaceX * 0, spaceY * 1 + 2) + .setSize(spaceX * 2 + 5, 12)) + .addFollower( + new CoverDataFollowerNumericWidget<>(), + coverData -> (double) (getFlagAdjacentSlot(convert(coverData)) - 1), + (coverData, state) -> { + final int coverVariable = convert(coverData); + return new ISerializableObject.LegacyCoverData( + getFlagExport(coverVariable) | getFlagInternalSlot(coverVariable) + | (((state.intValue() + 1) & SLOT_ID_MASK) << 14) + | CONVERTED_BIT); + }, + widget -> widget.setValidator(val -> { + // We need to check the adjacent inventory here, and can't simply set a maximum value, + // because it can change while this cover is alive. + final int adjacentMaxSlot; + final ICoverable tile = getUIBuildContext().getTile(); + if (tile instanceof TileEntity && !tile.isDead()) { + TileEntity adj = tile.getTileEntityAtSide(getUIBuildContext().getCoverSide()); + if (adj instanceof IInventory) + adjacentMaxSlot = ((IInventory) adj).getSizeInventory() - 1; + else adjacentMaxSlot = -1; + } else { + adjacentMaxSlot = -1; + } + return Math.min(val, adjacentMaxSlot); + }) + .setMinValue(-1) + .setDefaultValue(-1) + .setScrollValues(1, 100, 10) + .setNumberFormat(numberFormatAny) + .setPos(spaceX * 0, spaceY * 2 + 2) + .setSize(spaceX * 2 + 5, 12)) + .setPos(startX, startY)) + .widget( + new TextWidget() + .setStringSupplier( + () -> (convert(getCoverData()) & EXPORT_MASK) > 0 ? GTUtility.trans("006", "Export") + : GTUtility.trans("007", "Import")) + .setDefaultColor(COLOR_TEXT_GRAY.get()) + .setPos(startX + spaceX * 3, 4 + startY + spaceY * 0)) + .widget( + new TextWidget(GTUtility.trans("254.1", "Internal slot#")).setDefaultColor(COLOR_TEXT_GRAY.get()) + .setPos(startX + spaceX * 3, 4 + startY + spaceY * 1)) + .widget( + new TextWidget(GTUtility.trans("255", "Adjacent slot#")).setDefaultColor(COLOR_TEXT_GRAY.get()) + .setPos(startX + spaceX * 3, 4 + startY + spaceY * 2)); + } + + private int getMaxSlot() { + final ICoverable tile = getUIBuildContext().getTile(); + if (tile instanceof TileEntity && !tile.isDead()) { + return tile.getSizeInventory() - 1; + } else { + return -1; + } + } + + private int getFlagExport(int coverVariable) { + return coverVariable & EXPORT_MASK; + } + + private int getFlagInternalSlot(int coverVariable) { + return coverVariable & SLOT_ID_MASK; + } + + private int getFlagAdjacentSlot(int coverVariable) { + return (coverVariable >> 14) & SLOT_ID_MASK; + } + } +} diff --git a/src/main/java/gregtech/common/covers/CoverChest.java b/src/main/java/gregtech/common/covers/CoverChest.java new file mode 100644 index 0000000000..4afc3b9578 --- /dev/null +++ b/src/main/java/gregtech/common/covers/CoverChest.java @@ -0,0 +1,274 @@ +package gregtech.common.covers; + +import static gregtech.api.objects.XSTR.XSTR_INSTANCE; + +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTBase; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.common.util.ForgeDirection; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import com.google.common.io.ByteArrayDataInput; +import com.gtnewhorizons.modularui.api.forge.ItemStackHandler; +import com.gtnewhorizons.modularui.api.math.Alignment; +import com.gtnewhorizons.modularui.api.math.Size; +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.common.widget.SlotGroup; + +import cpw.mods.fml.common.network.ByteBufUtils; +import gregtech.api.gui.modularui.CoverUIBuildContext; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.util.CoverBehaviorBase; +import gregtech.api.util.ISerializableObject; +import gregtech.common.gui.modularui.widget.CoverDataControllerWidget; +import io.netty.buffer.ByteBuf; + +public class CoverChest extends CoverBehaviorBase { + + private final int slots; + private final int stackSizeLimit = 1; + + public CoverChest(int slots, ITexture coverTexture) { + super(ChestInventory.class, coverTexture); + if (slots <= 0) throw new IllegalArgumentException("slots must be greater than 0"); + this.slots = slots; + } + + @Override + public ChestInventory createDataObject(int aLegacyData) { + return new ChestInventory(slots, stackSizeLimit); + } + + @Override + public ChestInventory createDataObject() { + return new ChestInventory(slots, stackSizeLimit); + } + + @Override + public boolean hasCoverGUI() { + return true; + } + + @Override + public boolean isSimpleCover() { + return true; + } + + @Override + public boolean allowsCopyPasteTool() { + return false; + } + + @Override + public boolean allowsTickRateAddition() { + return false; + } + + @Override + protected void onDroppedImpl(ForgeDirection side, int aCoverID, ChestInventory aCoverVariable, + ICoverable aTileEntity) { + if (aTileEntity.getWorld().isRemote) return; + aCoverVariable.dropAll(aTileEntity, side); + } + + @Override + protected int getTickRateImpl(ForgeDirection side, int aCoverID, ChestInventory aCoverVariable, + ICoverable aTileEntity) { + return aCoverVariable.firstTick ? 1 : 0; + } + + @Override + protected ChestInventory doCoverThingsImpl(ForgeDirection side, byte aInputRedstone, int aCoverID, + ChestInventory aCoverVariable, ICoverable aTileEntity, long aTimer) { + // migrate slots. mostly needed while in development. still can be useful if we ever resize the inventory in the + // future + if (aCoverVariable.items.getSlots() != slots) { + if (aCoverVariable.items.getSlots() > slots) { + for (int i = slots; i < aCoverVariable.items.getSlots(); i++) { + ItemStack item = aCoverVariable.items.getStackInSlot(i); + if (item != null) { + dropItem(aTileEntity, side, item); + } + } + } + + ChestInventory newData = createDataObject(); + int toCopy = Math.min(newData.items.getSlots(), aCoverVariable.items.getSlots()); + for (int i = 0; i < toCopy; i++) { + newData.items.setStackInSlot(i, aCoverVariable.items.getStackInSlot(i)); + } + return newData; + } + aCoverVariable.firstTick = false; + return super.doCoverThingsImpl(side, aInputRedstone, aCoverID, aCoverVariable, aTileEntity, aTimer); + } + + @Override + public ModularWindow createWindow(CoverUIBuildContext buildContext) { + return new ChestUIFactory(buildContext).createWindow(); + } + + public class ChestUIFactory extends UIFactory { + + private static final int spaceX = 18; + private static final int spaceY = 18; + + public ChestUIFactory(CoverUIBuildContext buildContext) { + super(buildContext); + } + + @Override + protected int getGUIHeight() { + int height = slots / 3 * 18 + 8; + if (!getUIBuildContext().isAnotherWindow()) { + // player inv is 4 row + return height + 4 * 18 + 14; + } + return height; + } + + @Override + protected void addTitleToUI(ModularWindow.Builder builder) {} + + @Override + protected int getGUIWidth() { + if (getUIBuildContext().isAnotherWindow()) { + return 18 * 3 + 20; + } else { + return 18 * 9 + 20; + } + } + + @Override + protected void addUIWidgets(ModularWindow.Builder builder) { + CoverDataControllerWidget w = new CoverDataControllerWidget<>( + this::getCoverData, + this::setCoverData, + CoverChest.this); + ChestInventory d = getCoverData(); + LimitingItemStackHandler h; + if (d == null) { + // ??? + return; + } + h = d.items; + SlotGroup slotGroup = SlotGroup.ofItemHandler(h, 3) + .build(); + if (getUIBuildContext().isAnotherWindow()) { + slotGroup.setPos(4, 4); + } else { + slotGroup.setPos(getGUIWidth() / 2 - 18 * 3 / 2, 6); + } + w.addChild(slotGroup); + builder.widget(w); + + builder.setPos( + (p, t) -> Alignment.Center.getAlignedPos( + new Size(getUIBuildContext().isAnotherWindow() ? t.getPos().x : p.width, p.height), + new Size(getGUIWidth(), getGUIHeight()))); + } + + @Override + protected boolean doesBindPlayerInventory() { + return true; + } + } + + private static class LimitingItemStackHandler extends ItemStackHandler { + + private final int slotLimit; + + private LimitingItemStackHandler(int slots, int slotLimit) { + super(slots); + this.slotLimit = slotLimit; + } + + @Override + public int getSlotLimit(int slot) { + return slotLimit; + } + } + + public static class ChestInventory implements ISerializableObject { + + final LimitingItemStackHandler items; + boolean firstTick; + + public ChestInventory(int slots, int stackSize) { + items = new LimitingItemStackHandler(slots, stackSize); + } + + @NotNull + @Override + public ISerializableObject readFromPacket(ByteArrayDataInput aBuf, @Nullable EntityPlayerMP aPlayer) { + items.deserializeNBT(ISerializableObject.readCompoundTagFromGreggyByteBuf(aBuf)); + return this; + } + + @Override + public void writeToByteBuf(ByteBuf aBuf) { + ByteBufUtils.writeTag(aBuf, items.serializeNBT()); + } + + @Override + public void loadDataFromNBT(NBTBase aNBT) { + if (!(aNBT instanceof NBTTagCompound)) return; + items.deserializeNBT((NBTTagCompound) aNBT); + firstTick = true; + } + + @NotNull + @Override + public NBTBase saveDataToNBT() { + return items.serializeNBT(); + } + + @NotNull + @Override + public ISerializableObject copy() { + ChestInventory copy = new ChestInventory(items.getSlots(), items.getSlotLimit(0)); + for (int i = 0; i < items.getSlots(); i++) { + copy.items.setStackInSlot(i, items.getStackInSlot(i)); + } + return copy; + } + + public void dropAll(ICoverable coverable, ForgeDirection direction) { + for (int i = 0; i < items.getSlots(); i++) { + ItemStack tItem = items.getStackInSlot(i); + if (tItem == null) { + continue; + } + dropItem(coverable, direction, tItem); + items.setStackInSlot(i, null); + } + } + } + + private static void dropItem(ICoverable coverable, ForgeDirection direction, ItemStack tItem) { + final EntityItem tItemEntity = new EntityItem( + coverable.getWorld(), + coverable.getXCoord() + XSTR_INSTANCE.nextFloat() * 0.8F + 0.1F + direction.offsetX, + coverable.getYCoord() + XSTR_INSTANCE.nextFloat() * 0.8F + 0.1F + direction.offsetY, + coverable.getZCoord() + XSTR_INSTANCE.nextFloat() * 0.8F + 0.1F + direction.offsetZ, + new ItemStack(tItem.getItem(), tItem.stackSize, tItem.getItemDamage())); + if (tItem.hasTagCompound()) { + tItemEntity.getEntityItem() + .setTagCompound( + (NBTTagCompound) tItem.getTagCompound() + .copy()); + } + tItemEntity.motionX = (XSTR_INSTANCE.nextGaussian() * 0.05D); + tItemEntity.motionY = (XSTR_INSTANCE.nextGaussian() * 0.05D + 0.2D); + tItemEntity.motionZ = (XSTR_INSTANCE.nextGaussian() * 0.05D); + tItemEntity.hurtResistantTime = 999999; + tItemEntity.lifespan = 60000; + coverable.getWorld() + .spawnEntityInWorld(tItemEntity); + } +} diff --git a/src/main/java/gregtech/common/covers/CoverControlsWork.java b/src/main/java/gregtech/common/covers/CoverControlsWork.java new file mode 100644 index 0000000000..6c92c61351 --- /dev/null +++ b/src/main/java/gregtech/common/covers/CoverControlsWork.java @@ -0,0 +1,270 @@ +package gregtech.common.covers; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; + +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.common.widget.TextWidget; + +import gregtech.api.gui.modularui.CoverUIBuildContext; +import gregtech.api.gui.modularui.GTUITextures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.covers.IControlsWorkCover; +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.interfaces.tileentity.IMachineProgress; +import gregtech.api.util.CoverBehavior; +import gregtech.api.util.GTUtility; +import gregtech.api.util.ISerializableObject; +import gregtech.common.gui.modularui.widget.CoverDataControllerWidget; +import gregtech.common.gui.modularui.widget.CoverDataFollowerToggleButtonWidget; + +public class CoverControlsWork extends CoverBehavior implements IControlsWorkCover { + + public CoverControlsWork(ITexture coverTexture) { + super(coverTexture); + } + + @Override + public int doCoverThings(ForgeDirection side, byte aInputRedstone, int aCoverID, int aCoverVariable, + ICoverable aTileEntity, long aTimer) { + if (!makeSureOnlyOne(side, aTileEntity)) return 0; + if (aTileEntity instanceof IMachineProgress machine) { + if (aCoverVariable < 2) { + if ((aInputRedstone > 0) == (aCoverVariable == 0)) { + if (!machine.isAllowedToWork()) machine.enableWorking(); + } else if (machine.isAllowedToWork()) machine.disableWorking(); + machine.setWorkDataValue(aInputRedstone); + } else if (aCoverVariable == 2) { + machine.disableWorking(); + } else { + if (machine.wasShutdown() && machine.getLastShutDownReason() + .wasCritical()) { + machine.disableWorking(); + if (!mPlayerNotified) { + EntityPlayer player = lastPlayer == null ? null : lastPlayer.get(); + if (player != null) { + lastPlayer = null; + mPlayerNotified = true; + GTUtility.sendChatToPlayer( + player, + aTileEntity.getInventoryName() + "at " + + String.format( + "(%d,%d,%d)", + aTileEntity.getXCoord(), + aTileEntity.getYCoord(), + aTileEntity.getZCoord()) + + " shut down."); + } + } + return 2; + } else { + return 3 + doCoverThings(side, aInputRedstone, aCoverID, aCoverVariable - 3, aTileEntity, aTimer); + } + } + } + return aCoverVariable; + } + + @Override + protected boolean isRedstoneSensitiveImpl(ForgeDirection side, int aCoverID, + ISerializableObject.LegacyCoverData aCoverVariable, ICoverable aTileEntity, long aTimer) { + return aCoverVariable.get() != 2; // always off, so no redstone needed either + } + + /** + * Make sure there is only one GT_Cover_ControlsWork on the aTileEntity TODO this is a migration thing. Remove this + * after 2.3.0 is released. + * + * @return true if the cover is the first (side) one + **/ + private boolean makeSureOnlyOne(ForgeDirection side, ICoverable aTileEntity) { + return IControlsWorkCover.makeSureOnlyOne(side, aTileEntity); + } + + @Override + public boolean letsEnergyIn(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsEnergyOut(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsFluidIn(ForgeDirection side, int aCoverID, int aCoverVariable, Fluid aFluid, + ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsFluidOut(ForgeDirection side, int aCoverID, int aCoverVariable, Fluid aFluid, + ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsItemsIn(ForgeDirection side, int aCoverID, int aCoverVariable, int aSlot, + ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsItemsOut(ForgeDirection side, int aCoverID, int aCoverVariable, int aSlot, + ICoverable aTileEntity) { + return true; + } + + @Override + public boolean onCoverRemoval(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity, + boolean aForced) { + if ((aTileEntity instanceof IMachineProgress)) { + ((IMachineProgress) aTileEntity).enableWorking(); + ((IMachineProgress) aTileEntity).setWorkDataValue((byte) 0); + } + return true; + } + + @Override + public int onCoverScrewdriverclick(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity, + EntityPlayer aPlayer, float aX, float aY, float aZ) { + aCoverVariable = (aCoverVariable + (aPlayer.isSneaking() ? -1 : 1)) % 5; + if (aCoverVariable < 0) { + aCoverVariable = 2; + } + if (aCoverVariable == 0) { + GTUtility.sendChatToPlayer(aPlayer, GTUtility.trans("003", "Enable with Signal")); + } + if (aCoverVariable == 1) { + GTUtility.sendChatToPlayer(aPlayer, GTUtility.trans("004", "Disable with Signal")); + } + if (aCoverVariable == 2) { + GTUtility.sendChatToPlayer(aPlayer, GTUtility.trans("005", "Disabled")); + } + if (aCoverVariable == 3) { + GTUtility.sendChatToPlayer(aPlayer, GTUtility.trans("505", "Enable with Signal (Safe)")); + } + if (aCoverVariable == 4) { + GTUtility.sendChatToPlayer(aPlayer, GTUtility.trans("506", "Disable with Signal (Safe)")); + } + // TODO: Set lastPlayer + return aCoverVariable; + } + + @Override + public int getTickRate(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return 1; + } + + @Override + public boolean isCoverPlaceable(ForgeDirection side, ItemStack aStack, ICoverable aTileEntity) { + if (!super.isCoverPlaceable(side, aStack, aTileEntity)) return false; + for (final ForgeDirection tSide : ForgeDirection.VALID_DIRECTIONS) { + if (aTileEntity.getCoverBehaviorAtSideNew(tSide) instanceof IControlsWorkCover) { + return false; + } + } + return true; + } + + // GUI stuff + + @Override + public boolean hasCoverGUI() { + return true; + } + + @Override + public ModularWindow createWindow(CoverUIBuildContext buildContext) { + return new ControlsWorkUIFactory(buildContext).createWindow(); + } + + private class ControlsWorkUIFactory extends UIFactory { + + private static final int startX = 10; + private static final int startY = 25; + private static final int spaceX = 18; + private static final int spaceY = 18; + + public ControlsWorkUIFactory(CoverUIBuildContext buildContext) { + super(buildContext); + } + + @SuppressWarnings("PointlessArithmeticExpression") + @Override + protected void addUIWidgets(ModularWindow.Builder builder) { + builder + .widget( + new CoverDataControllerWidget.CoverDataIndexedControllerWidget_ToggleButtons<>( + this::getCoverData, + this::setCoverData, + CoverControlsWork.this, + (id, coverData) -> !getClickable(id, convert(coverData)), + (id, coverData) -> new ISerializableObject.LegacyCoverData( + getNewCoverVariable(id, convert(coverData)))) + .addToggleButton( + 0, + CoverDataFollowerToggleButtonWidget.ofDisableable(), + widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_REDSTONE_ON) + .setPos(spaceX * 0, spaceY * 0)) + .addToggleButton( + 1, + CoverDataFollowerToggleButtonWidget.ofDisableable(), + widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_REDSTONE_OFF) + .setPos(spaceX * 0, spaceY * 1)) + .addToggleButton( + 2, + CoverDataFollowerToggleButtonWidget.ofDisableable(), + widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_CROSS) + .setPos(spaceX * 0, spaceY * 2)) + .setPos(startX, startY)) + .widget( + new CoverDataControllerWidget<>(this::getCoverData, this::setCoverData, CoverControlsWork.this) + .addFollower( + CoverDataFollowerToggleButtonWidget.ofCheckAndCross(), + coverData -> convert(coverData) > 2, + (coverData, state) -> new ISerializableObject.LegacyCoverData( + adjustCoverVariable(state, convert(coverData))), + widget -> widget.setPos(spaceX * 0, spaceY * 3)) + .setPos(startX, startY)) + .widget( + new TextWidget(GTUtility.trans("243", "Enable with Redstone")) + .setDefaultColor(COLOR_TEXT_GRAY.get()) + .setPos(3 + startX + spaceX * 1, 4 + startY + spaceY * 0)) + .widget( + new TextWidget(GTUtility.trans("244", "Disable with Redstone")) + .setDefaultColor(COLOR_TEXT_GRAY.get()) + .setPos(3 + startX + spaceX * 1, 4 + startY + spaceY * 1)) + .widget( + new TextWidget(GTUtility.trans("245", "Disable machine")).setDefaultColor(COLOR_TEXT_GRAY.get()) + .setPos(3 + startX + spaceX * 1, 4 + startY + spaceY * 2)) + .widget( + new TextWidget(GTUtility.trans("507", "Safe Mode")).setDefaultColor(COLOR_TEXT_GRAY.get()) + .setPos(3 + startX + spaceX * 1, 4 + startY + spaceY * 3)); + } + + private int getNewCoverVariable(int id, int coverVariable) { + if (coverVariable > 2) { + return id + 3; + } else { + return id; + } + } + + private boolean getClickable(int id, int coverVariable) { + return ((id != coverVariable && id != coverVariable - 3) || id == 3); + } + + private int adjustCoverVariable(boolean safeMode, int coverVariable) { + if (safeMode && coverVariable <= 2) { + coverVariable += 3; + } + if (!safeMode && coverVariable > 2) { + coverVariable -= 3; + } + return coverVariable; + } + } +} diff --git a/src/main/java/gregtech/common/covers/CoverConveyor.java b/src/main/java/gregtech/common/covers/CoverConveyor.java new file mode 100644 index 0000000000..cb2690d95b --- /dev/null +++ b/src/main/java/gregtech/common/covers/CoverConveyor.java @@ -0,0 +1,325 @@ +package gregtech.common.covers; + +import static gregtech.api.util.GTUtility.moveMultipleItemStacks; + +import java.util.Arrays; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; + +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.common.widget.TextWidget; + +import gregtech.api.gui.modularui.CoverUIBuildContext; +import gregtech.api.gui.modularui.GTUITextures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.interfaces.tileentity.IMachineProgress; +import gregtech.api.util.CoverBehavior; +import gregtech.api.util.GTUtility; +import gregtech.api.util.ISerializableObject; +import gregtech.common.gui.modularui.widget.CoverDataControllerWidget; +import gregtech.common.gui.modularui.widget.CoverDataFollowerToggleButtonWidget; + +public class CoverConveyor extends CoverBehavior { + + public final int mTickRate; + private final int mMaxStacks; + + public CoverConveyor(int aTickRate, int maxStacks, ITexture coverTexture) { + super(coverTexture); + this.mTickRate = aTickRate; + this.mMaxStacks = maxStacks; + } + + @Override + public boolean isRedstoneSensitive(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity, + long aTimer) { + return false; + } + + @Override + public int doCoverThings(ForgeDirection side, 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; + } + } + final TileEntity tTileEntity = aTileEntity.getTileEntityAtSide(side); + final Object fromEntity = aCoverVariable % 2 == 0 ? aTileEntity : tTileEntity; + final Object toEntity = aCoverVariable % 2 != 0 ? aTileEntity : tTileEntity; + final ForgeDirection fromSide = aCoverVariable % 2 != 0 ? side.getOpposite() : side; + final ForgeDirection toSide = aCoverVariable % 2 == 0 ? side.getOpposite() : side; + + moveMultipleItemStacks( + fromEntity, + toEntity, + fromSide, + toSide, + null, + false, + (byte) 64, + (byte) 1, + (byte) 64, + (byte) 1, + this.mMaxStacks); + + return aCoverVariable; + } + + @Override + public int onCoverScrewdriverclick(ForgeDirection side, 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 -> GTUtility.sendChatToPlayer(aPlayer, GTUtility.trans("006", "Export")); + case 1 -> GTUtility.sendChatToPlayer(aPlayer, GTUtility.trans("007", "Import")); + case 2 -> GTUtility.sendChatToPlayer(aPlayer, GTUtility.trans("008", "Export (conditional)")); + case 3 -> GTUtility.sendChatToPlayer(aPlayer, GTUtility.trans("009", "Import (conditional)")); + case 4 -> GTUtility.sendChatToPlayer(aPlayer, GTUtility.trans("010", "Export (invert cond)")); + case 5 -> GTUtility.sendChatToPlayer(aPlayer, GTUtility.trans("011", "Import (invert cond)")); + case 6 -> GTUtility.sendChatToPlayer(aPlayer, GTUtility.trans("012", "Export allow Input")); + case 7 -> GTUtility.sendChatToPlayer(aPlayer, GTUtility.trans("013", "Import allow Output")); + case 8 -> GTUtility.sendChatToPlayer(aPlayer, GTUtility.trans("014", "Export allow Input (conditional)")); + case 9 -> GTUtility.sendChatToPlayer(aPlayer, GTUtility.trans("015", "Import allow Output (conditional)")); + case 10 -> GTUtility.sendChatToPlayer(aPlayer, GTUtility.trans("016", "Export allow Input (invert cond)")); + case 11 -> GTUtility.sendChatToPlayer(aPlayer, GTUtility.trans("017", "Import allow Output (invert cond)")); + } + return aCoverVariable; + } + + @Override + public boolean letsRedstoneGoIn(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsRedstoneGoOut(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsEnergyIn(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsEnergyOut(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsFluidIn(ForgeDirection side, int aCoverID, int aCoverVariable, Fluid aFluid, + ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsFluidOut(ForgeDirection side, int aCoverID, int aCoverVariable, Fluid aFluid, + ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsItemsIn(ForgeDirection side, int aCoverID, int aCoverVariable, int aSlot, + ICoverable aTileEntity) { + return (aCoverVariable >= 6) || (aCoverVariable % 2 != 0); + } + + @Override + public boolean letsItemsOut(ForgeDirection side, int aCoverID, int aCoverVariable, int aSlot, + ICoverable aTileEntity) { + return (aCoverVariable >= 6) || (aCoverVariable % 2 == 0); + } + + @Override + public boolean alwaysLookConnected(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public int getTickRate(ForgeDirection side, int aCoverID, int aCoverVariable, ICoverable aTileEntity) { + return this.mTickRate; + } + + // GUI stuff + + @Override + public boolean hasCoverGUI() { + return true; + } + + @Override + public ModularWindow createWindow(CoverUIBuildContext buildContext) { + return new ConveyorUIFactory(buildContext).createWindow(); + } + + private class ConveyorUIFactory extends UIFactory { + + private static final int startX = 10; + private static final int startY = 25; + private static final int spaceX = 18; + private static final int spaceY = 18; + + private CoverDataFollowerToggleButtonWidget mBlockWidget = null; + private CoverDataFollowerToggleButtonWidget mAllowWidget = null; + + public ConveyorUIFactory(CoverUIBuildContext buildContext) { + super(buildContext); + } + + @SuppressWarnings("PointlessArithmeticExpression") + @Override + protected void addUIWidgets(ModularWindow.Builder builder) { + builder.widget( + new CoverDataControllerWidget.CoverDataIndexedControllerWidget_ToggleButtons<>( + this::getCoverData, + this::setCoverData, + CoverConveyor.this, + (id, coverData) -> !getClickable(id, convert(coverData)), + (id, coverData) -> new ISerializableObject.LegacyCoverData( + getNewCoverVariable(id, convert(coverData)))) + .addToggleButton( + 0, + CoverDataFollowerToggleButtonWidget.ofDisableable(), + widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_EXPORT) + .addTooltip(GTUtility.trans("006", "Export")) +