diff --git a/src/main/java/reobf/proghatches/ae/ItemPartMAP2P.java b/src/main/java/reobf/proghatches/ae/ItemPartMAP2P.java new file mode 100644 index 0000000..0ee72ac --- /dev/null +++ b/src/main/java/reobf/proghatches/ae/ItemPartMAP2P.java @@ -0,0 +1,95 @@ +package reobf.proghatches.ae; + +import java.util.List; + +import javax.annotation.Nullable; + +import appeng.api.AEApi; +import appeng.api.parts.IPart; +import appeng.api.parts.IPartItem; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.enums.GT_Values; +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.PartLazerP2P; + +public class ItemPartMAP2P extends Item implements IPartItem { + @SideOnly(Side.CLIENT) + private IIcon icon; + + + public ItemPartMAP2P() { + this.setMaxStackSize(64); + + AEApi.instance().partHelper().setItemBusRenderer(this); + setHasSubtypes(true); + } + + @Nullable + @Override + public IPart createPartFromItemStack(ItemStack is) { + return new PartMAP2P(is); + } + @Override + public String getItemStackDisplayName(ItemStack stack) { + /*int damage=stack.getItemDamage(); + if(damage>=1&&damage<=15){ + return StatCollector.translateToLocalFormatted("item.proghatches.part.eu.source.superconduct.name",GT_Values.VN[damage-1]); + } + if(damage>=16&&damage<=30){ + return StatCollector.translateToLocalFormatted("item.proghatches.part.eu.source.normal.name",GT_Values.VN[damage-16]); + } */ + return super.getItemStackDisplayName(stack); + } + + @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 register) { + + this.icon = register.registerIcon("appliedenergistics2:ItemPart.P2PTunnel"); + } + @SideOnly(Side.CLIENT) + @Override + public IIcon getIconFromDamage(int dmg) { + return icon; + } + /* +@Override +public IIcon getIconIndex(ItemStack p_77650_1_) { + + return PartEUSource.a; +}*/ + @Override + @SideOnly(Side.CLIENT) + public int getSpriteNumber() { + return 0; + } +@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.proghatches.part.ma.p2p.tooltips.0")); + p_77624_3_.add(StatCollector.translateToLocal("item.proghatches.part.ma.p2p.tooltips.1")); + p_77624_3_.add(StatCollector.translateToLocal("item.proghatches.part.ma.p2p.tooltips.2")); + // + super.addInformation(p_77624_1_, p_77624_2_, p_77624_3_, p_77624_4_); +} + +} diff --git a/src/main/java/reobf/proghatches/ae/ItemPartStockingExportBus.java b/src/main/java/reobf/proghatches/ae/ItemPartStockingExportBus.java new file mode 100644 index 0000000..d365486 --- /dev/null +++ b/src/main/java/reobf/proghatches/ae/ItemPartStockingExportBus.java @@ -0,0 +1,103 @@ +package reobf.proghatches.ae; + + + +import java.util.List; + +import javax.annotation.Nullable; + +import appeng.api.AEApi; +import appeng.api.parts.IPart; +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.creativetab.CreativeTabs; +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 ItemPartStockingExportBus extends Item implements IPartItem { + + public ItemPartStockingExportBus() { + this.setMaxStackSize(64); + + AEApi.instance().partHelper().setItemBusRenderer(this); + } + @Override + public void getSubItems(Item itemIn, CreativeTabs p_150895_2_, List list) { + + list.add(new ItemStack(itemIn, 1, 0)); + list.add(new ItemStack(itemIn, 1, 1)); + //list.add(new ItemStack(itemIn, 1, 1)); + // list.add(new ItemStack(itemIn, 1, 2)); + } + + @Override + public boolean getHasSubtypes() { + + return true; + } + @Override + public String getUnlocalizedName(ItemStack stack) { + + return super.getUnlocalizedName(stack)+"."+stack.getItemDamage(); + } + @Nullable + @Override + public IPart createPartFromItemStack(ItemStack is) { + if(is.getItemDamage()==1) return new PartStockingFluidExportBus(is); + + return new PartStockingExportBus(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.stockingexport.name.tooltip.0."+p_77624_1_.getItemDamage())); + p_77624_3_.add(StatCollector.translateToLocal("item.stockingexport.name.tooltip.1."+p_77624_1_.getItemDamage())); + + //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) { + + itemIcon=_iconRegister.registerIcon("proghatches:proxy_item_part"); + alt=_iconRegister.registerIcon("proghatches:proxy_fluid_part"); + alt2=_iconRegister.registerIcon("proghatches:proxy_item_adv_part"); + } + IIcon alt; + IIcon alt2; +@Override +public IIcon getIconIndex(ItemStack p_77650_1_) { +if(p_77650_1_.getItemDamage()==1)return alt; +if(p_77650_1_.getItemDamage()==0)return alt2; + 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 index cd7336b..49cec75 100644 --- a/src/main/java/reobf/proghatches/ae/PartAmountMaintainer.java +++ b/src/main/java/reobf/proghatches/ae/PartAmountMaintainer.java @@ -6,6 +6,7 @@ import java.util.List; import java.util.Map; import java.util.Objects; +import java.util.Set; import java.util.concurrent.Future; import com.glodblock.github.common.item.ItemFluidDrop; @@ -67,6 +68,7 @@ import appeng.api.storage.data.IAEItemStack; import appeng.api.storage.data.IAEStack; import appeng.api.storage.data.IItemList; +import appeng.api.util.IConfigManager; import appeng.client.texture.CableBusTextures; import appeng.core.Api; import appeng.core.api.definitions.ApiItems; @@ -107,6 +109,75 @@ public class PartAmountMaintainer extends PartBasicState implements IGuiProvidingPart,IGridTickable,IPowerChannelState, ICraftingRequester{ + @Override + public IConfigManager getConfigManager() { + + return new IConfigManager() { + + @Override + public void writeToNBT(NBTTagCompound data) { + data.setLong("freq", freq); + data.setInteger("mode", mode); + data.setInteger("rsmode", rsmode); + data.setInteger("redstone", redstone); + data.setLong("amount", amount); + //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())); + + + + } + + @Override + public void registerSetting(Settings settingName, Enum defaultValue) { + + + } + + @Override + public void readFromNBT(NBTTagCompound data) { + freq=data.getLong("freq"); + mode=data.getInteger("mode"); + rsmode=data.getInteger("rsmode"); + redstone=data.getInteger("redstone"); + amount=data.getLong("amount"); + //lastredstone=data.getBoolean("lastredstone" ); + if(data.getCompoundTag("mark").hasNoTags()==false) + mark[0]=ItemStack.loadItemStackFromNBT(data.getCompoundTag("mark")); + //upgrade[0]=ItemStack.loadItemStackFromNBT(data.getCompoundTag("upgrade")); + //upgrade[1]=ItemStack.loadItemStackFromNBT(data.getCompoundTag("upgrade1")); + + + + + + } + + @Override + public Enum putSetting(Settings settingName, Enum newValue) { + + return null; + } + + @Override + public Set getSettings() { + + return null; + } + + @Override + public Enum getSetting(Settings settingName) { + + return null; + } + }; + } + + + + private int mode; private int rsmode; @@ -862,4 +933,28 @@ public void validateLink(){ } +/* +@Override +public Set getSettings() { + + return null; +} + +@Override +public void registerSetting(Settings settingName, Enum defaultValue) { + + +} + +@Override +public Enum getSetting(Settings settingName) { + + return null; +} + +@Override +public Enum putSetting(Settings settingName, Enum newValue) { + + return null; +}*/ } diff --git a/src/main/java/reobf/proghatches/ae/PartMAP2P.java b/src/main/java/reobf/proghatches/ae/PartMAP2P.java new file mode 100644 index 0000000..4dd3da1 --- /dev/null +++ b/src/main/java/reobf/proghatches/ae/PartMAP2P.java @@ -0,0 +1,209 @@ +package reobf.proghatches.ae; + +import java.lang.ref.WeakReference; +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashSet; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; +import java.util.function.Supplier; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import com.google.common.collect.Iterables; + +import appeng.api.implementations.tiles.ICraftingMachine; +import appeng.api.networking.crafting.ICraftingPatternDetails; +import appeng.api.parts.IPart; +import appeng.api.parts.IPartHost; +import appeng.api.parts.IPartRenderHelper; +import appeng.api.util.AEColor; +import appeng.client.texture.CableBusTextures; +import appeng.me.GridAccessException; +import appeng.parts.p2p.PartP2PTunnelStatic; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.init.Blocks; +import net.minecraft.inventory.InventoryCrafting; +import net.minecraft.item.ItemStack; +import net.minecraft.server.MinecraftServer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.IIcon; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.IFluidHandler; +import reobf.proghatches.fmp.ICraftingMachinePart; +import reobf.proghatches.fmp.LayerCraftingMachine.StateHolder; + +public class PartMAP2P extends PartP2PTunnelStatic implements ICraftingMachinePart { + + public PartMAP2P(ItemStack is) { + super(is); + + } + + @Override + public boolean pushPattern(ICraftingPatternDetails patternDetails, InventoryCrafting table, + ForgeDirection ejectionDirection) { + if (isOutput()) { + return false; + } + if (getFrequency() == 0) { + return false; + } + + if(tick==MinecraftServer.getServer().getTickCounter()){ + //same tick... try the one found in acceptsPlans! + ICraftingMachine val; + if((val=candidate.get())!=null&&val.pushPattern(patternDetails,table,ejectionDirection)){return true;} + } + //direct call to pushPattern? or acceptsPlans but push failed? + //just iterate again to find another valid! + for(ICraftingMachine ep:getOuputEndpoints(null)){ + if(ep.pushPattern(patternDetails,table,ejectionDirection)){return true;} + } + return false; + } + + WeakReference candidate=new WeakReference<>(null); + int tick; + @Override + public boolean acceptsPlans(ForgeDirection ejectionDirection) { + try{ + + if(chain.contains(this)){return false;} + chain.add(this);if (isOutput()) { + return false; + } + if (getFrequency() == 0) { + return false; + } + + for(ICraftingMachine ep:getOuputEndpoints(null)){ + if(ep.acceptsPlans()){ + tick=MinecraftServer.getServer().getTickCounter(); + candidate=new WeakReference(ep); + return true;} + } + + + return false;}finally{ + chain.remove(this); + } + } + private TileEntity getTarget() { + if (!this.getProxy().isActive()) { + return null; + } + + + + final TileEntity te = this.getTile().getWorldObj().getTileEntity( + this.getTile().xCoord + this.getSide().offsetX, + this.getTile().yCoord + this.getSide().offsetY, + this.getTile().zCoord + this.getSide().offsetZ); + + + return te; + } + + + public static HashSet chain=new HashSet(); + public Collection getOuputEndpoints(Collection ret) { + try{ + if(ret==null) + ret=new LinkedList<>(); + if(chain.contains(this)){return ret;} + chain.add(this); + + final Collection fret=ret; + + try { + getOutputs().forEach((out)->{ + + TileEntity te = out.getTarget(); + if(te==null){return;} + if(te instanceof IPartHost){ + //shortcut fot recursive p2p + IPart p=((IPartHost) te).getPart(side.getOpposite()); + if( p instanceof PartMAP2P){ + + ((PartMAP2P)p).getOuputEndpoints(fret); + return; + } + } + if(te instanceof ICraftingMachine){ + + ForgeDirection old=StateHolder.state; + StateHolder.state=out.getSide().getOpposite(); + fret.add((ICraftingMachine) te); + StateHolder.state=old; + } + + + }); + } catch (GridAccessException e) { + + } + + + + + + return ret;}finally{ + chain.remove(this); + } + } + + @Override + @SideOnly(Side.CLIENT) + public void renderInventory(final IPartRenderHelper rh, final RenderBlocks renderer) { + rh.setTexture(Blocks.crafting_table.getIcon(1, 0)); + + rh.setBounds(2, 2, 14, 14, 14, 16); + rh.renderInventoryBox(renderer); + + rh.setTexture(CableBusTextures.PartTunnelSides.getIcon(), CableBusTextures.PartTunnelSides.getIcon(), + CableBusTextures.BlockP2PTunnel2.getIcon(), this.getItemStack().getIconIndex(), + CableBusTextures.PartTunnelSides.getIcon(), CableBusTextures.PartTunnelSides.getIcon()); + + rh.setBounds(2, 2, 14, 14, 14, 16); + 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(Blocks.crafting_table.getIcon(1, 0)); + + + rh.setBounds(2, 2, 14, 14, 14, 16); + rh.renderBlock(x, y, z, renderer); + + rh.setTexture(CableBusTextures.PartTunnelSides.getIcon(), CableBusTextures.PartTunnelSides.getIcon(), + CableBusTextures.BlockP2PTunnel2.getIcon(), this.getItemStack().getIconIndex(), + CableBusTextures.PartTunnelSides.getIcon(), CableBusTextures.PartTunnelSides.getIcon()); + + rh.setBounds(2, 2, 14, 14, 14, 16); + rh.renderBlock(x, y, z, renderer); + + rh.setBounds(3, 3, 13, 13, 13, 14); + rh.renderBlock(x, y, z, renderer); + + rh.setTexture(CableBusTextures.BlockP2PTunnel3.getIcon()); + + rh.setBounds(6, 5, 12, 10, 11, 13); + rh.renderBlock(x, y, z, renderer); + + rh.setBounds(5, 6, 12, 11, 10, 13); + rh.renderBlock(x, y, z, renderer); + + this.renderLights(x, y, z, rh, renderer); + } +} diff --git a/src/main/java/reobf/proghatches/ae/PartStockingExportBus.java b/src/main/java/reobf/proghatches/ae/PartStockingExportBus.java new file mode 100644 index 0000000..a15062f --- /dev/null +++ b/src/main/java/reobf/proghatches/ae/PartStockingExportBus.java @@ -0,0 +1,372 @@ +package reobf.proghatches.ae; + +import static gregtech.api.metatileentity.BaseTileEntity.TOOLTIP_DELAY; + +import com.google.common.collect.ImmutableList; +import com.gtnewhorizons.modularui.api.ModularUITextures; +import com.gtnewhorizons.modularui.api.forge.ItemStackHandler; +import com.gtnewhorizons.modularui.api.math.Color; +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.api.screen.UIBuildContext; +import com.gtnewhorizons.modularui.common.widget.CycleButtonWidget; +import com.gtnewhorizons.modularui.common.widget.FluidSlotWidget; +import com.gtnewhorizons.modularui.common.widget.SlotWidget; +import com.gtnewhorizons.modularui.common.widget.textfield.TextFieldWidget; + +import appeng.api.config.Actionable; +import appeng.api.config.FuzzyMode; +import appeng.api.config.SchedulingMode; +import appeng.api.config.Settings; +import appeng.api.config.Upgrades; +import appeng.api.implementations.items.IUpgradeModule; +import appeng.api.networking.IGridNode; +import appeng.api.networking.crafting.ICraftingGrid; +import appeng.api.networking.crafting.ICraftingPatternDetails; +import appeng.api.networking.energy.IEnergyGrid; +import appeng.api.networking.security.IActionHost; +import appeng.api.networking.security.MachineSource; +import appeng.api.networking.ticking.IGridTickable; +import appeng.api.networking.ticking.TickRateModulation; +import appeng.api.networking.ticking.TickingRequest; +import appeng.api.parts.IPartCollisionHelper; +import appeng.api.parts.IPartRenderHelper; +import appeng.api.storage.IMEInventory; +import appeng.api.storage.IMEMonitor; +import appeng.api.storage.data.IAEFluidStack; +import appeng.api.storage.data.IAEItemStack; +import appeng.client.texture.CableBusTextures; +import appeng.core.settings.TickRates; +import appeng.me.GridAccessException; +import appeng.me.helpers.IGridProxyable; +import appeng.parts.PartBasicState; +import appeng.parts.automation.PartExportBus; +import appeng.util.InventoryAdaptor; +import appeng.util.Platform; +import appeng.util.prioitylist.OreFilteredList; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.gui.modularui.GT_UITextures; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.InventoryCrafting; +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.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import reobf.proghatches.eucrafting.EUUtil; +import reobf.proghatches.eucrafting.IGuiProvidingPart; +import reobf.proghatches.fmp.ICraftingMachinePart; +import reobf.proghatches.gt.metatileentity.util.MappingFluidTank; +import reobf.proghatches.gt.metatileentity.util.MappingItemHandler; + +public class PartStockingExportBus extends PartBasicState implements + +IGridProxyable, IActionHost,IGuiProvidingPart,IGridTickable,ICraftingMachinePart{ + + + + + + + +ItemStack[] inv=new ItemStack[1]; + +@Override +public void writeToNBT(NBTTagCompound data) { + if(inv[0]!=null){ + data.setTag("theslot", + inv[0].writeToNBT(new NBTTagCompound()));} + super.writeToNBT(data); +} +@Override +public void readFromNBT(NBTTagCompound data) { + inv[0]=ItemStack.loadItemStackFromNBT(data.getCompoundTag("theslot")); + super.readFromNBT(data); +} + + + private InventoryAdaptor adaptor; + private int adaptorHash; + public PartStockingExportBus(ItemStack is) { + super(is); + + }protected int getGUIWidth() { + return 176; + } + + protected int getGUIHeight() { + return 107 + 18 * 3 + 18; + } + + @Override + public ModularWindow createWindow(UIBuildContext buildContext) { + ModularWindow.Builder builder = ModularWindow.builder(getGUIWidth(), getGUIHeight()); + builder.setBackground(ModularUITextures.VANILLA_BACKGROUND); + builder.bindPlayerInventory(buildContext.getPlayer()); + + builder.widget(new SlotWidget(new ItemStackHandler(inv){ + @Override + public int getSlotLimit(int slot) { + + return 16; + } + @Override + public boolean isItemValid(int slot, ItemStack stack) { + if(stack.getItem() instanceof IUpgradeModule){ + return ((IUpgradeModule) stack.getItem()).getType(stack)==Upgrades.SPEED|| + ((IUpgradeModule) stack.getItem()).getType(stack)==Upgrades.SUPERSPEED + ; + } + return false; + } + + }, 0).setPos(3, 3)); + + + return builder.build(); + } + + + @Override + public TickingRequest getTickingRequest(final IGridNode node) { + return new TickingRequest(TickRates.ExportBus.getMin(), TickRates.ExportBus.getMax(), false, false); + } + + + @Override + public void getBoxes(final IPartCollisionHelper bch) { + bch.addBox(4, 4, 12, 12, 12, 14); + bch.addBox(5, 5, 14, 11, 11, 15); + bch.addBox(6, 6, 15, 10, 10, 16); + bch.addBox(6, 6, 11, 10, 10, 12); + } + + @Override + @SideOnly(Side.CLIENT) + public void renderInventory(final IPartRenderHelper rh, final RenderBlocks renderer) { + rh.setTexture( + CableBusTextures.PartExportSides.getIcon(), + CableBusTextures.PartExportSides.getIcon(), + CableBusTextures.PartMonitorBack.getIcon(), + this.getItemStack().getIconIndex(), + CableBusTextures.PartExportSides.getIcon(), + CableBusTextures.PartExportSides.getIcon()); + + rh.setBounds(4, 4, 12, 12, 12, 14); + rh.renderInventoryBox(renderer); + + rh.setBounds(5, 5, 14, 11, 11, 15); + rh.renderInventoryBox(renderer); + + rh.setBounds(6, 6, 15, 10, 10, 16); + 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.PartExportSides.getIcon(), + CableBusTextures.PartExportSides.getIcon(), + CableBusTextures.PartMonitorBack.getIcon(), + this.getItemStack().getIconIndex(), + CableBusTextures.PartExportSides.getIcon(), + CableBusTextures.PartExportSides.getIcon()); + + rh.setBounds(4, 4, 12, 12, 12, 14); + rh.renderBlock(x, y, z, renderer); + + rh.setBounds(5, 5, 14, 11, 11, 15); + rh.renderBlock(x, y, z, renderer); + + rh.setBounds(6, 6, 15, 10, 10, 16); + 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(6, 6, 11, 10, 10, 12); + rh.renderBlock(x, y, z, renderer); + + this.renderLights(x, y, z, rh, renderer); + } + + @Override + public int cableConnectionRenderTo() { + return 5; + } + protected boolean canDoBusWork() { + final TileEntity self = this.getHost().getTile(); + final World world = self.getWorldObj(); + final int xCoordinate = self.xCoord + this.getSide().offsetX; + final int zCoordinate = self.zCoord + this.getSide().offsetZ; + + return world != null && world.getChunkProvider().chunkExists(xCoordinate >> 4, zCoordinate >> 4); + } private TileEntity getTileEntity(final TileEntity self, final int x, final int y, final int z) { + final World w = self.getWorldObj(); + + if (w.getChunkProvider().chunkExists(x >> 4, z >> 4)) { + return w.getTileEntity(x, y, z); + } + + return null; + } + protected InventoryAdaptor getHandler() { + final TileEntity self = this.getHost().getTile(); + final TileEntity target = this.getTileEntity( + self, + self.xCoord + this.getSide().offsetX, + self.yCoord + this.getSide().offsetY, + self.zCoord + this.getSide().offsetZ); + + final int newAdaptorHash = Platform.generateTileHash(target); + + if (this.adaptorHash == newAdaptorHash && newAdaptorHash != 0) { + return this.adaptor; + } + + this.adaptorHash = newAdaptorHash; + this.adaptor = InventoryAdaptor.getAdaptor(target, this.getSide().getOpposite()); + + return this.adaptor; + } + @Override + public TickRateModulation tickingRequest(IGridNode node, int TicksSinceLastCall) { + if (!this.getProxy().isActive() || !this.canDoBusWork()) { + return TickRateModulation.IDLE; + } + try { + final InventoryAdaptor destination = this.getHandler(); + final IMEMonitor inv = this.getProxy().getStorage().getItemInventory(); + final IEnergyGrid energy = this.getProxy().getEnergy(); + didSomething=false; + + + + IMEMonitor iinv = getProxy().getStorage().getItemInventory(); + itemToSend=calculateItemsToSend(); + for(IAEItemStack iae:iinv.getStorageList()){ + //IAEItemStack iae=iinv.getStorageList().getFirstItem(); + if(iae==null)break; + + final IAEItemStack itemsToAdd = inv.extractItems(iae.copy().setStackSize(itemToSend), Actionable.SIMULATE, this.mySrc); + if(itemsToAdd==null)break; + this.pushItemIntoTarget(destination, energy, inv, itemsToAdd); + + if(itemToSend<=0)break; + + + } + + + } catch (GridAccessException e) { + //bruh + } + + + + + return didSomething ? TickRateModulation.FASTER : TickRateModulation.SLOWER; + } + + MachineSource mySrc = new MachineSource(this); + private long itemToSend; + private boolean didSomething; + private void pushItemIntoTarget(final InventoryAdaptor d, final IEnergyGrid energy, + final IMEInventory inv, IAEItemStack ais) { + final ItemStack is = ais.getItemStack(); + is.stackSize = (int) this.itemToSend; + if(this.itemToSend>Integer.MAX_VALUE){ + this.itemToSend=Integer.MAX_VALUE; + } + final ItemStack o = d.simulateAdd(is); + final long canFit = o == null ? this.itemToSend : this.itemToSend - o.stackSize; + + if (canFit > 0) { + ais = ais.copy(); + ais.setStackSize(canFit); + final IAEItemStack itemsToAdd = Platform.poweredExtraction(energy, inv, ais, this.mySrc); + + if (itemsToAdd != null) { + this.itemToSend -= itemsToAdd.getStackSize(); + + final ItemStack failed = d.addItems(itemsToAdd.getItemStack()); + if (failed != null) { + ais.setStackSize(failed.stackSize); + inv.injectItems(ais, Actionable.MODULATE, this.mySrc); + } else { + this.didSomething = true; + } + } + } + } + + protected long calculateItemsToSend() { + + long items=1; + if(inv[0]!=null&&inv[0].getItem() instanceof IUpgradeModule){ + if( ((IUpgradeModule) inv[0].getItem()).getType(inv[0])==Upgrades.SPEED) + { + + items=items< 1; + case 1 -> 8; + case 2 -> 32; + case 3 -> 64; + case 4 -> 96; + };*/ + } + @SuppressWarnings("deprecation") + @Override + public boolean onPartActivate(EntityPlayer player, Vec3 pos) { + + if (player.isSneaking()) + return false; + TileEntity t = this.getTile(); + + EUUtil.open(player, player.getEntityWorld(), t.xCoord, t.yCoord, t.zCoord, getSide()); + + return true; + } + @Override + public boolean pushPattern(ICraftingPatternDetails patternDetails, InventoryCrafting table, + ForgeDirection ejectionDirection) { + + return false; + } + @Override + public boolean acceptsPlans(ForgeDirection ejectionDirection) { + System.out.println(ejectionDirection); + return false; + } + +} diff --git a/src/main/java/reobf/proghatches/ae/PartStockingFluidExportBus.java b/src/main/java/reobf/proghatches/ae/PartStockingFluidExportBus.java new file mode 100644 index 0000000..b9248da --- /dev/null +++ b/src/main/java/reobf/proghatches/ae/PartStockingFluidExportBus.java @@ -0,0 +1,345 @@ +package reobf.proghatches.ae; + +import static gregtech.api.metatileentity.BaseTileEntity.TOOLTIP_DELAY; + +import com.google.common.collect.ImmutableList; +import com.gtnewhorizons.modularui.api.ModularUITextures; +import com.gtnewhorizons.modularui.api.forge.ItemStackHandler; +import com.gtnewhorizons.modularui.api.math.Color; +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.api.screen.UIBuildContext; +import com.gtnewhorizons.modularui.common.widget.CycleButtonWidget; +import com.gtnewhorizons.modularui.common.widget.FluidSlotWidget; +import com.gtnewhorizons.modularui.common.widget.SlotWidget; +import com.gtnewhorizons.modularui.common.widget.textfield.TextFieldWidget; + +import appeng.api.config.Actionable; +import appeng.api.config.FuzzyMode; +import appeng.api.config.SchedulingMode; +import appeng.api.config.Settings; +import appeng.api.config.Upgrades; +import appeng.api.implementations.items.IUpgradeModule; +import appeng.api.networking.IGridNode; +import appeng.api.networking.crafting.ICraftingGrid; +import appeng.api.networking.energy.IEnergyGrid; +import appeng.api.networking.security.IActionHost; +import appeng.api.networking.security.MachineSource; +import appeng.api.networking.ticking.IGridTickable; +import appeng.api.networking.ticking.TickRateModulation; +import appeng.api.networking.ticking.TickingRequest; +import appeng.api.parts.IPartCollisionHelper; +import appeng.api.parts.IPartRenderHelper; +import appeng.api.storage.IMEInventory; +import appeng.api.storage.IMEMonitor; +import appeng.api.storage.data.IAEFluidStack; +import appeng.api.storage.data.IAEFluidStack; +import appeng.client.texture.CableBusTextures; +import appeng.core.settings.TickRates; +import appeng.me.GridAccessException; +import appeng.me.helpers.IGridProxyable; +import appeng.parts.PartBasicState; +import appeng.parts.automation.PartExportBus; +import appeng.util.InventoryAdaptor; +import appeng.util.Platform; +import appeng.util.prioitylist.OreFilteredList; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.gui.modularui.GT_UITextures; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.entity.player.EntityPlayer; +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.minecraft.world.World; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.IFluidHandler; +import reobf.proghatches.eucrafting.EUUtil; +import reobf.proghatches.eucrafting.IGuiProvidingPart; +import reobf.proghatches.gt.metatileentity.util.MappingFluidTank; +import reobf.proghatches.gt.metatileentity.util.MappingItemHandler; + +public class PartStockingFluidExportBus extends PartBasicState implements + +IGridProxyable, IActionHost,IGuiProvidingPart,IGridTickable{ +ItemStack[] inv=new ItemStack[1]; + +@Override +public void writeToNBT(NBTTagCompound data) { + if(inv[0]!=null){ + data.setTag("theslot", + inv[0].writeToNBT(new NBTTagCompound()));} + super.writeToNBT(data); +} +@Override +public void readFromNBT(NBTTagCompound data) { + inv[0]=ItemStack.loadItemStackFromNBT(data.getCompoundTag("theslot")); + super.readFromNBT(data); +} + + + + public PartStockingFluidExportBus(ItemStack is) { + super(is); + + }protected int getGUIWidth() { + return 176; + } + + protected int getGUIHeight() { + return 107 + 18 * 3 + 18; + } + + @Override + public ModularWindow createWindow(UIBuildContext buildContext) { + ModularWindow.Builder builder = ModularWindow.builder(getGUIWidth(), getGUIHeight()); + builder.setBackground(ModularUITextures.VANILLA_BACKGROUND); + builder.bindPlayerInventory(buildContext.getPlayer()); + + builder.widget(new SlotWidget(new ItemStackHandler(inv){ + @Override + public int getSlotLimit(int slot) { + + return 16; + } + @Override + public boolean isItemValid(int slot, ItemStack stack) { + if(stack.getItem() instanceof IUpgradeModule){ + return ((IUpgradeModule) stack.getItem()).getType(stack)==Upgrades.SPEED|| + ((IUpgradeModule) stack.getItem()).getType(stack)==Upgrades.SUPERSPEED + ; + } + return false; + } + + }, 0).setPos(3, 3)); + + + return builder.build(); + } + + + @Override + public TickingRequest getTickingRequest(final IGridNode node) { + return new TickingRequest(TickRates.ExportBus.getMin(), TickRates.ExportBus.getMax(), false, false); + } + + + @Override + public void getBoxes(final IPartCollisionHelper bch) { + bch.addBox(4, 4, 12, 12, 12, 14); + bch.addBox(5, 5, 14, 11, 11, 15); + bch.addBox(6, 6, 15, 10, 10, 16); + bch.addBox(6, 6, 11, 10, 10, 12); + } + + @Override + @SideOnly(Side.CLIENT) + public void renderInventory(final IPartRenderHelper rh, final RenderBlocks renderer) { + rh.setTexture( + CableBusTextures.PartExportSides.getIcon(), + CableBusTextures.PartExportSides.getIcon(), + CableBusTextures.PartMonitorBack.getIcon(), + this.getItemStack().getIconIndex(), + CableBusTextures.PartExportSides.getIcon(), + CableBusTextures.PartExportSides.getIcon()); + + rh.setBounds(4, 4, 12, 12, 12, 14); + rh.renderInventoryBox(renderer); + + rh.setBounds(5, 5, 14, 11, 11, 15); + rh.renderInventoryBox(renderer); + + rh.setBounds(6, 6, 15, 10, 10, 16); + 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.PartExportSides.getIcon(), + CableBusTextures.PartExportSides.getIcon(), + CableBusTextures.PartMonitorBack.getIcon(), + this.getItemStack().getIconIndex(), + CableBusTextures.PartExportSides.getIcon(), + CableBusTextures.PartExportSides.getIcon()); + + rh.setBounds(4, 4, 12, 12, 12, 14); + rh.renderBlock(x, y, z, renderer); + + rh.setBounds(5, 5, 14, 11, 11, 15); + rh.renderBlock(x, y, z, renderer); + + rh.setBounds(6, 6, 15, 10, 10, 16); + 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(6, 6, 11, 10, 10, 12); + rh.renderBlock(x, y, z, renderer); + + this.renderLights(x, y, z, rh, renderer); + } + + @Override + public int cableConnectionRenderTo() { + return 5; + } + protected boolean canDoBusWork() { + final TileEntity self = this.getHost().getTile(); + final World world = self.getWorldObj(); + final int xCoordinate = self.xCoord + this.getSide().offsetX; + final int zCoordinate = self.zCoord + this.getSide().offsetZ; + + return world != null && world.getChunkProvider().chunkExists(xCoordinate >> 4, zCoordinate >> 4); + } private TileEntity getTileEntity(final TileEntity self, final int x, final int y, final int z) { + final World w = self.getWorldObj(); + + if (w.getChunkProvider().chunkExists(x >> 4, z >> 4)) { + return w.getTileEntity(x, y, z); + } + + return null; + } + protected IFluidHandler getHandler() { + final TileEntity self = this.getHost().getTile(); + final TileEntity target = this.getTileEntity( + self, + self.xCoord + this.getSide().offsetX, + self.yCoord + this.getSide().offsetY, + self.zCoord + this.getSide().offsetZ); + + + + return target instanceof IFluidHandler?(IFluidHandler)target:null; + } + @Override + public TickRateModulation tickingRequest(IGridNode node, int TicksSinceLastCall) { + if (!this.getProxy().isActive() || !this.canDoBusWork()) { + return TickRateModulation.IDLE; + } + try { + final IFluidHandler te = this.getHandler(); + final IMEMonitor inv = this.getProxy().getStorage().getFluidInventory(); + final IEnergyGrid energy = this.getProxy().getEnergy(); + didSomething=false; + + + + IMEMonitor iinv = getProxy().getStorage().getFluidInventory(); + itemToSend=calculateItemsToSend(); + for(IAEFluidStack iae:iinv.getStorageList()){ + //IAEFluidStack iae=iinv.getStorageList().getFirstItem(); + if(iae==null)break; + + final IAEFluidStack itemsToAdd = inv.extractItems(iae.copy().setStackSize(itemToSend), Actionable.SIMULATE, this.mySrc); + if(itemsToAdd==null)break; + //long before=itemToSend; + this.pushItemIntoTarget(te, energy, inv, itemsToAdd); + // if(before==itemToSend)break; + if(itemToSend<=0)break; + + + } + + + } catch (GridAccessException e) { + //bruh + } + + + + + return didSomething ? TickRateModulation.FASTER : TickRateModulation.SLOWER; + } + + MachineSource mySrc = new MachineSource(this); + private long itemToSend; + private boolean didSomething; + private void pushItemIntoTarget(final IFluidHandler d, final IEnergyGrid energy, + final IMEInventory inv, IAEFluidStack ais) { + final FluidStack is = ais.getFluidStack(); + is.amount = (int) this.itemToSend; + if(this.itemToSend>Integer.MAX_VALUE){ + this.itemToSend=Integer.MAX_VALUE; + } + final int o = is.amount-d.fill(side.getOpposite(), is, false); + final long canFit = o == 0 ? this.itemToSend : this.itemToSend - o; + + if (canFit > 0) { + ais = ais.copy(); + ais.setStackSize(canFit); + final IAEFluidStack itemsToAdd = Platform.poweredExtraction(energy, inv, ais, this.mySrc); + + if (itemsToAdd != null) { + this.itemToSend -= itemsToAdd.getStackSize(); + + final long failed = itemsToAdd.getStackSize()-d.fill(side.getOpposite(),itemsToAdd.getFluidStack(),true); + if (failed >0) { + ais.setStackSize(failed); + inv.injectItems(ais, Actionable.MODULATE, this.mySrc); + } else { + this.didSomething = true; + } + } + } + } + + protected long calculateItemsToSend() { + + long items=1000; + if(inv[0]!=null&&inv[0].getItem() instanceof IUpgradeModule){ + if( ((IUpgradeModule) inv[0].getItem()).getType(inv[0])==Upgrades.SPEED) + { + + items=items< 1; + case 1 -> 8; + case 2 -> 32; + case 3 -> 64; + case 4 -> 96; + };*/ + } + + @SuppressWarnings("deprecation") + @Override + public boolean onPartActivate(EntityPlayer player, Vec3 pos) { + + if (player.isSneaking()) + return false; + TileEntity t = this.getTile(); + + EUUtil.open(player, player.getEntityWorld(), t.xCoord, t.yCoord, t.zCoord, getSide()); + + return true; + } +} diff --git a/src/main/java/reobf/proghatches/ae/TileStorageProxy.java b/src/main/java/reobf/proghatches/ae/TileStorageProxy.java index 025e142..df129ee 100644 --- a/src/main/java/reobf/proghatches/ae/TileStorageProxy.java +++ b/src/main/java/reobf/proghatches/ae/TileStorageProxy.java @@ -7,6 +7,7 @@ import java.util.EnumSet; import java.util.Iterator; import java.util.NoSuchElementException; +import java.util.Set; import java.util.function.Predicate; import javax.annotation.Nonnull; @@ -28,6 +29,7 @@ import appeng.api.config.AccessRestriction; import appeng.api.config.Actionable; import appeng.api.config.FuzzyMode; +import appeng.api.config.Settings; import appeng.api.implementations.tiles.ITileStorageMonitorable; import appeng.api.networking.GridFlags; import appeng.api.networking.IGridNode; @@ -43,6 +45,8 @@ import appeng.api.storage.data.IItemList; import appeng.api.util.AECableType; import appeng.api.util.DimensionalCoord; +import appeng.api.util.IConfigManager; +import appeng.api.util.IConfigurableObject; import appeng.helpers.ICustomNameObject; import appeng.me.GridAccessException; import appeng.me.helpers.AENetworkProxy; @@ -70,7 +74,7 @@ public class TileStorageProxy extends TileEntity implements IGridProxyable, IActionHost, IStorageMonitorable, ITileStorageMonitorable,ITileWithModularUI - + //,IConfigurableObject { boolean fluid; public AENetworkProxy gridProxy; @@ -962,6 +966,117 @@ public ModularWindow createWindow(UIBuildContext buildContext) { return builder.build(); } - + // @Override + public IConfigManager getConfigManager() { + return new IConfigManager(){ + + @Override + public Set getSettings() { + // TODO Auto-generated method stub + return null; + } + + @Override + public void registerSetting(Settings settingName, Enum defaultValue) { + // TODO Auto-generated method stub + + } + + @Override + public Enum getSetting(Settings settingName) { + // TODO Auto-generated method stub + return null; + } + + @Override + public Enum putSetting(Settings settingName, Enum newValue) { + // TODO Auto-generated method stub + return null; + } + + @Override + public void writeToNBT(NBTTagCompound compound) { + + compound.setString("dict", dict); + compound.setInteger("fuzzmode", fuzzmode); + + + + NBTTagList nbttaglist = new NBTTagList(); + + for (int i = 0; i < is.length; ++i) + { + if (is[i] != null) + { + NBTTagCompound nbttagcompound1 = new NBTTagCompound(); + nbttagcompound1.setByte("Slot", (byte)i); + is[i].writeToNBT(nbttagcompound1); + nbttaglist.appendTag(nbttagcompound1); + } + } + + compound.setTag("Items", nbttaglist); + nbttaglist = new NBTTagList(); + + for (int i = 0; i < fs.length; ++i) + { + if (fs[i] != null) + { + NBTTagCompound nbttagcompound1 = new NBTTagCompound(); + nbttagcompound1.setByte("Slot", (byte)i); + fs[i].writeToNBT(nbttagcompound1); + nbttaglist.appendTag(nbttagcompound1); + } + } + + compound.setTag("Fluids", nbttaglist); + + + } + + @Override + public void readFromNBT(NBTTagCompound compound) { + if(!isProxyExternal)getProxy().readFromNBT(compound); + dict= compound.getString("dict" ); + fuzzmode=compound.getInteger("fuzzmode"); + fluid=compound.getBoolean("fluid"); + noAdvConfig=compound.getBoolean("noAdvConfig"); + isProxyExternal=compound.getBoolean("isProxyExternal"); + NBTTagList nbttaglist = compound.getTagList("Items", 10); + Arrays.fill(is,null); + + + + for (int i = 0; i < nbttaglist.tagCount(); ++i) + { + NBTTagCompound nbttagcompound1 = nbttaglist.getCompoundTagAt(i); + int j = nbttagcompound1.getByte("Slot") & 255; + + if (j >= 0 && j < is.length) + { + is[j] = ItemStack.loadItemStackFromNBT(nbttagcompound1); + } + } + + NBTTagList nbttaglist0 = compound.getTagList("Fluids", 10); + Arrays.fill(fs,null); + + + + for (int i = 0; i < nbttaglist0.tagCount(); ++i) + { + NBTTagCompound nbttagcompound1 = nbttaglist0.getCompoundTagAt(i); + int j = nbttagcompound1.getByte("Slot") & 255; + + if (j >= 0 && j < fs.length) + { + fs[j] = FluidStack.loadFluidStackFromNBT(nbttagcompound1); + } + } + + + + + }};} } diff --git a/src/main/java/reobf/proghatches/eio/ICraftingMachineConduit.java b/src/main/java/reobf/proghatches/eio/ICraftingMachineConduit.java new file mode 100644 index 0000000..f033661 --- /dev/null +++ b/src/main/java/reobf/proghatches/eio/ICraftingMachineConduit.java @@ -0,0 +1,8 @@ +package reobf.proghatches.eio; + +import appeng.api.implementations.tiles.ICraftingMachine; +import crazypants.enderio.conduit.IConduit; + +public interface ICraftingMachineConduit extends IConduit,ICraftingMachine{ + +} diff --git a/src/main/java/reobf/proghatches/eio/IInit.java b/src/main/java/reobf/proghatches/eio/IInit.java new file mode 100644 index 0000000..32d877b --- /dev/null +++ b/src/main/java/reobf/proghatches/eio/IInit.java @@ -0,0 +1,5 @@ +package reobf.proghatches.eio; + +public interface IInit { +default void doJob(){} +} diff --git a/src/main/java/reobf/proghatches/eio/ItemMAConduit.java b/src/main/java/reobf/proghatches/eio/ItemMAConduit.java new file mode 100644 index 0000000..9084c03 --- /dev/null +++ b/src/main/java/reobf/proghatches/eio/ItemMAConduit.java @@ -0,0 +1,65 @@ +package reobf.proghatches.eio; + +import cpw.mods.fml.common.registry.GameRegistry; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import crazypants.enderio.ModObject; +import crazypants.enderio.conduit.AbstractItemConduit; +import crazypants.enderio.conduit.IConduit; +import crazypants.enderio.conduit.ItemConduitSubtype; +import crazypants.enderio.conduit.item.IItemConduit; +import crazypants.enderio.conduit.item.ItemConduit; +import crazypants.enderio.conduit.item.ItemItemConduit; +import crazypants.enderio.conduit.render.ItemConduitRenderer; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraftforge.client.MinecraftForgeClient; +import reobf.proghatches.main.MyMod; + +public class ItemMAConduit extends AbstractItemConduit implements IInit { + + + private static ItemConduitSubtype[] subtypes = new ItemConduitSubtype[] { + new ItemConduitSubtype("proghatch.ma.conduit", "proghatches:itemMAConduit") }; + + public static ItemMAConduit create() { + ItemMAConduit result = new ItemMAConduit(); + //result.init(); + GameRegistry.registerItem(result, "proghatch.ma.conduit"); + ((IInit)result).doJob(); + + + + return result; + } + + + @SideOnly(Side.CLIENT) + @Override + public void doJob() { + MinecraftForgeClient.registerItemRenderer(this, new ItemConduitRenderer()); + + } + + protected ItemMAConduit() { + super(ModObject.itemItemConduit/*this is an Enum... I have no choice! hope this will not break something!*/ + ,subtypes); + setUnlocalizedName("proghatch.ma.conduit"); + } + + @Override + public Class getBaseConduitType() { + return ICraftingMachineConduit.class; + } + + @Override + public IConduit createConduit(ItemStack item, EntityPlayer player) { + return new MAConduit(); + } + + @Override + public boolean shouldHideFacades(ItemStack stack, EntityPlayer player) { + return true; + } +} + diff --git a/src/main/java/reobf/proghatches/eio/MAConduit.java b/src/main/java/reobf/proghatches/eio/MAConduit.java new file mode 100644 index 0000000..b8ba489 --- /dev/null +++ b/src/main/java/reobf/proghatches/eio/MAConduit.java @@ -0,0 +1,539 @@ +package reobf.proghatches.eio; + +import java.lang.ref.WeakReference; +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; + +import com.enderio.core.common.util.DyeColor; +import com.google.common.collect.HashBasedTable; +import com.google.common.collect.HashMultimap; +import com.google.common.collect.Multimap; +import com.google.common.collect.Table; + +import appeng.api.implementations.tiles.ICraftingMachine; +import appeng.api.networking.crafting.ICraftingPatternDetails; +import appeng.api.parts.IPart; +import appeng.api.parts.IPartHost; +import appeng.helpers.IInterfaceHost; +import crazypants.enderio.conduit.AbstractConduit; +import crazypants.enderio.conduit.AbstractConduitNetwork; +import crazypants.enderio.conduit.ConduitUtil; +import crazypants.enderio.conduit.ConnectionMode; +import crazypants.enderio.conduit.IConduit; +import crazypants.enderio.conduit.IConduitBundle; +import crazypants.enderio.conduit.RaytraceResult; +import crazypants.enderio.conduit.geom.CollidableComponent; +import crazypants.enderio.conduit.geom.ConnectionModeGeometry; +import crazypants.enderio.conduit.geom.Offset; +import crazypants.enderio.conduit.item.IItemConduit; +import crazypants.enderio.conduit.item.ItemConduit; +import crazypants.enderio.conduit.me.MEConduit; +import crazypants.enderio.conduit.oc.OCConduitNetwork; +import crazypants.enderio.conduit.render.ConduitBundleRenderer; +import crazypants.enderio.conduit.render.ConduitRenderer; +import crazypants.enderio.conduit.render.DefaultConduitRenderer; +import crazypants.enderio.item.PacketConduitProbe; +import crazypants.enderio.tool.ToolUtil; +import li.cil.oc.api.network.Environment; +import li.cil.oc.api.network.SidedEnvironment; +import net.minecraft.block.Block; +import net.minecraft.client.renderer.RenderBlocks; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.inventory.InventoryCrafting; +import net.minecraft.item.ItemDye; +import net.minecraft.item.ItemStack; +import net.minecraft.server.MinecraftServer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.IIcon; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import reobf.proghatches.ae.PartMAP2P; +import reobf.proghatches.fmp.ICraftingMachinePart; +import reobf.proghatches.fmp.LayerCraftingMachine.StateHolder; +import reobf.proghatches.main.MyMod; + + +public class MAConduit extends AbstractConduit implements ICraftingMachineConduit{ + + + + + public static class MAConduitNetwork + extends AbstractConduitNetwork + + { + + public MAConduitNetwork(Class implClass, + Class baseConduitClass) { + super(implClass, baseConduitClass);} + + + @Override + public void doNetworkTick() { + super.doNetworkTick(); + + + + } + @Override + public void addConduit(ICraftingMachineConduit con) { + super.addConduit(con); + for(ForgeDirection dir:ForgeDirection.VALID_DIRECTIONS) + if(((MAConduit) con).containsExternalConnection(dir)&&((MAConduit) con).getConnectionMode(dir)!=ConnectionMode.DISABLED) + conn.put((MAConduit) con, dir); + } + + + public void updateConn(MAConduit con) { + conn.removeAll(con); + for(ForgeDirection dir:ForgeDirection.VALID_DIRECTIONS) + if(((MAConduit) con).containsExternalConnection(dir)&&((MAConduit) con).getConnectionMode(dir)!=ConnectionMode.DISABLED) + conn.put((MAConduit) con, dir); + + } + + HashMultimap conn= HashMultimap.create(); + + + + + } + public void setConnectionMode(ForgeDirection dir, ConnectionMode mode) { + + super.setConnectionMode(dir, mode); + + if(net!=null)net.updateConn(this); + else updateLater=true; + }; + boolean updateLater; + + + MAConduitNetwork net; + + + + @Override + public Class getBaseConduitType() { + + return ICraftingMachineConduit.class; + } + + @Override + public ItemStack createItem() { + + return new ItemStack(MyMod.ma_conduit); + } + + @Override + public AbstractConduitNetwork getNetwork() { + + return net; + } + + @Override + public boolean setNetwork(AbstractConduitNetwork network) { + + this.net = (MAConduitNetwork) network; + if(updateLater&&net!=null){net.updateConn(this);updateLater=false;} + return true; + } + + @Override + public IIcon getTextureForState(CollidableComponent component) { + + return Blocks.crafting_table.getIcon(1, 0); + } + + @Override + public IIcon getTransmitionTextureForState(CollidableComponent component) { + + return null; + } + + int tick; + + + private WeakReference candidate=new WeakReference<>(null);; + @Override + public boolean pushPattern(ICraftingPatternDetails patternDetails, InventoryCrafting table, + ForgeDirection ejectionDirection) { + + try{ + + if(PartMAP2P.chain.contains(this)){return false;} + PartMAP2P.chain.add(this); + + if(tick==MinecraftServer.getServer().getTickCounter()){ + ICraftingMachine val; + if((val=candidate.get())!=null&&val.pushPattern(patternDetails,table,ejectionDirection)){return true;} + } + + if(( getExternalConnections().contains(StateHolder.state))&& + (getConnectionMode(StateHolder.state).acceptsInput()) + ){ + + if(net!=null){ + + for(Entry ent:net.conn.entries()){ + + try { + TileEntity thiz=(TileEntity) getBundle.invoke(ent.getKey()); + TileEntity te=getTarget(thiz,ent.getValue()); + if(te==null){continue;} + + if(te instanceof ICraftingMachine){ + ForgeDirection old=StateHolder.state; + StateHolder.state=ent.getValue().getOpposite(); + if(((ICraftingMachine) te).pushPattern(patternDetails, table, ejectionDirection)){ + StateHolder.state=old; + return true; + } + StateHolder.state=old; + } + + + + } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { + e.printStackTrace(); + } + + } + + } + + + return false; + + }; + + + + + + return false; + + }finally{ + + PartMAP2P.chain.remove(this); + } + } + private TileEntity getTarget(TileEntity thiz,ForgeDirection side) { + + + + + final TileEntity te = thiz.getWorldObj().getTileEntity( + thiz.xCoord +side.offsetX, + thiz.yCoord + side.offsetY, + thiz.zCoord + side.offsetZ); + + + return te; + } + + @Override + public boolean acceptsPlans() { + + //System.out.println(StateHolder.state); + //System.out.println(getConnectionMode(StateHolder.state).acceptsInput()); + try{ + + if(PartMAP2P.chain.contains(this)){return false;} + PartMAP2P.chain.add(this); + + + + if(( getExternalConnections().contains(StateHolder.state))&& + (getConnectionMode(StateHolder.state).acceptsInput()) + ){ + + if(net!=null){ + + for(Entry ent:net.conn.entries()){ + + try { + TileEntity thiz=(TileEntity) getBundle.invoke(ent.getKey()); + TileEntity te=getTarget(thiz,ent.getValue()); + if(te==null){continue;} + + if(te instanceof ICraftingMachine){ + ForgeDirection old=StateHolder.state; + StateHolder.state=ent.getValue().getOpposite(); + if(((ICraftingMachine) te).acceptsPlans()){ + StateHolder.state=old; + + tick=MinecraftServer.getServer().getTickCounter(); + candidate=new WeakReference((ICraftingMachine) te); + + + + return true; + } + StateHolder.state=old; + } + + + + } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { + e.printStackTrace(); + } + + } + + } + + + return false; + + }; + + + + + + return false; + + }finally{ + + PartMAP2P.chain.remove(this); + } + } + + @Override + public ConduitRenderer getRenderer() { + + return ConduitRenderer.instance.get(); + } + static Method getBundle; + static Method getOffset; + + public TileEntity getTE(){ + if(getBundle==null) + for(Method m:this.getClass().getMethods()){ + if(m.getName().equals("getBundle")){ + + getBundle=m; + + + } + + + } + try { + return (TileEntity) getBundle.invoke(this); + } catch (Exception e) { + e.printStackTrace(); + } + + getBundle(); + throw new AssertionError(); + } + @Override + public void externalConnectionAdded(ForgeDirection fromDirection) { + super.externalConnectionAdded(fromDirection); + ConnectionMode mode=ConnectionMode.DISABLED; + TileEntity te = getLocation().getLocation(fromDirection).getTileEntity(getTE().getWorldObj()); + int bit=0; + if (te instanceof ICraftingMachine) { + bit=bit|1; + } + if (te instanceof IInterfaceHost) { + bit=bit|2; + } + if (te instanceof IPartHost) { + + if (((IPartHost)te).getPart(fromDirection.getOpposite()) instanceof IInterfaceHost) + bit=bit|2; + } + + if(bit==1)mode=ConnectionMode.OUTPUT; + else if(bit==2)mode=ConnectionMode.INPUT; + else if(bit==3)mode=ConnectionMode.IN_OUT; + + setConnectionMode(fromDirection, mode); + + } + @Override + public boolean canConnectToExternal(ForgeDirection direction, boolean ignoreConnectionMode) { + TileEntity te = getLocation().getLocation(direction).getTileEntity(getTE().getWorldObj()); + + ignoreConnectionMode=true; + a:if (te instanceof ICraftingMachine) { + if(ignoreConnectionMode==false&&!getConnectionMode(direction).acceptsOutput()){break a;} + return true; + } + a:if (te instanceof IInterfaceHost) { + if(ignoreConnectionMode==false&&!getConnectionMode(direction).acceptsInput()){break a;} + return true; + } + a: if (te instanceof IPartHost) { + if(ignoreConnectionMode==false&&!getConnectionMode(direction).acceptsInput()){break a;} + return ((IPartHost)te).getPart(direction.getOpposite()) instanceof IInterfaceHost; + + + } + return false; + } + @Override + public boolean onBlockActivated(EntityPlayer player, RaytraceResult res, List all) { + + /* if (!getTE().getWorldObj().isRemote) { + System.out.println(net.conn.toString()); + System.out.println(net.getConduits()); + + + }*/ + if (ToolUtil.isToolEquipped(player)) { + if (!getTE().getWorldObj().isRemote) { + if (res != null && res.component != null) { + ForgeDirection connDir = res.component.dir; + ForgeDirection faceHit = ForgeDirection.getOrientation(res.movingObjectPosition.sideHit); + if (connDir == ForgeDirection.UNKNOWN || connDir == faceHit) { + if (getConnectionMode(faceHit) == ConnectionMode.DISABLED) { + setConnectionMode(faceHit, getNextConnectionMode(faceHit)); + return true; + } + // Attempt to join networks + return ConduitUtil.joinConduits(this, faceHit); + } else if (externalConnections.contains(connDir)) { + setConnectionMode(connDir, getNextConnectionMode(connDir)); + return true; + } else if (containsConduitConnection(connDir)) { + ConduitUtil.disconectConduits(this, connDir); + return true; + } + } + } + } + return false; + } + + + public static class ConduitRenderer extends DefaultConduitRenderer { + + public static final ThreadLocal instance = ThreadLocal.withInitial(ConduitRenderer::new); + + + + @Override + public void renderEntity(ConduitBundleRenderer conduitBundleRenderer, IConduitBundle te, IConduit conduit, double x, + double y, double z, float partialTick, float worldLight, RenderBlocks rb) { + super.renderEntity(conduitBundleRenderer, te, conduit, x, y, z, partialTick, worldLight, rb); + + Map ICONS=null; + try {Field f=null; + f = ItemConduit.class.getDeclaredField("ICONS"); + f.setAccessible(true);ICONS= (Map) f.get(null); + } catch (Exception e) { + e.printStackTrace(); + } + + + + + + IConduit pc = (IConduit) conduit; + for (ForgeDirection dir : conduit.getExternalConnections()) { + + IIcon inTex = null; + IIcon outTex = null; + boolean render = true; + if (conduit.getConnectionMode(dir) == ConnectionMode.INPUT) { + inTex = ICONS.get(ItemConduit.ICON_KEY_INPUT); + //inChannel = pc.getInputColor(dir); + } else if (conduit.getConnectionMode(dir) == ConnectionMode.OUTPUT) { + outTex = ICONS.get(ItemConduit.ICON_KEY_OUTPUT);//pc.getTextureForOutputMode(); + // outChannel = pc.getOutputColor(dir); + } else if (conduit.getConnectionMode(dir) == ConnectionMode.IN_OUT) { + inTex = ICONS.get(ItemConduit.ICON_KEY_IN_OUT_IN); + outTex = ICONS.get(ItemConduit.ICON_KEY_IN_OUT_OUT); + //inChannel = pc.getInputColor(dir); + //outChannel = pc.getOutputColor(dir); + } else { + render = false; + } + if(getOffset==null) + for(Method m:((Object)te).getClass().getMethods()){ + if(m.getName().equals("getOffset")){ + + getOffset=m; + + + } + + + } + if (render && !rb.hasOverrideBlockTexture()) { + Offset offset =null; + + try { + offset= (Offset) getOffset.invoke(te,ICraftingMachineConduit.class, dir); + } catch (Exception e) { + e.printStackTrace(); + } + + + + + + ConnectionModeGeometry.renderModeConnector(dir, offset,ICONS.get(ItemConduit.ICON_KEY_IN_OUT_BG), true); + + if (inTex != null) { + Tessellator.instance.setColorOpaque_I(ItemDye.field_150922_c[12]);//12->bright red + ConnectionModeGeometry.renderModeConnector(dir, offset, inTex, false); + } + if (outTex != null) { + Tessellator.instance.setColorOpaque_I(ItemDye.field_150922_c[12]); + ConnectionModeGeometry.renderModeConnector(dir, offset, outTex, false); + } + + Tessellator.instance.setColorOpaque_F(1f, 1f, 1f); + } + } + } + } + + /* @Override + public void updateNetwork() { + World world = getBundle().getEntity().getWorldObj(); + if (world != null) { + updateNetwork(world); + } + }*/ + boolean neighbourDirty; + @Override + public void updateEntity(World world) { + super.updateEntity(world); + + if (!world.isRemote && neighbourDirty) { + net.destroyNetwork(); + updateNetwork(world); + neighbourDirty = false; + } + } + @Override + public void externalConnectionRemoved(ForgeDirection fromDirection) { + + super.externalConnectionRemoved(fromDirection); + + if(net!=null)net.updateConn(this); + } +@Override +public boolean onNeighborBlockChange(Block block) { + boolean B = super.onNeighborBlockChange(block); + if(net!=null){ + net.updateConn(this); + } + + return B; +} + +} diff --git a/src/main/java/reobf/proghatches/eio/MASettings.java b/src/main/java/reobf/proghatches/eio/MASettings.java new file mode 100644 index 0000000..13d2bc7 --- /dev/null +++ b/src/main/java/reobf/proghatches/eio/MASettings.java @@ -0,0 +1,188 @@ +package reobf.proghatches.eio; + +import java.awt.Color; +import java.lang.reflect.Field; +import java.util.ArrayList; +import java.util.Collection; + +import javax.annotation.Nonnull; + +import org.lwjgl.opengl.GL11; + +import com.enderio.core.api.client.render.IWidgetIcon; +import com.enderio.core.api.client.render.IWidgetMap; +import com.enderio.core.client.gui.button.ColorButton; +import com.enderio.core.client.render.ColorUtil; +import com.enderio.core.client.render.RenderUtil; +import com.enderio.core.common.util.DyeColor; + +import crazypants.enderio.EnderIO; +import crazypants.enderio.conduit.ConnectionMode; +import crazypants.enderio.conduit.IConduit; +import crazypants.enderio.conduit.gui.BaseSettingsPanel; +import crazypants.enderio.conduit.gui.GuiExternalConnection; +import crazypants.enderio.conduit.oc.IOCConduit; +import crazypants.enderio.conduit.packet.PacketConnectionMode; +import crazypants.enderio.conduit.packet.PacketOCConduitSignalColor; +import crazypants.enderio.gui.IconEIO; +import crazypants.enderio.network.PacketHandler; +import net.minecraft.client.gui.GuiButton; +import net.minecraft.client.gui.GuiScreen; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.util.ResourceLocation; +import reobf.proghatches.main.MyMod; +import reobf.proghatches.net.ConnectionModeMessage; + +public class MASettings extends BaseSettingsPanel { + + public MASettings(GuiExternalConnection gui, IConduit con) { + super( + new IWidgetIcon(){ + + @Override + public int getX() { + // TODO Auto-generated method stub + return 0; + } + + @Override + public int getY() { + // TODO Auto-generated method stub + return 0; + } + + @Override + public int getWidth() { + + return 16; + } + + @Override + public int getHeight() { + + return 16; + } + + @Override + public IWidgetIcon getOverlay() { + return null; + } + + @Override + public IWidgetMap getMap() { + + return new IWidgetMap.WidgetMapImpl(16, + + new ResourceLocation("minecraft", "textures/blocks/crafting_table_top.png")) + + + { + + @Override + public void render(IWidgetIcon widget, double x, double y, double width, double height, double zLevel, + boolean doDraw, boolean flipY) { + //一个个画能有多大性能损失？ 既然非要共用单个纹理 还假惺惺弄个ResourceLocation参数干啥 真的会谢 + Tessellator tessellator = Tessellator.instance; + + if(!doDraw)tessellator.draw();//如果是连续绘制 先把之前的画了 + int old= GL11.glGetInteger(GL11.GL_TEXTURE_2D); + RenderUtil.bindTexture(this.getTexture()); + super.render(widget, x, y, width, height, zLevel, true,flipY); + GL11.glBindTexture(GL11.GL_TEXTURE_2D, old); + if(!doDraw)tessellator.startDrawingQuads();//再重新开始画 + + } + + + + } + + ; + } + } + + + , EnderIO.lang.localize("itemMEConduit.name"), gui, con); + } + protected boolean hasInOutModes() { + return true; + } + static final int ID_INSERT_ENABLED = 327; + static final int ID_EXTRACT_ENABLED = 328; + + + static Field insertEnabled; + static Field extractEnabled; + static{ + try { + insertEnabled= BaseSettingsPanel.class.getDeclaredField("insertEnabled"); + extractEnabled=BaseSettingsPanel.class.getDeclaredField("extractEnabled"); + insertEnabled.setAccessible(true); + extractEnabled.setAccessible(true); + } catch (Exception e) { + e.printStackTrace(); + } + + + } + private void updateConnectionMode() { + try{ ConnectionMode mode = ConnectionMode.DISABLED; + if ((boolean)insertEnabled.get(this) && (boolean)extractEnabled.get(this) ) { + mode = ConnectionMode.IN_OUT; + } else if ((boolean)insertEnabled.get(this)) { + mode = ConnectionMode.OUTPUT; + } else if ((boolean)extractEnabled.get(this)) { + mode = ConnectionMode.INPUT; + } + con.setConnectionMode(gui.getDir(), mode); + + MyMod.net.sendToServer(new ConnectionModeMessage(con, gui.getDir())); + }catch(Exception e){e.printStackTrace();} + // PacketHandler.INSTANCE.sendToServer(new PacketConnectionMode(con, gui.getDir())); + } + + @Override + public void actionPerformed(@Nonnull GuiButton guiButton) { + try{if (guiButton.id == ID_INSERT_ENABLED) { + insertEnabled .set(this, !(boolean)insertEnabled.get(this)); + updateConnectionMode(); + } else if (guiButton.id == ID_EXTRACT_ENABLED) { + extractEnabled .set(this, !(boolean)extractEnabled.get(this)); + updateConnectionMode(); + } }catch(Exception e){e.printStackTrace();} + + /*else if (guiButton.id == ID_ENABLED) { + enabled = !enabled; + updateConnectionMode(); + }*/ + } + /* @Override + public void onGuiInit(int leftIn, int topIn, int widthIn, int heightIn) { + + + Collection old=null; + try { + Field f; + f = GuiScreen.class.getDeclaredField("buttonList"); + f.setAccessible(true); + old=new ArrayList<>((Collection)f.get(gui)); + } catch (Exception e) { + e.printStackTrace(); + } + + + + super.onGuiInit(leftIn, topIn, widthIn, heightIn); + + try {//the button is glitchy! kill it + Field f; + f = GuiScreen.class.getDeclaredField("buttonList"); + f.setAccessible(true); + f.set(gui, old); + } catch (Exception e) { + e.printStackTrace(); + } + + + }*/ +} diff --git a/src/main/java/reobf/proghatches/fmp/ICraftingMachinePart.java b/src/main/java/reobf/proghatches/fmp/ICraftingMachinePart.java new file mode 100644 index 0000000..1315afa --- /dev/null +++ b/src/main/java/reobf/proghatches/fmp/ICraftingMachinePart.java @@ -0,0 +1,12 @@ +package reobf.proghatches.fmp; + +import appeng.api.networking.crafting.ICraftingPatternDetails; +import net.minecraft.inventory.InventoryCrafting; +import net.minecraftforge.common.util.ForgeDirection; + +public interface ICraftingMachinePart { + boolean pushPattern(ICraftingPatternDetails patternDetails, InventoryCrafting table, + ForgeDirection ejectionDirection); + + boolean acceptsPlans( ForgeDirection ejectionDirection); +} diff --git a/src/main/java/reobf/proghatches/fmp/LayerCraftingMachine.java b/src/main/java/reobf/proghatches/fmp/LayerCraftingMachine.java new file mode 100644 index 0000000..ae73fb6 --- /dev/null +++ b/src/main/java/reobf/proghatches/fmp/LayerCraftingMachine.java @@ -0,0 +1,46 @@ +package reobf.proghatches.fmp; + +import appeng.api.implementations.tiles.ICraftingMachine; +import appeng.api.networking.crafting.ICraftingPatternDetails; +import appeng.api.parts.IPart; +import appeng.api.parts.LayerBase; +import net.minecraft.inventory.InventoryCrafting; +import net.minecraftforge.common.util.ForgeDirection; +import reobf.proghatches.eucrafting.ILazer; + +public class LayerCraftingMachine extends LayerBase implements ICraftingMachine{ + + @Override + public boolean pushPattern(ICraftingPatternDetails patternDetails, InventoryCrafting table, + ForgeDirection ejectionDirection) { + IPart part = this.getPart(ejectionDirection); + if(part!=null){ + if(part instanceof ICraftingMachinePart){ + + return ((ICraftingMachinePart) part).pushPattern(patternDetails, table, ejectionDirection) ; + } + } + return false; + } + public static class StateHolder{ + + static public ForgeDirection state=ForgeDirection.UNKNOWN; + + } + + + @Override + public boolean acceptsPlans() { + //System.out.println(state); + IPart part = this.getPart(StateHolder.state); + if(part!=null){ + if(part instanceof ICraftingMachinePart){ + return ((ICraftingMachinePart) part).acceptsPlans(StateHolder.state); + } + } + + + return false; + } + +} diff --git a/src/main/java/reobf/proghatches/gt/metatileentity/BufferedDualInputHatch.java b/src/main/java/reobf/proghatches/gt/metatileentity/BufferedDualInputHatch.java index f507f09..8c377c0 100644 --- a/src/main/java/reobf/proghatches/gt/metatileentity/BufferedDualInputHatch.java +++ b/src/main/java/reobf/proghatches/gt/metatileentity/BufferedDualInputHatch.java @@ -149,7 +149,7 @@ public int fluidLimit() { public int itemLimit() { - return (int) (64 * Math.pow(2, Math.max(mTier - 3, 0))); + return (int) (64 * Math.pow(4, Math.max(mTier - 3, 0))); } private static int fluidLimit(int mTier,boolean mMultiFluid) { @@ -159,7 +159,7 @@ private static int fluidLimit(int mTier,boolean mMultiFluid) { private static int itemLimit(int mTier) { - return (int) (64 * Math.pow(2, Math.max(mTier - 3, 0))); + return (int) (64 * Math.pow(4, Math.max(mTier - 3, 0))); } public BufferedDualInputHatch(int id, String name, String nameRegional, int tier, boolean mMultiFluid, int bufferNum, String... optional) { @@ -1246,6 +1246,7 @@ public void loadNBTData(NBTTagCompound aNBT) { final int ii = i; inv0.get(i).fromTag((NBTTagCompound) aNBT.getTag("BUFFER_" + ii)); } + CMMode=aNBT.getBoolean("CMMode"); merge = aNBT.getBoolean("merge"); justHadNewItems = aNBT.getBoolean("justHadNewItems"); updateEveryTick = aNBT.getBoolean("updateEveryTick"); @@ -1259,7 +1260,7 @@ public void saveNBTData(NBTTagCompound aNBT) { for (int i = 0; i < bufferNum; i++) aNBT.setTag("BUFFER_" + i, inv0.get(i).toTag()); - + aNBT.setBoolean("CMMode", CMMode); aNBT.setBoolean("merge", merge); aNBT.setBoolean("justHadNewItems", justHadNewItems); aNBT.setBoolean("updateEveryTick", updateEveryTick); diff --git a/src/main/java/reobf/proghatches/gt/metatileentity/DualInputHatch.java b/src/main/java/reobf/proghatches/gt/metatileentity/DualInputHatch.java index 462ca78..30a8a8a 100644 --- a/src/main/java/reobf/proghatches/gt/metatileentity/DualInputHatch.java +++ b/src/main/java/reobf/proghatches/gt/metatileentity/DualInputHatch.java @@ -1789,13 +1789,13 @@ public CheckRecipeResult endRecipeProcessingImpl(GT_MetaTileEntity_MultiBlockBas @Override public int getInventoryStackLimit() { - return 64+64*Math.max(0,mTier-3); + return 64+64*Math.max(0,mTier-3)*Math.max(0,mTier-3); } public static int getInventoryStackLimit(int mTier) { - return 64+64*Math.max(0,mTier-3); + return 64+64*Math.max(0,mTier-3)*Math.max(0,mTier-3); } public int fluidBuff(){ diff --git a/src/main/java/reobf/proghatches/gt/metatileentity/PatternDualInputHatchInventoryMappingSlave.java b/src/main/java/reobf/proghatches/gt/metatileentity/PatternDualInputHatchInventoryMappingSlave.java index 2e6e478..09cbfa9 100644 --- a/src/main/java/reobf/proghatches/gt/metatileentity/PatternDualInputHatchInventoryMappingSlave.java +++ b/src/main/java/reobf/proghatches/gt/metatileentity/PatternDualInputHatchInventoryMappingSlave.java @@ -1,6 +1,7 @@ package reobf.proghatches.gt.metatileentity; import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_PIPE_IN; +import static gregtech.api.objects.XSTR.XSTR_INSTANCE; import java.io.IOException; import java.util.EnumSet; @@ -62,6 +63,7 @@ import gregtech.common.tileentities.machines.IDualInputHatch; import mcp.mobius.waila.api.IWailaConfigHandler; import mcp.mobius.waila.api.IWailaDataAccessor; +import net.minecraft.entity.item.EntityItem; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.entity.player.EntityPlayerMP; import net.minecraft.inventory.IInventory; @@ -1127,4 +1129,34 @@ public boolean pasteCopiedData(EntityPlayer player, NBTTagCompound nbt) { master=null; return true; } + + @Override + public void onBlockDestroyed() { + + super.onBlockDestroyed(); + + IGregTechTileEntity te = this.getBaseMetaTileEntity(); + World aWorld = te.getWorld(); + int aX = te.getXCoord(); + short aY = te.getYCoord(); + int aZ = te.getZCoord(); + + for (int i = 0; i < pattern.length; i++) { + final ItemStack tItem = pattern[i]; + if ((tItem != null) && (tItem.stackSize > 0)) { + final EntityItem tItemEntity = new EntityItem(aWorld, aX + XSTR_INSTANCE.nextFloat() * 0.8F + 0.1F, + aY + XSTR_INSTANCE.nextFloat() * 0.8F + 0.1F, aZ + XSTR_INSTANCE.nextFloat() * 0.8F + 0.1F, + new ItemStack(tItem.getItem(), tItem.stackSize, tItem.getItemDamage())); + if (tItem.hasTagCompound()) { + tItemEntity.getEntityItem().setTagCompound((NBTTagCompound) tItem.getTagCompound().copy()); + } + tItemEntity.motionX = (XSTR_INSTANCE.nextGaussian() * 0.05D); + tItemEntity.motionY = (XSTR_INSTANCE.nextGaussian() * 0.25D); + tItemEntity.motionZ = (XSTR_INSTANCE.nextGaussian() * 0.05D); + aWorld.spawnEntityInWorld(tItemEntity); + tItem.stackSize = 0; + pattern[i] = null; + } + } + } } diff --git a/src/main/java/reobf/proghatches/gt/metatileentity/SuperChestME.java b/src/main/java/reobf/proghatches/gt/metatileentity/SuperChestME.java index 61864f9..4282206 100644 --- a/src/main/java/reobf/proghatches/gt/metatileentity/SuperChestME.java +++ b/src/main/java/reobf/proghatches/gt/metatileentity/SuperChestME.java @@ -517,7 +517,7 @@ protected void fillStacksIntoFirstSlots() { int rep; @Override public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { - + boolean active=this.getProxy().isActive(); if(!aBaseMetaTileEntity.getWorld().isRemote){ if(rep>0){rep--;update=true;} if(this.getBaseMetaTileEntity().hasInventoryBeenModified()){ @@ -526,8 +526,8 @@ public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { }; if(update){update=false;updateStatus();} - if(wasActive!=this.getProxy().isActive()){ - wasActive=this.getProxy().isActive(); + if(wasActive!=active){ + wasActive=active; post(); } if (voidFull ) { @@ -543,7 +543,7 @@ public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { } if(!aBaseMetaTileEntity.getWorld().isRemote&&(aTick&16)!=0){ this.getBaseMetaTileEntity().setActive( - this.getProxy().isPowered()&&this.getProxy().isActive() + this.getProxy().isPowered()&&active ) ; diff --git a/src/main/java/reobf/proghatches/gt/metatileentity/multi/IngredientDistributor.java b/src/main/java/reobf/proghatches/gt/metatileentity/multi/IngredientDistributor.java index 2216fbe..bbd9e69 100644 --- a/src/main/java/reobf/proghatches/gt/metatileentity/multi/IngredientDistributor.java +++ b/src/main/java/reobf/proghatches/gt/metatileentity/multi/IngredientDistributor.java @@ -768,12 +768,16 @@ private boolean moveToOutpusME(IDualInputInventory opt) { } + + for(int index=0;indexs.getStackSize()).orElse(0l).intValue(); } catch (GridAccessException e) {} @@ -787,6 +791,7 @@ private boolean moveToOutpusME(IDualInputInventory opt) { .getProxy().getStorage().getFluidInventory().injectItems(AEApi.instance() .storage() .createFluidStack(f[index]), Actionable.MODULATE, getActionSourceFor(mOutputHatches.get(index))); + f[index].amount=Optional.ofNullable(notadded).map(s->s.getStackSize()).orElse(0l).intValue(); } catch (GridAccessException e) {} } diff --git a/src/main/java/reobf/proghatches/main/CommonProxy.java b/src/main/java/reobf/proghatches/main/CommonProxy.java index fe0df6b..df77303 100644 --- a/src/main/java/reobf/proghatches/main/CommonProxy.java +++ b/src/main/java/reobf/proghatches/main/CommonProxy.java @@ -26,6 +26,8 @@ import reobf.proghatches.ae.BlockCyclicPatternSubmitter; import reobf.proghatches.ae.BlockStorageProxy; import reobf.proghatches.ae.ItemPartAmountMaintainer; +import reobf.proghatches.ae.ItemPartMAP2P; +import reobf.proghatches.ae.ItemPartStockingExportBus; import reobf.proghatches.ae.ItemPartStorageProxy; import reobf.proghatches.ae.ItemPartSubnetExciter; import reobf.proghatches.ae.TileCraftingCondenser; @@ -41,6 +43,7 @@ import reobf.proghatches.block.TileAnchorAlert; import reobf.proghatches.block.TileIOHub; import reobf.proghatches.block.TileReactorSyncer; +import reobf.proghatches.eio.ItemMAConduit; import reobf.proghatches.eucrafting.BlockEUInterface; import reobf.proghatches.eucrafting.EUUtil; import reobf.proghatches.eucrafting.ItemBlockEUInterface; @@ -176,6 +179,8 @@ public void preInit(FMLPreInitializationEvent event) { .setUnlocalizedName("proghatches.part.eu.source").setTextureName("?"), "proghatches.part.eu.source"); GameRegistry.registerItem(MyMod.lazer_p2p_part = new ItemPartLazerP2P() .setUnlocalizedName("proghatches.part.lazer.p2p").setTextureName("?"), "proghatches.part.lazer.p2p"); + GameRegistry.registerItem(MyMod.ma_p2p_part = new ItemPartMAP2P() + .setUnlocalizedName("proghatches.part.ma.p2p").setTextureName("?"), "proghatches.part.ma.p2p"); GameRegistry .registerItem( @@ -197,11 +202,15 @@ public void preInit(FMLPreInitializationEvent event) { MyMod.exciter = new ItemPartSubnetExciter() .setUnlocalizedName("proghatches.exciter").setTextureName("?"), "proghatches.exciter"); - + GameRegistry + .registerItem( + MyMod.stockingexport = new ItemPartStockingExportBus() + .setUnlocalizedName("proghatches.stockingexport").setTextureName("?"), + "stockingexport"); a(); - + MyMod.ma_conduit =ItemMAConduit.create(); GameRegistry.registerTileEntity(TileCraftingCondenser.class, "proghatches.craftingdumper"); } diff --git a/src/main/java/reobf/proghatches/main/MyMod.java b/src/main/java/reobf/proghatches/main/MyMod.java index 175d294..f833810 100644 --- a/src/main/java/reobf/proghatches/main/MyMod.java +++ b/src/main/java/reobf/proghatches/main/MyMod.java @@ -139,6 +139,7 @@ import reobf.proghatches.Tags; import reobf.proghatches.block.ChunkTrackingGridCahce; import reobf.proghatches.block.TileIOHub; +import reobf.proghatches.eio.ItemMAConduit; import reobf.proghatches.eucrafting.BlockEUInterface; import reobf.proghatches.eucrafting.AECover; import reobf.proghatches.eucrafting.AECover.IMemoryCardSensitive; @@ -156,6 +157,7 @@ import reobf.proghatches.lang.LangManager; import reobf.proghatches.main.mixin.mixins.MixinFixPipeCoverBug; import reobf.proghatches.main.registration.Registration; +import reobf.proghatches.net.ConnectionModeMessage; import reobf.proghatches.net.MasterSetMessage; import reobf.proghatches.net.OpenPartGuiMessage; import reobf.proghatches.net.PriorityMessage; @@ -186,7 +188,7 @@ public class MyMod { public static MyMod instance; { if((Boolean)Launch.blackboard.get("fml.deobfuscatedEnvironment") ){ - + DualityInterface.class.getDeclaredFields(); /*CraftingCPUCluster.class.getDeclaredFields(); NBTTagCompound t=new NBTTagCompound(); AEFluidStack.create(new FluidStack(FluidRegistry.WATER,123).writeToNBT(t)); @@ -278,7 +280,7 @@ public void preInit(FMLPreInitializationEvent event) { net.registerMessage(new MasterSetMessage.Handler(), MasterSetMessage.class, 4, Side.CLIENT); net.registerMessage(new WayPointMessage.Handler(), WayPointMessage.class, 5, Side.CLIENT); net.registerMessage(new VoidFXMessage.Handler(), VoidFXMessage.class, 6, Side.CLIENT); - + net.registerMessage(new ConnectionModeMessage.Handler(), ConnectionModeMessage.class, 7, Side.SERVER); proxy.preInit(event); } @@ -296,7 +298,8 @@ public void init(FMLInitializationEvent event) { AEApi.instance().partHelper().registerNewLayer("reobf.proghatches.fmp.LazerLayer", "reobf.proghatches.eucrafting.ILazer"); - + AEApi.instance().partHelper().registerNewLayer("reobf.proghatches.fmp.LayerCraftingMachine", + "appeng.api.implementations.tiles.ICraftingMachine"); FMLCommonHandler.instance().bus().register(this); MinecraftForge.EVENT_BUS.register(this); @@ -699,6 +702,9 @@ public void init(Entity entity, World world) { public static Item exciter; public static Block[] condensers=new Block[16]; + public static Item stockingexport; + public static Item ma_p2p_part; + public static ItemMAConduit ma_conduit; @SubscribeEvent(priority = EventPriority.HIGH, receiveCanceled = false) public void pretick(final TickEvent.ServerTickEvent event) { diff --git a/src/main/java/reobf/proghatches/main/mixin/MixinPlugin.java b/src/main/java/reobf/proghatches/main/mixin/MixinPlugin.java index 6fefcd0..31ae57b 100644 --- a/src/main/java/reobf/proghatches/main/mixin/MixinPlugin.java +++ b/src/main/java/reobf/proghatches/main/mixin/MixinPlugin.java @@ -78,7 +78,7 @@ public void acceptTargets(Set myTargets, Set otherTargets) { "noRecipeFilterForDualHatch=false"+System.lineSeparator()+ "noRemoveUnusedCacheInModularUIContainer=false"+System.lineSeparator()+ //"noFixRecursiveCraft=false"+System.lineSeparator()+ -"noEUCraftingMixins=false"+System.lineSeparator()+ +"addEUCraftingMixins=false"+System.lineSeparator()+ "noAEItemSortMixins=false"+System.lineSeparator() ; @@ -124,6 +124,8 @@ public List getMixins() { System.out.println("following warnings like 'Error loading class: xxxx' is normal and safe to ignore"); + //Configuration configuration = new Configuration(f); + // load all jars that mixin involves HashMap map= new HashMap<>(6); @@ -144,7 +146,7 @@ public List getMixins() { //if (!"true".equals(pp.get("noFixRecursiveCraft"))) - if (!"true".equals(pp.get("noEUCraftingMixins"))) { + if ("true".equals(pp.get("addEUCraftingMixins"))) { if(ff)retLate.add("eucrafting." + "MixinMachineIdle"); if(ff)retLate.add("eucrafting." + "MixinMachineIdle2"); if(ff)retLate.add("eucrafting." + "MixinCpuClusterEUAutoRequest"); @@ -206,6 +208,11 @@ public List getMixins() { retLate.add("part2.MixinCraftingCondender"); retLate.add("part2.MixinVoidingHatch"); retLate.add("part2.MixinCraftingV2"); + + retLate.add("part2.MixinDirectionCapture"); + retLate.add("part2.MixinEIOGui"); + retLate.add("part2.MixinEIOInit"); + retLate.add("part2.MixinEIOBundle"); 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/part2/MixinDirectionCapture.java b/src/main/java/reobf/proghatches/main/mixin/mixins/part2/MixinDirectionCapture.java new file mode 100644 index 0000000..c8157b5 --- /dev/null +++ b/src/main/java/reobf/proghatches/main/mixin/mixins/part2/MixinDirectionCapture.java @@ -0,0 +1,39 @@ +package reobf.proghatches.main.mixin.mixins.part2; + +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.At.Shift; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.ModifyVariable; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; + +import com.github.vfyjxf.nee.block.tile.TilePatternInterface; + +import appeng.helpers.DualityInterface; +import net.minecraftforge.common.util.ForgeDirection; +import reobf.proghatches.fmp.LayerCraftingMachine; +import reobf.proghatches.fmp.LayerCraftingMachine.StateHolder; + +@Mixin(value={DualityInterface.class,TilePatternInterface.class},remap=false) +public class MixinDirectionCapture { + + + + @ModifyVariable(method="pushPattern",at = @At( + value="INVOKE",target="Lappeng/api/implementations/tiles/ICraftingMachine;acceptsPlans()Z" + ,shift=Shift.BEFORE ) ) + public ForgeDirection cap(ForgeDirection i){ + //System.out.println(i); + LayerCraftingMachine.StateHolder.state=i.getOpposite(); + return i; + } + + + + + + + + + +} diff --git a/src/main/java/reobf/proghatches/main/mixin/mixins/part2/MixinEIOBundle.java b/src/main/java/reobf/proghatches/main/mixin/mixins/part2/MixinEIOBundle.java new file mode 100644 index 0000000..98139d2 --- /dev/null +++ b/src/main/java/reobf/proghatches/main/mixin/mixins/part2/MixinEIOBundle.java @@ -0,0 +1,45 @@ +package reobf.proghatches.main.mixin.mixins.part2; + +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; + +import appeng.api.implementations.tiles.ICraftingMachine; +import appeng.api.networking.crafting.ICraftingPatternDetails; +import crazypants.enderio.conduit.IConduit; +import crazypants.enderio.conduit.TileConduitBundle; +import net.minecraft.inventory.InventoryCrafting; +import net.minecraftforge.common.util.ForgeDirection; +import reobf.proghatches.eio.ICraftingMachineConduit; + +@Mixin(value=TileConduitBundle.class,remap=false) +public abstract class MixinEIOBundle implements ICraftingMachine{ + + @Override + public boolean pushPattern(ICraftingPatternDetails patternDetails, InventoryCrafting table, + ForgeDirection ejectionDirection) { + + ICraftingMachineConduit gc = (ICraftingMachineConduit) getConduit(ICraftingMachineConduit.class); + if(gc!=null){ + return gc.pushPattern(patternDetails, table, ejectionDirection); + + } + + + return false; + } + + @Shadow + public abstract IConduit getConduit(Class type) ; + @Override + public boolean acceptsPlans() { + ICraftingMachineConduit gc = (ICraftingMachineConduit) getConduit(ICraftingMachineConduit.class); + if(gc!=null){ + return gc.acceptsPlans(); + + } + + + return false; + } + +} diff --git a/src/main/java/reobf/proghatches/main/mixin/mixins/part2/MixinEIOGui.java b/src/main/java/reobf/proghatches/main/mixin/mixins/part2/MixinEIOGui.java new file mode 100644 index 0000000..db05f7e --- /dev/null +++ b/src/main/java/reobf/proghatches/main/mixin/mixins/part2/MixinEIOGui.java @@ -0,0 +1,33 @@ +package reobf.proghatches.main.mixin.mixins.part2; + +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; + +import com.enderio.core.api.client.gui.ITabPanel; + +import crazypants.enderio.conduit.IConduit; +import crazypants.enderio.conduit.gui.GuiExternalConnection; +import crazypants.enderio.conduit.gui.PowerSettings; +import crazypants.enderio.conduit.gui.TabFactory; +import crazypants.enderio.conduit.power.IPowerConduit; +import reobf.proghatches.eio.ICraftingMachineConduit; +import reobf.proghatches.eio.MASettings; + +@Mixin(value=TabFactory.class,remap=false) +public class MixinEIOGui { + @Inject(method="createPanelForConduit",at = { @At("RETURN") },cancellable=true) + public void createPanelForConduit(GuiExternalConnection gui, IConduit con + ,CallbackInfoReturnable a + ) { + Class baseType = con.getBaseConduitType(); + if (baseType.isAssignableFrom(ICraftingMachineConduit.class)) { + a.setReturnValue( new MASettings(gui, con)); + + + } + + + } +} diff --git a/src/main/java/reobf/proghatches/main/mixin/mixins/part2/MixinEIOInit.java b/src/main/java/reobf/proghatches/main/mixin/mixins/part2/MixinEIOInit.java new file mode 100644 index 0000000..d3a46b2 --- /dev/null +++ b/src/main/java/reobf/proghatches/main/mixin/mixins/part2/MixinEIOInit.java @@ -0,0 +1,33 @@ +package reobf.proghatches.main.mixin.mixins.part2; + +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; + +import com.enderio.core.api.client.gui.ITabPanel; + +import crazypants.enderio.conduit.AbstractConduit; +import crazypants.enderio.conduit.AbstractConduitNetwork; +import crazypants.enderio.conduit.IConduit; +import crazypants.enderio.conduit.gui.GuiExternalConnection; +import crazypants.enderio.conduit.gui.TabFactory; +import reobf.proghatches.eio.ICraftingMachineConduit; +import reobf.proghatches.eio.MAConduit; +import reobf.proghatches.eio.MASettings; + +@Mixin(value=AbstractConduit.class,remap=false) +public class MixinEIOInit { + + @Inject(method="createNetworkForType",at = { @At("RETURN") },cancellable=true) + public void createPanelForConduit(CallbackInfoReturnable a + ) { + Class type = this.getClass(); + if (ICraftingMachineConduit.class.isAssignableFrom(type)) { + a.setReturnValue( new MAConduit.MAConduitNetwork( + ICraftingMachineConduit.class, ICraftingMachineConduit.class)); + } + + } + +} diff --git a/src/main/java/reobf/proghatches/main/registration/EUCraftingCreativeTab.java b/src/main/java/reobf/proghatches/main/registration/EUCraftingCreativeTab.java index 6cd26f2..b0f3836 100644 --- a/src/main/java/reobf/proghatches/main/registration/EUCraftingCreativeTab.java +++ b/src/main/java/reobf/proghatches/main/registration/EUCraftingCreativeTab.java @@ -30,21 +30,7 @@ public Item getTabIconItem() { @SuppressWarnings("unchecked") @Override public void displayAllReleventItems(List p_78018_1_) { - p_78018_1_.addAll(Registration.items_eucrafting); - //for(int i=0;i<=30;i++) - // p_78018_1_.add(new ItemStack(MyMod.eu_source_part,1,i)); - p_78018_1_.add(new ItemStack(MyMod.eu_source_part,1,0)); - p_78018_1_.add(new ItemStack(MyMod.block_euinterface)); - p_78018_1_.add(new ItemStack(MyMod.euinterface_p2p)); - p_78018_1_.add(new ItemStack(MyMod.cover, 1, 3)); - - p_78018_1_.add(new ItemStack(MyMod.cover, 1, 32)); - p_78018_1_.add(new ItemStack(MyMod.cover, 1, 33)); - //p_78018_1_.add(new ItemStack(MyMod.cover, 1, 34)); - //p_78018_1_.add(new ItemStack(MyMod.cover, 1, 35)); - //p_78018_1_.add(new ItemStack(MyMod.cover, 1, 36)); - p_78018_1_.add(new ItemStack(MyMod.cover, 1, 37)); super.displayAllReleventItems(p_78018_1_); } diff --git a/src/main/java/reobf/proghatches/main/registration/PHRecipes.java b/src/main/java/reobf/proghatches/main/registration/PHRecipes.java index cc49583..7543ea8 100644 --- a/src/main/java/reobf/proghatches/main/registration/PHRecipes.java +++ b/src/main/java/reobf/proghatches/main/registration/PHRecipes.java @@ -37,6 +37,7 @@ import appeng.core.Api; import cpw.mods.fml.common.registry.GameRegistry; +import crazypants.enderio.EnderIOTab; import gregtech.api.GregTech_API; import gregtech.api.enums.GT_Values; import gregtech.api.enums.ItemList; @@ -1647,7 +1648,119 @@ public void run() { ); CraftingManager.getInstance().getRecipeList().add(rec3); - }} + } + + GT_Values.RA.stdBuilder() + .itemInputs( + new ItemStack(GameRegistry.findItem("ExtraUtilities", "trashcan"),1,0), + Hatch_Output_Bus_IV.get(1), + GT_Utility.getIntegratedCircuit(3) + + ) + .itemOutputs( + new ItemStack(GregTech_API.sBlockMachines,1,Config.metaTileEntityOffset + Registration.VBus) + ) + .duration(100 * SECONDS) + .eut(480*4) + .addTo(RecipeMaps.assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + new ItemStack(GameRegistry.findItem("ExtraUtilities", "trashcan"),1,1), + Hatch_Output_IV.get(1), + GT_Utility.getIntegratedCircuit(4) + + ) + .itemOutputs( + new ItemStack(GregTech_API.sBlockMachines,1,Config.metaTileEntityOffset + Registration.VHatch) + ) + .duration(100 * SECONDS) + .eut(480*4) + .addTo(RecipeMaps.assemblerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs( + Cover_Controller.get(1), + new ItemStack(MyMod.cover, 1,37) + + ) + .itemOutputs( + new ItemStack(MyMod.cover, 1,100) + ) + .duration(100 * SECONDS) + .eut(480) + .addTo(RecipeMaps.assemblerRecipes); + + + GT_Values.RA.stdBuilder() + .itemInputs( + + Api.INSTANCE.parts().partExportBus.stack(1), + Api.INSTANCE.materials().materialCardFuzzy.stack(1), + Optional.of( + Api.INSTANCE.definitions().materials().cardOreFilter().maybeStack(1).get() + ).filter(s->{s.stackSize=0;return true;}) + .get() + + ) + .itemOutputs( + new ItemStack(MyMod.stockingexport, 1,0) + ) + .duration(100 * SECONDS) + .eut(480) + .addTo(RecipeMaps.assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + + new ItemStack( ItemAndBlockHolder.FLUID_EXPORT_BUS), + Api.INSTANCE.materials().materialCardFuzzy.stack(1), + Optional.of( + Api.INSTANCE.definitions().materials().cardOreFilter().maybeStack(1).get() + ).filter(s->{s.stackSize=0;return true;}) + .get() + + ) + .itemOutputs( + new ItemStack(MyMod.stockingexport, 1,1) + ) + .duration(100 * SECONDS) + .eut(480) + .addTo(RecipeMaps.assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + Api.INSTANCE.definitions().parts().p2PTunnelME().maybeStack(1).get(), + Api.INSTANCE.definitions().blocks().molecularAssembler().maybeStack(1).get() + + ) + .itemOutputs( + new ItemStack(MyMod.ma_p2p_part, 1,0) + ) + .duration(1000 * SECONDS) + .eut(480) + .addTo(RecipeMaps.assemblerRecipes); + GT_Values.RA.stdBuilder() + .itemInputs( + new ItemStack( GameRegistry.findItem("EnderIO","itemMaterial"),6,1),//Conduit Binder + Api.INSTANCE.definitions().blocks().molecularAssembler().maybeStack(1).get() + + ) + .itemOutputs( + new ItemStack(MyMod.ma_conduit, 8,0) + ) + .duration(1000 * SECONDS) + .eut(480) + .addTo(RecipeMaps.assemblerRecipes); + + + + + + + } + + + + } diff --git a/src/main/java/reobf/proghatches/main/registration/ProgHatchCreativeTab.java b/src/main/java/reobf/proghatches/main/registration/ProgHatchCreativeTab.java index f0809b7..fac5b9c 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.upgrades, 1, 2)); //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(MyMod.ma_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.submitter)); @@ -68,8 +69,38 @@ public void displayAllReleventItems(List p_78018_1_) { p_78018_1_.add(new ItemStack(MyMod.storageproxy,1,1)); p_78018_1_.add(new ItemStack(MyMod.storageproxy,1,2)); p_78018_1_.add(new ItemStack(MyMod.exciter,1,0)); + + p_78018_1_.add(new ItemStack(MyMod.stockingexport,1,0)); + p_78018_1_.add(new ItemStack(MyMod.stockingexport,1,1)); //p_78018_1_.add(new ItemStack(MyMod.storageproxy)); // p_78018_1_.add(new ItemStack(MyMod.euupgrade, 1)); + + + + + + + + + + + + p_78018_1_.addAll(Registration.items_eucrafting); + //for(int i=0;i<=30;i++) + // p_78018_1_.add(new ItemStack(MyMod.eu_source_part,1,i)); + //p_78018_1_.add(new ItemStack(MyMod.eu_source_part,1,0)); + //p_78018_1_.add(new ItemStack(MyMod.block_euinterface)); + + //p_78018_1_.add(new ItemStack(MyMod.euinterface_p2p)); + p_78018_1_.add(new ItemStack(MyMod.cover, 1, 3)); + + p_78018_1_.add(new ItemStack(MyMod.cover, 1, 32)); + p_78018_1_.add(new ItemStack(MyMod.cover, 1, 33)); + //p_78018_1_.add(new ItemStack(MyMod.cover, 1, 34)); + //p_78018_1_.add(new ItemStack(MyMod.cover, 1, 35)); + //p_78018_1_.add(new ItemStack(MyMod.cover, 1, 36)); + p_78018_1_.add(new ItemStack(MyMod.cover, 1, 37)); + p_78018_1_.add(new ItemStack(MyMod.ma_conduit)); } @Override diff --git a/src/main/java/reobf/proghatches/net/ConnectionModeMessage.java b/src/main/java/reobf/proghatches/net/ConnectionModeMessage.java new file mode 100644 index 0000000..3359053 --- /dev/null +++ b/src/main/java/reobf/proghatches/net/ConnectionModeMessage.java @@ -0,0 +1,110 @@ +package reobf.proghatches.net; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +import cpw.mods.fml.common.network.simpleimpl.IMessage; +import cpw.mods.fml.common.network.simpleimpl.IMessageHandler; +import cpw.mods.fml.common.network.simpleimpl.MessageContext; +import crazypants.enderio.conduit.ConnectionMode; +import crazypants.enderio.conduit.IConduit; +import crazypants.enderio.conduit.IConduitBundle; +import crazypants.enderio.conduit.packet.ConTypeEnum; +import crazypants.enderio.conduit.packet.PacketConnectionMode; +import crazypants.enderio.conduit.redstone.IInsulatedRedstoneConduit; +import io.netty.buffer.ByteBuf; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import reobf.proghatches.eio.ICraftingMachineConduit; + +public class ConnectionModeMessage implements IMessage{ + int x,y,z; + protected IConduit getTileCasted(MessageContext ctx) { + World world = ctx.getServerHandler().playerEntity.getEntityWorld(); + if (world == null) { + return null; + } + TileEntity te = world.getTileEntity(x, y, z); + /*if (!(te instanceof IConduitBundle)) { + return null; + }*/ + if (te==null||!te.getClass().getName().contains("crazypants.enderio.conduit.TileConduitBundle")) { + return null; + } + for(Method m:te.getClass().getMethods()){ + if(m.getName().equals("getConduit")){ + + try { + return (IConduit) m.invoke(te, ICraftingMachineConduit.class); + } catch (Exception e) { + e.printStackTrace(); + }break; + + } + + } + + + + return null;//bundle.getConduit(ICraftingMachineConduit.class); + } + public static class Handler implements IMessageHandler { + + @Override + public ConnectionModeMessage onMessage(ConnectionModeMessage message, MessageContext ctx) { + //if (isInvalidPacketForGui(message, ctx)) return null; + IConduit conduit = message.getTileCasted(ctx); + if (conduit == null) { + return null; + } + if (conduit instanceof IInsulatedRedstoneConduit) { + ((IInsulatedRedstoneConduit) conduit).forceConnectionMode(message.dir, message.mode); + } else { + conduit.setConnectionMode(message.dir, message.mode); + } + ctx.getServerHandler().playerEntity.worldObj.markBlockForUpdate(message.x, message.y, message.z); + return null; + } + + + } + private ForgeDirection dir; + private ConnectionMode mode; + + public ConnectionModeMessage() {} + + public ConnectionModeMessage(IConduit con, ForgeDirection dir) { + // super(con.getBundle().getEntity(), ConTypeEnum.get(con)); + try{TileEntity te=(TileEntity)con.getClass().getMethod("getBundle").invoke(con); + x=te.xCoord; + y=te.yCoord; + z=te.zCoord; + this.dir = dir; + mode = con.getConnectionMode(dir);}catch(Exception e){e.printStackTrace();} + } + + @Override + public void toBytes(ByteBuf buf) { + + buf.writeShort(dir.ordinal()); + buf.writeShort(mode.ordinal()); + buf.writeInt(x); + buf.writeInt(y); + buf.writeInt(z); + + } + + @Override + public void fromBytes(ByteBuf buf) { + + dir = ForgeDirection.values()[buf.readShort()]; + mode = ConnectionMode.values()[buf.readShort()]; + x=buf.readInt(); + y=buf.readInt(); + z=buf.readInt(); + + } + + +} diff --git a/src/main/resources/assets/proghatches/lang/en_US.lang b/src/main/resources/assets/proghatches/lang/en_US.lang index b428314..b8a6c28 100644 --- a/src/main/resources/assets/proghatches/lang/en_US.lang +++ b/src/main/resources/assets/proghatches/lang/en_US.lang @@ -654,3 +654,14 @@ programmable_hatches.gt.cmmode.5=So do not place unexpected TEs around, or Inter programmable_hatches.gt.cmmode.6=This happens even it TE has no inventory in some version, or just use Interface in panel form. proghatches.levelcontrolcover.invert.0=On if >=amount proghatches.levelcontrolcover.invert.1=On if <=amount +item.proghatches.stockingexport.0.name=ME Stocking Export Bus +item.proghatches.stockingexport.1.name=ME Stocking Fluid Export Bus +item.stockingexport.name.tooltip.0.0=Try to export everything in storage outside, just like oredict card with wildcard(*) config but also applies to item without oredict. +item.stockingexport.name.tooltip.1.0=Cannot specify target item, only accept up to 16 (Super) Speed Upgrades(base 1, each upgrade x4/x2) . +item.stockingexport.name.tooltip.0.1=Try to export everything in storage outside +item.stockingexport.name.tooltip.1.1=Cannot specify target fluid, only accept up to 16 (Super) Speed Upgrades(base 1000mb, each upgrade x4/x2) . +item.proghatches.part.ma.p2p.name=P2P Tunnel - Molecular Assembly +item.proghatches.part.ma.p2p.tooltips.0=Delegate crafting requests to a remote point. +item.proghatches.part.ma.p2p.tooltips.1=Input side for Interface, output side for Molecular Assembler. +item.proghatches.part.ma.p2p.tooltips.2=Not attunable +enderio.proghatch.ma.conduit.name=Molecular Assembly Conduit diff --git a/src/main/resources/assets/proghatches/lang/zh_CN.lang b/src/main/resources/assets/proghatches/lang/zh_CN.lang index c7a4097..f70d3ef 100644 --- a/src/main/resources/assets/proghatches/lang/zh_CN.lang +++ b/src/main/resources/assets/proghatches/lang/zh_CN.lang @@ -652,3 +652,14 @@ programmable_hatches.gt.cmmode.5=所以不要在周围放TE方块,否则接口 programmable_hatches.gt.cmmode.6=某些版本中即使TE没有物品栏也被认为是容器!或者使用面板形式的接口避免这个问题 proghatches.levelcontrolcover.invert.0=开启条件: >=数量 proghatches.levelcontrolcover.invert.1=开启条件: <=数量 +item.proghatches.stockingexport.0.name=ME库存输出总线 +item.proghatches.stockingexport.1.name=ME库存流体输出总线 +item.stockingexport.name.tooltip.0.0=尝试输出存储内的一切物品,就像使用通配符(*)配置的矿典卡,只是对没有矿典的物品也有效 +item.stockingexport.name.tooltip.1.0=不能指定类型 仅接受至多16个(超级)加速卡(基础1,每个x4/x2) +item.stockingexport.name.tooltip.0.1=尝试输出存储内的一切流体 +item.stockingexport.name.tooltip.1.1=不能指定类型 仅接受至多16个(超级)加速卡(基础1000mb,每个x4/x2) +item.proghatches.part.ma.p2p.name=P2P通道 - 分子装配 +item.proghatches.part.ma.p2p.tooltips.0=将合成请求代理到远端 +item.proghatches.part.ma.p2p.tooltips.1=输入端连接口 输出端连分子装配室 +item.proghatches.part.ma.p2p.tooltips.2=无法调谐 +enderio.proghatch.ma.conduit.name=分子装配导管 diff --git a/src/main/resources/assets/proghatches/textures/items/itemMAConduit.png b/src/main/resources/assets/proghatches/textures/items/itemMAConduit.png new file mode 100644 index 0000000..5cd53a5 Binary files /dev/null and b/src/main/resources/assets/proghatches/textures/items/itemMAConduit.png differ