diff --git a/build.gradle b/build.gradle index b3f9e8f..d48d9a3 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.18p12' +String versionOverride = '0.0.18p13' 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/ItemPartAmountMaintainer.java b/src/main/java/reobf/proghatches/ae/ItemPartAmountMaintainer.java new file mode 100644 index 0000000..d97a113 --- /dev/null +++ b/src/main/java/reobf/proghatches/ae/ItemPartAmountMaintainer.java @@ -0,0 +1,72 @@ +package reobf.proghatches.ae; + +import java.util.List; + +import javax.annotation.Nullable; + +import appeng.api.AEApi; +import appeng.api.parts.IPartItem; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraft.util.StatCollector; +import net.minecraft.world.World; +import reobf.proghatches.eucrafting.PartEUP2PInterface; + +public class ItemPartAmountMaintainer extends Item implements IPartItem { + + public ItemPartAmountMaintainer() { + this.setMaxStackSize(64); + + AEApi.instance().partHelper().setItemBusRenderer(this); + } + + @Nullable + @Override + public PartAmountMaintainer createPartFromItemStack(ItemStack is) { + return new PartAmountMaintainer(is); + } +@SideOnly(value=Side.CLIENT) +@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.amountmaintainer.name.tooltip.0")); + p_77624_3_.add(StatCollector.translateToLocal("item.amountmaintainer.name.tooltip.1")); + p_77624_3_.add(StatCollector.translateToLocal("item.amountmaintainer.name.tooltip.2")); + + super.addInformation(p_77624_1_, p_77624_2_, p_77624_3_, p_77624_4_); +} + @Override + public boolean onItemUse(ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int side, + float xOffset, float yOffset, float zOffset) { + return AEApi.instance().partHelper().placeBus(player.getHeldItem(), x, y, z, side, player, world); + } + + /* + * public ItemPartEUSource register() { //if (!Config.fluidIOBus) return + * null; GameRegistry.registerItem(this, NameConst.ITEM_PART_FLUID_EXPORT, + * FluidCraft.MODID); //setCreativeTab(FluidCraftingTabs.INSTANCE); return + * this; } + */ + @SideOnly(Side.CLIENT) + @Override + public void registerIcons(IIconRegister _iconRegister) { + // PartEUSource.registerIcons(_iconRegister); + itemIcon=_iconRegister.registerIcon("proghatches:amountmaintainer"); + } +@Override +public IIcon getIconIndex(ItemStack p_77650_1_) { + // TODO Auto-generated method stub + return super.getIconIndex(p_77650_1_); +} + @Override + @SideOnly(Side.CLIENT) + public int getSpriteNumber() { + return 0; + } + +} + diff --git a/src/main/java/reobf/proghatches/ae/PartAmountMaintainer.java b/src/main/java/reobf/proghatches/ae/PartAmountMaintainer.java new file mode 100644 index 0000000..cd5cd5d --- /dev/null +++ b/src/main/java/reobf/proghatches/ae/PartAmountMaintainer.java @@ -0,0 +1,626 @@ +package reobf.proghatches.ae; + +import java.lang.reflect.Field; +import java.util.Arrays; +import java.util.HashMap; +import java.util.Map; + +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.gtnewhorizons.modularui.api.ModularUITextures; +import com.gtnewhorizons.modularui.api.drawable.IDrawable; +import com.gtnewhorizons.modularui.api.drawable.Text; +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.ModularWindow; +import com.gtnewhorizons.modularui.api.screen.UIBuildContext; +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.DrawableWidget; +import com.gtnewhorizons.modularui.common.widget.FakeSyncWidget; +import com.gtnewhorizons.modularui.common.widget.SlotWidget; +import com.gtnewhorizons.modularui.common.widget.SyncedWidget; +import com.gtnewhorizons.modularui.common.widget.TextWidget; +import com.gtnewhorizons.modularui.common.widget.textfield.NumericWidget; + +import appeng.api.AEApi; +import appeng.api.config.AccessRestriction; +import appeng.api.config.Actionable; +import appeng.api.config.IncludeExclude; +import appeng.api.config.Settings; +import appeng.api.config.StorageFilter; +import appeng.api.config.Upgrades; +import appeng.api.implementations.IPowerChannelState; +import appeng.api.networking.GridFlags; +import appeng.api.networking.IGridNode; +import appeng.api.networking.security.BaseActionSource; +import appeng.api.networking.security.MachineSource; +import appeng.api.networking.storage.IBaseMonitor; +import appeng.api.networking.storage.IStorageGrid; +import appeng.api.networking.ticking.IGridTickable; +import appeng.api.networking.ticking.ITickManager; +import appeng.api.networking.ticking.TickRateModulation; +import appeng.api.networking.ticking.TickingRequest; +import appeng.api.parts.IPartCollisionHelper; +import appeng.api.parts.IPartItem; +import appeng.api.parts.IPartRenderHelper; +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.storage.data.IAEStack; +import appeng.api.storage.data.IItemList; +import appeng.client.texture.CableBusTextures; +import appeng.core.Api; +import appeng.core.api.definitions.ApiItems; +import appeng.items.tools.ToolMemoryCard; +import appeng.me.GridAccessException; +import appeng.me.cache.GridStorageCache; +import appeng.me.storage.MEInventoryHandler; +import appeng.parts.AEBasePart; +import appeng.parts.PartBasicState; +import appeng.parts.p2p.PartP2PRedstone; +import appeng.parts.p2p.PartP2PTunnel; +import appeng.util.Platform; +import appeng.util.item.AEFluidStack; +import appeng.util.item.AEItemStack; +import appeng.util.prioitylist.PrecisePriorityList; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.gui.modularui.GT_UITextures; +import gregtech.api.util.GT_Util; +import gregtech.api.util.GT_Utility; +import mrtjp.projectred.core.ItemPart; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.StatCollector; +import net.minecraft.util.Vec3; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; +import reobf.proghatches.eucrafting.EUUtil; +import reobf.proghatches.eucrafting.IGuiProvidingPart; + +public class PartAmountMaintainer extends PartBasicState implements IGuiProvidingPart,IGridTickable,IPowerChannelState{ + + private int mode; + + + //bit0 ->when offline,clear or maintain + //bit1 ->when online,invert redstone + private int redstone; + + public PartAmountMaintainer(ItemStack is) { + super(is); + this.getProxy().setFlags(GridFlags.REQUIRE_CHANNEL); + } + + @Override + public TickingRequest getTickingRequest(IGridNode node) { + + return new TickingRequest(1,1,false,false); + } + + //AEItemStack empty=AEItemStack.create(new ItemStack(Items.apple,0)); + //AEFluidStack emptyf=AEFluidStack.create(new FluidStack(FluidRegistry.WATER,0)); + @SuppressWarnings({ "unchecked", "rawtypes" }) + static private Map EMPTY=(Map)(Object)ImmutableMap.of( + StorageChannel.FLUIDS,AEFluidStack.create(new FluidStack(FluidRegistry.WATER,0)), + StorageChannel.ITEMS,AEItemStack.create(new ItemStack(Items.apple,0)) + ); + + @SuppressWarnings({ "rawtypes", "unchecked" }) + @Override + public TickRateModulation tickingRequest(IGridNode node, int TicksSinceLastCall) { + if(getProxy().isActive()==false)return TickRateModulation.SAME; + for(StorageChannel ch:new StorageChannel[]{StorageChannel.FLUIDS,StorageChannel.ITEMS}) + { + IMEInventory inv = getInv(ch); + if(inv!=null){ + + IItemList list; + if(inv instanceof IMEMonitor){ + inv.injectItems(EMPTY.get(ch), Actionable.MODULATE, source);//dirty hack, trigger update + list = ((IMEMonitor) inv).getStorageList(); + + }else{ + list=inv.getAvailableItems(ch.createList()); + } + + end:{ + IAEStack opt=maybe(ch); + if(opt==null)break end; + IAEStack is= list.findPrecise( + //AEItemStack.create(new ItemStack(Items.apple)) + opt + ); + + long amount; + if(is==null){ + amount=0; + is=opt.copy(); + is.setStackSize(0); + }else{ + amount=is.getStackSize(); + } + + + + long expected=opt.getStackSize(); + sc:if(amount>expected){ + try{ + IAEStack take = inv.extractItems(is.copy().setStackSize(amount-expected), Actionable.SIMULATE, source); + if(take==null){break sc;} + IAEStack notadd =getStorage(getProxy().getStorage(),ch).injectItems( take, Actionable.SIMULATE, source); + if(notadd==null||notadd.getStackSize()==0){ + IAEStack realtake = inv.extractItems(is.copy().setStackSize(amount-expected), Actionable.MODULATE, source); + /*IAEStack notadd =*/getStorage(getProxy().getStorage(),ch).injectItems( realtake, Actionable.MODULATE, source); + } + + }catch(GridAccessException e){} + } + sc:if(amount{ + System.out.println(s); + + });*/ + + + + + + + } + + + } + + + + return TickRateModulation.SAME; + } + + + @Override + public void getBoxes(final IPartCollisionHelper bch) { + bch.addBox(2, 2, 14, 14, 14, 16); + bch.addBox(5, 5, 12, 11, 11, 14); + } @Override + @SideOnly(Side.CLIENT) + public void renderInventory(final IPartRenderHelper rh, final RenderBlocks renderer) { + rh.setTexture( + CableBusTextures.PartMonitorSides.getIcon(), + CableBusTextures.PartMonitorSides.getIcon(), + CableBusTextures.PartMonitorBack.getIcon(), + this.getItemStack().getIconIndex(), + CableBusTextures.PartMonitorSides.getIcon(), + CableBusTextures.PartMonitorSides.getIcon()); + + rh.setBounds(2, 2, 14, 14, 14, 16); + rh.renderInventoryBox(renderer); + + rh.setBounds(5, 5, 12, 11, 11, 13); + rh.renderInventoryBox(renderer); + + rh.setBounds(5, 5, 13, 11, 11, 14); + rh.renderInventoryBox(renderer); + } @Override + @SideOnly(Side.CLIENT) + public void renderStatic(final int x, final int y, final int z, final IPartRenderHelper rh, + final RenderBlocks renderer) { + this.setRenderCache(rh.useSimplifiedRendering(x, y, z, this, this.getRenderCache())); + rh.setTexture( + CableBusTextures.PartMonitorSides.getIcon(), + CableBusTextures.PartMonitorSides.getIcon(), + CableBusTextures.PartMonitorBack.getIcon(), + this.getItemStack().getIconIndex(), + CableBusTextures.PartMonitorSides.getIcon(), + CableBusTextures.PartMonitorSides.getIcon()); + + rh.setBounds(2, 2, 14, 14, 14, 16); + rh.renderBlock(x, y, z, renderer); + + rh.setTexture( + CableBusTextures.PartMonitorSides.getIcon(), + CableBusTextures.PartMonitorSides.getIcon(), + CableBusTextures.PartMonitorBack.getIcon(), + this.getItemStack().getIconIndex(), + CableBusTextures.PartMonitorSides.getIcon(), + CableBusTextures.PartMonitorSides.getIcon()); + + rh.setBounds(5, 5, 12, 11, 11, 13); + rh.renderBlock(x, y, z, renderer); + + rh.setTexture( + CableBusTextures.PartMonitorSidesStatus.getIcon(), + CableBusTextures.PartMonitorSidesStatus.getIcon(), + CableBusTextures.PartMonitorBack.getIcon(), + this.getItemStack().getIconIndex(), + CableBusTextures.PartMonitorSidesStatus.getIcon(), + CableBusTextures.PartMonitorSidesStatus.getIcon()); + + rh.setBounds(5, 5, 13, 11, 11, 14); + rh.renderBlock(x, y, z, renderer); + + //this.renderLights(x, y, z, rh, renderer); + } + + + + + @SuppressWarnings("deprecation") + @Override + public boolean onPartActivate(EntityPlayer player, Vec3 pos) { +/*if(player.getHeldItem()!=null&&player.getHeldItem().getItem()instanceof ToolMemoryCard){ + + NBTTagCompound a = ((ToolMemoryCard)player.getHeldItem().getItem()).getData(player.getHeldItem()); + if (a.hasKey("freq")) { + final long freq = a.getLong("freq"); + final ItemStack newType = ItemStack.loadItemStackFromNBT(a); + + if (newType != null) { + + if(Api.INSTANCE.definitions().parts().p2PTunnelRedstone().isSameAs(newType)){ + + System.out.println(freq); + + + + }; + + + } + } + +}*/ + // System.out.println(this.getTile().getWorldObj().isRemote); + if (player.isSneaking()) + return false; + TileEntity t = this.getTile(); + // System.out.println(getSide()); + EUUtil.open(player, player.getEntityWorld(), t.xCoord, t.yCoord, t.zCoord, getSide()); + //System.out.println(player.getHeldItem()); + return true; + } + + @Override + public ModularWindow createWindow(UIBuildContext buildContext) { + ModularWindow.Builder builder = ModularWindow.builder(176, 107+20); + builder.setBackground(ModularUITextures.VANILLA_BACKGROUND); + builder.bindPlayerInventory(buildContext.getPlayer()); + + String freqTooltip = String.format("%X", freq).replaceAll("(.{4})", "$0 ").trim(); + ItemStackHandler is=new ItemStackHandler(); + + if(freq!=0){ + ItemStack stack = Api.INSTANCE.definitions().parts().p2PTunnelRedstone().maybeStack(1).get(); + + stack.setStackDisplayName("freq:"+freqTooltip); + is.setStackInSlot(0, stack); + } + builder.widget( TextWidget.dynamicString(()->{ + try{ + PartP2PTunnel p2p = getProxy().getP2P().getInput(freq); + if(p2p.isActive()&&p2p.isPowered()){ + return StatCollector.translateToLocal("proghatches.amountmaintainer.redstone.online"); + }}catch(Exception e){} + + + return StatCollector.translateToLocal("proghatches.amountmaintainer.redstone.offline"); + + }).setPos(30,10)); + builder.widget( new SlotWidget(new BaseSlot(is, 0,true)){ + @Override + protected void phantomClick(ClickData clickData, ItemStack cursorStack) { + if(cursorStack==null){ + freq=0; + is.setStackInSlot(0, null); + } + if(cursorStack!=null&&cursorStack.getItem()instanceof ToolMemoryCard){ + + NBTTagCompound a = ((ToolMemoryCard)cursorStack.getItem()).getData(cursorStack); + if (a.hasKey("freq")) { + final long freqx = a.getLong("freq"); + final ItemStack newType = ItemStack.loadItemStackFromNBT(a); + + if (newType != null) { + + if(Api.INSTANCE.definitions().parts().p2PTunnelRedstone().isSameAs(newType)){ + + + freq=freqx; + String freqTooltip = String.format("%X", freq).replaceAll("(.{4})", "$0 ").trim(); + ItemStack stack = Api.INSTANCE.definitions().parts().p2PTunnelRedstone().maybeStack(1).get(); + stack.setStackDisplayName("freq:"+freqTooltip); + is.setStackInSlot(0, stack); + + + }; + + + } + }} + + + + } + + + }.setPos(3+4, 3) + .addTooltip( StatCollector.translateToLocal("proghatches.amountmaintainer.memorycard")) + ); + + + + + + ItemStackHandler iss=new ItemStackHandler(mark); + builder.widget( new SlotWidget(new BaseSlot(iss, 0,true)){ + @Override + protected void phantomClick(ClickData clickData, ItemStack cursorStack) { + if(cursorStack==null){ + mark[0]=null; + + }else{ + ItemStack fis = mode==0?null:tryConvertToFluid(cursorStack); + + mark[0]=fis==null?cursorStack:fis; + mark[0]=mark[0].copy(); + mark[0].stackSize=1; + } + + } + + + }.setPos(60, 3).addTooltip(StatCollector.translateToLocal("proghatches.amountmaintainer.phantomslot"))); + + + builder.widget( + new NumericWidget().setSetter(val -> amount = (long) val) + .setGetter(() -> amount) + .setBounds(1, 9_007_199_254_740_991D) + .setScrollValues(1, 4, 64) + .setTextAlignment(Alignment.Center) + .setTextColor(Color.WHITE.normal) + .setSize(60, 18) + .setPos(60+18, 3) + .setBackground(GT_UITextures.BACKGROUND_TEXT_FIELD) + .addTooltips(Arrays.asList( + StatCollector.translateToLocal("proghatches.amountmaintainer.amount.0"), + StatCollector.translateToLocal("proghatches.amountmaintainer.amount.1"), + StatCollector.translateToLocal("proghatches.amountmaintainer.amount.2"), + StatCollector.translateToLocal("proghatches.amountmaintainer.amount.3")) + + ) + ); + + builder.widget(new CycleButtonWidget().setGetter(()->mode) + .setSetter(s->mode=s).setLength(2) + .setTextureGetter(s->{ + if(s==0)return GT_UITextures.OVERLAY_BUTTON_VOID_EXCESS_ITEM; + if(s==1)return GT_UITextures.OVERLAY_BUTTON_VOID_EXCESS_FLUID; + return GT_UITextures.OVERLAY_BUTTON_VOID_EXCESS_ALL; + }) + .addTooltip(0, StatCollector.translateToLocal("proghatches.amountmaintainer.phantomclick.mode.0")) + .addTooltip(1, StatCollector.translateToLocal("proghatches.amountmaintainer.phantomclick.mode.1")) + .setBackground(() -> { + { + return new IDrawable[] { GT_UITextures.BUTTON_STANDARD, + }; + } + }) + + .setSize(18, 18) + .setPos(120+20, 3)); + + + builder.widget(new CycleButtonWidget().setGetter(()->redstone) + .setSetter(s->redstone=s).setLength(4) + .setTextureGetter(s->{ + + return GT_UITextures.OVERLAY_BUTTON_REDSTONE_ON; + }) + .addTooltip(0, StatCollector.translateToLocal("proghatches.amountmaintainer.redstone.mode.0")) + .addTooltip(1, StatCollector.translateToLocal("proghatches.amountmaintainer.redstone.mode.1")) + .addTooltip(2, StatCollector.translateToLocal("proghatches.amountmaintainer.redstone.mode.2")) + .addTooltip(3, StatCollector.translateToLocal("proghatches.amountmaintainer.redstone.mode.3")) + + .setBackground(() -> { + { + return new IDrawable[] { GT_UITextures.BUTTON_STANDARD, + }; + } + }) + + .setSize(18, 18) + .setPos(3+4, 3+18)); + + + builder.widget(new DrawableWidget().setDrawable(GT_UITextures.OVERLAY_BUTTON_REDSTONE_ON).setPos(3+4+20, 3+18).setSize(18,18).setEnabled(s->{on=isOn();return on;}) + .addTooltip(StatCollector.translateToLocalFormatted("proghatches.amountmaintainer.redstone.state.on",amount)) + ) + ; + builder.widget(new DrawableWidget().setDrawable(GT_UITextures.OVERLAY_BUTTON_REDSTONE_OFF).setPos(3+4+20, 3+18).setSize(18,18).setEnabled(s->!on) + .addTooltip(StatCollector.translateToLocalFormatted("proghatches.amountmaintainer.redstone.state.off")) + ) + ; + builder.widget(new FakeSyncWidget.BooleanSyncer(()->on, s->on=s)); + + return builder.build(); + } + private boolean on; + static Field f ; + static{try { + f=PartP2PRedstone.class.getDeclaredField("power"); + f.setAccessible(true); + } catch (NoSuchFieldException e) { + e.printStackTrace(); + throw new RuntimeException(e); + }} + + public Boolean getSignal(){ + + try { + PartP2PTunnel p2p = getProxy().getP2P().getInput(freq); + if(p2p!=null){ + if(p2p.isActive()&&p2p.isPowered()){ + + + return f.getInt(((PartP2PRedstone)p2p))>0; + + } + + } + + } catch (GridAccessException e) { + + } + + catch (Exception e) {e.printStackTrace(); + + } + return null; + + + } + long freq; + private BaseActionSource source=new MachineSource(this); + + + @Override + public void readFromNBT(NBTTagCompound data) { + freq=data.getLong("freq"); + mode=data.getInteger("mode"); + redstone=data.getInteger("redstone"); + amount=data.getLong("amount"); + mark[0]=ItemStack.loadItemStackFromNBT(data.getCompoundTag("mark")); + super.readFromNBT(data); + } + @Override + public void writeToNBT(NBTTagCompound data) { + data.setLong("freq", freq); + data.setInteger("mode", mode); + data.setInteger("redstone", redstone); + data.setLong("amount", amount); + if(mark[0]!=null)data.setTag("mark", mark[0].writeToNBT(new NBTTagCompound())); + + super.writeToNBT(data); + } + long amount=64; + + HashMap inv=new HashMap(); + HashMap handlerHash=new HashMap(); + public ItemStack[] mark=new ItemStack[1]; + public IMEInventory getInv(StorageChannel ch){ + final TileEntity self = this.getHost().getTile(); + 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; + } + return null; + + } + + public IAEStack maybe(StorageChannel c){ + + + + if(c==StorageChannel.ITEMS)return maybeItem(); + return maybeFluid(); + } + public AEItemStack maybeItem(){ + if(mark[0]==null)return null; + + FluidStack fs = GT_Utility.getFluidFromDisplayStack(mark[0]); + if(fs==null){ + AEItemStack is=AEItemStack.create(mark[0]); + is.setStackSize(requestedAmount()); + return is; + } + return null; + } + + + public long requestedAmount(){return isOn()?amount:0;} + public boolean isOn(){ + + Boolean b=getSignal(); + if(b==null){return (redstone&0b1)==0;} + return ((redstone&0b10)!=0)^b; + } + + + + public AEFluidStack maybeFluid(){ + if(mark[0]==null)return null; + FluidStack fs = GT_Utility.getFluidFromDisplayStack(mark[0]); + if(fs!=null){ + AEFluidStack is=AEFluidStack.create(fs); + is.setStackSize(requestedAmount()); + return is; + } + return null; + } + private ItemStack tryConvertToFluid(ItemStack is){ + + FluidStack fs = GT_Utility.getFluidForFilledItem(is, true); + if(fs!=null){ + return GT_Utility.getFluidDisplayStack(fs, false); + } + + return null; + } + private IMEMonitor getStorage(IStorageGrid g,StorageChannel c){ + if(c==StorageChannel.ITEMS)return g.getItemInventory(); + return g.getFluidInventory(); + + + } + + +} diff --git a/src/main/java/reobf/proghatches/gt/metatileentity/BufferedDualInputHatch.java b/src/main/java/reobf/proghatches/gt/metatileentity/BufferedDualInputHatch.java index 6464d00..799f7c7 100644 --- a/src/main/java/reobf/proghatches/gt/metatileentity/BufferedDualInputHatch.java +++ b/src/main/java/reobf/proghatches/gt/metatileentity/BufferedDualInputHatch.java @@ -707,7 +707,7 @@ public boolean updateEveryTick() { @Override public void startRecipeProcessing() { - if (isInputEmpty() == false) + if (isInputEmpty() == false&&getBaseMetaTileEntity().isAllowedToWork()) for (DualInvBuffer inv0 : this.sortByEmpty()) { if (inv0.full() == false) { diff --git a/src/main/java/reobf/proghatches/gt/metatileentity/DataHatchME.java b/src/main/java/reobf/proghatches/gt/metatileentity/DataHatchME.java index dd76c17..69573c1 100644 --- a/src/main/java/reobf/proghatches/gt/metatileentity/DataHatchME.java +++ b/src/main/java/reobf/proghatches/gt/metatileentity/DataHatchME.java @@ -132,7 +132,7 @@ public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { //System.out.println("power check"); if(aTick%400==20||ok!=prevOk){ //System.out.println("force update"); - updateCache();} + updateCache();updateValidGridProxySides();} prevOk=ok; } @@ -207,6 +207,7 @@ public void loadNBTData(NBTTagCompound aNBT) { } getProxy().readFromNBT(aNBT); + } @Override public IGridNode getGridNode(ForgeDirection dir) { diff --git a/src/main/java/reobf/proghatches/gt/metatileentity/RestrictedInputBusME.java b/src/main/java/reobf/proghatches/gt/metatileentity/RestrictedInputBusME.java new file mode 100644 index 0000000..ad4a46f --- /dev/null +++ b/src/main/java/reobf/proghatches/gt/metatileentity/RestrictedInputBusME.java @@ -0,0 +1,311 @@ +package reobf.proghatches.gt.metatileentity; + +import static gregtech.api.enums.GT_Values.TIER_COLORS; +import static gregtech.api.enums.GT_Values.VN; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_ME_INPUT_FLUID_HATCH; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_ME_INPUT_FLUID_HATCH_ACTIVE; +import static gregtech.api.metatileentity.BaseTileEntity.TOOLTIP_DELAY; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.EnumSet; +import java.util.Iterator; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +import javax.annotation.Nullable; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.ChatComponentTranslation; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.StatCollector; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.FluidStack; +import reobf.proghatches.lang.LangManager; +import reobf.proghatches.main.registration.Registration; +import sun.misc.Unsafe; + +import com.google.common.collect.ImmutableMap; +import com.gtnewhorizons.modularui.api.ModularUITextures; +import com.gtnewhorizons.modularui.api.drawable.IDrawable; +import com.gtnewhorizons.modularui.api.drawable.Text; +import com.gtnewhorizons.modularui.api.math.Alignment; +import com.gtnewhorizons.modularui.api.math.Color; +import com.gtnewhorizons.modularui.api.math.Pos2d; +import com.gtnewhorizons.modularui.api.math.Size; +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.api.screen.UIBuildContext; +import com.gtnewhorizons.modularui.api.widget.IWidgetBuilder; +import com.gtnewhorizons.modularui.api.widget.Interactable; +import com.gtnewhorizons.modularui.api.widget.Widget; +import com.gtnewhorizons.modularui.common.fluid.FluidStackTank; +import com.gtnewhorizons.modularui.common.widget.ButtonWidget; +import com.gtnewhorizons.modularui.common.widget.DrawableWidget; +import com.gtnewhorizons.modularui.common.widget.FakeSyncWidget; +import com.gtnewhorizons.modularui.common.widget.FluidSlotWidget; +import com.gtnewhorizons.modularui.common.widget.SlotGroup; +import com.gtnewhorizons.modularui.common.widget.TextWidget; +import com.gtnewhorizons.modularui.common.widget.textfield.NumericWidget; + +import appeng.api.config.Actionable; +import appeng.api.config.PowerMultiplier; +import appeng.api.implementations.IPowerChannelState; +import appeng.api.networking.GridFlags; +import appeng.api.networking.security.BaseActionSource; +import appeng.api.networking.security.IActionHost; +import appeng.api.networking.security.MachineSource; +import appeng.api.storage.IMEMonitor; +import appeng.api.storage.data.IAEFluidStack; +import appeng.api.storage.data.IAEItemStack; +import appeng.api.util.AECableType; +import appeng.core.localization.WailaText; +import appeng.me.GridAccessException; +import appeng.me.helpers.AENetworkProxy; +import appeng.me.helpers.IGridProxyable; +import appeng.util.item.AEFluidStack; +import appeng.util.item.AEItemStack; +import gregtech.api.GregTech_API; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.SoundResource; +import gregtech.api.gui.modularui.GT_UITextures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.modularui.IAddGregtechLogo; +import gregtech.api.interfaces.modularui.IAddUIWidgets; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase; +import gregtech.api.recipe.check.CheckRecipeResult; +import gregtech.api.recipe.check.CheckRecipeResultRegistry; +import gregtech.api.recipe.check.SimpleCheckRecipeResult; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_Utility; +import gregtech.api.util.shutdown.ShutDownReasonRegistry; +import gregtech.common.tileentities.machines.GT_MetaTileEntity_Hatch_InputBus_ME; +import gregtech.common.tileentities.machines.GT_MetaTileEntity_Hatch_Input_ME; +import gregtech.common.tileentities.machines.IRecipeProcessingAwareHatch; +import mcp.mobius.waila.api.IWailaConfigHandler; +import mcp.mobius.waila.api.IWailaDataAccessor; + +public class RestrictedInputBusME extends GT_MetaTileEntity_Hatch_InputBus_ME{ + + public RestrictedInputBusME(int aID, boolean autoPullAvailable, String aName, String aNameRegional) { + super(aID, autoPullAvailable, aName, aNameRegional); + Registration.items.add(new ItemStack(GregTech_API.sBlockMachines, 1, aID)); + desc=reobf.proghatches.main.Config.get("RIBME", ImmutableMap.of()); + } + public RestrictedInputBusME(String aName, boolean autoPullAvailable, int aTier, String[] aDescription, + ITexture[][][] aTextures) { + super(aName, autoPullAvailable, aTier, aDescription, aTextures); + + } + + private static final int SLOT_COUNT = 16; + + + String[] desc; + @Override + public String[] getDescription() { + + return desc; + } + + + static private int _mDescriptionArray_offset; + static private int _mDescription_offset; + + + + + + + public ItemStack updateInformationSlot(int aIndex, ItemStack aStack) { + if (aIndex >= 0 && aIndex < SLOT_COUNT) { + if (aStack == null) { + super.setInventorySlotContents(aIndex + SLOT_COUNT, null); + } else { + AENetworkProxy proxy = getProxy(); + if (!proxy.isActive()) { + super.setInventorySlotContents(aIndex + SLOT_COUNT, null); + return null; + } + try { + IMEMonitor sg = proxy.getStorage() + .getItemInventory(); + IAEItemStack request = AEItemStack.create(mInventory[aIndex]); + request.setStackSize(Integer.MAX_VALUE); + IAEItemStack result = sg.extractItems(request, Actionable.SIMULATE, getRequestSource()); + ItemStack s = (result != null) ? result.getItemStack() : null; + if(s!=null&&s.stackSize>restrict){ + s.stackSize=restrict; + } + if(s!=null&&s.stackSize0&&multiples){ + s.stackSize=(s.stackSize/restrict_lowbound)*restrict_lowbound; + } + + + + + setInventorySlotContents(aIndex + SLOT_COUNT, s); + return s; + } catch (final GridAccessException ignored) {} + } + } + return null; + } + + +@Override +public CheckRecipeResult endRecipeProcessing(GT_MetaTileEntity_MultiBlockBase controller) { + try{ + return super.endRecipeProcessing(controller);}finally{ + for (int index = 0; index < SLOT_COUNT; index++) { + updateInformationSlot(index, mInventory[index]); + } + } + +}BaseActionSource requestSource; + private BaseActionSource getRequestSource() { + if (requestSource == null) requestSource = new MachineSource((IActionHost) getBaseMetaTileEntity()); + return requestSource; + } + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + + return new RestrictedInputBusME(mName, false, mTier, mDescriptionArray, mTextures); + + } + private static final int CONFIG_WINDOW_ID=123456; + @Override + public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) { + + buildContext.addSyncedWindow(CONFIG_WINDOW_ID, this::createStackSizeConfigurationWindow); + builder.widget(new ButtonWidget().setOnClick((clickData, widget) -> { + if (clickData.mouseButton == 0) { + if (!widget.isClient()) { + widget.getContext() + .openSyncedWindow(CONFIG_WINDOW_ID); + } + }}) + .setBackground(() -> { + { + return new IDrawable[] { GT_UITextures.BUTTON_STANDARD, + GT_UITextures.OVERLAY_BUTTON_AUTOPULL_ME_DISABLED }; + } + }) + .addTooltips( + Arrays.asList( + StatCollector.translateToLocal("proghatches.restricted.configure"))) + .setSize(16, 16) + .setPos(80, 10)); + // .widget(new FakeSyncWidget.BooleanSyncer(() -> autoPullFluidList, this::setAutoPullFluidList)); + + + super.addUIWidgets(builder, buildContext); + + } + protected ModularWindow createStackSizeConfigurationWindow(final EntityPlayer player) { + final int WIDTH = 78; + final int HEIGHT = 80+18; + final int PARENT_WIDTH = getGUIWidth(); + final int PARENT_HEIGHT = getGUIHeight(); + ModularWindow.Builder builder = ModularWindow.builder(WIDTH, HEIGHT); + builder.setBackground(GT_UITextures.BACKGROUND_SINGLEBLOCK_DEFAULT); + builder.setGuiTint(getGUIColorization()); + builder.setDraggable(true); + builder.setPos( + (size, window) -> Alignment.Center.getAlignedPos(size, new Size(PARENT_WIDTH, PARENT_HEIGHT)) + .add( + Alignment.TopRight.getAlignedPos(new Size(PARENT_WIDTH, PARENT_HEIGHT), new Size(WIDTH, HEIGHT)) + .add(WIDTH - 3, 0))); + builder.widget( + TextWidget.localised("proghatches.restricted.bound.down") + .setPos(3, 2) + .setSize(74, 14)) + .widget( + new NumericWidget().setSetter(val -> restrict_lowbound = (int) val) + .setGetter(() -> restrict_lowbound) + .setBounds(1, Integer.MAX_VALUE) + .setScrollValues(1, 4, 64) + .setTextAlignment(Alignment.Center) + .setTextColor(Color.WHITE.normal) + .setSize(70, 18) + .setPos(3, 18) + .setBackground(GT_UITextures.BACKGROUND_TEXT_FIELD)); + builder.widget( + TextWidget.localised("proghatches.restricted.bound.up") + .setPos(3, 42) + .setSize(74, 14)) + .widget( + new NumericWidget().setSetter(val -> restrict = (int) val) + .setGetter(() -> restrict) + .setBounds(1, Integer.MAX_VALUE) + .setScrollValues(1, 4, 64) + .setTextAlignment(Alignment.Center) + .setTextColor(Color.WHITE.normal) + .setSize(70, 18) + .setPos(3, 58) + .setBackground(GT_UITextures.BACKGROUND_TEXT_FIELD)); + + builder.widget(createMultiplesModeButton(builder,HEIGHT)); + + + + + return builder.build(); + } + boolean multiples; + ButtonWidget createMultiplesModeButton(IWidgetBuilder builder,int HEIGHT) { + + Widget button = new ButtonWidget().setOnClick((clickData, widget) -> { + + multiples=!multiples; + }).attachSyncer(new FakeSyncWidget.BooleanSyncer(()->multiples, val -> { + multiples=val; + }), builder) + .setBackground(() -> { + if (multiples) { + return new IDrawable[] { GT_UITextures.BUTTON_STANDARD_PRESSED, + GT_UITextures.OVERLAY_BUTTON_POWER_SWITCH_ON }; + } else { + return new IDrawable[] { GT_UITextures.BUTTON_STANDARD, + GT_UITextures.OVERLAY_BUTTON_POWER_SWITCH_OFF }; + } + }) + + + .addTooltip(LangManager.translateToLocal("proghatches.restricted.multiples")) + .setTooltipShowUpDelay(TOOLTIP_DELAY) + + .setPos(new Pos2d(3, HEIGHT-3-16)).setSize(16, 16); + return (ButtonWidget) button; + } +int restrict=Integer.MAX_VALUE; +int restrict_lowbound=1; +@Override +public void saveNBTData(NBTTagCompound aNBT) { + super.saveNBTData(aNBT); + aNBT.setInteger("restrict", restrict); + aNBT.setInteger("restrict_l", restrict_lowbound); + aNBT.setBoolean("multiples", multiples); + } +@Override +public void loadNBTData(NBTTagCompound aNBT) { + super.loadNBTData(aNBT); + restrict=aNBT.getInteger( "restrict"); + restrict_lowbound=aNBT.getInteger( "restrict_l"); + multiples=aNBT.getBoolean("multiples"); +} + + +} diff --git a/src/main/java/reobf/proghatches/gt/metatileentity/RestrictedInputHatchME.java b/src/main/java/reobf/proghatches/gt/metatileentity/RestrictedInputHatchME.java new file mode 100644 index 0000000..0743402 --- /dev/null +++ b/src/main/java/reobf/proghatches/gt/metatileentity/RestrictedInputHatchME.java @@ -0,0 +1,288 @@ +package reobf.proghatches.gt.metatileentity; + +import static gregtech.api.enums.GT_Values.TIER_COLORS; +import static gregtech.api.enums.GT_Values.VN; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_ME_INPUT_FLUID_HATCH; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_ME_INPUT_FLUID_HATCH_ACTIVE; +import static gregtech.api.metatileentity.BaseTileEntity.TOOLTIP_DELAY; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.EnumSet; +import java.util.Iterator; +import java.util.List; +import java.util.stream.Collectors; +import java.util.stream.IntStream; + +import javax.annotation.Nullable; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.ChatComponentTranslation; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.StatCollector; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.FluidStack; +import reobf.proghatches.lang.LangManager; +import reobf.proghatches.main.registration.Registration; + +import com.google.common.collect.ImmutableMap; +import com.gtnewhorizons.modularui.api.ModularUITextures; +import com.gtnewhorizons.modularui.api.drawable.IDrawable; +import com.gtnewhorizons.modularui.api.drawable.Text; +import com.gtnewhorizons.modularui.api.math.Alignment; +import com.gtnewhorizons.modularui.api.math.Color; +import com.gtnewhorizons.modularui.api.math.Pos2d; +import com.gtnewhorizons.modularui.api.math.Size; +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.api.screen.UIBuildContext; +import com.gtnewhorizons.modularui.api.widget.IWidgetBuilder; +import com.gtnewhorizons.modularui.api.widget.Interactable; +import com.gtnewhorizons.modularui.api.widget.Widget; +import com.gtnewhorizons.modularui.common.fluid.FluidStackTank; +import com.gtnewhorizons.modularui.common.widget.ButtonWidget; +import com.gtnewhorizons.modularui.common.widget.DrawableWidget; +import com.gtnewhorizons.modularui.common.widget.FakeSyncWidget; +import com.gtnewhorizons.modularui.common.widget.FluidSlotWidget; +import com.gtnewhorizons.modularui.common.widget.SlotGroup; +import com.gtnewhorizons.modularui.common.widget.TextWidget; +import com.gtnewhorizons.modularui.common.widget.textfield.NumericWidget; + +import appeng.api.config.Actionable; +import appeng.api.config.PowerMultiplier; +import appeng.api.implementations.IPowerChannelState; +import appeng.api.networking.GridFlags; +import appeng.api.networking.security.BaseActionSource; +import appeng.api.networking.security.IActionHost; +import appeng.api.networking.security.MachineSource; +import appeng.api.storage.IMEMonitor; +import appeng.api.storage.data.IAEFluidStack; +import appeng.api.util.AECableType; +import appeng.core.localization.WailaText; +import appeng.me.GridAccessException; +import appeng.me.helpers.AENetworkProxy; +import appeng.me.helpers.IGridProxyable; +import appeng.util.item.AEFluidStack; +import gregtech.api.GregTech_API; +import gregtech.api.enums.ItemList; +import gregtech.api.gui.modularui.GT_UITextures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.modularui.IAddGregtechLogo; +import gregtech.api.interfaces.modularui.IAddUIWidgets; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase; +import gregtech.api.recipe.check.CheckRecipeResult; +import gregtech.api.recipe.check.CheckRecipeResultRegistry; +import gregtech.api.recipe.check.SimpleCheckRecipeResult; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_Utility; +import gregtech.api.util.shutdown.ShutDownReasonRegistry; +import gregtech.common.tileentities.machines.GT_MetaTileEntity_Hatch_Input_ME; +import gregtech.common.tileentities.machines.IRecipeProcessingAwareHatch; +import mcp.mobius.waila.api.IWailaConfigHandler; +import mcp.mobius.waila.api.IWailaDataAccessor; + +public class RestrictedInputHatchME extends GT_MetaTileEntity_Hatch_Input_ME +{ + + public RestrictedInputHatchME(int aID, boolean autoPullAvailable, String aName, String aNameRegional) { + super(aID, autoPullAvailable, aName, aNameRegional); + Registration.items.add(new ItemStack(GregTech_API.sBlockMachines, 1, aID)); + desc=reobf.proghatches.main.Config.get("RIHME", ImmutableMap.of()); + } + public RestrictedInputHatchME(String aName, boolean autoPullAvailable, int aTier, String[] aDescription, + ITexture[][][] aTextures) { + super(aName, autoPullAvailable, aTier, aDescription, aTextures); + + } + String[] desc; + @Override + public String[] getDescription() { + + return desc; + } + private static final int SLOT_COUNT = 16; + public void updateInformationSlot(int index) { + if (index < 0 || index >= SLOT_COUNT) { + return; + } + + FluidStack fluidStack = storedFluids[index]; + if (fluidStack == null) { + storedInformationFluids[index] = null; + return; + } + + AENetworkProxy proxy = getProxy(); + if (proxy == null || !proxy.isActive()) { + storedInformationFluids[index] = null; + return; + } + + try { + IMEMonitor sg = proxy.getStorage() + .getFluidInventory(); + IAEFluidStack request = AEFluidStack.create(fluidStack); + request.setStackSize(Integer.MAX_VALUE); + IAEFluidStack result = sg.extractItems(request, Actionable.SIMULATE, getRequestSource()); + FluidStack resultFluid = (result != null) ? result.getFluidStack() : null; + if(resultFluid!=null&&resultFluid.amount>restrict){ + resultFluid.amount=restrict; + } + if(resultFluid!=null&&resultFluid.amount0&&multiples){ + resultFluid.amount=(resultFluid.amount/restrict_lowbound)*restrict_lowbound; + } + storedInformationFluids[index] = resultFluid; + } catch (final GridAccessException ignored) {} + } +@Override +public CheckRecipeResult endRecipeProcessing(GT_MetaTileEntity_MultiBlockBase controller) { + try{ + return super.endRecipeProcessing(controller);}finally{ + for (int index = 0; index < SLOT_COUNT; index++) { + updateInformationSlot(index); + } + } + +}BaseActionSource requestSource; + private BaseActionSource getRequestSource() { + if (requestSource == null) requestSource = new MachineSource((IActionHost) getBaseMetaTileEntity()); + return requestSource; + } + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + + return new RestrictedInputHatchME(mName, false, mTier, mDescriptionArray, mTextures); + + } + private static final int CONFIG_WINDOW_ID=123456; + @Override + public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) { + + buildContext.addSyncedWindow(CONFIG_WINDOW_ID, this::createStackSizeConfigurationWindow); + builder.widget(new ButtonWidget().setOnClick((clickData, widget) -> { + if ( !widget.isClient()) { + widget.getContext() + .openSyncedWindow(CONFIG_WINDOW_ID); + } + }) + .setPlayClickSound(true) + .setBackground(() -> { + if (autoPullFluidList) { + return new IDrawable[] { GT_UITextures.BUTTON_STANDARD_PRESSED, + GT_UITextures.OVERLAY_BUTTON_AUTOPULL_ME }; + } else { + return new IDrawable[] { GT_UITextures.BUTTON_STANDARD, + GT_UITextures.OVERLAY_BUTTON_AUTOPULL_ME_DISABLED }; + } + }) + .addTooltips( + Arrays.asList( + StatCollector.translateToLocal("proghatches.restricted.configure") + )) + .setSize(16, 16) + .setPos(80, 10)); + // .widget(new FakeSyncWidget.BooleanSyncer(() -> autoPullFluidList, this::setAutoPullFluidList)); + + + super.addUIWidgets(builder, buildContext); + + } + boolean multiples; + ButtonWidget createMultiplesModeButton(IWidgetBuilder builder,int HEIGHT) { + + Widget button = new ButtonWidget().setOnClick((clickData, widget) -> { + + multiples=!multiples; + }).attachSyncer(new FakeSyncWidget.BooleanSyncer(()->multiples, val -> { + multiples=val; + }), builder) + .setBackground(() -> { + if (multiples) { + return new IDrawable[] { GT_UITextures.BUTTON_STANDARD_PRESSED, + GT_UITextures.OVERLAY_BUTTON_POWER_SWITCH_ON }; + } else { + return new IDrawable[] { GT_UITextures.BUTTON_STANDARD, + GT_UITextures.OVERLAY_BUTTON_POWER_SWITCH_OFF }; + } + }) + .addTooltip(LangManager.translateToLocal("proghatches.restricted.multiples")) + .setTooltipShowUpDelay(TOOLTIP_DELAY) + + .setPos(new Pos2d(3, HEIGHT-3-16)).setSize(16, 16); + return (ButtonWidget) button; + } + protected ModularWindow createStackSizeConfigurationWindow(final EntityPlayer player) { + final int WIDTH = 78; + final int HEIGHT = 80+18; + final int PARENT_WIDTH = getGUIWidth(); + final int PARENT_HEIGHT = getGUIHeight(); + ModularWindow.Builder builder = ModularWindow.builder(WIDTH, HEIGHT); + builder.setBackground(GT_UITextures.BACKGROUND_SINGLEBLOCK_DEFAULT); + builder.setGuiTint(getGUIColorization()); + builder.setDraggable(true); + builder.setPos( + (size, window) -> Alignment.Center.getAlignedPos(size, new Size(PARENT_WIDTH, PARENT_HEIGHT)) + .add( + Alignment.TopRight.getAlignedPos(new Size(PARENT_WIDTH, PARENT_HEIGHT), new Size(WIDTH, HEIGHT)) + .add(WIDTH - 3, 0))); + builder.widget( + TextWidget.localised("proghatches.restricted.bound.down") + .setPos(3, 2) + .setSize(74, 14)) + .widget( + new NumericWidget().setSetter(val -> restrict_lowbound = (int) val) + .setGetter(() -> restrict_lowbound) + .setBounds(1, Integer.MAX_VALUE) + .setScrollValues(1, 4, 64) + .setTextAlignment(Alignment.Center) + .setTextColor(Color.WHITE.normal) + .setSize(70, 18) + .setPos(3, 18) + .setBackground(GT_UITextures.BACKGROUND_TEXT_FIELD)); + builder.widget( + TextWidget.localised("proghatches.restricted.bound.up") + .setPos(3, 42) + .setSize(74, 14)) + .widget( + new NumericWidget().setSetter(val -> restrict = (int) val) + .setGetter(() -> restrict) + .setBounds(1, Integer.MAX_VALUE) + .setScrollValues(1, 4, 64) + .setTextAlignment(Alignment.Center) + .setTextColor(Color.WHITE.normal) + .setSize(70, 18) + .setPos(3, 58) + .setBackground(GT_UITextures.BACKGROUND_TEXT_FIELD)); + builder.widget(createMultiplesModeButton(builder,HEIGHT)); + return builder.build(); + } +int restrict=Integer.MAX_VALUE; +int restrict_lowbound=1; +@Override +public void saveNBTData(NBTTagCompound aNBT) { + super.saveNBTData(aNBT); + aNBT.setInteger("restrict", restrict); + aNBT.setInteger("restrict_l", restrict_lowbound); + aNBT.setBoolean("multiples", multiples); + } +@Override +public void loadNBTData(NBTTagCompound aNBT) { + super.loadNBTData(aNBT); + restrict=aNBT.getInteger( "restrict"); + restrict_lowbound=aNBT.getInteger( "restrict_l"); + multiples=aNBT.getBoolean("multiples"); +} + + +} diff --git a/src/main/java/reobf/proghatches/main/CommonProxy.java b/src/main/java/reobf/proghatches/main/CommonProxy.java index 3a07fb5..0f009f0 100644 --- a/src/main/java/reobf/proghatches/main/CommonProxy.java +++ b/src/main/java/reobf/proghatches/main/CommonProxy.java @@ -13,6 +13,7 @@ import gregtech.api.util.GT_ModHandler; import mcp.mobius.waila.api.IWailaRegistrar; import reobf.proghatches.Tags; +import reobf.proghatches.ae.ItemPartAmountMaintainer; import reobf.proghatches.block.BlockAnchorAlert; import reobf.proghatches.block.BlockIOHub; import reobf.proghatches.block.ItemBlockAnchorAlert; @@ -140,6 +141,15 @@ public void preInit(FMLPreInitializationEvent event) { MyMod.euinterface_p2p = new ItemPartEUP2PInterface() .setUnlocalizedName("proghatches.euinterface.p2p").setTextureName("?"), "proghatches.euinterface.p2p"); + GameRegistry + .registerItem( + MyMod.amountmaintainer = new ItemPartAmountMaintainer() + .setUnlocalizedName("proghatches.amountmaintainer").setTextureName("?"), + "amountmaintainer"); + + + + } public static ProgHatchCreativeTab tab; diff --git a/src/main/java/reobf/proghatches/main/MyMod.java b/src/main/java/reobf/proghatches/main/MyMod.java index e2ce3cd..84a0cbb 100644 --- a/src/main/java/reobf/proghatches/main/MyMod.java +++ b/src/main/java/reobf/proghatches/main/MyMod.java @@ -171,6 +171,7 @@ public class MyMod { public static Item lazer_p2p_part; public static Item upgrades; public static Block alert; + public static Item amountmaintainer; @Mod.EventHandler // preInit "Run before anything else. Read your config, create blocks, diff --git a/src/main/java/reobf/proghatches/main/registration/ProgHatchCreativeTab.java b/src/main/java/reobf/proghatches/main/registration/ProgHatchCreativeTab.java index 41ae8bc..2a88680 100644 --- a/src/main/java/reobf/proghatches/main/registration/ProgHatchCreativeTab.java +++ b/src/main/java/reobf/proghatches/main/registration/ProgHatchCreativeTab.java @@ -56,6 +56,7 @@ public void displayAllReleventItems(List p_78018_1_) { p_78018_1_.add(new ItemStack(MyMod.alert, 1)); p_78018_1_.add(new ItemStack(MyMod.lazer_p2p_part)); p_78018_1_.add(new ItemStack(ConfigItems.itemGolemCore,1,120)); + p_78018_1_.add(new ItemStack(MyMod.amountmaintainer)); // p_78018_1_.add(new ItemStack(MyMod.euupgrade, 1)); } diff --git a/src/main/java/reobf/proghatches/main/registration/Registration.java b/src/main/java/reobf/proghatches/main/registration/Registration.java index 3628a38..eb638b6 100644 --- a/src/main/java/reobf/proghatches/main/registration/Registration.java +++ b/src/main/java/reobf/proghatches/main/registration/Registration.java @@ -43,6 +43,8 @@ import reobf.proghatches.gt.metatileentity.ProviderChainer; import reobf.proghatches.gt.metatileentity.RemoteInputBus; import reobf.proghatches.gt.metatileentity.RemoteInputHatch; +import reobf.proghatches.gt.metatileentity.RestrictedInputBusME; +import reobf.proghatches.gt.metatileentity.RestrictedInputHatchME; import reobf.proghatches.gt.metatileentity.SuperChestME; import reobf.proghatches.gt.metatileentity.SuperTankME; import reobf.proghatches.gt.metatileentity.SuperfluidHatch; @@ -83,7 +85,8 @@ public class Registration implements Runnable { public static final int MultiCircuitDualInputHatchOffset = 154;//-157 public static final int MultiCircuitQuadDualInputHatchOffset = 158;//-161 public static final int DataHatchMEOffset = 162; - + public static final int RestrictedHatchME = 163; + public static final int RestrictedBusME=164; @SuppressWarnings("deprecation") @Override public void run() { @@ -383,6 +386,22 @@ public void run() { ); + + new RestrictedInputHatchME( + Config.metaTileEntityOffset + RestrictedHatchME, + false, "fluid.input.me.restriced", + LangManager.translateToLocalFormatted("fluid.input.me.restriced.name") + + ); + new RestrictedInputBusME( + Config.metaTileEntityOffset + RestrictedBusME, + false, "fluid.input.bus.me.restriced", + LangManager.translateToLocalFormatted("fluid.input.bus.me.restriced.name") + + ); + + + /*for (int i = 0; i < 4; i++) { new DualInputHatch( diff --git a/src/main/resources/assets/proghatches/lang/en_US.lang b/src/main/resources/assets/proghatches/lang/en_US.lang index 847d9ed..9594d55 100644 --- a/src/main/resources/assets/proghatches/lang/en_US.lang +++ b/src/main/resources/assets/proghatches/lang/en_US.lang @@ -430,16 +430,17 @@ item.proghatch.upgrades.0=Virtual Circuit Slot Upgrade item.proghatch.upgrades.tooltips.1=4 item.proghatch.upgrades.tooltips.1.0=Right click a Dual Input Hatch to install. item.proghatch.upgrades.tooltips.1.1=Each installed Upgrade provides an extra ME Item slot. -item.proghatch.upgrades.tooltips.1.2=1 Upgrade acceptable at max +item.proghatch.upgrades.tooltips.1.2=4 Stocking Upgrades acceptable at max item.proghatch.upgrades.tooltips.1.3=Harvest the Hatch to retrieve installed Upgrades. -item.proghatch.upgrades.1=ME Stock Item Upgrade +item.proghatch.upgrades.1=ME Stocking Item Upgrade programmable_hatches.gt.item.pull.me.0=Mark item to pull items from ME storgae. programmable_hatches.gt.item.pull.me.1=Access the ME storgae of the adjacent ME Interface. programmable_hatches.gt.item.pull.me.2=Only works with non-empty buffer. If all Buffers are empty, this will not be accessed! +item.proghatch.upgrades.2=ME Stocking Fluid Upgrade item.proghatch.upgrades.tooltips.2=4 item.proghatch.upgrades.tooltips.2.0=Right click a Dual Input Hatch to install. item.proghatch.upgrades.tooltips.2.1=Each installed Upgrade provides an extra ME Item slot. -item.proghatch.upgrades.tooltips.2.2=1 Upgrade acceptable at max +item.proghatch.upgrades.tooltips.2.2=4 Stocking Upgrades acceptable at max item.proghatch.upgrades.tooltips.2.3=Harvest the Hatch to retrieve installed Upgrades. proghatch.ingbuf.fail.cache.diff.bus=The bus#%s has %s in its cache which is different from %s. proghatch.ingbuf.fail.net.diff.bus=The bus#%s has %s in its ME storage which is different from %s. @@ -494,4 +495,29 @@ data.input.me.name=Data Access Hatch (ME) item.ItemGolemCore.120.name=Golem Core: Mainteinence proghatches.golemcore.120.hint.0=Bound Multiblock §cController§7 with Golemancer's Bell proghatches.golemcore.120.hint.1=And clear the way to the §cMainteinence Hatch§7 of the Multiblock! - +proghatches.restricted.bound.up=Maximum amount to pull: +proghatches.restricted.bound.down=Do not pull if stocking amount lower than: +proghatches.restricted.configure=Click to configure +fluid.input.me.restriced.name=Restricted Stocking Input Hatch (ME) +fluid.input.bus.me.restriced.name=Restricted Stocking Input Bus (ME) +proghatches.restricted.multiples=Restrict amount to a multiply of Minimum amount +proghatches.amountmaintainer.phantomclick.mode.0=Marked Fluid Container treated as Item +proghatches.amountmaintainer.phantomclick.mode.1=Marked Fluid Container treated as Fluid +proghatches.amountmaintainer.redstone.mode.0=Redstone Offline:Maintain Redstone Online:Maintain If On +proghatches.amountmaintainer.redstone.mode.1=Redstone Offline:Clear Redstone Online:Maintain If On +proghatches.amountmaintainer.redstone.mode.2=Redstone Offline:Maintain Redstone Online:Invert +proghatches.amountmaintainer.redstone.mode.3=Redstone Offline:Clear Redstone Online:Invert +proghatches.amountmaintainer.redstone.offline=§cOffline +proghatches.amountmaintainer.redstone.online=§aOnline +proghatches.amountmaintainer.memorycard=Use Memory Card bound to a Redstone P2P to link +item.proghatches.amountmaintainer.name=Amount Maintaining Bus +proghatches.amountmaintainer.redstone.state.on=Maintain amount to %s +proghatches.amountmaintainer.redstone.state.off=Maintain amount to 0 +proghatches.amountmaintainer.amount.0=Expected amount of item/fluid you want to maintain. +proghatches.amountmaintainer.amount.1=Specify the type of item/fluid by marking the slot on the left side. +proghatches.amountmaintainer.amount.2=The value might be overridden to 0 if Redstone config. +proghatches.amountmaintainer.amount.3=Do not affect item/fluid other than the marked item/fluid. +proghatches.amountmaintainer.phantomslot=To specify whether you want to mark the item itself or the contained fluid, use the button on the right side. +item.amountmaintainer.name.tooltip.0=Use Item/Fluid Storage to maintain the amount of Item/Fluid of target Inventory +item.amountmaintainer.name.tooltip.1=as if the target Inventory is a slot in ME Interface Config Slot. +item.amountmaintainer.name.tooltip.2=Only active for specified Item/Fluid, will not add or remove Item/Fluid of ther types. diff --git a/src/main/resources/assets/proghatches/lang/en_US/RIBME.lang b/src/main/resources/assets/proghatches/lang/en_US/RIBME.lang new file mode 100644 index 0000000..18e02f2 --- /dev/null +++ b/src/main/resources/assets/proghatches/lang/en_US/RIBME.lang @@ -0,0 +1,2 @@ +Item Input for Multiblocks +Just like Stocking Input Bus(ME), but restrict the amount to be pulled. \ No newline at end of file diff --git a/src/main/resources/assets/proghatches/lang/en_US/RIHME.lang b/src/main/resources/assets/proghatches/lang/en_US/RIHME.lang new file mode 100644 index 0000000..d7d7bdb --- /dev/null +++ b/src/main/resources/assets/proghatches/lang/en_US/RIHME.lang @@ -0,0 +1,2 @@ +Fluid Input for Multiblocks +Just like Stocking Input Hatch(ME), but restrict the amount to be pulled. \ 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 e4624fe..4c394d6 100644 --- a/src/main/resources/assets/proghatches/lang/zh_CN.lang +++ b/src/main/resources/assets/proghatches/lang/zh_CN.lang @@ -430,7 +430,7 @@ item.proghatch.upgrades.0=虚拟电路槽升级 item.proghatch.upgrades.tooltips.1=4 item.proghatch.upgrades.tooltips.1.0=右键一个二合一输入仓以安装升级 item.proghatch.upgrades.tooltips.1.1=每个升级增加一个ME物品槽 -item.proghatch.upgrades.tooltips.1.2=最多安装 1 个 +item.proghatch.upgrades.tooltips.1.2=库存升级最多安装 4 个 item.proghatch.upgrades.tooltips.1.3=拆卸输入仓回收已安装的升级 item.proghatch.upgrades.1=ME物品库存升级 programmable_hatches.gt.item.pull.me.0=标记物品以从ME存储拉取物品 @@ -440,7 +440,7 @@ item.proghatch.upgrades.2=ME流体库存升级 item.proghatch.upgrades.tooltips.2=4 item.proghatch.upgrades.tooltips.2.0=右键一个二合一输入仓以安装升级 item.proghatch.upgrades.tooltips.2.1=每个升级增加一个ME流体槽 -item.proghatch.upgrades.tooltips.2.2=最多安装 1 个 +item.proghatch.upgrades.tooltips.2.2=库存升级最多安装 4 个 item.proghatch.upgrades.tooltips.2.3=拆卸输入仓回收已安装的升级 proghatch.ingbuf.fail.cache.diff.bus=%s号ME输出总线内部缓存含有:%s 因此无法(在阻挡模式开启时)接受类型不同的物品:%s. proghatch.ingbuf.fail.net.diff.bus=%s号ME输出总线所在ME网络含有:%s 因此无法(在阻挡模式开启时)接受类型不同的物品:%s. @@ -495,3 +495,30 @@ data.input.me.name=数据访问仓 (ME) item.ItemGolemCore.120.name=傀儡核心: 维护 proghatches.golemcore.120.hint.0=使用傀儡使铃铛绑定多方块结构的§c主方块§7 proghatches.golemcore.120.hint.1=并确保前往多方块结构的§c维护仓§7的路畅通无阻! +proghatches.restricted.bound.up=拉取数量上限: +proghatches.restricted.bound.down=禁止拉取的数量下限: +proghatches.restricted.configure=点击配置 +fluid.input.me.restriced.name=限制存储输入仓(ME) +fluid.input.bus.me.restriced.name=限制存储输入总线(ME) +proghatches.restricted.multiples=限制拉取数量为数量下限的整数倍 +proghatches.amountmaintainer.phantomclick.mode.0=标记的流体容器识别为物品 +proghatches.amountmaintainer.phantomclick.mode.1=标记的流体容器识别为流体 +proghatches.amountmaintainer.redstone.mode.0=红石离线时维持 红石在线时有信号时维持 +proghatches.amountmaintainer.redstone.mode.1=红石离线时清空 红石在线时有信号时维持 +proghatches.amountmaintainer.redstone.mode.2=红石离线时维持 红石在线时有信号时清空 +proghatches.amountmaintainer.redstone.mode.3=红石离线时清空 红石在线时有信号时清空 +proghatches.amountmaintainer.redstone.offline=§c离线 +proghatches.amountmaintainer.redstone.online=§a在线 +proghatches.amountmaintainer.memorycard=使用绑定到红石P2P的内存卡标记 +item.proghatches.amountmaintainer.name=数量维持总线 +proghatches.amountmaintainer.redstone.state.on=维持数量为 %s +proghatches.amountmaintainer.redstone.state.off=维持数量为 0 +proghatches.amountmaintainer.amount.0=期望维持的物品/流体数量 +proghatches.amountmaintainer.amount.1=标记左边的槽来指定物品/流体类型 +proghatches.amountmaintainer.amount.2=根据红石配置,维持数量可能会被设为0而不是这个值 +proghatches.amountmaintainer.amount.3=不会影响标记的物品/流体以外的物品/流体 +proghatches.amountmaintainer.phantomslot=欲明确要标记物品本身还是所包含的流体,使用右侧按钮 +item.amountmaintainer.name.tooltip.0=使用存储内物品/流体来维持目标容器的物品/流体数量 +item.amountmaintainer.name.tooltip.1=就好像目标容器是ME接口的一个配置格一样 +item.amountmaintainer.name.tooltip.2=只对指定类型物品/流体活跃,不会移除或加入其它类型物品/流体 + diff --git a/src/main/resources/assets/proghatches/lang/zh_CN/RIBME.lang b/src/main/resources/assets/proghatches/lang/zh_CN/RIBME.lang new file mode 100644 index 0000000..e921387 --- /dev/null +++ b/src/main/resources/assets/proghatches/lang/zh_CN/RIBME.lang @@ -0,0 +1,2 @@ +多方块机器的物品输入 +类似存储输入总线(ME),但能限制拉取的数量 \ No newline at end of file diff --git a/src/main/resources/assets/proghatches/lang/zh_CN/RIHME.lang b/src/main/resources/assets/proghatches/lang/zh_CN/RIHME.lang new file mode 100644 index 0000000..d7e7483 --- /dev/null +++ b/src/main/resources/assets/proghatches/lang/zh_CN/RIHME.lang @@ -0,0 +1,2 @@ +多方块机器的流体输入 +类似存储输入仓(ME),但能限制拉取的数量 \ No newline at end of file diff --git a/src/main/resources/assets/proghatches/textures/blocks/amountmaintainer.png b/src/main/resources/assets/proghatches/textures/blocks/amountmaintainer.png new file mode 100644 index 0000000..2afd3b0 Binary files /dev/null and b/src/main/resources/assets/proghatches/textures/blocks/amountmaintainer.png differ