From 0734ee0dd035bc810b85bdd4f9fac3cc7d3f47c4 Mon Sep 17 00:00:00 2001 From: reobf <2215595288@qq.com> Date: Mon, 2 Sep 2024 21:38:25 +0800 Subject: [PATCH] update --- build.gradle | 2 +- .../proghatches/ae/PartAmountMaintainer.java | 136 +++- .../ae/TileCyclicPatternSubmitter.java | 81 ++- .../reobf/proghatches/block/TileIOHub.java | 15 +- .../proghatches/eucrafting/PartEUSource.java | 29 +- .../proghatches/eucrafting/PartLazerP2P.java | 3 +- .../gt/metatileentity/DualInputHachOC.java | 671 ++++++++++++++++++ .../metatileentity/PatternDualInputHatch.java | 16 +- .../reobf/proghatches/main/CommonProxy.java | 6 +- .../java/reobf/proghatches/main/Config.java | 1 + .../java/reobf/proghatches/main/MyMod.java | 5 +- .../proghatches/main/mixin/MixinPlugin.java | 1 + .../main/mixin/mixins/MixinAE2FCCompat.java | 44 +- .../main/mixin/mixins/part2/MixinOC.java | 61 ++ .../main/registration/Registration.java | 12 +- src/main/java/reobf/proghatches/oc/Arch.java | 88 +++ .../java/reobf/proghatches/oc/ItemCPU.java | 63 ++ .../assets/proghatches/lang/en_US.lang | 5 + .../assets/proghatches/lang/en_US/DIHOC.lang | 2 + .../assets/proghatches/lang/zh_CN.lang | 5 + .../assets/proghatches/lang/zh_CN/DIHOC.lang | 2 + 21 files changed, 1194 insertions(+), 54 deletions(-) create mode 100644 src/main/java/reobf/proghatches/gt/metatileentity/DualInputHachOC.java create mode 100644 src/main/java/reobf/proghatches/main/mixin/mixins/part2/MixinOC.java create mode 100644 src/main/java/reobf/proghatches/oc/Arch.java create mode 100644 src/main/java/reobf/proghatches/oc/ItemCPU.java create mode 100644 src/main/resources/assets/proghatches/lang/en_US/DIHOC.lang create mode 100644 src/main/resources/assets/proghatches/lang/zh_CN/DIHOC.lang diff --git a/build.gradle b/build.gradle index 2c9629d..b6df550 100644 --- a/build.gradle +++ b/build.gradle @@ -373,7 +373,7 @@ catch (Exception ignored) { // Pulls version first from the VERSION env and then git tag String identifiedVersion = null -String versionOverride = '0.0.18p16' +String versionOverride = '0.0.18p17' try { // Produce a version based on the tag, or for branches something like 0.2.2-configurable-maven-and-extras.38+43090270b6-dirty if (versionOverride == null) { diff --git a/src/main/java/reobf/proghatches/ae/PartAmountMaintainer.java b/src/main/java/reobf/proghatches/ae/PartAmountMaintainer.java index 307d1cd..bf64700 100644 --- a/src/main/java/reobf/proghatches/ae/PartAmountMaintainer.java +++ b/src/main/java/reobf/proghatches/ae/PartAmountMaintainer.java @@ -5,12 +5,16 @@ import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Objects; +import java.util.concurrent.Future; +import com.glodblock.github.common.item.ItemFluidDrop; import com.glodblock.github.common.item.ItemFluidPacket; import com.glodblock.github.inventory.MEMonitorIFluidHandler; import com.glodblock.github.util.BlockPos; import com.google.common.collect.ImmutableMap; +import com.google.common.collect.ImmutableSet; import com.gtnewhorizons.modularui.api.ModularUITextures; import com.gtnewhorizons.modularui.api.drawable.IDrawable; import com.gtnewhorizons.modularui.api.drawable.ItemDrawable; @@ -40,6 +44,10 @@ import appeng.api.implementations.IPowerChannelState; import appeng.api.networking.GridFlags; import appeng.api.networking.IGridNode; +import appeng.api.networking.crafting.ICraftingCPU; +import appeng.api.networking.crafting.ICraftingJob; +import appeng.api.networking.crafting.ICraftingLink; +import appeng.api.networking.crafting.ICraftingRequester; import appeng.api.networking.security.BaseActionSource; import appeng.api.networking.security.MachineSource; import appeng.api.networking.storage.IBaseMonitor; @@ -62,9 +70,11 @@ import appeng.client.texture.CableBusTextures; import appeng.core.Api; import appeng.core.api.definitions.ApiItems; +import appeng.crafting.CraftingLink; import appeng.items.tools.ToolMemoryCard; import appeng.me.GridAccessException; import appeng.me.cache.GridStorageCache; +import appeng.me.cluster.implementations.CraftingCPUCluster; import appeng.me.storage.MEInventoryHandler; import appeng.parts.AEBasePart; import appeng.parts.PartBasicState; @@ -94,7 +104,7 @@ import reobf.proghatches.eucrafting.IGuiProvidingPart; import reobf.proghatches.gt.metatileentity.util.polyfill.NumericWidget; -public class PartAmountMaintainer extends PartBasicState implements IGuiProvidingPart,IGridTickable,IPowerChannelState{ +public class PartAmountMaintainer extends PartBasicState implements IGuiProvidingPart,IGridTickable,IPowerChannelState, ICraftingRequester{ private int mode; private int rsmode; @@ -139,10 +149,44 @@ public boolean shouldProceed(boolean red, boolean lastredstone){ return true;} + Future job; + ICraftingLink link; + int reqcooldown; + public void requestForMissing(IAEStack primitive){ + if(upgrade[1]==null)return; + if(reqcooldown>0)reqcooldown--; + IAEItemStack iaeStack=(primitive instanceof IAEItemStack)?(IAEItemStack) primitive: + ItemFluidDrop.newAeStack((AEFluidStack) primitive); + + try { + if(link==null){ + if(job==null){ + reqcooldown=40; + job=getProxy().getCrafting().beginCraftingJob(this.getTile().getWorldObj(), getProxy().getGrid(), source, iaeStack, null); + } + else{ + if(job.isDone()){ + link = getProxy().getCrafting().submitJob(job.get(), this, null, false, source); + job=null;} + if(job.isCancelled()){job=null;} + } + }else{ + if(link.isCanceled()||link.isDone()){link=null;} + + } + + + } catch (Exception e1) {} + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) @Override public TickRateModulation tickingRequest(IGridNode node, int TicksSinceLastCall) { + + // validateLink(); + if(upgrade[0]==null)rsmode=0; boolean red=this.getHost().hasRedstone(this.getSide()); boolean should=shouldProceed(red,lastredstone); @@ -198,6 +242,8 @@ public TickRateModulation tickingRequest(IGridNode node, int TicksSinceLastCall) sc:if(amount0)requestForMissing(is.copy().setStackSize(missing)); if(take==null){break sc;}//ae2fc fluid inv disallow injecting null IAEStack notadd =inv.injectItems( take, Actionable.SIMULATE, source); if(notadd==null||notadd.getStackSize()==0){ @@ -532,6 +578,7 @@ public int getSlotLimit(int slot) { } .setPos(60, 3+20).addTooltip(StatCollector.translateToLocal("proghatches.amountmaintainer.rscard"))); + builder.widget(new CycleButtonWidget().setGetter(()->rsmode) .setSetter(s->rsmode=s).setLength(6) .setTextureGetter(s->{ @@ -560,7 +607,23 @@ public int getSlotLimit(int slot) { .setEnabled((a)->(upgrade[0]!=null)) .setSize(18, 18) .setPos(60+20, 3+20)); - + + ItemStackHandler iss1=new ItemStackHandler(upgrade){ + + public boolean isItemValid(int slot, ItemStack stack) { + return Api.INSTANCE.definitions().materials().cardCrafting().isSameAs(stack); + + }; + public int getSlotLimit(int slot) { + return 1;}; + }; + + builder.widget( new SlotWidget(new BaseSlot(iss1, 1)){ + + + } + .setPos(60+40, 3+20).addTooltip(StatCollector.translateToLocal("proghatches.amountmaintainer.craftcard"))); + return builder.build(); @@ -602,7 +665,8 @@ public Boolean getSignal(){ } long freq; private BaseActionSource source=new MachineSource(this); - ItemStack[] upgrade=new ItemStack[1]; + ItemStack[] upgrade=new ItemStack[2]; + private boolean danglingLink; @Override public void readFromNBT(NBTTagCompound data) { @@ -614,7 +678,15 @@ public void readFromNBT(NBTTagCompound data) { lastredstone=data.getBoolean("lastredstone" ); mark[0]=ItemStack.loadItemStackFromNBT(data.getCompoundTag("mark")); upgrade[0]=ItemStack.loadItemStackFromNBT(data.getCompoundTag("upgrade")); + upgrade[1]=ItemStack.loadItemStackFromNBT(data.getCompoundTag("upgrade1")); super.readFromNBT(data); + NBTTagCompound tag=data.getCompoundTag("link"); + + if(tag.hasNoTags()==false){ + tag.setBoolean("req", true); + link=new CraftingLink(tag,this); + danglingLink=true; + } } @Override public void writeToNBT(NBTTagCompound data) { @@ -626,7 +698,13 @@ public void writeToNBT(NBTTagCompound data) { data.setBoolean("lastredstone", lastredstone); if(mark[0]!=null)data.setTag("mark", mark[0].writeToNBT(new NBTTagCompound())); if(upgrade[0]!=null)data.setTag("upgrade", upgrade[0].writeToNBT(new NBTTagCompound())); + if(upgrade[1]!=null)data.setTag("upgrade1", upgrade[1].writeToNBT(new NBTTagCompound())); super.writeToNBT(data); + if(link!=null){ + NBTTagCompound tag=new NBTTagCompound(); + link.writeToNBT(tag); + data.setTag("link", tag); + } } long amount=64; @@ -715,5 +793,57 @@ private IMEMonitor getStorage(IStorageGrid g,StorageChannel c){ public void getDrops(final List drops, final boolean wrenched) { if(upgrade[0]!=null) drops.add(upgrade[0]); + if(upgrade[1]!=null) + drops.add(upgrade[1]); } + + @Override + public ImmutableSet getRequestedJobs() { + + return link==null?ImmutableSet.of():ImmutableSet.of(link); + } + + @Override + public IAEItemStack injectCraftedItems(ICraftingLink link, IAEItemStack items, Actionable mode) { + + return items; + } + + @Override + public void jobStateChange(ICraftingLink link) { + + + } + +public void validateLink(){ + try { + if(link!=null) + if(danglingLink) + { + getProxy().getCrafting().getCpus().stream().filter(s->{ + if(s instanceof CraftingCPUCluster){ + CraftingCPUCluster c=(CraftingCPUCluster) s; + boolean b=c.isBusy(); + if(b){ + + if(Objects.equals(c.getLastCraftingLink().getCraftingID(),link.getCraftingID())){ + link=c.getLastCraftingLink(); + danglingLink=false; + return true; + } + } + } + return false; + }).findFirst().orElse(null); + } + + + } catch (GridAccessException e) { + + e.printStackTrace(); + } + + + +} } diff --git a/src/main/java/reobf/proghatches/ae/TileCyclicPatternSubmitter.java b/src/main/java/reobf/proghatches/ae/TileCyclicPatternSubmitter.java index efdfdd8..1ae5c37 100644 --- a/src/main/java/reobf/proghatches/ae/TileCyclicPatternSubmitter.java +++ b/src/main/java/reobf/proghatches/ae/TileCyclicPatternSubmitter.java @@ -17,6 +17,7 @@ import com.gtnewhorizons.modularui.api.ModularUITextures; import com.gtnewhorizons.modularui.api.drawable.IDrawable; import com.gtnewhorizons.modularui.api.drawable.ItemDrawable; +import com.gtnewhorizons.modularui.api.drawable.Text; import com.gtnewhorizons.modularui.api.drawable.UITexture; import com.gtnewhorizons.modularui.api.forge.IItemHandlerModifiable; import com.gtnewhorizons.modularui.api.forge.ItemStackHandler; @@ -26,6 +27,7 @@ import com.gtnewhorizons.modularui.common.internal.wrapper.BaseSlot; import com.gtnewhorizons.modularui.common.widget.ButtonWidget; import com.gtnewhorizons.modularui.common.widget.CycleButtonWidget; +import com.gtnewhorizons.modularui.common.widget.DynamicTextWidget; import com.gtnewhorizons.modularui.common.widget.FakeSyncWidget; import com.gtnewhorizons.modularui.common.widget.FluidSlotWidget; import com.gtnewhorizons.modularui.common.widget.Scrollable; @@ -50,6 +52,7 @@ import appeng.api.util.DimensionalCoord; import appeng.core.Api; import appeng.crafting.CraftingLink; +import appeng.crafting.CraftingLinkNexus; import appeng.me.GridAccessException; import appeng.me.cluster.implementations.CraftingCPUCluster; import appeng.me.helpers.AENetworkProxy; @@ -77,6 +80,10 @@ import reobf.proghatches.util.ProghatchesUtil; +/** + * @author zyf + * + */ public class TileCyclicPatternSubmitter extends TileEntity implements IGridProxyable, ICraftingRequester, ITileWithModularUI{ public static final int ALL = 0; public static final int DIM = 1; @@ -191,8 +198,8 @@ public void readFromNBT(NBTTagCompound compound) { NBTTagCompound tag=compound.getCompoundTag("link"); if(tag.hasNoTags()==false){ - - last=new CraftingLink(tag, (ICraftingCPU)null);//work-around + tag.setBoolean("req", true); + last=new CraftingLink(tag, this); danglingLink=true; } for(int i=0;i{ - if(s instanceof CraftingCPUCluster){ - CraftingCPUCluster c=(CraftingCPUCluster) s; - boolean b=c.isBusy(); - if(b){ - - if(c.getLastCraftingLink()==cid){ - - return true; - } - } - } - return false; - }).findFirst().orElse(null); + end:if(broken==false) + try { + CraftingLinkNexus nex=(CraftingLinkNexus) nexus.get(cid); + if(nex==null)break end; + ICraftingLink other=(ICraftingLink) cpuside.get(nex); + if(other==null)break end; + ICraftingCPU ret=(ICraftingCPU) cpu.get(other); + if(ret instanceof CraftingCPUCluster){return (CraftingCPUCluster) ret;} + } catch (Exception e) { + broken=true; + e.printStackTrace(); + } - //not found? try checking CraftingID this might happen when game save/load + CraftingCPUCluster found=null; if(found==null){ found=(CraftingCPUCluster) getProxy().getCrafting().getCpus().stream().filter(s->{ if(s instanceof CraftingCPUCluster){ @@ -367,9 +391,8 @@ public CraftingCPUCluster getCpu(ICraftingLink cid){ if(b){ if(Objects.equals(c.getLastCraftingLink().getCraftingID(),(cid).getCraftingID())){ - last=c.getLastCraftingLink(); - //update last to real link - danglingLink=false; + //last=c.getLastCraftingLink(); + return true; } @@ -510,6 +533,12 @@ public ModularWindow createWindow() { // IItemHandlerModifiable fakeInv=new ItemHandlerModifiable(); protected void addUIWidgets(ModularWindow.Builder builder) { + + builder.widget(new FakeSyncWidget.IntegerSyncer(()->state(), s->state=s)); + builder.widget( + new DynamicTextWidget(()->new Text(StatCollector.translateToLocal("proghatches.submitter.state."+state))) + .setSynced(false) + .setPos(5, 3)); final IItemHandlerModifiable inventoryHandler = new MappingItemHandler(inv, 0, inv.length){ public boolean isItemValid(int slot, ItemStack stack) { return stack.getItem() instanceof ICraftingPatternItem; diff --git a/src/main/java/reobf/proghatches/block/TileIOHub.java b/src/main/java/reobf/proghatches/block/TileIOHub.java index 9750532..8814c9f 100644 --- a/src/main/java/reobf/proghatches/block/TileIOHub.java +++ b/src/main/java/reobf/proghatches/block/TileIOHub.java @@ -93,13 +93,14 @@ import li.cil.oc.api.network.Connector; import li.cil.oc.api.network.Message; import li.cil.oc.api.network.Node; +import li.cil.oc.api.network.SidedEnvironment; import li.cil.oc.api.network.Visibility; import li.cil.oc.api.internal.Database; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.tileentity.TileEntity; import net.minecraft.util.AxisAlignedBB; -public class TileIOHub extends TileEntity implements li.cil.oc.api.network.Environment, +public class TileIOHub extends TileEntity implements li.cil.oc.api.network.Environment,SidedEnvironment, /* * WorldInventoryAnalytics,WorldTankAnalytics, * WorldFluidContainerAnalytics, TankInventoryControl, @@ -1684,4 +1685,16 @@ public IGridNode getActionableNode() { return getProxy().getNode(); } + @Override + public Node sidedNode(ForgeDirection side) { + + return null; + } + + @Override + public boolean canConnect(ForgeDirection side) { + + return false; + } + } diff --git a/src/main/java/reobf/proghatches/eucrafting/PartEUSource.java b/src/main/java/reobf/proghatches/eucrafting/PartEUSource.java index cf73404..2be4025 100644 --- a/src/main/java/reobf/proghatches/eucrafting/PartEUSource.java +++ b/src/main/java/reobf/proghatches/eucrafting/PartEUSource.java @@ -75,6 +75,7 @@ import net.minecraft.client.renderer.texture.IIconRegister; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.init.Items; import net.minecraft.inventory.IInventory; import net.minecraft.inventory.InventoryCrafting; import net.minecraft.item.ItemStack; @@ -574,8 +575,30 @@ public ModularWindow createWindow(UIBuildContext buildContext) { return builder.build(); } + + static Field fis; + static{ + try { + fis= AEBasePart.class.getDeclaredField("is"); + fis.setAccessible(true); + } catch (NoSuchFieldException | SecurityException e) { + + e.printStackTrace(); + } + + } + public ItemStack getIS(){ + try { + return (ItemStack) fis.get(this); + } catch (IllegalArgumentException | IllegalAccessException e) { + e.printStackTrace(); + return new ItemStack(Items.apple); + } + + + } public long maxWorkingVoltage(){ - int damage=this.is.getItemDamage(); + int damage=this.getIS().getItemDamage(); if(damage>=1&&damage<=15){ return GT_Values.V[damage-1]; } @@ -585,7 +608,7 @@ public long maxWorkingVoltage(){ return Long.MAX_VALUE; } public int maxWorkingVoltageTier(){ - int damage=this.is.getItemDamage(); + int damage=this.getIS().getItemDamage(); if(damage>=1&&damage<=15){ return damage-1; } @@ -595,7 +618,7 @@ public int maxWorkingVoltageTier(){ return 15; } public double taxPercentage(){ - int damage=this.is.getItemDamage(); + int damage=this.getIS().getItemDamage(); if(damage>=16&&damage<=30){ return 0.95d; } diff --git a/src/main/java/reobf/proghatches/eucrafting/PartLazerP2P.java b/src/main/java/reobf/proghatches/eucrafting/PartLazerP2P.java index 64671fa..164d5fd 100644 --- a/src/main/java/reobf/proghatches/eucrafting/PartLazerP2P.java +++ b/src/main/java/reobf/proghatches/eucrafting/PartLazerP2P.java @@ -39,6 +39,7 @@ import net.minecraft.tileentity.TileEntity; import net.minecraft.util.IIcon; import net.minecraftforge.common.util.ForgeDirection; +import reobf.proghatches.main.Config; public class PartLazerP2P ) new ObjectInputStream(bi).readObject(); + + } catch (Exception e) { + e.printStackTrace(); + } + idcounter.set(aNBT.getInteger("idcounter")); + } + private void updateValidGridProxySides() { + + + getProxy().setValidSides(EnumSet.of(getBaseMetaTileEntity().getFrontFacing())); + + } + AENetworkProxy gridProxy; + @Override + public IGridNode getGridNode(ForgeDirection dir) { + return getProxy().getNode();} + + + @Override + public AENetworkProxy getProxy() { + + if (gridProxy == null) { + gridProxy = new AENetworkProxy(this, "proxy", + new ItemStack(GregTech_API.sBlockMachines, 1, this.getBaseMetaTileEntity().getMetaTileID()), true); + gridProxy.setFlags(GridFlags.REQUIRE_CHANNEL); + updateValidGridProxySides(); + if (getBaseMetaTileEntity().getWorld() != null) + gridProxy.setOwner(getBaseMetaTileEntity().getWorld() + .getPlayerEntityByName(getBaseMetaTileEntity().getOwnerName())); + } + + return this.gridProxy; + } + + + @Override + public void securityBreak() { + + + } + + + @Override + public DimensionalCoord getLocation() { + + return new DimensionalCoord((TileEntity)this.getBaseMetaTileEntity()); + } + @Override + public void onFirstTick(IGregTechTileEntity aBaseMetaTileEntity) { + super.onFirstTick(aBaseMetaTileEntity); + getProxy().onReady(); + if (node != null) { + li.cil.oc.api.Network.joinOrCreateNetwork((TileEntity)this.getBaseMetaTileEntity()); + } + } + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + + super.onPostTick(aBaseMetaTileEntity, aTick); + //item.injectItems(AEItemStack.create(new ItemStack(Items.apple)), Actionable.MODULATE, source); + //fluid.injectItems(AEFluidStack.create(new FluidStack(FluidRegistry.WATER,1)), Actionable.MODULATE, source); + tasks.forEach(s->s.update(node())); + + } + @Override + public void onFacingChange() { + updateValidGridProxySides(); + } + + /*public Object[] help(final Context context, final Arguments args) { + if(args.checkString(0).equals("type")){ + return new Object[]{ + "\"now\": Execute task the next world update." + +"\"never\": Just add task, do nothing. Call executeTask to execute it." + +"\"blocking\": Exexute if inventory is empty." + + }; + + } + + return new Object[]{}; + } + */ + + + public static class AEStackHolder implements Externalizable{ + public AEStackHolder(IAEStack stack){this.stack=stack;} + IAEStack stack; + public AEStackHolder(){} + @Override + public void writeExternal(ObjectOutput out) throws IOException { + NBTTagCompound tag =new NBTTagCompound(); + stack.writeToNBT(tag); + byte[] b=CompressedStreamTools.compress(tag); + out.write(b.length); + out.write(b); + out.write(stack instanceof AEItemStack?1:0); + } + + @Override + public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { + byte b[]=new byte[in.readInt()]; + if(in.available()!=b.length){throw new IOException();} + in.readFully(b); + NBTTagCompound tag = CompressedStreamTools.func_152457_a(b, new NBTSizeTracker(Long.MAX_VALUE)); + IAEStack ch= + in.readInt()==1?AEItemStack.loadItemStackFromNBT(tag):AEFluidStack.loadFluidStackFromNBT(tag); + stack=ch; + } + } + public static class TargetStack implements Serializable{ + + private static final long serialVersionUID = -6805372705502580992L; + String addr; + int index; + boolean itemtype;//false->item true->fluid + int amount; + AEStackHolder item; + + public void validate(Node n,Task task){ + if(task.state==0) + { + Node data=n.network().node(addr); + if(data==null){ + task.state=2;return; + } + if(data.host() instanceof UpgradeDatabase){ + + UpgradeDatabase base=(UpgradeDatabase) data.host(); + if(index<0||index>=base.size()){ task.state=3;return;} + ItemStack is=base.getStackInSlot(index); + if(is==null){ + task.state=3;return; + } + + if(itemtype){ + + FluidStack fs = GT_Utility.getFluidForFilledItem(is, true); + if(fs==null){ + task.state=4;return; + } + item=new AEStackHolder(AEFluidStack.create(fs)); + + }else{ + item=new AEStackHolder(AEItemStack.create(is)); + } + item.stack.setStackSize(amount); + task.state=1;return; + + + + }else{ + task.state=2;return; + } + + + } + + + } + + } + public static class Task implements Serializable{ + + private static final long serialVersionUID = 4868145313081267898L; + int id; + + TargetStack item; + //0->submitted + //1->validated + //2->data base missing + //3->item invalid + //4->item not fluid + //5->cancelled + //6->executed + //7->not enough materials + //8->me access unavailable + //9->partial executed + //10-> + + //1x->failed to execute due to x + int state; + + //0->never + //1->empty + //int mode; + + + //int idcount; + + public Task(String addr,int index,int amount,boolean itemtype,int id){ + TargetStack ts= new TargetStack(); + ts.addr=addr; + ts.index=index; + ts.itemtype=itemtype; + ts.amount=amount; + item=ts; + this.id=id; + } + + void update(Node n){ + if(state==0)item.validate(n, this); + } + @SuppressWarnings("unchecked") + void submit(IMEInventory f,IMEInventory i,AENetworkProxy storage,BaseActionSource source){ + if(state!=1)return; + if(item==null)return; + try { + IStorageGrid st = storage.getStorage(); + IMEInventory src= + item.itemtype? + st.getFluidInventory():st.getItemInventory(); + IMEInventory dest=item.itemtype?f:i; + + IAEStack sim = src.extractItems(item.item.stack, Actionable.SIMULATE, source); + if(sim==null||sim.getStackSize()!=item.item.stack.getStackSize()){ + state=7; + return; + } + + IAEStack ext = src.extractItems(item.item.stack, Actionable.MODULATE, source); + if(ext==null){ + state=7; + return;} + boolean same=ext.getStackSize()==item.item.stack.getStackSize(); + IAEStack remain = dest.injectItems(ext, Actionable.MODULATE, source); + if(remain!=null){ + src.injectItems(remain, Actionable.MODULATE, source); + state=9; + return; + } + if(!same){ + state=9; + return; + } + + + } catch (GridAccessException e) { + state=8;return; + } + + + + state=6; + } + + + + public String state() { + switch (state) { + case 0:return "added"; + case 1:return "ready to submit"; + case 2:return "data base missing"; + case 3:return "item invalid"; + case 4:return "item is not fluid container"; + case 5:return "cancelled"; + case 6:return "executed"; + case 7:return "me storage not sufficient"; + case 8:return "me network disconnected"; + case 9:return "partially executed"; + } + return "error"; + } + + + + } + + + + + + + + + @Callback(doc = "function(data:address,index:number,amount:number[,isFluid:boolean]):table -- Append a task of extracting materials from ME Storage into the hatch. Call submitTask to submit the task. This function returns instantly." + + ,direct=true) + public Object[] addTask(final Context context, final Arguments args) { + try{ + Task task=new Task(args.checkString(0), args.checkInteger(1), args.checkInteger(2), args.optBoolean(3,false), idcounter.addAndGet(1)); + tasks.add(task); + + TreeMap map=new TreeMap<>(); + map.put("id", task.id); + map.put("state","added"); + + return new Object[]{map}; + }catch(Exception e){e.printStackTrace();return new Object[0];} + } + + @Callback(doc = "function(taskID:number):table -- Cancel the task. This function returns instantly.",direct=true) + public Object[] cancelTask(final Context context, final Arguments args) { + try{TreeMap map=new TreeMap<>(); + Task task=null; + synchronized (tasks){ + for(Iterator itr = tasks.iterator();itr.hasNext();){ + Task task0=itr.next(); + if(task0.id==args.checkInteger(0)){ + itr.remove(); + task=task0;break; + } + + } + } + + if(task!=null){ + map.put("id", task.id); + map.put("state","cancelled"); + } + + return new Object[]{map}; + }catch(Exception e){e.printStackTrace();return new Object[0];} + } + + @Callback(doc = "function(taskID:number):table -- Get the state of task. This function returns instantly.",direct=true) + public Object[] state(final Context context, final Arguments args) { + try{ + TreeMap map=new TreeMap<>(); + Task task=null; + synchronized (tasks){ + for(Iterator itr = tasks.iterator();itr.hasNext();){ + Task task0=itr.next(); + if(task0.id==args.checkInteger(0)){ + + task=task0;break; + } + + } + } + + if(task!=null){ + map.put("id", task.id); + map.put("state",task.state()); + } + + return new Object[]{map}; + }catch(Exception e){e.printStackTrace();return new Object[0];} + } + + + + @Callback(doc = "function():table -- Submit all tasks added via addTask. Return an array of state of those tasks. This function blocks until world update, then execute ALL added tasks in one tick.") + public Object[] submitTask(final Context context, final Arguments args) { + try{ + ArrayList arr=new ArrayList<>(); + synchronized (tasks){ + while(tasks.isEmpty()==false){ + + Task t=tasks.remove(0); + t.update(node()); + t.submit(fluid, item, getProxy(), source); + TreeMap map=new TreeMap<>(); + map.put("id", t.id); + map.put("state",t.state()); + arr.add(map); + } + + } + + + + return new Object[]{arr}; + + }catch(Exception e){e.printStackTrace();return new Object[0];} + + } + @Callback(doc = "function(data:address,index:number,amount:number[,isFluid:boolean]):table -- Exexute the task. This function blocks until world update.") + public Object[] executeTask(final Context context, final Arguments args) { + Task task=new Task(args.checkString(0), args.checkInteger(1), args.checkInteger(2), args.optBoolean(3,false), idcounter.addAndGet(1)); + task.update(node()); + task.submit(fluid, item, getProxy(), source); + TreeMap map=new TreeMap<>(); + map.put("id", task.id); + map.put("state",task.state()); + return new Object[]{map}; + } + + + + + + + + +AtomicInteger idcounter=new AtomicInteger(0); +@SuppressWarnings("unchecked") +List tasks=(List) Collections.synchronizedList(new ArrayList()); +private BaseActionSource source=new MachineSource(this); + +@Override +public int fill(ForgeDirection from, FluidStack resource, boolean doFill) { + // TODO Auto-generated method stub + return super.fill(from, resource, doFill); +} +@Override +public IGridNode getActionableNode() { + + return getProxy().getNode(); +} +MEIInventoryWrapper item=new MEIInventoryWrapper(this, new AdaptorIInventory(this,Integer.MAX_VALUE)); +MEMonitorIFluidHandler fluid=new MEMonitorIFluidHandler(this); + + +@Callback(doc = "function():boolean -- Return if the hatch is empty.") +public Object[] isEmpty(final Context context, final Arguments args) { + return new Object[]{!this.getFirstNonEmptyInventory().isPresent()}; +} +@Callback(doc = "function():boolean -- Refund all materials back to ME Storage. Return if all materials are transfered.") +public Object[] refund(final Context context, final Arguments args) { + boolean leftsomething=false; + try { + Optional inv = this.getFirstNonEmptyInventory(); + if(inv.isPresent()==false)return new Object[0]; + IMEMonitor sg = getProxy().getStorage().getItemInventory(); + IMEMonitor fsg = getProxy().getStorage().getFluidInventory(); + for (ItemStack itemStack : inv.get().getItemInputs()) { + if (itemStack == null || itemStack.stackSize == 0) + continue; + IAEItemStack rest = Platform.poweredInsert(getProxy().getEnergy(), sg, + AEApi.instance().storage().createItemStack(itemStack), source); + itemStack.stackSize = rest != null && rest.getStackSize() > 0 ? (int) rest.getStackSize() : 0; + if(itemStack.stackSize>0)leftsomething=true; + } + + for (FluidStack fluidStack : inv.get().getFluidInputs()) { + if (fluidStack == null || fluidStack.amount == 0) + continue; + IAEFluidStack rest = Platform.poweredInsert(getProxy().getEnergy(), fsg, + AEApi.instance().storage().createFluidStack(fluidStack), source); + fluidStack.amount=(Optional.ofNullable(rest).map(s->s.getStackSize()).orElse(0L)).intValue(); + if(fluidStack.amount>0)leftsomething=true; + } + ; + updateSlots(); + } catch (Exception e) { + throw new RuntimeException(e); + } + return new Object[]{!leftsomething}; +} + +@Override +public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection aFacing, + int colorIndex, boolean aActive, boolean redstoneLevel) { + int texturePointer = (byte) (getUpdateData() & 0x7F); + +int textureIndex = texturePointer | (getTexturePage() << 7); + + Block b=/*Blocks.cactus;*/GameRegistry.findBlock("OpenComputers", "raid"); + ITexture tex = TextureFactory.of(b,0,ForgeDirection.UP); + + if (textureIndex > 0){ + + tex= Textures.BlockIcons.casingTexturePages[getTexturePage()][texturePointer] ; + + } + if(side==aFacing){ + return new ITexture[]{tex,TextureFactory.of(BlockIcons.OVERLAY_ME_CRAFTING_INPUT_BUFFER)}; + } + return new ITexture[]{tex}; + + + +} + +} diff --git a/src/main/java/reobf/proghatches/gt/metatileentity/PatternDualInputHatch.java b/src/main/java/reobf/proghatches/gt/metatileentity/PatternDualInputHatch.java index 73553cf..571bc1e 100644 --- a/src/main/java/reobf/proghatches/gt/metatileentity/PatternDualInputHatch.java +++ b/src/main/java/reobf/proghatches/gt/metatileentity/PatternDualInputHatch.java @@ -78,10 +78,17 @@ import gregtech.common.tileentities.casings.upgrade.Inventory; import gregtech.common.tileentities.machines.GT_MetaTileEntity_Hatch_CraftingInput_ME; import gregtech.common.tileentities.machines.GT_MetaTileEntity_Hatch_InputBus_ME; +import li.cil.oc.api.network.Environment; +import li.cil.oc.api.network.Message; +import li.cil.oc.api.network.Node; +import li.cil.oc.api.network.SidedEnvironment; +import li.cil.oc.api.network.Visibility; public class PatternDualInputHatch extends BufferedDualInputHatch - implements ICraftingProvider, IGridProxyable, ICustomNameObject, IInterfaceViewable, IPowerChannelState, IActionHost { + implements ICraftingProvider, IGridProxyable, ICustomNameObject, IInterfaceViewable, IPowerChannelState, IActionHost + + { public PatternDualInputHatch(String mName, byte mTier, String[] mDescriptionArray, ITexture[][][] mTextures, boolean mMultiFluid, int bufferNum) { @@ -872,4 +879,11 @@ public boolean allowsPatternOptimization() { // TODO Auto-generated method stub return IInterfaceViewable.super.allowsPatternOptimization(); } + + + + + + + } diff --git a/src/main/java/reobf/proghatches/main/CommonProxy.java b/src/main/java/reobf/proghatches/main/CommonProxy.java index 8c45427..57578c0 100644 --- a/src/main/java/reobf/proghatches/main/CommonProxy.java +++ b/src/main/java/reobf/proghatches/main/CommonProxy.java @@ -44,6 +44,7 @@ import reobf.proghatches.main.registration.ProgHatchCreativeTab; import reobf.proghatches.main.registration.Registration; import reobf.proghatches.oc.ItemAPICard; +import reobf.proghatches.oc.ItemCPU; import reobf.proghatches.oc.ItemGTRedstoneCard; import reobf.proghatches.oc.ItemWirelessPeripheralCard; import reobf.proghatches.oc.TileCoprocessor; @@ -113,7 +114,8 @@ public void preInit(FMLPreInitializationEvent event) { MyMod.upgrades = new ItemUpgrades().setUnlocalizedName("prog_upgrades").setTextureName("?"), "prog_upgrades"); - + GameRegistry.registerItem(MyMod.cpu = new ItemCPU().setUnlocalizedName("test_cpu").setTextureName("?"), + "test_cpu"); @@ -127,6 +129,8 @@ public void preInit(FMLPreInitializationEvent event) { li.cil.oc.server.driver.Registry.add((li.cil.oc.api.driver.Item) MyMod.oc_redstone); li.cil.oc.server.driver.Registry.add((li.cil.oc.api.driver.Item) MyMod.oc_api); li.cil.oc.server.driver.Registry.add((li.cil.oc.api.driver.Item) MyMod.pitem); + li.cil.oc.server.driver.Registry.add((li.cil.oc.api.driver.Item) MyMod.cpu); + GT_ModHandler.addToRecyclerBlackList(new ItemStack(MyMod.progcircuit)); FMLInterModComms.sendMessage("Waila", "register", "reobf.proghatches.main.CommonProxy.callbackRegister"); //System.out.println(AEConfig.instance); diff --git a/src/main/java/reobf/proghatches/main/Config.java b/src/main/java/reobf/proghatches/main/Config.java index f15e8ba..c7bd895 100644 --- a/src/main/java/reobf/proghatches/main/Config.java +++ b/src/main/java/reobf/proghatches/main/Config.java @@ -273,6 +273,7 @@ public static String[] get(String key, Map fmtter, boolean defau .getResourceAsStream("/assets/proghatches/lang/en_US/" + s + ".lang"); static Function getInput = s -> Config.class.getResourceAsStream("/assets/proghatches/lang/" + LangManager.translateToLocal("programmable_hatches.gt.lang.dir") + "/" + s + ".lang"); + public static boolean recursiveLazer=false; diff --git a/src/main/java/reobf/proghatches/main/MyMod.java b/src/main/java/reobf/proghatches/main/MyMod.java index 48ce7dc..d21b872 100644 --- a/src/main/java/reobf/proghatches/main/MyMod.java +++ b/src/main/java/reobf/proghatches/main/MyMod.java @@ -142,7 +142,7 @@ public class MyMod { public static final Logger LOG = LogManager.getLogger(Tags.MODID); public static MyMod instance; - { + {FluidConvertingInventoryAdaptor.class.getDeclaredFields(); instance = this;} static{ @@ -199,6 +199,7 @@ class test extends Item{@Override public int getItemStackLimit() {return 0;}} public static Block alert; public static Item amountmaintainer; public static Block submitter; + public static Item cpu; @Mod.EventHandler // preInit "Run before anything else. Read your config, create blocks, @@ -219,7 +220,7 @@ public void preInit(FMLPreInitializationEvent event) { public void init(FMLInitializationEvent event) { proxy.init(event); AEApi.instance().partHelper().registerNewLayer("reobf.proghatches.fmp.LazerLayer", "reobf.proghatches.eucrafting.ILazer"); - + FMLCommonHandler.instance().bus().register(this); MinecraftForge.EVENT_BUS.register(this); } diff --git a/src/main/java/reobf/proghatches/main/mixin/MixinPlugin.java b/src/main/java/reobf/proghatches/main/mixin/MixinPlugin.java index 0d59948..3ba089c 100644 --- a/src/main/java/reobf/proghatches/main/mixin/MixinPlugin.java +++ b/src/main/java/reobf/proghatches/main/mixin/MixinPlugin.java @@ -181,6 +181,7 @@ public List getMixins() { retLate.add("MixinStorageChangeEvent"); retLate.add("MixinOptimize"); retLate.add("part2.MixinIsWailaCall"); + retLate.add("part2.MixinOC"); if (FMLLaunchHandler.side().isClient()) { if (!"true".equals(pp.get("noAEItemSortMixins"))) if(ff)retLate.add("MixinAEItemStackCompare"); diff --git a/src/main/java/reobf/proghatches/main/mixin/mixins/MixinAE2FCCompat.java b/src/main/java/reobf/proghatches/main/mixin/mixins/MixinAE2FCCompat.java index c3bfcfc..e005e54 100644 --- a/src/main/java/reobf/proghatches/main/mixin/mixins/MixinAE2FCCompat.java +++ b/src/main/java/reobf/proghatches/main/mixin/mixins/MixinAE2FCCompat.java @@ -6,6 +6,7 @@ import org.spongepowered.asm.mixin.injection.At; import org.spongepowered.asm.mixin.injection.Inject; import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; +import org.spongepowered.asm.mixin.injection.callback.LocalCapture; import com.glodblock.github.inventory.FluidConvertingInventoryAdaptor; import com.glodblock.github.util.BlockPos; @@ -23,28 +24,37 @@ @Mixin(FluidConvertingInventoryAdaptor.class) public class MixinAE2FCCompat { + + /* @Inject(method = "wrap", remap = false, at = { @At("HEAD") }, cancellable = true) private static void wrap(TileEntity capProvider, ForgeDirection face, CallbackInfoReturnable ret) { + */ + + @Inject(method = "wrap", remap = false, at = { @At(value="INVOKE_ASSIGN",target="getTileEntity") }, + locals=LocalCapture.CAPTURE_FAILHARD, + cancellable = true) + private static void wrap(TileEntity capProvider, ForgeDirection face, + CallbackInfoReturnable ret, TileEntity inter) { + + + if (face == ForgeDirection.UNKNOWN) { return; } - boolean iscover = (check(capProvider, face)); + boolean iscover = check(capProvider, face); boolean ispart = false; if (iscover == false) { - TileEntity inter = capProvider.getWorldObj().getTileEntity(capProvider.xCoord + face.offsetX, + /* TileEntity inter = capProvider.getWorldObj().getTileEntity(capProvider.xCoord + face.offsetX, capProvider.yCoord + face.offsetY, capProvider.zCoord + face.offsetZ); + */ ispart = Util.getPart(inter, face.getOpposite()) instanceof PartEUP2PInterface; } - /* - * System.out.println(inter); - */ - // System.out.println(face); if (iscover || ispart) { - BlockPos pos = new BlockPos(capProvider.xCoord + face.offsetX, capProvider.yCoord + face.offsetY, - capProvider.zCoord + face.offsetZ); + BlockPos pos = /*new BlockPos(capProvider.xCoord + face.offsetX, capProvider.yCoord + face.offsetY, + capProvider.zCoord + face.offsetZ);*/new BlockPos(inter); InventoryAdaptor item = InventoryAdaptor.getAdaptor(capProvider, face); IFluidHandler fluid = capProvider instanceof IFluidHandler ? (IFluidHandler) capProvider : null; @@ -58,18 +68,24 @@ private static void wrap(TileEntity capProvider, ForgeDirection face, private static boolean check(TileEntity te, ForgeDirection face) { - // TileEntity te=b.world.getTileEntity(b.x, b.y, b.z); + if (te instanceof ICoverable) { ICoverable c = (ICoverable) te; - { - + ISerializableObject data = c.getComplexCoverDataAtSide(face); + if(data instanceof AECover.Data){ + return ((AECover.Data) data).supportFluid(); + } + + /* Optional op = Optional.ofNullable(c.getComplexCoverDataAtSide(face)); - // System.out.println(op); System.out.println(face); + return op.filter(s -> (s instanceof AECover.Data) && ((AECover.Data) s).supportFluid()) .isPresent(); - - } + */ + + + } return false; diff --git a/src/main/java/reobf/proghatches/main/mixin/mixins/part2/MixinOC.java b/src/main/java/reobf/proghatches/main/mixin/mixins/part2/MixinOC.java new file mode 100644 index 0000000..3502984 --- /dev/null +++ b/src/main/java/reobf/proghatches/main/mixin/mixins/part2/MixinOC.java @@ -0,0 +1,61 @@ +package reobf.proghatches.main.mixin.mixins.part2; + +import org.spongepowered.asm.mixin.Mixin; + +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.metatileentity.BaseMetaTileEntity; +import gregtech.api.metatileentity.CommonMetaTileEntity; +import li.cil.oc.api.network.Environment; +import li.cil.oc.api.network.Message; +import li.cil.oc.api.network.Node; +import li.cil.oc.api.network.SidedEnvironment; + +import net.minecraftforge.common.util.ForgeDirection; + +@Mixin(value=BaseMetaTileEntity.class,remap=false) +public abstract class MixinOC extends CommonMetaTileEntity implements Environment,SidedEnvironment{ + + @Override + public Node sidedNode(ForgeDirection side) { + IMetaTileEntity mte = getMetaTileEntity(); + if(mte instanceof SidedEnvironment){return ((SidedEnvironment) mte).sidedNode(side);} + return null; + } + + @Override + public boolean canConnect(ForgeDirection side) { + IMetaTileEntity mte = getMetaTileEntity(); + if(mte instanceof SidedEnvironment){return ((SidedEnvironment) mte).canConnect(side);} + return false; + } + + @Override + public Node node() { + + IMetaTileEntity mte = getMetaTileEntity(); + if(mte instanceof Environment){return ((Environment) mte).node();} + return null; + } + + @Override + public void onConnect(Node node) { + IMetaTileEntity mte = getMetaTileEntity(); + if(mte instanceof Environment){ ((Environment) mte).onConnect(node);} + + + } + + @Override + public void onDisconnect(Node node) { + IMetaTileEntity mte = getMetaTileEntity(); + if(mte instanceof Environment){ ((Environment) mte).onDisconnect(node);} + } + + @Override + public void onMessage(Message message) { + IMetaTileEntity mte = getMetaTileEntity(); + if(mte instanceof Environment){ ((Environment) mte).onMessage(message);} + + } + +} diff --git a/src/main/java/reobf/proghatches/main/registration/Registration.java b/src/main/java/reobf/proghatches/main/registration/Registration.java index eb638b6..4cf169c 100644 --- a/src/main/java/reobf/proghatches/main/registration/Registration.java +++ b/src/main/java/reobf/proghatches/main/registration/Registration.java @@ -32,6 +32,7 @@ import reobf.proghatches.gt.cover.WirelessControlCover; import reobf.proghatches.gt.metatileentity.BufferedDualInputHatch; import reobf.proghatches.gt.metatileentity.DataHatchME; +import reobf.proghatches.gt.metatileentity.DualInputHachOC; import reobf.proghatches.gt.metatileentity.DualInputHatch; import reobf.proghatches.gt.metatileentity.DualInputHatchSlave; import reobf.proghatches.gt.metatileentity.FilterOutputBus; @@ -87,6 +88,9 @@ public class Registration implements Runnable { public static final int DataHatchMEOffset = 162; public static final int RestrictedHatchME = 163; public static final int RestrictedBusME=164; + public final static int DualInputHatchOCOffset = 165; + + @SuppressWarnings("deprecation") @Override public void run() { @@ -399,7 +403,13 @@ public void run() { LangManager.translateToLocalFormatted("fluid.input.bus.me.restriced.name") ); - + new DualInputHachOC( + Config.metaTileEntityOffset + DualInputHatchOCOffset, + "hatch.input.dual.oc", + LangManager.translateToLocalFormatted("hatch.input.dual.oc"), 10, true + + + ); /*for (int i = 0; i < 4; i++) { diff --git a/src/main/java/reobf/proghatches/oc/Arch.java b/src/main/java/reobf/proghatches/oc/Arch.java new file mode 100644 index 0000000..5b87cdd --- /dev/null +++ b/src/main/java/reobf/proghatches/oc/Arch.java @@ -0,0 +1,88 @@ +package reobf.proghatches.oc; + +import li.cil.oc.api.machine.Architecture; +import li.cil.oc.api.machine.ExecutionResult; +import li.cil.oc.api.machine.Machine; +import li.cil.oc.common.component.Screen; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +@Architecture.Name("?") +@Architecture.NoMemoryRequirements +public class Arch implements Architecture{ + private li.cil.oc.server.machine.Machine machine; + + public Arch(Machine machine) { + this.machine = (li.cil.oc.server.machine.Machine) machine; + } + @Override + public boolean isInitialized() { + + return true; + } + + @Override + public boolean recomputeMemory(Iterable components) { + + return true; + } + + @Override + public boolean initialize() { + + return true; + } + + @Override + public void close() { + + + } + + @Override + public void runSynchronized() { + + machine.node().network().nodes().forEach(s->{ + + if(s.host() instanceof li.cil.oc.common.component.Screen){ + + li.cil.oc.common.component.Screen sc=(Screen) s.host(); + sc.set(1, 1, "hello", false); + + + }; + + + + }); + } + + @Override + public ExecutionResult runThreaded(boolean isSynchronizedReturn) { + + return new li.cil.oc.api.machine.ExecutionResult.SynchronizedCall(); + } + + @Override + public void onSignal() { + + + } + + @Override + public void onConnect() { + + + } + + @Override + public void load(NBTTagCompound nbt) { + + } + + @Override + public void save(NBTTagCompound nbt) { + + + } + +} diff --git a/src/main/java/reobf/proghatches/oc/ItemCPU.java b/src/main/java/reobf/proghatches/oc/ItemCPU.java new file mode 100644 index 0000000..f8ccf27 --- /dev/null +++ b/src/main/java/reobf/proghatches/oc/ItemCPU.java @@ -0,0 +1,63 @@ +package reobf.proghatches.oc; + +import javafx.scene.shape.Arc; +import li.cil.oc.api.driver.item.Slot; +import li.cil.oc.api.machine.Architecture; +import li.cil.oc.api.network.EnvironmentHost; +import li.cil.oc.api.network.ManagedEnvironment; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; + +public class ItemCPU extends Item implements li.cil.oc.api.driver.item.HostAware, +li.cil.oc.api.driver.item.Processor{ + + @Override + public boolean worksWith(ItemStack stack) { + + return stack.getItem() instanceof ItemCPU; + } + + @Override + public ManagedEnvironment createEnvironment(ItemStack stack, EnvironmentHost host) { + + return null; + } + + @Override + public String slot(ItemStack stack) { + + return Slot.CPU; + } + + @Override + public int tier(ItemStack stack) { + + return 0; + } + + @Override + public NBTTagCompound dataTag(ItemStack stack) { + + return null; + } + + @Override + public int supportedComponents(ItemStack stack) { + + return 100; + } + + @Override + public Class architecture(ItemStack stack) { + + return Arch.class; + } + + @Override + public boolean worksWith(ItemStack stack, Class host) { + + return stack.getItem() instanceof ItemCPU; + } + +} diff --git a/src/main/resources/assets/proghatches/lang/en_US.lang b/src/main/resources/assets/proghatches/lang/en_US.lang index 7a6cd83..baac5a7 100644 --- a/src/main/resources/assets/proghatches/lang/en_US.lang +++ b/src/main/resources/assets/proghatches/lang/en_US.lang @@ -533,3 +533,8 @@ proghatches.amountmaintainer.rscard.mode.2=Redstone proghatches.amountmaintainer.rscard.mode.3=Redstone Inverted proghatches.amountmaintainer.rscard.mode.4=Rising Edge proghatches.amountmaintainer.rscard.mode.5=Falling Edge +proghatches.amountmaintainer.craftcard=Put Crafting Card to auto-request for missing material +proghatches.submitter.state.0=§3Idle +proghatches.submitter.state.1=§cFailed +proghatches.submitter.state.2=§aSubmitted +hatch.input.dual.oc=Programmable Dual Input Hub(ME) diff --git a/src/main/resources/assets/proghatches/lang/en_US/DIHOC.lang b/src/main/resources/assets/proghatches/lang/en_US/DIHOC.lang new file mode 100644 index 0000000..a87a7ed --- /dev/null +++ b/src/main/resources/assets/proghatches/lang/en_US/DIHOC.lang @@ -0,0 +1,2 @@ +Item/Fluid Input for Multiblocks +Use OC Computer to precisely transfer Item and Fluid from ME Network to this Hatch. \ No newline at end of file diff --git a/src/main/resources/assets/proghatches/lang/zh_CN.lang b/src/main/resources/assets/proghatches/lang/zh_CN.lang index a70cd30..479b765 100644 --- a/src/main/resources/assets/proghatches/lang/zh_CN.lang +++ b/src/main/resources/assets/proghatches/lang/zh_CN.lang @@ -533,3 +533,8 @@ proghatches.amountmaintainer.rscard.mode.2=根据红石信号 proghatches.amountmaintainer.rscard.mode.3=反转红石信号 proghatches.amountmaintainer.rscard.mode.4=上升沿 proghatches.amountmaintainer.rscard.mode.5=下降沿 +proghatches.amountmaintainer.craftcard=放入合成卡自动合成补齐缺失材料 +proghatches.submitter.state.0=§3空闲 +proghatches.submitter.state.1=§c失败 +proghatches.submitter.state.2=§a已提交 +hatch.input.dual.oc=可编程二合一输入枢纽(ME) diff --git a/src/main/resources/assets/proghatches/lang/zh_CN/DIHOC.lang b/src/main/resources/assets/proghatches/lang/zh_CN/DIHOC.lang new file mode 100644 index 0000000..2ed9aea --- /dev/null +++ b/src/main/resources/assets/proghatches/lang/zh_CN/DIHOC.lang @@ -0,0 +1,2 @@ +多方块机器的物品/流体输入 +使用OC计算机精确转移物品/流体 \ No newline at end of file