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 --- .../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 ----------------- 22 files changed, 1800 insertions(+), 1801 deletions(-) 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/redstone') diff --git a/src/main/java/gregtech/common/covers/redstone/CoverAdvancedRedstoneReceiverBase.java b/src/main/java/gregtech/common/covers/redstone/CoverAdvancedRedstoneReceiverBase.java new file mode 100644 index 0000000000..68564e33e5 --- /dev/null +++ b/src/main/java/gregtech/common/covers/redstone/CoverAdvancedRedstoneReceiverBase.java @@ -0,0 +1,202 @@ +package gregtech.common.covers.redstone; + +import java.util.Arrays; +import java.util.UUID; + +import javax.annotation.Nonnull; + +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.nbt.NBTBase; +import net.minecraft.nbt.NBTTagCompound; + +import com.google.common.io.ByteArrayDataInput; +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.util.GTUtility; +import gregtech.api.util.ISerializableObject; +import gregtech.common.gui.modularui.widget.CoverDataControllerWidget; +import gregtech.common.gui.modularui.widget.CoverDataFollowerToggleButtonWidget; +import io.netty.buffer.ByteBuf; + +public abstract class CoverAdvancedRedstoneReceiverBase + extends CoverAdvancedWirelessRedstoneBase { + + public CoverAdvancedRedstoneReceiverBase(ITexture coverTexture) { + super(ReceiverData.class, coverTexture); + } + + @Override + public ReceiverData createDataObject() { + return new ReceiverData(); + } + + @Override + public ReceiverData createDataObject(int aLegacyData) { + return createDataObject(); + } + + // GUI stuff + + @Override + public ModularWindow createWindow(CoverUIBuildContext buildContext) { + return new AdvancedRedstoneReceiverBaseUIFactory(buildContext).createWindow(); + } + + private class AdvancedRedstoneReceiverBaseUIFactory extends AdvancedWirelessRedstoneBaseUIFactory { + + public AdvancedRedstoneReceiverBaseUIFactory(CoverUIBuildContext buildContext) { + super(buildContext); + } + + @Override + protected int getFrequencyRow() { + return 0; + } + + @Override + protected int getButtonRow() { + return 1; + } + + @Override + protected boolean isShiftPrivateLeft() { + return false; + } + + @Override + protected void addUIWidgets(ModularWindow.Builder builder) { + super.addUIWidgets(builder); + builder.widget( + new TextWidget(GTUtility.trans("335", "Gate Mode")).setDefaultColor(COLOR_TEXT_GRAY.get()) + .setPos(startX + spaceX * 5, 4 + startY + spaceY * 2)); + } + + @SuppressWarnings("PointlessArithmeticExpression") + @Override + protected void addUIForDataController(CoverDataControllerWidget controller) { + super.addUIForDataController(controller); + controller.addFollower( + CoverDataFollowerToggleButtonWidget.ofDisableable(), + coverData -> coverData.mode == GateMode.AND, + (coverData, state) -> { + coverData.mode = GateMode.AND; + return coverData; + }, + widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_GATE_AND) + .addTooltip(GTUtility.trans("331", "AND Gate")) + .setPos(spaceX * 0, spaceY * 2)) + .addFollower( + CoverDataFollowerToggleButtonWidget.ofDisableable(), + coverData -> coverData.mode == GateMode.NAND, + (coverData, state) -> { + coverData.mode = GateMode.NAND; + return coverData; + }, + widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_GATE_NAND) + .addTooltip(GTUtility.trans("332", "NAND Gate")) + .setPos(spaceX * 1, spaceY * 2)) + .addFollower( + CoverDataFollowerToggleButtonWidget.ofDisableable(), + coverData -> coverData.mode == GateMode.OR, + (coverData, state) -> { + coverData.mode = GateMode.OR; + return coverData; + }, + widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_GATE_OR) + .addTooltip(GTUtility.trans("333", "OR Gate")) + .setPos(spaceX * 2, spaceY * 2)) + .addFollower( + CoverDataFollowerToggleButtonWidget.ofDisableable(), + coverData -> coverData.mode == GateMode.NOR, + (coverData, state) -> { + coverData.mode = GateMode.NOR; + return coverData; + }, + widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_GATE_NOR) + .addTooltip(GTUtility.trans("334", "NOR Gate")) + .setPos(spaceX * 3, spaceY * 2)) + .addFollower( + CoverDataFollowerToggleButtonWidget.ofDisableable(), + coverData -> coverData.mode == GateMode.SINGLE_SOURCE, + (coverData, state) -> { + coverData.mode = GateMode.SINGLE_SOURCE; + return coverData; + }, + widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_ANALOG) + .addTooltips( + Arrays.asList( + "ANALOG Mode", + "Only use this mode with ONE transmitter in total,", + "no logic involved")) + .setPos(spaceX * 4, spaceY * 2)); + } + } + + public enum GateMode { + AND, + NAND, + OR, + NOR, + SINGLE_SOURCE + } + + public static class ReceiverData extends CoverAdvancedWirelessRedstoneBase.WirelessData { + + private GateMode mode; + + public ReceiverData(int frequency, UUID uuid, GateMode mode) { + super(frequency, uuid); + this.mode = mode; + } + + public ReceiverData() { + this(0, null, GateMode.AND); + } + + public GateMode getGateMode() { + return mode; + } + + @Nonnull + @Override + public ISerializableObject copy() { + return new ReceiverData(frequency, uuid, mode); + } + + @Nonnull + @Override + public NBTBase saveDataToNBT() { + NBTTagCompound tag = (NBTTagCompound) super.saveDataToNBT(); + tag.setByte("mode", (byte) mode.ordinal()); + + return tag; + } + + @Override + public void writeToByteBuf(ByteBuf aBuf) { + super.writeToByteBuf(aBuf); + aBuf.writeByte(mode.ordinal()); + } + + @Override + public void loadDataFromNBT(NBTBase aNBT) { + super.loadDataFromNBT(aNBT); + + NBTTagCompound tag = (NBTTagCompound) aNBT; + mode = GateMode.values()[tag.getByte("mode")]; + } + + @Nonnull + @Override + public ISerializableObject readFromPacket(ByteArrayDataInput aBuf, EntityPlayerMP aPlayer) { + super.readFromPacket(aBuf, aPlayer); + mode = GateMode.values()[aBuf.readByte()]; + + return this; + } + } +} diff --git a/src/main/java/gregtech/common/covers/redstone/CoverAdvancedRedstoneReceiverExternal.java b/src/main/java/gregtech/common/covers/redstone/CoverAdvancedRedstoneReceiverExternal.java new file mode 100644 index 0000000000..5473ab3fec --- /dev/null +++ b/src/main/java/gregtech/common/covers/redstone/CoverAdvancedRedstoneReceiverExternal.java @@ -0,0 +1,35 @@ +package gregtech.common.covers.redstone; + +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.ICoverable; + +public class CoverAdvancedRedstoneReceiverExternal extends CoverAdvancedRedstoneReceiverBase { + + public CoverAdvancedRedstoneReceiverExternal(ITexture coverTexture) { + super(coverTexture); + } + + @Override + public ReceiverData doCoverThingsImpl(ForgeDirection side, byte aInputRedstone, int aCoverID, + ReceiverData aCoverVariable, ICoverable aTileEntity, long aTimer) { + aTileEntity.setOutputRedstoneSignal( + side, + getSignalAt(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), aCoverVariable.getGateMode())); + + return aCoverVariable; + } + + @Override + protected boolean isRedstoneSensitiveImpl(ForgeDirection side, int aCoverID, ReceiverData aCoverVariable, + ICoverable aTileEntity, long aTimer) { + return false; + } + + @Override + protected boolean manipulatesSidedRedstoneOutputImpl(ForgeDirection side, int aCoverID, ReceiverData aCoverVariable, + ICoverable aTileEntity) { + return true; + } +} diff --git a/src/main/java/gregtech/common/covers/redstone/CoverAdvancedRedstoneReceiverInternal.java b/src/main/java/gregtech/common/covers/redstone/CoverAdvancedRedstoneReceiverInternal.java new file mode 100644 index 0000000000..f22a81bdba --- /dev/null +++ b/src/main/java/gregtech/common/covers/redstone/CoverAdvancedRedstoneReceiverInternal.java @@ -0,0 +1,42 @@ +package gregtech.common.covers.redstone; + +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.interfaces.tileentity.IMachineProgress; + +public class CoverAdvancedRedstoneReceiverInternal extends CoverAdvancedRedstoneReceiverBase { + + public CoverAdvancedRedstoneReceiverInternal(ITexture coverTexture) { + super(coverTexture); + } + + @Override + public ReceiverData doCoverThingsImpl(ForgeDirection side, byte aInputRedstone, int aCoverID, + ReceiverData aCoverVariable, ICoverable aTileEntity, long aTimer) { + if (aTileEntity instanceof IMachineProgress machine) { + if (getRedstoneInput(side, aInputRedstone, aCoverID, aCoverVariable, aTileEntity) > 0) { + machine.enableWorking(); + } else { + machine.disableWorking(); + } + + machine.setWorkDataValue(aInputRedstone); + } + + return aCoverVariable; + } + + @Override + protected byte getRedstoneInputImpl(ForgeDirection side, byte aInputRedstone, int aCoverID, + ReceiverData aCoverVariable, ICoverable aTileEntity) { + return getSignalAt(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), aCoverVariable.getGateMode()); + } + + @Override + protected boolean isRedstoneSensitiveImpl(ForgeDirection side, int aCoverID, ReceiverData aCoverVariable, + ICoverable aTileEntity, long aTimer) { + return true; + } +} diff --git a/src/main/java/gregtech/common/covers/redstone/CoverAdvancedRedstoneTransmitterBase.java b/src/main/java/gregtech/common/covers/redstone/CoverAdvancedRedstoneTransmitterBase.java new file mode 100644 index 0000000000..cfa5461305 --- /dev/null +++ b/src/main/java/gregtech/common/covers/redstone/CoverAdvancedRedstoneTransmitterBase.java @@ -0,0 +1,188 @@ +package gregtech.common.covers.redstone; + +import java.util.Objects; +import java.util.UUID; + +import javax.annotation.Nonnull; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.nbt.NBTBase; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.common.util.ForgeDirection; + +import com.google.common.io.ByteArrayDataInput; +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.common.widget.TextWidget; + +import gregtech.api.gui.modularui.CoverUIBuildContext; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.util.GTUtility; +import gregtech.api.util.ISerializableObject; +import gregtech.common.gui.modularui.widget.CoverDataControllerWidget; +import gregtech.common.gui.modularui.widget.CoverDataFollowerToggleButtonWidget; +import io.netty.buffer.ByteBuf; + +public abstract class CoverAdvancedRedstoneTransmitterBase + extends CoverAdvancedWirelessRedstoneBase { + + public CoverAdvancedRedstoneTransmitterBase(Class typeToken, ITexture coverTexture) { + super(typeToken, coverTexture); + } + + private static void unregisterSignal(ForgeDirection side, TransmitterData aCoverVariable, ICoverable aTileEntity) { + final long hash = hashCoverCoords(aTileEntity, side); + removeSignalAt(aCoverVariable.uuid, aCoverVariable.frequency, hash); + } + + @Override + public boolean onCoverRemovalImpl(ForgeDirection side, int aCoverID, TransmitterData aCoverVariable, + ICoverable aTileEntity, boolean aForced) { + unregisterSignal(side, aCoverVariable, aTileEntity); + return true; + } + + @Override + protected void onBaseTEDestroyedImpl(ForgeDirection side, int aCoverID, TransmitterData aCoverVariable, + ICoverable aTileEntity) { + unregisterSignal(side, aCoverVariable, aTileEntity); + } + + @Override + protected T onCoverScrewdriverClickImpl(ForgeDirection side, int aCoverID, T aCoverVariable, ICoverable aTileEntity, + EntityPlayer aPlayer, float aX, float aY, float aZ) { + aCoverVariable.invert = !aCoverVariable.invert; + GTUtility.sendChatToPlayer( + aPlayer, + aCoverVariable.invert ? GTUtility.trans("054", "Inverted") : GTUtility.trans("055", "Normal")); + + return aCoverVariable; + } + + @Override + protected void preDataChangedImpl(ForgeDirection side, int aCoverID, int aNewCoverId, T aCoverVariable, + T aNewCoverVariable, ICoverable aTileEntity) { + if (aCoverVariable.frequency != aNewCoverVariable.frequency + || !Objects.equals(aCoverVariable.uuid, aNewCoverVariable.uuid)) { + unregisterSignal(side, aCoverVariable, aTileEntity); + } + } + + public static class TransmitterData extends CoverAdvancedWirelessRedstoneBase.WirelessData { + + protected boolean invert; + + public TransmitterData(int frequency, UUID uuid, boolean invert) { + super(frequency, uuid); + this.invert = invert; + } + + public TransmitterData() { + this(0, null, false); + } + + public boolean isInvert() { + return invert; + } + + @Nonnull + @Override + public ISerializableObject copy() { + return new TransmitterData(frequency, uuid, invert); + } + + @Nonnull + @Override + public NBTBase saveDataToNBT() { + NBTTagCompound tag = (NBTTagCompound) super.saveDataToNBT(); + tag.setBoolean("invert", invert); + + return tag; + } + + @Override + public void writeToByteBuf(ByteBuf aBuf) { + super.writeToByteBuf(aBuf); + aBuf.writeBoolean(invert); + } + + @Override + public void loadDataFromNBT(NBTBase aNBT) { + super.loadDataFromNBT(aNBT); + + NBTTagCompound tag = (NBTTagCompound) aNBT; + invert = tag.getBoolean("invert"); + } + + @Nonnull + @Override + public ISerializableObject readFromPacket(ByteArrayDataInput aBuf, EntityPlayerMP aPlayer) { + super.readFromPacket(aBuf, aPlayer); + invert = aBuf.readBoolean(); + + return this; + } + } + + // GUI stuff + + @Override + public ModularWindow createWindow(CoverUIBuildContext buildContext) { + return new AdvancedRedstoneTransmitterBaseUIFactory(buildContext).createWindow(); + } + + protected class AdvancedRedstoneTransmitterBaseUIFactory extends AdvancedWirelessRedstoneBaseUIFactory { + + public AdvancedRedstoneTransmitterBaseUIFactory(CoverUIBuildContext buildContext) { + super(buildContext); + } + + @Override + protected int getFrequencyRow() { + return 0; + } + + @Override + protected int getButtonRow() { + return 1; + } + + @Override + protected boolean isShiftPrivateLeft() { + return true; + } + + @Override + protected void addUIWidgets(ModularWindow.Builder builder) { + super.addUIWidgets(builder); + builder.widget(TextWidget.dynamicString(() -> { + T coverData = getCoverData(); + if (coverData != null) { + return getCoverData().invert ? GTUtility.trans("INVERTED", "Inverted") + : GTUtility.trans("NORMAL", "Normal"); + } else { + return ""; + } + }) + .setSynced(false) + .setDefaultColor(COLOR_TEXT_GRAY.get()) + .setPos(startX + spaceX * 10, 4 + startY + spaceY * getButtonRow())); + } + + @Override + protected void addUIForDataController(CoverDataControllerWidget controller) { + super.addUIForDataController(controller); + controller.addFollower( + CoverDataFollowerToggleButtonWidget.ofRedstone(), + coverData -> coverData.invert, + (coverData, state) -> { + coverData.invert = state; + return coverData; + }, + widget -> widget.addTooltip(0, GTUtility.trans("NORMAL", "Normal")) + .addTooltip(1, GTUtility.trans("INVERTED", "Inverted")) + .setPos(spaceX * 9, spaceY * getButtonRow())); + } + } +} diff --git a/src/main/java/gregtech/common/covers/redstone/CoverAdvancedRedstoneTransmitterExternal.java b/src/main/java/gregtech/common/covers/redstone/CoverAdvancedRedstoneTransmitterExternal.java new file mode 100644 index 0000000000..71003974c5 --- /dev/null +++ b/src/main/java/gregtech/common/covers/redstone/CoverAdvancedRedstoneTransmitterExternal.java @@ -0,0 +1,51 @@ +package gregtech.common.covers.redstone; + +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.ICoverable; + +public class CoverAdvancedRedstoneTransmitterExternal + extends CoverAdvancedRedstoneTransmitterBase { + + public CoverAdvancedRedstoneTransmitterExternal(ITexture coverTexture) { + super(TransmitterData.class, coverTexture); + } + + @Override + public TransmitterData createDataObject() { + return new TransmitterData(); + } + + @Override + public TransmitterData createDataObject(int aLegacyData) { + return createDataObject(); + } + + @Override + public TransmitterData doCoverThingsImpl(ForgeDirection side, byte aInputRedstone, int aCoverID, + TransmitterData aCoverVariable, ICoverable aTileEntity, long aTimer) { + byte outputRedstone = aInputRedstone; + if (aCoverVariable.isInvert()) { + if (outputRedstone > 0) outputRedstone = 0; + else outputRedstone = 15; + } + + final long hash = hashCoverCoords(aTileEntity, side); + setSignalAt(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), hash, outputRedstone); + + return aCoverVariable; + } + + @Override + protected boolean isRedstoneSensitiveImpl(ForgeDirection side, int aCoverID, TransmitterData aCoverVariable, + ICoverable aTileEntity, long aTimer) { + return true; + } + + @Override + public boolean letsRedstoneGoInImpl(ForgeDirection side, int aCoverID, TransmitterData aCoverVariable, + ICoverable aTileEntity) { + return true; + } +} diff --git a/src/main/java/gregtech/common/covers/redstone/CoverAdvancedRedstoneTransmitterInternal.java b/src/main/java/gregtech/common/covers/redstone/CoverAdvancedRedstoneTransmitterInternal.java new file mode 100644 index 0000000000..ab368e0c5b --- /dev/null +++ b/src/main/java/gregtech/common/covers/redstone/CoverAdvancedRedstoneTransmitterInternal.java @@ -0,0 +1,50 @@ +package gregtech.common.covers.redstone; + +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.ICoverable; + +public class CoverAdvancedRedstoneTransmitterInternal + extends CoverAdvancedRedstoneTransmitterBase { + + public CoverAdvancedRedstoneTransmitterInternal(ITexture coverTexture) { + super(TransmitterData.class, coverTexture); + } + + @Override + public TransmitterData createDataObject() { + return new TransmitterData(); + } + + @Override + public TransmitterData createDataObject(int aLegacyData) { + return createDataObject(); + } + + @Override + public TransmitterData doCoverThingsImpl(ForgeDirection side, byte aInputRedstone, int aCoverID, + TransmitterData aCoverVariable, ICoverable aTileEntity, long aTimer) { + byte outputRedstone = aTileEntity.getOutputRedstoneSignal(side); + if (aCoverVariable.isInvert()) { + if (outputRedstone > 0) outputRedstone = 0; + else outputRedstone = 15; + } + + final long hash = hashCoverCoords(aTileEntity, side); + setSignalAt(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), hash, outputRedstone); + return aCoverVariable; + } + + @Override + public boolean letsRedstoneGoOutImpl(ForgeDirection side, int aCoverID, TransmitterData aCoverVariable, + ICoverable aTileEntity) { + return true; + } + + @Override + protected boolean manipulatesSidedRedstoneOutputImpl(ForgeDirection side, int aCoverID, + TransmitterData aCoverVariable, ICoverable aTileEntity) { + return true; + } +} diff --git a/src/main/java/gregtech/common/covers/redstone/CoverAdvancedWirelessRedstoneBase.java b/src/main/java/gregtech/common/covers/redstone/CoverAdvancedWirelessRedstoneBase.java new file mode 100644 index 0000000000..963678a24c --- /dev/null +++ b/src/main/java/gregtech/common/covers/redstone/CoverAdvancedWirelessRedstoneBase.java @@ -0,0 +1,298 @@ +package gregtech.common.covers.redstone; + +import java.util.Map; +import java.util.UUID; +import java.util.concurrent.ConcurrentHashMap; + +import javax.annotation.Nonnull; + +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.nbt.NBTBase; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; + +import com.google.common.io.ByteArrayDataInput; +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.common.widget.TextWidget; + +import gregtech.api.GregTechAPI; +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.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; +import io.netty.buffer.ByteBuf; + +public abstract class CoverAdvancedWirelessRedstoneBase + extends CoverBehaviorBase { + + public CoverAdvancedWirelessRedstoneBase(Class typeToken, ITexture coverTexture) { + super(typeToken, coverTexture); + } + + public static Byte getSignalAt(UUID uuid, int frequency, CoverAdvancedRedstoneReceiverBase.GateMode mode) { + Map> frequencies = GregTechAPI.sAdvancedWirelessRedstone.get(String.valueOf(uuid)); + if (frequencies == null) return 0; + + Map signals = frequencies.get(frequency); + if (signals == null) signals = new ConcurrentHashMap<>(); + + switch (mode) { + case AND -> { + return (byte) (signals.values() + .stream() + .map(signal -> signal > 0) + .reduce(true, (signalA, signalB) -> signalA && signalB) ? 15 : 0); + } + case NAND -> { + return (byte) (signals.values() + .stream() + .map(signal -> signal > 0) + .reduce(true, (signalA, signalB) -> signalA && signalB) ? 0 : 15); + } + case OR -> { + return (byte) (signals.values() + .stream() + .map(signal -> signal > 0) + .reduce(false, (signalA, signalB) -> signalA || signalB) ? 15 : 0); + } + case NOR -> { + return (byte) (signals.values() + .stream() + .map(signal -> signal > 0) + .reduce(false, (signalA, signalB) -> signalA || signalB) ? 0 : 15); + } + case SINGLE_SOURCE -> { + if (signals.values() + .isEmpty()) { + return 0; + } + return signals.values() + .iterator() + .next(); + } + default -> { + return 0; + } + } + } + + public static void removeSignalAt(UUID uuid, int frequency, long hash) { + Map> frequencies = GregTechAPI.sAdvancedWirelessRedstone.get(String.valueOf(uuid)); + if (frequencies == null) return; + frequencies.computeIfPresent(frequency, (freq, longByteMap) -> { + longByteMap.remove(hash); + return longByteMap.isEmpty() ? null : longByteMap; + }); + } + + public static void setSignalAt(UUID uuid, int frequency, long hash, byte value) { + Map> frequencies = GregTechAPI.sAdvancedWirelessRedstone + .computeIfAbsent(String.valueOf(uuid), k -> new ConcurrentHashMap<>()); + Map signals = frequencies.computeIfAbsent(frequency, k -> new ConcurrentHashMap<>()); + signals.put(hash, value); + } + + /** + * x hashed into first 20 bytes y hashed into second 20 bytes z hashed into fifth 10 bytes dim hashed into sixth 10 + * bytes side hashed into last 4 bytes + */ + public static long hashCoverCoords(ICoverable tile, ForgeDirection side) { + return (((((long) tile.getXCoord() << 20) + tile.getZCoord() << 10) + tile.getYCoord() << 10) + + tile.getWorld().provider.dimensionId << 4) + side.ordinal(); + } + + @Override + public boolean letsEnergyInImpl(ForgeDirection side, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsEnergyOutImpl(ForgeDirection side, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsFluidInImpl(ForgeDirection side, int aCoverID, T aCoverVariable, Fluid aFluid, + ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsFluidOutImpl(ForgeDirection side, int aCoverID, T aCoverVariable, Fluid aFluid, + ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsItemsInImpl(ForgeDirection side, int aCoverID, T aCoverVariable, int aSlot, + ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsItemsOutImpl(ForgeDirection side, int aCoverID, T aCoverVariable, int aSlot, + ICoverable aTileEntity) { + return true; + } + + @Override + public String getDescriptionImpl(ForgeDirection side, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { + return GTUtility.trans("081", "Frequency: ") + aCoverVariable.frequency + + ", Transmission: " + + (aCoverVariable.uuid == null ? "Public" : "Private"); + } + + @Override + public int getTickRateImpl(ForgeDirection side, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { + return 5; + } + + public abstract static class WirelessData implements ISerializableObject { + + protected int frequency; + + /** + * If UUID is set to null, the cover frequency is public, rather than private + **/ + protected UUID uuid; + + public WirelessData(int frequency, UUID uuid) { + this.frequency = frequency; + this.uuid = uuid; + } + + public UUID getUuid() { + return uuid; + } + + public int getFrequency() { + return frequency; + } + + @Nonnull + @Override + public NBTBase saveDataToNBT() { + NBTTagCompound tag = new NBTTagCompound(); + tag.setInteger("frequency", frequency); + if (uuid != null) { + tag.setString("uuid", uuid.toString()); + } + + return tag; + } + + @Override + public void writeToByteBuf(ByteBuf aBuf) { + aBuf.writeInt(frequency); + aBuf.writeBoolean(uuid != null); + if (uuid != null) { + aBuf.writeLong(uuid.getLeastSignificantBits()); + aBuf.writeLong(uuid.getMostSignificantBits()); + } + } + + @Override + public void loadDataFromNBT(NBTBase aNBT) { + NBTTagCompound tag = (NBTTagCompound) aNBT; + frequency = tag.getInteger("frequency"); + if (tag.hasKey("uuid")) { + uuid = UUID.fromString(tag.getString("uuid")); + } + } + + @Nonnull + @Override + public ISerializableObject readFromPacket(ByteArrayDataInput aBuf, EntityPlayerMP aPlayer) { + frequency = aBuf.readInt(); + if (aBuf.readBoolean()) { + uuid = new UUID(aBuf.readLong(), aBuf.readLong()); + } + + return this; + } + } + + // GUI stuff + + @Override + public boolean hasCoverGUI() { + return true; + } + + protected abstract class AdvancedWirelessRedstoneBaseUIFactory extends UIFactory { + + protected static final int startX = 10; + protected static final int startY = 25; + protected static final int spaceX = 18; + protected static final int spaceY = 18; + + public AdvancedWirelessRedstoneBaseUIFactory(CoverUIBuildContext buildContext) { + super(buildContext); + } + + @Override + protected int getGUIWidth() { + return 250; + } + + @Override + protected void addUIWidgets(ModularWindow.Builder builder) { + final int privateExtraColumn = isShiftPrivateLeft() ? 1 : 5; + + CoverDataControllerWidget dataController = new CoverDataControllerWidget<>( + this::getCoverData, + this::setCoverData, + CoverAdvancedWirelessRedstoneBase.this); + dataController.setPos(startX, startY); + addUIForDataController(dataController); + + builder.widget(dataController) + .widget( + new TextWidget(GTUtility.trans("246", "Frequency")).setDefaultColor(COLOR_TEXT_GRAY.get()) + .setPos(startX + spaceX * 5, 4 + startY + spaceY * getFrequencyRow())) + .widget( + new TextWidget(GTUtility.trans("602", "Use Private Frequency")) + .setDefaultColor(COLOR_TEXT_GRAY.get()) + .setPos(startX + spaceX * privateExtraColumn, 4 + startY + spaceY * getButtonRow())); + } + + protected void addUIForDataController(CoverDataControllerWidget controller) { + controller.addFollower( + new CoverDataFollowerNumericWidget<>(), + coverData -> (double) coverData.frequency, + (coverData, state) -> { + coverData.frequency = state.intValue(); + return coverData; + }, + widget -> widget.setScrollValues(1, 1000, 10) + .setBounds(0, Integer.MAX_VALUE) + .setPos(1, 2 + spaceY * getFrequencyRow()) + .setSize(spaceX * 5 - 4, 12)) + .addFollower( + CoverDataFollowerToggleButtonWidget.ofCheck(), + coverData -> coverData.uuid != null, + (coverData, state) -> { + if (state) { + coverData.uuid = getUIBuildContext().getPlayer() + .getUniqueID(); + } else { + coverData.uuid = null; + } + return coverData; + }, + widget -> widget.setPos(0, spaceY * getButtonRow())); + } + + protected abstract int getFrequencyRow(); + + protected abstract int getButtonRow(); + + protected abstract boolean isShiftPrivateLeft(); + } +} diff --git a/src/main/java/gregtech/common/covers/redstone/CoverWirelessDoesWorkDetector.java b/src/main/java/gregtech/common/covers/redstone/CoverWirelessDoesWorkDetector.java new file mode 100644 index 0000000000..ed55280b7f --- /dev/null +++ b/src/main/java/gregtech/common/covers/redstone/CoverWirelessDoesWorkDetector.java @@ -0,0 +1,244 @@ +package gregtech.common.covers.redstone; + +import java.util.UUID; + +import javax.annotation.Nonnull; + +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.nbt.NBTBase; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.common.util.ForgeDirection; + +import com.google.common.io.ByteArrayDataInput; +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.GTUtility; +import gregtech.api.util.ISerializableObject; +import gregtech.common.gui.modularui.widget.CoverDataControllerWidget; +import gregtech.common.gui.modularui.widget.CoverDataFollowerToggleButtonWidget; +import io.netty.buffer.ByteBuf; + +public class CoverWirelessDoesWorkDetector + extends CoverAdvancedRedstoneTransmitterBase { + + public CoverWirelessDoesWorkDetector(ITexture coverTexture) { + super(ActivityTransmitterData.class, coverTexture); + } + + @Override + public ActivityTransmitterData createDataObject() { + return new ActivityTransmitterData(); + } + + @Override + public ActivityTransmitterData createDataObject(int aLegacyData) { + return createDataObject(); + } + + private static byte computeSignalBasedOnActivity(ActivityTransmitterData coverVariable, ICoverable tileEntity) { + + if (tileEntity instanceof IMachineProgress) { + IMachineProgress mProgress = (IMachineProgress) tileEntity; + boolean inverted = coverVariable.invert; + int signal = 0; + + switch (coverVariable.mode) { + case MACHINE_ENABLED -> signal = inverted == mProgress.isAllowedToWork() ? 0 : 15; + case MACHINE_IDLE -> signal = inverted == (mProgress.getMaxProgress() == 0) ? 0 : 15; + case RECIPE_PROGRESS -> { + int tScale = mProgress.getMaxProgress() / 15; + + if (tScale > 0 && mProgress.hasThingsToDo()) { + signal = inverted ? (15 - mProgress.getProgress() / tScale) + : (mProgress.getProgress() / tScale); + } else { + signal = inverted ? 15 : 0; + } + } + } + + return (byte) signal; + } else { + return (byte) 0; + } + + } + + @Override + public ActivityTransmitterData doCoverThingsImpl(ForgeDirection side, byte aInputRedstone, int aCoverID, + ActivityTransmitterData aCoverVariable, ICoverable aTileEntity, long aTimer) { + final byte signal = computeSignalBasedOnActivity(aCoverVariable, aTileEntity); + final long hash = hashCoverCoords(aTileEntity, side); + setSignalAt(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), hash, signal); + + return aCoverVariable; + } + + @Override + public boolean letsRedstoneGoOutImpl(ForgeDirection side, int aCoverID, ActivityTransmitterData aCoverVariable, + ICoverable aTileEntity) { + return true; + } + + @Override + protected boolean manipulatesSidedRedstoneOutputImpl(ForgeDirection side, int aCoverID, + ActivityTransmitterData aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public int getTickRateImpl(ForgeDirection side, int aCoverID, ActivityTransmitterData aCoverVariable, + ICoverable aTileEntity) { + return 5; + } + + public enum ActivityMode { + RECIPE_PROGRESS, + MACHINE_IDLE, + MACHINE_ENABLED, + } + + public static class ActivityTransmitterData extends CoverAdvancedRedstoneTransmitterBase.TransmitterData { + + private ActivityMode mode; + + public ActivityTransmitterData(int frequency, UUID uuid, boolean invert, ActivityMode mode) { + super(frequency, uuid, invert); + this.mode = mode; + } + + public ActivityTransmitterData() { + super(); + this.mode = ActivityMode.MACHINE_IDLE; + } + + @Nonnull + @Override + public ISerializableObject copy() { + return new ActivityTransmitterData(frequency, uuid, invert, mode); + } + + @Nonnull + @Override + public NBTBase saveDataToNBT() { + NBTTagCompound tag = (NBTTagCompound) super.saveDataToNBT(); + tag.setInteger("mode", mode.ordinal()); + + return tag; + } + + @Override + public void writeToByteBuf(ByteBuf aBuf) { + super.writeToByteBuf(aBuf); + aBuf.writeInt(mode.ordinal()); + } + + @Override + public void loadDataFromNBT(NBTBase aNBT) { + super.loadDataFromNBT(aNBT); + + NBTTagCompound tag = (NBTTagCompound) aNBT; + mode = ActivityMode.values()[tag.getInteger("mode")]; + } + + @Nonnull + @Override + public ISerializableObject readFromPacket(ByteArrayDataInput aBuf, EntityPlayerMP aPlayer) { + super.readFromPacket(aBuf, aPlayer); + mode = ActivityMode.values()[aBuf.readInt()]; + + return this; + } + } + + @Override + public ModularWindow createWindow(CoverUIBuildContext buildContext) { + return new WirelessActivityDetectorUIFactory(buildContext).createWindow(); + } + + private class WirelessActivityDetectorUIFactory extends AdvancedRedstoneTransmitterBaseUIFactory { + + public WirelessActivityDetectorUIFactory(CoverUIBuildContext buildContext) { + super(buildContext); + } + + @Override + protected int getGUIHeight() { + return 107; + } + + @Override + protected int getFrequencyRow() { + return 0; + } + + @Override + protected int getButtonRow() { + return 1; + } + + @Override + protected void addUIWidgets(ModularWindow.Builder builder) { + super.addUIWidgets(builder); + builder.widget(TextWidget.dynamicString(() -> { + + ActivityMode mode = getCoverData().mode; + + if (mode == ActivityMode.MACHINE_ENABLED) { + return GTUtility.trans("271", "Machine enabled"); + } else if (mode == ActivityMode.MACHINE_IDLE) { + return GTUtility.trans("242", "Machine idle"); + } else { + return GTUtility.trans("241", "Recipe progress"); + } + + }) + .setSynced(false) + .setDefaultColor(COLOR_TEXT_GRAY.get()) + .setPos(startX + spaceX * 3, 4 + startY + spaceY * 2)); + } + + @Override + protected void addUIForDataController(CoverDataControllerWidget controller) { + super.addUIForDataController(controller); + + controller.addFollower( + CoverDataFollowerToggleButtonWidget.ofDisableable(), + coverData -> coverData.mode == ActivityMode.RECIPE_PROGRESS, + (coverData, state) -> { + coverData.mode = ActivityMode.RECIPE_PROGRESS; + return coverData; + }, + widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_PROGRESS) + .addTooltip(GTUtility.trans("241", "Recipe progress")) + .setPos(spaceX * 0, spaceY * 2)) + .addFollower( + CoverDataFollowerToggleButtonWidget.ofDisableable(), + coverData -> coverData.mode == ActivityMode.MACHINE_IDLE, + (coverData, state) -> { + coverData.mode = ActivityMode.MACHINE_IDLE; + return coverData; + }, + widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_CHECKMARK) + .addTooltip(GTUtility.trans("242", "Machine idle")) + .setPos(spaceX * 1, spaceY * 2)) + .addFollower( + CoverDataFollowerToggleButtonWidget.ofDisableable(), + coverData -> coverData.mode == ActivityMode.MACHINE_ENABLED, + (coverData, state) -> { + coverData.mode = ActivityMode.MACHINE_ENABLED; + return coverData; + }, + widget -> widget.setStaticTexture(GTUITextures.OVERLAY_BUTTON_POWER_SWITCH_ON) + .addTooltip(GTUtility.trans("271", "Machine enabled")) + .setPos(spaceX * 2, spaceY * 2)); + } + } + +} diff --git a/src/main/java/gregtech/common/covers/redstone/CoverWirelessFluidDetector.java b/src/main/java/gregtech/common/covers/redstone/CoverWirelessFluidDetector.java new file mode 100644 index 0000000000..cfea9b7b28 --- /dev/null +++ b/src/main/java/gregtech/common/covers/redstone/CoverWirelessFluidDetector.java @@ -0,0 +1,186 @@ +package gregtech.common.covers.redstone; + +import java.util.Arrays; +import java.util.UUID; + +import javax.annotation.Nonnull; + +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.nbt.NBTBase; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.FluidTankInfo; +import net.minecraftforge.fluids.IFluidHandler; + +import com.google.common.io.ByteArrayDataInput; +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.common.widget.TextWidget; + +import gregtech.api.gui.modularui.CoverUIBuildContext; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.util.GTUtility; +import gregtech.api.util.ISerializableObject; +import gregtech.common.covers.CoverLiquidMeter; +import gregtech.common.gui.modularui.widget.CoverDataControllerWidget; +import gregtech.common.gui.modularui.widget.CoverDataFollowerNumericWidget; +import io.netty.buffer.ByteBuf; + +public class CoverWirelessFluidDetector + extends CoverAdvancedRedstoneTransmitterBase { + + public CoverWirelessFluidDetector(ITexture coverTexture) { + super(FluidTransmitterData.class, coverTexture); + } + + @Override + public FluidTransmitterData createDataObject() { + return new FluidTransmitterData(); + } + + @Override + public FluidTransmitterData createDataObject(int aLegacyData) { + return createDataObject(); + } + + @Override + public FluidTransmitterData doCoverThingsImpl(ForgeDirection side, byte aInputRedstone, int aCoverID, + FluidTransmitterData aCoverVariable, ICoverable aTileEntity, long aTimer) { + final byte signal = CoverLiquidMeter + .computeSignalBasedOnFluid(aTileEntity, aCoverVariable.invert, aCoverVariable.threshold); + final long hash = hashCoverCoords(aTileEntity, side); + setSignalAt(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), hash, signal); + + return aCoverVariable; + } + + @Override + public boolean letsRedstoneGoOutImpl(ForgeDirection side, int aCoverID, FluidTransmitterData aCoverVariable, + ICoverable aTileEntity) { + return true; + } + + @Override + protected boolean manipulatesSidedRedstoneOutputImpl(ForgeDirection side, int aCoverID, + FluidTransmitterData aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public static class FluidTransmitterData extends CoverAdvancedRedstoneTransmitterBase.TransmitterData { + + /** The special value {@code 0} means threshold check is disabled. */ + private int threshold; + + public FluidTransmitterData(int frequency, UUID uuid, boolean invert, int threshold) { + super(frequency, uuid, invert); + this.threshold = threshold; + } + + public FluidTransmitterData() { + super(); + this.threshold = 0; + } + + @Nonnull + @Override + public ISerializableObject copy() { + return new FluidTransmitterData(frequency, uuid, invert, threshold); + } + + @Nonnull + @Override + public NBTBase saveDataToNBT() { + NBTTagCompound tag = (NBTTagCompound) super.saveDataToNBT(); + tag.setInteger("threshold", threshold); + + return tag; + } + + @Override + public void writeToByteBuf(ByteBuf aBuf) { + super.writeToByteBuf(aBuf); + aBuf.writeInt(threshold); + } + + @Override + public void loadDataFromNBT(NBTBase aNBT) { + super.loadDataFromNBT(aNBT); + + NBTTagCompound tag = (NBTTagCompound) aNBT; + threshold = tag.getInteger("threshold"); + } + + @Nonnull + @Override + public ISerializableObject readFromPacket(ByteArrayDataInput aBuf, EntityPlayerMP aPlayer) { + super.readFromPacket(aBuf, aPlayer); + threshold = aBuf.readInt(); + + return this; + } + } + + // GUI stuff + + @Override + public ModularWindow createWindow(CoverUIBuildContext buildContext) { + return new WirelessFluidDetectorUIFactory(buildContext).createWindow(); + } + + private class WirelessFluidDetectorUIFactory extends AdvancedRedstoneTransmitterBaseUIFactory { + + private int maxCapacity; + + public WirelessFluidDetectorUIFactory(CoverUIBuildContext buildContext) { + super(buildContext); + } + + @Override + protected int getFrequencyRow() { + return 0; + } + + @Override + protected int getButtonRow() { + return 1; + } + + @Override + protected void addUIWidgets(ModularWindow.Builder builder) { + setMaxCapacity(); + super.addUIWidgets(builder); + builder.widget( + new TextWidget(GTUtility.trans("222", "Fluid threshold")).setDefaultColor(COLOR_TEXT_GRAY.get()) + .setPos(startX + spaceX * 5, 4 + startY + spaceY * 2)); + } + + @Override + protected void addUIForDataController(CoverDataControllerWidget controller) { + super.addUIForDataController(controller); + controller.addFollower( + new CoverDataFollowerNumericWidget<>(), + coverData -> (double) coverData.threshold, + (coverData, state) -> { + coverData.threshold = state.intValue(); + return coverData; + }, + widget -> widget.setBounds(0, maxCapacity > 0 ? maxCapacity : Integer.MAX_VALUE) + .setScrollValues(1000, 144, 100000) + .setFocusOnGuiOpen(true) + .setPos(1, 2 + spaceY * 2) + .setSize(spaceX * 5 - 4, 12)); + } + + private void setMaxCapacity() { + final ICoverable tile = getUIBuildContext().getTile(); + if (!tile.isDead() && tile instanceof IFluidHandler) { + FluidTankInfo[] tanks = ((IFluidHandler) tile).getTankInfo(ForgeDirection.UNKNOWN); + maxCapacity = Arrays.stream(tanks) + .mapToInt(tank -> tank.capacity) + .sum(); + } else { + maxCapacity = -1; + } + } + } +} diff --git a/src/main/java/gregtech/common/covers/redstone/CoverWirelessItemDetector.java b/src/main/java/gregtech/common/covers/redstone/CoverWirelessItemDetector.java new file mode 100644 index 0000000000..19cefdabcf --- /dev/null +++ b/src/main/java/gregtech/common/covers/redstone/CoverWirelessItemDetector.java @@ -0,0 +1,262 @@ +package gregtech.common.covers.redstone; + +import java.text.FieldPosition; +import java.util.UUID; + +import javax.annotation.Nonnull; + +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTBase; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; + +import com.google.common.io.ByteArrayDataInput; +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.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.util.GTUtility; +import gregtech.api.util.ISerializableObject; +import gregtech.common.covers.CoverItemMeter; +import gregtech.common.gui.modularui.widget.CoverDataControllerWidget; +import gregtech.common.gui.modularui.widget.CoverDataFollowerNumericWidget; +import gregtech.common.gui.modularui.widget.ItemWatcherSlotWidget; +import gregtech.common.tileentities.storage.MTEDigitalChestBase; +import io.netty.buffer.ByteBuf; + +public class CoverWirelessItemDetector + extends CoverAdvancedRedstoneTransmitterBase { + + public CoverWirelessItemDetector(ITexture coverTexture) { + super(ItemTransmitterData.class, coverTexture); + } + + @Override + public ItemTransmitterData createDataObject() { + return new ItemTransmitterData(); + } + + @Override + public ItemTransmitterData createDataObject(int aLegacyData) { + return createDataObject(); + } + + @Override + public ItemTransmitterData doCoverThingsImpl(ForgeDirection side, byte aInputRedstone, int aCoverID, + ItemTransmitterData aCoverVariable, ICoverable aTileEntity, long aTimer) { + byte signal = CoverItemMeter.computeSignalBasedOnItems( + aTileEntity, + aCoverVariable.invert, + aCoverVariable.threshold, + aCoverVariable.slot, + side.ordinal()); + final long hash = hashCoverCoords(aTileEntity, side); + setSignalAt(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), hash, signal); + + return aCoverVariable; + } + + @Override + public boolean letsRedstoneGoOutImpl(ForgeDirection side, int aCoverID, ItemTransmitterData aCoverVariable, + ICoverable aTileEntity) { + return true; + } + + @Override + protected boolean manipulatesSidedRedstoneOutputImpl(ForgeDirection side, int aCoverID, + ItemTransmitterData aCoverVariable, ICoverable aTileEntity) { + return true; + } + + public static class ItemTransmitterData extends CoverAdvancedRedstoneTransmitterBase.TransmitterData { + + /** + * The special value {@code -1} means all slots. + */ + private int slot; + /** + * The special value {@code 0} means threshold check is disabled. + */ + private int threshold; + + public ItemTransmitterData(int frequency, UUID uuid, boolean invert, int threshold, int slot) { + super(frequency, uuid, invert); + this.threshold = threshold; + this.slot = slot; + } + + public ItemTransmitterData() { + super(); + this.threshold = 0; + this.slot = -1; + } + + @Nonnull + @Override + public ISerializableObject copy() { + return new ItemTransmitterData(frequency, uuid, invert, threshold, slot); + } + + @Nonnull + @Override + public NBTBase saveDataToNBT() { + NBTTagCompound tag = (NBTTagCompound) super.saveDataToNBT(); + tag.setInteger("threshold", threshold); + tag.setInteger("slot", slot); + + return tag; + } + + @Override + public void writeToByteBuf(ByteBuf aBuf) { + super.writeToByteBuf(aBuf); + aBuf.writeInt(threshold); + aBuf.writeInt(slot); + } + + @Override + public void loadDataFromNBT(NBTBase aNBT) { + super.loadDataFromNBT(aNBT); + + NBTTagCompound tag = (NBTTagCompound) aNBT; + threshold = tag.getInteger("threshold"); + slot = tag.getInteger("slot"); + } + + @Nonnull + @Override + public ISerializableObject readFromPacket(ByteArrayDataInput aBuf, EntityPlayerMP aPlayer) { + super.readFromPacket(aBuf, aPlayer); + threshold = aBuf.readInt(); + slot = aBuf.readInt(); + + return this; + } + } + + // GUI stuff + + @Override + public ModularWindow createWindow(CoverUIBuildContext buildContext) { + return new WirelessItemDetectorUIFactory(buildContext).createWindow(); + } + + private class WirelessItemDetectorUIFactory extends AdvancedRedstoneTransmitterBaseUIFactory { + + private int maxSlot; + private int maxThreshold; + /** + * Display the text "All" instead of a number when the slot is set to -1. + */ + private static final NumberFormatMUI numberFormatAll = new NumberFormatMUI() { + + @Override + public StringBuffer format(double number, StringBuffer toAppendTo, FieldPosition pos) { + if (number < 0) { + return toAppendTo.append(GTUtility.trans("ALL", "All")); + } else { + return super.format(number, toAppendTo, pos); + } + } + }; + + public WirelessItemDetectorUIFactory(CoverUIBuildContext buildContext) { + super(buildContext); + } + + @Override + protected int getFrequencyRow() { + return 0; + } + + @Override + protected int getButtonRow() { + return 1; + } + + @Override + protected void addUIWidgets(ModularWindow.Builder builder) { + setMaxSlot(); + setMaxThreshold(); + super.addUIWidgets(builder); + builder.widget( + new ItemWatcherSlotWidget().setGetter(this::getTargetItem) + .setPos(startX + spaceX * 4 - 1, startY + spaceY * 3)) + .widget( + new TextWidget(GTUtility.trans("221", "Item threshold")).setDefaultColor(COLOR_TEXT_GRAY.get()) + .setPos(startX + spaceX * 5, 4 + startY + spaceY * 2)) + .widget( + new TextWidget(GTUtility.trans("254", "Detect Slot #")).setDefaultColor(COLOR_TEXT_GRAY.get()) + .setPos(startX + spaceX * 5, 4 + startY + spaceY * 3)); + } + + @Override + protected void addUIForDataController(CoverDataControllerWidget controller) { + super.addUIForDataController(controller); + controller.addFollower( + new CoverDataFollowerNumericWidget<>(), + coverData -> (double) coverData.threshold, + (coverData, state) -> { + coverData.threshold = state.intValue(); + return coverData; + }, + widget -> widget.setBounds(0, maxThreshold) + .setScrollValues(1, 64, 1000) + .setFocusOnGuiOpen(true) + .setPos(1, 2 + spaceY * 2) + .setSize(spaceX * 5 - 4, 12)) + .addFollower( + new CoverDataFollowerNumericWidget<>(), + coverData -> (double) coverData.slot, + (coverData, state) -> { + coverData.slot = state.intValue(); + return coverData; + }, + widget -> widget.setBounds(-1, maxSlot) + .setDefaultValue(-1) + .setScrollValues(1, 100, 10) + .setNumberFormat(numberFormatAll) + .setPos(1, 2 + spaceY * 3) + .setSize(spaceX * 4 - 8, 12)); + } + + private void setMaxSlot() { + final ICoverable tile = getUIBuildContext().getTile(); + if (!tile.isDead() && tile instanceof IGregTechTileEntity gtTile + && !(gtTile.getMetaTileEntity() instanceof MTEDigitalChestBase)) { + maxSlot = tile.getSizeInventory() - 1; + } else { + maxSlot = -1; + } + } + + private void setMaxThreshold() { + final ICoverable tile = getUIBuildContext().getTile(); + if (!tile.isDead() && tile instanceof IGregTechTileEntity gtTile +