From 11a2735b633623cb6a754247c4f42ff14810b38b Mon Sep 17 00:00:00 2001 From: NotAPenguin Date: Thu, 18 Jul 2024 17:08:27 +0200 Subject: Add wireless computation and data stick hatches (#2724) * start on wireless computation * initial implementation of wireless computation hatch * Implement wireless data sticks * Fix wireless computation by simplifying the implementation greatly * Delete dead code * Add scanner output for wireless computation in network * Rename wireless computation hatch to cloud hatch * Final rename to client/server --- .../tectech/loader/thing/MachineLoader.java | 33 ++++- .../technus/tectech/thing/CustomItemList.java | 4 + .../GT_MetaTileEntity_Hatch_InputDataItems.java | 11 ++ ...TileEntity_Hatch_WirelessComputation_Input.java | 139 +++++++++++++++++++ ...ileEntity_Hatch_WirelessComputation_Output.java | 61 +++++++++ ...etaTileEntity_Hatch_WirelessInputDataItems.java | 146 ++++++++++++++++++++ ...taTileEntity_Hatch_WirelessOutputDataItems.java | 148 +++++++++++++++++++++ .../multi/GT_MetaTileEntity_EM_computer.java | 101 +++++++++++++- .../multi/GT_MetaTileEntity_EM_dataBank.java | 92 ++++++++++++- .../GT_MetaTileEntity_Hatch_DataAccess.java | 18 +++ .../gregtech/common/WirelessComputationPacket.java | 120 +++++++++++++++++ .../java/gregtech/common/WirelessDataStore.java | 36 +++++ .../common/misc/GlobalVariableStorage.java | 10 +- .../multi/GT_MetaTileEntity_AssemblyLine.java | 14 +- src/main/resources/assets/tectech/lang/en_US.lang | 9 ++ 15 files changed, 921 insertions(+), 21 deletions(-) create mode 100644 src/main/java/com/github/technus/tectech/thing/metaTileEntity/hatch/GT_MetaTileEntity_Hatch_WirelessComputation_Input.java create mode 100644 src/main/java/com/github/technus/tectech/thing/metaTileEntity/hatch/GT_MetaTileEntity_Hatch_WirelessComputation_Output.java create mode 100644 src/main/java/com/github/technus/tectech/thing/metaTileEntity/hatch/GT_MetaTileEntity_Hatch_WirelessInputDataItems.java create mode 100644 src/main/java/com/github/technus/tectech/thing/metaTileEntity/hatch/GT_MetaTileEntity_Hatch_WirelessOutputDataItems.java create mode 100644 src/main/java/gregtech/common/WirelessComputationPacket.java create mode 100644 src/main/java/gregtech/common/WirelessDataStore.java diff --git a/src/main/java/com/github/technus/tectech/loader/thing/MachineLoader.java b/src/main/java/com/github/technus/tectech/loader/thing/MachineLoader.java index 13681d2637..ecbe748705 100644 --- a/src/main/java/com/github/technus/tectech/loader/thing/MachineLoader.java +++ b/src/main/java/com/github/technus/tectech/loader/thing/MachineLoader.java @@ -59,9 +59,13 @@ import static com.github.technus.tectech.thing.CustomItemList.Uncertainty_Hatch; import static com.github.technus.tectech.thing.CustomItemList.UnusedStuff; import static com.github.technus.tectech.thing.CustomItemList.capacitor_Hatch; import static com.github.technus.tectech.thing.CustomItemList.dataInAss_Hatch; +import static com.github.technus.tectech.thing.CustomItemList.dataInAss_Wireless_Hatch; import static com.github.technus.tectech.thing.CustomItemList.dataIn_Hatch; +import static com.github.technus.tectech.thing.CustomItemList.dataIn_Wireless_Hatch; import static com.github.technus.tectech.thing.CustomItemList.dataOutAss_Hatch; +import static com.github.technus.tectech.thing.CustomItemList.dataOutAss_Wireless_Hatch; import static com.github.technus.tectech.thing.CustomItemList.dataOut_Hatch; +import static com.github.technus.tectech.thing.CustomItemList.dataOut_Wireless_Hatch; import static com.github.technus.tectech.thing.CustomItemList.eM_dynamoMulti16_EV; import static com.github.technus.tectech.thing.CustomItemList.eM_dynamoMulti16_IV; import static com.github.technus.tectech.thing.CustomItemList.eM_dynamoMulti16_LuV; @@ -318,7 +322,11 @@ import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_H import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_ParamText; import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_Rack; import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_Uncertainty; +import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_WirelessComputation_Input; +import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_WirelessComputation_Output; +import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_WirelessInputDataItems; import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_WirelessMulti; +import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_WirelessOutputDataItems; import com.github.technus.tectech.thing.metaTileEntity.multi.GT_MetaTileEntity_EM_EyeOfHarmony; import com.github.technus.tectech.thing.metaTileEntity.multi.GT_MetaTileEntity_EM_ForgeOfGods; import com.github.technus.tectech.thing.metaTileEntity.multi.GT_MetaTileEntity_EM_computer; @@ -1929,7 +1937,30 @@ public class MachineLoader implements Runnable { "hatch.dataoutass.tier.07", "Data Bank Master Connector", 7).getStackForm(1L)); - + dataOut_Wireless_Hatch.set( + new GT_MetaTileEntity_Hatch_WirelessComputation_Output( + 15444, + "hatch.dataout.wireless.tier.12", + "Cloud Computation Server Hatch", + 12).getStackForm(1L)); + dataIn_Wireless_Hatch.set( + new GT_MetaTileEntity_Hatch_WirelessComputation_Input( + 15445, + "hatch.datain.wireless.tier.12", + "Cloud Computation Client Hatch", + 12).getStackForm(1L)); + dataInAss_Wireless_Hatch.set( + new GT_MetaTileEntity_Hatch_WirelessInputDataItems( + 15446, + "hatch.datainass.wireless.tier.12", + "Wireless Assembly line Slave Connector", + 12).getStackForm(1L)); + dataOutAss_Wireless_Hatch.set( + new GT_MetaTileEntity_Hatch_WirelessOutputDataItems( + 15447, + "hatch.dataoutass.wireless.tier.12", + "Wireless Data Bank Master Connector", + 12).getStackForm(1L)); rack_Hatch .set(new GT_MetaTileEntity_Hatch_Rack(15450, "hatch.rack.tier.08", "Computer Rack", 8).getStackForm(1L)); holder_Hatch.set( diff --git a/src/main/java/com/github/technus/tectech/thing/CustomItemList.java b/src/main/java/com/github/technus/tectech/thing/CustomItemList.java index a45e342050..4e10eaa74f 100644 --- a/src/main/java/com/github/technus/tectech/thing/CustomItemList.java +++ b/src/main/java/com/github/technus/tectech/thing/CustomItemList.java @@ -309,6 +309,10 @@ public enum CustomItemList implements IItemContainer { UncertaintyX_Hatch, dataIn_Hatch, dataOut_Hatch, + dataOut_Wireless_Hatch, + dataIn_Wireless_Hatch, + dataInAss_Wireless_Hatch, + dataOutAss_Wireless_Hatch, dataInAss_Hatch, dataOutAss_Hatch, eM_Containment, diff --git a/src/main/java/com/github/technus/tectech/thing/metaTileEntity/hatch/GT_MetaTileEntity_Hatch_InputDataItems.java b/src/main/java/com/github/technus/tectech/thing/metaTileEntity/hatch/GT_MetaTileEntity_Hatch_InputDataItems.java index 50e9eebd76..9fc12e6ac5 100644 --- a/src/main/java/com/github/technus/tectech/thing/metaTileEntity/hatch/GT_MetaTileEntity_Hatch_InputDataItems.java +++ b/src/main/java/com/github/technus/tectech/thing/metaTileEntity/hatch/GT_MetaTileEntity_Hatch_InputDataItems.java @@ -10,6 +10,10 @@ import static net.minecraft.util.StatCollector.translateToLocal; import static net.minecraft.util.StatCollector.translateToLocalFormatted; import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.function.Predicate; +import java.util.stream.Collectors; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.entity.player.EntityPlayerMP; @@ -199,6 +203,13 @@ public class GT_MetaTileEntity_Hatch_InputDataItems extends GT_MetaTileEntity_Ha return stacks != null && aIndex < stacks.length ? stacks[aIndex] : null; } + @Override + public List getInventoryItems(Predicate filter) { + return Arrays.stream(stacks) + .filter(stack -> stack != null && filter.test(stack)) + .collect(Collectors.toList()); + } + @Override public boolean shouldDropItemAt(int index) { return false; diff --git a/src/main/java/com/github/technus/tectech/thing/metaTileEntity/hatch/GT_MetaTileEntity_Hatch_WirelessComputation_Input.java b/src/main/java/com/github/technus/tectech/thing/metaTileEntity/hatch/GT_MetaTileEntity_Hatch_WirelessComputation_Input.java new file mode 100644 index 0000000000..c29a5320dd --- /dev/null +++ b/src/main/java/com/github/technus/tectech/thing/metaTileEntity/hatch/GT_MetaTileEntity_Hatch_WirelessComputation_Input.java @@ -0,0 +1,139 @@ +package com.github.technus.tectech.thing.metaTileEntity.hatch; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.common.util.ForgeDirection; + +import org.apache.commons.lang3.reflect.FieldUtils; + +import com.github.technus.tectech.thing.gui.TecTechUITextures; +import com.gtnewhorizons.modularui.api.math.Alignment; +import com.gtnewhorizons.modularui.api.math.Color; +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.api.screen.UIBuildContext; +import com.gtnewhorizons.modularui.common.widget.DrawableWidget; +import com.gtnewhorizons.modularui.common.widget.TextWidget; +import com.gtnewhorizons.modularui.common.widget.textfield.TextFieldWidget; + +import gregtech.api.gui.modularui.GT_UIInfos; +import gregtech.api.gui.modularui.GT_UITextures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.modularui.IAddGregtechLogo; +import gregtech.api.interfaces.modularui.IAddUIWidgets; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.common.WirelessComputationPacket; + +public class GT_MetaTileEntity_Hatch_WirelessComputation_Input extends GT_MetaTileEntity_Hatch_InputData + implements IAddGregtechLogo, IAddUIWidgets { + + public long requiredComputation = 10000; + + private String clientLocale = "en_US"; + + public GT_MetaTileEntity_Hatch_WirelessComputation_Input(int aID, String aName, String aNameRegional, int aTier) { + super(aID, aName, aNameRegional, aTier); + } + + public GT_MetaTileEntity_Hatch_WirelessComputation_Input(String aName, int aTier, String[] aDescription, + ITexture[][][] aTextures) { + super(aName, aTier, aDescription, aTextures); + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new GT_MetaTileEntity_Hatch_WirelessComputation_Input(mName, mTier, mDescriptionArray, mTextures); + } + + @Override + public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) { + try { + EntityPlayerMP player = (EntityPlayerMP) aPlayer; + clientLocale = (String) FieldUtils.readField(player, "translator", true); + } catch (Exception e) { + clientLocale = "en_US"; + } + if (!aPlayer.isUsingItem()) { + GT_UIInfos.openGTTileEntityUI(aBaseMetaTileEntity, aPlayer); + } + return super.onRightclick(aBaseMetaTileEntity, aPlayer); + } + + @Override + public boolean isDataInputFacing(ForgeDirection side) { + return false; + } + + @Override + public boolean canConnectData(ForgeDirection side) { + return false; + } + + @Override + public void onPreTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + super.onPreTick(aBaseMetaTileEntity, aTick); + if (aBaseMetaTileEntity.isServerSide() && q == null) { + q = WirelessComputationPacket.downloadData(aBaseMetaTileEntity.getOwnerUuid(), requiredComputation, aTick); + } + + } + + @Override + public void onFirstTick(IGregTechTileEntity aBaseMetaTileEntity) { + super.onFirstTick(aBaseMetaTileEntity); + } + + @Override + public boolean useModularUI() { + return true; + } + + @Override + public void addGregTechLogo(ModularWindow.Builder builder) { + builder.widget( + new DrawableWidget().setDrawable(TecTechUITextures.PICTURE_TECTECH_LOGO) + .setSize(18, 18) + .setPos(151, 63)); + } + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + super.loadNBTData(aNBT); + requiredComputation = aNBT.getLong("requiredComputation"); + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + super.saveNBTData(aNBT); + aNBT.setLong("requiredComputation", requiredComputation); + } + + @Override + public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) { + builder.widget( + TextWidget.localised("tt.wirelessInputData.config.text") + .setPos(20, 12) + .setSize(140, 14)) + .widget( + new TextFieldWidget().setSetterInt(val -> requiredComputation = val) + .setGetterLong(() -> requiredComputation) + .setNumbers(1, Integer.MAX_VALUE) + .setOnScrollNumbers(1, 4, 64) + .setTextAlignment(Alignment.Center) + .setTextColor(Color.WHITE.normal) + .setSize(70, 18) + .setPos(54, 36) + .setBackground(GT_UITextures.BACKGROUND_TEXT_FIELD)); + } + + private static String[] tooltips; + + @Override + public String[] getDescription() { + if (tooltips == null) { + tooltips = new String[] { "Wireless Computation Data Input for Multiblocks" }; + } + return tooltips; + } +} diff --git a/src/main/java/com/github/technus/tectech/thing/metaTileEntity/hatch/GT_MetaTileEntity_Hatch_WirelessComputation_Output.java b/src/main/java/com/github/technus/tectech/thing/metaTileEntity/hatch/GT_MetaTileEntity_Hatch_WirelessComputation_Output.java new file mode 100644 index 0000000000..6e09554acd --- /dev/null +++ b/src/main/java/com/github/technus/tectech/thing/metaTileEntity/hatch/GT_MetaTileEntity_Hatch_WirelessComputation_Output.java @@ -0,0 +1,61 @@ +package com.github.technus.tectech.thing.metaTileEntity.hatch; + +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.common.WirelessComputationPacket; + +public class GT_MetaTileEntity_Hatch_WirelessComputation_Output extends GT_MetaTileEntity_Hatch_OutputData { + + public GT_MetaTileEntity_Hatch_WirelessComputation_Output(int aID, String aName, String aNameRegional, int aTier) { + super(aID, aName, aNameRegional, aTier); + + } + + public GT_MetaTileEntity_Hatch_WirelessComputation_Output(String aName, int aTier, String[] aDescription, + ITexture[][][] aTextures) { + super(aName, aTier, aDescription, aTextures); + + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new GT_MetaTileEntity_Hatch_WirelessComputation_Output(mName, mTier, mDescriptionArray, mTextures); + } + + @Override + public boolean isOutputFacing(ForgeDirection side) { + return false; + } + + @Override + public boolean isDataInputFacing(ForgeDirection side) { + return false; + } + + @Override + public boolean canConnectData(ForgeDirection side) { + return false; + } + + @Override + public void onPreTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + super.onPreTick(aBaseMetaTileEntity, aTick); + if (aBaseMetaTileEntity.isServerSide() && q != null) { + WirelessComputationPacket.uploadData(aBaseMetaTileEntity.getOwnerUuid(), q.getContent(), aTick); + q = null; + } + } + + private static String[] tooltips; + + @Override + public String[] getDescription() { + if (tooltips == null) { + tooltips = new String[] { "Wireless Computation Output for Multiblocks" }; + } + return tooltips; + } +} diff --git a/src/main/java/com/github/technus/tectech/thing/metaTileEntity/hatch/GT_MetaTileEntity_Hatch_WirelessInputDataItems.java b/src/main/java/com/github/technus/tectech/thing/metaTileEntity/hatch/GT_MetaTileEntity_Hatch_WirelessInputDataItems.java new file mode 100644 index 0000000000..15f4b1f988 --- /dev/null +++ b/src/main/java/com/github/technus/tectech/thing/metaTileEntity/hatch/GT_MetaTileEntity_Hatch_WirelessInputDataItems.java @@ -0,0 +1,146 @@ +package com.github.technus.tectech.thing.metaTileEntity.hatch; + +import static com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_DataConnector.EM_D_ACTIVE; +import static com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_DataConnector.EM_D_CONN; +import static com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_DataConnector.EM_D_SIDES; +import static gregtech.api.enums.Dyes.MACHINE_METAL; +import static net.minecraft.util.StatCollector.translateToLocal; +import static net.minecraft.util.StatCollector.translateToLocalFormatted; + +import java.util.List; +import java.util.function.Predicate; +import java.util.stream.Collectors; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.item.ItemStack; +import net.minecraftforge.common.util.ForgeDirection; + +import org.apache.commons.lang3.reflect.FieldUtils; + +import com.github.technus.tectech.util.CommonValues; +import com.github.technus.tectech.util.TT_Utility; + +import gregtech.api.enums.Dyes; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_DataAccess; +import gregtech.api.objects.GT_RenderedTexture; +import gregtech.common.WirelessDataStore; + +public class GT_MetaTileEntity_Hatch_WirelessInputDataItems extends GT_MetaTileEntity_Hatch_DataAccess { + + private String clientLocale = "en_US"; + + public GT_MetaTileEntity_Hatch_WirelessInputDataItems(int aID, String aName, String aNameRegional, int aTier) { + super(aID, aName, aNameRegional, aTier); + TT_Utility.setTier(aTier, this); + } + + public GT_MetaTileEntity_Hatch_WirelessInputDataItems(String aName, int aTier, String aDescription, + ITexture[][][] aTextures) { + super(aName, aTier, aDescription, aTextures); + } + + public GT_MetaTileEntity_Hatch_WirelessInputDataItems(String aName, int aTier, String[] aDescription, + ITexture[][][] aTextures) { + super(aName, aTier, aDescription, aTextures); + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new GT_MetaTileEntity_Hatch_WirelessInputDataItems( + this.mName, + this.mTier, + mDescriptionArray, + this.mTextures); + } + + @Override + public ITexture[] getTexturesActive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, + new GT_RenderedTexture( + EM_D_ACTIVE, + Dyes.getModulation(getBaseMetaTileEntity().getColorization(), MACHINE_METAL.getRGBA())), + new GT_RenderedTexture(EM_D_CONN) }; + } + + @Override + public ITexture[] getTexturesInactive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, + new GT_RenderedTexture( + EM_D_SIDES, + Dyes.getModulation(getBaseMetaTileEntity().getColorization(), MACHINE_METAL.getRGBA())), + new GT_RenderedTexture(EM_D_CONN) }; + } + + @Override + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + return false; + } + + @Override + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + return false; + } + + @Override + public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) { + if (aBaseMetaTileEntity.isClientSide()) { + return true; + } + try { + EntityPlayerMP player = (EntityPlayerMP) aPlayer; + clientLocale = (String) FieldUtils.readField(player, "translator", true); + } catch (Exception e) { + clientLocale = "en_US"; + } + return true; + } + + @Override + public int getInventoryStackLimit() { + return 1; + } + + @Override + public boolean isOutputFacing(ForgeDirection side) { + return false; + } + + @Override + public boolean isInputFacing(ForgeDirection side) { + return side == getBaseMetaTileEntity().getFrontFacing(); + } + + @Override + public String[] getDescription() { + return new String[] { CommonValues.TEC_MARK_EM, + translateToLocal("gt.blockmachines.hatch.datainasswireless.desc.0"), + translateToLocal("gt.blockmachines.hatch.datainasswireless.desc.1"), }; + } + + @Override + public List getInventoryItems(Predicate filter) { + WirelessDataStore wirelessData = WirelessDataStore + .getWirelessDataSticks(getBaseMetaTileEntity().getOwnerUuid()); + return wirelessData.downloadData() + .stream() + .filter(stack -> stack != null && filter.test(stack)) + .collect(Collectors.toList()); + } + + @Override + public boolean isGivingInformation() { + return true; + } + + @Override + public String[] getInfoData() { + return new String[] { translateToLocalFormatted("tt.keyphrase.Content_Stack_Count", clientLocale) + ": " + + getInventoryItems(_stack -> true).size() }; + } +} diff --git a/src/main/java/com/github/technus/tectech/thing/metaTileEntity/hatch/GT_MetaTileEntity_Hatch_WirelessOutputDataItems.java b/src/main/java/com/github/technus/tectech/thing/metaTileEntity/hatch/GT_MetaTileEntity_Hatch_WirelessOutputDataItems.java new file mode 100644 index 0000000000..02b8ef182f --- /dev/null +++ b/src/main/java/com/github/technus/tectech/thing/metaTileEntity/hatch/GT_MetaTileEntity_Hatch_WirelessOutputDataItems.java @@ -0,0 +1,148 @@ +package com.github.technus.tectech.thing.metaTileEntity.hatch; + +import static com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_DataConnector.EM_D_ACTIVE; +import static com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_DataConnector.EM_D_CONN; +import static com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_DataConnector.EM_D_SIDES; +import static gregtech.api.enums.Dyes.MACHINE_METAL; +import static net.minecraft.util.StatCollector.translateToLocal; + +import java.util.Arrays; + +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.common.util.ForgeDirection; + +import com.github.technus.tectech.mechanics.dataTransport.InventoryDataPacket; +import com.github.technus.tectech.util.CommonValues; +import com.github.technus.tectech.util.TT_Utility; + +import gregtech.api.enums.Dyes; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch; +import gregtech.api.objects.GT_RenderedTexture; +import gregtech.common.WirelessDataStore; + +public class GT_MetaTileEntity_Hatch_WirelessOutputDataItems extends GT_MetaTileEntity_Hatch { + + public InventoryDataPacket dataPacket = null; + + public boolean uploadedSinceReset = false; + + public GT_MetaTileEntity_Hatch_WirelessOutputDataItems(int aID, String aName, String aNameRegional, int aTier) { + super( + aID, + aName, + aNameRegional, + aTier, + 0, + new String[] { CommonValues.TEC_MARK_EM, + translateToLocal("gt.blockmachines.hatch.wirelessdataoutass.desc.0"), + translateToLocal("gt.blockmachines.hatch.wirelessdataoutass.desc.1"), }); + TT_Utility.setTier(aTier, this); + } + + public GT_MetaTileEntity_Hatch_WirelessOutputDataItems(String aName, int aTier, String[] aDescription, + ITexture[][][] aTextures) { + super(aName, aTier, 0, aDescription, aTextures); + } + + @Override + public boolean isSimpleMachine() { + return true; + } + + @Override + public boolean isFacingValid(ForgeDirection facing) { + return true; + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new GT_MetaTileEntity_Hatch_WirelessOutputDataItems( + this.mName, + this.mTier, + this.mDescriptionArray, + this.mTextures); + } + + @Override + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + return false; + } + + @Override + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + return false; + } + + @Override + public int getInventoryStackLimit() { + return 1; + } + + @Override + public boolean isOutputFacing(ForgeDirection side) { + return side == getBaseMetaTileEntity().getFrontFacing(); + } + + @Override + public boolean isInputFacing(ForgeDirection side) { + return false; + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + super.saveNBTData(aNBT); + if (dataPacket != null) { + aNBT.setTag("eDATA", dataPacket.toNbt()); + } + aNBT.setBoolean("uploadedSinceReset", uploadedSinceReset); + } + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + super.loadNBTData(aNBT); + if (aNBT.hasKey("eDATA")) { + dataPacket = new InventoryDataPacket(aNBT.getCompoundTag("eDATA")); + } + if (aNBT.hasKey("uploadedSinceReset")) { + uploadedSinceReset = aNBT.getBoolean("uploadedSinceReset"); + } + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if (aBaseMetaTileEntity.isServerSide()) { + // Upload data packet and mark it as uploaded, so it will not be uploaded again + // until the data bank resets the wireless network + if (dataPacket != null && !uploadedSinceReset) { + WirelessDataStore wirelessDataStore = WirelessDataStore + .getWirelessDataSticks(getBaseMetaTileEntity().getOwnerUuid()); + wirelessDataStore.uploadData(Arrays.asList(dataPacket.getContent())); + uploadedSinceReset = true; + } + } + } + + @Override + public ITexture[] getTexturesActive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, + new GT_RenderedTexture( + EM_D_ACTIVE, + Dyes.getModulation(getBaseMetaTileEntity().getColorization(), MACHINE_METAL.getRGBA())), + new GT_RenderedTexture(EM_D_CONN) }; + } + + @Override + public ITexture[] getTexturesInactive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, + new GT_RenderedTexture( + EM_D_SIDES, + Dyes.getModulation(getBaseMetaTileEntity().getColorization(), MACHINE_METAL.getRGBA())), + new GT_RenderedTexture(EM_D_CONN) }; + } +} diff --git a/src/main/java/com/github/technus/tectech/thing/metaTileEntity/multi/GT_MetaTileEntity_EM_computer.java b/src/main/java/com/github/technus/tectech/thing/metaTileEntity/multi/GT_MetaTileEntity_EM_computer.java index 1be94b4333..12b69eeb47 100644 --- a/src/main/java/com/github/technus/tectech/thing/metaTileEntity/multi/GT_MetaTileEntity_EM_computer.java +++ b/src/main/java/com/github/technus/tectech/thing/metaTileEntity/multi/GT_MetaTileEntity_EM_computer.java @@ -18,12 +18,14 @@ import static gregtech.api.util.GT_Utility.filterValidMTEs; import static net.minecraft.util.StatCollector.translateToLocal; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collections; import java.util.List; import javax.annotation.Nonnull; import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.entity.player.EntityPlayer; import net.minecraft.entity.player.EntityPlayerMP; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; @@ -37,6 +39,7 @@ import com.github.technus.tectech.mechanics.dataTransport.QuantumDataPacket; import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_InputData; import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_OutputData; import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_Rack; +import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_WirelessComputation_Output; import com.github.technus.tectech.thing.metaTileEntity.multi.base.GT_MetaTileEntity_MultiblockBase_EM; import com.github.technus.tectech.thing.metaTileEntity.multi.base.INameFunction; import com.github.technus.tectech.thing.metaTileEntity.multi.base.IStatusFunction; @@ -62,8 +65,10 @@ import gregtech.api.recipe.check.CheckRecipeResult; import gregtech.api.recipe.check.CheckRecipeResultRegistry; import gregtech.api.recipe.check.SimpleCheckRecipeResult; import gregtech.api.util.GT_Multiblock_Tooltip_Builder; +import gregtech.api.util.GT_Utility; import gregtech.api.util.IGT_HatchAdder; import gregtech.api.util.shutdown.ShutDownReason; +import gregtech.common.WirelessComputationPacket; /** * Created by danie_000 on 17.12.2016. @@ -74,6 +79,8 @@ public class GT_MetaTileEntity_EM_computer extends GT_MetaTileEntity_MultiblockB // region variables private final ArrayList eRacks = new ArrayList<>(); + private final ArrayList eWirelessComputationOutputs = new ArrayList<>(); + private static Textures.BlockIcons.CustomIcon ScreenOFF; private static Textures.BlockIcons.CustomIcon ScreenON; // endregion @@ -103,7 +110,8 @@ public class GT_MetaTileEntity_EM_computer extends GT_MetaTileEntity_MultiblockB Energy.or(HatchElement.EnergyMulti), Maintenance, HatchElement.Uncertainty, - HatchElement.OutputData) + HatchElement.OutputData, + WirelessComputationHatchElement.INSTANCE) .casingIndex(textureOffset + 1) .dot(1) .buildAndChain(ofBlock(sBlockCasingsTT, 1))) @@ -115,6 +123,8 @@ public class GT_MetaTileEntity_EM_computer extends GT_MetaTileEntity_MultiblockB protected Parameters.Group.ParameterIn overclock, overvolt; protected Parameters.Group.ParameterOut maxCurrentTemp, availableData; + private boolean wirelessModeEnabled = false; + private static final INameFunction OC_NAME = (base, p) -> translateToLocal("gt.blockmachines.multimachine.em.computer.cfgi.0"); // Overclock ratio private static final INameFunction OV_NAME = (base, @@ -208,6 +218,7 @@ public class GT_MetaTileEntity_EM_computer extends GT_MetaTileEntity_MultiblockB public void saveNBTData(NBTTagCompound aNBT) { super.saveNBTData(aNBT); aNBT.setDouble("computation", availableData.get()); + aNBT.setBoolean("wirelessModeEnabled", wirelessModeEnabled); } @Override @@ -217,6 +228,22 @@ public class GT_MetaTileEntity_EM_computer extends GT_MetaTileEntity_MultiblockB availableData.set(aNBT.getDouble("computation")); eAvailableData = (long) availableData.get(); } + if (aNBT.hasKey("wirelessModeEnabled")) { + wirelessModeEnabled = aNBT.getBoolean("wirelessModeEnabled"); + if (wirelessModeEnabled) { + WirelessComputationPacket.enableWirelessNetWork(getBaseMetaTileEntity()); + } + } else { + wirelessModeEnabled = false; + } + } + + @Override + public void onPreTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + super.onPreTick(aBaseMetaTileEntity, aTick); + if (aBaseMetaTileEntity.isServerSide() && wirelessModeEnabled && aTick % 20 == 0) { + WirelessComputationPacket.updatePacket(aBaseMetaTileEntity, aTick); + } } @Override @@ -307,7 +334,7 @@ public class GT_MetaTileEntity_EM_computer extends GT_MetaTileEntity_MultiblockB getBaseMetaTileEntity().getYCoord(), getBaseMetaTileEntity().getZCoord()); - QuantumDataPacket pack = new QuantumDataPacket(eAvailableData / eOutputData.size()).unifyTraceWith(pos); + QuantumDataPacket pack = new QuantumDataPacket(eAvailableData / (eOutputData.size())).unifyTraceWith(pos); if (pack == null) { return; } @@ -336,6 +363,8 @@ public class GT_MetaTileEntity_EM_computer extends GT_MetaTileEntity_MultiblockB // the Quantum Computer .addInfo(translateToLocal("gt.blockmachines.multimachine.em.computer.desc.1")) // Used to generate // computation (and heat) + .addInfo(translateToLocal("gt.blockmachines.multimachine.em.computer.desc.2")) // Use screwdriver to toggle + // wireless mode .addInfo(translateToLocal("tt.keyword.Structure.StructureTooComplex")) // The structure is too complex! .addSeparator() .beginVariableStructureBlock(2, 2, 4, 4, 5, 16, false) @@ -380,6 +409,20 @@ public class GT_MetaTileEntity_EM_computer extends GT_MetaTileEntity_MultiblockB return tt; } + @Override + public void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) { + if (getBaseMetaTileEntity().isServerSide()) { + wirelessModeEnabled = !wirelessModeEnabled; + if (wirelessModeEnabled) { + GT_Utility.sendChatToPlayer(aPlayer, "Wireless mode enabled"); + WirelessComputationPacket.enableWirelessNetWork(getBaseMetaTileEntity()); + } else { + GT_Utility.sendChatToPlayer(aPlayer, "Wireless mode disabled"); + WirelessComputationPacket.disableWirelessNetWork(getBaseMetaTileEntity()); + } + } + } + @Override @SideOnly(Side.CLIENT) public void registerIcons(IIconRegister aBlockIconRegister) { @@ -460,6 +503,24 @@ public class GT_MetaTileEntity_EM_computer extends GT_MetaTileEntity_MultiblockB return false; } + public final boolean addWirelessDataOutputToMachineList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) { + if (aTileEntity == null) { + return false; + } + IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity(); + if (aMetaTileEntity == null) { + return false; + } + if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_WirelessComputation_Output) { + ((GT_MetaTileEntity_Hatch) aMetaTileEntity).updateTexture(aBaseCasingIndex); + // Add to wireless computation outputs, so we can detect these and turn on wireless mode, + // but also add to regular outputs, so they are used as output data hatches by the quantum computer + return eWirelessComputationOutputs.add((GT_MetaTileEntity_Hatch_WirelessComputation_Output) aMetaTileEntity) + && eOutputData.add((GT_MetaTileEntity_Hatch_WirelessComputation_Output) aMetaTileEntity); + } + return false; + } + @Override public void construct(ItemStack stackSize, boolean hintsOnly) { structureBuild_EM("front", 1, 2, 0, stackSize, hintsOnly); @@ -503,6 +564,22 @@ public class GT_MetaTileEntity_EM_computer extends GT_MetaTileEntity_MultiblockB return description; } + @Override + public String[] getInfoData() { + ArrayList data = new ArrayList<>(Arrays.asList(super.getInfoData())); + if (wirelessModeEnabled) { + WirelessComputationPacket wirelessComputationPacket = WirelessComputationPacket + .getPacketByUserId(getBaseMetaTileEntity().getOwnerUuid()); + data.add("Wireless mode: " + EnumChatFormatting.GREEN + "enabled"); + data.add( + "Total wireless computation available: " + EnumChatFormatting.YELLOW + + wirelessComputationPacket.getTotalComputationStored()); + } else { + data.add("Wireless mode: " + EnumChatFormatting.RED + "disabled"); + } + return data.toArray(new String[] {}); + } + private enum RackHatchElement implements IHatchElement { INSTANCE; @@ -522,4 +599,24 @@ public class GT_MetaTileEntity_EM_computer extends GT_MetaTileEntity_MultiblockB return t.eRacks.size(); } } + + private enum WirelessComputationHatchElement implements IHatchElement { + + INSTANCE; + + @Override + public List> mteClasses() { + return Collections.singletonList(GT_MetaTileEntity_Hatch_WirelessComputation_Output.class); + } + + @Override + public IGT_HatchAdder adder() { + return GT_MetaTileEntity_EM_computer::addWirelessDataOutputToMachineList; + } + + @Override + public long count(GT_MetaTileEntity_EM_computer gtMetaTileEntityEmComputer) { + return gtMetaTileEntityEmComputer.eWirelessComputationOutputs.size(); + } + } } diff --git a/src/main/java/com/github/technus/tectech/thing/metaTileEntity/multi/GT_MetaTileEntity_EM_dataBank.java b/src/main/java/com/github/technus/tectech/thing/metaTileEntity/multi/GT_MetaTileEntity_EM_dataBank.java index bbf719542b..0723dc52de 100644 --- a/src/main/java/com/github/technus/tectech/thing/metaTileEntity/multi/GT_MetaTileEntity_EM_dataBank.java +++ b/src/main/java/com/github/technus/tectech/thing/metaTileEntity/multi/GT_MetaTileEntity_EM_dataBank.java @@ -15,9 +15,11 @@ import java.util.Arrays; import java.util.Collections; import java.util.List; +import net.minecraft.entity.player.EntityPlayer; import net.minecraft.entity.player.EntityPlayerMP; import net.minecraft.inventory.IInventory; import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.EnumChatFormatting; import net.minecraft.util.ResourceLocation; import net.minecraftforge.common.util.ForgeDirection; @@ -28,6 +30,7 @@ import com.github.technus.tectech.Reference; import com.github.technus.tectech.mechanics.dataTransport.InventoryDataPacket; import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_InputDataItems; import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_OutputDataItems; +import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_WirelessOutputDataItems; import com.github.technus.tectech.thing.metaTileEntity.multi.base.GT_MetaTileEntity_MultiblockBase_EM; import com.github.technus.tectech.thing.metaTileEntity.multi.base.render.TT_RenderedExtendedFacingTexture; import com.github.technus.tectech.util.CommonValues; @@ -47,15 +50,20 @@ import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_DataA import gregtech.api.recipe.check.CheckRecipeResult; import gregtech.api.recipe.check.SimpleCheckRecipeResult; import gregtech.api.util.GT_Multiblock_Tooltip_Builder; +import gregtech.api.util.GT_Utility; import gregtech.api.util.IGT_HatchAdder; +import gregtech.common.WirelessComputationPacket; +import gregtech.common.WirelessDataStore; public class GT_MetaTileEntity_EM_dataBank extends GT_MetaTileEntity_MultiblockBase_EM implements ISurvivalConstructable { // region variables private final ArrayList eStacksDataOutputs = new ArrayList<>(); + private final ArrayList eWirelessStacksDataOutputs = new ArrayList<>(); private final ArrayList eDataAccessHatches = new ArrayList<>(); private boolean slave = false; + private boolean wirelessModeEnabled = false; // endregion // region structure @@ -81,7 +89,10 @@ public class GT_MetaTileEntity_EM_dataBank extends GT_MetaTileEntity_MultiblockB .addElement( 'D', buildHatchAdder(GT_MetaTileEntity_EM_dataBank.class) - .atLeast(DataBankHatches.OutboundConnector, DataBankHatches.InboundConnector) + .atLeast( + DataBankHatches.OutboundConnector, + DataBankHatches.InboundConnector, + DataBankHatches.WirelessOutboundConnector) .casingIndex(textureOffset + 1) .dot(2) .buildAndChain(DataBankHatches.DataStick.newAny(textureOffset + 1, 2), ofBlock(sBlockCasingsTT, 1))) @@ -111,8 +122,11 @@ public class GT_MetaTileEntity_EM_dataBank extends GT_MetaTileEntity_MultiblockB // Assembling Lines // with more Data Sticks .addInfo(translateToLocal("gt.blockmachines.multimachine.em.databank.desc.2")) // and give multiple - // Assembling - // Lines access to the same Data + // Assembling Lines access to + // the same Data + .addInfo(translateToLocal("gt.blockmachines.multimachine.em.databank.desc.3")) // Use screwdriver to toggle + // wireless mode + // Stick .addInfo(translateToLocal("tt.keyword.Structure.StructureTooComplex")) // The structure is too complex! .addSeparator() @@ -138,6 +152,7 @@ public class GT_MetaTileEntity_EM_dataBank extends GT_MetaTileEntity_MultiblockB public boolean checkMachine_EM(IGregTechTileEntity iGregTechTileEntity, ItemStack itemStack) { eDataAccessHatches.clear(); eStacksDataOutputs.clear(); + eWirelessStacksDataOutputs.clear(); slave = false; return structureCheck_EM("main", 2, 1, 0); } @@ -145,9 +160,10 @@ public class GT_MetaTileEntity_EM_dataBank extends GT_MetaTileEntity_MultiblockB @Override @NotNull protected CheckRecipeResult checkProcessing_EM() { - if (eDataAccessHatches.size() > 0 && eStacksDataOutputs.size() > 0) { + if (eDataAccessHatches.size() > 0 && (eStacksDataOutputs.size() > 0 || eWirelessStacksDataOutputs.size() > 0)) { mEUt = -(int) V[slave ? 6 : 4]; - eAmpereFlow = 1 + (long) eStacksDataOutputs.size() * eDataAccessHatches.size(); + eAmpereFlow = 1 + + (long) (eStacksDataOutputs.size() + eWirelessStacksDataOutputs.size()) * eDataAccessHatches.size(); mMaxProgresstime = 20; mEfficiencyIncrease = 10000; return SimpleCheckRecipeResult.ofSuccess("providing_data"); @@ -172,10 +188,18 @@ public class GT_MetaTileEntity_EM_dataBank extends GT_MetaTileEntity_MultiblockB for (GT_MetaTileEntity_Hatch_OutputDataItems hatch : eStacksDataOutputs) { hatch.q = new InventoryDataPacket(arr); } + if (wirelessModeEnabled) { + for (GT_MetaTileEntity_Hatch_WirelessOutputDataItems hatch : eWirelessStacksDataOutputs) { + hatch.dataPacket = new InventoryDataPacket(arr); + } + } } else { for (GT_MetaTileEntity_Hatch_OutputDataItems hatch : eStacksDataOutputs) { hatch.q = null; } + for (GT_MetaTileEntity_Hatch_WirelessOutputDataItems hatch : eWirelessStacksDataOutputs) { + hatch.dataPacket = null; + } } } @@ -207,6 +231,10 @@ public class GT_MetaTileEntity_EM_dataBank extends GT_MetaTileEntity_MultiblockB if (aMetaTileEntity == null) { return false; } + if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_WirelessOutputDataItems) { + ((GT_MetaTileEntity_Hatch_WirelessOutputDataItems) aMetaTileEntity).updateTexture(aBaseCasingIndex); + return eWirelessStacksDataOutputs.add((GT_MetaTileEntity_Hatch_WirelessOutputDataItems) aMetaTileEntity); + } if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_OutputDataItems) { ((GT_MetaTileEntity_Hatch) aMetaTileEntity).updateTexture(aBaseCasingIndex); return eStacksDataOutputs.add((GT_MetaTileEntity_Hatch_OutputDataItems) aMetaTileEntity); @@ -222,6 +250,53 @@ public class GT_MetaTileEntity_EM_dataBank extends GT_MetaTileEntity_MultiblockB return false; } + @Override + public void onPreTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + super.onPreTick(aBaseMetaTileEntity, aTick); + // Every 200 ticks, clear wireless data store so hatches need to provide their data again in + // their onPostTick() call. This also happens every 200 ticks + if (mMachine && aBaseMetaTileEntity.isActive() && wirelessModeEnabled && aTick % 200 == 0) { + WirelessDataStore wirelessStore = WirelessDataStore + .getWirelessDataSticks(aBaseMetaTileEntity.getOwnerUuid()); + wirelessStore.clearData(); + + // After reset, clear uploadedSinceReset of all connected hatches + for (GT_MetaTileEntity_Hatch_WirelessOutputDataItems hatch : eWirelessStacksDataOutputs) { + hatch.uploadedSinceReset = false; + } + } + } + + @Override + public void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) { + if (getBaseMetaTileEntity().isServerSide()) { + wirelessModeEnabled = !wirelessModeEnabled; + if (wirelessModeEnabled) { + GT_Utility.sendChatToPlayer(aPlayer, "Wireless mode enabled"); + WirelessComputationPacket.enableWirelessNetWork(getBaseMetaTileEntity()); + } else { + GT_Utility.sendChatToPlayer(aPlayer, "Wireless mode disabled"); + WirelessComputationPacket.disableWirelessNetWork(getBaseMetaTileEntity()); + } + } + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + super.saveNBTData(aNBT); + aNBT.setBoolean("wirelessModeEnabled", wirelessModeEnabled); + } + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + super.loadNBTData(aNBT); + if (aNBT.hasKey("wirelessModeEnabled")) { + wirelessModeEnabled = aNBT.getBoolean("wirelessModeEnabled"); + } else { + wirelessModeEnabled = false; + } + } + @Override public void construct(ItemStack stackSize, boolean hintsOnly) { structureBuild_EM("main", 2, 1, 0, stackSize, hintsOnly); @@ -265,6 +340,13 @@ public class GT_MetaTileEntity_EM_dataBank extends GT_MetaTileEntity_MultiblockB public long count(GT_MetaTileEntity_EM_dataBank t) { return t.eDataAccessHatches.size(); } + }, + WirelessOutboundConnector(GT_MetaTileEntity_Hatch_WirelessOutputDataItems.class) { + + @Override + public long count(GT_MetaTileEntity_EM_dataBank t) { + return t.eWirelessStacksDataOutputs.size(); + } }; private final List> mteClasses; diff --git a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_DataAccess.java b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_DataAccess.java index 122dcfa746..f5bfd1d27e 100644 --- a/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_DataAccess.java +++ b/src/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_Hatch_DataAccess.java @@ -2,6 +2,10 @@ package gregtech.api.metatileentity.implementations; import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_DATA_ACCESS; +import java.util.ArrayList; +import java.util.List; +import java.util.function.Predicate; + import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; @@ -139,6 +143,20 @@ public class GT_MetaTileEntity_Hatch_DataAccess extends GT_MetaTileEntity_Hatch GT_AssemblyLineUtils.processDataStick(aStack); } + public List getInventoryItems(Predicate filter) { + ArrayList items = new ArrayList<>(); + IGregTechTileEntity te = getBaseMetaTileEntity(); + for (int i = 0; i < te.getSizeInventory(); ++i) { + ItemStack slot = te.getStackInSlot(i); + if (slot != null) { + if (filter != null && filter.test(slot)) { + items.add(slot); + } + } + } + return items; + } + @Override public boolean useModularUI() { return true; diff --git a/src/main/java/gregtech/common/WirelessComputationPacket.java b/src/main/java/gregtech/common/WirelessComputationPacket.java new file mode 100644 index 0000000000..cafe4d93dc --- /dev/null +++ b/src/main/java/gregtech/common/WirelessComputationPacket.java @@ -0,0 +1,120 @@ +package gregtech.common; + +import static gregtech.common.misc.GlobalVariableStorage.GlobalWirelessComputation; + +import java.util.UUID; + +import com.github.technus.tectech.mechanics.dataTransport.QuantumDataPacket; +import com.gtnewhorizon.structurelib.util.Vec3Impl; + +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.common.misc.spaceprojects.SpaceProjectManager; + +public class WirelessComputationPacket { + + public boolean wirelessEnabled = false; + + // The main idea: 'Clearing' the computation net advances the index and sets the computation stored + // for this index to zero. Uploading is always done to the current index, but data can be downloaded from + // both indices + private final long[] computationStored = new long[] { 0, 0 }; + private long computationDownloaded = 0; + private int currentIndex = 0; + + public Vec3Impl controllerPosition = null; + + public long getTotalComputationStored() { + return computationStored[0] + computationStored[1]; + } + + private long getAvailableComputationStored() { + return getTotalComputationStored() - computationDownloaded; + } + + private QuantumDataPacket download(long dataIn, long aTick) { + if (!wirelessEnabled || controllerPosition == null) return new QuantumDataPacket(0L); + + // If we have enough computation 'stored', download it + // Note that this means that if you do not have enough computation to go to all + // destinations, it won't be distributed equally. This is fine. + // This also means that if you don't have enough computation for a hatch, it will not receive any computation + // at all. This is also fine. + if (getAvailableComputationStored() >= dataIn) { + computationDownloaded += dataIn; + return new QuantumDataPacket(dataIn); + } else return new QuantumDataPacket(0L); + } + + private void update(IGregTechTileEntity entity, long aTick) { + // The reason we want this complex index cycling system is because hatches may upload and download computation + // in the same tick as the currently stored computation is cleared. To avoid interruptions, we want to + // try to double buffer these updates. This means that we keep two computation values around, and every update + // we only clear one of them. Only the most recent entry can be used for uploading computation, but we allow + // downloading computation from both the current and the previous index. + + // Remove downloaded computation previous index (which is also the next index since there are only two), + // then remove the leftover from current index. + int nextIndex = (currentIndex + 1) % 2; + long availableInPrevious = computationStored[nextIndex]; + // Clear stored computation for the next index, since we don't want to allow players to accumulate + // computation in their wireless network indefinitely. This would allow for cheesing research by passively + // banking computation and then setting the input hatch to a high value when the computation is needed. + computationStored[nextIndex] = 0; + if (computationDownloaded > availableInPrevious) { + long toDrainFromCurrent = computationDownloaded - availableInPrevious; + computationStored[currentIndex] -= toDrainFromCurrent; + } + // Reset our current tally of downloaded computation + computationDownloaded = 0; + // Now advance the current index to the next index + currentIndex = nextIndex; + } + + private void setWirelessEnabled(boolean wirelessEnabled) { + this.wirelessEnabled = wirelessEnabled; + } + + private void upload(long dataOut, long aTick) { + // Store computation that is uploaded internally + computationStored[currentIndex] += dataOut; + } + + public static QuantumDataPacket downloadData(UUID userId, long dataIn, long aTick) { + return getPacketByUserId(userId).download(dataIn, aTick); + } + + public static void uploadData(UUID userId, long dataOut, long aTick) { + getPacketByUserId(userId).upload(dataOut, aTick); + } + + public static void updatePacket(IGregTechTileEntity entity, long aTick) { + getPacketByUserId(entity.getOwnerUuid()).update(entity, aTick); + } + + public static boolean enableWirelessNetWork(IGregTechTileEntity entity) { + var packet = getPacketByUserId(entity.getOwnerUuid()); + Vec3Impl pos = new Vec3Impl(entity.getXCoord(), entity.getYCoord(), entity.getZCoord()); + if (packet.wirelessEnabled && packet.controllerPosition != null + && pos.compareTo(packet.controllerPosition) != 0) return false; + getPacketByUserId(entity.getOwnerUuid()).setWirelessEnabled(true); + if (packet.controllerPosition == null) { + packet.controllerPosition = new Vec3Impl(entity.getXCoord(), entity.getYCoord(), entity.getZCoord()); + } + return true; + } + + public static void disableWirelessNetWork(IGregTechTileEntity entity) { + var packet = getPacketByUserId(entity.getOwnerUuid()); + Vec3Impl pos = new Vec3Impl(entity.getXCoord(), entity.getYCoord(), entity.getZCoord()); + if (packet.controllerPosition != null && packet.controllerPosition.compareTo(pos) != 0) return; + getPacketByUserId(entity.getOwnerUuid()).setWirelessEnabled(false); + } + + public static WirelessComputationPacket getPacketByUserId(UUID userId) { + UUID team = SpaceProjectManager.getLeader(userId); + if (GlobalWirelessComputation.get(team) == null) { + GlobalWirelessComputation.put(team, new WirelessComputationPacket()); + } + return GlobalWirelessComputation.get(team); + } +} diff --git a/src/main/java/gregtech/common/WirelessDataStore.java b/src/main/java/gregtech/common/WirelessDataStore.java new file mode 100644 index 0000000000..4016a2440b --- /dev/null +++ b/src/main/java/gregtech/common/WirelessDataStore.java @@ -0,0 +1,36 @@ +package gregtech.common; + +import static gregtech.common.misc.GlobalVariableStorage.GlobalWirelessDataSticks; + +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; + +import net.minecraft.item.ItemStack; + +import gregtech.common.misc.spaceprojects.SpaceProjectManager; + +public class WirelessDataStore { + + private final ArrayList dataSticks = new ArrayList<>(); + + public void clearData() { + dataSticks.clear(); + } + + public void uploadData(List sticks) { + dataSticks.addAll(sticks); + } + + public List downloadData() { + return dataSticks; + } + + public static WirelessDataStore getWirelessDataSticks(UUID uuid) { + UUID team = SpaceProjectManager.getLeader(uuid); + if (GlobalWirelessDataSticks.get(team) == null) { + GlobalWirelessDataSticks.put(team, new WirelessDataStore()); + } + return GlobalWirelessDataSticks.get(team); + } +} diff --git a/src/main/java/gregtech/common/misc/GlobalVariableStorage.java b/src/main/java/gregtech/common/misc/GlobalVariableStorage.java index 27aad0a11f..33abc66f13 100644 --- a/src/main/java/gregtech/common/misc/GlobalVariableStorage.java +++ b/src/main/java/gregtech/common/misc/GlobalVariableStorage.java @@ -4,12 +4,20 @@ import java.math.BigInteger; import java.util.HashMap; import java.util.UUID; +import gregtech.common.WirelessComputationPacket; +import gregtech.common.WirelessDataStore; + public abstract class GlobalVariableStorage { // --------------------- NEVER access these maps! Use the methods provided! --------------------- // Global EU map. public static HashMap GlobalEnergy = new HashMap<>(100, 0.9f); - // ---------------------------------------------------------------------------------------------- + // Global Wireless Data map + public static HashMap GlobalWirelessComputation = new HashMap<>(100, 0.9f); + // Global Wireless Data Stick map + public static HashMap GlobalWirelessDataSticks = new HashMap<>(100, 0.9f); + + // ---------------------------------------------------------------------------------------------- } diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_AssemblyLine.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_AssemblyLine.java index 7c7c27c880..aa422505d7 100644 --- a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_AssemblyLine.java +++ b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_AssemblyLine.java @@ -395,7 +395,7 @@ public class GT_MetaTileEntity_AssemblyLine extends /** * @param state using bitmask, 1 for IntegratedCircuit, 2 for DataStick, 4 for DataOrb */ - private boolean isCorrectDataItem(ItemStack aStack, int state) { + private static boolean isCorrectDataItem(ItemStack aStack, int state) { if ((state & 1) != 0 && ItemList.Circuit_Integrated.isStackEqual(aStack, true, true)) return true; if ((state & 2) != 0 && ItemList.Tool_DataStick.isStackEqual(aStack, false, true)) return true; return (state & 4) != 0 && ItemList.Tool_DataOrb.isStackEqual(aStack, false, true); @@ -410,17 +410,7 @@ public class GT_MetaTileEntity_AssemblyLine extends rList.add(mInventory[1]); } for (GT_MetaTileEntity_Hatch_DataAccess tHatch : filterValidMTEs(mDataAccessHatches)) { - for (int i = 0; i < tHatch.getBaseMetaTileEntity() - .getSizeInventory(); i++) { - if (tHatch.getBaseMetaTileEntity() - .getStackInSlot(i) != null && isCorrectDataItem( - tHatch.getBaseMetaTileEntity() - .getStackInSlot(i), - state)) - rList.add( - tHatch.getBaseMetaTileEntity() - .getStackInSlot(i)); - } + rList.addAll(tHatch.getInventoryItems(stack -> isCorrectDataItem(stack, state))); } return rList; } diff --git a/src/main/resources/assets/tectech/lang/en_US.lang b/src/main/resources/assets/tectech/lang/en_US.lang index e92bbd69d9..ece0cbab3c 100644 --- a/src/main/resources/assets/tectech/lang/en_US.lang +++ b/src/main/resources/assets/tectech/lang/en_US.lang @@ -522,11 +522,17 @@ gt.blockmachines.hatch.datainass.desc.0=ItemStack Data Input for Multiblocks gt.blockmachines.hatch.datainass.desc.1=High speed fibre optics connector. gt.blockmachines.hatch.datainass.desc.2=Must be painted to work +gt.blockmachines.hatch.datainasswireless.desc.0=Wireless ItemStack Data Input for Multiblocks +gt.blockmachines.hatch.datainasswireless.desc.1=High speed internet connection + gt.blockmachines.hatch.dataoutass.tier.07.name=Data Bank Master Connector gt.blockmachines.hatch.dataoutass.desc.0=ItemStack Data Output for Multiblocks gt.blockmachines.hatch.dataoutass.desc.1=High speed fibre optics connector. gt.blockmachines.hatch.dataoutass.desc.2=Must be painted to work +gt.blockmachines.hatch.wirelessdataoutass.desc.0=Wireless ItemStack Data Output for Multiblocks +gt.blockmachines.hatch.wirelessdataoutass.desc.1=High speed internet connection + gt.blockmachines.hatch.rack.tier.08.name=Computer Rack gt.blockmachines.hatch.rack.desc.0=4 Slot Rack gt.blockmachines.hatch.rack.desc.1=Holds Computer Components @@ -703,6 +709,7 @@ gt.blockmachines.multimachine.em.computer.cfgo.0=Current max. heat gt.blockmachines.multimachine.em.computer.cfgo.1=Produced computation gt.blockmachines.multimachine.em.computer.desc.0=Controller block of the Quantum Computer gt.blockmachines.multimachine.em.computer.desc.1=Used to generate computation (and heat) +gt.blockmachines.multimachine.em.computer.desc.2=Use screwdriver to toggle wireless mode gt.blockmachines.multimachine.em.databank.name=Data Bank gt.blockmachines.multimachine.em.databank.hint.0=1 - Classic Hatches or high power casing @@ -710,6 +717,7 @@ gt.blockmachines.multimachine.em.databank.hint.1=2 - Data Access/Data Bank Maste gt.blockmachines.multimachine.em.databank.desc.0=Controller block of the Data Bank gt.blockmachines.multimachine.em.databank.desc.1=Used to supply Assembling Lines with more Data Sticks gt.blockmachines.multimachine.em.databank.desc.2=and give multiple Assembling Lines access to the same Data Stick +gt.blockmachines.multimachine.em.databank.desc.3=Use screwdriver to toggle wireless mode gt.blockmachines.multimachine.em.junction.name=Matter Junction gt.blockmachines.multimachine.em.junction.hint.0=1 - Classic Hatches or High Power Casing @@ -1226,6 +1234,7 @@ tt.keyword.Structure.EssentiaStorage=Essentia Storage tt.keyword.Structure.DataConnector=Data Connector tt.keyword.Structure.SuperconductingCoilBlock=Superconducting Coil Block tt.keyword.Structure.StainlessSteelCasing=Stainless Steel Casing +tt.wirelessInputData.config.text=Configure how much computation to pull from wireless network tt.keyphrase.Hint_Details=Hint Details -- cgit