From 300f36ca0f219f0f7828bc5abcb0abfb9de1e29f Mon Sep 17 00:00:00 2001 From: Matej Dipčár <492666@mail.muni.cz> Date: Mon, 19 Sep 2022 19:38:19 +0200 Subject: Add missing space --- src/main/java/gregtech/common/items/GT_MetaGenerated_Item_01.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'src/main/java') diff --git a/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_01.java b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_01.java index aa54520d02..fd4d64d363 100644 --- a/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_01.java +++ b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_01.java @@ -4637,25 +4637,25 @@ public class GT_MetaGenerated_Item_01 extends GT_MetaGenerated_Item_X32 { ItemList.Cover_RedstoneTransmitterExternal.set(addItem( tLastID = 741, "Redstone Transmitter (Out)", - "Transfers Redstonesignals wireless", + "Transfers Redstone signals wireless", new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L), new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L))); ItemList.Cover_RedstoneTransmitterInternal.set(addItem( tLastID = 742, "Redstone Transmitter (In)", - "Transfers Redstonesignals wireless", + "Transfers Redstone signals wireless", new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L), new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L))); ItemList.Cover_RedstoneReceiverExternal.set(addItem( tLastID = 746, "Redstone Receiver (Out)", - "Transfers Redstonesignals wireless", + "Transfers Redstone signals wireless", new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L), new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L))); ItemList.Cover_RedstoneReceiverInternal.set(addItem( tLastID = 747, "Redstone Receiver (In)", - "Transfers Redstonesignals wireless", + "Transfers Redstone signals wireless", new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L), new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 1L))); -- cgit From dc511e64e2ffeb47fd0357eca0598f946704cb2a Mon Sep 17 00:00:00 2001 From: Matej Dipčár <492666@mail.muni.cz> Date: Tue, 20 Sep 2022 22:02:17 +0200 Subject: Add Advanced Wireless Redstone Covers --- src/main/java/gregtech/api/GregTech_API.java | 24 ++ src/main/java/gregtech/api/enums/ItemList.java | 5 + src/main/java/gregtech/api/gui/GT_GUIScreen.java | 2 +- .../GT_Cover_AdvancedRedstoneReceiverBase.java | 319 +++++++++++++++++++ .../GT_Cover_AdvancedRedstoneReceiverExternal.java | 30 ++ .../GT_Cover_AdvancedRedstoneReceiverInternal.java | 34 ++ .../GT_Cover_AdvancedRedstoneTransmitterBase.java | 342 +++++++++++++++++++++ ..._Cover_AdvancedRedstoneTransmitterExternal.java | 30 ++ ..._Cover_AdvancedRedstoneTransmitterInternal.java | 37 +++ .../common/items/GT_MetaGenerated_Item_02.java | 70 +++++ 10 files changed, 892 insertions(+), 1 deletion(-) create mode 100644 src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverBase.java create mode 100644 src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverExternal.java create mode 100644 src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverInternal.java create mode 100644 src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterBase.java create mode 100644 src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterExternal.java create mode 100644 src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterInternal.java (limited to 'src/main/java') diff --git a/src/main/java/gregtech/api/GregTech_API.java b/src/main/java/gregtech/api/GregTech_API.java index 7a52021eea..fefbe06518 100644 --- a/src/main/java/gregtech/api/GregTech_API.java +++ b/src/main/java/gregtech/api/GregTech_API.java @@ -53,6 +53,7 @@ import java.util.List; import java.util.Locale; import java.util.Map; import java.util.TreeMap; +import java.util.UUID; import java.util.concurrent.ConcurrentHashMap; import java.util.function.BiFunction; import java.util.function.IntFunction; @@ -172,6 +173,29 @@ public class GregTech_API { * The Redstone Frequencies */ public static final Map sWirelessRedstone = new ConcurrentHashMap<>(); + /** + * The Advanced Redstone Frequencies + */ + public static final Map> sAdvancedWirelessRedstone = new ConcurrentHashMap<>(); + + public static Byte getAdvancedRedstone(UUID uuid, int frequency) { + Map frequencies = GregTech_API.sAdvancedWirelessRedstone.get(String.valueOf(uuid)); + if (frequencies == null) return 0; + return frequencies.getOrDefault(frequency, (byte) 0); + } + + public static void removeAdvancedRedstone(UUID uuid, int frequency) { + Map frequencies = GregTech_API.sAdvancedWirelessRedstone.get(String.valueOf(uuid)); + if (frequencies == null) return; + frequencies.remove(frequency); + } + + public static void setAdvancedRedstone(UUID uuid, int frequency, byte value) { + String key = String.valueOf(uuid); + Map frequencies = GregTech_API.sAdvancedWirelessRedstone.computeIfAbsent(key, k -> new ConcurrentHashMap<>()); + frequencies.put(frequency, value); + } + /** * The IDSU Frequencies */ diff --git a/src/main/java/gregtech/api/enums/ItemList.java b/src/main/java/gregtech/api/enums/ItemList.java index 279233d101..b8b457ad16 100644 --- a/src/main/java/gregtech/api/enums/ItemList.java +++ b/src/main/java/gregtech/api/enums/ItemList.java @@ -1529,6 +1529,11 @@ public enum ItemList implements IItemContainer { Hatch_Output_Bus_ME, NULL, + Cover_AdvancedRedstoneTransmitterExternal, + Cover_AdvancedRedstoneTransmitterInternal, + Cover_AdvancedRedstoneReceiverExternal, + Cover_AdvancedRedstoneReceiverInternal, + Cover_RedstoneTransmitterExternal, Cover_RedstoneTransmitterInternal, Cover_RedstoneReceiverExternal, diff --git a/src/main/java/gregtech/api/gui/GT_GUIScreen.java b/src/main/java/gregtech/api/gui/GT_GUIScreen.java index 281be1e55d..d39a6b738e 100644 --- a/src/main/java/gregtech/api/gui/GT_GUIScreen.java +++ b/src/main/java/gregtech/api/gui/GT_GUIScreen.java @@ -28,8 +28,8 @@ public abstract class GT_GUIScreen extends GuiScreen implements GT_IToolTipRende protected int gui_height = 107; protected int guiTop, guiLeft; protected boolean drawButtons = true; + protected ResourceLocation mGUIbackgroundLocation; - private ResourceLocation mGUIbackgroundLocation; private GuiButton selectedButton; private GT_GUIColorOverride colorOverride; private final int textColor; diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverBase.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverBase.java new file mode 100644 index 0000000000..ccd0ea0b8f --- /dev/null +++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverBase.java @@ -0,0 +1,319 @@ +package gregtech.common.covers.redstone; + +import com.google.common.io.ByteArrayDataInput; +import gregtech.api.GregTech_API; +import gregtech.api.enums.GT_Values; +import gregtech.api.gui.GT_GUICover; +import gregtech.api.gui.widgets.GT_GuiIcon; +import gregtech.api.gui.widgets.GT_GuiIconCheckButton; +import gregtech.api.gui.widgets.GT_GuiIntegerTextBox; +import gregtech.api.interfaces.IGuiScreen; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.net.GT_Packet_TileEntityCoverNew; +import gregtech.api.util.GT_CoverBehaviorBase; +import gregtech.api.util.GT_Utility; +import gregtech.api.util.ISerializableObject; +import io.netty.buffer.ByteBuf; +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.GuiButton; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.nbt.NBTBase; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.ResourceLocation; +import net.minecraft.world.World; +import net.minecraftforge.fluids.Fluid; + +import javax.annotation.Nonnull; +import java.util.UUID; + +public class GT_Cover_AdvancedRedstoneReceiverBase extends GT_CoverBehaviorBase { + + public GT_Cover_AdvancedRedstoneReceiverBase(ITexture coverTexture) { + super(ReceiverData.class, coverTexture); + } + + @Override + public ReceiverData createDataObject() { + return new ReceiverData(); + } + + @Override + public ReceiverData createDataObject(int aLegacyData) { + return createDataObject(); + } + + @Override + public boolean onCoverRemovalImpl(byte aSide, int aCoverID, ReceiverData aCoverVariable, ICoverable aTileEntity, + boolean aForced) { + GregTech_API.removeAdvancedRedstone(aCoverVariable.uuid, aCoverVariable.frequency); + return true; + } + + @Override + public boolean letsEnergyInImpl(byte aSide, int aCoverID, ReceiverData aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsEnergyOutImpl(byte aSide, int aCoverID, ReceiverData aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsFluidInImpl(byte aSide, int aCoverID, ReceiverData aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsFluidOutImpl(byte aSide, int aCoverID, ReceiverData aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsItemsInImpl(byte aSide, int aCoverID, ReceiverData aCoverVariable, int aSlot, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsItemsOutImpl(byte aSide, int aCoverID, ReceiverData aCoverVariable, int aSlot, ICoverable aTileEntity) { + return true; + } + + @Override + public String getDescriptionImpl(byte aSide, int aCoverID, ReceiverData aCoverVariable, ICoverable aTileEntity) { + return GT_Utility.trans("081", "Frequency: ") + aCoverVariable.frequency + ", Transmission: " + (aCoverVariable.uuid == null ? "Public" : "Private"); + } + + @Override + public int getTickRateImpl(byte aSide, int aCoverID, ReceiverData aCoverVariable, ICoverable aTileEntity) { + return 5; + } + + /** + * GUI Stuff + */ + @Override + public boolean hasCoverGUI() { + return true; + } + + @Override + public Object getClientGUIImpl(byte aSide, int aCoverID, ReceiverData aCoverVariable, ICoverable aTileEntity, + EntityPlayer aPlayer, World aWorld) { + return new GT_Cover_AdvancedRedstoneReceiverBase.GUI(aSide, aCoverID, aCoverVariable, aTileEntity); + } + + public static class ReceiverData implements ISerializableObject { + private int frequency; + + /** + * If UUID is set to null, the cover frequency is public, rather than private + **/ + private UUID uuid; + + public ReceiverData(int frequency, UUID uuid) { + this.frequency = frequency; + this.uuid = uuid; + } + + public ReceiverData() { + this(0, null); + } + + public UUID getUuid() { + return uuid; + } + + public int getFrequency() { + return frequency; + } + + @Nonnull + @Override + public ISerializableObject copy() { + return new ReceiverData(frequency, uuid); + } + + @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; + } + } + + private class GUI extends GT_GUICover { + + private final byte side; + private final int coverID; + private final GT_GuiIntegerTextBox frequencyBox; + private final GT_GuiIconCheckButton privateButton; + private final ReceiverData coverVariable; + + 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 static final String guiTexturePath = "gregtech:textures/gui/GuiCoverLong.png"; + + private final int textColor = this.getTextColorOrDefault("text", 0xFF555555); + + public GUI(byte aSide, int aCoverID, ReceiverData aCoverVariable, ICoverable aTileEntity) { + super(aTileEntity, 250, 107, GT_Utility.intToStack(aCoverID)); + this.mGUIbackgroundLocation = new ResourceLocation(guiTexturePath); + this.side = aSide; + this.coverID = aCoverID; + this.coverVariable = aCoverVariable; + + frequencyBox = new GT_Cover_AdvancedRedstoneReceiverBase.GUI.GT_GuiShortTextBox(this, 2, startX, startY + 2, spaceX * 5 - 3, 12); + privateButton = new GT_GuiIconCheckButton(this, 0, startX, startY + spaceY * 1, GT_GuiIcon.CHECKMARK, null); + } + + @Override + public void drawExtras(int mouseX, int mouseY, float parTicks) { + super.drawExtras(mouseX, mouseY, parTicks); + this.getFontRenderer().drawString( + GT_Utility.trans("246", "Frequency"), + startX + spaceX * 5, + 4 + startY, + textColor); + this.getFontRenderer().drawString( + GT_Utility.trans("601", "Use Private Frequency"), + startX + spaceX, + startY + spaceY * 1 + 4, + textColor); + } + + @Override + protected void onInitGui(int guiLeft, int guiTop, int gui_width, int gui_height) { + update(); + frequencyBox.setFocused(true); + } + + @Override + public void onMouseWheel(int x, int y, int delta) { + if (frequencyBox.isFocused()) { + long step = Math.max(1, Math.abs(delta / 120)); + step = (isShiftKeyDown() ? 1000 : isCtrlKeyDown() ? 50 : 1) * (delta > 0 ? step : -step); + + long frequency = parseTextBox(frequencyBox) + step; + if (frequency > Integer.MAX_VALUE) frequency = Integer.MAX_VALUE; + else if (frequency < 0) frequency = 0; + + frequencyBox.setText(Long.toString(frequency)); + } + } + + @Override + public void applyTextBox(GT_GuiIntegerTextBox box) { + if (box == frequencyBox) { + coverVariable.frequency = parseTextBox(frequencyBox); + } + + GT_Values.NW.sendToServer(new GT_Packet_TileEntityCoverNew(side, coverID, coverVariable, tile)); + update(); + } + + @Override + public void resetTextBox(GT_GuiIntegerTextBox box) { + if (box == frequencyBox) { + frequencyBox.setText(Integer.toString(coverVariable.frequency)); + } + } + + private void update() { + privateButton.setChecked(coverVariable.uuid != null); + resetTextBox(frequencyBox); + } + + @Override + public void buttonClicked(GuiButton btn) { + if (btn == privateButton) { + coverVariable.uuid = coverVariable.uuid == null ? Minecraft.getMinecraft().thePlayer.getUniqueID() : null; + } + + GT_Values.NW.sendToServer(new GT_Packet_TileEntityCoverNew(side, coverID, coverVariable, tile)); + update(); + } + + private int parseTextBox(GT_GuiIntegerTextBox box) { + if (box == frequencyBox) { + String text = box.getText(); + if (text == null) { + return 0; + } + + long frequency; + try { + frequency = Long.parseLong(text.trim()); + } catch (NumberFormatException e) { + return 0; + } + + if (frequency > Integer.MAX_VALUE) frequency = Integer.MAX_VALUE; + else if (frequency < 0) frequency = 0; + + return (int) frequency; + } + + throw new UnsupportedOperationException("Unknown text box: " + box); + } + + private class GT_GuiShortTextBox extends GT_GuiIntegerTextBox { + + public GT_GuiShortTextBox(IGuiScreen gui, int id, int x, int y, int width, int height) { + super(gui, id, x, y, width, height); + } + + @Override + public boolean textboxKeyTyped(char c, int key) { + if (!super.textboxKeyTyped(c, key)) return false; + + String text = getText().trim(); + if (text.length() > 0) { + setText(String.valueOf(parseTextBox(this))); + } + + return true; + } + } + } +} diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverExternal.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverExternal.java new file mode 100644 index 0000000000..bedb878295 --- /dev/null +++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverExternal.java @@ -0,0 +1,30 @@ +package gregtech.common.covers.redstone; + +import gregtech.api.GregTech_API; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.ICoverable; + +public class GT_Cover_AdvancedRedstoneReceiverExternal extends GT_Cover_AdvancedRedstoneReceiverBase { + + public GT_Cover_AdvancedRedstoneReceiverExternal(ITexture coverTexture) { + super(coverTexture); + } + + @Override + public ReceiverData doCoverThingsImpl(byte aSide, byte aInputRedstone, int aCoverID, ReceiverData aCoverVariable, ICoverable aTileEntity, long aTimer) { + aTileEntity.setOutputRedstoneSignal(aSide, + GregTech_API.getAdvancedRedstone(aCoverVariable.getUuid(), aCoverVariable.getFrequency())); + + return aCoverVariable; + } + + @Override + protected boolean isRedstoneSensitiveImpl(byte aSide, int aCoverID, ReceiverData aCoverVariable, ICoverable aTileEntity, long aTimer) { + return false; + } + + @Override + protected boolean manipulatesSidedRedstoneOutputImpl(byte aSide, int aCoverID, ReceiverData aCoverVariable, ICoverable aTileEntity) { + return true; + } +} diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverInternal.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverInternal.java new file mode 100644 index 0000000000..7a4d498059 --- /dev/null +++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverInternal.java @@ -0,0 +1,34 @@ +package gregtech.common.covers.redstone; + +import gregtech.api.GregTech_API; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.interfaces.tileentity.IMachineProgress; + +public class GT_Cover_AdvancedRedstoneReceiverInternal extends GT_Cover_AdvancedRedstoneReceiverBase { + + public GT_Cover_AdvancedRedstoneReceiverInternal(ITexture coverTexture) { + super(coverTexture); + } + + @Override + public ReceiverData doCoverThingsImpl(byte aSide, byte aInputRedstone, int aCoverID, ReceiverData aCoverVariable, ICoverable aTileEntity, long aTimer) { + if (aTileEntity instanceof IMachineProgress) { + IMachineProgress machine = ((IMachineProgress) aTileEntity); + if (getRedstoneInput(aSide, aInputRedstone, aCoverID, aCoverVariable, aTileEntity) > 0) { + machine.enableWorking(); + } else { + machine.disableWorking();; + } + + machine.setWorkDataValue(aInputRedstone); + } + + return aCoverVariable; + } + + @Override + protected byte getRedstoneInputImpl(byte aSide, byte aInputRedstone, int aCoverID, ReceiverData aCoverVariable, ICoverable aTileEntity) { + return GregTech_API.getAdvancedRedstone(aCoverVariable.getUuid(), aCoverVariable.getFrequency()); + } +} diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterBase.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterBase.java new file mode 100644 index 0000000000..a71cea094a --- /dev/null +++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterBase.java @@ -0,0 +1,342 @@ +package gregtech.common.covers.redstone; + +import com.google.common.io.ByteArrayDataInput; +import gregtech.api.GregTech_API; +import gregtech.api.enums.GT_Values; +import gregtech.api.gui.GT_GUICover; +import gregtech.api.gui.widgets.GT_GuiIcon; +import gregtech.api.gui.widgets.GT_GuiIconCheckButton; +import gregtech.api.gui.widgets.GT_GuiIntegerTextBox; +import gregtech.api.interfaces.IGuiScreen; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.net.GT_Packet_TileEntityCoverNew; +import gregtech.api.util.GT_CoverBehaviorBase; +import gregtech.api.util.GT_Utility; +import gregtech.api.util.ISerializableObject; +import io.netty.buffer.ByteBuf; +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.GuiButton; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.nbt.NBTBase; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.ResourceLocation; +import net.minecraft.world.World; +import net.minecraftforge.fluids.Fluid; + +import javax.annotation.Nonnull; +import java.util.UUID; + +public class GT_Cover_AdvancedRedstoneTransmitterBase extends GT_CoverBehaviorBase { + + public GT_Cover_AdvancedRedstoneTransmitterBase(ITexture coverTexture) { + super(TransmitterData.class, coverTexture); + } + + @Override + public TransmitterData createDataObject() { + return new TransmitterData(); + } + + @Override + public TransmitterData createDataObject(int aLegacyData) { + return createDataObject(); + } + + @Override + public boolean onCoverRemovalImpl(byte aSide, int aCoverID, TransmitterData aCoverVariable, ICoverable aTileEntity, + boolean aForced) { + GregTech_API.removeAdvancedRedstone(aCoverVariable.uuid, aCoverVariable.frequency); + return true; + } + + @Override + public boolean letsEnergyInImpl(byte aSide, int aCoverID, TransmitterData aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsEnergyOutImpl(byte aSide, int aCoverID, TransmitterData aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsFluidInImpl(byte aSide, int aCoverID, TransmitterData aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsFluidOutImpl(byte aSide, int aCoverID, TransmitterData aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsItemsInImpl(byte aSide, int aCoverID, TransmitterData aCoverVariable, int aSlot, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsItemsOutImpl(byte aSide, int aCoverID, TransmitterData aCoverVariable, int aSlot, ICoverable aTileEntity) { + return true; + } + + @Override + public String getDescriptionImpl(byte aSide, int aCoverID, TransmitterData aCoverVariable, ICoverable aTileEntity) { + return GT_Utility.trans("081", "Frequency: ") + aCoverVariable.frequency + ", Transmission: " + (aCoverVariable.uuid == null ? "Public" : "Private"); + } + + @Override + public int getTickRateImpl(byte aSide, int aCoverID, TransmitterData aCoverVariable, ICoverable aTileEntity) { + return 5; + } + + /** + * GUI Stuff + */ + @Override + public boolean hasCoverGUI() { + return true; + } + + @Override + public Object getClientGUIImpl(byte aSide, int aCoverID, TransmitterData aCoverVariable, ICoverable aTileEntity, + EntityPlayer aPlayer, World aWorld) { + return new GT_Cover_AdvancedRedstoneTransmitterBase.GUI(aSide, aCoverID, aCoverVariable, aTileEntity); + } + + public static class TransmitterData implements ISerializableObject { + private int frequency; + + /** + * If UUID is set to null, the cover frequency is public, rather than private + **/ + private UUID uuid; + private boolean invert; + + public TransmitterData(int frequency, UUID uuid, boolean invert) { + this.frequency = frequency; + this.uuid = uuid; + this.invert = invert; + } + + public TransmitterData() { + this(0, null, false); + } + + public UUID getUuid() { + return uuid; + } + + public int getFrequency() { + return frequency; + } + + public boolean isInvert() { + return invert; + } + + @Nonnull + @Override + public ISerializableObject copy() { + return new TransmitterData(frequency, uuid, invert); + } + + @Nonnull + @Override + public NBTBase saveDataToNBT() { + NBTTagCompound tag = new NBTTagCompound(); + tag.setInteger("frequency", frequency); + if (uuid != null) { + tag.setString("uuid", uuid.toString()); + } + tag.setBoolean("invert", invert); + + 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()); + } + aBuf.writeBoolean(invert); + } + + @Override + public void loadDataFromNBT(NBTBase aNBT) { + NBTTagCompound tag = (NBTTagCompound) aNBT; + frequency = tag.getInteger("frequency"); + if (tag.hasKey("uuid")) { + uuid = UUID.fromString(tag.getString("uuid")); + } + invert = tag.getBoolean("invert"); + } + + @Nonnull + @Override + public ISerializableObject readFromPacket(ByteArrayDataInput aBuf, EntityPlayerMP aPlayer) { + frequency = aBuf.readInt(); + if (aBuf.readBoolean()) { + uuid = new UUID(aBuf.readLong(), aBuf.readLong()); + } + invert = aBuf.readBoolean(); + + return this; + } + } + + private class GUI extends GT_GUICover { + + private final byte side; + private final int coverID; + private final GT_GuiIntegerTextBox frequencyBox; + private final GT_GuiIconCheckButton privateButton; + private final GT_GuiIconCheckButton invertButton; + private final TransmitterData coverVariable; + + 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 final String INVERTED = GT_Utility.trans("INVERTED", "Inverted"); + private final String NORMAL = GT_Utility.trans("NORMAL", "Normal"); + + private static final String guiTexturePath = "gregtech:textures/gui/GuiCoverLong.png"; + + private final int textColor = this.getTextColorOrDefault("text", 0xFF555555); + + public GUI(byte aSide, int aCoverID, TransmitterData aCoverVariable, ICoverable aTileEntity) { + super(aTileEntity, 250, 107, GT_Utility.intToStack(aCoverID)); + this.mGUIbackgroundLocation = new ResourceLocation(guiTexturePath); + this.side = aSide; + this.coverID = aCoverID; + this.coverVariable = aCoverVariable; + + privateButton = new GT_GuiIconCheckButton(this, 0, startX, startY + spaceY * 1, GT_GuiIcon.CHECKMARK, null); + invertButton = new GT_GuiIconCheckButton(this, 0, startX, startY + spaceY * 2, GT_GuiIcon.REDSTONE_ON, GT_GuiIcon.REDSTONE_OFF, INVERTED, NORMAL); + frequencyBox = new GT_Cover_AdvancedRedstoneTransmitterBase.GUI.GT_GuiShortTextBox(this, 2, startX, startY + 2, spaceX * 5 - 3, 12); + } + + @Override + public void drawExtras(int mouseX, int mouseY, float parTicks) { + super.drawExtras(mouseX, mouseY, parTicks); + this.getFontRenderer().drawString( + GT_Utility.trans("246", "Frequency"), + startX + spaceX * 5, + 4 + startY, + textColor); + this.getFontRenderer().drawString( + GT_Utility.trans("601", "Use Private Frequency"), + startX + spaceX, + startY + spaceY * 1 + 4, + textColor); + this.getFontRenderer().drawString( + coverVariable.invert ? INVERTED : NORMAL, + startX + spaceX, + startY + spaceY * 2 + 4, + textColor); + } + + @Override + protected void onInitGui(int guiLeft, int guiTop, int gui_width, int gui_height) { + update(); + frequencyBox.setFocused(true); + } + + @Override + public void onMouseWheel(int x, int y, int delta) { + if (frequencyBox.isFocused()) { + long step = Math.max(1, Math.abs(delta / 120)); + step = (isShiftKeyDown() ? 1000 : isCtrlKeyDown() ? 50 : 1) * (delta > 0 ? step : -step); + + long frequency = parseTextBox(frequencyBox) + step; + if (frequency > Integer.MAX_VALUE) frequency = Integer.MAX_VALUE; + else if (frequency < 0) frequency = 0; + + frequencyBox.setText(Long.toString(frequency)); + } + } + + @Override + public void applyTextBox(GT_GuiIntegerTextBox box) { + if (box == frequencyBox) { + coverVariable.frequency = parseTextBox(frequencyBox); + } + + GT_Values.NW.sendToServer(new GT_Packet_TileEntityCoverNew(side, coverID, coverVariable, tile)); + update(); + } + + @Override + public void resetTextBox(GT_GuiIntegerTextBox box) { + if (box == frequencyBox) { + frequencyBox.setText(Integer.toString(coverVariable.frequency)); + } + } + + private void update() { + privateButton.setChecked(coverVariable.uuid != null); + invertButton.setChecked(coverVariable.invert); + resetTextBox(frequencyBox); + } + + @Override + public void buttonClicked(GuiButton btn) { + if (btn == privateButton) { + coverVariable.uuid = coverVariable.uuid == null ? Minecraft.getMinecraft().thePlayer.getUniqueID() : null; + } else if (btn == invertButton) { + coverVariable.invert = !coverVariable.invert; + } + + GT_Values.NW.sendToServer(new GT_Packet_TileEntityCoverNew(side, coverID, coverVariable, tile)); + update(); + } + + private int parseTextBox(GT_GuiIntegerTextBox box) { + if (box == frequencyBox) { + String text = box.getText(); + if (text == null) { + return 0; + } + + long frequency; + try { + frequency = Long.parseLong(text.trim()); + } catch (NumberFormatException e) { + return 0; + } + + if (frequency > Integer.MAX_VALUE) frequency = Integer.MAX_VALUE; + else if (frequency < 0) frequency = 0; + + return (int) frequency; + } + + throw new UnsupportedOperationException("Unknown text box: " + box); + } + + private class GT_GuiShortTextBox extends GT_GuiIntegerTextBox { + + public GT_GuiShortTextBox(IGuiScreen gui, int id, int x, int y, int width, int height) { + super(gui, id, x, y, width, height); + } + + @Override + public boolean textboxKeyTyped(char c, int key) { + if (!super.textboxKeyTyped(c, key)) return false; + + String text = getText().trim(); + if (text.length() > 0) { + setText(String.valueOf(parseTextBox(this))); + } + + return true; + } + } + } +} diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterExternal.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterExternal.java new file mode 100644 index 0000000000..51533c2b98 --- /dev/null +++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterExternal.java @@ -0,0 +1,30 @@ +package gregtech.common.covers.redstone; + +import gregtech.api.GregTech_API; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.ICoverable; + +public class GT_Cover_AdvancedRedstoneTransmitterExternal extends GT_Cover_AdvancedRedstoneTransmitterBase { + + public GT_Cover_AdvancedRedstoneTransmitterExternal(ITexture coverTexture) { + super(coverTexture); + } + + @Override + public TransmitterData doCoverThingsImpl(byte aSide, byte aInputRedstone, int aCoverID, + TransmitterData aCoverVariable, ICoverable tile, long aTimer) { + byte outputRedstone = aInputRedstone; + if (aCoverVariable.isInvert()) { + if (outputRedstone > 0) outputRedstone = 0; + else outputRedstone = 15; + } + + GregTech_API.setAdvancedRedstone(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), outputRedstone); + return aCoverVariable; + } + + @Override + public boolean letsRedstoneGoInImpl(byte aSide, int aCoverID, TransmitterData aCoverVariable, ICoverable aTileEntity) { + return true; + } +} diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterInternal.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterInternal.java new file mode 100644 index 0000000000..058081fd13 --- /dev/null +++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterInternal.java @@ -0,0 +1,37 @@ +package gregtech.common.covers.redstone; + +import gregtech.api.GregTech_API; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.ICoverable; + +public class GT_Cover_AdvancedRedstoneTransmitterInternal extends GT_Cover_AdvancedRedstoneTransmitterBase { + + public GT_Cover_AdvancedRedstoneTransmitterInternal(ITexture coverTexture) { + super(coverTexture); + } + + @Override + public TransmitterData doCoverThingsImpl(byte aSide, byte aInputRedstone, int aCoverID, + TransmitterData aCoverVariable, ICoverable aTileEntity, long aTimer) { + byte outputRedstone = aTileEntity.getOutputRedstoneSignal(aSide); + if (aCoverVariable.isInvert()) { + if (outputRedstone > 0) outputRedstone = 0; + else outputRedstone = 15; + } + + GregTech_API.setAdvancedRedstone(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), outputRedstone); + return aCoverVariable; + } + + @Override + public boolean letsRedstoneGoOutImpl(byte aSide, int aCoverID, TransmitterData aCoverVariable, + ICoverable aTileEntity) { + return true; + } + + @Override + protected boolean manipulatesSidedRedstoneOutputImpl(byte aSide, int aCoverID, TransmitterData aCoverVariable, + ICoverable aTileEntity) { + return true; + } +} diff --git a/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_02.java b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_02.java index af5c1dc457..53ed73ae5a 100644 --- a/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_02.java +++ b/src/main/java/gregtech/common/items/GT_MetaGenerated_Item_02.java @@ -8,6 +8,7 @@ import gregtech.api.enums.Materials; import gregtech.api.enums.OrePrefixes; import gregtech.api.enums.SubTag; import gregtech.api.enums.TC_Aspects; +import gregtech.api.interfaces.ITexture; import gregtech.api.items.GT_MetaGenerated_Item_X32; import gregtech.api.objects.ItemData; import gregtech.api.render.TextureFactory; @@ -16,6 +17,11 @@ import gregtech.api.util.GT_Log; import gregtech.api.util.GT_ModHandler; import gregtech.api.util.GT_OreDictUnificator; import gregtech.api.util.GT_Utility; +import gregtech.common.covers.GT_Cover_RedstoneReceiverExternal; +import gregtech.common.covers.redstone.GT_Cover_AdvancedRedstoneReceiverExternal; +import gregtech.common.covers.redstone.GT_Cover_AdvancedRedstoneReceiverInternal; +import gregtech.common.covers.redstone.GT_Cover_AdvancedRedstoneTransmitterExternal; +import gregtech.common.covers.redstone.GT_Cover_AdvancedRedstoneTransmitterInternal; import gregtech.common.items.behaviors.Behaviour_Arrow; import net.minecraft.dispenser.IBlockSource; import net.minecraft.enchantment.Enchantment; @@ -32,6 +38,8 @@ import net.minecraft.nbt.NBTTagCompound; import net.minecraft.potion.Potion; import net.minecraft.world.World; +import static gregtech.api.enums.Textures.BlockIcons.*; + public class GT_MetaGenerated_Item_02 extends GT_MetaGenerated_Item_X32 { public static GT_MetaGenerated_Item_02 INSTANCE; private static final String aTextCover = "Usable as Cover"; @@ -2297,6 +2305,68 @@ public class GT_MetaGenerated_Item_02 extends GT_MetaGenerated_Item_X32 { new GT_FoodStat(1, 0.1F, EnumAction.eat, null, false, true, false), new TC_Aspects.TC_AspectStack(TC_Aspects.FAMES, 1L))); + + + ItemList.Cover_AdvancedRedstoneTransmitterExternal.set(addItem( + tLastID = 577, + "Advanced Redstone Transmitter (External)", + "Transfers Redstone signals wirelessly", + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L))); + ItemList.Cover_AdvancedRedstoneTransmitterInternal.set(addItem( + tLastID = 578, + "Advanced Redstone Transmitter (Internal)", + "Transfers Redstone signals wirelessly", + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L))); + ItemList.Cover_AdvancedRedstoneReceiverExternal.set(addItem( + tLastID = 579, + "Advanced Redstone Receiver (External)", + "Transfers Redstone signals wirelessly", + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L))); + ItemList.Cover_AdvancedRedstoneReceiverInternal.set(addItem( + tLastID = 580, + "Advanced Redstone Receiver (Internal)", + "Transfers Redstone signals wirelessly", + new TC_Aspects.TC_AspectStack(TC_Aspects.ORDO, 2L), + new TC_Aspects.TC_AspectStack(TC_Aspects.MACHINA, 2L))); + + final ITexture redstoneTransmitterExternalCoverTexture = TextureFactory.of( + TextureFactory.of(OVERLAY_ACTIVITYDETECTOR), + TextureFactory.builder() + .addIcon(OVERLAY_ACTIVITYDETECTOR_GLOW) + .glow() + .build()); + + final ITexture redstoneTransmitterInternalCoverTexture = TextureFactory.of( + TextureFactory.of(OVERLAY_ACTIVITYDETECTOR), + TextureFactory.builder() + .addIcon(OVERLAY_ACTIVITYDETECTOR_GLOW) + .glow() + .build()); + + GregTech_API.registerCover( + ItemList.Cover_AdvancedRedstoneTransmitterExternal.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], redstoneTransmitterExternalCoverTexture), + new GT_Cover_AdvancedRedstoneTransmitterExternal(redstoneTransmitterExternalCoverTexture)); + + GregTech_API.registerCover( + ItemList.Cover_AdvancedRedstoneTransmitterInternal.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], redstoneTransmitterInternalCoverTexture), + new GT_Cover_AdvancedRedstoneTransmitterInternal(redstoneTransmitterInternalCoverTexture)); + + GregTech_API.registerCover( + ItemList.Cover_AdvancedRedstoneReceiverExternal.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_FLUIDDETECTOR)), + new GT_Cover_AdvancedRedstoneReceiverExternal(TextureFactory.of(OVERLAY_FLUIDDETECTOR))); + + GregTech_API.registerCover( + ItemList.Cover_AdvancedRedstoneReceiverInternal.get(1L), + TextureFactory.of(MACHINE_CASINGS[2][0], TextureFactory.of(OVERLAY_FLUIDDETECTOR)), + new GT_Cover_AdvancedRedstoneReceiverInternal(TextureFactory.of(OVERLAY_FLUIDDETECTOR))); + + GT_ModHandler.addExtractionRecipe(new ItemStack(Blocks.red_flower, 1, 0), new ItemStack(Items.dye, 2, 1)); GT_ModHandler.addExtractionRecipe(new ItemStack(Blocks.red_flower, 1, 1), new ItemStack(Items.dye, 2, 12)); GT_ModHandler.addExtractionRecipe(new ItemStack(Blocks.red_flower, 1, 2), new ItemStack(Items.dye, 2, 13)); -- cgit From fe4a5eba58bbe30c5114319401c356127fb00263 Mon Sep 17 00:00:00 2001 From: Matej Dipčár <492666@mail.muni.cz> Date: Tue, 20 Sep 2022 23:44:45 +0200 Subject: Add handling of multiple sources --- src/main/java/gregtech/api/GregTech_API.java | 47 +++++++++++++++++----- .../GT_Cover_AdvancedRedstoneReceiverBase.java | 3 +- .../GT_Cover_AdvancedRedstoneTransmitterBase.java | 3 +- ..._Cover_AdvancedRedstoneTransmitterExternal.java | 6 ++- ..._Cover_AdvancedRedstoneTransmitterInternal.java | 3 +- 5 files changed, 47 insertions(+), 15 deletions(-) (limited to 'src/main/java') diff --git a/src/main/java/gregtech/api/GregTech_API.java b/src/main/java/gregtech/api/GregTech_API.java index fefbe06518..d4fd4206cf 100644 --- a/src/main/java/gregtech/api/GregTech_API.java +++ b/src/main/java/gregtech/api/GregTech_API.java @@ -20,6 +20,7 @@ import gregtech.api.interfaces.ITexture; import gregtech.api.interfaces.internal.IGT_RecipeAdder; import gregtech.api.interfaces.internal.IThaumcraftCompat; import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.ICoverable; import gregtech.api.interfaces.tileentity.IMachineBlockUpdateable; import gregtech.api.items.GT_CoolantCellIC_Item; import gregtech.api.items.GT_CoolantCell_Item; @@ -176,24 +177,50 @@ public class GregTech_API { /** * The Advanced Redstone Frequencies */ - public static final Map> sAdvancedWirelessRedstone = new ConcurrentHashMap<>(); + public static final Map>> sAdvancedWirelessRedstone = new ConcurrentHashMap<>(); public static Byte getAdvancedRedstone(UUID uuid, int frequency) { - Map frequencies = GregTech_API.sAdvancedWirelessRedstone.get(String.valueOf(uuid)); + Map> frequencies = GregTech_API.sAdvancedWirelessRedstone.get(String.valueOf(uuid)); if (frequencies == null) return 0; - return frequencies.getOrDefault(frequency, (byte) 0); + + // TODO: Implement All Modes + Map signals = frequencies.get(frequency); + if (signals == null) return 0; + + return (byte) (signals.values().stream() + .map(signal -> signal > 0) + .reduce(true, (signalA, signalB) -> signalA && signalB) ? 15 : 0); } - public static void removeAdvancedRedstone(UUID uuid, int frequency) { - Map frequencies = GregTech_API.sAdvancedWirelessRedstone.get(String.valueOf(uuid)); + public static void removeAdvancedRedstone(UUID uuid, int frequency, long hash) { + Map> frequencies = GregTech_API.sAdvancedWirelessRedstone.get(String.valueOf(uuid)); if (frequencies == null) return; - frequencies.remove(frequency); + frequencies.computeIfPresent(frequency, (freq, longByteMap) -> { + longByteMap.remove(hash); + return longByteMap.isEmpty() ? null : longByteMap; + }); + } + + public static void setAdvancedRedstone(UUID uuid, int frequency, long hash, byte value) { + Map> frequencies = GregTech_API.sAdvancedWirelessRedstone.computeIfAbsent(String.valueOf(uuid), k -> new ConcurrentHashMap<>()); + Map signals = frequencies.computeIfAbsent(frequency, k -> new ConcurrentHashMap<>()); + signals.put(hash, value); } - public static void setAdvancedRedstone(UUID uuid, int frequency, byte value) { - String key = String.valueOf(uuid); - Map frequencies = GregTech_API.sAdvancedWirelessRedstone.computeIfAbsent(key, k -> new ConcurrentHashMap<>()); - frequencies.put(frequency, 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, byte side) { + return (((((long) + tile.getXCoord() << 20) + + tile.getZCoord() << 10) + + tile.getYCoord() << 10) + + tile.getWorld().provider.dimensionId << 4) + + side; } /** diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverBase.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverBase.java index ccd0ea0b8f..bbe43f9c92 100644 --- a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverBase.java +++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverBase.java @@ -47,7 +47,8 @@ public class GT_Cover_AdvancedRedstoneReceiverBase extends GT_CoverBehaviorBase< @Override public boolean onCoverRemovalImpl(byte aSide, int aCoverID, ReceiverData aCoverVariable, ICoverable aTileEntity, boolean aForced) { - GregTech_API.removeAdvancedRedstone(aCoverVariable.uuid, aCoverVariable.frequency); + long hash = GregTech_API.hashCoverCoords(aTileEntity, aSide); + GregTech_API.removeAdvancedRedstone(aCoverVariable.uuid, aCoverVariable.frequency, hash); return true; } diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterBase.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterBase.java index a71cea094a..f7f6cc3a40 100644 --- a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterBase.java +++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterBase.java @@ -47,7 +47,8 @@ public class GT_Cover_AdvancedRedstoneTransmitterBase extends GT_CoverBehaviorBa @Override public boolean onCoverRemovalImpl(byte aSide, int aCoverID, TransmitterData aCoverVariable, ICoverable aTileEntity, boolean aForced) { - GregTech_API.removeAdvancedRedstone(aCoverVariable.uuid, aCoverVariable.frequency); + long hash = GregTech_API.hashCoverCoords(aTileEntity, aSide); + GregTech_API.removeAdvancedRedstone(aCoverVariable.uuid, aCoverVariable.frequency, hash); return true; } diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterExternal.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterExternal.java index 51533c2b98..d33ed2d47a 100644 --- a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterExternal.java +++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterExternal.java @@ -12,14 +12,16 @@ public class GT_Cover_AdvancedRedstoneTransmitterExternal extends GT_Cover_Advan @Override public TransmitterData doCoverThingsImpl(byte aSide, byte aInputRedstone, int aCoverID, - TransmitterData aCoverVariable, ICoverable tile, long aTimer) { + TransmitterData aCoverVariable, ICoverable aTileEntity, long aTimer) { byte outputRedstone = aInputRedstone; if (aCoverVariable.isInvert()) { if (outputRedstone > 0) outputRedstone = 0; else outputRedstone = 15; } - GregTech_API.setAdvancedRedstone(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), outputRedstone); + long hash = GregTech_API.hashCoverCoords(aTileEntity, aSide); + GregTech_API.setAdvancedRedstone(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), hash, outputRedstone); + return aCoverVariable; } diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterInternal.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterInternal.java index 058081fd13..93f769c567 100644 --- a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterInternal.java +++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterInternal.java @@ -19,7 +19,8 @@ public class GT_Cover_AdvancedRedstoneTransmitterInternal extends GT_Cover_Advan else outputRedstone = 15; } - GregTech_API.setAdvancedRedstone(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), outputRedstone); + long hash = GregTech_API.hashCoverCoords(aTileEntity, aSide); + GregTech_API.setAdvancedRedstone(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), hash, outputRedstone); return aCoverVariable; } -- cgit From 16cf739469afd1332f6e3bd7c93e081dd60988e5 Mon Sep 17 00:00:00 2001 From: Matej Dipčár <492666@mail.muni.cz> Date: Tue, 20 Sep 2022 23:58:31 +0200 Subject: Fix map not updating when transmitter TE gets destroyed The map is reset when player opens cover GUI --- src/main/java/gregtech/api/GregTech_API.java | 6 ++++++ .../covers/redstone/GT_Cover_AdvancedRedstoneTransmitterBase.java | 1 + 2 files changed, 7 insertions(+) (limited to 'src/main/java') diff --git a/src/main/java/gregtech/api/GregTech_API.java b/src/main/java/gregtech/api/GregTech_API.java index d4fd4206cf..e6bd089027 100644 --- a/src/main/java/gregtech/api/GregTech_API.java +++ b/src/main/java/gregtech/api/GregTech_API.java @@ -192,6 +192,12 @@ public class GregTech_API { .reduce(true, (signalA, signalB) -> signalA && signalB) ? 15 : 0); } + public static void resetAdvancedRedstoneFrequency(UUID uuid, int frequency) { + Map> frequencies = GregTech_API.sAdvancedWirelessRedstone.get(String.valueOf(uuid)); + if (frequencies == null) return; + frequencies.computeIfPresent(frequency, (k, longByteMap) -> new ConcurrentHashMap<>()); + } + public static void removeAdvancedRedstone(UUID uuid, int frequency, long hash) { Map> frequencies = GregTech_API.sAdvancedWirelessRedstone.get(String.valueOf(uuid)); if (frequencies == null) return; diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterBase.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterBase.java index f7f6cc3a40..3e16a4b202 100644 --- a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterBase.java +++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterBase.java @@ -284,6 +284,7 @@ public class GT_Cover_AdvancedRedstoneTransmitterBase extends GT_CoverBehaviorBa privateButton.setChecked(coverVariable.uuid != null); invertButton.setChecked(coverVariable.invert); resetTextBox(frequencyBox); + GregTech_API.resetAdvancedRedstoneFrequency(coverVariable.uuid, coverVariable.frequency); } @Override -- cgit From 65fe09f68401bb773651a7a2ca2fcb1d50abc508 Mon Sep 17 00:00:00 2001 From: Matej Dipčár <492666@mail.muni.cz> Date: Wed, 21 Sep 2022 01:04:24 +0200 Subject: Fix GUI button ids --- .../common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverBase.java | 2 +- .../covers/redstone/GT_Cover_AdvancedRedstoneTransmitterBase.java | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) (limited to 'src/main/java') diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverBase.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverBase.java index bbe43f9c92..53a36cadce 100644 --- a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverBase.java +++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverBase.java @@ -204,7 +204,7 @@ public class GT_Cover_AdvancedRedstoneReceiverBase extends GT_CoverBehaviorBase< this.coverID = aCoverID; this.coverVariable = aCoverVariable; - frequencyBox = new GT_Cover_AdvancedRedstoneReceiverBase.GUI.GT_GuiShortTextBox(this, 2, startX, startY + 2, spaceX * 5 - 3, 12); + frequencyBox = new GT_Cover_AdvancedRedstoneReceiverBase.GUI.GT_GuiShortTextBox(this, 0, startX, startY + 2, spaceX * 5 - 3, 12); privateButton = new GT_GuiIconCheckButton(this, 0, startX, startY + spaceY * 1, GT_GuiIcon.CHECKMARK, null); } diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterBase.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterBase.java index 3e16a4b202..7e5232c59b 100644 --- a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterBase.java +++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterBase.java @@ -218,9 +218,9 @@ public class GT_Cover_AdvancedRedstoneTransmitterBase extends GT_CoverBehaviorBa this.coverID = aCoverID; this.coverVariable = aCoverVariable; + frequencyBox = new GT_Cover_AdvancedRedstoneTransmitterBase.GUI.GT_GuiShortTextBox(this, 0, startX, startY + 2, spaceX * 5 - 3, 12); privateButton = new GT_GuiIconCheckButton(this, 0, startX, startY + spaceY * 1, GT_GuiIcon.CHECKMARK, null); - invertButton = new GT_GuiIconCheckButton(this, 0, startX, startY + spaceY * 2, GT_GuiIcon.REDSTONE_ON, GT_GuiIcon.REDSTONE_OFF, INVERTED, NORMAL); - frequencyBox = new GT_Cover_AdvancedRedstoneTransmitterBase.GUI.GT_GuiShortTextBox(this, 2, startX, startY + 2, spaceX * 5 - 3, 12); + invertButton = new GT_GuiIconCheckButton(this, 1, startX, startY + spaceY * 2, GT_GuiIcon.REDSTONE_ON, GT_GuiIcon.REDSTONE_OFF, INVERTED, NORMAL); } @Override -- cgit From 5a3ce692c6da21cb45c12db9076cf344ad4b4f6e Mon Sep 17 00:00:00 2001 From: Matej Dipčár <492666@mail.muni.cz> Date: Wed, 21 Sep 2022 02:58:15 +0200 Subject: Implement all advanced receiver modes --- src/main/java/gregtech/api/GregTech_API.java | 31 ++++++++++--- .../java/gregtech/api/gui/widgets/GT_GuiIcon.java | 5 +++ .../GT_Cover_AdvancedRedstoneReceiverBase.java | 52 ++++++++++++++++++++-- .../GT_Cover_AdvancedRedstoneReceiverExternal.java | 2 +- .../GT_Cover_AdvancedRedstoneReceiverInternal.java | 2 +- 5 files changed, 79 insertions(+), 13 deletions(-) (limited to 'src/main/java') diff --git a/src/main/java/gregtech/api/GregTech_API.java b/src/main/java/gregtech/api/GregTech_API.java index e6bd089027..053d8c6236 100644 --- a/src/main/java/gregtech/api/GregTech_API.java +++ b/src/main/java/gregtech/api/GregTech_API.java @@ -42,6 +42,7 @@ import gregtech.api.util.GT_ModHandler; import gregtech.api.util.GT_OreDictUnificator; import gregtech.api.util.GT_Utility; import gregtech.api.world.GT_Worldgen; +import gregtech.common.covers.redstone.GT_Cover_AdvancedRedstoneReceiverBase; import gregtech.common.items.GT_IntegratedCircuit_Item; import java.util.ArrayList; import java.util.Collection; @@ -179,17 +180,33 @@ public class GregTech_API { */ public static final Map>> sAdvancedWirelessRedstone = new ConcurrentHashMap<>(); - public static Byte getAdvancedRedstone(UUID uuid, int frequency) { + public static Byte getAdvancedRedstone(UUID uuid, int frequency, GT_Cover_AdvancedRedstoneReceiverBase.GateMode mode) { Map> frequencies = GregTech_API.sAdvancedWirelessRedstone.get(String.valueOf(uuid)); if (frequencies == null) return 0; - // TODO: Implement All Modes Map signals = frequencies.get(frequency); - if (signals == null) return 0; - - return (byte) (signals.values().stream() - .map(signal -> signal > 0) - .reduce(true, (signalA, signalB) -> signalA && signalB) ? 15 : 0); + 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); + default: + return 0; + } } public static void resetAdvancedRedstoneFrequency(UUID uuid, int frequency) { diff --git a/src/main/java/gregtech/api/gui/widgets/GT_GuiIcon.java b/src/main/java/gregtech/api/gui/widgets/GT_GuiIcon.java index 37e1a6d960..2be46dfa14 100644 --- a/src/main/java/gregtech/api/gui/widgets/GT_GuiIcon.java +++ b/src/main/java/gregtech/api/gui/widgets/GT_GuiIcon.java @@ -30,6 +30,11 @@ public enum GT_GuiIcon implements IGuiIcon { GREEN_ARROW_DOWN(0, 32 * 5, 32 * 2), CYCLIC(0, 32 * 6, 32 * 2), + AND_GATE(0, 0, 32 * 3), + NAND_GATE(0, 32, 32 * 3), + OR_GATE(0, 32 * 2, 32 * 3), + NOR_GATE(0, 32 * 3, 32 * 3), + SLOT_DARKGRAY(1, 176, 0, 18, 18), SLOT_GRAY(1, 176, 18, 18, 18), diff --git a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverBase.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverBase.java index 53a36cadce..8befcbfd52 100644 --- a/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverBase.java +++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverBase.java @@ -5,6 +5,7 @@ import gregtech.api.GregTech_API; import gregtech.api.enums.GT_Values; import gregtech.api.gui.GT_GUICover; import gregtech.api.gui.widgets.GT_GuiIcon; +import gregtech.api.gui.widgets.GT_GuiIconButton; import gregtech.api.gui.widgets.GT_GuiIconCheckButton; import gregtech.api.gui.widgets.GT_GuiIntegerTextBox; import gregtech.api.interfaces.IGuiScreen; @@ -106,6 +107,13 @@ public class GT_Cover_AdvancedRedstoneReceiverBase extends GT_CoverBehaviorBase< return new GT_Cover_AdvancedRedstoneReceiverBase.GUI(aSide, aCoverID, aCoverVariable, aTileEntity); } + public enum GateMode { + AND, + NAND, + OR, + NOR + } + public static class ReceiverData implements ISerializableObject { private int frequency; @@ -113,14 +121,16 @@ public class GT_Cover_AdvancedRedstoneReceiverBase extends GT_CoverBehaviorBase< * If UUID is set to null, the cover frequency is public, rather than private **/ private UUID uuid; + private GateMode mode; - public ReceiverData(int frequency, UUID uuid) { + public ReceiverData(int frequency, UUID uuid, GateMode mode) { this.frequency = frequency; this.uuid = uuid; + this.mode = mode; } public ReceiverData() { - this(0, null); + this(0, null, GateMode.AND); } public UUID getUuid() { @@ -131,10 +141,14 @@ public class GT_Cover_AdvancedRedstoneReceiverBase extends GT_CoverBehaviorBase< return frequency; } + public GateMode getGateMode() { + return mode; + } + @Nonnull @Override public ISerializableObject copy() { - return new ReceiverData(frequency, uuid); + return new ReceiverData(frequency, uuid, mode); } @Nonnull @@ -145,6 +159,7 @@ public class GT_Cover_AdvancedRedstoneReceiverBase extends GT_CoverBehaviorBase< if (uuid != null) { tag.setString("uuid", uuid.toString()); } + tag.setByte("mode", (byte) mode.ordinal()); return tag; } @@ -157,6 +172,7 @@ public class GT_Cover_AdvancedRedstoneReceiverBase extends GT_CoverBehaviorBase< aBuf.writeLong(uuid.getLeastSignificantBits()); aBuf.writeLong(uuid.getMostSignificantBits()); } + aBuf.writeByte(mode.ordinal()); } @Override @@ -166,6 +182,7 @@ public class GT_Cover_AdvancedRedstoneReceiverBase extends GT_CoverBehaviorBase< if (tag.hasKey("uuid")) { uuid = UUID.fromString(tag.getString("uuid")); } + mode = GateMode.values()[tag.getByte("mode")]; } @Nonnull @@ -175,6 +192,7 @@ public class GT_Cover_AdvancedRedstoneReceiverBase extends GT_CoverBehaviorBase< if (aBuf.readBoolean()) { uuid = new UUID(aBuf.readLong(), aBuf.readLong()); } + mode = GateMode.valu