diff --git a/build.gradle b/build.gradle index cf41012..d1f5825 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.18p24' +String versionOverride = '0.0.18p25' 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/gt/metatileentity/BufferedDualInputHatch.java b/src/main/java/reobf/proghatches/gt/metatileentity/BufferedDualInputHatch.java index 5341a3a..7e480c0 100644 --- a/src/main/java/reobf/proghatches/gt/metatileentity/BufferedDualInputHatch.java +++ b/src/main/java/reobf/proghatches/gt/metatileentity/BufferedDualInputHatch.java @@ -521,7 +521,7 @@ private void programLocal() { } - public void classify(ListeningFluidTank[] fin, ItemStack[] iin) { + public boolean classify(ListeningFluidTank[] fin, ItemStack[] iin,boolean removeInputOnSuccess) { boolean hasJob = false; for (int ix = 0; ix < f; ix++) { @@ -530,10 +530,10 @@ public void classify(ListeningFluidTank[] fin, ItemStack[] iin) { } if (fluidEquals(mStoredFluidInternalSingle[ix], fin[ix])) { if((fin[ix].getFluidAmount()>0&&mStoredFluidInternal[ix].getFluidAmount()>0)&&!fluidEqualsIngoreAmount(mStoredFluidInternal[ix], fin[ix])){ - return; + return false; } } else { - return; + return false; } } @@ -543,20 +543,21 @@ public void classify(ListeningFluidTank[] fin, ItemStack[] iin) { } if (ItemStack.areItemStacksEqual(mStoredItemInternalSingle[ix], iin[ix])) { if((iin[ix]!=null&&mStoredItemInternal[ix]!=null)&&!areItemStacksEqualIngoreAmount(mStoredItemInternal[ix], iin[ix])){ - return; + return false; } } else { - return; + return false; } } if (!hasJob) { - return; + return false; } for (int ix = 0; ix < f; ix++) { mStoredFluidInternal[ix].fill(mStoredFluidInternalSingle[ix].getFluid(), true); - fin[ix].setFluidDirect(null); + if(removeInputOnSuccess)fin[ix].setFluidDirect(null);else + if(fin[ix].getFluid()!=null)fin[ix].setFluidDirect(fin[ix].getFluid().copy()); } for (int ix = 0; ix < i; ix++) { @@ -565,14 +566,15 @@ public void classify(ListeningFluidTank[] fin, ItemStack[] iin) { mStoredItemInternal[ix] = mStoredItemInternalSingle[ix].copy(); else mStoredItemInternal[ix].stackSize += mStoredItemInternalSingle[ix].stackSize; - iin[ix] = null; + if(removeInputOnSuccess)iin[ix] = null;else + if(iin[ix]!=null)iin[ix]=iin[ix].copy(); } tickFirstClassify=-1;//make it instantly accessible markJustHadNewItems(); onClassify(); if (program) programLocal(); - + return true; } public boolean recordRecipeOrClassify(ListeningFluidTank[] fin, ItemStack[] iin) { @@ -628,6 +630,35 @@ public FluidStack[] getFluidInputs() { return asFluidStack.apply(mStoredFluidInternal,shared.getFluid()); } + public int space() { + int ret=Integer.MAX_VALUE; + boolean found=false; + for (int ix = 0; ix < i; ix++) { + + if(mStoredItemInternalSingle[ix]!=null&&mStoredItemInternalSingle[ix].stackSize>0){ + int now=0; + if(mStoredItemInternal[ix]!=null)now=mStoredItemInternal[ix].stackSize; + int tmp=(itemLimit()-now)/mStoredItemInternalSingle[ix].stackSize; + if(tmp0){ + int now=mStoredFluidInternal[ix].getFluidAmount(); + + int tmp=(fluidLimit()-now)/mStoredFluidInternalSingle[ix].getFluidAmount(); + if(tmp this.fluidSlots()) { + clearInv(); + return 0; + } + + mStoredFluid[fluids-1].setFluidDirect(ItemFluidPacket.getFluidStack(itemStack)); + + } else { + items++; + if (items > 16) { + clearInv(); + return 0; + } + mInventory[items-1] = itemStack; + + } + } + markDirty(); + dirty = true; + //classify(); + int suc=0; + DualInvBuffer theBuffer=classifyForce(); + //if(theBuffer!=null){ + suc++;maxTodo--; + //} + /*for (DualInvBuffer inv0 : this.sortByEmpty()) { + if (inv0.full() == false) + if(inv0.recordRecipeOrClassify(this.mStoredFluid, mInventory)|| + inv0.classify(this.mStoredFluid, mInventory, true) + ){ + theBuffer=inv0;suc++;maxTodo--; + break;} + }*/ + if(theBuffer!=null){//if succeeded, it's safe to simply add to stacksize to push more patterns + int todo=Math.min(theBuffer.space() + /*space() will return correct result here + *it assumes item/fluid type is correct + * */ + ,maxTodo); + + if(todo>0){ + for(int ix=0;ix0){ + theBuffer.mStoredFluidInternal[ix].getFluid().amount+=theBuffer.mStoredFluidInternalSingle[ix].getFluidAmount(); + } + } + suc+=todo; + } + + + } + + + + + + + + justHadNewItems = true; + return suc; + } + + diff --git a/src/main/java/reobf/proghatches/gt/metatileentity/PatternDualInputHatchInventoryMappingSlave.java b/src/main/java/reobf/proghatches/gt/metatileentity/PatternDualInputHatchInventoryMappingSlave.java index c849e79..51add0d 100644 --- a/src/main/java/reobf/proghatches/gt/metatileentity/PatternDualInputHatchInventoryMappingSlave.java +++ b/src/main/java/reobf/proghatches/gt/metatileentity/PatternDualInputHatchInventoryMappingSlave.java @@ -82,7 +82,9 @@ import net.minecraftforge.fluids.FluidStack; import net.minecraftforge.fluids.FluidTank; import reobf.proghatches.block.BlockIOHub; +import reobf.proghatches.gt.metatileentity.BufferedDualInputHatch.DualInvBuffer; import reobf.proghatches.gt.metatileentity.DualInputHatch.Net; +import reobf.proghatches.gt.metatileentity.util.IMultiplePatternPushable; import reobf.proghatches.gt.metatileentity.util.ISkipStackSizeCheck; import reobf.proghatches.gt.metatileentity.util.MappingItemHandler; import reobf.proghatches.lang.LangManager; @@ -94,7 +96,9 @@ public class PatternDualInputHatchInventoryMappingSlave extends GT_MetaTileEntity_TieredMachineBlock implements IAddUIWidgets, ICraftingMedium, ICustomNameObject, - IGridProxyable, IInterfaceViewable, IPowerChannelState, IActionHost, ICraftingProvider { + IGridProxyable, IInterfaceViewable, IPowerChannelState, IActionHost, ICraftingProvider + ,IMultiplePatternPushable + { private T master; // use getMaster() to access public int masterX, masterY, masterZ; public boolean masterSet = false; // indicate if values of masterX, @@ -799,7 +803,7 @@ public boolean pushPattern(ICraftingPatternDetails patternDetails, InventoryCraf return false; } FluidStack splitted = new FluidStack(fs.getFluid(), tosplit); - master.mStoredFluid[index].setFluid(splitted); + master.mStoredFluid[f].setFluidDirect(splitted); f++; } @@ -814,13 +818,15 @@ public boolean pushPattern(ICraftingPatternDetails patternDetails, InventoryCraf clearInv(master); return false; } - master.mInventory[index] = splitted; + master.mInventory[i] = splitted; i++; } } } - + if(master instanceof BufferedDualInputHatch){ + ((BufferedDualInputHatch) master).classifyForce(); + } return true;// hoo ray } @@ -962,4 +968,113 @@ public boolean onWireCutterRightClick(ForgeDirection side, ForgeDirection wrench return true; } + @Override + public int pushPatternMulti(ICraftingPatternDetails patternDetails, InventoryCrafting table, int maxTodo) { + if(Config.fastPatternDualInput==false)return 0; + + if (getMaster() instanceof PatternDualInputHatch) { + PatternDualInputHatch dih = ((PatternDualInputHatch) getMaster()); + try{ + dih.skipActiveCheck=true; + return dih.pushPatternMulti(patternDetails, table, maxTodo); + }finally{dih.skipActiveCheck=false;} + } + int suc=0; + if (master != null) { + if (!isInputEmpty(master)) { + return 0; + } + + int i = 0; + int f = 0; + int ilimit = master.getInventoryStackLimit(); + int flimit = master.getInventoryFluidLimit(); + boolean isplit = master.disableLimited; + boolean fsplit = !master.fluidLimit; + for (int index = 0; index < table.getSizeInventory(); index++) { + ItemStack is = (table.getStackInSlot(index)); + if (is == null) + continue; + is = is.copy(); + if (is.getItem() instanceof ItemFluidPacket) { + FluidStack fs = ItemFluidPacket.getFluidStack(is); + if (fs == null) { + continue; + } + while (fs.amount > 0) { + if (f >= master.mStoredFluid.length) { + clearInv(master); + return 0; + } + int tosplit = Math.min(fs.amount, flimit); + fs.amount -= tosplit; + if ((!fsplit) && fs.amount > 0) { + clearInv(master); + return 0; + } + FluidStack splitted = new FluidStack(fs.getFluid(), tosplit); + master.mStoredFluid[f].setFluidDirect(splitted); + f++; + } + + } else { + while (is.stackSize > 0) { + if (master.isValidSlot(i) == false) { + clearInv(master); + return 0; + } + ItemStack splitted = is.splitStack(Math.min(is.stackSize, ilimit)); + if ((!isplit) && is.stackSize > 0) { + clearInv(master); + return 0; + } + master.mInventory[i] = splitted; + i++; + } + } + + } + suc++;maxTodo--; + + if(master instanceof BufferedDualInputHatch){ + DualInvBuffer theBuffer=((BufferedDualInputHatch) master).classifyForce(); + + if(theBuffer!=null){ + int todo=Math.min(theBuffer.space(),maxTodo); + + if(todo>0){ + for(int ix=0;ix0){ + theBuffer.mStoredFluidInternal[ix].getFluid().amount+=theBuffer.mStoredFluidInternalSingle[ix].getFluidAmount()*todo; + }} + + suc+=todo; + } + + + } + + + } + + + + + + + + + + + } + return suc; + + +} } diff --git a/src/main/java/reobf/proghatches/gt/metatileentity/util/IMultiplePatternPushable.java b/src/main/java/reobf/proghatches/gt/metatileentity/util/IMultiplePatternPushable.java new file mode 100644 index 0000000..290ec97 --- /dev/null +++ b/src/main/java/reobf/proghatches/gt/metatileentity/util/IMultiplePatternPushable.java @@ -0,0 +1,13 @@ +package reobf.proghatches.gt.metatileentity.util; + +import appeng.api.networking.crafting.ICraftingPatternDetails; +import appeng.me.cluster.implementations.CraftingCPUCluster; +import net.minecraft.inventory.InventoryCrafting; + +public interface IMultiplePatternPushable { + public int pushPatternMulti(ICraftingPatternDetails patternDetails, InventoryCrafting table + ,int maxTodo); + + + +} diff --git a/src/main/java/reobf/proghatches/main/Config.java b/src/main/java/reobf/proghatches/main/Config.java index 758dd53..810ee80 100644 --- a/src/main/java/reobf/proghatches/main/Config.java +++ b/src/main/java/reobf/proghatches/main/Config.java @@ -33,8 +33,9 @@ public class Config { public static boolean sleep=true; public static boolean MECover=false; public static boolean delayUnlock=true; + public static boolean fastPatternDualInput =true; public static void synchronizeConfiguration(File configFile) { - + Configuration configuration = new Configuration(configFile); /*if(!configuration.hasKey(lang, greeting)){ @@ -57,6 +58,8 @@ public static void synchronizeConfiguration(File configFile) { "When on, hatch will sleep when not busy, to ease server load."); MECover = configuration.getBoolean("MECover on MEHatch", "Experimental", MECover, "When on, ME Cover will be allowed to be placed on machine that requires ME channel."); + fastPatternDualInput = configuration.getBoolean("Fast PatternDualInputHatch","Experimental", fastPatternDualInput, + "When on, optimize performance of DualHatches that directly accept Encoded Patterns. Useful when number of Co-Processors is very large."); diff --git a/src/main/java/reobf/proghatches/main/MyMod.java b/src/main/java/reobf/proghatches/main/MyMod.java index 86d78a8..19d7a0d 100644 --- a/src/main/java/reobf/proghatches/main/MyMod.java +++ b/src/main/java/reobf/proghatches/main/MyMod.java @@ -159,7 +159,7 @@ public class MyMod { public static final Logger LOG = LogManager.getLogger(Tags.MODID); public static MyMod instance; { - DualityInterface.class.getDeclaredFields(); + CraftingCPUCluster.class.getDeclaredFields(); instance = this; } diff --git a/src/main/java/reobf/proghatches/main/mixin/MixinPlugin.java b/src/main/java/reobf/proghatches/main/mixin/MixinPlugin.java index 957d6ee..0efff1c 100644 --- a/src/main/java/reobf/proghatches/main/mixin/MixinPlugin.java +++ b/src/main/java/reobf/proghatches/main/mixin/MixinPlugin.java @@ -191,7 +191,7 @@ public List getMixins() { retLate.add("part2.MixinIsWailaCall"); retLate.add("part2.MixinOC"); retLate.add("part2.MixinRecursiveSlotClickProtection"); - //retLate.add("part2.MixinBlockModeAltBehaviour"); + retLate.add("part2.MixinMultiPattern"); 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/eucrafting/MixinEUSourceCoverChunkUnloadNotification.java b/src/main/java/reobf/proghatches/main/mixin/mixins/eucrafting/MixinEUSourceCoverChunkUnloadNotification.java index e3946e7..b3af2e7 100644 --- a/src/main/java/reobf/proghatches/main/mixin/mixins/eucrafting/MixinEUSourceCoverChunkUnloadNotification.java +++ b/src/main/java/reobf/proghatches/main/mixin/mixins/eucrafting/MixinEUSourceCoverChunkUnloadNotification.java @@ -35,7 +35,7 @@ protected void unloadCover() { final CoverInfo coverInfo = getCoverInfoAtSide(side); if (coverInfo.isValid()) { - Object be = coverInfo.getCoverBehavior(); + GT_CoverBehaviorBase be = coverInfo.getCoverBehavior(); if (be != null && be instanceof AECover) { 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 new file mode 100644 index 0000000..e6e72c3 --- /dev/null +++ b/src/main/java/reobf/proghatches/main/mixin/mixins/part2/MixinMultiPattern.java @@ -0,0 +1,205 @@ +package reobf.proghatches.main.mixin.mixins.part2; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; +import java.util.ListIterator; +import java.util.function.Supplier; +import java.util.stream.Stream; +import java.util.stream.StreamSupport; + +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.Unique; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.ModifyArg; +import org.spongepowered.asm.mixin.injection.ModifyVariable; +import org.spongepowered.asm.mixin.injection.At.Shift; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; + +import com.glodblock.github.common.item.ItemFluidDrop; +import com.glodblock.github.common.item.ItemFluidPacket; + +import appeng.api.config.Actionable; +import appeng.api.config.PowerMultiplier; +import appeng.api.networking.crafting.ICraftingMedium; +import appeng.api.networking.crafting.ICraftingPatternDetails; +import appeng.api.networking.crafting.ICraftingProvider; +import appeng.api.networking.energy.IEnergyGrid; +import appeng.api.networking.security.BaseActionSource; +import appeng.api.networking.security.MachineSource; +import appeng.api.storage.data.IAEItemStack; +import appeng.api.storage.data.IItemList; +import appeng.api.util.DimensionalCoord; +import appeng.crafting.MECraftingInventory; +import appeng.me.cache.CraftingGridCache; +import appeng.me.cluster.implementations.CraftingCPUCluster; +import appeng.util.item.AEItemStack; +import net.minecraft.inventory.InventoryCrafting; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import reobf.proghatches.eucrafting.IInstantCompletable; +import reobf.proghatches.gt.metatileentity.util.IMultiplePatternPushable; +import reobf.proghatches.main.mixin.MixinCallback; + +@Mixin(value = CraftingCPUCluster.class, remap = false) +public class MixinMultiPattern { + @Unique + boolean isMulti; + @Unique + T medium; + + @ModifyVariable(method = "executeCrafting", at = @At(value = "INVOKE", target = "pushPattern(Lappeng/api/networking/crafting/ICraftingPatternDetails;Lnet/minecraft/inventory/InventoryCrafting;)Z")) + public ICraftingMedium b(ICraftingMedium a) { + isMulti = a instanceof IMultiplePatternPushable; + if (isMulti) + medium = (T) a; + return a; + } + + @Unique + InventoryCrafting inv; + + @ModifyArg(method = "executeCrafting", at = @At(value = "INVOKE", target = "Lappeng/api/networking/crafting/ICraftingMedium;pushPattern(Lappeng/api/networking/crafting/ICraftingPatternDetails;Lnet/minecraft/inventory/InventoryCrafting;)Z")) + public InventoryCrafting a(InventoryCrafting a) { + if (isMulti) + inv = a; + return a; + } + + @Unique + ICraftingPatternDetails detail; + + @ModifyArg(method = "executeCrafting", at = @At(value = "INVOKE", target = "Lappeng/api/networking/crafting/ICraftingMedium;pushPattern(Lappeng/api/networking/crafting/ICraftingPatternDetails;Lnet/minecraft/inventory/InventoryCrafting;)Z")) + public ICraftingPatternDetails b(ICraftingPatternDetails a) { + if (isMulti) + detail = a; + return a; + } + + @Unique + java.util.Map.Entry e; + + @ModifyVariable(method = "executeCrafting", at = @At(value = "INVOKE", target = "Lappeng/api/networking/crafting/ICraftingMedium;pushPattern(Lappeng/api/networking/crafting/ICraftingPatternDetails;Lnet/minecraft/inventory/InventoryCrafting;)Z")) + public java.util.Map.Entry b(java.util.Map.Entry a) { + if (isMulti) + e = a; + return a; + } + + @Shadow + private MachineSource machineSrc; + @Shadow + private IItemList waitingFor; + + @Shadow + private void postChange(final IAEItemStack diff, final BaseActionSource src) { + }; + + @Shadow + private void postCraftingStatusChange(final IAEItemStack diff) { + }; + + @Shadow + private MECraftingInventory inventory; + private static final IAEItemStack[] EMPTY= new IAEItemStack[0]; + @Inject(at = @At(value = "INVOKE", shift = Shift.BEFORE, target = "markDirty"), method = "executeCrafting") + public void b(IEnergyGrid eg, CraftingGridCache cc, CallbackInfo ci) { + + if (isMulti) { + int used = 0; + + LinkedList is=new LinkedList<>(); + for(int i=0;i itr = is.listIterator(); + while(itr.hasNext()){ + Object o=itr.next(); + if(o==null){itr.remove();} + if(((ItemStack)o).getItem() instanceof ItemFluidPacket){ + o=(ItemFluidDrop.newStack(ItemFluidPacket.getFluidStack((ItemStack) o))); + } + itr.set(AEItemStack.create((ItemStack) o)); + } + + + IAEItemStack[] input = is.toArray(EMPTY); + + int[] nums = new int[input.length]; + for (int x = 0; x < input.length; x++) { + IAEItemStack tmp = input[x].copy().setStackSize(Integer.MAX_VALUE); + final IAEItemStack ais = this.inventory.extractItems(tmp, Actionable.MODULATE, this.machineSrc); + if (ais != null) + nums[x] = (int) ais.getStackSize(); + } + try { + + int best = Integer.MAX_VALUE; + boolean any = false; + for (int x = 0; x < input.length; x++) { + if (input[x].getStackSize() > 0) { + int num = (int) (nums[x] / input[x].getStackSize()); + if (num < best) + best = num; + any = true; + } + } + if (any == false) { + return; + } + + long num = MixinCallback.getter.apply(e.getValue()); + + int maxtry = Math.min(Math.min( + (int) (num > (Integer.MAX_VALUE - 1) ? (Integer.MAX_VALUE - 1) : num) - 1, remainingOperations), + + best); + + if (maxtry <= 0) { + return; + } + used = medium.pushPatternMulti(detail, inv, maxtry); + + MixinCallback.setter.accept(e.getValue(), num - used); + + if (used > 0) { + for (IAEItemStack out : detail.getCondensedOutputs()) { + out = out.copy().setStackSize(used * out.getStackSize()); + this.postChange(out, this.machineSrc); + this.waitingFor.add(out.copy()); + this.postCraftingStatusChange(out.copy()); + } + } + + } finally { + //return all unused + for (int x = 0; x < input.length; x++) { + this.inventory.injectItems(input[x].copy().setStackSize( + /* all availavle - pushed recipes*per recipe */ + nums[x] - used * input[x].getStackSize()), Actionable.MODULATE, this.machineSrc); + + } + } + + } + + } + + @Shadow + int remainingOperations; + + @Inject(at = @At(value = "RETURN"), method = "executeCrafting") + public void ret(IEnergyGrid eg, CraftingGridCache cc, CallbackInfo ci) { + detail = null; + e = null; + inv = null; + medium = null; + + } + +} diff --git a/src/main/java/reobf/proghatches/util/ProghatchesUtil.java b/src/main/java/reobf/proghatches/util/ProghatchesUtil.java index 1061ecd..0f54f17 100644 --- a/src/main/java/reobf/proghatches/util/ProghatchesUtil.java +++ b/src/main/java/reobf/proghatches/util/ProghatchesUtil.java @@ -167,9 +167,9 @@ public static ItemStack getWrittenBook(Item it, String aMapping, String aTitle, if (aPages[i].length() < 256) tNBTList.appendTag(new NBTTagString(aPages[i])); else - GT_Log.err.println("WARNING: String for written Book too long! -> " + aPages[i]); + MyMod.LOG.warn("WARNING: String for written Book too long! -> " + aPages[i]); } else { - GT_Log.err.println("WARNING: Too much Pages for written Book! -> " + aTitle); + MyMod.LOG.warn("WARNING: Too much Pages for written Book! -> " + aTitle); break; } } diff --git a/src/main/resources/assets/proghatches/lang/en_US/PDIH.lang b/src/main/resources/assets/proghatches/lang/en_US/PDIH.lang index 0a5ae41..3348051 100644 --- a/src/main/resources/assets/proghatches/lang/en_US/PDIH.lang +++ b/src/main/resources/assets/proghatches/lang/en_US/PDIH.lang @@ -6,4 +6,5 @@ If all pattern inputs cannot be push in one single try, it won't be pushed at al Buffer: {bufferNum} For each buffer: Capacity: 2^31-1 L{mMultiFluid?} x{fluidSlots} types of fluid{mMultiFluid:}{mMultiFluid!} -Slot maximum stacksize:2^31-1 \ No newline at end of file +Slot maximum stacksize:2^31-1 +§eHas better performance working with large amount of Co-Processing Units. \ No newline at end of file diff --git a/src/main/resources/assets/proghatches/lang/en_US/PDIHB.lang b/src/main/resources/assets/proghatches/lang/en_US/PDIHB.lang index 1dfccf3..5a26a63 100644 --- a/src/main/resources/assets/proghatches/lang/en_US/PDIHB.lang +++ b/src/main/resources/assets/proghatches/lang/en_US/PDIHB.lang @@ -6,4 +6,5 @@ If all pattern inputs cannot be push in one single try, it won't be pushed at al No fluid support, patterns with fluid will be rejected. Buffer: {bufferNum} For each buffer: -Slot maximum stacksize:2^31-1 \ No newline at end of file +Slot maximum stacksize:2^31-1 +§eHas better performance working with large amount of Co-Processing Units. \ No newline at end of file diff --git a/src/main/resources/assets/proghatches/lang/en_US/PDIHIMS.lang b/src/main/resources/assets/proghatches/lang/en_US/PDIHIMS.lang index 2091070..b88c8bc 100644 --- a/src/main/resources/assets/proghatches/lang/en_US/PDIHIMS.lang +++ b/src/main/resources/assets/proghatches/lang/en_US/PDIHIMS.lang @@ -1,3 +1,4 @@ Not a hatch, is not a part of Multiblock Link with Crafting Input Buffer using Data Stick to share input area inventory -Can be used to extend Patterns attached to master hatch \ No newline at end of file +Can be used to extend Patterns attached to master hatch +§eHas better performance working with large amount of Co-Processing Units. \ No newline at end of file diff --git a/src/main/resources/assets/proghatches/lang/zh_CN/PDIH.lang b/src/main/resources/assets/proghatches/lang/zh_CN/PDIH.lang index c350e7b..4f5ceaf 100644 --- a/src/main/resources/assets/proghatches/lang/zh_CN/PDIH.lang +++ b/src/main/resources/assets/proghatches/lang/zh_CN/PDIH.lang @@ -6,4 +6,5 @@ 缓冲数量: {bufferNum} 缓冲容量: 2^31-1 L{mMultiFluid?} x{fluidSlots}种流体{mMultiFluid:}{mMultiFluid!} {slots}格 -每格堆叠限制:2^31-1 \ No newline at end of file +每格堆叠限制:2^31-1 +§e针对高并行CPU合成有特殊优化 \ No newline at end of file diff --git a/src/main/resources/assets/proghatches/lang/zh_CN/PDIHB.lang b/src/main/resources/assets/proghatches/lang/zh_CN/PDIHB.lang index 1f73e89..799cfb9 100644 --- a/src/main/resources/assets/proghatches/lang/zh_CN/PDIHB.lang +++ b/src/main/resources/assets/proghatches/lang/zh_CN/PDIHB.lang @@ -6,4 +6,5 @@ 不支持流体,带有流体的样板无法工作 缓冲数量: {bufferNum} {slots}格 -每格堆叠限制:2^31-1 \ No newline at end of file +每格堆叠限制:2^31-1 +§e针对高并行CPU合成有特殊优化 \ No newline at end of file diff --git a/src/main/resources/assets/proghatches/lang/zh_CN/PDIHIMS.lang b/src/main/resources/assets/proghatches/lang/zh_CN/PDIHIMS.lang index efca394..241837d 100644 --- a/src/main/resources/assets/proghatches/lang/zh_CN/PDIHIMS.lang +++ b/src/main/resources/assets/proghatches/lang/zh_CN/PDIHIMS.lang @@ -1,3 +1,4 @@ 不是多方块机器的一部分 使用闪存链接二合一输入仓以共享其输入区 -从而拓展连接的样板数量 \ No newline at end of file +从而拓展连接的样板数量 +§e针对高并行CPU合成有特殊优化 \ No newline at end of file