diff options
Diffstat (limited to 'src/main/java/gregtech/common/covers/redstone')
10 files changed, 1721 insertions, 0 deletions
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..233be511a3 --- /dev/null +++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverBase.java @@ -0,0 +1,193 @@ +package gregtech.common.covers.redstone; + +import com.google.common.io.ByteArrayDataInput; +import gregtech.api.gui.widgets.GT_GuiIcon; +import gregtech.api.gui.widgets.GT_GuiIconButton; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.util.GT_Utility; +import gregtech.api.util.ISerializableObject; +import io.netty.buffer.ByteBuf; +import java.util.UUID; +import javax.annotation.Nonnull; +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.world.World; + +public abstract class GT_Cover_AdvancedRedstoneReceiverBase + extends GT_Cover_AdvancedWirelessRedstoneBase<GT_Cover_AdvancedRedstoneReceiverBase.ReceiverData> { + + 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(); + } + + /** + * GUI Stuff + */ + @Override + public Object getClientGUIImpl( + byte aSide, + int aCoverID, + ReceiverData aCoverVariable, + ICoverable aTileEntity, + EntityPlayer aPlayer, + World aWorld) { + return new ReceiverGUI(aSide, aCoverID, aCoverVariable, aTileEntity); + } + + public enum GateMode { + AND, + NAND, + OR, + NOR, + SINGLE_SOURCE + } + + public static class ReceiverData extends GT_Cover_AdvancedWirelessRedstoneBase.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; + } + } + + private static class ReceiverGUI extends WirelessGUI<ReceiverData> { + + private static final int gateModeButtonIdStart = 1; + + public ReceiverGUI(byte aSide, int aCoverID, ReceiverData aCoverVariable, ICoverable aTileEntity) { + super(aSide, aCoverID, aCoverVariable, aTileEntity); + + new GT_GuiIconButton( + this, + gateModeButtonIdStart + 0, + startX + spaceX * 0, + startY + spaceY * 2, + GT_GuiIcon.AND_GATE) + .setTooltipText(GT_Utility.trans("006", "AND Gate")); + new GT_GuiIconButton( + this, + gateModeButtonIdStart + 1, + startX + spaceX * 1, + startY + spaceY * 2, + GT_GuiIcon.NAND_GATE) + .setTooltipText(GT_Utility.trans("006", "NAND Gate")); + new GT_GuiIconButton( + this, + gateModeButtonIdStart + 2, + startX + spaceX * 2, + startY + spaceY * 2, + GT_GuiIcon.OR_GATE) + .setTooltipText(GT_Utility.trans("006", "OR Gate")); + new GT_GuiIconButton( + this, + gateModeButtonIdStart + 3, + startX + spaceX * 3, + startY + spaceY * 2, + GT_GuiIcon.NOR_GATE) + .setTooltipText(GT_Utility.trans("006", "NOR Gate")); + new GT_GuiIconButton( + this, + gateModeButtonIdStart + 4, + startX + spaceX * 4, + startY + spaceY * 2, + GT_GuiIcon.ANALOG_MODE) + .setTooltipText( + "ANALOG Mode", "Only use this mode with ONE transmitter in total,", "no logic involved"); + } + + @Override + public void drawExtras(int mouseX, int mouseY, float parTicks) { + super.drawExtras(mouseX, mouseY, parTicks); + this.getFontRenderer() + .drawString( + GT_Utility.trans("601", "Gate Mode"), + startX + spaceX * 5, + 4 + startY + spaceY * 2, + textColor); + } + + @Override + protected void update() { + super.update(); + updateButtons(); + } + + private void updateButtons() { + GuiButton button; + for (int i = gateModeButtonIdStart; i < gateModeButtonIdStart + 5; ++i) { + button = (GuiButton) this.buttonList.get(i); + button.enabled = (button.id - gateModeButtonIdStart) != coverVariable.mode.ordinal(); + } + } + + @Override + public void buttonClicked(GuiButton btn) { + if (btn.id >= gateModeButtonIdStart && btn.enabled) { + coverVariable.mode = GateMode.values()[btn.id - gateModeButtonIdStart]; + } + + super.buttonClicked(btn); + } + } +} 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..56b7fadd24 --- /dev/null +++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverExternal.java @@ -0,0 +1,38 @@ +package gregtech.common.covers.redstone; + +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, + getSignalAt(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), aCoverVariable.getGateMode())); + + 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..c3537350a6 --- /dev/null +++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneReceiverInternal.java @@ -0,0 +1,40 @@ +package gregtech.common.covers.redstone; + +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 getSignalAt(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), aCoverVariable.getGateMode()); + } +} 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..07592a00dc --- /dev/null +++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterBase.java @@ -0,0 +1,192 @@ +package gregtech.common.covers.redstone; + +import com.google.common.io.ByteArrayDataInput; +import gregtech.api.gui.widgets.GT_GuiIcon; +import gregtech.api.gui.widgets.GT_GuiIconCheckButton; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.ICoverable; +import gregtech.api.util.GT_Utility; +import gregtech.api.util.ISerializableObject; +import io.netty.buffer.ByteBuf; +import java.util.Objects; +import java.util.UUID; +import javax.annotation.Nonnull; +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.world.World; + +public abstract class GT_Cover_AdvancedRedstoneTransmitterBase< + T extends GT_Cover_AdvancedRedstoneTransmitterBase.TransmitterData> + extends GT_Cover_AdvancedWirelessRedstoneBase<T> { + + public GT_Cover_AdvancedRedstoneTransmitterBase(Class<T> typeToken, ITexture coverTexture) { + super(typeToken, coverTexture); + } + + private static void unregisterSignal(byte aSide, TransmitterData aCoverVariable, ICoverable aTileEntity) { + long hash = hashCoverCoords(aTileEntity, aSide); + removeSignalAt(aCoverVariable.uuid, aCoverVariable.frequency, hash); + } + + @Override + public boolean onCoverRemovalImpl( + byte aSide, int aCoverID, TransmitterData aCoverVariable, ICoverable aTileEntity, boolean aForced) { + unregisterSignal(aSide, aCoverVariable, aTileEntity); + return true; + } + + @Override + protected void onBaseTEDestroyedImpl( + byte aSide, int aCoverID, TransmitterData aCoverVariable, ICoverable aTileEntity) { + unregisterSignal(aSide, aCoverVariable, aTileEntity); + } + + @Override + protected T onCoverScrewdriverClickImpl( + byte aSide, + int aCoverID, + T aCoverVariable, + ICoverable aTileEntity, + EntityPlayer aPlayer, + float aX, + float aY, + float aZ) { + aCoverVariable.invert = !aCoverVariable.invert; + GT_Utility.sendChatToPlayer(aPlayer, GT_Utility.trans("055", aCoverVariable.invert ? "Inverted" : "Normal")); + + return aCoverVariable; + } + + @Override + protected void preDataChangedImpl( + byte aSide, int aCoverID, int aNewCoverId, T aCoverVariable, T aNewCoverVariable, ICoverable aTileEntity) { + if (aCoverVariable.frequency != aNewCoverVariable.frequency + || !Objects.equals(aCoverVariable.uuid, aNewCoverVariable.uuid)) { + unregisterSignal(aSide, aCoverVariable, aTileEntity); + } + } + + public static class TransmitterData extends GT_Cover_AdvancedWirelessRedstoneBase.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 Object getClientGUIImpl( + byte aSide, + int aCoverID, + TransmitterData aCoverVariable, + ICoverable aTileEntity, + EntityPlayer aPlayer, + World aWorld) { + return new TransmitterGUI<>(aSide, aCoverID, aCoverVariable, aTileEntity); + } + + protected class TransmitterGUI<X extends TransmitterData> extends WirelessGUI<X> { + + private final GT_GuiIconCheckButton invertButton; + + private final String INVERTED = GT_Utility.trans("INVERTED", "Inverted"); + private final String NORMAL = GT_Utility.trans("NORMAL", "Normal"); + + public TransmitterGUI( + byte aSide, int aCoverID, X aCoverVariable, ICoverable aTileEntity, int frequencyRow, int buttonRow) { + super(aSide, aCoverID, aCoverVariable, aTileEntity, frequencyRow, buttonRow, true); + invertButton = new GT_GuiIconCheckButton( + this, + 1, + startX + spaceX * 9, + startY + spaceY * buttonRow, + GT_GuiIcon.REDSTONE_ON, + GT_GuiIcon.REDSTONE_OFF, + INVERTED, + NORMAL); + } + + public TransmitterGUI(byte aSide, int aCoverID, X aCoverVariable, ICoverable aTileEntity) { + this(aSide, aCoverID, aCoverVariable, aTileEntity, 0, 1); + } + + @Override + public void drawExtras(int mouseX, int mouseY, float parTicks) { + super.drawExtras(mouseX, mouseY, parTicks); + this.getFontRenderer() + .drawString( + coverVariable.invert ? INVERTED : NORMAL, + startX + spaceX * 10, + 4 + startY + spaceY * buttonRow, + textColor); + } + + @Override + protected void update() { + super.update(); + invertButton.setChecked(coverVariable.invert); + } + + @Override + public void buttonClicked(GuiButton btn) { + if (btn == invertButton) { + coverVariable.invert = !coverVariable.invert; + } + + super.buttonClicked(btn); + } + } +} 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..aaa526e565 --- /dev/null +++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterExternal.java @@ -0,0 +1,48 @@ +package gregtech.common.covers.redstone; + +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.ICoverable; + +public class GT_Cover_AdvancedRedstoneTransmitterExternal + extends GT_Cover_AdvancedRedstoneTransmitterBase<GT_Cover_AdvancedRedstoneTransmitterBase.TransmitterData> { + + public GT_Cover_AdvancedRedstoneTransmitterExternal(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( + byte aSide, + byte aInputRedstone, + int aCoverID, + TransmitterData aCoverVariable, + ICoverable aTileEntity, + long aTimer) { + byte outputRedstone = aInputRedstone; + if (aCoverVariable.isInvert()) { + if (outputRedstone > 0) outputRedstone = 0; + else outputRedstone = 15; + } + + long hash = hashCoverCoords(aTileEntity, aSide); + setSignalAt(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), hash, 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..1d21b7060f --- /dev/null +++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedRedstoneTransmitterInternal.java @@ -0,0 +1,53 @@ +package gregtech.common.covers.redstone; + +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.ICoverable; + +public class GT_Cover_AdvancedRedstoneTransmitterInternal + extends GT_Cover_AdvancedRedstoneTransmitterBase<GT_Cover_AdvancedRedstoneTransmitterBase.TransmitterData> { + + public GT_Cover_AdvancedRedstoneTransmitterInternal(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( + 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; + } + + long hash = hashCoverCoords(aTileEntity, aSide); + setSignalAt(aCoverVariable.getUuid(), aCoverVariable.getFrequency(), hash, 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/covers/redstone/GT_Cover_AdvancedWirelessRedstoneBase.java b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedWirelessRedstoneBase.java new file mode 100644 index 0000000000..a3f37e5f28 --- /dev/null +++ b/src/main/java/gregtech/common/covers/redstone/GT_Cover_AdvancedWirelessRedstoneBase.java @@ -0,0 +1,443 @@ +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 java.util.HashMap; +import java.util.Map; +import java.util.UUID; +import java.util.concurrent.ConcurrentHashMap; +import java.util.stream.Collectors; +import javax.annotation.Nonnull; +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.GuiButton; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.nbt.NBTBase; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.ResourceLocation; +import net.minecraftforge.fluids.Fluid; + +public abstract class GT_Cover_AdvancedWirelessRedstoneBase< + T extends GT_Cover_AdvancedWirelessRedstoneBase.WirelessData> + extends GT_CoverBehaviorBase<T> { + + public GT_Cover_AdvancedWirelessRedstoneBase(Class<T> typeToken, ITexture coverTexture) { + super(typeToken, coverTexture); + } + + public static Byte getSignalAt(UUID uuid, int frequency, GT_Cover_AdvancedRedstoneReceiverBase.GateMode mode) { + Map<Integer, Map<Long, Byte>> frequencies = GregTech_API.sAdvancedWirelessRedstone.get(String.valueOf(uuid)); + if (frequencies == null) return 0; + + Map<Long, Byte> 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 (Byte) signals.values().toArray()[0]; + default: + return 0; + } + } + + public static void removeSignalAt(UUID uuid, int frequency, long hash) { + Map<Integer, Map<Long, Byte>> frequencies = GregTech_API.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<Integer, Map<Long, Byte>> frequencies = GregTech_API.sAdvancedWirelessRedstone.computeIfAbsent( + String.valueOf(uuid), k -> new ConcurrentHashMap<>()); + Map<Long, Byte> 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, byte side) { + return (((((long) tile.getXCoord() << 20) + tile.getZCoord() << 10) + tile.getYCoord() << 10) + + tile.getWorld().provider.dimensionId + << 4) + + side; + } + + @Override + public boolean letsEnergyInImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsEnergyOutImpl(byte aSide, int aCoverID, T aCoverVariable, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsFluidInImpl(byte aSide, int aCoverID, T aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsFluidOutImpl(byte aSide, int aCoverID, T aCoverVariable, Fluid aFluid, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsItemsInImpl(byte aSide, int aCoverID, T aCoverVariable, int aSlot, ICoverable aTileEntity) { + return true; + } + + @Override + public boolean letsItemsOutImpl(byte aSide, int aCoverID, T aCoverVariable, int aSlot, ICoverable aTileEntity) { + return true; + } + + @Override + public String getDescriptionImpl(byte aSide, int aCoverID, T 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, 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 static class WirelessGUI<X extends WirelessData> extends GT_GUICover { + + protected final byte side; + protected final int coverID; + protected final GT_GuiIntegerTextBox frequencyBox; + protected final GT_GuiIconCheckButton privateButton; + protected final X coverVariable; + + protected static final int startX = 10; + protected static final int startY = 25; + protected static final int spaceX = 18; + protected static final int spaceY = 18; + + protected final int frequencyRow; + protected final int buttonRow; + private final int privateExtraColumn; + + protected final int textColor = this.getTextColorOrDefault("text", 0xFF555555); + + private static final String guiTexturePath = "gregtech:textures/gui/GuiCoverLong.png"; + + public WirelessGUI( + byte aSide, + int aCoverID, + X aCoverVariable, + ICoverable aTileEntity, + int frequencyRow, + int buttonRow, + boolean shiftPrivateLeft) { + super(aTileEntity, 250, 107, GT_Utility.intToStack(aCoverID)); + this.mGUIbackgroundLocation = new ResourceLocation(guiTexturePath); + this.side = aSide; + this.coverID = aCoverID; + this.coverVariable = aCoverVariable; + this.frequencyRow = frequencyRow; + this.buttonRow = buttonRow; + this.privateExtraColumn = shiftPrivateLeft ? 1 : 5; + + frequencyBox = + new GT_GuiShortTextBox(this, 0, 1 + startX, 2 + startY + spaceY * frequencyRow, spaceX * 5 - 4, 12); + privateButton = + new GT_GuiIconCheckButton(this, 0, startX, startY + spaceY * buttonRow, GT_GuiIcon.CHECKMARK, null); + } + + public WirelessGUI(byte aSide, int aCoverID, X aCoverVariable, ICoverable aTileEntity) { + this(aSide, aCoverID, aCoverVariable, aTileEntity, 0, 1, false); + } + + @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 + spaceY * frequencyRow, + textColor); + this.getFontRenderer() + .drawString( + GT_Utility.trans("601", "Use Private Frequency"), + startX + spaceX * privateExtraColumn, + 4 + startY + spaceY * buttonRow, + textColor); + } + + @Override + protected void onInitGui(int guiLeft, int guiTop, int gui_width, int gui_height) { + update(); |