From 1b820de08a05070909a267e17f033fcf58ac8710 Mon Sep 17 00:00:00 2001 From: NotAPenguin Date: Mon, 2 Sep 2024 23:17:17 +0200 Subject: The Great Renaming (#3014) * move kekztech to a single root dir * move detrav to a single root dir * move gtnh-lanthanides to a single root dir * move tectech and delete some gross reflection in gt++ * remove more reflection inside gt5u * delete more reflection in gt++ * fix imports * move bartworks and bwcrossmod * fix proxies * move galactigreg and ggfab * move gtneioreplugin * try to fix gt++ bee loader * apply the rename rules to BW * apply rename rules to bwcrossmod * apply rename rules to detrav scanner mod * apply rename rules to galacticgreg * apply rename rules to ggfab * apply rename rules to goodgenerator * apply rename rules to gtnh-lanthanides * apply rename rules to gt++ * apply rename rules to kekztech * apply rename rules to kubatech * apply rename rules to tectech * apply rename rules to gt apply the rename rules to gt * fix tt import * fix mui hopefully * fix coremod except intergalactic * rename assline recipe class * fix a class name i stumbled on * rename StructureUtility to GTStructureUtility to prevent conflict with structurelib * temporary rename of GTTooltipDataCache to old name * fix gt client/server proxy names --- .../metaTileEntity/hatch/MTEHatchCapacitor.java | 241 +++++++++ .../metaTileEntity/hatch/MTEHatchCreativeData.java | 129 +++++ .../hatch/MTEHatchCreativeMaintenance.java | 90 ++++ .../hatch/MTEHatchCreativeUncertainty.java | 56 +++ .../hatch/MTEHatchDataConnector.java | 198 ++++++++ .../metaTileEntity/hatch/MTEHatchDataInput.java | 101 ++++ .../hatch/MTEHatchDataItemsInput.java | 255 ++++++++++ .../hatch/MTEHatchDataItemsOutput.java | 133 +++++ .../metaTileEntity/hatch/MTEHatchDataOutput.java | 113 +++++ .../metaTileEntity/hatch/MTEHatchDynamoMulti.java | 127 +++++ .../metaTileEntity/hatch/MTEHatchDynamoTunnel.java | 286 +++++++++++ .../metaTileEntity/hatch/MTEHatchEnergyMulti.java | 133 +++++ .../metaTileEntity/hatch/MTEHatchEnergyTunnel.java | 203 ++++++++ .../metaTileEntity/hatch/MTEHatchObjectHolder.java | 176 +++++++ .../thing/metaTileEntity/hatch/MTEHatchParam.java | 554 +++++++++++++++++++++ .../metaTileEntity/hatch/MTEHatchParamText.java | 291 +++++++++++ .../thing/metaTileEntity/hatch/MTEHatchRack.java | 412 +++++++++++++++ .../metaTileEntity/hatch/MTEHatchUncertainty.java | 467 +++++++++++++++++ .../hatch/MTEHatchWirelessComputationInput.java | 132 +++++ .../hatch/MTEHatchWirelessComputationOutput.java | 60 +++ .../hatch/MTEHatchWirelessDataItemsInput.java | 139 ++++++ .../hatch/MTEHatchWirelessDataItemsOutput.java | 142 ++++++ .../hatch/MTEHatchWirelessMulti.java | 209 ++++++++ 23 files changed, 4647 insertions(+) create mode 100644 src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCapacitor.java create mode 100644 src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCreativeData.java create mode 100644 src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCreativeMaintenance.java create mode 100644 src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCreativeUncertainty.java create mode 100644 src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataConnector.java create mode 100644 src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataInput.java create mode 100644 src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataItemsInput.java create mode 100644 src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataItemsOutput.java create mode 100644 src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataOutput.java create mode 100644 src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDynamoMulti.java create mode 100644 src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDynamoTunnel.java create mode 100644 src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchEnergyMulti.java create mode 100644 src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchEnergyTunnel.java create mode 100644 src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchObjectHolder.java create mode 100644 src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchParam.java create mode 100644 src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchParamText.java create mode 100644 src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchRack.java create mode 100644 src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchUncertainty.java create mode 100644 src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchWirelessComputationInput.java create mode 100644 src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchWirelessComputationOutput.java create mode 100644 src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchWirelessDataItemsInput.java create mode 100644 src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchWirelessDataItemsOutput.java create mode 100644 src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchWirelessMulti.java (limited to 'src/main/java/tectech/thing/metaTileEntity/hatch') diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCapacitor.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCapacitor.java new file mode 100644 index 0000000000..d3cfb21c29 --- /dev/null +++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCapacitor.java @@ -0,0 +1,241 @@ +package tectech.thing.metaTileEntity.hatch; + +import static gregtech.api.enums.GTValues.V; +import static net.minecraft.util.StatCollector.translateToLocal; + +import java.util.HashMap; +import java.util.Map; + +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumChatFormatting; +import net.minecraftforge.common.util.ForgeDirection; + +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.api.screen.UIBuildContext; +import com.gtnewhorizons.modularui.common.internal.wrapper.BaseSlot; +import com.gtnewhorizons.modularui.common.widget.SlotGroup; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.enums.Textures; +import gregtech.api.gui.modularui.GTUIInfos; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.modularui.IAddUIWidgets; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.MTEHatch; +import gregtech.api.objects.GTRenderedTexture; +import tectech.Reference; +import tectech.TecTech; +import tectech.loader.TecTechConfig; +import tectech.util.CommonValues; +import tectech.util.TTUtility; + +/** + * Created by Tec on 03.04.2017. + */ +public class MTEHatchCapacitor extends MTEHatch implements IAddUIWidgets { + + private static Textures.BlockIcons.CustomIcon TM_H; + private static Textures.BlockIcons.CustomIcon TM_H_ACTIVE; + private static final Map componentBinds = new HashMap<>(); + + public MTEHatchCapacitor(int aID, String aName, String aNameRegional, int aTier) { + super( + aID, + aName, + aNameRegional, + aTier, + 16, + new String[] { CommonValues.THETA_MOVEMENT, translateToLocal("gt.blockmachines.hatch.capacitor.desc.0"), + EnumChatFormatting.AQUA + translateToLocal("gt.blockmachines.hatch.capacitor.desc.1") }); + TTUtility.setTier(aTier, this); + } + + public MTEHatchCapacitor(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, 16, aDescription, aTextures); + } + + @Override + public int getInventoryStackLimit() { + return 1; + } + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(IIconRegister aBlockIconRegister) { + super.registerIcons(aBlockIconRegister); + TM_H_ACTIVE = new Textures.BlockIcons.CustomIcon("iconsets/TM_TESLA_CAPS_ACTIVE"); + TM_H = new Textures.BlockIcons.CustomIcon("iconsets/TM_TESLA_CAPS"); + } + + @Override + public ITexture[] getTexturesActive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, new GTRenderedTexture(TM_H_ACTIVE) }; + } + + @Override + public ITexture[] getTexturesInactive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, new GTRenderedTexture(TM_H) }; + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new MTEHatchCapacitor(mName, mTier, mDescriptionArray, mTextures); + } + + @Override + public boolean isSimpleMachine() { + return true; + } + + @Override + public boolean isFacingValid(ForgeDirection facing) { + return true; + } + + @Override + public boolean isAccessAllowed(EntityPlayer aPlayer) { + return true; + } + + @Override + public boolean isValidSlot(int aIndex) { + return true; + } + + @Override + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + return side == aBaseMetaTileEntity.getFrontFacing(); + } + + @Override + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + return side == aBaseMetaTileEntity.getFrontFacing(); + } + + @Override + public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) { + GTUIInfos.openGTTileEntityUI(aBaseMetaTileEntity, aPlayer); + return true; + } + + @Override + public int getSizeInventory() { + return getBaseMetaTileEntity().isActive() ? 0 : mInventory.length; + } + + public long[] getCapacitors() { + long tier = -1; + long tCurrent = 0; + long tEnergyMax = 0; + for (int i = 0; i < mInventory.length; i++) { + if (mInventory[i] == null || mInventory[i].stackSize != 1) { + continue; + } + CapacitorComponent cap = componentBinds.get(TTUtility.getUniqueIdentifier(mInventory[i])); + if (cap != null && cap.tier > tier) { + tier = cap.tier; + } + } + if (tier >= 0) { + for (int i = 0; i < mInventory.length; i++) { + if (mInventory[i] == null || mInventory[i].stackSize != 1) { + continue; + } + CapacitorComponent cap = componentBinds.get(TTUtility.getUniqueIdentifier(mInventory[i])); + if (cap == null) { + continue; + } + if (cap.tier < tier) { + if (getBaseMetaTileEntity().isActive()) { + mInventory[i] = null; + getBaseMetaTileEntity().setOnFire(); + } + } else { + tCurrent += cap.current; + tEnergyMax += cap.energyMax; + } + } + } + return new long[] { tier, tCurrent, tEnergyMax }; + } + + @Override + public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) { + builder.widget( + SlotGroup.ofItemHandler(inventoryHandler, 4) + .startFromSlot(0) + .endAtSlot(15) + .slotCreator(index -> new BaseSlot(inventoryHandler, index) { + + @Override + public int getSlotStackLimit() { + return 1; + } + + @Override + public boolean isEnabled() { + return !getBaseMetaTileEntity().isActive(); + } + }) + .background(getGUITextureSet().getItemSlot()) + .build() + .setPos(52, 7)); + } + + public static void run() { + new MTEHatchCapacitor.CapacitorComponent(Reference.MODID + ":item.tm.teslaCoilCapacitor.0", 0, 1, V[1] * 512); // LV + // Capacitor + new MTEHatchCapacitor.CapacitorComponent(Reference.MODID + ":item.tm.teslaCoilCapacitor.1", 1, 1, V[2] * 512); // MV + // Capacitor + new MTEHatchCapacitor.CapacitorComponent(Reference.MODID + ":item.tm.teslaCoilCapacitor.2", 2, 1, V[3] * 512); // HV + // Capacitor + new MTEHatchCapacitor.CapacitorComponent(Reference.MODID + ":item.tm.teslaCoilCapacitor.3", 3, 1, V[4] * 512); // EV + // Capacitor + new MTEHatchCapacitor.CapacitorComponent(Reference.MODID + ":item.tm.teslaCoilCapacitor.4", 4, 1, V[5] * 512); // IV + // Capacitor + new MTEHatchCapacitor.CapacitorComponent(Reference.MODID + ":item.tm.teslaCoilCapacitor.5", 5, 1, V[6] * 512); // LuV + // Capacitor + new MTEHatchCapacitor.CapacitorComponent(Reference.MODID + ":item.tm.teslaCoilCapacitor.6", 6, 1, V[7] * 512); // ZPM + // Capacitor + } + + public static class CapacitorComponent implements Comparable { + + private final String unlocalizedName; + private final long tier, current, energyMax; + + CapacitorComponent(ItemStack is, long tier, long current, long energyMax) { + this(TTUtility.getUniqueIdentifier(is), tier, current, energyMax); + } + + CapacitorComponent(String is, long tier, long current, long energyMax) { + unlocalizedName = is; + this.tier = tier; + this.current = current; + this.energyMax = energyMax; + componentBinds.put(unlocalizedName, this); + if (TecTechConfig.DEBUG_MODE) { + TecTech.LOGGER.info("Tesla Capacitor registered: " + unlocalizedName); + } + } + + @Override + public int compareTo(CapacitorComponent o) { + return unlocalizedName.compareTo(o.unlocalizedName); + } + + @Override + public boolean equals(Object obj) { + if (obj instanceof CapacitorComponent) { + return compareTo((CapacitorComponent) obj) == 0; + } + return false; + } + } +} diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCreativeData.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCreativeData.java new file mode 100644 index 0000000000..ed162e59e6 --- /dev/null +++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCreativeData.java @@ -0,0 +1,129 @@ +package tectech.thing.metaTileEntity.hatch; + +import static net.minecraft.util.StatCollector.translateToLocal; + +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import tectech.mechanics.dataTransport.QuantumDataPacket; +import tectech.mechanics.pipe.IConnectsToDataPipe; +import tectech.thing.metaTileEntity.pipe.MTEPipeData; +import tectech.util.CommonValues; +import tectech.util.TTUtility; + +/** + * Created by danie_000 on 27.10.2016. + */ +public class MTEHatchCreativeData extends MTEHatchDataConnector { + + public MTEHatchCreativeData(int aID, String aName, String aNameRegional, int aTier) { + super( + aID, + aName, + aNameRegional, + aTier, + new String[] { CommonValues.TEC_MARK_EM, translateToLocal("gt.blockmachines.debug.tt.data.desc.0"), + translateToLocal("gt.blockmachines.debug.tt.data.desc.1"), + EnumChatFormatting.AQUA + translateToLocal("gt.blockmachines.debug.tt.data.desc.2") }); + TTUtility.setTier(aTier, this); + } + + public MTEHatchCreativeData(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, aDescription, aTextures); + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new MTEHatchCreativeData(mName, mTier, mDescriptionArray, mTextures); + } + + @Override + public boolean isOutputFacing(ForgeDirection side) { + return side == getBaseMetaTileEntity().getFrontFacing(); + } + + @Override + public boolean isInputFacing(ForgeDirection side) { + return false; + } + + @Override + public boolean isSimpleMachine() { + return true; + } + + @Override + public boolean isDataInputFacing(ForgeDirection side) { + return isInputFacing(side); + } + + @Override + protected QuantumDataPacket loadPacketFromNBT(NBTTagCompound nbt) { + return new QuantumDataPacket(nbt); + } + + @Override + public boolean canConnectData(ForgeDirection side) { + return isOutputFacing(side); + } + + @Override + public void moveAround(IGregTechTileEntity aBaseMetaTileEntity) { + IConnectsToDataPipe current = this, source = this, next; + int range = 0; + while ((next = current.getNext(source)) != null && range++ < 1000) { + if (next instanceof MTEHatchDataInput) { + ((MTEHatchDataInput) next).setContents(q); + break; + } + source = current; + current = next; + } + q = null; + } + + @Override + public IConnectsToDataPipe getNext(IConnectsToDataPipe source /* ==this */) { + IGregTechTileEntity base = getBaseMetaTileEntity(); + byte color = base.getColorization(); + if (color < 0) { + return null; + } + IGregTechTileEntity next = base.getIGregTechTileEntityAtSide(base.getFrontFacing()); + if (next == null) { + return null; + } + IMetaTileEntity meta = next.getMetaTileEntity(); + if (meta instanceof MTEPipeData) { + ((MTEPipeData) meta).markUsed(); + return (IConnectsToDataPipe) meta; + } else if (meta instanceof MTEHatchDataInput && ((MTEHatchDataInput) meta).getColorization() == color + && ((MTEHatchDataInput) meta).canConnectData( + base.getFrontFacing() + .getOpposite())) { + return (IConnectsToDataPipe) meta; + } + return null; + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if (aBaseMetaTileEntity.isServerSide()) { + if (CommonValues.MOVE_AT == aTick % 20) { + if (aBaseMetaTileEntity.isAllowedToWork()) { + getBaseMetaTileEntity().setActive(true); + if (q == null) q = new QuantumDataPacket(0xFFFFFFFFL); + moveAround(aBaseMetaTileEntity); + } else { + q = null; + getBaseMetaTileEntity().setActive(false); + } + } + } + } +} diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCreativeMaintenance.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCreativeMaintenance.java new file mode 100644 index 0000000000..28d631e606 --- /dev/null +++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCreativeMaintenance.java @@ -0,0 +1,90 @@ +package tectech.thing.metaTileEntity.hatch; + +import static net.minecraft.util.StatCollector.translateToLocal; + +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumChatFormatting; +import net.minecraftforge.common.util.ForgeDirection; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.MTEHatchMaintenance; +import gregtech.api.objects.GTRenderedTexture; +import tectech.util.CommonValues; +import tectech.util.TTUtility; + +public class MTEHatchCreativeMaintenance extends MTEHatchMaintenance { + + private static Textures.BlockIcons.CustomIcon face; + + public MTEHatchCreativeMaintenance(int aID, String aName, String aNameRegional, int aTier) { + super(aID, aName, aNameRegional, aTier); + TTUtility.setTier(aTier, this); + } + + public MTEHatchCreativeMaintenance(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, aDescription, aTextures, false); + } + + @Override + public String[] getDescription() { + return new String[] { CommonValues.THETA_MOVEMENT, + translateToLocal("gt.blockmachines.debug.tt.maintenance.desc.0"), // For automatically maintaining + // Multiblocks + translateToLocal("gt.blockmachines.debug.tt.maintenance.desc.1"), // Does fix everything but itself. + EnumChatFormatting.AQUA + translateToLocal("gt.blockmachines.debug.tt.maintenance.desc.2") // Fixing is + // for plebs! + }; + } + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(IIconRegister aBlockIconRegister) { + super.registerIcons(aBlockIconRegister); + face = new Textures.BlockIcons.CustomIcon("iconsets/OVERLAY_FULLAUTOMAINTENANCE"); + } + + @Override + public ITexture[] getTexturesActive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, new GTRenderedTexture(face) }; + } + + @Override + public ITexture[] getTexturesInactive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, new GTRenderedTexture(face) }; + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new MTEHatchCreativeMaintenance(this.mName, this.mTier, this.mDescriptionArray, this.mTextures); + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + this.mWrench = this.mScrewdriver = this.mSoftHammer = this.mHardHammer = this.mCrowbar = this.mSolderingTool = true; + } + + @Override + public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, ForgeDirection side, + float aX, float aY, float aZ) { + return false; + } + + @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; + } +} diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCreativeUncertainty.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCreativeUncertainty.java new file mode 100644 index 0000000000..953506e4d9 --- /dev/null +++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchCreativeUncertainty.java @@ -0,0 +1,56 @@ +package tectech.thing.metaTileEntity.hatch; + +import static net.minecraft.util.StatCollector.translateToLocal; + +import net.minecraft.util.EnumChatFormatting; + +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import tectech.util.CommonValues; + +public class MTEHatchCreativeUncertainty extends MTEHatchUncertainty { + + public MTEHatchCreativeUncertainty(int aID, String aName, String aNameRegional, int aTier) { + super(aID, aName, aNameRegional, aTier); + } + + public MTEHatchCreativeUncertainty(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, aDescription, aTextures); + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity iGregTechTileEntity) { + return new MTEHatchCreativeUncertainty(mName, mTier, mDescriptionArray, mTextures); + } + + @Override + public String[] getDescription() { + return new String[] { CommonValues.TEC_MARK_EM, translateToLocal("gt.blockmachines.debug.tt.certain.desc.0"), // Feeling + // certain, + // for + // sure + EnumChatFormatting.AQUA.toString() + EnumChatFormatting.BOLD + + translateToLocal("gt.blockmachines.debug.tt.certain.desc.1") // Schrödinger's cat escaped the + // box + }; + } + + @Override + public void regenerate() { + // no-op + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if (aBaseMetaTileEntity.isServerSide() && (aTick % 100) == 0) { + if (mode == 0) { + aBaseMetaTileEntity.setActive(false); + status = -128; + } else { + aBaseMetaTileEntity.setActive(true); + compute(); + } + } + } +} diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataConnector.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataConnector.java new file mode 100644 index 0000000000..484fcdaff1 --- /dev/null +++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataConnector.java @@ -0,0 +1,198 @@ +package tectech.thing.metaTileEntity.hatch; + +import static gregtech.api.enums.Dyes.MACHINE_METAL; +import static net.minecraft.util.StatCollector.translateToLocalFormatted; + +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; +import net.minecraft.util.EnumChatFormatting; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.FluidStack; + +import org.apache.commons.lang3.reflect.FieldUtils; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.enums.Dyes; +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.implementations.MTEHatch; +import gregtech.api.objects.GTRenderedTexture; +import tectech.mechanics.dataTransport.DataPacket; +import tectech.mechanics.pipe.IConnectsToDataPipe; +import tectech.util.CommonValues; +import tectech.util.TTUtility; + +/** + * Created by danie_000 on 11.12.2016. + */ +public abstract class MTEHatchDataConnector extends MTEHatch implements IConnectsToDataPipe { + + public static Textures.BlockIcons.CustomIcon EM_D_SIDES; + public static Textures.BlockIcons.CustomIcon EM_D_ACTIVE; + public static Textures.BlockIcons.CustomIcon EM_D_CONN; + + private String clientLocale = "en_US"; + + public T q; + + public short id = -1; + + protected MTEHatchDataConnector(int aID, String aName, String aNameRegional, int aTier, String[] descr) { + super(aID, aName, aNameRegional, aTier, 0, descr); + TTUtility.setTier(aTier, this); + } + + protected MTEHatchDataConnector(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, 0, aDescription, aTextures); + } + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(IIconRegister aBlockIconRegister) { + super.registerIcons(aBlockIconRegister); + EM_D_ACTIVE = new Textures.BlockIcons.CustomIcon("iconsets/OVERLAY_EM_D_ACTIVE"); + EM_D_SIDES = new Textures.BlockIcons.CustomIcon("iconsets/OVERLAY_EM_D_SIDES"); + EM_D_CONN = new Textures.BlockIcons.CustomIcon("iconsets/EM_DATA_CONN"); + } + + @Override + public ITexture[] getTexturesActive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, + new GTRenderedTexture( + EM_D_ACTIVE, + Dyes.getModulation(getBaseMetaTileEntity().getColorization(), MACHINE_METAL.getRGBA())), + new GTRenderedTexture(EM_D_CONN) }; + } + + @Override + public ITexture[] getTexturesInactive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, + new GTRenderedTexture( + EM_D_SIDES, + Dyes.getModulation(getBaseMetaTileEntity().getColorization(), MACHINE_METAL.getRGBA())), + new GTRenderedTexture(EM_D_CONN) }; + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + super.saveNBTData(aNBT); + aNBT.setShort("eID", id); + if (q != null) { + aNBT.setTag("eDATA", q.toNbt()); + } + } + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + super.loadNBTData(aNBT); + id = aNBT.getShort("eID"); + if (aNBT.hasKey("eDATA")) { + q = loadPacketFromNBT(aNBT.getCompoundTag("eDATA")); + } + } + + protected abstract T loadPacketFromNBT(NBTTagCompound nbt); + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if (aBaseMetaTileEntity.isServerSide()) { + if (CommonValues.MOVE_AT == aTick % 20) { + if (q == null) { + getBaseMetaTileEntity().setActive(false); + } else { + getBaseMetaTileEntity().setActive(true); + moveAround(aBaseMetaTileEntity); + } + } + } + } + + public abstract void moveAround(IGregTechTileEntity aBaseMetaTileEntity); + + @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 boolean isFacingValid(ForgeDirection facing) { + return true; + } + + @Override + public boolean isAccessAllowed(EntityPlayer aPlayer) { + return true; + } + + @Override + public boolean isLiquidInput(ForgeDirection side) { + return false; + } + + @Override + public boolean isFluidInputAllowed(FluidStack aFluid) { + return false; + } + + @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 isValidSlot(int aIndex) { + return false; + } + + @Override + public boolean isGivingInformation() { + return true; + } + + @Override + public String[] getInfoData() { + if (id > 0) { + return new String[] { + translateToLocalFormatted("tt.keyword.ID", clientLocale) + ": " + EnumChatFormatting.AQUA + id, + translateToLocalFormatted("tt.keyword.Content", clientLocale) + ": " + + EnumChatFormatting.AQUA + + (q != null ? q.getContentString() : 0), + translateToLocalFormatted("tt.keyword.PacketHistory", clientLocale) + ": " + + EnumChatFormatting.RED + + (q != null ? q.getTraceSize() : 0), }; + } + return new String[] { + translateToLocalFormatted("tt.keyword.Content", clientLocale) + ": " + + EnumChatFormatting.AQUA + + (q != null ? q.getContentString() : 0), + translateToLocalFormatted("tt.keyword.PacketHistory", clientLocale) + ": " + + EnumChatFormatting.RED + + (q != null ? q.getTraceSize() : 0), }; + } + + @Override + public byte getColorization() { + return getBaseMetaTileEntity().getColorization(); + } +} diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataInput.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataInput.java new file mode 100644 index 0000000000..57ecd948b5 --- /dev/null +++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataInput.java @@ -0,0 +1,101 @@ +package tectech.thing.metaTileEntity.hatch; + +import static net.minecraft.util.StatCollector.translateToLocal; + +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import tectech.mechanics.dataTransport.QuantumDataPacket; +import tectech.mechanics.pipe.IConnectsToDataPipe; +import tectech.util.CommonValues; +import tectech.util.TTUtility; + +/** + * Created by danie_000 on 27.10.2016. + */ +public class MTEHatchDataInput extends MTEHatchDataConnector { + + private boolean delDelay = true; + + public MTEHatchDataInput(int aID, String aName, String aNameRegional, int aTier) { + super( + aID, + aName, + aNameRegional, + aTier, + new String[] { CommonValues.TEC_MARK_EM, translateToLocal("gt.blockmachines.hatch.datain.desc.0"), + translateToLocal("gt.blockmachines.hatch.datain.desc.1"), + EnumChatFormatting.AQUA + translateToLocal("gt.blockmachines.hatch.datain.desc.2") }); + TTUtility.setTier(aTier, this); + } + + public MTEHatchDataInput(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, aDescription, aTextures); + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new MTEHatchDataInput(mName, mTier, mDescriptionArray, mTextures); + } + + @Override + protected QuantumDataPacket loadPacketFromNBT(NBTTagCompound nbt) { + return new QuantumDataPacket(nbt); + } + + @Override + public boolean isInputFacing(ForgeDirection side) { + return side == getBaseMetaTileEntity().getFrontFacing(); + } + + @Override + public boolean isDataInputFacing(ForgeDirection side) { + return isInputFacing(side); + } + + @Override + public boolean isOutputFacing(ForgeDirection side) { + return false; + } + + @Override + public boolean isSimpleMachine() { + return true; + } + + @Override + public boolean canConnectData(ForgeDirection side) { + return isInputFacing(side); + } + + @Override + public IConnectsToDataPipe getNext(IConnectsToDataPipe source) { + return null; + } + + public void setContents(QuantumDataPacket qIn) { + if (qIn == null) { + this.q = null; + } else { + if (qIn.getContent() > 0) { + this.q = qIn; + delDelay = true; + } else { + this.q = null; + } + } + } + + @Override + public void moveAround(IGregTechTileEntity aBaseMetaTileEntity) { + if (delDelay) { + delDelay = false; + } else { + setContents(null); + } + } +} diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataItemsInput.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataItemsInput.java new file mode 100644 index 0000000000..533c9cb695 --- /dev/null +++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataItemsInput.java @@ -0,0 +1,255 @@ +package tectech.thing.metaTileEntity.hatch; + +import static gregtech.api.enums.Dyes.MACHINE_METAL; +import static net.minecraft.util.StatCollector.translateToLocal; +import static net.minecraft.util.StatCollector.translateToLocalFormatted; +import static tectech.thing.metaTileEntity.hatch.MTEHatchDataConnector.EM_D_ACTIVE; +import static tectech.thing.metaTileEntity.hatch.MTEHatchDataConnector.EM_D_CONN; +import static tectech.thing.metaTileEntity.hatch.MTEHatchDataConnector.EM_D_SIDES; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +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.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraftforge.common.util.ForgeDirection; + +import org.apache.commons.lang3.reflect.FieldUtils; + +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.MTEHatchDataAccess; +import gregtech.api.objects.GTRenderedTexture; +import tectech.mechanics.dataTransport.InventoryDataPacket; +import tectech.mechanics.pipe.IConnectsToDataPipe; +import tectech.recipe.TTRecipeAdder; +import tectech.util.CommonValues; +import tectech.util.TTUtility; + +public class MTEHatchDataItemsInput extends MTEHatchDataAccess implements IConnectsToDataPipe { + + public boolean delDelay = true; + private ItemStack[] stacks; + + private String clientLocale = "en_US"; + + public MTEHatchDataItemsInput(int aID, String aName, String aNameRegional, int aTier) { + super(aID, aName, aNameRegional, aTier); + TTUtility.setTier(aTier, this); + } + + public MTEHatchDataItemsInput(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, aDescription, aTextures); + } + + @Override + public ITexture[] getTexturesActive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, + new GTRenderedTexture( + EM_D_ACTIVE, + Dyes.getModulation(getBaseMetaTileEntity().getColorization(), MACHINE_METAL.getRGBA())), + new GTRenderedTexture(EM_D_CONN) }; + } + + @Override + public ITexture[] getTexturesInactive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, + new GTRenderedTexture( + EM_D_SIDES, + Dyes.getModulation(getBaseMetaTileEntity().getColorization(), MACHINE_METAL.getRGBA())), + new GTRenderedTexture(EM_D_CONN) }; + } + + @Override + public boolean isSimpleMachine() { + return true; + } + + @Override + public boolean isFacingValid(ForgeDirection facing) { + return true; + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new MTEHatchDataItemsInput(this.mName, this.mTier, mDescriptionArray, this.mTextures); + } + + @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 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 false; + } + + @Override + public boolean isInputFacing(ForgeDirection side) { + return side == getBaseMetaTileEntity().getFrontFacing(); + } + + @Override + public boolean isDataInputFacing(ForgeDirection side) { + return isInputFacing(side); + } + + @Override + public boolean canConnectData(ForgeDirection side) { + return isInputFacing(side); + } + + @Override + public IConnectsToDataPipe getNext(IConnectsToDataPipe source) { + return null; + } + + public void setContents(InventoryDataPacket iIn) { + if (iIn == null) { + stacks = null; + } else { + if (iIn.getContent().length > 0) { + stacks = iIn.getContent(); + delDelay = true; + } else { + stacks = null; + } + } + } + + @Override + public void onRemoval() { + stacks = null; + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + super.saveNBTData(aNBT); + NBTTagCompound stacksTag = new NBTTagCompound(); + if (stacks != null) { + stacksTag.setInteger("count", stacks.length); + for (int i = 0; i < stacks.length; i++) { + stacksTag.setTag(Integer.toString(i), stacks[i].writeToNBT(new NBTTagCompound())); + } + } + aNBT.setTag("data_stacks", stacksTag); + } + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + super.loadNBTData(aNBT); + NBTTagCompound stacksTag = aNBT.getCompoundTag("data_stacks"); + int count = stacksTag.getInteger("count"); + if (count > 0) { + ArrayList stacks = new ArrayList<>(); + for (int i = 0; i < count; i++) { + ItemStack stack = ItemStack.loadItemStackFromNBT(stacksTag.getCompoundTag(Integer.toString(i))); + if (stack != null) { + stacks.add(stack); + } + } + if (stacks.size() > 0) { + this.stacks = stacks.toArray(TTRecipeAdder.nullItem); + } + } + } + + @Override + public int getSizeInventory() { + return stacks != null ? stacks.length : 0; + } + + @Override + public ItemStack getStackInSlot(int aIndex) { + return stacks != null && aIndex < stacks.length ? stacks[aIndex] : null; + } + + @Override + public List getInventoryItems(Predicate filter) { + if (stacks == null) return Collections.emptyList(); + return Arrays.stream(stacks) + .filter(stack -> stack != null && filter.test(stack)) + .collect(Collectors.toList()); + } + + @Override + public boolean shouldDropItemAt(int index) { + return false; + } + + @Override + public void onPreTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + super.onPreTick(aBaseMetaTileEntity, aTick); + if (CommonValues.MOVE_AT == aTick % 20) { + if (stacks == null) { + getBaseMetaTileEntity().setActive(false); + } else { + getBaseMetaTileEntity().setActive(true); + if (delDelay) { + delDelay = false; + } else { + setContents(null); + } + } + } + } + + @Override + public String[] getDescription() { + return new String[] { CommonValues.TEC_MARK_EM, translateToLocal("gt.blockmachines.hatch.datainass.desc.0"), + translateToLocal("gt.blockmachines.hatch.datainass.desc.1"), + EnumChatFormatting.AQUA + translateToLocal("gt.blockmachines.hatch.datainass.desc.2") }; + } + + @Override + public boolean isGivingInformation() { + return true; + } + + @Override + public String[] getInfoData() { + return new String[] { translateToLocalFormatted("tt.keyphrase.Content_Stack_Count", clientLocale) + ": " + + (stacks == null ? 0 : stacks.length) }; + } + + @Override + public byte getColorization() { + return getBaseMetaTileEntity().getColorization(); + } +} diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataItemsOutput.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataItemsOutput.java new file mode 100644 index 0000000000..8a2c005fec --- /dev/null +++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataItemsOutput.java @@ -0,0 +1,133 @@ +package tectech.thing.metaTileEntity.hatch; + +import static net.minecraft.util.StatCollector.translateToLocal; + +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import tectech.mechanics.dataTransport.InventoryDataPacket; +import tectech.mechanics.pipe.IConnectsToDataPipe; +import tectech.thing.metaTileEntity.pipe.MTEPipeData; +import tectech.util.CommonValues; +import tectech.util.TTUtility; + +public class MTEHatchDataItemsOutput extends MTEHatchDataConnector { + + public MTEHatchDataItemsOutput(int aID, String aName, String aNameRegional, int aTier) { + super( + aID, + aName, + aNameRegional, + aTier, + new String[] { CommonValues.TEC_MARK_EM, translateToLocal("gt.blockmachines.hatch.dataoutass.desc.0"), + translateToLocal("gt.blockmachines.hatch.dataoutass.desc.1"), + EnumChatFormatting.AQUA + translateToLocal("gt.blockmachines.hatch.dataoutass.desc.2") }); + TTUtility.setTier(aTier, this); + } + + public MTEHatchDataItemsOutput(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, aDescription, aTextures); + } + + @Override + public boolean isSimpleMachine() { + return true; + } + + @Override + public boolean isFacingValid(ForgeDirection facing) { + return true; + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new MTEHatchDataItemsOutput(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 + protected InventoryDataPacket loadPacketFromNBT(NBTTagCompound nbt) { + return new InventoryDataPacket(nbt); + } + + @Override + public boolean isDataInputFacing(ForgeDirection side) { + return isInputFacing(side); + } + + @Override + public boolean canConnectData(ForgeDirection side) { + return isOutputFacing(side); + } + + @Override + public void moveAround(IGregTechTileEntity aBaseMetaTileEntity) { + IConnectsToDataPipe current = this, source = this, next; + int range = 0; + while ((next = current.getNext(source)) != null && range++ < 1000) { + if (next instanceof MTEHatchDataItemsInput) { + ((MTEHatchDataItemsInput) next).setContents(q); + break; + } + source = current; + current = next; + } + q = null; + } + + @Override + public IConnectsToDataPipe getNext(IConnectsToDataPipe source /* ==this */) { + IGregTechTileEntity base = getBaseMetaTileEntity(); + byte color = base.getColorization(); + if (color < 0) { + return null; + } + IGregTechTileEntity next = base.getIGregTechTileEntityAtSide(base.getFrontFacing()); + if (next == null) { + return null; + } + IMetaTileEntity meta = next.getMetaTileEntity(); + if (meta instanceof MTEPipeData) { + ((MTEPipeData) meta).markUsed(); + return (IConnectsToDataPipe) meta; + } else if (meta instanceof MTEHatchDataItemsInput && ((MTEHatchDataItemsInput) meta).getColorization() == color + && ((MTEHatchDataItemsInput) meta).canConnectData( + base.getFrontFacing() + .getOpposite())) { + return (IConnectsToDataPipe) meta; + } + return null; + } +} diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataOutput.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataOutput.java new file mode 100644 index 0000000000..094423cb0a --- /dev/null +++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDataOutput.java @@ -0,0 +1,113 @@ +package tectech.thing.metaTileEntity.hatch; + +import static net.minecraft.util.StatCollector.translateToLocal; + +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import tectech.mechanics.dataTransport.QuantumDataPacket; +import tectech.mechanics.pipe.IConnectsToDataPipe; +import tectech.thing.metaTileEntity.pipe.MTEPipeData; +import tectech.util.CommonValues; +import tectech.util.TTUtility; + +/** + * Created by danie_000 on 27.10.2016. + */ +public class MTEHatchDataOutput extends MTEHatchDataConnector { + + public MTEHatchDataOutput(int aID, String aName, String aNameRegional, int aTier) { + super( + aID, + aName, + aNameRegional, + aTier, + new String[] { CommonValues.TEC_MARK_EM, translateToLocal("gt.blockmachines.hatch.dataout.desc.0"), + translateToLocal("gt.blockmachines.hatch.dataout.desc.1"), + EnumChatFormatting.AQUA + translateToLocal("gt.blockmachines.hatch.dataout.desc.2") }); + TTUtility.setTier(aTier, this); + } + + public MTEHatchDataOutput(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, aDescription, aTextures); + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new MTEHatchDataOutput(mName, mTier, mDescriptionArray, mTextures); + } + + @Override + public boolean isOutputFacing(ForgeDirection side) { + return side == getBaseMetaTileEntity().getFrontFacing(); + } + + @Override + public boolean isInputFacing(ForgeDirection side) { + return false; + } + + @Override + public boolean isSimpleMachine() { + return true; + } + + @Override + public boolean isDataInputFacing(ForgeDirection side) { + return isInputFacing(side); + } + + @Override + protected QuantumDataPacket loadPacketFromNBT(NBTTagCompound nbt) { + return new QuantumDataPacket(nbt); + } + + @Override + public boolean canConnectData(ForgeDirection side) { + return isOutputFacing(side); + } + + @Override + public void moveAround(IGregTechTileEntity aBaseMetaTileEntity) { + IConnectsToDataPipe current = this, source = this, next; + int range = 0; + while ((next = current.getNext(source)) != null && range++ < 1000) { + if (next instanceof MTEHatchDataInput) { + ((MTEHatchDataInput) next).setContents(q); + break; + } + source = current; + current = next; + } + q = null; + } + + @Override + public IConnectsToDataPipe getNext(IConnectsToDataPipe source /* ==this */) { + IGregTechTileEntity base = getBaseMetaTileEntity(); + byte color = base.getColorization(); + if (color < 0) { + return null; + } + IGregTechTileEntity next = base.getIGregTechTileEntityAtSide(base.getFrontFacing()); + if (next == null) { + return null; + } + IMetaTileEntity meta = next.getMetaTileEntity(); + if (meta instanceof MTEPipeData) { + ((MTEPipeData) meta).markUsed(); + return (IConnectsToDataPipe) meta; + } else if (meta instanceof MTEHatchDataInput && ((MTEHatchDataInput) meta).getColorization() == color + && ((MTEHatchDataInput) meta).canConnectData( + base.getFrontFacing() + .getOpposite())) { + return (IConnectsToDataPipe) meta; + } + return null; + } +} diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDynamoMulti.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDynamoMulti.java new file mode 100644 index 0000000000..e5f457ccc2 --- /dev/null +++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDynamoMulti.java @@ -0,0 +1,127 @@ +package tectech.thing.metaTileEntity.hatch; + +import static gregtech.api.enums.GTValues.V; +import static net.minecraft.util.StatCollector.translateToLocal; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.MTEHatch; +import tectech.thing.metaTileEntity.Textures; +import tectech.util.CommonValues; +import tectech.util.TTUtility; + +/** + * Created by danie_000 on 16.12.2016. + */ +public class MTEHatchDynamoMulti extends MTEHatch { + + public final int maxAmperes; + public int Amperes; + + public MTEHatchDynamoMulti(int aID, String aName, String aNameRegional, int aTier, int aAmp) { + super( + aID, + aName, + aNameRegional, + aTier, + 0, + new String[] { CommonValues.TEC_MARK_GENERAL, + translateToLocal("gt.blockmachines.hatch.dynamomulti.desc.0") }); // Multiple Ampere Energy + // Extractor for Multiblocks + Amperes = maxAmperes = aAmp; + TTUtility.setTier(aTier, this); + } + + public MTEHatchDynamoMulti(String aName, int aTier, int aAmp, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, 0, aDescription, aTextures); + Amperes = maxAmperes = aAmp; + } + + public MTEHatchDynamoMulti(int aID, String aName, String aNameRegional, int aTier, int i, String[] description, + int aAmp) { + super(aID, aName, aNameRegional, aTier, 0, description); + Amperes = maxAmperes = aAmp; + } + + @Override + public ITexture[] getTexturesActive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, Textures.OVERLAYS_ENERGY_IN_POWER_TT[mTier] }; + } + + @Override + public ITexture[] getTexturesInactive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, Textures.OVERLAYS_ENERGY_IN_POWER_TT[mTier] }; + } + + @Override + public boolean isSimpleMachine() { + return true; + } + + @Override + public boolean isFacingValid(ForgeDirection facing) { + return true; + } + + @Override + public boolean isAccessAllowed(EntityPlayer aPlayer) { + return true; + } + + @Override + public boolean isEnetOutput() { + return true; + } + + @Override + public boolean isOutputFacing(ForgeDirection side) { + return side == getBaseMetaTileEntity().getFrontFacing(); + } + + @Override + public boolean isValidSlot(int aIndex) { + return false; + } + + @Override + public long getMinimumStoredEU() { + return 128L * Amperes; + } + + @Override + public long maxEUOutput() { + return V[mTier]; + } + + @Override + public long maxEUStore() { + return 512L + V[mTier] * 4L * Amperes; + } + + @Override + public long maxAmperesOut() { + return Amperes; + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new MTEHatchDynamoMulti(mName, mTier, Amperes, mDescriptionArray, 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; + } +} diff --git a/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDynamoTunnel.java b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDynamoTunnel.java new file mode 100644 index 0000000000..2a72fb31f2 --- /dev/null +++ b/src/main/java/tectech/thing/metaTileEntity/hatch/MTEHatchDynamoTunnel.java @@ -0,0 +1,286 @@ +package tectech.thing.metaTileEntity.hatch; + +import static gregtech.api.enums.GTValues.V; +import static net.minecraft.util.StatCollector.translateToLocal; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraftforge.common.util.ForgeDirection; + +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.TextWidget; +import com.gtnewhorizons.modularui.common.widget.textfield.NumericWidget; + +import gregtech.api.gui.modularui.GTUIInfos; +import gregtech.api.gui.modularui.GTUITextures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.logic.PowerLogic; +import gregtech.api.logic.interfaces.PowerLogicHost; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.util.GTUtility; +import tectech.mechanics.pipe.IConnectsToEnergyTunnel; +import tectech.thing.metaTileEntity.Textures; +import tectech.thing.metaTileEntity.pipe.MTEPipeEnergy; +import tectech.thing.metaTileEntity.pipe.MTEPipeEnergyMirror; +import tectech.util.CommonValues; +import tectech.util.TTUtility; + +/** + * Created by danie_000 on 16.12.2016. + */ +public class MTEHatchDynamoTunnel extends MTEHatchDynamoMulti implements IConnectsToEnergyTunnel { + + public MTEHatchDynamoTunnel(int ID, String unlocalisedName, String localisedName, int tier, int amps) { + super( + ID, + unlocalisedName, + localisedName, + tier, + 0, + new String[] { CommonValues.TEC_MARK_GENERAL, + translateToLocal("gt.blockmachines.hatch.dynamotunnel.desc.0"), + translateToLocal("gt.blockmachines.hatch.dynamotunnel.desc.1") + ": " + + EnumChatFormatting.YELLOW + + GTUtility.formatNumbers(amps * V[tier]) + + EnumChatFormatting.RESET + + " EU/t" }, + amps); + + TTUtility.setTier(tier, this); + } + + public MTEHatchDynamoTunnel(String aName, int aTier, int aAmp, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, aAmp, aDescription, aTextures); + } + + @Override + public ITexture[] getTexturesActive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, Textures.OVERLAYS_ENERGY_OUT_LASER_TT[mTier] }; + } + + @Override + public ITexture[] getTexturesInactive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, Textures.OVERLAYS_ENERGY_OUT_LASER_TT[mTier] }; + } + + @Override + public boolean isSimpleMachine() { + return true; + } + + @Override + public boolean isFacingValid(ForgeDirection facing) { + return true; + } + + @Override + public boolean isAccessAllowed(EntityPlayer aPlayer) { + return true; + } + + @Override + public boolean isOutputFacing(ForgeDirection side) { + return side == getBaseMetaTileEntity().getFrontFacing(); + } + + @Override + public boolean isValidSlot(int aIndex) { + return false; + } + + @Override + public long getMinimumStoredEU() { + return V[mTier]; + } + + @Override + public long maxEUOutput() { + return V[mTier]; + } + + @Override + public long maxEUStore() { + return V[mTier] * 24L * Amperes; + } + + @Override + public boolean isEnetOutput() { + return false; + } + + @Override + public boolean isEnetInput() { + return false; + } + + @Override + public ConnectionType getConnectionType() { + return ConnectionType.LASER; + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new MTEHatchDynamoTunnel(mName, mTier, Amperes, mDescriptionArray, 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 void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if (aBaseMetaTileEntity.isServerSide()) { + byte Tick = (byte) (aTick % 20); + if (CommonValues.TRANSFER_AT == Tick) { + if (aBaseMetaTileEntity.getStoredEU() > 0) { + setEUVar(aBaseMetaTileEntity.getStoredEU() - Amperes); + if (aBaseMetaTileEntity.getStoredEU() < 0) { + setEUVar(0); + } +