From 51cb986f905623eadb04b5e30bcdab503817b1a7 Mon Sep 17 00:00:00 2001 From: reobf <2215595288@qq.com> Date: Tue, 21 Jan 2025 18:52:21 +0800 Subject: [PATCH] update --- .../proghatches/ae/BlockRequestTunnel.java | 151 ++++ .../reobf/proghatches/ae/EmitterPattern.java | 104 +++ .../proghatches/ae/ItemEmitterPattern.java | 347 +++++++ .../proghatches/ae/PartAmountMaintainer.java | 4 +- .../proghatches/ae/TileRequestTunnel.java | 855 ++++++++++++++++++ .../item/ItemProgrammingToolkit.java | 16 +- .../reobf/proghatches/main/CommonProxy.java | 15 +- .../java/reobf/proghatches/main/MyMod.java | 3 + .../proghatches/main/mixin/MixinCallback.java | 12 + .../mixin/mixins/MixinCanCraftExempt.java | 5 +- .../mixin/mixins/part2/MixinMultiPattern.java | 24 +- .../main/registration/PHRecipes.java | 50 + src/main/java/reobf/proghatches/oc/Arch.java | 2 +- .../java/reobf/proghatches/oc/ItemCPU.java | 6 +- .../assets/proghatches/lang/en_US.lang | 10 + .../assets/proghatches/lang/zh_CN.lang | 10 + .../proghatches/textures/blocks/tunnel.png | Bin 0 -> 133 bytes .../proghatches/textures/blocks/tunnel_1.png | Bin 0 -> 251 bytes .../proghatches/textures/blocks/tunnel_2.png | Bin 0 -> 248 bytes .../proghatches/textures/blocks/tunnel_3.png | Bin 0 -> 248 bytes .../textures/blocks/tunnel_back.png | Bin 0 -> 277 bytes .../textures/blocks/tunnel_front.png | Bin 0 -> 211 bytes .../textures/items/emitterpattern.png | Bin 0 -> 383 bytes 23 files changed, 1601 insertions(+), 13 deletions(-) create mode 100644 src/main/java/reobf/proghatches/ae/BlockRequestTunnel.java create mode 100644 src/main/java/reobf/proghatches/ae/EmitterPattern.java create mode 100644 src/main/java/reobf/proghatches/ae/ItemEmitterPattern.java create mode 100644 src/main/java/reobf/proghatches/ae/TileRequestTunnel.java create mode 100644 src/main/resources/assets/proghatches/textures/blocks/tunnel.png create mode 100644 src/main/resources/assets/proghatches/textures/blocks/tunnel_1.png create mode 100644 src/main/resources/assets/proghatches/textures/blocks/tunnel_2.png create mode 100644 src/main/resources/assets/proghatches/textures/blocks/tunnel_3.png create mode 100644 src/main/resources/assets/proghatches/textures/blocks/tunnel_back.png create mode 100644 src/main/resources/assets/proghatches/textures/blocks/tunnel_front.png create mode 100644 src/main/resources/assets/proghatches/textures/items/emitterpattern.png diff --git a/src/main/java/reobf/proghatches/ae/BlockRequestTunnel.java b/src/main/java/reobf/proghatches/ae/BlockRequestTunnel.java new file mode 100644 index 0000000..dc5294a --- /dev/null +++ b/src/main/java/reobf/proghatches/ae/BlockRequestTunnel.java @@ -0,0 +1,151 @@ +package reobf.proghatches.ae; + +import java.util.List; + +import appeng.api.util.IOrientable; +import appeng.api.util.IOrientableBlock; +import appeng.client.texture.ExtraBlockTextures; +import appeng.tile.misc.TileInterface; +import appeng.util.Platform; +import appeng.util.item.AEItemStack; +import net.minecraft.block.BlockContainer; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.IIcon; +import net.minecraft.util.StatCollector; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import reobf.proghatches.block.INameAndTooltips; + +public class BlockRequestTunnel extends BlockContainer implements IOrientableBlock,INameAndTooltips{ + + public BlockRequestTunnel() { + + super(Material.rock); + setHardness(1); + setHarvestLevel("pickaxe", 1); + setBlockName("proghatches.request_tunnel"); + setBlockTextureName("proghatches:request_tunnel"); + } + @Override + public TileEntity createNewTileEntity(World worldIn, int meta) { + + return new TileRequestTunnel(); + } + @Override + public boolean onBlockActivated(World worldIn, int x, int y, int z, EntityPlayer player, int side, float subX, + float subY, float subZ) { + /*if(worldIn.isRemote==false){ + TileRequestTunnel te=(TileRequestTunnel) worldIn.getTileEntity(x, y, z); + te.injectCraftedItems(null, AEItemStack.create(new ItemStack(Items.apple)), null); + + }*/ + return super.onBlockActivated(worldIn, x, y, z, player, side, subX, subY, subZ); + } + @Override + public void onBlockPlacedBy(World worldIn, int x, int y, int z, EntityLivingBase placer, ItemStack itemIn) { + // TODO Auto-generated method stub + super.onBlockPlacedBy(worldIn, x, y, z, placer, itemIn); + try{ + ((TileRequestTunnel)worldIn.getTileEntity(x, y, z) + ).getProxy().setOwner((EntityPlayer) placer); + }catch(Exception e){e.printStackTrace();} + } + @Override + public boolean usesMetadata() { + + return false; + } + + IIcon fr; + IIcon ba; + @Override + public void registerBlockIcons(IIconRegister reg) { + + IIcon c=reg.registerIcon("proghatches:tunnel"); + IIcon d=reg.registerIcon("proghatches:tunnel_1"); + IIcon a=reg.registerIcon("proghatches:tunnel_2"); + IIcon b=reg.registerIcon("proghatches:tunnel_3"); + fr=reg.registerIcon("proghatches:tunnel_front"); + ba=reg.registerIcon("proghatches:tunnel_back"); + IIcon x=null; + tab=new IIcon[][] + { + {x,x,a,a,a,a}, + {x,x,c,c,c,c}, + {c,c,x,x,b,d}, + {a,a,x,x,d,b}, + {b,b,d,b,x,x}, + {d,d,b,d,x,x}, + }; + + + + this.blockIcon=fr; + } + static IIcon[][] tab;//={}; + @Override + public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) { + TileRequestTunnel te= (TileRequestTunnel)world.getTileEntity(x, y, z); + if(te.getUp()==ForgeDirection.UNKNOWN){return fr; } + + if(te.getUp().getOpposite().ordinal()==side){ + + return ba; + } + + + if(te.getUp().ordinal()==side){ + + return fr; + } + + + return tab[te.getUp().ordinal()][side]; + } + @Override + public IOrientable getOrientable(IBlockAccess world, int x, int y, int z) { + + return (TileRequestTunnel)world.getTileEntity(x, y, z); + } + + protected void customRotateBlock(final IOrientable rotatable, final ForgeDirection axis) { + if (rotatable instanceof TileRequestTunnel) { + ((TileRequestTunnel) rotatable).setSide(axis); + } + } + @Override + public final boolean rotateBlock(final World w, final int x, final int y, final int z, final ForgeDirection axis) { + final IOrientable rotatable = this.getOrientable(w, x, y, z); + + if (rotatable != null && rotatable.canBeRotated()) { + + this.customRotateBlock(rotatable, axis); + return true; + + } + + return super.rotateBlock(w, x, y, z, axis); + } + @Override + public void addInformation(ItemStack p_77624_1_, List l) { + + + + l.add(StatCollector.translateToLocal("proghatch.request_tunnel.tooltip.0")); + l.add(StatCollector.translateToLocal("proghatch.request_tunnel.tooltip.1")); + l.add(StatCollector.translateToLocal("proghatch.request_tunnel.tooltip.2")); + l.add(StatCollector.translateToLocal("proghatch.request_tunnel.tooltip.3")); + } + @Override + public String getName(ItemStack p_77624_1_) { + // TODO Auto-generated method stub + return null; + } +} diff --git a/src/main/java/reobf/proghatches/ae/EmitterPattern.java b/src/main/java/reobf/proghatches/ae/EmitterPattern.java new file mode 100644 index 0000000..fd523c8 --- /dev/null +++ b/src/main/java/reobf/proghatches/ae/EmitterPattern.java @@ -0,0 +1,104 @@ +package reobf.proghatches.ae; + +import appeng.api.AEApi; +import appeng.api.networking.crafting.ICraftingPatternDetails; +import appeng.api.storage.data.IAEItemStack; +import appeng.util.item.AEItemStack; +import net.minecraft.init.Items; +import net.minecraft.inventory.InventoryCrafting; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; +import reobf.proghatches.eucrafting.IInputMightBeEmptyPattern; +import reobf.proghatches.gt.metatileentity.util.IDisallowOptimize; + +public class EmitterPattern implements ICraftingPatternDetails,IInputMightBeEmptyPattern,IDisallowOptimize { +private final ItemStack patternStack; +private final IAEItemStack outputs; +private int priority = 0; + +public EmitterPattern(ItemStack patternStack,IAEItemStack outputs){ + this.patternStack=patternStack; + this.outputs=outputs; + + +} +@Override + public boolean equals(Object obj) { + + if(obj instanceof EmitterPattern){ + + return outputs.equals(((EmitterPattern)obj).outputs); + } + + return super.equals(obj); + } +@Override + public int hashCode() { + + return ((AEItemStack)outputs).hashCode(); + } +@Override +public ItemStack getPattern() { + + return patternStack; +} + +@Override +public boolean isValidItemForSlot(int slotIndex, ItemStack itemStack, World world) { + + return false; +} + +@Override +public boolean isCraftable() { + + return false; +} + +@Override +public IAEItemStack[] getInputs() { + return new IAEItemStack[] { AEApi.instance().storage().createItemStack(new ItemStack(Items.apple, 0)) }; + +} + +@Override +public IAEItemStack[] getCondensedInputs() { + + return getInputs(); +} + +@Override +public IAEItemStack[] getCondensedOutputs() { + + return new IAEItemStack[]{outputs}; +} + +@Override +public IAEItemStack[] getOutputs() { + return new IAEItemStack[]{outputs}; +} + +@Override +public boolean canSubstitute() { + + return false; +} + +@Override +public ItemStack getOutput(InventoryCrafting craftingInv, World world) { + + return outputs.getItemStack(); +} + +@Override +public int getPriority() { + + return priority; +} + +@Override +public void setPriority(int priority) { + this.priority=priority; + +} +} \ No newline at end of file diff --git a/src/main/java/reobf/proghatches/ae/ItemEmitterPattern.java b/src/main/java/reobf/proghatches/ae/ItemEmitterPattern.java new file mode 100644 index 0000000..86cd5bc --- /dev/null +++ b/src/main/java/reobf/proghatches/ae/ItemEmitterPattern.java @@ -0,0 +1,347 @@ +package reobf.proghatches.ae; + +import java.util.List; +import java.util.Optional; +import java.util.function.Supplier; + +import org.lwjgl.input.Keyboard; +import org.lwjgl.opengl.GL11; + +import com.glodblock.github.common.item.ItemFluidDrop; +import com.glodblock.github.common.item.ItemFluidPacket; +import com.google.common.collect.ImmutableList; +import com.gtnewhorizons.modularui.api.ModularUITextures; +import com.gtnewhorizons.modularui.api.forge.IItemHandlerModifiable; +import com.gtnewhorizons.modularui.api.forge.ItemStackHandler; +import com.gtnewhorizons.modularui.api.math.Alignment; +import com.gtnewhorizons.modularui.api.math.Color; +import com.gtnewhorizons.modularui.api.screen.IItemWithModularUI; +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.api.screen.UIBuildContext; +import com.gtnewhorizons.modularui.api.widget.Widget; +import com.gtnewhorizons.modularui.common.internal.wrapper.BaseSlot; +import com.gtnewhorizons.modularui.common.widget.SlotWidget; +import com.gtnewhorizons.modularui.common.widget.textfield.NumericWidget; +import com.gtnewhorizons.modularui.common.widget.textfield.TextFieldWidget; + +import appeng.api.implementations.ICraftingPatternItem; +import appeng.api.networking.crafting.ICraftingPatternDetails; + + +import appeng.util.Platform; +import appeng.util.item.AEItemStack; +import gregtech.api.gui.modularui.GTUIInfos; +import gregtech.api.gui.modularui.GTUITextures; +import gregtech.api.util.GTUtil; +import gregtech.api.util.GTUtility; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.RenderHelper; +import net.minecraft.client.renderer.entity.RenderItem; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.StatCollector; +import net.minecraft.world.World; +import net.minecraftforge.client.IItemRenderer; +import net.minecraftforge.client.MinecraftForgeClient; +import net.minecraftforge.client.IItemRenderer.ItemRenderType; +import net.minecraftforge.client.IItemRenderer.ItemRendererHelper; +import net.minecraftforge.fluids.FluidStack; +import reobf.proghatches.item.ItemProgrammingCircuit; + +import reobf.proghatches.lang.LangManager; +import reobf.proghatches.main.MyMod; +import reobf.proghatches.util.ProghatchesUtil; + +public class ItemEmitterPattern extends Item implements ICraftingPatternItem,IItemWithModularUI{ + + public ItemEmitterPattern() { + //super(target); + if (Platform.isClient()) { + MinecraftForgeClient.registerItemRenderer(this, new ItemEmitterPatternRenderer()); + } + } + + +public static class ItemEmitterPatternRenderer implements IItemRenderer { + + private final RenderItem ri = new RenderItem(); + private boolean recursive = false; + + @Override + public boolean handleRenderType(final ItemStack item, final ItemRenderType type) { + final boolean isShiftHeld = Keyboard.isKeyDown(Keyboard.KEY_LSHIFT) || Keyboard.isKeyDown(Keyboard.KEY_RSHIFT); + + if (!this.recursive && type == IItemRenderer.ItemRenderType.INVENTORY && isShiftHeld) { + final ItemEmitterPattern iep = (ItemEmitterPattern) item.getItem(); + + if (iep.getOutput(item) != null) { + return true; + } + } + + return false; + } + + @Override + public boolean shouldUseRenderHelper(final ItemRenderType type, final ItemStack item, + final ItemRendererHelper helper) { + return false; + } + + @Override + public void renderItem(final ItemRenderType type, final ItemStack item, final Object... data) { + this.recursive = true; + + final ItemEmitterPattern iep = (ItemEmitterPattern) item.getItem(); + final ItemStack is = iep.getOutput(item); + final Minecraft mc = Minecraft.getMinecraft(); + + GL11.glPushAttrib(GL11.GL_ENABLE_BIT | GL11.GL_COLOR_BUFFER_BIT | GL11.GL_LIGHTING_BIT); + RenderHelper.enableGUIStandardItemLighting(); + this.ri.renderItemAndEffectIntoGUI(mc.fontRenderer, mc.getTextureManager(), is, 0, 0); + RenderHelper.disableStandardItemLighting(); + GL11.glPopAttrib(); + + this.recursive = false; + } +} + +@Override +public ItemStack onItemRightClick(ItemStack itemStackIn, World worldIn, EntityPlayer player) { + if(itemStackIn.stackSize>1){return itemStackIn;} + + GTUIInfos.openPlayerHeldItemUI(player); + return itemStackIn; +} + public ItemStack getOutput(ItemStack item) { + + ICraftingPatternDetails k = getPatternForItem(item, null); + + if(k!=null)return k.getOutput(null, null); + return null; +} + @Override + public ICraftingPatternDetails getPatternForItem(ItemStack is, World w) { + NBTTagCompound tag = is.getTagCompound(); + if(tag!=null){ + + ItemStack isx=ItemStack.loadItemStackFromNBT(tag.getCompoundTag("out")); + if(isx!=null)return new EmitterPattern(is, AEItemStack.create(isx).setStackSize(tag.getLong("num"))); + } + + return null; + } + + @Override + public ModularWindow createWindow(UIBuildContext buildContext, ItemStack heldStack) { + + return new UIFactory(buildContext).createWindow(); + } + protected class UIFactory { + + private final UIBuildContext uiBuildContext; + private ItemStack getCurrentItem() { + return uiBuildContext.getPlayer().inventory.getCurrentItem(); + } + public UIFactory(UIBuildContext buildContext) { + this.uiBuildContext = buildContext; + } + + public ModularWindow createWindow() { + ModularWindow.Builder builder = ModularWindow.builder(getGUIWidth(), getGUIHeight()); + builder.setBackground(ModularUITextures.VANILLA_BACKGROUND); + // builder.setGuiTint(getUIBuildContext().getGuiColorization()); + if (doesBindPlayerInventory()) { + builder.bindPlayerInventory(getUIBuildContext().getPlayer()); + } + // builder.bindPlayerInventory(builder.getPlayer(), 7, + // getGUITextureSet().getItemSlot()); + + addTitleToUI(builder); + addUIWidgets(builder); + /* + * if (getUIBuildContext().isAnotherWindow()) { builder.widget( + * ButtonWidget.closeWindowButton(true) .setPos(getGUIWidth() - 15, + * 3)); } + */ + + /* + * final CoverInfo coverInfo = uiBuildContext.getTile() + * .getCoverInfoAtSide(uiBuildContext.getCoverSide()); final + * CoverBehaviorBase behavior = coverInfo.getCoverBehavior(); + * if (coverInfo.getMinimumTickRate() > 0 && + * behavior.allowsTickRateAddition()) { builder.widget( new + * GT_CoverTickRateButton(coverInfo, builder).setPos(getGUIWidth() - + * 24, getGUIHeight() - 24)); } + */ + return builder.build(); + } + + /** + * Override this to add widgets for your UI. + */ + + // IItemHandlerModifiable fakeInv=new ItemHandlerModifiable(); +class TakeOnlyItemStackHandler extends ItemStackHandler{ + @Override + public boolean isItemValid(int slot, ItemStack stack) { + + return false;//not allowed to put in + } +} + protected void addUIWidgets(ModularWindow.Builder builder) { + + builder.widget(new TextFieldWidget().setGetter(() -> { + if(getCurrentItem().getTagCompound()!=null){ + return getCurrentItem().getTagCompound().getLong("num")+""; + } + + return "1"; + }) + .setSetter(val -> { + if(getCurrentItem().getTagCompound()==null){getCurrentItem().setTagCompound(new NBTTagCompound());}; + + getCurrentItem().getTagCompound().setLong("num",Long.valueOf( val)); + + }) + .setNumbersLong(s->{if(s<0)return 1l;return s;}) + //.setBounds(1, 3) + .setTextColor(Color.WHITE.normal) + .setTextAlignment(Alignment.Center) + .setBackground(GTUITextures.BACKGROUND_TEXT_FIELD) + .setSize(18*4, 18) + .setPos(50, 3)); + builder.widget(SlotWidget.phantom(new IItemHandlerModifiable() { + + @Override + public ItemStack insertItem(int var1, ItemStack var2, boolean var3) { + if(var2!=null&&var2.getItem() instanceof ItemFluidPacket){ + FluidStack x = ItemFluidPacket.getFluidStack(var2); + if(x!=null) + var2=ItemFluidDrop.newStack(x); + } + if(GTUtility.getFluidFromDisplayStack(var2) != null){ + FluidStack x = GTUtility.getFluidFromDisplayStack(var2); + x.amount=1; + var2=ItemFluidDrop.newStack(x); + } + + if(getCurrentItem().getTagCompound()==null){getCurrentItem().setTagCompound(new NBTTagCompound());}; + getCurrentItem().getTagCompound().setTag("out", one(var2.copy()).writeToNBT(new NBTTagCompound())); + + return null; + } + + @Override + public ItemStack getStackInSlot(int var1) { + if(getCurrentItem().getTagCompound()!=null){ + + + return ItemStack.loadItemStackFromNBT(getCurrentItem().getTagCompound().getCompoundTag("out")); + } + return null; + } + + @Override + public int getSlots() { + + return 1; + } + + @Override + public int getSlotLimit(int var1) { + + return Integer.MAX_VALUE; + } + + @Override + public ItemStack extractItem(int var1, int var2, boolean var3) { + if(getCurrentItem().getTagCompound()==null){ + getCurrentItem().setTagCompound(new NBTTagCompound()); + + } + return null; + } + + @Override + public void setStackInSlot(int var1, ItemStack var2) { + if(var2!=null&&var2.getItem() instanceof ItemFluidPacket){ + FluidStack x = ItemFluidPacket.getFluidStack(var2); + if(x!=null) + var2=ItemFluidDrop.newStack(x); + } + if(GTUtility.getFluidFromDisplayStack(var2) != null){ + FluidStack x = GTUtility.getFluidFromDisplayStack(var2); + x.amount=1; + var2=ItemFluidDrop.newStack(x); + } + + + + + if(getCurrentItem().getTagCompound()==null){getCurrentItem().setTagCompound(new NBTTagCompound());}; + + if(var2==null) + getCurrentItem().getTagCompound().removeTag("out"); + else + getCurrentItem().getTagCompound().setTag("out", one(var2.copy()).writeToNBT(new NBTTagCompound())); + + + } + }, 0).setPos(3, 3)); + } +public ItemStack one(ItemStack is){is.stackSize=1;return is;} + public UIBuildContext getUIBuildContext() { + return uiBuildContext; + } + + /* + * public boolean isCoverValid() { return !getUIBuildContext().getTile() + * .isDead() && getUIBuildContext().getTile() + * .getCoverBehaviorAtSideNew(getUIBuildContext().getCoverSide()) != + * GregTechAPI.sNoBehavior; } + */ + + protected void addTitleToUI(ModularWindow.Builder builder) { + /* + * ItemStack coverItem = + * GTUtility.intToStack(getUIBuildContext().getCoverID()); if + * (coverItem != null) { builder.widget( new + * ItemDrawable(coverItem).asWidget() .setPos(5, 5) .setSize(16, + * 16)) .widget( new + * TextWidget(coverItem.getDisplayName()).setDefaultColor( + * COLOR_TITLE.get()) .setPos(25, 9)); } + */ + } + + protected int getGUIWidth() { + return 176; + } + + protected int getGUIHeight() { + return 107; + } + + protected boolean doesBindPlayerInventory() { + return true; + } + + protected int getTextColorOrDefault(String textType, int defaultColor) { + return defaultColor; + } + + protected final Supplier COLOR_TITLE = () -> getTextColorOrDefault("title", 0x222222); + protected final Supplier COLOR_TEXT_GRAY = () -> getTextColorOrDefault("text_gray", 0x555555); + protected final Supplier COLOR_TEXT_WARN = () -> getTextColorOrDefault("text_warn", 0xff0000); + } + @Override + public void addInformation(ItemStack p_77624_1_, EntityPlayer p_77624_2_, List p_77624_3_, boolean p_77624_4_) { + p_77624_3_.add(StatCollector.translateToLocal("item.emitterpattern.name.tooltip.0")); + p_77624_3_.add(StatCollector.translateToLocal("item.emitterpattern.name.tooltip.1")); + p_77624_3_.add(StatCollector.translateToLocal("item.emitterpattern.name.tooltip.2")); + p_77624_3_.add(StatCollector.translateToLocal("item.emitterpattern.name.tooltip.3")); + } +} diff --git a/src/main/java/reobf/proghatches/ae/PartAmountMaintainer.java b/src/main/java/reobf/proghatches/ae/PartAmountMaintainer.java index f5780a7..87125e5 100644 --- a/src/main/java/reobf/proghatches/ae/PartAmountMaintainer.java +++ b/src/main/java/reobf/proghatches/ae/PartAmountMaintainer.java @@ -240,10 +240,10 @@ public void requestForMissing(IAEStack primitive){ job=getProxy().getCrafting().beginCraftingJob(this.getTile().getWorldObj(), getProxy().getGrid(), source, iaeStack, null); } else{ - if(job.isDone()){ + if(job.isDone()&&!job.isCancelled()){ link = getProxy().getCrafting().submitJob(job.get(), this, null, false, source); job=null;} - if(job.isCancelled()){job=null;} + else if(job.isCancelled()){job=null;} } }else{ if(link.isCanceled()||link.isDone()){link=null;} diff --git a/src/main/java/reobf/proghatches/ae/TileRequestTunnel.java b/src/main/java/reobf/proghatches/ae/TileRequestTunnel.java new file mode 100644 index 0000000..c74b5c4 --- /dev/null +++ b/src/main/java/reobf/proghatches/ae/TileRequestTunnel.java @@ -0,0 +1,855 @@ +package reobf.proghatches.ae; + +import java.util.ArrayList; +import java.util.EnumSet; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.NavigableMap; +import java.util.TreeMap; +import java.util.concurrent.Future; +import java.util.stream.IntStream; + +import org.apache.commons.io.output.NullOutputStream; + +import com.glodblock.github.common.item.ItemFluidDrop; +import com.glodblock.github.common.item.ItemFluidPacket; +import com.glodblock.github.inventory.FluidConvertingInventoryAdaptor; +import com.glodblock.github.util.BlockPos; +import com.glodblock.github.util.Util; +import com.google.common.collect.ImmutableSet; + +import appeng.api.AEApi; +import appeng.api.config.Actionable; +import appeng.api.implementations.ICraftingPatternItem; +import appeng.api.implementations.tiles.ICraftingMachine; +import appeng.api.networking.GridFlags; +import appeng.api.networking.crafting.ICraftingJob; +import appeng.api.networking.crafting.ICraftingLink; +import appeng.api.networking.crafting.ICraftingPatternDetails; +import appeng.api.networking.crafting.ICraftingRequester; +import appeng.api.networking.security.BaseActionSource; +import appeng.api.networking.security.MachineSource; +import appeng.api.storage.IExternalStorageHandler; +import appeng.api.storage.IMEInventory; +import appeng.api.storage.IMEMonitor; +import appeng.api.storage.StorageChannel; +import appeng.api.storage.data.IAEFluidStack; +import appeng.api.storage.data.IAEItemStack; +import appeng.api.util.IOrientable; +import appeng.crafting.CraftingLink; +import appeng.me.GridAccessException; +import appeng.me.cluster.implementations.CraftingCPUCluster; +import appeng.tile.TileEvent; +import appeng.tile.events.TileEventType; +import appeng.tile.grid.AENetworkTile; +import appeng.util.InventoryAdaptor; +import appeng.util.Platform; +import appeng.util.item.AEFluidStack; +import appeng.util.item.AEItemStack; +import gregtech.api.util.GTUtility; +import mcp.mobius.waila.api.IWailaConfigHandler; +import mcp.mobius.waila.api.IWailaDataAccessor; +import mcp.mobius.waila.api.IWailaDataProvider; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.inventory.ISidedInventory; +import net.minecraft.inventory.InventoryCrafting; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTank; +import net.minecraftforge.fluids.FluidTankInfo; +import net.minecraftforge.fluids.IFluidHandler; + +public class TileRequestTunnel extends AENetworkTile implements ICraftingMachine,ICraftingRequester,IOrientable +,ISidedInventory,IFluidHandler + + +{ + public static IWailaDataProvider provider=new IWailaDataProvider(){ + + @Override + public ItemStack getWailaStack(IWailaDataAccessor accessor, IWailaConfigHandler config) { + + return null; + } + + @Override + public List getWailaHead(ItemStack itemStack, List currenttip, IWailaDataAccessor accessor, + IWailaConfigHandler config) { + + return null; + } + + @Override + public List getWailaBody(ItemStack itemStack, List currenttip, IWailaDataAccessor accessor, + IWailaConfigHandler config) { + try{ + if( accessor.getSide()==((TileRequestTunnel)accessor.getTileEntity()).getUp().getOpposite()){ + + currenttip.add("Auto-output to this side"); + + }; + + + + + NBTTagCompound data = accessor.getNBTData(); + + ArrayList cacheR=new ArrayList<>(); + { NBTTagList t= (NBTTagList) data.getTag("cacheR"); + for(int i=0;i cacheFR=new ArrayList<>(); + { NBTTagList t= (NBTTagList) data.getTag("cacheFR"); + for(int i=0;i ret=currenttip; + + + + if(cacheR.isEmpty()==false||cacheFR.isEmpty()==false) + ret.add("Sending:"); + + cacheR.forEach(s->{ + + ret.add(""+s.getDisplayName()+" x"+s.stackSize); + + }); + + cacheFR.forEach(s->{ + + ret.add(""+s.getFluid().getLocalizedName(s)+" x"+s.amount+"mB"); + + }); + NavigableMap waiting=new TreeMap<>(); + NBTTagList t= (NBTTagList) data.getTag("waiting"); + for(int i=0;i{ + + ret.add(""+s.getKey().getDisplayName()+" x"+s.getValue()); + + + }); + + + + + return ret;}catch(Exception e){e.printStackTrace();} + return currenttip; + } + + @Override + public List getWailaTail(ItemStack itemStack, List currenttip, IWailaDataAccessor accessor, + IWailaConfigHandler config) { + + return null; + } + + @Override + public NBTTagCompound getNBTData(EntityPlayerMP player, TileEntity te, NBTTagCompound data, World world, int x, + int y, int z) { + + + TileRequestTunnel thiz= (TileRequestTunnel) te; + { + NBTTagList listR=new NBTTagList(); + thiz. cacheR.stream().map(s-> + s.writeToNBT(new NBTTagCompound()) + ).forEach(s->listR.appendTag(s)); + data.setTag("cacheR", listR); + NBTTagList listFR=new NBTTagList(); + thiz. cacheFR.stream().map(s-> + s.writeToNBT(new NBTTagCompound()) + ).forEach(s->listFR.appendTag(s)); + data.setTag("cacheFR", listFR); + } + NBTTagList listR=new NBTTagList(); + thiz.waiting.entrySet().stream().map(s-> + { + NBTTagCompound t=new NBTTagCompound(); + NBTTagCompound k=new NBTTagCompound(); + s.getKey().writeToNBT(k); + t.setTag("key", k); + t.setLong("value", s.getValue()); + + return t; + } + ).forEach(s->listR.appendTag(s)) ; + data.setTag("waiting", listR);; + return data; + }}; + public TileRequestTunnel() { + this.getProxy().setFlags(GridFlags.REQUIRE_CHANNEL); + } + ArrayList cache=new ArrayList<>(); + ArrayList cacheF=new ArrayList<>(); + HashMap waiting=new HashMap<>(); + ArrayList cacheR=new ArrayList<>(); + ArrayList cacheFR=new ArrayList<>(); + @Override + public boolean pushPattern(ICraftingPatternDetails patternDetails, InventoryCrafting table, + ForgeDirection ejectionDirection) { + for(int i=0;i + s.writeToNBT(new NBTTagCompound()) + ).forEach(s->list.appendTag(s)); + data.setTag("cache", list); + NBTTagList listF=new NBTTagList(); + cacheF.stream().map(s-> + s.writeToNBT(new NBTTagCompound()) + ).forEach(s->listF.appendTag(s)); + data.setTag("cacheF", listF); + { + NBTTagList listR=new NBTTagList(); + cacheR.stream().map(s-> + s.writeToNBT(new NBTTagCompound()) + ).forEach(s->listR.appendTag(s)); + data.setTag("cacheR", listR); + NBTTagList listFR=new NBTTagList(); + cacheFR.stream().map(s-> + s.writeToNBT(new NBTTagCompound()) + ).forEach(s->listFR.appendTag(s)); + data.setTag("cacheFR", listFR); + } + + + + + + NBTTagList listR=new NBTTagList(); + waiting.entrySet().stream().map(s-> + { + NBTTagCompound t=new NBTTagCompound(); + NBTTagCompound k=new NBTTagCompound(); + s.getKey().writeToNBT(k); + t.setTag("key", k); + t.setLong("value", s.getValue()); + + return t; + } + ).forEach(s->listR.appendTag(s)); + data.setTag("waiting", listR); + if(last!=null){ + NBTTagCompound tag=new NBTTagCompound(); + last.writeToNBT(tag); + data.setTag("link", tag); + } + + } + public void dump(){ + try { + IMEMonitor i = getProxy().getStorage().getItemInventory(); + cache.removeIf(s->{ + IAEItemStack left = i.injectItems(AEItemStack.create(s), Actionable.MODULATE, new MachineSource(this)); + if(left==null||left.getStackSize()<=0){return true;} + s.stackSize=(int) left.getStackSize(); + return false; + }); + } catch (GridAccessException e) { + + } + + try { + IMEMonitor i = getProxy().getStorage().getFluidInventory(); + cacheF.removeIf(s->{ + IAEFluidStack left = i.injectItems(AEFluidStack.create(s), Actionable.MODULATE, new MachineSource(this)); + if(left==null||left.getStackSize()<=0){return true;} + s.amount=(int) left.getStackSize(); + return false; + }); + } catch (GridAccessException e) { + + } + + } + + + + + @Override + public boolean acceptsPlans() { + + return true; + } + + ICraftingLink last; + @Override + public ImmutableSet getRequestedJobs() { + return last==null?ImmutableSet.of():ImmutableSet.of(last); + } + @Override + public IAEItemStack injectCraftedItems(ICraftingLink link, IAEItemStack items, Actionable mode) { + if(mode==Actionable.SIMULATE){ + + return null; + } + /*Long l=waiting.get(items); + if(l!=null){ + long todo=Math.min(l, items.getStackSize()); + IAEItemStack t = items.copy().setStackSize(todo); + t=complete(t); + todo=todo-((t==null)?0:t.getStackSize()); + waiting.put((AEItemStack) items, l-todo); + items.decStackSize(todo); + if(l-todo<=0){ + waiting.remove(items); + } + if(items.getStackSize()<=0)items=null; + + + }*/ + if(items.getItem() instanceof ItemFluidDrop){ + cacheFR.add(ItemFluidDrop.getAeFluidStack(items).getFluidStack()); + }else{ + cacheR.add(items.getItemStack()); + + } + return null; + } + + HashMap inv=new HashMap(); + HashMap handlerHash=new HashMap(); + public ItemStack[] mark=new ItemStack[1]; + private BaseActionSource source=new MachineSource(this); + + + ForgeDirection prevDir; +public IMEInventory getInv(StorageChannel ch){ + if(prevDir!=getUp()){ + prevDir=getUp(); + this.inv.clear(); + } + if(getSide()==ForgeDirection.UNKNOWN)return null; + final TileEntity self = this; + final TileEntity target = new BlockPos(self).getOffSet(this.getSide()).getTileEntity(); + + final int newHandlerHash = Platform.generateTileHash(target); + if (newHandlerHash != 0 && newHandlerHash == this.handlerHash.getOrDefault(ch, 0)) { + return this.inv.get(ch); + } + + final IExternalStorageHandler esh = AEApi.instance().registries().externalStorage() + .getHandler(target, this.getSide().getOpposite(), ch, this.source); + if (esh != null) { + final IMEInventory inv = esh + .getInventory(target, this.getSide().getOpposite(), ch, this.source); + this.inv.put(ch,inv); + handlerHash.put(ch, newHandlerHash); + return inv; + }else{ + + handlerHash.put(ch, 0); + } + return null; + +} + private ForgeDirection getSide() { + + return getUp().getOpposite(); +} +/* @SuppressWarnings("unchecked") + public IAEItemStack complete(IAEItemStack todo){ + + try{ + todo=(IAEItemStack) getInv(StorageChannel.ITEMS).injectItems(todo, Actionable.MODULATE, source); + + }catch(NullPointerException e){} + + + return todo; + } + */ + + + + @Override + public void jobStateChange(ICraftingLink link) { + + + } + int cd; + int tick; + Future job; + @TileEvent(TileEventType.TICK) + public void update(){tick++; + if(getWorldObj().isRemote)return; + + if(dirty){ + dirty=false; + cacheR.removeIf(s->s.stackSize<=0); + } + if(dirtyF){ + dirtyF=false; + cacheFR.removeIf(s->s.amount<=0); + } + boolean clear=false; + + IMEInventory ch = getInv(StorageChannel.ITEMS); + if(ch!=null) + for(ItemStack todo:cacheR){ + AEItemStack itodo=(AEItemStack)ch .injectItems(AEItemStack.create(todo), Actionable.MODULATE, source); + todo.stackSize=(int) (itodo==null?0:itodo.getStackSize()); + if(todo.stackSize==0)clear=true; + } + if(clear)cacheR.removeIf(s->s.stackSize==0); + + ch = getInv(StorageChannel.FLUIDS); + clear=false; + if(ch!=null) + for(FluidStack todo:cacheFR){ + AEFluidStack itodo=(AEFluidStack) getInv(StorageChannel.FLUIDS).injectItems(AEFluidStack.create(todo), Actionable.MODULATE, source); + todo.amount=(int) (itodo==null?0:itodo.getStackSize()); + if(todo.amount==0)clear=true; + } + if(clear)cacheFR.removeIf(s->s.amount==0); + + + + + + IAEItemStack req = null; + + if(waiting.isEmpty()==false){ + + + + + useExisting(); + } + if(this.tick%40==2){ + + fillStacksIntoFirstSlots(cacheR); + fillStacksIntoFirstSlotsF(cacheFR); + fillStacksIntoFirstSlots(cache); + fillStacksIntoFirstSlotsF(cacheF); + + } + if(waiting.isEmpty()==false&&job==null){ + Entry ent = waiting.entrySet().iterator().next(); + req= ent.getKey().copy().setStackSize(ent.getValue()); + } + + + + + + + + + try{ + if(last!=null){ + if(last.isDone()||last.isCanceled()){ + last=null; + + } + } + if(last==null){ + if(job==null){ + if(req!=null){ + if(cd--<=0){ + job = getProxy().getCrafting().beginCraftingJob(this.getTile().getWorldObj(), getProxy().getGrid(), new MachineSource(this), req, null); + cd=40; + }} + } + else if(job.isDone()&&!job.isCancelled()){ + last=getProxy().getCrafting().submitJob(job.get(), this, null, true, new MachineSource(this)); + job=null; + }else if(job.isCancelled()){last=null;} + + }else{ + + + } + }catch(Exception e){} + + + } + protected void fillStacksIntoFirstSlotsF( ArrayList mInventory) { + final int L = mInventory.size(); + HashMap slots = new HashMap<>(L); + HashMap stacks = new HashMap<>(L); + List order = new ArrayList<>(L); + List validSlots = new ArrayList<>(L); + for (int i = 0; i < L; i++) { + + validSlots.add(i); + FluidStack s = mInventory.get(i); + if (s == null) continue; + Fluid sID =s.getFluid(); + slots.merge(sID, s.amount, Integer::sum); + if (!stacks.containsKey(sID)) stacks.put(sID, s); + order.add(sID); + mInventory.set(i, null); + } + int slotindex = 0; + for (Fluid sID : order) { + int toSet = slots.get(sID); + if (toSet == 0) continue; + int slot = validSlots.get(slotindex); + slotindex++; + mInventory.set( slot,stacks.get(sID).copy()) + ; + // toSet = Math.min(toSet, mInventory[slot].getMaxStackSize()); + mInventory.get(slot).amount = toSet; + slots.merge(sID, toSet, (a, b) -> a - b); + } + while(mInventory.size()>=1&&mInventory.get(mInventory.size()-1)==null){ + mInventory.remove(mInventory.size()-1); + } + + } + protected void fillStacksIntoFirstSlots( ArrayList mInventory) { + final int L = mInventory.size() ; + HashMap slots = new HashMap<>(L); + HashMap stacks = new HashMap<>(L); + List order = new ArrayList<>(L); + List validSlots = new ArrayList<>(L); + for (int i = 0; i < L; i++) { + + validSlots.add(i); + ItemStack s = mInventory.get(i); + if (s == null) continue; + GTUtility.ItemId sID = GTUtility.ItemId.createNoCopy(s); + slots.merge(sID, s.stackSize, Integer::sum); + if (!stacks.containsKey(sID)) stacks.put(sID, s); + order.add(sID); + mInventory.set(i, null); + } + int slotindex = 0; + for (GTUtility.ItemId sID : order) { + int toSet = slots.get(sID); + if (toSet == 0) continue; + int slot = validSlots.get(slotindex); + slotindex++; + mInventory.set( slot,stacks.get(sID).copy()) + ; + // toSet = Math.min(toSet, mInventory[slot].getMaxStackSize()); + mInventory.get(slot).stackSize = toSet; + slots.merge(sID, toSet, (a, b) -> a - b); + } + while(mInventory.size()>=1&&mInventory.get(mInventory.size()-1)==null){ + mInventory.remove(mInventory.size()-1); + } + + } + private void useExisting() { + for(Iterator> itr = waiting.entrySet().iterator();itr.hasNext();){ + + Entry e=itr.next(); + + + IAEItemStack val = e.getKey().copy().setStackSize(e.getValue()); + + if(val.getItem() instanceof ItemFluidDrop) + try { + IAEFluidStack ext = getProxy().getStorage().getFluidInventory().extractItems(ItemFluidDrop.getAeFluidStack(val), Actionable.MODULATE, source); + if(ext!=null){ + e.setValue(e.getValue()-ext.getStackSize()); + cacheFR.add(ext.copy().getFluidStack()); + if(e.getValue()<=0){itr.remove();} + } + + } catch (GridAccessException e1) { + } + + + else + try { + IAEItemStack ext = getProxy().getStorage().getItemInventory().extractItems(val, Actionable.MODULATE, source); + if(ext!=null){ + e.setValue(e.getValue()-ext.getStackSize()); + cacheR.add(ext.copy().getItemStack()); + if(e.getValue()<=0){itr.remove();} + } + + } catch (GridAccessException e1) { + } + + + + + } + + + + + + } + public boolean canBeRotated() { + return true; + } + + public void setSide( ForgeDirection axis) { + if (Platform.isClient()) { + return; + }//axis=axis.getOpposite(); + ForgeDirection pointAt = getUp().getOpposite(); + if (pointAt == axis.getOpposite()) { + pointAt = axis; + } else if (pointAt == axis || pointAt == axis.getOpposite()) { + pointAt = ForgeDirection.UNKNOWN; + } else if (pointAt == ForgeDirection.UNKNOWN) { + pointAt = axis.getOpposite(); + } else { + pointAt = Platform.rotateAround(pointAt, axis); + } + + if (ForgeDirection.UNKNOWN == pointAt) { + this.setOrientation(pointAt, pointAt); + } else { + this.setOrientation( + pointAt.offsetY != 0 ? ForgeDirection.SOUTH : ForgeDirection.UP, + pointAt.getOpposite()); + } + + this.markForUpdate(); + this.markDirty(); + } + /* ForgeDirection getForward() { + return null; + } + + + ForgeDirection getUp() { + return null; + }*/ + + + public void setOrientation(ForgeDirection Forward, ForgeDirection Up) { + super.setOrientation(Forward, Up); + ForgeDirection pointAt = Up.getOpposite(); + this.getProxy().setValidSides(EnumSet.complementOf(EnumSet.of(pointAt))); + } + @Override + public int getSizeInventory() { + + return cacheR.size()+1; + } + @Override + public ItemStack getStackInSlot(int slotIn) { + if(slotIn==cacheR.size())return null; + dirty=true; + return cacheR.get(slotIn); + } + @Override + public ItemStack decrStackSize(int index, int count) { + if(index==cacheR.size())return null; + dirty=true; + if(cacheR.get(index)==null){return null;} + cacheR.get(index).stackSize-=count; + ItemStack ret = cacheR.get(index).copy(); + ret.stackSize=count; + return ret; + } + @Override + public ItemStack getStackInSlotOnClosing(int index) { + return null; + } + @Override + public void setInventorySlotContents(int index, ItemStack stack) { + if(index==cacheR.size())return ; + dirty=true; + if(stack==null||stack.stackSize==0){ + cacheR.get(index).stackSize=0; + }else{ + cacheR.set(index,stack); + } + + + } + @Override + public String getInventoryName() { + + return ""; + } + @Override + public boolean hasCustomInventoryName() { + + return false; + } + @Override + public int getInventoryStackLimit() { + + return Integer.MAX_VALUE; + } + @Override + public boolean isUseableByPlayer(EntityPlayer player) { + + return true; + } + @Override + public void openInventory() { + + + } + @Override + public void closeInventory() { + + + } + @Override + public boolean isItemValidForSlot(int index, ItemStack stack) { + + return false; + } + @Override + public int[] getAccessibleSlotsFromSide(int p_94128_1_) { + // ForgeDirection pointAt =getUp().getOpposite(); + //if(pointAt.ordinal()==p_94128_1_){ + return IntStream.range(0, cacheR.size()+1).toArray(); +//} + // return new int[0]; + } + @Override + public boolean canInsertItem(int p_102007_1_, ItemStack p_102007_2_, int p_102007_3_) { + + return false; + } + @Override + public boolean canExtractItem(int p_102008_1_, ItemStack p_102008_2_, int p_102008_3_) { + + return true; + } + @Override + public int fill(ForgeDirection from, FluidStack resource, boolean doFill) { + + return 0; + } + @Override + public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) { + int all=cacheFR.stream().filter(s->s.getFluid()==resource.getFluid()) + .mapToInt(s->s.amount).sum(); + if(doDrain){ + dirtyF=true; + int[] todo=new int[]{all}; + cacheFR.stream().filter(s->s.getFluid()==resource.getFluid()).forEach(s->{ + int real=Math.min(todo[0], s.amount); + s.amount-=real; + todo[0]-=real; + }); + + } + + FluidStack cp = resource.copy(); + cp.amount=all; + if(cp.amount==0)cp=null; + return cp; + } + @Override + public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) { + if(cacheFR.size()==0){return null;} + FluidStack cp = cacheFR.get(0).copy(); + cp.amount=maxDrain; + return drain(from,cp , doDrain); + } + @Override + public boolean canFill(ForgeDirection from, Fluid fluid) { + + return false; + } + @Override + public boolean canDrain(ForgeDirection from, Fluid fluid) { + + return true; + } + @Override + public FluidTankInfo[] getTankInfo(ForgeDirection from) { + + return cacheFR.stream().map(s->new FluidTank(s, 1)).toArray(FluidTankInfo[]::new); + } + boolean dirty,dirtyF; +} diff --git a/src/main/java/reobf/proghatches/item/ItemProgrammingToolkit.java b/src/main/java/reobf/proghatches/item/ItemProgrammingToolkit.java index 394aca4..3c6e868 100644 --- a/src/main/java/reobf/proghatches/item/ItemProgrammingToolkit.java +++ b/src/main/java/reobf/proghatches/item/ItemProgrammingToolkit.java @@ -404,5 +404,19 @@ public String[] getBaubleTypes(ItemStack itemstack) { "universal" }; }*/ - + @Override + public boolean doesContainerItemLeaveCraftingGrid(ItemStack p_77630_1_) { + // TODO Auto-generated method stub + return false; + } +@Override +public boolean hasContainerItem(ItemStack stack) { + + return true; +} +@Override +public ItemStack getContainerItem(ItemStack itemStack) { + + return itemStack; +} } diff --git a/src/main/java/reobf/proghatches/main/CommonProxy.java b/src/main/java/reobf/proghatches/main/CommonProxy.java index 1cd61c2..055a9ac 100644 --- a/src/main/java/reobf/proghatches/main/CommonProxy.java +++ b/src/main/java/reobf/proghatches/main/CommonProxy.java @@ -27,8 +27,10 @@ import reobf.proghatches.ae.BlockCraftingCondenser; import reobf.proghatches.ae.BlockCyclicPatternSubmitter; import reobf.proghatches.ae.BlockMolecularAssemblerInterface; +import reobf.proghatches.ae.BlockRequestTunnel; import reobf.proghatches.ae.BlockStockingCircuitRequestInterceptor; import reobf.proghatches.ae.BlockStorageProxy; +import reobf.proghatches.ae.ItemEmitterPattern; import reobf.proghatches.ae.ItemPartAmountMaintainer; import reobf.proghatches.ae.ItemPartMAP2P; import reobf.proghatches.ae.ItemPartStockingExportBus; @@ -38,6 +40,7 @@ import reobf.proghatches.ae.TileCraftingCondenser; import reobf.proghatches.ae.TileCyclicPatternSubmitter; import reobf.proghatches.ae.TileMolecularAssemblerInterface; +import reobf.proghatches.ae.TileRequestTunnel; import reobf.proghatches.ae.TileStockingCircuitRequestInterceptor; import reobf.proghatches.ae.TileStorageProxy; import reobf.proghatches.block.BlockAnchorAlert; @@ -107,7 +110,7 @@ public void preInit(FMLPreInitializationEvent event) { GameRegistry.registerTileEntity(TileStockingCircuitRequestInterceptor.class, "proghatches.circuit_interceptor"); GameRegistry.registerTileEntity(TileAutoFillerMKII.class, "proghatches.autofillerMKII"); GameRegistry.registerTileEntity(TileGTHatchConfigurator.class, "proghatches.configurator"); - + GameRegistry.registerTileEntity(TileRequestTunnel.class, "proghatches.request_tunnel"); ItemMEPlunger a=new ItemMEPlunger(100000); @@ -246,6 +249,14 @@ public void preInit(FMLPreInitializationEvent event) { , "proghatches.ma_iface",new Object[]{""}); + GameRegistry.registerItem(MyMod.emitterpattern = new ItemEmitterPattern() + .setUnlocalizedName("proghatches.emitterpattern").setTextureName("proghatches:emitterpattern"), "proghatches.emitterpattern"); + GameRegistry + .registerBlock( + MyMod.request_tunnel = new BlockRequestTunnel(),ItemBlockTooltip.class + + ,"request_tunnel",new Object[]{""}); + } static public class ToolTipAEBaseItemBlock extends AEBaseItemBlock{ public ToolTipAEBaseItemBlock(Block id) { @@ -302,6 +313,8 @@ public static void callbackRegister(IWailaRegistrar registrar) { registrar.registerBodyProvider(TileCyclicPatternSubmitter.provider, BlockCyclicPatternSubmitter.class); registrar.registerNBTProvider(TileCyclicPatternSubmitter.provider, BlockCyclicPatternSubmitter.class); + registrar.registerBodyProvider(TileRequestTunnel.provider, BlockRequestTunnel.class); + registrar.registerNBTProvider(TileRequestTunnel.provider, BlockRequestTunnel.class); } diff --git a/src/main/java/reobf/proghatches/main/MyMod.java b/src/main/java/reobf/proghatches/main/MyMod.java index b63862d..8859cdd 100644 --- a/src/main/java/reobf/proghatches/main/MyMod.java +++ b/src/main/java/reobf/proghatches/main/MyMod.java @@ -156,6 +156,7 @@ import reobf.proghatches.Tags; import reobf.proghatches.ae.BlockAutoFillerMKII; import reobf.proghatches.ae.BlockMolecularAssemblerInterface; +import reobf.proghatches.ae.BlockRequestTunnel; import reobf.proghatches.block.ChunkTrackingGridCahce; import reobf.proghatches.block.TileIOHub; import reobf.proghatches.eio.ICraftingMachineConduit; @@ -792,6 +793,8 @@ public void init(Entity entity, World world) { public static BlockMolecularAssemblerInterface ma_iface; public static BlockAutoFillerMKII autofiller; //public static Block occonfigurator; + public static BlockRequestTunnel request_tunnel; + public static Item emitterpattern; @SubscribeEvent(priority = EventPriority.HIGH, receiveCanceled = false) public void pretick(final TickEvent.ServerTickEvent event) { diff --git a/src/main/java/reobf/proghatches/main/mixin/MixinCallback.java b/src/main/java/reobf/proghatches/main/mixin/MixinCallback.java index a744eba..ada9d66 100644 --- a/src/main/java/reobf/proghatches/main/mixin/MixinCallback.java +++ b/src/main/java/reobf/proghatches/main/mixin/MixinCallback.java @@ -4,6 +4,7 @@ import java.util.ArrayList; import java.util.LinkedList; import java.util.List; +import java.util.ListIterator; import java.util.Map; import java.util.Objects; import java.util.Optional; @@ -13,9 +14,18 @@ import java.util.function.Function; import java.util.stream.Collectors; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; +import com.glodblock.github.common.item.ItemFluidDrop; +import com.glodblock.github.common.item.ItemFluidPacket; +import com.glodblock.github.inventory.FluidConvertingInventoryCrafting; import com.glodblock.github.nei.object.OrderStack; +import com.llamalad7.mixinextras.sugar.Local; +import com.llamalad7.mixinextras.sugar.Share; +import com.llamalad7.mixinextras.sugar.ref.LocalRef; import appeng.api.config.Actionable; import appeng.api.config.FuzzyMode; @@ -39,11 +49,13 @@ import net.minecraft.item.ItemStack; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.server.MinecraftServer; +import reobf.proghatches.ae.ICondenser; import reobf.proghatches.eucrafting.IEUManager; import reobf.proghatches.eucrafting.IEUManager.EUManager; import reobf.proghatches.eucrafting.IEUManager.IDrain; import reobf.proghatches.eucrafting.TileFluidInterface_EU.SISOPatternDetail; import reobf.proghatches.gt.metatileentity.DualInputHatch; +import reobf.proghatches.gt.metatileentity.util.IMultiplePatternPushable; import reobf.proghatches.item.ItemProgrammingCircuit; import reobf.proghatches.item.ItemProgrammingToolkit; import reobf.proghatches.main.MyMod; diff --git a/src/main/java/reobf/proghatches/main/mixin/mixins/MixinCanCraftExempt.java b/src/main/java/reobf/proghatches/main/mixin/mixins/MixinCanCraftExempt.java index e85f2a9..a5bb281 100644 --- a/src/main/java/reobf/proghatches/main/mixin/mixins/MixinCanCraftExempt.java +++ b/src/main/java/reobf/proghatches/main/mixin/mixins/MixinCanCraftExempt.java @@ -22,6 +22,7 @@ import appeng.me.cluster.implementations.CraftingCPUCluster; import codechicken.nei.InventoryCraftingDummy; import net.minecraft.inventory.InventoryCrafting; +import reobf.proghatches.eucrafting.IInputMightBeEmptyPattern; import reobf.proghatches.gt.metatileentity.ProgrammingCircuitProvider; @SuppressWarnings("unused") @@ -33,7 +34,7 @@ public class MixinCanCraftExempt { @ModifyVariable(method = "executeCrafting", at = @At(value = "INVOKE", target = "getMediums(Lappeng/api/networking/crafting/ICraftingPatternDetails;)Ljava/util/List;"), require = 1) private ICraftingPatternDetails executeCrafting(ICraftingPatternDetails details, @Share("arg") LocalBooleanRef shouldExempt) { - shouldExempt.set((details instanceof ProgrammingCircuitProvider.CircuitProviderPatternDetial)); + shouldExempt.set((details instanceof IInputMightBeEmptyPattern)); return details; } @@ -48,7 +49,7 @@ private InventoryCrafting executeCrafting0(InventoryCrafting x, @Share("arg") Lo @Inject(method = "canCraft", at = @At("RETURN"), cancellable = true, require = 1) private void canCraft(final ICraftingPatternDetails details, final IAEItemStack[] condensedInputs, CallbackInfoReturnable ci) { - if ((details instanceof ProgrammingCircuitProvider.CircuitProviderPatternDetial)) { + if ((details instanceof IInputMightBeEmptyPattern)) { ci.setReturnValue(true); } } diff --git a/src/main/java/reobf/proghatches/main/mixin/mixins/part2/MixinMultiPattern.java b/src/main/java/reobf/proghatches/main/mixin/mixins/part2/MixinMultiPattern.java index ffc9d25..2cdb068 100644 --- a/src/main/java/reobf/proghatches/main/mixin/mixins/part2/MixinMultiPattern.java +++ b/src/main/java/reobf/proghatches/main/mixin/mixins/part2/MixinMultiPattern.java @@ -123,6 +123,15 @@ public void MixinMultiPattern_executeCrafting(IEnergyGrid eg, CraftingGridCache @Local java.util.Map.Entry e, @Share("inv") LocalRef inv0/*, @Share("isMulti") LocalBooleanRef isMulti*/) { + + + + + + + + + InventoryCrafting inv = inv0.get(); //if (isMulti.get()) { if(medium instanceof IMultiplePatternPushable){ @@ -224,17 +233,22 @@ public void MixinMultiPattern_executeCrafting(IEnergyGrid eg, CraftingGridCache InventoryCrafting ic = detail.isCraftable() ? new InventoryCrafting(new ContainerNull(), 3, 3) : new FluidConvertingInventoryCrafting(new ContainerNull(), detail.getInputs().length, 1); final IAEItemStack[] input = detail.getInputs(); - boolean found = false; + boolean found = true; for (int x = 0; x < input.length; x++) { - if (input[x] != null) { + //System.out.println(input[x]); + if (input[x] != null&&input[x].getStackSize()>0) { found = false; for (IAEItemStack ias : getExtractItems(input[x], detail)) { - + //System.out.println(ias); final IAEItemStack ais = this.inventory.extractItems(ias, Actionable.MODULATE, this.machineSrc); final ItemStack is = ais == null ? null : ais.getItemStack(); - if (is == null) + //System.out.println(ais); + if (ias.getStackSize()!=((is == null)?0:is.stackSize)) continue; + + + found = true; ic.setInventorySlotContents(x, is); if (!detail.canBeSubstitute() && is.stackSize == input[x].getStackSize()) { @@ -249,7 +263,7 @@ public void MixinMultiPattern_executeCrafting(IEnergyGrid eg, CraftingGridCache } } } - + //System.out.println(found); if (!found) { // put stuff back.. for (int x = 0; x < ic.getSizeInventory(); x++) { diff --git a/src/main/java/reobf/proghatches/main/registration/PHRecipes.java b/src/main/java/reobf/proghatches/main/registration/PHRecipes.java index 92ffc61..cae2d37 100644 --- a/src/main/java/reobf/proghatches/main/registration/PHRecipes.java +++ b/src/main/java/reobf/proghatches/main/registration/PHRecipes.java @@ -38,6 +38,7 @@ import com.glodblock.github.loader.ItemAndBlockHolder; import appeng.core.Api; +import appeng.core.api.definitions.ApiItems; import appeng.integration.modules.Chisel; import cpw.mods.fml.common.registry.GameRegistry; import cpw.mods.ironchest.IronChest; @@ -1962,6 +1963,55 @@ bb,new ItemStack(MyMod.smartarm, 4,i+5) .eut(30) .addTo(RecipeMaps.assemblerRecipes); + ////// + GTValues.RA.stdBuilder() + .itemInputs( + new ItemStack( MyMod.toolkit,0,OreDictionary.WILDCARD_VALUE), + + Api.INSTANCE.definitions() + .materials().blankPattern().maybeStack(1).get() + ) + .itemOutputs( + new ItemStack( MyMod.emitterpattern) + ) + .duration(1 * SECONDS) + .eut(30) + .addTo(RecipeMaps.assemblerRecipes); + + rec = new ShapelessOreRecipe(new ItemStack( MyMod.emitterpattern), + + new ItemStack( MyMod.toolkit,1,OreDictionary.WILDCARD_VALUE), + + Api.INSTANCE.definitions() + .materials().blankPattern().maybeStack(1).get() + ); + CraftingManager.getInstance().getRecipeList().add(rec); + + rec = new ShapelessOreRecipe( Api.INSTANCE.definitions() + .materials().blankPattern().maybeStack(1).get(), + new ItemStack( MyMod.emitterpattern) + ); + CraftingManager.getInstance().getRecipeList().add(rec); + + + GTValues.RA.stdBuilder() + .itemInputs( + Api.INSTANCE.definitions() + .blocks().iface().maybeStack(1).get(), + Api.INSTANCE.definitions() + .materials().cardCrafting().maybeStack(8).get(), + Api.INSTANCE.definitions() + .blocks().molecularAssembler().maybeStack(8).get() + + ) + .itemOutputs( + new ItemStack( MyMod.request_tunnel) + ) + .duration(1 * SECONDS) + .eut(30) + .addTo(RecipeMaps.assemblerRecipes); + + /*GTRecipeBuilder.builder() .metadata(RESEARCH_ITEM, new ItemStack(ChiselBlocks.present,1,16)) .metadata(RESEARCH_TIME, 1 ) diff --git a/src/main/java/reobf/proghatches/oc/Arch.java b/src/main/java/reobf/proghatches/oc/Arch.java index 5b87cdd..9d45c8e 100644 --- a/src/main/java/reobf/proghatches/oc/Arch.java +++ b/src/main/java/reobf/proghatches/oc/Arch.java @@ -40,7 +40,7 @@ public void close() { @Override public void runSynchronized() { - + machine.node().network().nodes().forEach(s->{ if(s.host() instanceof li.cil.oc.common.component.Screen){ diff --git a/src/main/java/reobf/proghatches/oc/ItemCPU.java b/src/main/java/reobf/proghatches/oc/ItemCPU.java index fe6e1e5..c572f40 100644 --- a/src/main/java/reobf/proghatches/oc/ItemCPU.java +++ b/src/main/java/reobf/proghatches/oc/ItemCPU.java @@ -20,6 +20,7 @@ import li.cil.oc.api.network.Message; import li.cil.oc.api.network.Node; import li.cil.oc.api.network.Visibility; +import li.cil.oc.server.machine.Callbacks; import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.nbt.CompressedStreamTools; @@ -48,8 +49,11 @@ public void update() { + ; + System.out.println(Callbacks.apply(s.host())); + System.out.println(Callbacks.fromClass(s.host().getClass())); + - System.out.println(s.host()); }); } diff --git a/src/main/resources/assets/proghatches/lang/en_US.lang b/src/main/resources/assets/proghatches/lang/en_US.lang index 0b9bafa..43c2a66 100644 --- a/src/main/resources/assets/proghatches/lang/en_US.lang +++ b/src/main/resources/assets/proghatches/lang/en_US.lang @@ -728,3 +728,13 @@ achievement.proghatch.toolkit=Try equipping this on Baubles Slot! achievement.proghatch.toolkit.desc=Then bind a key in settings to switch mode! output.bus.storage.name=Storage Output Bus(ME) output.hacth.storage.name=Storage Output Hatch(ME) +item.proghatches.emitterpattern.name=Emitting Encoded Pattern +tile.proghatches.request_tunnel.name=Crafting Request Tunnel +item.emitterpattern.name.tooltip.0=A special pattern without inputs. Click RMB when not stacked to configure outputs. +item.emitterpattern.name.tooltip.1=It's like an ME Level Emitter with Crafting Card, but pushes pattern instead of sending RS signal. +item.emitterpattern.name.tooltip.2=This pattern will not send materials when being pushed, but Crafting CPU will add outputs to waiting list. +item.emitterpattern.name.tooltip.3=Especially, Crafting Request Tunnel will capture the outputs when accepting this pattern. +proghatch.request_tunnel.tooltip.0=§7This is an §cMA§7 device, it's like a §cM§7olecular §cA§7ssembler, accepts patterns rather than materials from patterns. +proghatch.request_tunnel.tooltip.1=When accepting patterns, it stores inputs into storage and records outputs. Then craft or extract materials to satisfy those outputs. +proghatch.request_tunnel.tooltip.2=Outputs will be cached in inventory, use pipes to send them back, or use wrench to specify the auto-output direction. +proghatch.request_tunnel.tooltip.3=Please use ME Interface (even if pattern contains fluids), ME Dual Interface does not work fine! diff --git a/src/main/resources/assets/proghatches/lang/zh_CN.lang b/src/main/resources/assets/proghatches/lang/zh_CN.lang index 12ac3c7..24e81bb 100644 --- a/src/main/resources/assets/proghatches/lang/zh_CN.lang +++ b/src/main/resources/assets/proghatches/lang/zh_CN.lang @@ -726,3 +726,13 @@ achievement.proghatch.toolkit=尝试把工具箱装备在在饰品栏! achievement.proghatch.toolkit.desc=在设置中绑定按键就能切换模式! output.bus.storage.name=存储输出总线(ME) output.hacth.storage.name=存储输出仓(ME) +item.proghatches.emitterpattern.name=发信编码样板 +tile.proghatches.request_tunnel.name=合成请求隧道 +item.emitterpattern.name.tooltip.0=不含输入仅含输出的特殊样板 不堆叠时右键打开GUI标记输出物品 +item.emitterpattern.name.tooltip.1=类似安装合成卡的ME发信器,只是触发一次发配行为而不是发射红石信号 +item.emitterpattern.name.tooltip.2=由于输入是空的,实际上不会发送物品,但合成CPU会等待输出被送回 +item.emitterpattern.name.tooltip.3=特别地,向合成请求隧道发配时,其输出能被其捕获 +proghatch.request_tunnel.tooltip.0=§7这是一个§cMA§7设备,类似于分子装配室(§cM§7olecular §cA§7ssembler),直接从接口接受样板,而不是样板的输入 +proghatch.request_tunnel.tooltip.1=接受样板后输入材料存入当前网络,并记录样板的输出材料从存储提取或者下单合成这些输出材料 +proghatch.request_tunnel.tooltip.2=这些输出材料会缓存在内部,使用物流管道将其送回下单网络,或者使用扳手指定输出方向 +proghatch.request_tunnel.tooltip.3=请用普通ME接口(即使样板含有流体),ME二合一接口可能会进入常规模式而非MA模式从而卡单 diff --git a/src/main/resources/assets/proghatches/textures/blocks/tunnel.png b/src/main/resources/assets/proghatches/textures/blocks/tunnel.png new file mode 100644 index 0000000000000000000000000000000000000000..28e6a6573f459472385d44062f5be1da1cf7d5af GIT binary patch literal 133 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`KAtX)Ar-fhJ-AH%`E#Z*2u|q9a&mqZhxuegsh;diiud2icml$0= fXD&M9!pX*P&AE@2o6U0v&|C&jS3j3^P6%K+m{a5t#_H__24`8+7B)m4>eJ}q3E)v+PcVIOZmxBL&i_KiIlPB%F!+gE zbj!7F`oO$~O(C0YW1@ug0$+(YwYj{hjyDW?cpsE7>hZo{Sk0)VrIqk!g1y{1w#1x< rU5OvQA5~mrV6?!(IB>>XNeKqyr~aFbRz7$FbQ^=GtDnm{r-UW|MCwqS literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/proghatches/textures/blocks/tunnel_2.png b/src/main/resources/assets/proghatches/textures/blocks/tunnel_2.png new file mode 100644 index 0000000000000000000000000000000000000000..45728f02a54a1304befbeaa321e14a8f9353147d GIT binary patch literal 248 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`jKx9jP7LeL$-D$|SkfJR9T^xl z_H+M9WCij$3p^r=85qP=L734qNaX`iu-DVYF~q_@*@w&I-+2c{2I+u^AnvD=*nU;d zl8ji8)7HE@%qj8+WA*j|gR?AZ3mYO2^=b6*1n?-ZCzw7sH`h8r=YOH1#Ni(|82rR7 zy5(9o1>AhWu$u9P$pa&n)r{5g(anZD3qDU|%w?J=(r}eQR8-WU?u0!5F#|g@hgk7H mwS^r(<226sh@_>nu`#f(^x15=KB5cgFa}RoKbLh*2~7Y|3rx)b literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/proghatches/textures/blocks/tunnel_3.png b/src/main/resources/assets/proghatches/textures/blocks/tunnel_3.png new file mode 100644 index 0000000000000000000000000000000000000000..e4975fbfe8d10b786e823d44921a934f34dc7d37 GIT binary patch literal 248 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!61|;P_|4#%`jKx9jP7LeL$-D$|SkfJR9T^xl z_H+M9WCij$3p^r=85qP=L734qNaX`iu-DVYF~q_@*@w&I-+2c{2I+u^AnvD=*nU;d zl8ji8)7HE@%qj8+WA*j|gR?AZ3mYO2^=b6*1n?-ZCzw7sH`lsA=YOH%oL*jmr%dS= z7YB%`9mrzvVCFf@py!++%vK#Aeb|skVe>@BK)nM?C0RB|Em*XO={Wz-#}9LI8g?aq o_%K+m{a5t#_H__24`8+7B)m4;$zh=yvLqgQkc?^#9%bx{|32W4gQ1Pl;I`lUSIl#cMStm@w Tpq^zb(A5l{u6{1-oD!MAREF-jj}%XrKb zbfCbLVT#;_#GHmC@dZmktwdLi3M+_k`%o#5l|EkSPefw3Z;?fDZ>biS2(RmNIUbj!a zSIeVf_54bnXy#8-2F}d~zjoCIPgLJOO`*VW{;Pii7u&g@Ew76!9IpOjYf??u3rJ2-SU6+8{iPW? bN=1yF?{;j