0

Be more lenient with extended block states being passed by other mods.

build.gradle

@@ -57,7 +57,7 @@ tasks.withType(JavaCompile) {
     options.encoding = 'UTF-8'
 }
 
-version = aeversion + "-" + aechannel + "-" + aebuild + " " + trousers
+version = trousers + "-" + aeversion + "-" + aechannel + "-" + aebuild + "-" + trousersversion
 group = aegroup
 archivesBaseName = aebasename
 

gradle.properties

@@ -3,8 +3,8 @@ aechannel=stable
 aebuild=7
 aegroup=appeng
 aebasename=appliedenergistics2
-trousers=omni-fixes-v46aa
-
+trousers=trousers_edition
+trousersversion=v49t
 #########################################################
 # Versions                                              #
 #########################################################

gradle/scripts/dependencies.gradle

@@ -31,7 +31,7 @@ repositories {
 
     maven {
         name = "Tesla repo"
-        url "http://maven.mcmoddev.com"
+        url "https://maven.mcmoddev.com"
     }
 
     maven {

src/api/java/appeng/api/definitions/IParts.java

@@ -58,6 +58,8 @@ public interface IParts
 
 	IItemDefinition storageBus();
 
+	IItemDefinition oreDictStorageBus();
+
 	IItemDefinition importBus();
 
 	IItemDefinition exportBus();
@@ -102,6 +104,8 @@ public interface IParts
 
 	IItemDefinition patternTerminal();
 
+	IItemDefinition expandedProcessingPatternTerminal();
+
 	IItemDefinition craftingTerminal();
 
 	IItemDefinition terminal();

src/api/java/appeng/api/storage/data/IAEItemStack.java

@@ -121,4 +121,8 @@ public interface IAEItemStack extends IAEStack<IAEItemStack>
 	 */
 	boolean equals(ItemStack is);
 
+	ItemStack getCachedItemStack();
+
+	void setCachedItemStack(ItemStack is);
+
 }

src/main/java/appeng/client/gui/AEGuiHandler.java

@@ -104,7 +104,7 @@ public class AEGuiHandler implements IAdvancedGuiHandler<AEBaseGui>, IGhostIngre
         }
         if( doStart && GuiScreen.isShiftKeyDown() && Mouse.isButtonDown( 0 ) )
         {
-            if( gui instanceof GuiUpgradeable || gui instanceof GuiPatternTerm )
+            if( gui instanceof GuiUpgradeable || gui instanceof GuiPatternTerm || gui instanceof GuiExpandedProcessingPatternTerm )
             {
                 IJEIGhostIngredients ghostGui = ( (IJEIGhostIngredients) gui );
                 for( Target<I> target : targets )

src/main/java/appeng/client/gui/implementations/GuiCraftAmount.java

@@ -21,6 +21,7 @@ package appeng.client.gui.implementations;
 
 import java.io.IOException;
 
+import appeng.parts.reporting.PartExpandedProcessingPatternTerminal;
 import net.minecraft.client.gui.GuiButton;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.item.ItemStack;
@@ -123,6 +124,12 @@ public class GuiCraftAmount extends AEBaseGui
 			this.originalGui = GuiBridge.GUI_PATTERN_TERMINAL;
 		}
 
+		if( target instanceof PartExpandedProcessingPatternTerminal )
+		{
+			myIcon = parts.expandedProcessingPatternTerminal().maybeStack( 1 ).orElse( ItemStack.EMPTY );
+			this.originalGui = GuiBridge.GUI_EXPANDED_PROCESSING_PATTERN_TERMINAL;
+		}
+
 		if( this.originalGui != null && !myIcon.isEmpty() )
 		{
 			this.buttonList.add( this.originalGuiBtn = new GuiTabButton( this.guiLeft + 154, this.guiTop, myIcon, myIcon.getDisplayName(), this.itemRender ) );

src/main/java/appeng/client/gui/implementations/GuiCraftConfirm.java

@@ -25,6 +25,7 @@ import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 
+import appeng.parts.reporting.PartExpandedProcessingPatternTerminal;
 import com.google.common.base.Joiner;
 
 import org.lwjgl.input.Mouse;
@@ -104,6 +105,11 @@ public class GuiCraftConfirm extends AEBaseGui
 		{
 			this.OriginalGui = GuiBridge.GUI_PATTERN_TERMINAL;
 		}
+
+		if( te instanceof PartExpandedProcessingPatternTerminal )
+		{
+			this.OriginalGui = GuiBridge.GUI_EXPANDED_PROCESSING_PATTERN_TERMINAL;
+		}
 	}
 
 	boolean isAutoStart()

src/main/java/appeng/client/gui/implementations/GuiCraftingStatus.java

@@ -25,6 +25,7 @@ package appeng.client.gui.implementations;
 
 import java.io.IOException;
 
+import appeng.parts.reporting.PartExpandedProcessingPatternTerminal;
 import org.lwjgl.input.Mouse;
 
 import net.minecraft.client.gui.GuiButton;
@@ -95,6 +96,12 @@ public class GuiCraftingStatus extends GuiCraftingCPU
 
 			this.originalGui = GuiBridge.GUI_PATTERN_TERMINAL;
 		}
+
+		if( target instanceof PartExpandedProcessingPatternTerminal )
+		{
+			myIcon = parts.expandedProcessingPatternTerminal().maybeStack( 1 ).orElse( ItemStack.EMPTY );
+			this.originalGui = GuiBridge.GUI_EXPANDED_PROCESSING_PATTERN_TERMINAL;
+		}
 	}
 
 	@Override

src/main/java/appeng/client/gui/implementations/GuiExpandedProcessingPatternTerm.java

@@ -0,0 +1,277 @@
+package appeng.client.gui.implementations;
+
+import appeng.api.config.ActionItems;
+import appeng.api.config.ItemSubstitution;
+import appeng.api.config.Settings;
+import appeng.api.storage.ITerminalHost;
+import appeng.client.gui.widgets.GuiImgButton;
+import appeng.client.gui.widgets.GuiTabButton;
+import appeng.container.implementations.ContainerExpandedProcessingPatternTerm;
+import appeng.container.interfaces.IJEIGhostIngredients;
+import appeng.container.slot.AppEngSlot;
+import appeng.container.slot.SlotFake;
+import appeng.core.AELog;
+import appeng.core.localization.GuiText;
+import appeng.core.sync.network.NetworkHandler;
+import appeng.core.sync.packets.PacketInventoryAction;
+import appeng.core.sync.packets.PacketValueConfig;
+import appeng.helpers.InventoryAction;
+import appeng.util.item.AEItemStack;
+import mezz.jei.api.gui.IGhostIngredientHandler;
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.ItemStack;
+
+import java.awt.Rectangle;
+import java.io.IOException;
+import java.util.*;
+
+
+public class GuiExpandedProcessingPatternTerm extends GuiMEMonitorable implements IJEIGhostIngredients
+{
+    private static final String BACKGROUND_EXPANDED_PROCESSING_MODE = "guis/pattern_processing_expanded.png";
+
+    private static final String SUBSITUTION_DISABLE = "0";
+    private static final String SUBSITUTION_ENABLE = "1";
+
+    private static final String CRAFTMODE_CRFTING = "1";
+    private static final String CRAFTMODE_PROCESSING = "0";
+
+    private GuiTabButton tabCraftButton;
+    private GuiTabButton tabProcessButton;
+    private GuiImgButton substitutionsEnabledBtn;
+    private GuiImgButton substitutionsDisabledBtn;
+    private GuiImgButton encodeBtn;
+    private GuiImgButton clearBtn;
+    private GuiImgButton x2Btn;
+    private GuiImgButton x3Btn;
+    private GuiImgButton plusOneBtn;
+    private GuiImgButton divTwoBtn;
+    private GuiImgButton divThreeBtn;
+    private GuiImgButton minusOneBtn;
+    private GuiImgButton maxCountBtn;
+    public Map<IGhostIngredientHandler.Target<?>, Object> mapTargetSlot = new HashMap<>();
+
+    public GuiExpandedProcessingPatternTerm( final InventoryPlayer inventoryPlayer, final ITerminalHost te )
+    {
+        super( inventoryPlayer, te, new ContainerExpandedProcessingPatternTerm( inventoryPlayer, te ) );
+        this.setReservedSpace( 81 );
+    }
+
+    @Override
+    protected void actionPerformed( final GuiButton btn )
+    {
+        super.actionPerformed( btn );
+
+        try
+        {
+
+            if( this.tabCraftButton == btn || this.tabProcessButton == btn )
+            {
+                NetworkHandler.instance().sendToServer( new PacketValueConfig( "PatternTerminal.CraftMode", this.tabProcessButton == btn ? CRAFTMODE_CRFTING : CRAFTMODE_PROCESSING ) );
+            }
+
+            if( this.encodeBtn == btn )
+            {
+                if( isShiftKeyDown() )
+                {
+                    NetworkHandler.instance().sendToServer( new PacketValueConfig( "PatternTerminal.Encode", "2" ) );
+                }
+                else
+                {
+                    NetworkHandler.instance().sendToServer( new PacketValueConfig( "PatternTerminal.Encode", "1" ) );
+                }
+            }
+
+            if( this.clearBtn == btn )
+            {
+                NetworkHandler.instance().sendToServer( new PacketValueConfig( "PatternTerminal.Clear", "1" ) );
+            }
+
+            if( this.x2Btn == btn )
+            {
+                NetworkHandler.instance().sendToServer( new PacketValueConfig( "PatternTerminal.MultiplyByTwo", "1" ) );
+            }
+
+            if( this.x3Btn == btn )
+            {
+                NetworkHandler.instance().sendToServer( new PacketValueConfig( "PatternTerminal.MultiplyByThree", "1" ) );
+            }
+
+            if( this.divTwoBtn == btn )
+            {
+                NetworkHandler.instance().sendToServer( new PacketValueConfig( "PatternTerminal.DivideByTwo", "1" ) );
+            }
+
+            if( this.divThreeBtn == btn )
+            {
+                NetworkHandler.instance().sendToServer( new PacketValueConfig( "PatternTerminal.DivideByThree", "1" ) );
+            }
+
+            if( this.plusOneBtn == btn )
+            {
+                NetworkHandler.instance().sendToServer( new PacketValueConfig( "PatternTerminal.IncreaseByOne", "1" ) );
+            }
+
+            if( this.minusOneBtn == btn )
+            {
+                NetworkHandler.instance().sendToServer( new PacketValueConfig( "PatternTerminal.DecreaseByOne", "1" ) );
+            }
+
+            if( this.maxCountBtn == btn )
+            {
+                NetworkHandler.instance().sendToServer( new PacketValueConfig( "PatternTerminal.MaximizeCount", "1" ) );
+            }
+
+            if( this.substitutionsEnabledBtn == btn || this.substitutionsDisabledBtn == btn )
+            {
+                NetworkHandler.instance().sendToServer( new PacketValueConfig( "PatternTerminal.Substitute", this.substitutionsEnabledBtn == btn ? SUBSITUTION_DISABLE : SUBSITUTION_ENABLE ) );
+            }
+        }
+        catch( final IOException e )
+        {
+            AELog.error( e );
+        }
+    }
+
+    @Override
+    public void initGui()
+    {
+        super.initGui();
+
+        this.tabCraftButton = new GuiTabButton( this.guiLeft + 173, this.guiTop + this.ySize - 177, new ItemStack( Blocks.CRAFTING_TABLE ), GuiText.CraftingPattern.getLocal(), this.itemRender );
+        this.buttonList.add( this.tabCraftButton );
+
+        this.tabProcessButton = new GuiTabButton( this.guiLeft + 173, this.guiTop + this.ySize - 177, new ItemStack( Blocks.FURNACE ), GuiText.ProcessingPattern.getLocal(), this.itemRender );
+        this.buttonList.add( this.tabProcessButton );
+
+        this.substitutionsEnabledBtn = new GuiImgButton( this.guiLeft + 84, this.guiTop + this.ySize - 163, Settings.ACTIONS, ItemSubstitution.ENABLED );
+        this.substitutionsEnabledBtn.setHalfSize( true );
+        this.buttonList.add( this.substitutionsEnabledBtn );
+
+        this.substitutionsDisabledBtn = new GuiImgButton( this.guiLeft + 84, this.guiTop + this.ySize - 163, Settings.ACTIONS, ItemSubstitution.DISABLED );
+        this.substitutionsDisabledBtn.setHalfSize( true );
+        this.buttonList.add( this.substitutionsDisabledBtn );
+
+        this.clearBtn = new GuiImgButton( this.guiLeft + 74, this.guiTop + this.ySize - 163, Settings.ACTIONS, ActionItems.CLOSE );
+        this.clearBtn.setHalfSize( true );
+        this.buttonList.add( this.clearBtn );
+
+        this.x3Btn = new GuiImgButton( this.guiLeft + 131, this.guiTop + this.ySize - 158, Settings.ACTIONS, ActionItems.MULTIPLY_BY_THREE );
+        this.x3Btn.setHalfSize( true );
+        this.buttonList.add( this.x3Btn );
+
+        this.x2Btn = new GuiImgButton( this.guiLeft + 131, this.guiTop + this.ySize - 148, Settings.ACTIONS, ActionItems.MULTIPLY_BY_TWO );
+        this.x2Btn.setHalfSize( true );
+        this.buttonList.add( this.x2Btn );
+
+        this.plusOneBtn = new GuiImgButton( this.guiLeft + 131, this.guiTop + this.ySize - 110, Settings.ACTIONS, ActionItems.INCREASE_BY_ONE );
+        this.plusOneBtn.setHalfSize( true );
+        this.buttonList.add( this.plusOneBtn );
+
+        this.divThreeBtn = new GuiImgButton( this.guiLeft + 87, this.guiTop + this.ySize - 158, Settings.ACTIONS, ActionItems.DIVIDE_BY_THREE );
+        this.divThreeBtn.setHalfSize( true );
+        this.buttonList.add( this.divThreeBtn );
+
+        this.divTwoBtn = new GuiImgButton( this.guiLeft + 87, this.guiTop + this.ySize - 148, Settings.ACTIONS, ActionItems.DIVIDE_BY_TWO );
+        this.divTwoBtn.setHalfSize( true );
+        this.buttonList.add( this.divTwoBtn );
+
+        this.minusOneBtn = new GuiImgButton( this.guiLeft + 87, this.guiTop + this.ySize - 110, Settings.ACTIONS, ActionItems.DECREASE_BY_ONE );
+        this.minusOneBtn.setHalfSize( true );
+        this.buttonList.add( this.minusOneBtn );
+
+        //this.maxCountBtn = new GuiImgButton( this.guiLeft + 128, this.guiTop + this.ySize - 108, Settings.ACTIONS, ActionItems.MAX_COUNT );
+        //this.maxCountBtn.setHalfSize( true );
+        //this.buttonList.add( this.maxCountBtn );
+
+        this.encodeBtn = new GuiImgButton( this.guiLeft + 147, this.guiTop + this.ySize - 142, Settings.ACTIONS, ActionItems.ENCODE );
+        this.buttonList.add( this.encodeBtn );
+    }
+
+    @Override
+    public void drawFG( final int offsetX, final int offsetY, final int mouseX, final int mouseY )
+    {
+        this.tabCraftButton.visible = false;
+        this.tabProcessButton.visible = true;
+        this.substitutionsEnabledBtn.visible = false;
+        this.substitutionsDisabledBtn.visible = false;
+        this.x2Btn.visible = true;
+        this.x3Btn.visible = true;
+        this.divTwoBtn.visible = true;
+        this.divThreeBtn.visible = true;
+        this.plusOneBtn.visible = true;
+        this.minusOneBtn.visible = true;
+        //this.maxCountBtn.visible = true;
+
+        super.drawFG( offsetX, offsetY, mouseX, mouseY );
+        this.fontRenderer.drawString( GuiText.PatternTerminal.getLocal(), 8, this.ySize - 96 + 2 - this.getReservedSpace(), 4210752 );
+    }
+
+    @Override
+    protected String getBackground()
+    {
+        return BACKGROUND_EXPANDED_PROCESSING_MODE;
+    }
+
+    @Override
+    protected void repositionSlot( final AppEngSlot s )
+    {
+        final int offsetPlayerSide = s.isPlayerSide() ? 5 : 3;
+
+        s.yPos = s.getY() + this.ySize - 78 - offsetPlayerSide;
+    }
+
+    @Override
+    public List<IGhostIngredientHandler.Target<?>> getPhantomTargets( Object ingredient )
+    {
+        if( !( ingredient instanceof ItemStack ) )
+        {
+            return Collections.emptyList();
+        }
+        List<IGhostIngredientHandler.Target<?>> targets = new ArrayList<>();
+        for( Slot slot : this.inventorySlots.inventorySlots )
+        {
+            if( slot instanceof SlotFake )
+            {
+                ItemStack itemStack = (ItemStack) ingredient;
+                IGhostIngredientHandler.Target<Object> target = new IGhostIngredientHandler.Target<Object>()
+                {
+                    @Override
+                    public Rectangle getArea()
+                    {
+                        return new Rectangle( getGuiLeft() + slot.xPos, getGuiTop() + slot.yPos, 16, 16 );
+                    }
+
+                    @Override
+                    public void accept( Object ingredient )
+                    {
+                        final PacketInventoryAction p;
+                        try
+                        {
+                            p = new PacketInventoryAction( InventoryAction.PLACE_JEI_GHOST_ITEM, (SlotFake) slot, AEItemStack.fromItemStack( itemStack ) );
+                            NetworkHandler.instance().sendToServer( p );
+
+                        }
+                        catch( IOException e )
+                        {
+                            e.printStackTrace();
+                        }
+                    }
+                };
+                targets.add( target );
+                mapTargetSlot.putIfAbsent( target, slot );
+            }
+        }
+        return targets;
+    }
+
+    @Override
+    public Map<IGhostIngredientHandler.Target<?>, Object> getFakeSlotTargetMap()
+    {
+        return mapTargetSlot;
+    }
+}
+

src/main/java/appeng/client/gui/implementations/GuiPartOreDictStorageBus.java

@@ -0,0 +1,144 @@
+package appeng.client.gui.implementations;
+
+import appeng.api.config.ActionItems;
+import appeng.api.config.Settings;
+import appeng.client.gui.AEBaseGui;
+import appeng.client.gui.widgets.GuiImgButton;
+import appeng.client.gui.widgets.GuiTabButton;
+import appeng.client.gui.widgets.MEGuiTextField;
+import appeng.container.implementations.ContainerPartOreDictStorageBus;
+import appeng.core.localization.GuiText;
+import appeng.core.sync.GuiBridge;
+import appeng.core.sync.network.NetworkHandler;
+import appeng.core.sync.packets.PacketSwitchGuis;
+import appeng.core.sync.packets.PacketValueConfig;
+import appeng.parts.misc.PartOreDicStorageBus;
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.entity.player.InventoryPlayer;
+
+import java.io.IOException;
+import java.util.regex.Pattern;
+
+
+public class GuiPartOreDictStorageBus extends AEBaseGui
+{
+    PartOreDicStorageBus part;
+    private GuiTabButton priority;
+    private GuiImgButton partition;
+
+    private static final Pattern ORE_DICTIONARY_FILTER = Pattern.compile( "\\*?[a-zA-Z0-9_|\\\\+(){,}?!=\\-\\[:\\]&^$]*\\*?" );
+    private MEGuiTextField searchFieldInputs;
+
+    public GuiPartOreDictStorageBus( final InventoryPlayer inventoryPlayer, final PartOreDicStorageBus te )
+    {
+        super( new ContainerPartOreDictStorageBus( inventoryPlayer, te ) );
+        part = te;
+        this.ySize = 84;
+    }
+
+    @Override
+    public void initGui()
+    {
+        super.initGui();
+
+        this.searchFieldInputs = new MEGuiTextField( this.fontRenderer, this.guiLeft + 3, this.guiTop + 22, 170, 12 );
+        this.searchFieldInputs.setEnableBackgroundDrawing( false );
+        this.searchFieldInputs.setMaxStringLength( 512 );
+        this.searchFieldInputs.setTextColor( 0xFFFFFF );
+        this.searchFieldInputs.setVisible( true );
+        this.searchFieldInputs.setFocused( false );
+        this.searchFieldInputs.setValidator( str -> ORE_DICTIONARY_FILTER.matcher( str ).matches() );
+
+        this.buttonList.add( this.priority = new GuiTabButton( this.guiLeft + 154, this.guiTop, 2 + 4 * 16, GuiText.Priority.getLocal(), this.itemRender ) );
+        this.buttonList.add( this.partition = new GuiImgButton( this.guiLeft - 18, this.guiTop + 28, Settings.ACTIONS, ActionItems.WRENCH ) );
+
+        try
+        {
+            NetworkHandler.instance().sendToServer( new PacketValueConfig( "OreDictStorageBus.getRegex", "1" ) );
+        }
+        catch( IOException e )
+        {
+            e.printStackTrace();
+        }
+
+    }
+
+    public void fillRegex( String regex )
+    {
+        this.searchFieldInputs.setText( regex );
+    }
+
+    @Override
+    protected void actionPerformed( final GuiButton btn ) throws IOException
+    {
+        super.actionPerformed( btn );
+        if( btn == this.priority )
+        {
+            NetworkHandler.instance().sendToServer( new PacketSwitchGuis( GuiBridge.GUI_PRIORITY ) );
+        }
+        if( btn == this.partition )
+        {
+            NetworkHandler.instance().sendToServer( new PacketValueConfig( "StorageBus.Action", "Partition" ) );
+            try
+            {
+                NetworkHandler.instance().sendToServer( new PacketValueConfig( "OreDictStorageBus.getRegex", "1" ) );
+            }
+            catch( IOException e )
+            {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    @Override
+    protected void mouseClicked( final int xCoord, final int yCoord, final int btn ) throws IOException
+    {
+        boolean wasFocused = this.searchFieldInputs.isFocused();
+        this.searchFieldInputs.mouseClicked( xCoord, yCoord, btn );
+
+        if( btn == 1 && this.searchFieldInputs.isMouseIn( xCoord, yCoord ) )
+        {
+            this.searchFieldInputs.setText( "" );
+        }
+
+        if( !searchFieldInputs.isFocused() && wasFocused )
+        {
+            NetworkHandler.instance().sendToServer( new PacketValueConfig( "OreDictStorageBus.save", searchFieldInputs.getText() ) );
+        }
+
+        super.mouseClicked( xCoord, yCoord, btn );
+    }
+
+    @Override
+    protected void keyTyped( final char character, final int key ) throws IOException
+    {
+        if( !this.checkHotbarKeys( key ) )
+        {
+            if( !this.searchFieldInputs.textboxKeyTyped( character, key ) )
+            {
+                super.keyTyped( character, key );
+            }
+        }
+    }
+
+    @Override
+    public void drawFG( int offsetX, int offsetY, int mouseX, int mouseY )
+    {
+        this.fontRenderer.drawString( this.getGuiDisplayName( GuiText.OreDictStorageBus.getLocal() ), 8, 6, 4210752 );
+        this.fontRenderer.drawString( this.searchFieldInputs.getText().length() + " / " + this.searchFieldInputs.getMaxStringLength(), 8, 36, 4210752 );
+        this.fontRenderer.drawSplitString( "Supports regex. Or use * as a wildcard", 6, 48, 174, 4210752 );
+    }
+
+    @Override
+    public void drawBG( int offsetX, int offsetY, int mouseX, int mouseY )
+    {
+        this.bindTexture( "guis/oredictstoragebus.png" );
+        this.drawTexturedModalRect( offsetX, offsetY, 0, 0, 175, 85 );
+
+        if( this.searchFieldInputs != null )
+        {
+            this.searchFieldInputs.drawTextBox();
+        }
+    }
+
+}

src/main/java/appeng/client/render/model/DriveBakedModel.java

@@ -19,14 +19,9 @@
 package appeng.client.render.model;
 
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-
-import javax.annotation.Nullable;
-import javax.vecmath.Matrix4f;
-import javax.vecmath.Vector3f;
-
+import appeng.block.storage.BlockDrive;
+import appeng.block.storage.DriveSlotState;
+import appeng.block.storage.DriveSlotsState;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.client.renderer.block.model.BakedQuad;
 import net.minecraft.client.renderer.block.model.IBakedModel;
@@ -37,9 +32,12 @@ import net.minecraft.util.EnumFacing;
 import net.minecraftforge.client.model.pipeline.UnpackedBakedQuad;
 import net.minecraftforge.common.property.IExtendedBlockState;
 
-import appeng.block.storage.BlockDrive;
-import appeng.block.storage.DriveSlotState;
-import appeng.block.storage.DriveSlotsState;
+import javax.annotation.Nullable;
+import javax.vecmath.Matrix4f;
+import javax.vecmath.Vector3f;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
 
 
 public class DriveBakedModel implements IBakedModel
@@ -57,13 +55,17 @@ public class DriveBakedModel implements IBakedModel
 	public List<BakedQuad> getQuads( @Nullable IBlockState state, @Nullable EnumFacing side, long rand )
 	{
 
-		List<BakedQuad> result = new ArrayList<>();
-
-		result.addAll( this.bakedBase.getQuads( state, side, rand ) );
+		List<BakedQuad> result = new ArrayList<>( this.bakedBase.getQuads( state, side, rand ) );
 
 		if( side == null && state instanceof IExtendedBlockState )
 		{
 			IExtendedBlockState extState = (IExtendedBlockState) state;
+
+			if (!extState.getUnlistedNames().contains( BlockDrive.SLOTS_STATE ))
+			{
+				return result;
+			}
+
 			DriveSlotsState slotsState = extState.getValue( BlockDrive.SLOTS_STATE );
 
 			for( int row = 0; row < 5; row++ )

src/main/java/appeng/container/implementations/ContainerCraftConfirm.java

@@ -26,6 +26,7 @@ import java.util.concurrent.Future;
 
 import javax.annotation.Nonnull;
 
+import appeng.parts.reporting.PartExpandedProcessingPatternTerminal;
 import com.google.common.collect.ImmutableSet;
 
 import net.minecraft.entity.player.EntityPlayer;
@@ -345,11 +346,15 @@ public class ContainerCraftConfirm extends AEBaseContainer
 			originalGui = GuiBridge.GUI_PATTERN_TERMINAL;
 		}
 
+		if( ah instanceof PartExpandedProcessingPatternTerminal )
+		{
+			originalGui = GuiBridge.GUI_EXPANDED_PROCESSING_PATTERN_TERMINAL;
+		}
+
 		if( this.result != null && !this.isSimulation() )
 		{
 			final ICraftingGrid cc = this.getGrid().getCache( ICraftingGrid.class );
-			final ICraftingLink g = cc.submitJob( this.result, null, this.getSelectedCpu() == -1 ? null : this.cpus.get( this.getSelectedCpu() ).getCpu(), true,
-					this.getActionSrc() );
+			final ICraftingLink g = cc.submitJob( this.result, null, this.getSelectedCpu() == -1 ? null : this.cpus.get( this.getSelectedCpu() ).getCpu(), true, this.getActionSrc() );
 			this.setAutoStart( false );
 			if( g != null && originalGui != null && this.getOpenContext() != null )
 			{

src/main/java/appeng/container/implementations/ContainerExpandedProcessingPatternTerm.java

@@ -0,0 +1,528 @@
+package appeng.container.implementations;
+
+import appeng.api.AEApi;
+import appeng.api.definitions.IDefinitions;
+import appeng.api.storage.ITerminalHost;
+import appeng.container.slot.*;
+import appeng.helpers.IContainerCraftingPacket;
+import appeng.parts.reporting.PartExpandedProcessingPatternTerminal;
+import appeng.util.Platform;
+import appeng.util.inv.IAEAppEngInventory;
+import appeng.util.inv.InvOperation;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraftforge.items.IItemHandler;
+import net.minecraftforge.items.wrapper.PlayerInvWrapper;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+import static appeng.helpers.PatternHelper.PROCESSING_INPUT_LIMIT;
+import static appeng.helpers.PatternHelper.PROCESSING_OUTPUT_LIMIT;
+
+
+public class ContainerExpandedProcessingPatternTerm extends ContainerMEMonitorable implements IAEAppEngInventory, IOptionalSlotHost, IContainerCraftingPacket
+{
+    private final IItemHandler crafting;
+    private final SlotFakeCraftingMatrix[] gridSlots = new SlotFakeCraftingMatrix[PROCESSING_INPUT_LIMIT];
+    private final OptionalSlotFake[] outputSlots = new OptionalSlotFake[PROCESSING_OUTPUT_LIMIT];
+    private final SlotRestrictedInput patternSlotIN;
+    private final SlotRestrictedInput patternSlotOUT;
+    private final PartExpandedProcessingPatternTerminal expandedProcessingPatternTerminal;
+
+    public ContainerExpandedProcessingPatternTerm( InventoryPlayer ip, ITerminalHost monitorable )
+    {
+        super( ip, monitorable, false );
+
+        this.expandedProcessingPatternTerminal = (PartExpandedProcessingPatternTerminal) monitorable;
+
+        final IItemHandler patternInv = this.getExpandedPatternTerminal().getInventoryByName( "pattern" );
+        final IItemHandler output = this.getExpandedPatternTerminal().getInventoryByName( "output" );
+
+        this.crafting = this.getExpandedPatternTerminal().getInventoryByName( "crafting" );
+
+        for( int y = 0; y < 4; y++ )
+        {
+            for( int x = 0; x < 4; x++ )
+            {
+                this.addSlotToContainer( this.gridSlots[x + y * 4] = new SlotFakeCraftingMatrix( this.crafting, x + y * 4, 4 + x * 18, -85 + y * 18 ) );
+            }
+        }
+
+        for( int y = 0; y < 3; y++ )
+        {
+            for( int x = 0; x < 2; x++ )
+            {
+                this.addSlotToContainer( this.outputSlots[x + y * 2] = new SlotPatternOutputs( output, this, x + y * 2, 96 + x * 18, -76 + y * 18, 0, 0, 1 ) );
+                this.outputSlots[x + y * 2].setRenderDisabled( false );
+                this.outputSlots[x + y * 2].setIIcon( -1 );
+            }
+        }
+
+        this.addSlotToContainer( this.patternSlotIN = new SlotRestrictedInput( SlotRestrictedInput.PlacableItemType.BLANK_PATTERN, patternInv, 0, 147, -72 - 9, this.getInventoryPlayer() ) );
+        this.addSlotToContainer( this.patternSlotOUT = new SlotRestrictedInput( SlotRestrictedInput.PlacableItemType.ENCODED_PATTERN, patternInv, 1, 147, -72 + 34, this.getInventoryPlayer() ) );
+
+        this.patternSlotOUT.setStackLimit( 1 );
+
+        this.bindPlayerInventory( ip, 0, 0 );
+    }
+
+    @Override
+    public ItemStack transferStackInSlot( final EntityPlayer p, final int idx )
+    {
+        if( Platform.isClient() )
+        {
+            return ItemStack.EMPTY;
+        }
+        if( this.inventorySlots.get( idx ) instanceof SlotPlayerInv || this.inventorySlots.get( idx ) instanceof SlotPlayerHotBar )
+        {
+            final AppEngSlot clickSlot = (AppEngSlot) this.inventorySlots.get( idx ); // require AE SLots!
+            ItemStack itemStack = clickSlot.getStack();
+            if( AEApi.instance().definitions().materials().blankPattern().isSameAs( itemStack ) )
+            {
+                IItemHandler patternInv = this.getExpandedPatternTerminal().getInventoryByName( "pattern" );
+                ItemStack remainder = patternInv.insertItem( 0, itemStack, false );
+                clickSlot.putStack( remainder );
+            }
+        }
+        return super.transferStackInSlot( p, idx );
+    }
+
+    @Override
+    public void saveChanges()
+    {
+
+    }
+
+    @Override
+    public void onChangeInventory( final IItemHandler inv, final int slot, final InvOperation mc, final ItemStack removedStack, final ItemStack newStack )
+    {
+
+    }
+
+    public void encodeAndMoveToInventory()
+    {
+        encode();
+        ItemStack output = this.patternSlotOUT.getStack();
+        if( !output.isEmpty() )
+        {
+            if( !getPlayerInv().addItemStackToInventory( output ) )
+            {
+                getPlayerInv().player.dropItem( output, false );
+            }
+            this.patternSlotOUT.putStack( ItemStack.EMPTY );
+        }
+    }
+
+    public void encode()
+    {
+        ItemStack output = this.patternSlotOUT.getStack();
+
+        final ItemStack[] in = this.getInputs();
+        final ItemStack[] out = this.getOutputs();
+
+        // if there is no input, this would be silly.
+        if( in == null || out == null )
+        {
+            return;
+        }
+
+        // first check the output slots, should either be null, or a pattern
+        if( !output.isEmpty() && !this.isPattern( output ) )
+        {
+            return;
+        } // if nothing is there we should snag a new pattern.
+        else if( output.isEmpty() )
+        {
+            output = this.patternSlotIN.getStack();
+            if( output.isEmpty() || !this.isPattern( output ) )
+            {
+                return; // no blanks.
+            }
+
+            // remove one, and clear the input slot.
+            output.setCount( output.getCount() - 1 );
+            if( output.getCount() == 0 )
+            {
+                this.patternSlotIN.putStack( ItemStack.EMPTY );
+            }
+
+            // add a new encoded pattern.
+            Optional<ItemStack> maybePattern = AEApi.instance().definitions().items().encodedPattern().maybeStack( 1 );
+            if( maybePattern.isPresent() )
+            {
+                output = maybePattern.get();
+                this.patternSlotOUT.putStack( output );
+            }
+        }
+
+        // encode the slot.
+        final NBTTagCompound encodedValue = new NBTTagCompound();
+
+        final NBTTagList tagIn = new NBTTagList();
+        final NBTTagList tagOut = new NBTTagList();
+
+        for( final ItemStack i : in )
+        {
+            tagIn.appendTag( this.createItemTag( i ) );
+        }
+
+        for( final ItemStack i : out )
+        {
+            tagOut.appendTag( this.createItemTag( i ) );
+        }
+
+        encodedValue.setTag( "in", tagIn );
+        encodedValue.setTag( "out", tagOut );
+        encodedValue.setBoolean( "crafting", false );
+        encodedValue.setBoolean( "substitute", false );
+
+        output.setTagCompound( encodedValue );
+    }
+
+    boolean isPattern( final ItemStack output )
+    {
+        if( output.isEmpty() )
+        {
+            return false;
+        }
+
+        final IDefinitions definitions = AEApi.instance().definitions();
+
+        boolean isPattern = definitions.items().encodedPattern().isSameAs( output );
+        isPattern |= definitions.materials().blankPattern().isSameAs( output );
+
+        return isPattern;
+    }
+
+    NBTBase createItemTag( final ItemStack i )
+    {
+        final NBTTagCompound c = new NBTTagCompound();
+
+        if( !i.isEmpty() )
+        {
+            i.writeToNBT( c );
+        }
+
+        return c;
+    }
+
+    @Override
+    public boolean isSlotEnabled( final int idx )
+    {
+        return true;
+    }
+
+    protected ItemStack[] getInputs()
+    {
+        final ItemStack[] input = new ItemStack[16];
+        boolean hasValue = false;
+
+        for( int x = 0; x < this.gridSlots.length; x++ )
+        {
+            input[x] = this.gridSlots[x].getStack();
+            if( !input[x].isEmpty() )
+            {
+                hasValue = true;
+            }
+        }
+
+        if( hasValue )
+        {
+            return input;
+        }
+
+        return null;
+    }
+
+    protected ItemStack[] getOutputs()
+    {
+        final List<ItemStack> list = new ArrayList<>( 3 );
+        boolean hasValue = false;
+
+        for( final OptionalSlotFake outputSlot : this.outputSlots )
+        {
+            final ItemStack out = outputSlot.getStack();
+
+            if( !out.isEmpty() && out.getCount() > 0 )
+            {
+                list.add( out );
+                hasValue = true;
+            }
+        }
+
+        if( hasValue )
+        {
+            return list.toArray( new ItemStack[0] );
+        }
+        return null;
+    }
+
+    public void clear()
+    {
+        for( final Slot s : this.gridSlots )
+        {
+            s.putStack( ItemStack.EMPTY );
+        }
+
+        for( final Slot s : this.outputSlots )
+        {
+            s.putStack( ItemStack.EMPTY );
+        }
+
+        this.detectAndSendChanges();
+    }
+
+    @Override
+    public IItemHandler getInventoryByName( final String name )
+    {
+        if( name.equals( "player" ) )
+        {
+            return new PlayerInvWrapper( this.getInventoryPlayer() );
+        }
+        return this.getExpandedPatternTerminal().getInventoryByName( name );
+    }
+
+    @Override
+    public boolean useRealItems()
+    {
+        return false;
+    }
+
+    public PartExpandedProcessingPatternTerminal getExpandedPatternTerminal()
+    {
+        return this.expandedProcessingPatternTerminal;
+    }
+
+    public void multiply( int multiple )
+    {
+        ItemStack[] input = new ItemStack[gridSlots.length];
+        boolean canMultiplyInputs = true;
+        boolean canMultiplyOutputs = true;
+
+        for( int x = 0; x < this.gridSlots.length; x++ )
+        {
+            input[x] = this.gridSlots[x].getStack();
+            if( !input[x].isEmpty() && input[x].getCount() * multiple > input[x].getMaxStackSize() )
+            {
+                canMultiplyInputs = false;
+            }
+        }
+        for( final OptionalSlotFake outputSlot : this.outputSlots )
+        {
+            final ItemStack out = outputSlot.getStack();
+            if( !out.isEmpty() && out.getCount() * multiple > out.getMaxStackSize() )
+            {
+                canMultiplyOutputs = false;
+            }
+        }
+        if( canMultiplyInputs && canMultiplyOutputs )
+        {
+            for( SlotFakeCraftingMatrix craftingSlot : this.gridSlots )
+            {
+                ItemStack stack = craftingSlot.getStack();
+                if( !stack.isEmpty() )
+                {
+                    craftingSlot.getStack().setCount( stack.getCount() * multiple );
+                }
+            }
+            for( OptionalSlotFake outputSlot : this.outputSlots )
+            {
+                ItemStack stack = outputSlot.getStack();
+                if( !stack.isEmpty() )
+                {
+                    outputSlot.getStack().setCount( stack.getCount() * multiple );
+                }
+            }
+        }
+    }
+
+    public void divide( int divide )
+    {
+        ItemStack[] input = new ItemStack[gridSlots.length];
+        boolean canDivideInputs = true;
+        boolean canDivideOutputs = true;
+
+        for( int x = 0; x < this.gridSlots.length; x++ )
+        {
+            input[x] = this.gridSlots[x].getStack();
+            if( !input[x].isEmpty() && input[x].getCount() % divide != 0 )
+            {
+                canDivideInputs = false;
+            }
+        }
+        for( final OptionalSlotFake outputSlot : this.outputSlots )
+        {
+            final ItemStack out = outputSlot.getStack();
+            if( !out.isEmpty() && out.getCount() % divide != 0 )
+            {
+                canDivideOutputs = false;
+            }
+        }
+        if( canDivideInputs && canDivideOutputs )
+        {
+            for( SlotFakeCraftingMatrix craftingSlot : this.gridSlots )
+            {
+                ItemStack stack = craftingSlot.getStack();
+                if( !stack.isEmpty() )
+                {
+                    craftingSlot.getStack().setCount( stack.getCount() / divide );
+                }
+            }
+            for( OptionalSlotFake outputSlot : this.outputSlots )
+            {
+                ItemStack stack = outputSlot.getStack();
+                if( !stack.isEmpty() )
+                {
+                    outputSlot.getStack().setCount( stack.getCount() / divide );
+                }
+            }
+        }
+    }
+
+    public void increase( int increase )
+    {
+        ItemStack[] input = new ItemStack[gridSlots.length];
+        boolean canIncreaseInputs = true;
+        boolean canIncreaseOutputs = true;
+
+        for( int x = 0; x < this.gridSlots.length; x++ )
+        {
+            input[x] = this.gridSlots[x].getStack();
+            if( !input[x].isEmpty() && input[x].getCount() + increase > input[x].getMaxStackSize() )
+            {
+                canIncreaseInputs = false;
+            }
+        }
+        for( final OptionalSlotFake outputSlot : this.outputSlots )
+        {
+            final ItemStack out = outputSlot.getStack();
+            if( !out.isEmpty() && out.getCount() + increase > out.getMaxStackSize() )
+            {
+                canIncreaseOutputs = false;
+            }
+        }
+        if( canIncreaseInputs && canIncreaseOutputs )
+        {
+            for( SlotFakeCraftingMatrix craftingSlot : this.gridSlots )
+            {
+                ItemStack stack = craftingSlot.getStack();
+                if( !stack.isEmpty() )
+                {
+                    craftingSlot.getStack().setCount( stack.getCount() + increase );
+                }
+            }
+            for( OptionalSlotFake outputSlot : this.outputSlots )
+            {
+                ItemStack stack = outputSlot.getStack();
+                if( !stack.isEmpty() )
+                {
+                    outputSlot.getStack().setCount( stack.getCount() + increase );
+                }
+            }
+        }
+    }
+
+    public void decrease( int decrease )
+    {
+        ItemStack[] input = new ItemStack[gridSlots.length];
+        boolean canDecreaseInputs = true;
+        boolean canDecreaseOutputs = true;
+
+        for( int x = 0; x < this.gridSlots.length; x++ )
+        {
+            input[x] = this.gridSlots[x].getStack();
+            if( !input[x].isEmpty() && input[x].getCount() - decrease < 1 )
+            {
+                canDecreaseInputs = false;
+            }
+        }
+        for( final OptionalSlotFake outputSlot : this.outputSlots )
+        {
+            final ItemStack out = outputSlot.getStack();
+            if( !out.isEmpty() && out.getCount() - decrease < 1 )
+            {
+                canDecreaseOutputs = false;
+            }
+        }
+        if( canDecreaseInputs && canDecreaseOutputs )
+        {
+            for( SlotFakeCraftingMatrix craftingSlot : this.gridSlots )
+            {
+                ItemStack stack = craftingSlot.getStack();
+                if( !stack.isEmpty() )
+                {
+                    craftingSlot.getStack().setCount( stack.getCount() - decrease );
+                }
+            }
+            for( OptionalSlotFake outputSlot : this.outputSlots )
+            {
+                ItemStack stack = outputSlot.getStack();
+                if( !stack.isEmpty() )
+                {
+                    outputSlot.getStack().setCount( stack.getCount() - decrease );
+                }
+            }
+        }
+    }
+
+    public void maximizeCount()
+    {
+        ItemStack[] input = new ItemStack[gridSlots.length];
+        boolean canGrowInputs = true;
+        boolean canGrowOutputs = true;
+        int maxInputStackGrowth = 0;
+        int maxOutputStackGrowth = 0;
+
+        for( int x = 0; x < this.gridSlots.length; x++ )
+        {
+            input[x] = this.gridSlots[x].getStack();
+            if( !input[x].isEmpty() && input[x].getMaxStackSize() - input[x].getCount() > maxInputStackGrowth )
+            {
+                maxInputStackGrowth = input[x].getMaxStackSize() - input[x].getCount();
+            }
+            if( !input[x].isEmpty() && input[x].getCount() + maxInputStackGrowth > input[x].getMaxStackSize() )
+            {
+                canGrowInputs = false;
+            }
+        }
+        for( final OptionalSlotFake outputSlot : this.outputSlots )
+        {
+            final ItemStack out = outputSlot.getStack();
+            {
+                maxOutputStackGrowth = out.getMaxStackSize() - out.getCount();
+            }
+            if( !out.isEmpty() && out.getCount() + maxOutputStackGrowth > out.getMaxStackSize() )
+            {
+                canGrowOutputs = false;
+            }
+        }
+        if( canGrowInputs && canGrowOutputs )
+        {
+            int maxStackGrowth = Math.min( maxInputStackGrowth, maxOutputStackGrowth );
+            for( SlotFakeCraftingMatrix craftingSlot : this.gridSlots )
+            {
+                ItemStack stack = craftingSlot.getStack();
+                if( !stack.isEmpty() )
+                {
+                    craftingSlot.getStack().setCount( stack.getCount() + maxStackGrowth );
+                }
+            }
+            for( OptionalSlotFake outputSlot : this.outputSlots )
+            {
+                ItemStack stack = outputSlot.getStack();
+                if( !stack.isEmpty() )
+                {
+                    outputSlot.getStack().setCount( stack.getCount() + maxStackGrowth );
+                }
+            }
+        }
+    }
+
+}

src/main/java/appeng/container/implementations/ContainerPartOreDictStorageBus.java

@@ -0,0 +1,113 @@
+package appeng.container.implementations;
+
+import appeng.api.AEApi;
+import appeng.api.config.AccessRestriction;
+import appeng.api.config.FuzzyMode;
+import appeng.api.config.Settings;
+import appeng.api.config.StorageFilter;
+import appeng.api.storage.IMEInventory;
+import appeng.api.storage.channels.IItemStorageChannel;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.api.storage.data.IItemList;
+import appeng.container.AEBaseContainer;
+import appeng.core.sync.network.NetworkHandler;
+import appeng.core.sync.packets.PacketValueConfig;
+import appeng.parts.misc.PartOreDicStorageBus;
+import appeng.util.Platform;
+import appeng.util.helpers.ItemHandlerUtil;
+import appeng.util.item.AEItemStack;
+import appeng.util.item.OreReference;
+import appeng.util.iterators.NullIterator;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.items.IItemHandler;
+import net.minecraftforge.oredict.OreDictionary;
+
+import java.io.IOException;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+
+public class ContainerPartOreDictStorageBus extends AEBaseContainer
+{
+    private final PartOreDicStorageBus part;
+
+    public ContainerPartOreDictStorageBus( final InventoryPlayer ip, final PartOreDicStorageBus anchor )
+    {
+        super( ip, anchor );
+        this.part = anchor;
+
+        this.bindPlayerInventory( ip, 14, 256 - /* height of player inventory */82 );
+    }
+
+    @Override
+    public void detectAndSendChanges()
+    {
+        if( Platform.isClient() )
+        {
+            return;
+        }
+
+        super.detectAndSendChanges();
+    }
+
+    public void partition()
+    {
+        final IMEInventory<IAEItemStack> cellInv = this.part.getInternalHandler();
+
+        Set<Integer> oreIDs = new HashSet<>();
+
+        for( IAEItemStack itemStack : cellInv.getAvailableItems( AEApi.instance().storage().getStorageChannel( IItemStorageChannel.class ).createList() ) )
+        {
+            OreReference ref = ( (AEItemStack) itemStack ).getOre().orElse( null );
+            if( ref != null )
+            {
+                oreIDs.addAll( ref.getOres() );
+            }
+        }
+
+        String oreMatch = "(";
+        String append = "";
+
+        for( Iterator<Integer> it = oreIDs.iterator(); it.hasNext(); )
+        {
+            int oreID = it.next();
+            if( it.hasNext() )
+            {
+                append = ")|(";
+            }
+            else
+            {
+                append = ")";
+            }
+            oreMatch = oreMatch.concat( OreDictionary.getOreName( oreID ) + append );
+        }
+
+        if( oreMatch.equals( "(" ) )
+        {
+            oreMatch = "";
+        }
+        part.saveOreMatch( oreMatch );
+
+        this.detectAndSendChanges();
+    }
+
+    public void saveOreMatch( String value )
+    {
+        part.saveOreMatch( value );
+    }
+
+    public void sendRegex()
+    {
+        try
+        {
+            NetworkHandler.instance().sendTo( new PacketValueConfig( "OreDictStorageBus.sendRegex", part.getOreMatch() ), (EntityPlayerMP) getInventoryPlayer().player );
+        }
+        catch( IOException e )
+        {
+            e.printStackTrace();
+        }
+    }
+}

src/main/java/appeng/container/implementations/ContainerPatternTerm.java

@@ -178,7 +178,7 @@ public class ContainerPatternTerm extends ContainerMEMonitorable implements IAEA
 		this.getAndUpdateOutput();
 	}
 
-	private ItemStack getAndUpdateOutput()
+	protected ItemStack getAndUpdateOutput()
 	{
 		final World world = this.getPlayerInv().player.world;
 		final InventoryCrafting ic = new InventoryCrafting( this, 3, 3 );
@@ -505,7 +505,7 @@ public class ContainerPatternTerm extends ContainerMEMonitorable implements IAEA
 		}
 	}
 
-	private ItemStack[] getInputs()
+	protected ItemStack[] getInputs()
 	{
 		final ItemStack[] input = new ItemStack[9];
 		boolean hasValue = false;
@@ -527,7 +527,7 @@ public class ContainerPatternTerm extends ContainerMEMonitorable implements IAEA
 		return null;
 	}
 
-	private ItemStack[] getOutputs()
+	protected ItemStack[] getOutputs()
 	{
 		if( this.isCraftingMode() )
 		{
@@ -535,7 +535,7 @@ public class ContainerPatternTerm extends ContainerMEMonitorable implements IAEA
 
 			if( !out.isEmpty() && out.getCount() > 0 )
 			{
-				return new ItemStack[] { out };
+				return new ItemStack[]{out};
 			}
 		}
 		else
@@ -563,7 +563,7 @@ public class ContainerPatternTerm extends ContainerMEMonitorable implements IAEA
 		return null;
 	}
 
-	private boolean isPattern( final ItemStack output )
+	boolean isPattern( final ItemStack output )
 	{
 		if( output.isEmpty() )
 		{
@@ -578,7 +578,7 @@ public class ContainerPatternTerm extends ContainerMEMonitorable implements IAEA
 		return isPattern;
 	}
 
-	private NBTBase createItemTag( final ItemStack i )
+	NBTBase createItemTag( final ItemStack i )
 	{
 		final NBTTagCompound c = new NBTTagCompound();
 
@@ -824,7 +824,7 @@ public class ContainerPatternTerm extends ContainerMEMonitorable implements IAEA
 		return this.patternTerminal;
 	}
 
-	private boolean isSubstitute()
+	boolean isSubstitute()
 	{
 		return this.substitute;
 	}

src/main/java/appeng/core/api/definitions/ApiParts.java

@@ -52,6 +52,7 @@ public final class ApiParts implements IParts
 	private final IItemDefinition toggleBus;
 	private final IItemDefinition invertedToggleBus;
 	private final IItemDefinition storageBus;
+	private final IItemDefinition oreDictStorageBus;
 	private final IItemDefinition importBus;
 	private final IItemDefinition exportBus;
 	private final IItemDefinition iface;
@@ -77,6 +78,7 @@ public final class ApiParts implements IParts
 	private final IItemDefinition darkMonitor;
 	private final IItemDefinition interfaceTerminal;
 	private final IItemDefinition patternTerminal;
+	private final IItemDefinition expandedProcessingPatternTerminal;
 	private final IItemDefinition craftingTerminal;
 	private final IItemDefinition terminal;
 	private final IItemDefinition storageMonitor;
@@ -112,6 +114,7 @@ public final class ApiParts implements IParts
 		this.toggleBus = new DamagedItemDefinition( "part.toggle_bus", itemPart.createPart( PartType.TOGGLE_BUS ) );
 		this.invertedToggleBus = new DamagedItemDefinition( "part.toggle_bus.inverted", itemPart.createPart( PartType.INVERTED_TOGGLE_BUS ) );
 		this.storageBus = new DamagedItemDefinition( "part.bus.storage", itemPart.createPart( PartType.STORAGE_BUS ) );
+		this.oreDictStorageBus = new DamagedItemDefinition( "part.bus.oredict_storage", itemPart.createPart( PartType.OREDICT_STORAGE_BUS ) );
 		this.importBus = new DamagedItemDefinition( "part.bus.import", itemPart.createPart( PartType.IMPORT_BUS ) );
 		this.exportBus = new DamagedItemDefinition( "part.bus.export", itemPart.createPart( PartType.EXPORT_BUS ) );
 		this.iface = new DamagedItemDefinition( "part.interface", itemPart.createPart( PartType.INTERFACE ) );
@@ -139,6 +142,7 @@ public final class ApiParts implements IParts
 		this.darkMonitor = new DamagedItemDefinition( "part.monitor.dark", itemPart.createPart( PartType.DARK_MONITOR ) );
 		this.interfaceTerminal = new DamagedItemDefinition( "part.terminal.interface", itemPart.createPart( PartType.INTERFACE_TERMINAL ) );
 		this.patternTerminal = new DamagedItemDefinition( "part.terminal.pattern", itemPart.createPart( PartType.PATTERN_TERMINAL ) );
+		this.expandedProcessingPatternTerminal = new DamagedItemDefinition( "part.terminal.expanded_processing_pattern", itemPart.createPart( PartType.EXPANDED_PROCESSING_PATTERN_TERMINAL ) );
 		this.craftingTerminal = new DamagedItemDefinition( "part.terminal.crafting", itemPart.createPart( PartType.CRAFTING_TERMINAL ) );
 		this.terminal = new DamagedItemDefinition( "part.terminal", itemPart.createPart( PartType.TERMINAL ) );
 		this.storageMonitor = new DamagedItemDefinition( "part.monitor.storage", itemPart.createPart( PartType.STORAGE_MONITOR ) );
@@ -245,6 +249,12 @@ public final class ApiParts implements IParts
 		return this.storageBus;
 	}
 
+	@Override
+	public IItemDefinition oreDictStorageBus()
+	{
+		return this.oreDictStorageBus;
+	}
+
 	@Override
 	public IItemDefinition importBus()
 	{
@@ -379,6 +389,12 @@ public final class ApiParts implements IParts
 		return this.patternTerminal;
 	}
 
+	@Override
+	public IItemDefinition expandedProcessingPatternTerminal()
+	{
+		return this.expandedProcessingPatternTerminal;
+	}
+
 	@Override
 	public IItemDefinition craftingTerminal()
 	{

src/main/java/appeng/core/localization/GuiText.java

@@ -70,6 +70,7 @@ public enum GuiText
 	EnergyDrain,
 
 	StorageBus,
+	OreDictStorageBus,
 	StorageBusFluids,
 	Priority,
 	Security,

src/main/java/appeng/core/localization/WailaText.java

@@ -31,8 +31,10 @@ public enum WailaText
 	DeviceMissingChannel,
 
 	P2PUnlinked,
-	P2PInputOneOutput,
-	P2PInputManyOutputs,
+	P2P_INPUT_ONE_OUTPUT,
+	P2P_INPUT_MANY_OUTPUTS,
+	P2P_OUTPUT_ONE_INPUT,
+	P2P_OUTPUT_MANY_INPUTS,
 	P2POutput,
 
 	Locked,

src/main/java/appeng/core/sync/GuiBridge.java

@@ -21,6 +21,9 @@ package appeng.core.sync;
 
 import java.lang.reflect.Constructor;
 
+import appeng.container.implementations.*;
+import appeng.parts.misc.PartOreDicStorageBus;
+import appeng.parts.reporting.PartExpandedProcessingPatternTerminal;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.item.ItemStack;
@@ -53,39 +56,6 @@ import appeng.client.gui.GuiNull;
 import appeng.container.AEBaseContainer;
 import appeng.container.ContainerNull;
 import appeng.container.ContainerOpenContext;
-import appeng.container.implementations.ContainerCellWorkbench;
-import appeng.container.implementations.ContainerChest;
-import appeng.container.implementations.ContainerCondenser;
-import appeng.container.implementations.ContainerCraftAmount;
-import appeng.container.implementations.ContainerCraftConfirm;
-import appeng.container.implementations.ContainerCraftingCPU;
-import appeng.container.implementations.ContainerCraftingStatus;
-import appeng.container.implementations.ContainerCraftingTerm;
-import appeng.container.implementations.ContainerDrive;
-import appeng.container.implementations.ContainerFormationPlane;
-import appeng.container.implementations.ContainerGrinder;
-import appeng.container.implementations.ContainerIOPort;
-import appeng.container.implementations.ContainerInscriber;
-import appeng.container.implementations.ContainerInterface;
-import appeng.container.implementations.ContainerInterfaceTerminal;
-import appeng.container.implementations.ContainerLevelEmitter;
-import appeng.container.implementations.ContainerMAC;
-import appeng.container.implementations.ContainerMEMonitorable;
-import appeng.container.implementations.ContainerMEPortableCell;
-import appeng.container.implementations.ContainerNetworkStatus;
-import appeng.container.implementations.ContainerNetworkTool;
-import appeng.container.implementations.ContainerPatternTerm;
-import appeng.container.implementations.ContainerPriority;
-import appeng.container.implementations.ContainerQNB;
-import appeng.container.implementations.ContainerQuartzKnife;
-import appeng.container.implementations.ContainerSecurityStation;
-import appeng.container.implementations.ContainerSkyChest;
-import appeng.container.implementations.ContainerSpatialIOPort;
-import appeng.container.implementations.ContainerStorageBus;
-import appeng.container.implementations.ContainerUpgradeable;
-import appeng.container.implementations.ContainerVibrationChamber;
-import appeng.container.implementations.ContainerWireless;
-import appeng.container.implementations.ContainerWirelessTerm;
 import appeng.fluids.container.ContainerFluidFormationPlane;
 import appeng.fluids.container.ContainerFluidIO;
 import appeng.fluids.container.ContainerFluidInterface;
@@ -171,6 +141,8 @@ public enum GuiBridge implements IGuiHandler
 
 	GUI_STORAGEBUS( ContainerStorageBus.class, PartStorageBus.class, GuiHostType.WORLD, SecurityPermissions.BUILD ),
 
+	GUI_OREDICTSTORAGEBUS( ContainerPartOreDictStorageBus.class, PartOreDicStorageBus.class, GuiHostType.WORLD, SecurityPermissions.BUILD ),
+
 	GUI_STORAGEBUS_FLUID( ContainerFluidStorageBus.class, PartFluidStorageBus.class, GuiHostType.WORLD, SecurityPermissions.BUILD ),
 
 	GUI_FORMATION_PLANE( ContainerFormationPlane.class, PartFormationPlane.class, GuiHostType.WORLD, SecurityPermissions.BUILD ),
@@ -185,6 +157,8 @@ public enum GuiBridge implements IGuiHandler
 
 	GUI_PATTERN_TERMINAL( ContainerPatternTerm.class, PartPatternTerminal.class, GuiHostType.WORLD, SecurityPermissions.CRAFT ),
 
+	GUI_EXPANDED_PROCESSING_PATTERN_TERMINAL( ContainerExpandedProcessingPatternTerm.class, PartExpandedProcessingPatternTerminal.class, GuiHostType.WORLD, SecurityPermissions.CRAFT ),
+
 	GUI_FLUID_TERMINAL( ContainerFluidTerminal.class, ITerminalHost.class, GuiHostType.WORLD, SecurityPermissions.BUILD ),
 
 	// extends (Container/Gui) + Bus

src/main/java/appeng/core/sync/packets/PacketInventoryAction.java

@@ -192,7 +192,20 @@ public class PacketInventoryAction extends AppEngPacket
 			}
 			else if( this.action == InventoryAction.PLACE_JEI_GHOST_ITEM )
 			{
-				if( sender.openContainer.inventorySlots.get( this.slot ) instanceof SlotFake )
+				if( sender.openContainer instanceof ContainerFluidConfigurable )
+				{
+					if( this.slotItem != null )
+					{
+						IAEFluidStack aefs = AEFluidStack.fromNBT( this.slotItem.getDefinition().getTagCompound() );
+						if( aefs != null )
+						{
+							aefs.setStackSize( 1000 );
+							( (ContainerFluidConfigurable) sender.openContainer ).getFluidConfigInventory().setFluidInSlot( this.slot, aefs );
+							NetworkHandler.instance().sendToServer( new PacketFluidSlot( Collections.singletonMap( this.slot, aefs ) ) );
+						}
+					}
+				}
+				else if( this.slot < sender.openContainer.inventorySlots.size() && sender.openContainer.inventorySlots.get( this.slot ) instanceof SlotFake )
 				{
 					if( this.slotItem != null )
 					{
@@ -217,20 +230,6 @@ public class PacketInventoryAction extends AppEngPacket
 						AELog.debug( e );
 					}
 				}
-
-				if( sender.openContainer instanceof ContainerFluidConfigurable )
-				{
-					if( this.slotItem != null )
-					{
-						IAEFluidStack aefs = AEFluidStack.fromNBT( this.slotItem.getDefinition().getTagCompound() );
-						if( aefs != null )
-						{
-							aefs.setStackSize( 1000 );
-							( (ContainerFluidConfigurable) sender.openContainer ).getFluidConfigInventory().setFluidInSlot( this.slot, aefs );
-							NetworkHandler.instance().sendToServer( new PacketFluidSlot( Collections.singletonMap( this.slot, aefs ) ) );
-						}
-					}
-				}
 			}
 			else
 			{

src/main/java/appeng/core/sync/packets/PacketJEIRecipe.java

@@ -23,11 +23,12 @@ import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Iterator;
+import java.util.List;
 
 import appeng.api.config.FuzzyMode;
-import appeng.api.storage.data.IItemList;
+import appeng.container.implementations.ContainerExpandedProcessingPatternTerm;
 import appeng.container.implementations.ContainerPatternTerm;
 import gregtech.common.items.MetaTool;
 import io.netty.buffer.ByteBuf;
@@ -69,8 +70,9 @@ import appeng.util.prioritylist.IPartitionList;
 public class PacketJEIRecipe extends AppEngPacket
 {
 
-	private ItemStack[][] recipe;
-	private ItemStack[] output;
+	private List<ItemStack[]> recipe;
+	private List<ItemStack> output;
+	static ItemStack[] emptyArray = {ItemStack.EMPTY};
 
 
 	// automatic.
@@ -81,28 +83,35 @@ public class PacketJEIRecipe extends AppEngPacket
 		final NBTTagCompound comp = CompressedStreamTools.readCompressed( bytes );
 		if( comp != null )
 		{
-			this.recipe = new ItemStack[9][];
-			for( int x = 0; x < this.recipe.length; x++ )
+			this.recipe = new ArrayList<>();
+
+			for( int x = 0; x < comp.getKeySet().size(); x++ )
 			{
-				final NBTTagList list = comp.getTagList( "#" + x, 10 );
-				if( list.tagCount() > 0 )
+				if( comp.hasKey( "#" + x ) )
 				{
-					this.recipe[x] = new ItemStack[list.tagCount()];
-					for( int y = 0; y < list.tagCount(); y++ )
+					final NBTTagList list = comp.getTagList( "#" + x, 10 );
+					if( list.tagCount() > 0 )
 					{
-						this.recipe[x][y] = new ItemStack( list.getCompoundTagAt( y ) );
+						this.recipe.add( new ItemStack[list.tagCount()] );
+						for( int y = 0; y < list.tagCount(); y++ )
+						{
+							this.recipe.get( x )[y] = new ItemStack( list.getCompoundTagAt( y ) );
+						}
+					}
+					else
+					{
+						this.recipe.add( emptyArray );
 					}
 				}
 			}
-			if ( comp.hasKey("outputs") ) {
-				final NBTTagList outputList = comp.getTagList("outputs", 10);
-				this.output = new ItemStack[3];
-				for( int x = 0; x < this.output.length; x++ )
+
+			if( comp.hasKey( "outputs" ) )
+			{
+				final NBTTagList outputList = comp.getTagList( "outputs", 10 );
+				this.output = new ArrayList<>();
+				for( int z = 0; z < outputList.tagCount(); z++ )
 				{
-					if( outputList.tagCount() > 0 )
-					{
-						this.output[x] = new ItemStack(outputList.getCompoundTagAt( x ));
-					}
+					this.output.add( new ItemStack( outputList.getCompoundTagAt( z ) ) );
 				}
 			}
 		}
@@ -166,15 +175,22 @@ public class PacketJEIRecipe extends AppEngPacket
 			{
 				ItemStack currentItem = craftMatrix.getStackInSlot( x );
 
+				if (x >= this.recipe.size()) {
+					currentItem = ItemStack.EMPTY;
+				}
+
 				// prepare slots
 				if( !currentItem.isEmpty() )
 				{
 					// already the correct item?
 					ItemStack newItem = this.canUseInSlot( x, currentItem );
 
-					if ( !cct.useRealItems() && this.recipe[x] != null ) {
-						if (this.recipe[x].length > 0 )
-						currentItem.setCount( recipe[x][0].getCount() );
+					if( !cct.useRealItems() && this.recipe.get( x ) != null )
+					{
+						if( this.recipe.get( x ).length > 0 )
+						{
+							currentItem.setCount( recipe.get( x )[0].getCount() );
+						}
 					}
 
 					// put away old item
@@ -193,12 +209,12 @@ public class PacketJEIRecipe extends AppEngPacket
 					}
 				}
 
-				if( currentItem.isEmpty() && this.recipe[x] != null )
+				if( currentItem.isEmpty() && recipe.size() > x && recipe.get( x ) != null )
 				{
 					// for each variant
-					for( int y = 0; y < this.recipe[x].length && currentItem.isEmpty(); y++ )
+					for( int y = 0; y < this.recipe.get( x ).length && currentItem.isEmpty(); y++ )
 					{
-						final IAEItemStack request = AEItemStack.fromItemStack( this.recipe[x][y] );
+						final IAEItemStack request = AEItemStack.fromItemStack( this.recipe.get( x )[y] );
 						if( request != null )
 						{
 							// try ae
@@ -247,7 +263,7 @@ public class PacketJEIRecipe extends AppEngPacket
 								{
 									if (!cct.useRealItems())
 									{
-										out.setStackSize( recipe[x][y].getCount() );
+										out.setStackSize( recipe.get( x )[y].getCount() );
 									}
 									currentItem = out.createItemStack();
 								}
@@ -260,20 +276,20 @@ public class PacketJEIRecipe extends AppEngPacket
 
 								if( cct.useRealItems() )
 								{
-									currentItem = ad.removeSimilarItems(1, this.recipe[x][y],FuzzyMode.IGNORE_ALL, null );
+									currentItem = ad.removeSimilarItems( 1, this.recipe.get( x )[y], FuzzyMode.IGNORE_ALL, null );
 								}
 								else
 								{
-									currentItem = ad.simulateSimilarRemove(recipe[x][y].getCount(), this.recipe[x][y],FuzzyMode.IGNORE_ALL, null );
+									currentItem = ad.simulateSimilarRemove( recipe.get( x )[y].getCount(), this.recipe.get( x )[y], FuzzyMode.IGNORE_ALL, null );
 								}
 							}
 						}
 					}
 					if (!cct.useRealItems())
 					{
-						if( currentItem.isEmpty() && this.recipe[x] != null )
+						if( currentItem.isEmpty() && recipe.size() > x && this.recipe.get( x ) != null )
 						{
-							currentItem = this.recipe[x][0].copy();
+							currentItem = this.recipe.get( x )[0].copy();
 						}
 					}
 				}
@@ -282,14 +298,19 @@ public class PacketJEIRecipe extends AppEngPacket
 
 			con.onCraftMatrixChanged( new WrapperInvItemHandler( craftMatrix ) );
 
-			if( this.output != null && con instanceof ContainerPatternTerm && !( (ContainerPatternTerm) con ).isCraftingMode() )
+			if( this.output != null && ( ( con instanceof ContainerPatternTerm && !( (ContainerPatternTerm) con ).isCraftingMode() ) || con instanceof ContainerExpandedProcessingPatternTerm ) )
 			{
 				IItemHandler outputSlots = cct.getInventoryByName( "output" );
-				for( int i = 0; i < this.output.length; ++i )
+
+				for( int i = 0; i < this.output.size(); ++i )
 				{
-					if( this.output[i] == null ) continue;
-					ItemHandlerUtil.setStackInSlot( outputSlots, i, this.output[i] );
+					if( this.output.get( i ) == null )
+					{
+						continue;
+					}
+					ItemHandlerUtil.setStackInSlot( outputSlots, i, this.output.get( i ) );
 				}
+
 			}
 		}
 	}
@@ -302,9 +323,9 @@ public class PacketJEIRecipe extends AppEngPacket
 	 */
 	private ItemStack canUseInSlot( int slot, ItemStack is )
 	{
-		if( this.recipe[slot] != null )
+		if( this.recipe.get( slot ) != null )
 		{
-			for( ItemStack option : this.recipe[slot] )
+			for( ItemStack option : this.recipe.get( slot ) )
 			{
 				if( ItemStack.areItemStacksEqual( is, option ) )
 				{

src/main/java/appeng/core/sync/packets/PacketValueConfig.java

@@ -24,6 +24,8 @@ import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
 
+import appeng.client.gui.implementations.GuiPartOreDictStorageBus;
+import appeng.container.implementations.*;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 
@@ -40,17 +42,6 @@ import appeng.api.util.IConfigManager;
 import appeng.api.util.IConfigurableObject;
 import appeng.client.gui.implementations.GuiCraftingCPU;
 import appeng.container.AEBaseContainer;
-import appeng.container.implementations.ContainerCellWorkbench;
-import appeng.container.implementations.ContainerCraftConfirm;
-import appeng.container.implementations.ContainerCraftingCPU;
-import appeng.container.implementations.ContainerCraftingStatus;
-import appeng.container.implementations.ContainerLevelEmitter;
-import appeng.container.implementations.ContainerNetworkTool;
-import appeng.container.implementations.ContainerPatternTerm;
-import appeng.container.implementations.ContainerPriority;
-import appeng.container.implementations.ContainerQuartzKnife;
-import appeng.container.implementations.ContainerSecurityStation;
-import appeng.container.implementations.ContainerStorageBus;
 import appeng.core.sync.AppEngPacket;
 import appeng.core.sync.network.INetworkInfo;
 import appeng.fluids.container.ContainerFluidLevelEmitter;
@@ -166,58 +157,109 @@ public class PacketValueConfig extends AppEngPacket
 			final ContainerFluidLevelEmitter lvc = (ContainerFluidLevelEmitter) c;
 			lvc.setLevel( Long.parseLong( this.Value ), player );
 		}
-		else if( this.Name.startsWith( "PatternTerminal." ) && c instanceof ContainerPatternTerm )
+		else if( this.Name.startsWith( "PatternTerminal." ) )
 		{
-			final ContainerPatternTerm cpt = (ContainerPatternTerm) c;
-			if( this.Name.equals( "PatternTerminal.CraftMode" ) )
+			if( c instanceof ContainerPatternTerm )
 			{
-				cpt.getPatternTerminal().setCraftingRecipe( this.Value.equals( "1" ) );
-			}
-			else if( this.Name.equals( "PatternTerminal.Encode" ) )
-			{
-				if (this.Value.equals( "2" )) {
-					cpt.encodeAndMoveToInventory();
-				}
-				else
+				final ContainerPatternTerm cpt = (ContainerPatternTerm) c;
+				if( this.Name.equals( "PatternTerminal.CraftMode" ) )
 				{
-					cpt.encode();
+					cpt.getPatternTerminal().setCraftingRecipe( this.Value.equals( "1" ) );
+				}
+				else if( this.Name.equals( "PatternTerminal.Encode" ) )
+				{
+					if( this.Value.equals( "2" ) )
+					{
+						cpt.encodeAndMoveToInventory();
+					}
+					else
+					{
+						cpt.encode();
+					}
+				}
+				else if( this.Name.equals( "PatternTerminal.Clear" ) )
+				{
+					cpt.clear();
+				}
+				else if( this.Name.equals( "PatternTerminal.MultiplyByTwo" ) )
+				{
+					cpt.multiply( 2 );
+				}
+				else if( this.Name.equals( "PatternTerminal.MultiplyByThree" ) )
+				{
+					cpt.multiply( 3 );
+				}
+				else if( this.Name.equals( "PatternTerminal.DivideByTwo" ) )
+				{
+					cpt.divide( 2 );
+				}
+				else if( this.Name.equals( "PatternTerminal.DivideByThree" ) )
+				{
+					cpt.divide( 3 );
+				}
+				else if( this.Name.equals( "PatternTerminal.IncreaseByOne" ) )
+				{
+					cpt.increase( 1 );
+				}
+				else if( this.Name.equals( "PatternTerminal.DecreaseByOne" ) )
+				{
+					cpt.decrease( 1 );
+				}
+				else if( this.Name.equals( "PatternTerminal.MaximizeCount" ) )
+				{
+					cpt.maximizeCount();
+				}
+				else if( this.Name.equals( "PatternTerminal.Substitute" ) )
+				{
+					cpt.getPatternTerminal().setSubstitution( this.Value.equals( "1" ) );
 				}
 			}
-			else if( this.Name.equals( "PatternTerminal.Clear" ) )
+			else if( c instanceof ContainerExpandedProcessingPatternTerm )
 			{
-				cpt.clear();
-			}
-			else if( this.Name.equals( "PatternTerminal.MultiplyByTwo" ) )
-			{
-				cpt.multiply(2);
-			}
-			else if( this.Name.equals( "PatternTerminal.MultiplyByThree" ) )
-			{
-				cpt.multiply(3);
-			}
-			else if( this.Name.equals( "PatternTerminal.DivideByTwo" ) )
-			{
-				cpt.divide(2);
-			}
-			else if( this.Name.equals( "PatternTerminal.DivideByThree" ) )
-			{
-				cpt.divide(3);
-			}
-			else if( this.Name.equals( "PatternTerminal.IncreaseByOne" ) )
-			{
-				cpt.increase(1);
-			}
-			else if( this.Name.equals( "PatternTerminal.DecreaseByOne" ) )
-			{
-				cpt.decrease(1);
-			}
-			else if( this.Name.equals( "PatternTerminal.MaximizeCount" ) )
-			{
-				cpt.maximizeCount();
-			}
-			else if( this.Name.equals( "PatternTerminal.Substitute" ) )
-			{
-				cpt.getPatternTerminal().setSubstitution( this.Value.equals( "1" ) );
+				final ContainerExpandedProcessingPatternTerm cept = (ContainerExpandedProcessingPatternTerm) c;
+				if( this.Name.equals( "PatternTerminal.Encode" ) )
+				{
+					if( this.Value.equals( "2" ) )
+					{
+						cept.encodeAndMoveToInventory();
+					}
+					else
+					{
+						cept.encode();
+					}
+				}
+				else if( this.Name.equals( "PatternTerminal.Clear" ) )
+				{
+					cept.clear();
+				}
+				else if( this.Name.equals( "PatternTerminal.MultiplyByTwo" ) )
+				{
+					cept.multiply( 2 );
+				}
+				else if( this.Name.equals( "PatternTerminal.MultiplyByThree" ) )
+				{
+					cept.multiply( 3 );
+				}
+				else if( this.Name.equals( "PatternTerminal.DivideByTwo" ) )
+				{
+					cept.divide( 2 );
+				}
+				else if( this.Name.equals( "PatternTerminal.DivideByThree" ) )
+				{
+					cept.divide( 3 );
+				}
+				else if( this.Name.equals( "PatternTerminal.IncreaseByOne" ) )
+				{
+					cept.increase( 1 );
+				}
+				else if( this.Name.equals( "PatternTerminal.DecreaseByOne" ) )
+				{
+					cept.decrease( 1 );
+				}
+				else if( this.Name.equals( "PatternTerminal.MaximizeCount" ) )
+				{
+					cept.maximizeCount();
+				}
 			}
 		}
 		else if( this.Name.startsWith( "StorageBus." ) )
@@ -234,6 +276,10 @@ public class PacketValueConfig extends AppEngPacket
 					{
 						( (ContainerFluidStorageBus) c ).partition();
 					}
+					else if( c instanceof ContainerPartOreDictStorageBus )
+					{
+						( (ContainerPartOreDictStorageBus) c ).partition();
+					}
 				}
 				else if( this.Value.equals( "Clear" ) )
 				{
@@ -248,6 +294,20 @@ public class PacketValueConfig extends AppEngPacket
 				}
 			}
 		}
+		else if( this.Name.startsWith( "OreDictStorageBus" ) )
+		{
+			if( c instanceof ContainerPartOreDictStorageBus )
+			{
+				if( this.Name.equals( "OreDictStorageBus.save" ) )
+				{
+					( (ContainerPartOreDictStorageBus) c ).saveOreMatch( this.Value );
+				}
+				if( this.Name.equals( "OreDictStorageBus.getRegex" ) )
+				{
+					( (ContainerPartOreDictStorageBus) c ).sendRegex();
+				}
+			}
+		}
 		else if( this.Name.startsWith( "CellWorkbench." ) && c instanceof ContainerCellWorkbench )
 		{
 			final ContainerCellWorkbench ccw = (ContainerCellWorkbench) c;
@@ -324,6 +384,14 @@ public class PacketValueConfig extends AppEngPacket
 				( (GuiCraftingCPU) gs ).clearItems();
 			}
 		}
+		else if( this.Name.equals( "OreDictStorageBus.sendRegex" ) )
+		{
+			final GuiScreen gs = Minecraft.getMinecraft().currentScreen;
+			if( gs instanceof GuiPartOreDictStorageBus )
+			{
+				( (GuiPartOreDictStorageBus) gs ).fillRegex( this.Value );
+			}
+		}
 		else if( c instanceof IConfigurableObject )
 		{
 			final IConfigManager cm = ( (IConfigurableObject) c ).getConfigManager();

src/main/java/appeng/crafting/CraftingTreeNode.java

@@ -25,6 +25,7 @@ import java.util.List;
 
 import com.google.common.collect.Lists;
 
+import net.minecraft.util.text.TextComponentString;
 import net.minecraft.world.World;
 
 import appeng.api.AEApi;
@@ -123,18 +124,43 @@ public class CraftingTreeNode
 		final List<IAEItemStack> thingsUsed = new ArrayList<>();
 
 		this.what.setStackSize( l );
-		if( this.getSlot() >= 0 && this.parent != null && this.parent.details.isCraftable() )
+		IAEItemStack available = inv.extractItems( this.what, Actionable.MODULATE, src );
+
+		if( available != null )
+		{
+			if( !this.exhausted )
+			{
+				final IAEItemStack is = this.job.checkUse( available );
+
+				if( is != null )
+				{
+					thingsUsed.add( is.copy() );
+					this.used.add( is );
+				}
+			}
+
+			this.bytes += available.getStackSize();
+			l -= available.getStackSize();
+
+			if( l == 0 )
+			{
+				return available;
+			}
+		}
+
+		else if( this.getSlot() >= 0 && this.parent != null && this.parent.details.isCraftable() )
 		{
 			final Collection<IAEItemStack> itemList;
 			final IItemList<IAEItemStack> inventoryList = inv.getItemList();
 
 			if( this.parent.details.canSubstitute() )
 			{
-				final List<IAEItemStack> substitutes = this.parent.details.getSubstituteInputs(this.slot);
-				itemList = new ArrayList<>(substitutes.size());
+				final List<IAEItemStack> substitutes = this.parent.details.getSubstituteInputs( this.slot );
+				itemList = new ArrayList<>( substitutes.size() );
 
-				for (IAEItemStack stack : substitutes) {
-					itemList.addAll(inventoryList.findFuzzy(stack, FuzzyMode.IGNORE_ALL));
+				for( IAEItemStack stack : substitutes )
+				{
+					itemList.addAll( inventoryList.findFuzzy( stack, FuzzyMode.IGNORE_ALL ) );
 				}
 			}
 			else
@@ -156,7 +182,7 @@ public class CraftingTreeNode
 					fuzz = fuzz.copy();
 					fuzz.setStackSize( l );
 
-					final IAEItemStack available = inv.extractItems( fuzz, Actionable.MODULATE, src );
+					available = inv.extractItems( fuzz, Actionable.MODULATE, src );
 
 					if( available != null )
 					{
@@ -182,32 +208,6 @@ public class CraftingTreeNode
 				}
 			}
 		}
-		else
-		{
-			final IAEItemStack available = inv.extractItems( this.what, Actionable.MODULATE, src );
-
-			if( available != null )
-			{
-				if( !this.exhausted )
-				{
-					final IAEItemStack is = this.job.checkUse( available );
-
-					if( is != null )
-					{
-						thingsUsed.add( is.copy() );
-						this.used.add( is );
-					}
-				}
-
-				this.bytes += available.getStackSize();
-				l -= available.getStackSize();
-
-				if( l == 0 )
-				{
-					return available;
-				}
-			}
-		}
 
 		if( this.canEmit )
 		{
@@ -226,7 +226,7 @@ public class CraftingTreeNode
 		{
 			final CraftingTreeProcess pro = this.nodes.get( 0 );
 
-			while( pro.possible && l > 0 )
+			while ( pro.possible && l > 0 )
 			{
 				final IAEItemStack madeWhat = pro.getAmountCrafted( this.what );
 
@@ -234,7 +234,7 @@ public class CraftingTreeNode
 
 				madeWhat.setStackSize( l );
 
-				final IAEItemStack available = inv.extractItems( madeWhat, Actionable.MODULATE, src );
+				available = inv.extractItems( madeWhat, Actionable.MODULATE, src );
 
 				if( available != null )
 				{
@@ -258,13 +258,13 @@ public class CraftingTreeNode
 			{
 				try
 				{
-					while( pro.possible && l > 0 )
+					while ( pro.possible && l > 0 )
 					{
 						final MECraftingInventory subInv = new MECraftingInventory( inv, true, true, true );
 						pro.request( subInv, 1, src );
 
 						this.what.setStackSize( l );
-						final IAEItemStack available = subInv.extractItems( this.what, Actionable.MODULATE, src );
+						available = subInv.extractItems( this.what, Actionable.MODULATE, src );
 
 						if( available != null )
 						{
@@ -321,7 +321,7 @@ public class CraftingTreeNode
 		}
 		// missing = 0;
 
-		job.addBytes( 8 + this.bytes );
+		job.addBytes( this.bytes );
 
 		for( final CraftingTreeProcess pro : this.nodes )
 		{
@@ -358,6 +358,10 @@ public class CraftingTreeNode
 
 			if( ex == null || ex.getStackSize() != i.getStackSize() )
 			{
+				if( src.player().isPresent() )
+				{
+					src.player().get().sendStatusMessage( new TextComponentString( "System reported " + i.getStackSize() + " " + i.getDefinition().getItem().getItemStackDisplayName( i.getDefinition() ) + " available but could not extract anything" ), false );
+				}
 				throw new CraftBranchFailure( i, i.getStackSize() );
 			}
 

src/main/java/appeng/crafting/CraftingTreeProcess.java

@@ -241,7 +241,6 @@ public class CraftingTreeProcess
 			o.setStackSize( o.getStackSize() * i );
 			inv.injectItems( o, Actionable.MODULATE, src );
 		}
-
 		this.crafts += i;
 	}
 
@@ -253,7 +252,7 @@ public class CraftingTreeProcess
 			pro.dive( job );
 		}
 
-		job.addBytes( 8 + this.crafts + this.bytes );
+		job.addBytes( this.crafts + 8 + this.bytes );
 	}
 
 	IAEItemStack getAmountCrafted( IAEItemStack what2 )

src/main/java/appeng/crafting/MECraftingInventory.java

@@ -312,9 +312,13 @@ public class MECraftingInventory implements IMEInventory<IAEItemStack>
 					if( src.player().isPresent() )
 					{
 						if( result == null )
-							src.player().get().sendStatusMessage( new TextComponentString( "System reported " + extra.getStackSize() + " " + extra.getDefinition().getDisplayName() + " available but could not extract anything" ), false );
+						{
+							src.player().get().sendStatusMessage( new TextComponentString( "System reported " + extra.getStackSize() + " " + extra.getDefinition().getItem().getItemStackDisplayName( extra.getDefinition() ) + " available but could not extract anything" ), false );
+						}
 						else
-							src.player().get().sendStatusMessage( new TextComponentString( "System reported " + extra.getStackSize() + " " + extra.getDefinition().getDisplayName() + " available but could only extract " + result.getStackSize() ), false );
+						{
+							src.player().get().sendStatusMessage( new TextComponentString( "System reported " + extra.getStackSize() + " " + extra.getDefinition().getItem().getItemStackDisplayName( extra.getDefinition() ) + " available but could only extract " + result.getStackSize() ), false );
+						}
 					}
 					failed = true;
 					if( !src.player().isPresent() ) break;

src/main/java/appeng/fluids/helper/DualityFluidInterface.java

@@ -93,7 +93,7 @@ public class DualityFluidInterface implements IGridTickable, IStorageMonitorable
 
 	private final MEMonitorPassThrough<IAEItemStack> items = new MEMonitorPassThrough<>( new NullInventory<IAEItemStack>(), AEApi.instance().storage().getStorageChannel( IItemStorageChannel.class ) );
 	private final MEMonitorPassThrough<IAEFluidStack> fluids = new MEMonitorPassThrough<>( new NullInventory<IAEFluidStack>(), AEApi.instance().storage().getStorageChannel( IFluidStorageChannel.class ) );
-	private boolean resetConfigCache;
+	private boolean resetConfigCache = true;
 	private IMEMonitor<IAEFluidStack> configCachedHandler;
 
 	public DualityFluidInterface( final AENetworkProxy networkProxy, final IFluidInterfaceHost ih )
@@ -117,15 +117,7 @@ public class DualityFluidInterface implements IGridTickable, IStorageMonitorable
 
 	public IUpgradeableHost getHost()
 	{
-		if( this.iHost instanceof IUpgradeableHost )
-		{
-			return this.iHost;
-		}
-		if( this.iHost instanceof IUpgradeableHost )
-		{
-			return this.iHost;
-		}
-		return null;
+		return this.iHost;
 	}
 
 	@Override
@@ -386,7 +378,7 @@ public class DualityFluidInterface implements IGridTickable, IStorageMonitorable
 				{
 					changed = true;
 				}
-				else
+				else if( this.gridProxy.getStorage().getInventory( AEApi.instance().storage().getStorageChannel( IFluidStorageChannel.class ) ).getStorageList().findPrecise( work ) != null )
 				{
 					final IAEFluidStack acquired = Platform.poweredExtraction( src, dest, work, this.interfaceRequestSource );
 					if( acquired != null )
@@ -458,6 +450,7 @@ public class DualityFluidInterface implements IGridTickable, IStorageMonitorable
 			if( cfg != hasConfig )
 			{
 				resetConfigCache = true;
+				this.notifyNeighbors();
 			}
 		}
 		else if( inventory == this.tanks )

src/main/java/appeng/fluids/parts/PartFluidFormationPlane.java

@@ -178,8 +178,9 @@ public class PartFluidFormationPlane extends PartAbstractFormationPlane<IAEFluid
 		this.stateChanged();
 	}
 
+	@Override
 	@MENetworkEventSubscribe
-	public void updateChannels( final MENetworkChannelsChanged changedChannels )
+	public void chanRender( final MENetworkChannelsChanged changedChannels )
 	{
 		this.stateChanged();
 	}

src/main/java/appeng/fluids/parts/PartFluidInterface.java

@@ -90,14 +90,16 @@ public class PartFluidInterface extends PartBasicState implements IGridTickable,
 		return this.duality;
 	}
 
+	@Override
 	@MENetworkEventSubscribe
-	public void stateChange( final MENetworkChannelsChanged c )
+	public void chanRender( final MENetworkChannelsChanged c )
 	{
 		this.duality.notifyNeighbors();
 	}
 
+	@Override
 	@MENetworkEventSubscribe
-	public void stateChange( final MENetworkPowerStatusChange c )
+	public void powerRender( final MENetworkPowerStatusChange c )
 	{
 		this.duality.notifyNeighbors();
 	}

src/main/java/appeng/fluids/parts/PartFluidLevelEmitter.java

@@ -4,7 +4,6 @@ package appeng.fluids.parts;
 
 import java.util.Random;
 
-import appeng.api.networking.events.MENetworkChannelChanged;
 import appeng.api.storage.data.IItemList;
 import appeng.fluids.helper.IConfigurableFluidInventory;
 import appeng.me.cache.NetworkMonitor;
@@ -116,9 +115,9 @@ public class PartFluidLevelEmitter extends PartUpgradeable implements IStackWatc
 	@Override
 	public void onStackChange( IItemList<?> o, IAEStack<?> fullStack, IAEStack<?> diffStack, IActionSource src, IStorageChannel<?> chan )
 	{
-		if( chan == AEApi.instance().storage().getStorageChannel( IFluidStorageChannel.class ) && diffStack.equals( this.config.getFluidInSlot( 0 ) ) )
+		if( chan == AEApi.instance().storage().getStorageChannel( IFluidStorageChannel.class ) && fullStack.equals( this.config.getFluidInSlot( 0 ) ) )
 		{
-			this.lastReportedValue += diffStack.getStackSize();
+			this.lastReportedValue = fullStack.getStackSize();
 			this.updateState();
 		}
 	}
@@ -129,8 +128,9 @@ public class PartFluidLevelEmitter extends PartUpgradeable implements IStackWatc
 		this.configureWatchers();
 	}
 
+	@Override
 	@MENetworkEventSubscribe
-	public void powerStatusChange( final MENetworkPowerStatusChange powerEvent )
+	public void powerRender( final MENetworkPowerStatusChange powerEvent )
 	{
 		if (this.getProxy().isActive())
 		{
@@ -139,8 +139,9 @@ public class PartFluidLevelEmitter extends PartUpgradeable implements IStackWatc
 		this.updateState();
 	}
 
+	@Override
 	@MENetworkEventSubscribe
-	public void channelChanged( final MENetworkChannelsChanged c )
+	public void chanRender( final MENetworkChannelsChanged c )
 	{
 		if (this.getProxy().isActive())
 		{

src/main/java/appeng/helpers/DualityInterface.java

@@ -185,6 +185,7 @@ public class DualityInterface implements IGridTickable, IStorageMonitorable, IIn
 			if( cfg != hasConfig )
 			{
 				resetConfigCache = true;
+				this.notifyNeighbors();
 			}
 		}
 		else if( inv == this.patterns && ( !removed.isEmpty() || !added.isEmpty() ) )
@@ -856,19 +857,26 @@ public class DualityInterface implements IGridTickable, IStorageMonitorable, IIn
 					throw new GridAccessException();
 				}
 
-				final IAEItemStack acquired = Platform.poweredExtraction( src, this.destination, itemStack, this.interfaceRequestSource );
-				if( acquired != null )
+				IAEItemStack storedStack = this.gridProxy.getStorage().getInventory( AEApi.instance().storage().getStorageChannel( IItemStorageChannel.class ) ).getStorageList().findPrecise( itemStack );
+				if( storedStack != null )
 				{
-					changed = true;
-					final ItemStack issue = adaptor.addItems( acquired.createItemStack() );
-					if( !issue.isEmpty() )
+					if( storedStack.getStackSize() > 0 )
 					{
-						throw new IllegalStateException( "bad attempt at managing inventory. ( addItems )" );
+						final IAEItemStack acquired = Platform.poweredExtraction( src, this.destination, itemStack, this.interfaceRequestSource );
+						if( acquired != null )
+						{
+							changed = true;
+							final ItemStack issue = adaptor.addItems( acquired.createItemStack() );
+							if( !issue.isEmpty() )
+							{
+								throw new IllegalStateException( "bad attempt at managing inventory. ( addItems )" );
+							}
+						}
+					}
+					else if( storedStack.isCraftable() )
+					{
+						changed = this.handleCrafting( x, adaptor, itemStack ) || changed;
 					}
-				}
-				else
-				{
-					changed = this.handleCrafting( x, adaptor, itemStack ) || changed;
 				}
 			}
 			else if( itemStack.getStackSize() < 0 )

src/main/java/appeng/helpers/PatternHelper.java

@@ -20,7 +20,6 @@ package appeng.helpers;
 
 
 import java.util.*;
-import java.util.stream.Collectors;
 
 import net.minecraft.inventory.InventoryCrafting;
 import net.minecraft.item.Item;
@@ -38,9 +37,6 @@ import appeng.api.networking.crafting.ICraftingPatternDetails;
 import appeng.api.storage.channels.IItemStorageChannel;
 import appeng.api.storage.data.IAEItemStack;
 import appeng.container.ContainerNull;
-import appeng.core.AEConfig;
-import appeng.core.AELog;
-import appeng.core.features.AEFeature;
 import appeng.util.Platform;
 import appeng.util.item.AEItemStack;
 import net.minecraftforge.common.crafting.IShapedRecipe;
@@ -50,13 +46,16 @@ public class PatternHelper implements ICraftingPatternDetails, Comparable<Patter
 {
 
 	private static final int CRAFTING_GRID_DIMENSION = 3;
-	private static final int ALL_INPUT_LIMIT = CRAFTING_GRID_DIMENSION * CRAFTING_GRID_DIMENSION;
+	private static final int CRAFTING_INPUT_LIMIT = CRAFTING_GRID_DIMENSION * CRAFTING_GRID_DIMENSION;
+	public static final int PROCESSING_INPUT_HEIGHT = 4;
+	public static final int PROCESSING_INPUT_WIDTH = 4;
+	public static final int PROCESSING_INPUT_LIMIT = PROCESSING_INPUT_HEIGHT * PROCESSING_INPUT_WIDTH;
 	private static final int CRAFTING_OUTPUT_LIMIT = 1;
-	private static final int PROCESSING_OUTPUT_LIMIT = 3;
+	public static final int PROCESSING_OUTPUT_LIMIT = 6;
 
 	private final ItemStack patternItem;
-	private final InventoryCrafting crafting = new InventoryCrafting( new ContainerNull(), 3, 3 );
-	private final InventoryCrafting testFrame = new InventoryCrafting( new ContainerNull(), 3, 3 );
+	private final InventoryCrafting crafting;
+	private final InventoryCrafting testFrame;
 	private final ItemStack correctOutput;
 	private final IRecipe standardRecipe;
 	private final IAEItemStack[] condensedInputs;
@@ -84,6 +83,9 @@ public class PatternHelper implements ICraftingPatternDetails, Comparable<Patter
 		final NBTTagList outTag = encodedValue.getTagList( "out", 10 );
 		this.isCrafting = encodedValue.getBoolean( "crafting" );
 
+		crafting = new InventoryCrafting( new ContainerNull(), isCrafting ? 3 : 4, isCrafting ? 3 : 4 );
+		testFrame = new InventoryCrafting( new ContainerNull(), isCrafting ? 3 : 4, isCrafting ? 3 : 4 );
+
 		this.canSubstitute = this.isCrafting && encodedValue.getBoolean( "substitute" );
 		this.patternItem = is;
 		this.pattern = AEItemStack.fromItemStack( is );
@@ -149,9 +151,9 @@ public class PatternHelper implements ICraftingPatternDetails, Comparable<Patter
 		}
 		final int outputLength = out.size();
 
-		this.inputs = in.toArray(new IAEItemStack[ALL_INPUT_LIMIT]);
-		this.outputs = out.toArray(new IAEItemStack[outputLength]);
-		this.substituteInputs = new HashMap<>(ALL_INPUT_LIMIT);
+		this.inputs = in.toArray( new IAEItemStack[isCrafting ? CRAFTING_INPUT_LIMIT : PROCESSING_INPUT_LIMIT] );
+		this.outputs = out.toArray( new IAEItemStack[outputLength] );
+		this.substituteInputs = new HashMap<>( CRAFTING_INPUT_LIMIT );
 
 		final Map<IAEItemStack, IAEItemStack> tmpOutputs = new HashMap<>();
 

src/main/java/appeng/integration/modules/jei/JEIPlugin.java

@@ -26,6 +26,7 @@ import java.util.List;
 import java.util.Optional;
 
 import appeng.client.gui.AEGuiHandler;
+import appeng.container.implementations.ContainerExpandedProcessingPatternTerm;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Lists;
 
@@ -90,16 +91,13 @@ public class JEIPlugin implements IModPlugin
 		this.registerDescriptions( definitions, registry );
 
 		// Allow recipe transfer from JEI to crafting and pattern terminal
-		registry.getRecipeTransferRegistry()
-				.addRecipeTransferHandler( new RecipeTransferHandler<>( ContainerCraftingTerm.class ),
-						VanillaRecipeCategoryUid.CRAFTING );
-		registry.getRecipeTransferRegistry()
-				.addRecipeTransferHandler( new RecipeTransferHandler<>( ContainerPatternTerm.class ),
-						Constants.UNIVERSAL_RECIPE_TRANSFER_UID );
+		registry.getRecipeTransferRegistry().addRecipeTransferHandler( new RecipeTransferHandler<>( ContainerCraftingTerm.class ), VanillaRecipeCategoryUid.CRAFTING );
+		registry.getRecipeTransferRegistry().addRecipeTransferHandler( new RecipeTransferHandler<>( ContainerPatternTerm.class ), Constants.UNIVERSAL_RECIPE_TRANSFER_UID );
+		registry.getRecipeTransferRegistry().addRecipeTransferHandler( new RecipeTransferHandler<>( ContainerExpandedProcessingPatternTerm.class ), Constants.UNIVERSAL_RECIPE_TRANSFER_UID );
 
 		aeGuiHandler = new AEGuiHandler();
-		registry.addAdvancedGuiHandlers(aeGuiHandler);
-		registry.addGhostIngredientHandler( aeGuiHandler.getGuiContainerClass(), aeGuiHandler);
+		registry.addAdvancedGuiHandlers( aeGuiHandler );
+		registry.addGhostIngredientHandler( aeGuiHandler.getGuiContainerClass(), aeGuiHandler );
 	}
 
 	private void registerDescriptions( IDefinitions definitions, IModRegistry registry )

src/main/java/appeng/integration/modules/theoneprobe/TheOneProbeText.java

@@ -35,6 +35,8 @@ public enum TheOneProbeText
 	P2P_UNLINKED,
 	P2P_INPUT_ONE_OUTPUT,
 	P2P_INPUT_MANY_OUTPUTS,
+	P2P_OUTPUT_ONE_INPUT,
+	P2P_OUTPUT_MANY_INPUTS,
 	P2P_OUTPUT,
 	P2P_FREQUENCY,
 

src/main/java/appeng/integration/modules/theoneprobe/part/P2PStateInfoProvider.java

@@ -57,11 +57,11 @@ public class P2PStateInfoProvider implements IPartProbInfoProvider
 
 			// The default state
 			int state = STATE_UNLINKED;
-			int outputCount = 0;
+			int outputCount = getOutputCount( tunnel );
+			int inputCount = getInputCount( tunnel );
 
 			if( !tunnel.isOutput() )
 			{
-				outputCount = getOutputCount( tunnel );
 				if( outputCount > 0 )
 				{
 					// Only set it to INPUT if we know there are any outputs
@@ -70,8 +70,7 @@ public class P2PStateInfoProvider implements IPartProbInfoProvider
 			}
 			else
 			{
-				final PartP2PTunnel input = tunnel.getInput();
-				if( input != null )
+				if( inputCount > 0 )
 				{
 					state = STATE_OUTPUT;
 				}
@@ -83,7 +82,7 @@ public class P2PStateInfoProvider implements IPartProbInfoProvider
 					probeInfo.text( TheOneProbeText.P2P_UNLINKED.getLocal() );
 					break;
 				case STATE_OUTPUT:
-					probeInfo.text( TheOneProbeText.P2P_OUTPUT.getLocal() );
+					probeInfo.text( getInputText( inputCount ) );
 					break;
 				case STATE_INPUT:
 					probeInfo.text( getOutputText( outputCount ) );
@@ -110,6 +109,19 @@ public class P2PStateInfoProvider implements IPartProbInfoProvider
 		}
 	}
 
+	private static int getInputCount( PartP2PTunnel tunnel )
+	{
+		try
+		{
+			return Iterators.size( tunnel.getInputs().iterator() );
+		}
+		catch( GridAccessException e )
+		{
+			// Well... unknown size it is!
+			return 0;
+		}
+	}
+
 	private static String getOutputText( int outputs )
 	{
 		if( outputs <= 1 )
@@ -122,4 +134,16 @@ public class P2PStateInfoProvider implements IPartProbInfoProvider
 		}
 	}
 
+	private static String getInputText( int inputs )
+	{
+		if( inputs <= 1 )
+		{
+			return TheOneProbeText.P2P_OUTPUT_ONE_INPUT.getLocal();
+		}
+		else
+		{
+			return String.format( TheOneProbeText.P2P_OUTPUT_MANY_INPUTS.getLocal(), inputs );
+		}
+	}
+
 }

src/main/java/appeng/integration/modules/waila/part/P2PStateWailaDataProvider.java

@@ -21,6 +21,7 @@ package appeng.integration.modules.waila.part;
 
 import java.util.List;
 
+import appeng.integration.modules.theoneprobe.TheOneProbeText;
 import com.google.common.collect.Iterators;
 
 import net.minecraft.entity.player.EntityPlayerMP;
@@ -117,11 +118,11 @@ public final class P2PStateWailaDataProvider extends BasePartWailaDataProvider
 
 			// The default state
 			int state = STATE_UNLINKED;
-			int outputCount = 0;
+			int outputCount = getOutputCount( tunnel );
+			int inputCount = getInputCount( tunnel );
 
 			if( !tunnel.isOutput() )
 			{
-				outputCount = getOutputCount( tunnel );
 				if( outputCount > 0 )
 				{
 					// Only set it to INPUT if we know there are any outputs
@@ -130,8 +131,7 @@ public final class P2PStateWailaDataProvider extends BasePartWailaDataProvider
 			}
 			else
 			{
-				PartP2PTunnel input = tunnel.getInput();
-				if( input != null )
+				if( inputCount > 0 )
 				{
 					state = STATE_OUTPUT;
 				}
@@ -160,15 +160,40 @@ public final class P2PStateWailaDataProvider extends BasePartWailaDataProvider
 		}
 	}
 
+	private static int getInputCount( PartP2PTunnel tunnel )
+	{
+		try
+		{
+			return Iterators.size( tunnel.getInputs().iterator() );
+		}
+		catch( GridAccessException e )
+		{
+			// Well... unknown size it is!
+			return 0;
+		}
+	}
+
 	private static String getOutputText( int outputs )
 	{
 		if( outputs <= 1 )
 		{
-			return WailaText.P2PInputOneOutput.getLocal();
+			return WailaText.P2P_INPUT_ONE_OUTPUT.getLocal();
 		}
 		else
 		{
-			return String.format( WailaText.P2PInputManyOutputs.getLocal(), outputs );
+			return String.format( WailaText.P2P_INPUT_MANY_OUTPUTS.getLocal(), outputs );
+		}
+	}
+
+	private static String getInputText( int inputs )
+	{
+		if( inputs <= 1 )
+		{
+			return WailaText.P2P_OUTPUT_ONE_INPUT.getLocal();
+		}
+		else
+		{
+			return String.format( WailaText.P2P_OUTPUT_MANY_INPUTS.getLocal(), inputs );
 		}
 	}
 

src/main/java/appeng/items/contents/PortableCellViewer.java

@@ -19,6 +19,7 @@
 package appeng.items.contents;
 
 
+import appeng.api.networking.security.IActionSource;
 import net.minecraft.item.ItemStack;
 import net.minecraft.nbt.NBTTagCompound;
 
@@ -42,6 +43,8 @@ import appeng.me.helpers.MEMonitorHandler;
 import appeng.util.ConfigManager;
 import appeng.util.Platform;
 
+import java.util.Collections;
+
 
 public class PortableCellViewer extends MEMonitorHandler<IAEItemStack> implements IPortableCell, IInventorySlotAware
 {
@@ -83,6 +86,34 @@ public class PortableCellViewer extends MEMonitorHandler<IAEItemStack> implement
 		return usePowerMultiplier.divide( this.ips.extractAEPower( this.target, amt, Actionable.MODULATE ) );
 	}
 
+	@Override
+	public IAEItemStack injectItems( IAEItemStack input, Actionable mode, IActionSource src )
+	{
+		final long size = input.getStackSize();
+
+		final IAEItemStack injected = super.injectItems( input, mode, src );
+
+		if( mode == Actionable.MODULATE && ( injected == null || injected.getStackSize() != size ) )
+		{
+			this.notifyListenersOfChange( Collections.singletonList( input.copy().setStackSize( input.getStackSize() - ( injected == null ? 0 : injected.getStackSize() ) ) ), null);
+		}
+
+		return injected;
+	}
+
+	@Override
+	public IAEItemStack extractItems( IAEItemStack request, Actionable mode, IActionSource src )
+	{
+		final IAEItemStack extractable = super.extractItems( request, mode, src );
+
+		if( mode == Actionable.MODULATE && extractable != null )
+		{
+			this.notifyListenersOfChange( Collections.singletonList( request.copy().setStackSize( -extractable.getStackSize() ) ), null );
+		}
+
+		return extractable;
+	}
+
 	@Override
 	public <T extends IAEStack<T>> IMEMonitor<T> getInventory( IStorageChannel<T> channel )
 	{

src/main/java/appeng/items/parts/PartType.java

@@ -28,6 +28,8 @@ import java.util.List;
 import java.util.Set;
 import java.util.stream.Collectors;
 
+import appeng.parts.misc.*;
+import appeng.parts.reporting.*;
 import com.google.common.collect.ImmutableList;
 
 import net.minecraft.client.renderer.block.model.ModelResourceLocation;
@@ -57,11 +59,6 @@ import appeng.parts.automation.PartFormationPlane;
 import appeng.parts.automation.PartIdentityAnnihilationPlane;
 import appeng.parts.automation.PartImportBus;
 import appeng.parts.automation.PartLevelEmitter;
-import appeng.parts.misc.PartCableAnchor;
-import appeng.parts.misc.PartInterface;
-import appeng.parts.misc.PartInvertedToggleBus;
-import appeng.parts.misc.PartStorageBus;
-import appeng.parts.misc.PartToggleBus;
 import appeng.parts.networking.PartCableCovered;
 import appeng.parts.networking.PartCableGlass;
 import appeng.parts.networking.PartCableSmart;
@@ -75,15 +72,6 @@ import appeng.parts.p2p.PartP2PItems;
 import appeng.parts.p2p.PartP2PLight;
 import appeng.parts.p2p.PartP2PRedstone;
 import appeng.parts.p2p.PartP2PTunnelME;
-import appeng.parts.reporting.PartConversionMonitor;
-import appeng.parts.reporting.PartCraftingTerminal;
-import appeng.parts.reporting.PartDarkPanel;
-import appeng.parts.reporting.PartInterfaceTerminal;
-import appeng.parts.reporting.PartPanel;
-import appeng.parts.reporting.PartPatternTerminal;
-import appeng.parts.reporting.PartSemiDarkPanel;
-import appeng.parts.reporting.PartStorageMonitor;
-import appeng.parts.reporting.PartTerminal;
 import appeng.util.Platform;
 
 
@@ -193,14 +181,13 @@ public enum PartType
 
 	MONITOR( 160, "monitor", EnumSet.of( AEFeature.PANELS ), EnumSet.noneOf( IntegrationType.class ), PartPanel.class, "itemIlluminatedPanel" ),
 
-	SEMI_DARK_MONITOR( 180, "semi_dark_monitor", EnumSet.of( AEFeature.PANELS ), EnumSet
-			.noneOf( IntegrationType.class ), PartSemiDarkPanel.class, "itemIlluminatedPanel" ),
+	SEMI_DARK_MONITOR( 180, "semi_dark_monitor", EnumSet.of( AEFeature.PANELS ), EnumSet.noneOf( IntegrationType.class ), PartSemiDarkPanel.class, "itemIlluminatedPanel" ),
 
 	DARK_MONITOR( 200, "dark_monitor", EnumSet.of( AEFeature.PANELS ), EnumSet.noneOf( IntegrationType.class ), PartDarkPanel.class, "itemIlluminatedPanel" ),
 
 	STORAGE_BUS( 220, "storage_bus", EnumSet.of( AEFeature.STORAGE_BUS ), EnumSet.noneOf( IntegrationType.class ), PartStorageBus.class ),
-	FLUID_STORAGE_BUS( 221, "fluid_storage_bus", EnumSet.of( AEFeature.FLUID_STORAGE_BUS ), EnumSet
-			.noneOf( IntegrationType.class ), PartFluidStorageBus.class ),
+	FLUID_STORAGE_BUS( 221, "fluid_storage_bus", EnumSet.of( AEFeature.FLUID_STORAGE_BUS ), EnumSet.noneOf( IntegrationType.class ), PartFluidStorageBus.class ),
+	OREDICT_STORAGE_BUS( 222, "oredict_storage_bus", EnumSet.of( AEFeature.STORAGE_BUS ), EnumSet.noneOf( IntegrationType.class ), PartOreDicStorageBus.class ),
 
 	IMPORT_BUS( 240, "import_bus", EnumSet.of( AEFeature.IMPORT_BUS ), EnumSet.noneOf( IntegrationType.class ), PartImportBus.class ),
 
@@ -211,94 +198,83 @@ public enum PartType
 	FLUID_EXPORT_BUS( 261, "fluid_export_bus", EnumSet.of( AEFeature.FLUID_EXPORT_BUS ), EnumSet.noneOf( IntegrationType.class ), PartFluidExportBus.class ),
 
 	LEVEL_EMITTER( 280, "level_emitter", EnumSet.of( AEFeature.LEVEL_EMITTER ), EnumSet.noneOf( IntegrationType.class ), PartLevelEmitter.class ),
-	FLUID_LEVEL_EMITTER( 281, "fluid_level_emitter", EnumSet.of( AEFeature.FLUID_LEVEL_EMITTER ), EnumSet
-			.noneOf( IntegrationType.class ), PartFluidLevelEmitter.class ),
+	FLUID_LEVEL_EMITTER( 281, "fluid_level_emitter", EnumSet.of( AEFeature.FLUID_LEVEL_EMITTER ), EnumSet.noneOf( IntegrationType.class ), PartFluidLevelEmitter.class ),
 
-	ANNIHILATION_PLANE( 300, "annihilation_plane", EnumSet.of( AEFeature.ANNIHILATION_PLANE ), EnumSet
-			.noneOf( IntegrationType.class ), PartAnnihilationPlane.class ),
+	ANNIHILATION_PLANE( 300, "annihilation_plane", EnumSet.of( AEFeature.ANNIHILATION_PLANE ), EnumSet.noneOf( IntegrationType.class ), PartAnnihilationPlane.class ),
 
-	IDENTITY_ANNIHILATION_PLANE( 301, "identity_annihilation_plane", EnumSet.of( AEFeature.ANNIHILATION_PLANE, AEFeature.IDENTITY_ANNIHILATION_PLANE ), EnumSet
-			.noneOf( IntegrationType.class ), PartIdentityAnnihilationPlane.class ),
+	IDENTITY_ANNIHILATION_PLANE( 301, "identity_annihilation_plane", EnumSet.of( AEFeature.ANNIHILATION_PLANE, AEFeature.IDENTITY_ANNIHILATION_PLANE ), EnumSet.noneOf( IntegrationType.class ), PartIdentityAnnihilationPlane.class ),
 
-	FLUID_ANNIHILATION_PLANE( 302, "fluid_annihilation_plane", EnumSet.of( AEFeature.FLUID_ANNIHILATION_PLANE ), EnumSet
-			.noneOf( IntegrationType.class ), PartFluidAnnihilationPlane.class ),
+	FLUID_ANNIHILATION_PLANE( 302, "fluid_annihilation_plane", EnumSet.of( AEFeature.FLUID_ANNIHILATION_PLANE ), EnumSet.noneOf( IntegrationType.class ), PartFluidAnnihilationPlane.class ),
 
 	FORMATION_PLANE( 320, "formation_plane", EnumSet.of( AEFeature.FORMATION_PLANE ), EnumSet.noneOf( IntegrationType.class ), PartFormationPlane.class ),
 
-	FLUID_FORMATION_PLANE( 321, "fluid_formation_plane", EnumSet.of( AEFeature.FLUID_FORMATION_PLANE ), EnumSet
-			.noneOf( IntegrationType.class ), PartFluidFormationPlane.class ),
+	FLUID_FORMATION_PLANE( 321, "fluid_formation_plane", EnumSet.of( AEFeature.FLUID_FORMATION_PLANE ), EnumSet.noneOf( IntegrationType.class ), PartFluidFormationPlane.class ),
 
 	PATTERN_TERMINAL( 340, "pattern_terminal", EnumSet.of( AEFeature.PATTERNS ), EnumSet.noneOf( IntegrationType.class ), PartPatternTerminal.class ),
 
-	CRAFTING_TERMINAL( 360, "crafting_terminal", EnumSet.of( AEFeature.CRAFTING_TERMINAL ), EnumSet
-			.noneOf( IntegrationType.class ), PartCraftingTerminal.class ),
+	EXPANDED_PROCESSING_PATTERN_TERMINAL( 341, "expanded_processing_pattern_terminal", EnumSet.of( AEFeature.PATTERNS ), EnumSet.noneOf( IntegrationType.class ), PartExpandedProcessingPatternTerminal.class ),
+
+	CRAFTING_TERMINAL( 360, "crafting_terminal", EnumSet.of( AEFeature.CRAFTING_TERMINAL ), EnumSet.noneOf( IntegrationType.class ), PartCraftingTerminal.class ),
 
 	TERMINAL( 380, "terminal", EnumSet.of( AEFeature.TERMINAL ), EnumSet.noneOf( IntegrationType.class ), PartTerminal.class ),
 
 	STORAGE_MONITOR( 400, "storage_monitor", EnumSet.of( AEFeature.STORAGE_MONITOR ), EnumSet.noneOf( IntegrationType.class ), PartStorageMonitor.class ),
 
-	CONVERSION_MONITOR( 420, "conversion_monitor", EnumSet.of( AEFeature.PART_CONVERSION_MONITOR ), EnumSet
-			.noneOf( IntegrationType.class ), PartConversionMonitor.class ),
+	CONVERSION_MONITOR( 420, "conversion_monitor", EnumSet.of( AEFeature.PART_CONVERSION_MONITOR ), EnumSet.noneOf( IntegrationType.class ), PartConversionMonitor.class ),
 
 	INTERFACE( 440, "interface", EnumSet.of( AEFeature.INTERFACE ), EnumSet.noneOf( IntegrationType.class ), PartInterface.class ),
 	FLUID_INTERFACE( 441, "fluid_interface", EnumSet.of( AEFeature.FLUID_INTERFACE ), EnumSet.noneOf( IntegrationType.class ), PartFluidInterface.class ),
 
-	P2P_TUNNEL_ME( 460, "p2p_tunnel_me", EnumSet.of( AEFeature.P2P_TUNNEL, AEFeature.P2P_TUNNEL_ME ), EnumSet
-			.noneOf( IntegrationType.class ), PartP2PTunnelME.class, GuiText.METunnel )
-	{
-		@Override
-		String getUnlocalizedName()
-		{
-			return "p2p_tunnel";
-		}
-	},
+	P2P_TUNNEL_ME( 460, "p2p_tunnel_me", EnumSet.of( AEFeature.P2P_TUNNEL, AEFeature.P2P_TUNNEL_ME ), EnumSet.noneOf( IntegrationType.class ), PartP2PTunnelME.class, GuiText.METunnel )
+			{
+				@Override
+				String getUnlocalizedName()
+				{
+					return "p2p_tunnel";
+				}
+			},
 
-	P2P_TUNNEL_REDSTONE( 461, "p2p_tunnel_redstone", EnumSet.of( AEFeature.P2P_TUNNEL, AEFeature.P2P_TUNNEL_REDSTONE ), EnumSet
-			.noneOf( IntegrationType.class ), PartP2PRedstone.class, GuiText.RedstoneTunnel )
-	{
-		@Override
-		String getUnlocalizedName()
-		{
-			return "p2p_tunnel";
-		}
-	},
+	P2P_TUNNEL_REDSTONE( 461, "p2p_tunnel_redstone", EnumSet.of( AEFeature.P2P_TUNNEL, AEFeature.P2P_TUNNEL_REDSTONE ), EnumSet.noneOf( IntegrationType.class ), PartP2PRedstone.class, GuiText.RedstoneTunnel )
+			{
+				@Override
+				String getUnlocalizedName()
+				{
+					return "p2p_tunnel";
+				}
+			},
 
-	P2P_TUNNEL_ITEMS( 462, "p2p_tunnel_items", EnumSet.of( AEFeature.P2P_TUNNEL, AEFeature.P2P_TUNNEL_ITEMS ), EnumSet
-			.noneOf( IntegrationType.class ), PartP2PItems.class, GuiText.ItemTunnel )
-	{
-		@Override
-		String getUnlocalizedName()
-		{
-			return "p2p_tunnel";
-		}
-	},
+	P2P_TUNNEL_ITEMS( 462, "p2p_tunnel_items", EnumSet.of( AEFeature.P2P_TUNNEL, AEFeature.P2P_TUNNEL_ITEMS ), EnumSet.noneOf( IntegrationType.class ), PartP2PItems.class, GuiText.ItemTunnel )
+			{
+				@Override
+				String getUnlocalizedName()
+				{
+					return "p2p_tunnel";
+				}
+			},
 
-	P2P_TUNNEL_FLUIDS( 463, "p2p_tunnel_fluids", EnumSet.of( AEFeature.P2P_TUNNEL, AEFeature.P2P_TUNNEL_FLUIDS ), EnumSet
-			.noneOf( IntegrationType.class ), PartP2PFluids.class, GuiText.FluidTunnel )
-	{
-		@Override
-		String getUnlocalizedName()
-		{
-			return "p2p_tunnel";
-		}
-	},
+	P2P_TUNNEL_FLUIDS( 463, "p2p_tunnel_fluids", EnumSet.of( AEFeature.P2P_TUNNEL, AEFeature.P2P_TUNNEL_FLUIDS ), EnumSet.noneOf( IntegrationType.class ), PartP2PFluids.class, GuiText.FluidTunnel )
+			{
+				@Override
+				String getUnlocalizedName()
+				{
+					return "p2p_tunnel";
+				}
+			},
 
-	P2P_TUNNEL_IC2( 465, "p2p_tunnel_ic2", EnumSet.of( AEFeature.P2P_TUNNEL, AEFeature.P2P_TUNNEL_EU ), EnumSet
-			.of( IntegrationType.IC2 ), PartP2PIC2Power.class, GuiText.EUTunnel )
-	{
-		@Override
-		String getUnlocalizedName()
-		{
-			return "p2p_tunnel";
-		}
-	},
+	P2P_TUNNEL_IC2( 465, "p2p_tunnel_ic2", EnumSet.of( AEFeature.P2P_TUNNEL, AEFeature.P2P_TUNNEL_EU ), EnumSet.of( IntegrationType.IC2 ), PartP2PIC2Power.class, GuiText.EUTunnel )
+			{
+				@Override
+				String getUnlocalizedName()
+				{
+					return "p2p_tunnel";
+				}
+			},
 
-	P2P_TUNNEL_LIGHT( 467, "p2p_tunnel_light", EnumSet.of( AEFeature.P2P_TUNNEL, AEFeature.P2P_TUNNEL_LIGHT ), EnumSet
-			.noneOf( IntegrationType.class ), PartP2PLight.class, GuiText.LightTunnel )
-	{
-		@Override
-		String getUnlocalizedName()
-		{
+	P2P_TUNNEL_LIGHT( 467, "p2p_tunnel_light", EnumSet.of( AEFeature.P2P_TUNNEL, AEFeature.P2P_TUNNEL_LIGHT ), EnumSet.noneOf( IntegrationType.class ), PartP2PLight.class, GuiText.LightTunnel )
+			{
+				@Override
+				String getUnlocalizedName()
+				{
 			return "p2p_tunnel";
 		}
 	},

src/main/java/appeng/items/tools/powered/ToolMatterCannon.java

@@ -403,7 +403,7 @@ public class ToolMatterCannon extends AEBasePoweredItem implements IStorageCell<
 					}
 					else if( pos.entityHit.attackEntityFrom( dmgSrc, dmg ) )
 					{
-						hasDestroyed = true;
+						hasDestroyed = pos.entityHit.isEntityAlive();
 					}
 				}
 				else if( pos.typeOfHit == RayTraceResult.Type.BLOCK )

src/main/java/appeng/me/GridNode.java

@@ -59,6 +59,7 @@ import appeng.me.cache.CraftingGridCache;
 import appeng.me.pathfinding.IPathItem;
 import appeng.util.IWorldCallable;
 import appeng.util.ReadOnlyCollection;
+import net.minecraftforge.common.util.Constants;
 
 
 public class GridNode implements IGridNode, IPathItem
@@ -333,7 +334,11 @@ public class GridNode implements IGridNode, IPathItem
 	@Override
 	public void loadFromNBT( final String name, final NBTTagCompound nodeData )
 	{
-		if( this.myGrid == null )
+		if( this.myGrid != null )
+		{
+			throw new IllegalStateException( "Loading data after part of a grid, this is invalid." );
+		}
+		if( nodeData.hasKey( name, 10 ) )
 		{
 			final NBTTagCompound node = nodeData.getCompoundTag( name );
 			this.playerID = node.getInteger( "p" );
@@ -345,7 +350,9 @@ public class GridNode implements IGridNode, IPathItem
 		}
 		else
 		{
-			throw new IllegalStateException( "Loading data after part of a grid, this is invalid." );
+			this.playerID = -1; // Unknown owner
+			setLastSecurityKey( -1 );
+			setGridStorage( null );
 		}
 	}
 

src/main/java/appeng/me/cache/EnergyGridCache.java

@@ -65,11 +65,9 @@ public class EnergyGridCache implements IEnergyGrid
 {
 
 	private static final double MAX_BUFFER_STORAGE = 800;
-	private static final Comparator<IEnergyGridProvider> COMPARATOR_HIGHEST_AMOUNT_STORED_FIRST = ( o1, o2 ) -> Double.compare( o2.getProviderStoredEnergy(),
-			o1.getProviderStoredEnergy() );
+	private static final Comparator<IEnergyGridProvider> COMPARATOR_HIGHEST_AMOUNT_STORED_FIRST = ( o1, o2 ) -> Double.compare( o2.getProviderStoredEnergy(), o1.getProviderStoredEnergy() );
 
-	private static final Comparator<IEnergyGridProvider> COMPARATOR_LOWEST_PERCENTAGE_FIRST = ( o1, o2 ) ->
-	{
+	private static final Comparator<IEnergyGridProvider> COMPARATOR_LOWEST_PERCENTAGE_FIRST = ( o1, o2 ) -> {
 		final double percent1 = ( o1.getProviderStoredEnergy() + 1 ) / ( o1.getProviderMaxEnergy() + 1 );
 		final double percent2 = ( o2.getProviderStoredEnergy() + 1 ) / ( o2.getProviderMaxEnergy() + 1 );
 
@@ -163,34 +161,33 @@ public class EnergyGridCache implements IEnergyGrid
 	{
 		if( ev.storage.isAEPublicPowerStorage() )
 		{
-			switch ( ev.type )
+			if( ev.type == PowerEventType.PROVIDE_POWER )
 			{
-				case PROVIDE_POWER:
-					if( ev.storage.getPowerFlow() != AccessRestriction.WRITE )
+				if( ev.storage.getPowerFlow() != AccessRestriction.WRITE )
+				{
+					if( !ongoingExtractOperation )
 					{
-						if( !ongoingExtractOperation )
-						{
-							addProvider( ev.storage );
-						}
-						else
-						{
-							this.providersToAdd.add( ev.storage );
-						}
+						addProvider( ev.storage );
 					}
-					break;
-				case REQUEST_POWER:
-					if( ev.storage.getPowerFlow() != AccessRestriction.READ )
+					else
 					{
-						if( !ongoingInjectOperation )
-						{
-							addRequester( ev.storage );
-						}
-						else
-						{
-							this.requesterToAdd.add( ev.storage );
-						}
+						this.providersToAdd.add( ev.storage );
 					}
-					break;
+				}
+			}
+			else if( ev.type == PowerEventType.REQUEST_POWER )
+			{
+				if( ev.storage.getPowerFlow() != AccessRestriction.READ )
+				{
+					if( !ongoingInjectOperation )
+					{
+						addRequester( ev.storage );
+					}
+					else
+					{
+						this.requesterToAdd.add( ev.storage );
+					}
+				}
 			}
 		}
 		else
@@ -337,6 +334,8 @@ public class EnergyGridCache implements IEnergyGrid
 
 		this.providers.addAll( providersToAdd );
 		providersToAdd.clear();
+		providers.removeIf( providerToRemove::contains );
+		this.providerToRemove.clear();
 
 		final Iterator<IAEPowerStorage> it = this.providers.iterator();
 
@@ -347,18 +346,24 @@ public class EnergyGridCache implements IEnergyGrid
 			while ( extractedPower < amt && it.hasNext() )
 			{
 				final IAEPowerStorage node = it.next();
-
-				if( node == localStorage && mode == Actionable.MODULATE )
+				if( node != null )
 				{
-					ls = true;
-					continue;
+					if( node == localStorage && mode == Actionable.MODULATE )
+					{
+						ls = true;
+						continue;
+					}
+
+					final double req = amt - extractedPower;
+					final double newPower = node.extractAEPower( req, mode, PowerMultiplier.ONE );
+					extractedPower += newPower;
+
+					if( newPower < req && mode == Actionable.MODULATE )
+					{
+						it.remove();
+					}
 				}
-
-				final double req = amt - extractedPower;
-				final double newPower = node.extractAEPower( req, mode, PowerMultiplier.ONE );
-				extractedPower += newPower;
-
-				if( newPower < req && mode == Actionable.MODULATE )
+				else
 				{
 					it.remove();
 				}
@@ -366,24 +371,20 @@ public class EnergyGridCache implements IEnergyGrid
 		} finally
 		{
 			ongoingExtractOperation = false;
-		}
-
-		if( ls && extractedPower < amt )
-		{
-			final double req = amt - extractedPower;
-			final double newPower = localStorage.extractAEPower( req, mode, PowerMultiplier.ONE );
-
-			extractedPower += newPower;
-
-			if( newPower < req )
+			if( ls && extractedPower < amt )
 			{
-				providers.remove( localStorage );
+				final double req = amt - extractedPower;
+				final double newPower = localStorage.extractAEPower( req, mode, PowerMultiplier.ONE );
+
+				extractedPower += newPower;
+
+				if( newPower < req )
+				{
+					providers.remove( localStorage );
+				}
 			}
 		}
 
-		providers.removeIf( p -> providerToRemove.contains( p ) );
-		this.providerToRemove.clear();
-
 		final double result = Math.min( extractedPower, amt );
 
 		if( mode == Actionable.MODULATE )
@@ -407,6 +408,8 @@ public class EnergyGridCache implements IEnergyGrid
 
 		this.requesters.addAll( requesterToAdd );
 		requesterToAdd.clear();
+		requesters.removeIf( requesterToRemove::contains );
+		this.requesterToRemove.clear();
 
 		final Iterator<IAEPowerStorage> it = this.requesters.iterator();
 
@@ -417,9 +420,16 @@ public class EnergyGridCache implements IEnergyGrid
 			{
 				final IAEPowerStorage node = it.next();
 
-				amt = node.injectAEPower( amt, mode );
+				if( node != null )
+				{
+					amt = node.injectAEPower( amt, mode );
 
-				if( amt > 0 && mode == Actionable.MODULATE )
+					if( amt > 0 && mode == Actionable.MODULATE )
+					{
+						it.remove();
+					}
+				}
+				else
 				{
 					it.remove();
 				}
@@ -429,9 +439,6 @@ public class EnergyGridCache implements IEnergyGrid
 			ongoingInjectOperation = false;
 		}
 
-		requesters.removeIf( r -> requesterToRemove.contains( r ) );
-		this.requesterToRemove.clear();
-
 		final double overflow = Math.max( 0.0, amt );
 
 		if( mode == Actionable.MODULATE )
@@ -613,28 +620,28 @@ public class EnergyGridCache implements IEnergyGrid
 		}
 	}
 
-	private void addRequester(IAEPowerStorage requester) {
-		Preconditions.checkState(!ongoingInjectOperation,
-				"Cannot modify energy requesters while energy is being injected.");
-		this.requesters.add(requester);
+	private void addRequester( IAEPowerStorage requester )
+	{
+		Preconditions.checkState( !ongoingInjectOperation, "Cannot modify energy requesters while energy is being injected." );
+		this.requesters.add( requester );
 	}
 
-	private void removeRequester(IAEPowerStorage requester) {
-		Preconditions.checkState(!ongoingInjectOperation,
-				"Cannot modify energy requesters while energy is being injected.");
-		this.requesters.remove(requester);
+	private void removeRequester( IAEPowerStorage requester )
+	{
+		Preconditions.checkState( !ongoingInjectOperation, "Cannot modify energy requesters while energy is being injected." );
+		this.requesters.remove( requester );
 	}
 
-	private void addProvider(IAEPowerStorage provider) {
-		Preconditions.checkState(!ongoingExtractOperation,
-				"Cannot modify energy providers while energy is being extracted.");
-		this.providers.add(provider);
+	private void addProvider( IAEPowerStorage provider )
+	{
+		Preconditions.checkState( !ongoingExtractOperation, "Cannot modify energy providers while energy is being extracted." );
+		this.providers.add( provider );
 	}
 
-	private void removeProvider(IAEPowerStorage provider) {
-		Preconditions.checkState(!ongoingExtractOperation,
-				"Cannot modify energy providers while energy is being extracted.");
-		this.providers.remove(provider);
+	private void removeProvider( IAEPowerStorage provider )
+	{
+		Preconditions.checkState( !ongoingExtractOperation, "Cannot modify energy providers while energy is being extracted." );
+		this.providers.remove( provider );
 	}
 
 

src/main/java/appeng/me/cache/GridStorageCache.java

@@ -94,7 +94,7 @@ public class GridStorageCache implements IStorageGrid
 
 			this.removeCellProvider( cc, tracker );
 			this.inactiveCellProviders.remove( cc );
-			this.getGrid().postEvent( new MENetworkCellArrayUpdate() );
+			cellUpdate( null );
 
 			tracker.applyChanges();
 		}
@@ -109,9 +109,6 @@ public class GridStorageCache implements IStorageGrid
 				this.watchers.remove( node );
 			}
 		}
-
-		this.storageMonitors.forEach( ( channel, monitor ) -> monitor.forceUpdate() );
-
 	}
 
 	@Override
@@ -122,7 +119,7 @@ public class GridStorageCache implements IStorageGrid
 			final ICellContainer cc = (ICellContainer) machine;
 			this.inactiveCellProviders.add( cc );
 
-			this.getGrid().postEvent( new MENetworkCellArrayUpdate() );
+			cellUpdate( null );
 
 			if( node.isActive() )
 			{
@@ -140,9 +137,6 @@ public class GridStorageCache implements IStorageGrid
 			this.watchers.put( node, iw );
 			swh.updateWatcher( iw );
 		}
-
-		this.storageMonitors.forEach( ( channel, monitor ) -> monitor.forceUpdate() );
-
 	}
 
 	@Override
@@ -183,8 +177,7 @@ public class GridStorageCache implements IStorageGrid
 
 			final IActionSource actionSrc = cc instanceof IActionHost ? new MachineSource( (IActionHost) cc ) : new BaseActionSource();
 
-			this.storageMonitors.forEach( ( channel, monitor ) ->
-			{
+			this.storageMonitors.forEach( ( channel, monitor ) -> {
 				for( final IMEInventoryHandler<?> h : cc.getCellArray( channel ) )
 				{
 					tracker.postChanges( channel, 1, h, actionSrc );
@@ -253,8 +246,9 @@ public class GridStorageCache implements IStorageGrid
 				this.removeCellProvider( cc, tracker );
 			}
 		}
-
 		tracker.applyChanges();
+
+		this.storageMonitors.forEach( ( channel, monitor ) -> monitor.setForceUpdate( true ) );
 	}
 
 	private <T extends IAEStack<T>, C extends IStorageChannel<T>> void postChangesToNetwork( final C chan, final int upOrDown, final IItemList<T> availableItems, final IActionSource src )
@@ -334,7 +328,10 @@ public class GridStorageCache implements IStorageGrid
 
 		public void applyChanges()
 		{
-			GridStorageCache.this.postChangesToNetwork( this.channel, this.up_or_down, this.list, this.src );
+			if( !this.list.isEmpty() )
+			{
+				GridStorageCache.this.postChangesToNetwork( this.channel, this.up_or_down, this.list, this.src );
+			}
 		}
 	}
 

src/main/java/appeng/me/cache/NetworkMonitor.java

@@ -19,7 +19,6 @@
 package appeng.me.cache;
 
 
-import javax.annotation.Nonnegative;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 import appeng.api.AEApi;
@@ -36,20 +35,21 @@ import appeng.api.storage.channels.IItemStorageChannel;
 import appeng.api.storage.data.IAEStack;
 import appeng.api.storage.data.IItemList;
 import appeng.me.storage.ItemWatcher;
-import com.google.common.collect.Queues;
 import it.unimi.dsi.fastutil.objects.Object2ObjectMap;
 import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
 
-import java.util.Collection;
-import java.util.Deque;
-import java.util.Iterator;
+import java.util.*;
 import java.util.Map.Entry;
 
 
 public class NetworkMonitor<T extends IAEStack<T>> implements IMEMonitor<T>
 {
 	@Nonnull
-	private static final Deque<NetworkMonitor<?>> GLOBAL_DEPTH = Queues.newArrayDeque();
+	private static final HashMap<IActionSource, LinkedList<NetworkMonitor<?>>> src2MonitorsMap = new HashMap<>();
+	private static final Set<IActionSource> nestingSources = new HashSet<>();
+
+	protected boolean wasNested = false;
+	protected boolean isNested = false;
 
 	@Nonnull
 	private final GridStorageCache myGridCache;
@@ -61,11 +61,9 @@ public class NetworkMonitor<T extends IAEStack<T>> implements IMEMonitor<T>
 	private final Object2ObjectMap<IMEMonitorHandlerReceiver<T>, Object> listeners;
 
 	private boolean sendEvent = false;
-	private boolean forceUpdate = false;
-	@Nonnegative
-	private int localDepthSemaphore = 0;
 	private long gridItemCount;
 	private long gridFluidCount;
+	public boolean forceUpdate;
 
 	public NetworkMonitor( final GridStorageCache cache, final IStorageChannel<T> chan )
 	{
@@ -125,10 +123,6 @@ public class NetworkMonitor<T extends IAEStack<T>> implements IMEMonitor<T>
 
 	public long getGridCurrentCount()
 	{
-		if( forceUpdate )
-		{
-			getStorageList();
-		}
 		if( myChannel == AEApi.instance().storage().getStorageChannel( IItemStorageChannel.class ) )
 		{
 			return gridItemCount;
@@ -140,7 +134,7 @@ public class NetworkMonitor<T extends IAEStack<T>> implements IMEMonitor<T>
 		return 0;
 	}
 
-	public void incGridCurrentCount(long count)
+	public void incGridCurrentCount( long count )
 	{
 		if( myChannel == AEApi.instance().storage().getStorageChannel( IItemStorageChannel.class ) )
 		{
@@ -156,26 +150,6 @@ public class NetworkMonitor<T extends IAEStack<T>> implements IMEMonitor<T>
 	@Override
 	public IItemList<T> getStorageList()
 	{
-		if( forceUpdate )
-		{
-			forceUpdate = false;
-			this.cachedList.resetStatus();
-			this.getAvailableItems( this.cachedList );
-
-			long count = 0;
-			for (T stack : this.cachedList) {
-				count += stack.getStackSize();
-			}
-			if( myChannel == AEApi.instance().storage().getStorageChannel( IItemStorageChannel.class ) )
-			{
-				gridItemCount = count;
-			}
-			else if( myChannel == AEApi.instance().storage().getStorageChannel( IFluidStorageChannel.class ) )
-			{
-				gridFluidCount = count;
-			}
-		}
-
 		return this.cachedList;
 	}
 
@@ -222,6 +196,7 @@ public class NetworkMonitor<T extends IAEStack<T>> implements IMEMonitor<T>
 		{
 			final Entry<IMEMonitorHandlerReceiver<T>, Object> o = i.next();
 			final IMEMonitorHandlerReceiver<T> receiver = o.getKey();
+
 			if( receiver.isValid( o.getValue() ) )
 			{
 				receiver.postChange( this, diff, src );
@@ -251,27 +226,27 @@ public class NetworkMonitor<T extends IAEStack<T>> implements IMEMonitor<T>
 
 	protected void postChange( final boolean add, final Iterable<T> changes, final IActionSource src )
 	{
-		if( this.localDepthSemaphore > 0 || GLOBAL_DEPTH.contains( this ) )
+		src2MonitorsMap.putIfAbsent( src, new LinkedList<>() );
+		if( src2MonitorsMap.get( src ).contains( this ) )
 		{
+			nestingSources.add( src );
 			return;
 		}
-
-		this.localDepthSemaphore++;
-		GLOBAL_DEPTH.push( this );
+		src2MonitorsMap.get( src ).add( this );
 
 		this.sendEvent = true;
 
-		for( final T changed : changes )
+		for( final T change : changes )
 		{
-			T change = changed;
+			//T change = changed;
 			if( !add && change != null )
 			{
-				change = changed.copy();
+				//change = changed.copy();
 				change.setStackSize( -change.getStackSize() );
 			}
 
 			incGridCurrentCount( change.getStackSize() );
-			this.cachedList.add( change );
+			this.cachedList.addStorage( change );
 
 			if( this.myGridCache.getInterestManager().containsKey( change ) )
 			{
@@ -301,18 +276,73 @@ public class NetworkMonitor<T extends IAEStack<T>> implements IMEMonitor<T>
 
 		this.notifyListenersOfChange( changes, src );
 
-		final NetworkMonitor<?> last = GLOBAL_DEPTH.pop();
-		this.localDepthSemaphore--;
-
-		if( last != this )
+		if( src2MonitorsMap.get( src ).getFirst() == this )
 		{
-			throw new IllegalStateException( "Invalid Access to Networked Storage API detected." );
+			boolean nested = nestingSources.contains( src );
+			src2MonitorsMap.get( src ).forEach( networkMonitor -> networkMonitor.isNested = nested );
+
+			src2MonitorsMap.get( src ).forEach( networkMonitor -> {
+				if( networkMonitor.isNested != networkMonitor.wasNested )
+				{
+					networkMonitor.wasNested = networkMonitor.isNested;
+					networkMonitor.setForceUpdate( true );
+				}
+			} );
+			src2MonitorsMap.remove( src );
+			nestingSources.remove( src );
 		}
 	}
 
+	public void setForceUpdate( boolean forceUpdate )
+	{
+		this.forceUpdate = forceUpdate;
+	}
+
 	void forceUpdate()
 	{
-		this.forceUpdate = true;
+		forceUpdate = false;
+		this.cachedList.resetStatus();
+		this.getAvailableItems( this.cachedList );
+
+		long count = 0;
+		for( T stack : this.cachedList )
+		{
+			count += stack.getStackSize();
+
+			if( this.myGridCache.getInterestManager().containsKey( stack ) )
+			{
+				final Collection<ItemWatcher> list = this.myGridCache.getInterestManager().get( stack );
+
+				if( !list.isEmpty() )
+				{
+					IAEStack<T> fullStack = this.getStorageList().findPrecise( stack );
+
+					if( fullStack == null )
+					{
+						fullStack = stack.copy();
+						fullStack.setStackSize( 0 );
+					}
+
+					this.myGridCache.getInterestManager().enableTransactions();
+
+					for ( final ItemWatcher iw : list )
+					{
+						iw.getHost().onStackChange( this.getStorageList(), fullStack, stack, null, this.getChannel() );
+					}
+
+					this.myGridCache.getInterestManager().disableTransactions();
+				}
+			}
+		}
+
+		if( myChannel == AEApi.instance().storage().getStorageChannel( IItemStorageChannel.class ) )
+		{
+			gridItemCount = count;
+		}
+		else if( myChannel == AEApi.instance().storage().getStorageChannel( IFluidStorageChannel.class ) )
+		{
+			gridFluidCount = count;
+		}
 
 		final Iterator<Entry<IMEMonitorHandlerReceiver<T>, Object>> i = this.getListeners();
 		while ( i.hasNext() )
@@ -333,11 +363,14 @@ public class NetworkMonitor<T extends IAEStack<T>> implements IMEMonitor<T>
 
 	void onTick()
 	{
+		if( forceUpdate )
+		{
+			forceUpdate();
+		}
 		if( this.sendEvent )
 		{
 			this.sendEvent = false;
 			this.myGridCache.getGrid().postEvent( new MENetworkStorageEvent( this, this.myChannel ) );
 		}
-
 	}
 }

src/main/java/appeng/me/cache/P2PCache.java

@@ -19,7 +19,7 @@
 package appeng.me.cache;
 
 
-import java.util.HashMap;
+import java.util.Collection;
 import java.util.Random;
 
 import com.google.common.collect.LinkedHashMultimap;
@@ -46,7 +46,7 @@ public class P2PCache implements IGridCache
 	private static final TunnelCollection<PartP2PTunnel> NULL_COLLECTION = new TunnelCollection<PartP2PTunnel>( null, null );
 
 	private final IGrid myGrid;
-	private final HashMap<Short, PartP2PTunnel> inputs = new HashMap<>();
+	private final Multimap<Short, PartP2PTunnel> inputs = LinkedHashMultimap.create();
 	private final Multimap<Short, PartP2PTunnel> outputs = LinkedHashMultimap.create();
 	private final Random frequencyGenerator;
 
@@ -110,10 +110,19 @@ public class P2PCache implements IGridCache
 			}
 			else
 			{
-				this.inputs.remove( t.getFrequency() );
+				this.inputs.remove( t.getFrequency(), t );
 			}
 
-			this.updateTunnel( t.getFrequency(), !t.isOutput(), false );
+			if( this.inputs.get( t.getFrequency() ).isEmpty() )
+			{
+				this.inputs.removeAll( t.getFrequency() );
+			}
+			if( this.outputs.get( t.getFrequency() ).isEmpty() )
+			{
+				this.outputs.removeAll( t.getFrequency() );
+			}
+
+			this.updateTunnel( t.getFrequency(), t.isOutput(), false );
 		}
 	}
 
@@ -142,7 +151,7 @@ public class P2PCache implements IGridCache
 				this.inputs.put( t.getFrequency(), t );
 			}
 
-			this.updateTunnel( t.getFrequency(), !t.isOutput(), false );
+			this.updateTunnel( t.getFrequency(), t.isOutput(), false );
 		}
 	}
 
@@ -164,6 +173,20 @@ public class P2PCache implements IGridCache
 
 	}
 
+	public void removeTunnel( final PartP2PTunnel t, short freq )
+	{
+		this.outputs.remove( freq, t );
+		this.inputs.remove( freq, t );
+		if( this.inputs.get( t.getFrequency() ).isEmpty() )
+		{
+			this.inputs.removeAll( t.getFrequency() );
+		}
+		if( this.outputs.get( t.getFrequency() ).isEmpty() )
+		{
+			this.outputs.removeAll( t.getFrequency() );
+		}
+	}
+
 	private void updateTunnel( final short freq, final boolean updateOutputs, final boolean configChange )
 	{
 		for( final PartP2PTunnel p : this.outputs.get( freq ) )
@@ -175,8 +198,7 @@ public class P2PCache implements IGridCache
 			p.onTunnelNetworkChange();
 		}
 
-		final PartP2PTunnel in = this.inputs.get( freq );
-		if( in != null )
+		for( final PartP2PTunnel in : this.inputs.get( freq ) )
 		{
 			if( configChange )
 			{
@@ -195,7 +217,7 @@ public class P2PCache implements IGridCache
 
 		if( this.inputs.containsValue( t ) )
 		{
-			this.inputs.remove( t.getFrequency() );
+			this.inputs.remove( t.getFrequency(), t );
 		}
 
 		t.setFrequency( newFrequency );
@@ -211,7 +233,6 @@ public class P2PCache implements IGridCache
 
 		// AELog.info( "update-" + (t.output ? "output: " : "input: ") + t.freq );
 		this.updateTunnel( t.getFrequency(), t.isOutput(), true );
-		this.updateTunnel( t.getFrequency(), !t.isOutput(), true );
 	}
 
 	public short newFrequency()
@@ -236,25 +257,43 @@ public class P2PCache implements IGridCache
 
 	public TunnelCollection<PartP2PTunnel> getOutputs( final short freq, final Class<? extends PartP2PTunnel> c )
 	{
-		final PartP2PTunnel in = this.inputs.get( freq );
+		Collection<PartP2PTunnel> in = this.inputs.get( freq );
 
 		if( in == null )
 		{
 			return NULL_COLLECTION;
 		}
 
-		final TunnelCollection<PartP2PTunnel> out = this.inputs.get( freq ).getCollection( this.outputs.get( freq ), c );
+		TunnelCollection<PartP2PTunnel> out;
+		for( PartP2PTunnel part : this.inputs.get( freq ) )
+		{
+			out = part.getCollection( this.outputs.get( freq ), c );
+			if( out != null )
+			{
+				return out;
+			}
+		}
+		return NULL_COLLECTION;
+	}
+
+	public TunnelCollection<PartP2PTunnel> getInputs( final short freq, final Class<? extends PartP2PTunnel> c )
+	{
+		Collection<PartP2PTunnel> out = this.outputs.get( freq );
 
 		if( out == null )
 		{
 			return NULL_COLLECTION;
 		}
 
-		return out;
-	}
-
-	public PartP2PTunnel getInput( final short freq )
-	{
-		return this.inputs.get( freq );
+		TunnelCollection<PartP2PTunnel> in;
+		for( PartP2PTunnel part : this.outputs.get( freq ) )
+		{
+			in = part.getCollection( this.inputs.get( freq ), c );
+			if( in != null )
+			{
+				return in;
+			}
+		}
+		return NULL_COLLECTION;
 	}
 }

src/main/java/appeng/me/cluster/implementations/CraftingCPUCluster.java

@@ -25,6 +25,7 @@ import java.util.stream.Collectors;
 
 import appeng.api.config.Upgrades;
 import appeng.helpers.DualityInterface;
+import appeng.helpers.PatternHelper;
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
 
@@ -742,24 +743,35 @@ public final class CraftingCPUCluster implements IAECluster, ICraftingCPU
 							{
 								continue;
 							}
+							if( details.isCraftable() )
+							{
+								ic = new InventoryCrafting( new ContainerNull(), 3, 3 );
+							}
+							else
+							{
+								ic = new InventoryCrafting( new ContainerNull(), PatternHelper.PROCESSING_INPUT_WIDTH, PatternHelper.PROCESSING_INPUT_HEIGHT );
+							}
 
-							ic = new InventoryCrafting( new ContainerNull(), 3, 3 );
 							boolean found = false;
 
-							for (int x = 0; x < input.length; x++) {
-								if (input[x] != null) {
+							for( int x = 0; x < input.length; x++ )
+							{
+								if( input[x] != null )
+								{
 									found = false;
 
-									if (details.isCraftable()) {
+									if( details.isCraftable() )
+									{
 										final Collection<IAEItemStack> itemList;
 
-										if (details.canSubstitute()) {
-											final List<IAEItemStack> substitutes = details.getSubstituteInputs(x);
-											itemList = new ArrayList<>(substitutes.size());
+										if( details.canSubstitute() )
+										{
+											final List<IAEItemStack> substitutes = details.getSubstituteInputs( x );
+											itemList = new ArrayList<>( substitutes.size() );
 
-											for (IAEItemStack stack : substitutes) {
-												itemList.addAll(this.inventory.getItemList().findFuzzy(stack,
-														FuzzyMode.IGNORE_ALL));
+											for( IAEItemStack stack : substitutes )
+											{
+												itemList.addAll( this.inventory.getItemList().findFuzzy( stack, FuzzyMode.IGNORE_ALL ) );
 											}
 										} else {
 											itemList = new ArrayList<>(1);

src/main/java/appeng/me/helpers/GenericInterestManager.java

@@ -23,11 +23,10 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 
-import appeng.api.config.FuzzyMode;
-import appeng.api.storage.data.IAEStack;
-import appeng.util.item.AEItemStack;
 import com.google.common.collect.Multimap;
 
+import appeng.api.storage.data.IAEStack;
+
 
 public class GenericInterestManager<T>
 {
@@ -102,30 +101,12 @@ public class GenericInterestManager<T>
 
 	public boolean containsKey( final IAEStack stack )
 	{
-		if( stack.isItem() && ( ( AEItemStack ) stack ).getItem().isDamageable() )
-		{
-			return this.container.keySet().stream().filter( s -> s.isItem() )
-					.anyMatch( s -> s.fuzzyComparison( stack, FuzzyMode.IGNORE_ALL ) );
-		}
 		return this.container.containsKey( stack );
 	}
 
 	public Collection<T> get( final IAEStack stack )
 	{
-		Collection<T> watchers = new ArrayList<>();
-		if( stack.isItem() && ( ( AEItemStack ) stack ).getItem().isDamageable() )
-		{
-			this.container.keySet().stream().filter( s -> s.isItem() )
-					.filter( k -> k.fuzzyComparison( stack, FuzzyMode.IGNORE_ALL ) )
-					.forEach( key ->
-							watchers.addAll( this.container.get( key ) )
-					);
-		}
-		else
-		{
-			return this.container.get( stack );
-		}
-		return watchers;
+		return this.container.get( stack );
 	}
 
 	private class SavedTransactions
@@ -142,4 +123,4 @@ public class GenericInterestManager<T>
 			this.iw = watcher;
 		}
 	}
-}
+}

src/main/java/appeng/me/helpers/MEMonitorHandler.java

@@ -28,8 +28,6 @@ import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map.Entry;
 
-import com.google.common.collect.ImmutableList;
-
 import appeng.api.config.AccessRestriction;
 import appeng.api.config.Actionable;
 import appeng.api.networking.security.IActionSource;
@@ -85,11 +83,7 @@ public class MEMonitorHandler<T extends IAEStack<T>> implements IMEMonitor<T>
 	@Override
 	public T injectItems( final T input, final Actionable mode, final IActionSource src )
 	{
-		if( mode == Actionable.SIMULATE )
-		{
-			return this.getHandler().injectItems( input, mode, src );
-		}
-		return this.monitorDifference( input.copy(), this.getHandler().injectItems( input, mode, src ), false, src );
+		return this.getHandler().injectItems( input, mode, src );
 	}
 
 	protected IMEInventoryHandler<T> getHandler()
@@ -97,28 +91,7 @@ public class MEMonitorHandler<T extends IAEStack<T>> implements IMEMonitor<T>
 		return this.internalHandler;
 	}
 
-	private T monitorDifference( final T original, final T leftOvers, final boolean extraction, final IActionSource src )
-	{
-		final T diff = original.copy();
-
-		if( extraction )
-		{
-			diff.setStackSize( leftOvers == null ? 0 : -leftOvers.getStackSize() );
-		}
-		else if( leftOvers != null )
-		{
-			diff.decStackSize( leftOvers.getStackSize() );
-		}
-
-		if( diff.getStackSize() != 0 )
-		{
-			this.postChangesToListeners( ImmutableList.of( diff ), src );
-		}
-
-		return leftOvers;
-	}
-
-	protected void postChangesToListeners( final Iterable<T> changes, final IActionSource src )
+	public void postChangesToListeners( final Iterable<T> changes, final IActionSource src )
 	{
 		this.notifyListenersOfChange( changes, src );
 	}
@@ -150,11 +123,7 @@ public class MEMonitorHandler<T extends IAEStack<T>> implements IMEMonitor<T>
 	@Override
 	public T extractItems( final T request, final Actionable mode, final IActionSource src )
 	{
-		if( mode == Actionable.SIMULATE )
-		{
-			return this.getHandler().extractItems( request, mode, src );
-		}
-		return this.monitorDifference( request.copy(), this.getHandler().extractItems( request, mode, src ), true, src );
+		return this.getHandler().extractItems( request, mode, src );
 	}
 
 	@Override

src/main/java/appeng/me/helpers/MachineSource.java

@@ -19,6 +19,7 @@
 package appeng.me.helpers;
 
 
+import java.util.Objects;
 import java.util.Optional;
 
 import net.minecraft.entity.player.EntityPlayer;
@@ -55,4 +56,24 @@ public class MachineSource implements IActionSource
 		return Optional.empty();
 	}
 
+	@Override
+	public boolean equals( Object o )
+	{
+		if( this == o )
+		{
+			return true;
+		}
+		if( o == null || getClass() != o.getClass() )
+		{
+			return false;
+		}
+		MachineSource that = (MachineSource) o;
+		return via.equals( that.via );
+	}
+
+	@Override
+	public int hashCode()
+	{
+		return Objects.hash( via );
+	}
 }

src/main/java/appeng/me/storage/DriveWatcher.java

@@ -19,19 +19,20 @@
 package appeng.me.storage;
 
 
+import appeng.core.features.registries.cell.CreativeCellHandler;
 import appeng.me.GridAccessException;
 import appeng.me.helpers.MachineSource;
 import appeng.tile.storage.TileDrive;
-import com.google.common.collect.ImmutableList;
 import net.minecraft.item.ItemStack;
 
 import appeng.api.config.Actionable;
-import appeng.api.implementations.tiles.IChestOrDrive;
 import appeng.api.networking.security.IActionSource;
 import appeng.api.storage.ICellHandler;
 import appeng.api.storage.ICellInventoryHandler;
 import appeng.api.storage.data.IAEStack;
 
+import java.util.Collections;
+
 
 public class DriveWatcher<T extends IAEStack<T>> extends MEInventoryHandler<T>
 {
@@ -39,16 +40,16 @@ public class DriveWatcher<T extends IAEStack<T>> extends MEInventoryHandler<T>
 	private int oldStatus = 0;
 	private final ItemStack is;
 	private final ICellHandler handler;
-	private final IChestOrDrive cord;
+	private final TileDrive drive;
 	private IActionSource source;
 
-	public DriveWatcher( final ICellInventoryHandler<T> i, final ItemStack is, final ICellHandler han, final IChestOrDrive cod )
+	public DriveWatcher( final ICellInventoryHandler<T> i, final ItemStack is, final ICellHandler han, final TileDrive drive )
 	{
 		super( i, i.getChannel() );
 		this.is = is;
 		this.handler = han;
-		this.cord = cod;
-		this.source = new MachineSource( cod );
+		this.drive = drive;
+		this.source = new MachineSource( drive );
 	}
 
 	public int getStatus()
@@ -61,55 +62,58 @@ public class DriveWatcher<T extends IAEStack<T>> extends MEInventoryHandler<T>
 	{
 		final long size = input.getStackSize();
 
-		final T a = super.injectItems( input, type, src );
+		final T remainder = super.injectItems( input, type, src );
 
-		if( type == Actionable.MODULATE && ( a == null || a.getStackSize() != size ) )
+		if( type == Actionable.MODULATE && ( remainder == null || remainder.getStackSize() != size ) )
 		{
 			final int newStatus = this.getStatus();
 
 			if( newStatus != this.oldStatus )
 			{
-				this.cord.blinkCell( this.getSlot() );
+				this.drive.blinkCell( this.getSlot() );
 				this.oldStatus = newStatus;
 			}
-			try
+			if (this.drive.getProxy().isActive() && !(handler instanceof CreativeCellHandler))
 			{
-				( (TileDrive) this.cord ).getProxy().getStorage().postAlterationOfStoredItems( this.getChannel(), ImmutableList.of( input.copy().setStackSize( input.getStackSize() - ( a == null ? 0 : a.getStackSize() ) ) ), this.source );
-			}
-			catch( GridAccessException e )
-			{
-				e.printStackTrace();
+				try
+				{
+					this.drive.getProxy().getStorage().postAlterationOfStoredItems( this.getChannel(), Collections.singletonList( input.copy().setStackSize( input.getStackSize() - ( remainder == null ? 0 : remainder.getStackSize() ) ) ), this.source );
+				} catch ( GridAccessException e )
+				{
+					e.printStackTrace();
+				}
 			}
 		}
 
-		return a;
+		return remainder;
 	}
 
 	@Override
 	public T extractItems( final T request, final Actionable type, final IActionSource src )
 	{
-		final T a = super.extractItems( request, type, src );
+		final T extractable = super.extractItems( request, type, src );
 
-		if( type == Actionable.MODULATE && a != null )
+		if( type == Actionable.MODULATE && extractable != null )
 		{
 			final int newStatus = this.getStatus();
 
 			if( newStatus != this.oldStatus )
 			{
-				this.cord.blinkCell( this.getSlot() );
+				this.drive.blinkCell( this.getSlot() );
 				this.oldStatus = newStatus;
 			}
-
-			try
+			if (this.drive.getProxy().isActive() && !(handler instanceof CreativeCellHandler ))
 			{
-				( (TileDrive) this.cord ).getProxy().getStorage().postAlterationOfStoredItems( this.getChannel(), ImmutableList.of( request.copy().setStackSize( -a.getStackSize() ) ), this.source );
-			}
-			catch( GridAccessException e )
-			{
-				e.printStackTrace();
+				try
+				{
+					this.drive.getProxy().getStorage().postAlterationOfStoredItems( this.getChannel(), Collections.singletonList( request.copy().setStackSize( -extractable.getStackSize() ) ), this.source );
+				} catch ( GridAccessException e )
+				{
+					e.printStackTrace();
+				}
 			}
 		}
 
-		return a;
+		return extractable;
 	}
 }

src/main/java/appeng/me/storage/MEMonitorIInventory.java

@@ -288,24 +288,4 @@ public class MEMonitorIInventory implements IMEMonitor<IAEItemStack>, ITickingMo
 		this.mySource = mySource;
 	}
 
-	private static class CachedItemStack
-	{
-
-		private final ItemStack itemStack;
-		private final IAEItemStack aeStack;
-
-		public CachedItemStack( final ItemStack is )
-		{
-			if( is.isEmpty() )
-			{
-				this.itemStack = ItemStack.EMPTY;
-				this.aeStack = null;
-			}
-			else
-			{
-				this.itemStack = is.copy();
-				this.aeStack = AEApi.instance().storage().getStorageChannel( IItemStorageChannel.class ).createStack( is );
-			}
-		}
-	}
 }

src/main/java/appeng/me/storage/MEMonitorPassThrough.java

@@ -171,4 +171,5 @@ public class MEMonitorPassThrough<T extends IAEStack<T>> extends MEPassThrough<T
 	{
 		this.changeSource = changeSource;
 	}
+
 }

src/main/java/appeng/me/storage/SecurityStationInventory.java

@@ -19,6 +19,8 @@
 package appeng.me.storage;
 
 
+import appeng.me.helpers.MEMonitorHandler;
+import appeng.me.helpers.MachineSource;
 import com.mojang.authlib.GameProfile;
 
 import appeng.api.AEApi;
@@ -35,16 +37,20 @@ import appeng.api.storage.data.IItemList;
 import appeng.me.GridAccessException;
 import appeng.tile.misc.TileSecurityStation;
 
+import java.util.Collections;
+
 
 public class SecurityStationInventory implements IMEInventoryHandler<IAEItemStack>
 {
 
 	private final IItemList<IAEItemStack> storedItems = AEApi.instance().storage().getStorageChannel( IItemStorageChannel.class ).createList();
 	private final TileSecurityStation securityTile;
+	private final MachineSource src;
 
 	public SecurityStationInventory( final TileSecurityStation ts )
 	{
 		this.securityTile = ts;
+		this.src = new MachineSource( securityTile );
 	}
 
 	@Override
@@ -61,6 +67,11 @@ public class SecurityStationInventory implements IMEInventoryHandler<IAEItemStac
 						return null;
 					}
 
+					if( securityTile.getProxy().isActive() )
+					{
+						( ( MEMonitorHandler<IAEItemStack> ) securityTile.getInventory( AEApi.instance().storage().getStorageChannel( IItemStorageChannel.class ) ) ).postChangesToListeners( Collections.singletonList( input.copy() ), this.src );
+					}
+
 					this.getStoredItems().add( input );
 					this.securityTile.inventoryChanged();
 					return null;
@@ -101,6 +112,11 @@ public class SecurityStationInventory implements IMEInventoryHandler<IAEItemStac
 					return output;
 				}
 
+				if( securityTile.getProxy().isActive() )
+				{
+					( ( MEMonitorHandler<IAEItemStack> ) securityTile.getInventory( AEApi.instance().storage().getStorageChannel( IItemStorageChannel.class ) ) ).postChangesToListeners( Collections.singletonList( target.copy().setStackSize( -target.getStackSize() ) ), this.src );
+				}
+
 				target.setStackSize( 0 );
 				this.securityTile.inventoryChanged();
 				return output;

src/main/java/appeng/parts/PartBasicState.java

@@ -27,6 +27,7 @@ import net.minecraft.item.ItemStack;
 
 import appeng.api.implementations.IPowerChannelState;
 import appeng.api.networking.GridFlags;
+import appeng.api.networking.events.MENetworkBootingStatusChange;
 import appeng.api.networking.events.MENetworkChannelsChanged;
 import appeng.api.networking.events.MENetworkEventSubscribe;
 import appeng.api.networking.events.MENetworkPowerStatusChange;
@@ -59,6 +60,12 @@ public abstract class PartBasicState extends AEBasePart implements IPowerChannel
 		this.getHost().markForUpdate();
 	}
 
+	@MENetworkEventSubscribe
+	public void bootingRender( final MENetworkBootingStatusChange bs )
+	{
+		this.getHost().markForUpdate();
+	}
+
 	@Override
 	public void writeToStream( final ByteBuf data ) throws IOException
 	{

src/main/java/appeng/parts/automation/PartFormationPlane.java

@@ -187,8 +187,9 @@ public class PartFormationPlane extends PartAbstractFormationPlane<IAEItemStack>
 		this.stateChanged();
 	}
 
+	@Override
 	@MENetworkEventSubscribe
-	public void updateChannels( final MENetworkChannelsChanged changedChannels )
+	public void chanRender( final MENetworkChannelsChanged changedChannels )
 	{
 		this.stateChanged();
 	}

src/main/java/appeng/parts/automation/PartLevelEmitter.java

@@ -184,8 +184,9 @@ public class PartLevelEmitter extends PartUpgradeable implements IEnergyWatcherH
 		return flipState ? this.reportingValue >= this.lastReportedValue + 1 : this.reportingValue < this.lastReportedValue + 1;
 	}
 
+	@Override
 	@MENetworkEventSubscribe
-	public void powerStatusChange( final MENetworkPowerStatusChange powerEvent )
+	public void powerRender( final MENetworkPowerStatusChange powerEvent )
 	{
 		if (this.getProxy().isActive())
 		{
@@ -194,8 +195,9 @@ public class PartLevelEmitter extends PartUpgradeable implements IEnergyWatcherH
 		this.updateState();
 	}
 
+	@Override
 	@MENetworkEventSubscribe
-	public void channelChanged( final MENetworkChannelsChanged c )
+	public void chanRender( final MENetworkChannelsChanged c )
 	{
 		if (this.getProxy().isActive())
 		{
@@ -288,37 +290,24 @@ public class PartLevelEmitter extends PartUpgradeable implements IEnergyWatcherH
 
 		try
 		{
-
-			if( myStack == null )
+			if( this.getInstalledUpgrades( Upgrades.FUZZY ) > 0 || myStack == null )
 			{
-				this.getProxy().getStorage().getInventory( AEApi.instance().storage().getStorageChannel( IItemStorageChannel.class ) ).addListener( this, this.getProxy().getGrid() );
+				this.getProxy()
+						.getStorage()
+						.getInventory( AEApi.instance().storage().getStorageChannel( IItemStorageChannel.class ) )
+						.addListener( this,
+								this.getProxy().getGrid() );
 			}
 			else
 			{
 				this.getProxy().getStorage().getInventory( AEApi.instance().storage().getStorageChannel( IItemStorageChannel.class ) ).removeListener( this );
+
 				if( this.myWatcher != null )
 				{
-					if( this.getInstalledUpgrades( Upgrades.FUZZY ) > 0 )
-					{
-						Optional<OreReference> ores = OreHelper.INSTANCE.getOre( myStack.getDefinition() );
-						if( ores.isPresent() )
-						{
-							for( IAEItemStack iaeItemStack : ores.get().getAEEquivalents() )
-							{
-								this.myWatcher.add( iaeItemStack );
-							}
-						}
-						else
-						{
-							this.myWatcher.add( myStack );
-						}
-					}
-					else
-					{
-						this.myWatcher.add( myStack );
-					}
+					this.myWatcher.add( myStack );
 				}
 			}
+
 			this.updateReportingValue( this.getProxy().getStorage().getInventory( AEApi.instance().storage().getStorageChannel( IItemStorageChannel.class ) ) );
 		}
 		catch( final GridAccessException e )
@@ -363,23 +352,11 @@ public class PartLevelEmitter extends PartUpgradeable implements IEnergyWatcherH
 	}
 
 	@Override
-	public void onStackChange( IItemList<?> o, IAEStack<?> fullStack, IAEStack<?> diffStack, IActionSource src, IStorageChannel<?> chan )
+	public void onStackChange( final IItemList o, final IAEStack fullStack, final IAEStack diffStack, final IActionSource src, final IStorageChannel chan )
 	{
-		if( chan == AEApi.instance().storage().getStorageChannel( IItemStorageChannel.class ) )
+		if( chan == AEApi.instance().storage().getStorageChannel( IItemStorageChannel.class ) && fullStack.equals( this.config.getAEStackInSlot( 0 ) ) && this.getInstalledUpgrades( Upgrades.FUZZY ) == 0 )
 		{
-			IAEItemStack myStack = this.config.getAEStackInSlot( 0 );
-			if( this.getInstalledUpgrades( Upgrades.FUZZY ) > 0 )
-			{
-				final FuzzyMode fzMode = (FuzzyMode) this.getConfigManager().getSetting( Settings.FUZZY_MODE );
-				if( Platform.itemComparisons().isFuzzyEqualItem( myStack.getDefinition(), ( (IAEItemStack) diffStack ).getDefinition(), fzMode ) )
-				{
-					this.lastReportedValue += diffStack.getStackSize();
-				}
-			}
-			else if( diffStack.equals( myStack ) )
-			{
-				this.lastReportedValue += diffStack.getStackSize();
-			}
+			this.lastReportedValue = fullStack.getStackSize();
 			this.updateState();
 		}
 	}

src/main/java/appeng/parts/misc/ItemHandlerAdapter.java

@@ -62,8 +62,6 @@ class ItemHandlerAdapter implements IMEInventory<IAEItemStack>, IBaseMonitor<IAE
 	private StorageFilter mode;
 	private AccessRestriction access;
 
-	private ItemStack stackCache = null;
-
 	ItemHandlerAdapter( IItemHandler itemHandler, IGridProxyable proxy )
 	{
 		this.itemHandler = itemHandler;
@@ -82,8 +80,8 @@ class ItemHandlerAdapter implements IMEInventory<IAEItemStack>, IBaseMonitor<IAE
 	public IAEItemStack injectItems( IAEItemStack iox, Actionable type, IActionSource src )
 	{
 		// Try to reuse the cached stack
-		@Nullable ItemStack currentCached = stackCache;
-		stackCache = null;
+		@Nullable ItemStack currentCached = iox.getCachedItemStack();
+		iox.setCachedItemStack(null);
 
 		ItemStack orgInput;
 		int slotCount = this.itemHandler.getSlots();
@@ -108,9 +106,9 @@ class ItemHandlerAdapter implements IMEInventory<IAEItemStack>, IBaseMonitor<IAE
 		}
 
 		// Store the stack in the cache for next time.
-		if( !remaining.isEmpty() && remaining != orgInput )
+		if( !remaining.isEmpty() )
 		{
-			stackCache = remaining;
+			iox.setCachedItemStack( remaining );
 		}
 
 		// At this point, we still have some items left...

src/main/java/appeng/parts/misc/PartInterface.java

@@ -95,14 +95,16 @@ public class PartInterface extends PartBasicState implements IGridTickable, ISto
 		super( is );
 	}
 
+	@Override
 	@MENetworkEventSubscribe
-	public void stateChange( final MENetworkChannelsChanged c )
+	public void chanRender( final MENetworkChannelsChanged c )
 	{
 		this.duality.notifyNeighbors();
 	}
 
+	@Override
 	@MENetworkEventSubscribe
-	public void stateChange( final MENetworkPowerStatusChange c )
+	public void powerRender( final MENetworkPowerStatusChange c )
 	{
 		this.duality.notifyNeighbors();
 	}

src/main/java/appeng/parts/misc/PartOreDicStorageBus.java

@@ -0,0 +1,215 @@
+package appeng.parts.misc;
+
+import appeng.api.AEApi;
+import appeng.api.config.*;
+import appeng.api.networking.storage.IBaseMonitor;
+import appeng.api.networking.storage.IStorageGrid;
+import appeng.api.networking.ticking.ITickManager;
+import appeng.api.parts.IPartModel;
+import appeng.api.storage.IMEInventory;
+import appeng.api.storage.channels.IItemStorageChannel;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.core.AppEng;
+import appeng.core.sync.GuiBridge;
+import appeng.items.parts.PartModels;
+import appeng.me.GridAccessException;
+import appeng.me.cache.GridStorageCache;
+import appeng.me.storage.ITickingMonitor;
+import appeng.me.storage.MEInventoryHandler;
+import appeng.parts.PartModel;
+import appeng.util.ConfigManager;
+import appeng.util.Platform;
+import appeng.util.item.OreHelper;
+import appeng.util.prioritylist.OreDictPriorityList;
+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.EnumHand;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.Vec3d;
+
+
+public class PartOreDicStorageBus extends PartStorageBus
+{
+    public static final ResourceLocation MODEL_BASE = new ResourceLocation( AppEng.MOD_ID, "part/oredict_storage_bus_base" );
+    @PartModels
+    public static final IPartModel MODELS_OFF = new PartModel( MODEL_BASE, new ResourceLocation( AppEng.MOD_ID, "part/storage_bus_off" ) );
+    @PartModels
+    public static final IPartModel MODELS_ON = new PartModel( MODEL_BASE, new ResourceLocation( AppEng.MOD_ID, "part/storage_bus_on" ) );
+    @PartModels
+    public static final IPartModel MODELS_HAS_CHANNEL = new PartModel( MODEL_BASE, new ResourceLocation( AppEng.MOD_ID, "part/storage_bus_has_channel" ) );
+
+
+    public String oreMatch;
+    OreDictPriorityList<IAEItemStack> priorityList;
+
+    public PartOreDicStorageBus( ItemStack is )
+    {
+        super( is );
+    }
+
+    @Override
+    public void readFromNBT( NBTTagCompound data )
+    {
+        super.readFromNBT( data );
+        this.oreMatch = data.getString( "oreMatch" );
+        this.priorityList = new OreDictPriorityList<>( OreHelper.INSTANCE.getMatchingOre( oreMatch ), oreMatch );
+    }
+
+    @Override
+    public void writeToNBT( NBTTagCompound data )
+    {
+        super.writeToNBT( data );
+        data.setString( "oreMatch", getOreMatch() );
+    }
+
+    @Override
+    public boolean onPartActivate( final EntityPlayer player, final EnumHand hand, final Vec3d pos )
+    {
+        if( Platform.isServer() )
+        {
+            Platform.openGUI( player, this.getHost().getTile(), this.getSide(), GuiBridge.GUI_OREDICTSTORAGEBUS );
+        }
+        return true;
+    }
+
+    @Override
+    public GuiBridge getGuiBridge()
+    {
+        return GuiBridge.GUI_OREDICTSTORAGEBUS;
+    }
+
+    @Override
+    public MEInventoryHandler<IAEItemStack> getInternalHandler()
+    {
+        if( this.cached )
+        {
+            return this.handler;
+        }
+
+        final boolean wasSleeping = this.monitor == null;
+
+        this.cached = true;
+        final TileEntity self = this.getHost().getTile();
+        final TileEntity target = self.getWorld().getTileEntity( self.getPos().offset( this.getSide().getFacing() ) );
+        final int newHandlerHash = this.createHandlerHash( target );
+
+        if( newHandlerHash != 0 && newHandlerHash == this.handlerHash )
+        {
+            return this.handler;
+        }
+
+        this.handlerHash = newHandlerHash;
+        this.handler = null;
+        if( this.monitor != null )
+        {
+            ( (IBaseMonitor<IAEItemStack>) monitor ).removeListener( this );
+        }
+        this.monitor = null;
+        if( target != null )
+        {
+            IMEInventory<IAEItemStack> inv = this.getInventoryWrapper( target );
+
+            if( inv instanceof ITickingMonitor )
+            {
+                this.monitor = (ITickingMonitor) inv;
+                this.monitor.setActionSource( mySrc );
+                this.monitor.setMode( (StorageFilter) this.getConfigManager().getSetting( Settings.STORAGE_FILTER ) );
+            }
+
+            if( inv != null )
+            {
+                this.handler = new MEInventoryHandler<>( inv, AEApi.instance().storage().getStorageChannel( IItemStorageChannel.class ) );
+
+                this.handler.setBaseAccess( (AccessRestriction) this.getConfigManager().getSetting( Settings.ACCESS ) );
+                this.handler.setWhitelist( this.getInstalledUpgrades( Upgrades.INVERTER ) > 0 ? IncludeExclude.BLACKLIST : IncludeExclude.WHITELIST );
+                this.handler.setPriority( this.priority );
+
+                this.handler.setPartitionList( priorityList );
+
+                if( inv instanceof IBaseMonitor )
+                {
+                    if( ( (AccessRestriction) ( (ConfigManager) this.getConfigManager() ).getSetting( Settings.ACCESS ) ).hasPermission( AccessRestriction.READ ) )
+                    {
+                        ( (IBaseMonitor<IAEItemStack>) inv ).addListener( this, this.handler );
+                    }
+                }
+            }
+        }
+
+        // update sleep state...
+        if( wasSleeping != ( this.monitor == null ) )
+        {
+            try
+            {
+                final ITickManager tm = this.getProxy().getTick();
+                if( this.monitor == null )
+                {
+                    tm.sleepDevice( this.getProxy().getNode() );
+                }
+                else
+                {
+                    tm.wakeDevice( this.getProxy().getNode() );
+                }
+            }
+            catch( final GridAccessException e )
+            {
+                // :(
+            }
+        }
+
+        try
+        {
+            // force grid to update handlers...
+            ( (GridStorageCache) this.getProxy().getGrid().getCache( IStorageGrid.class ) ).cellUpdate( null );
+        }
+        catch( final GridAccessException e )
+        {
+            // :3
+        }
+
+        return this.handler;
+    }
+
+    public String getOreMatch()
+    {
+        if( this.oreMatch == null )
+        {
+            return "";
+        }
+        return oreMatch;
+    }
+
+    public void saveOreMatch( String oreMatch )
+    {
+        if( !this.oreMatch.equals( oreMatch ) )
+        {
+            this.oreMatch = oreMatch;
+            this.priorityList = new OreDictPriorityList<>( OreHelper.INSTANCE.getMatchingOre( oreMatch ), oreMatch );
+            if( this.handler != null )
+            {
+                handler.setPartitionList( this.priorityList );
+            }
+            this.getHost().markForSave();
+        }
+    }
+
+    @Override
+    public IPartModel getStaticModels()
+    {
+        if( this.isActive() && this.isPowered() )
+        {
+            return MODELS_HAS_CHANNEL;
+        }
+        else if( this.isPowered() )
+        {
+            return MODELS_ON;
+        }
+        else
+        {
+            return MODELS_OFF;
+        }
+    }
+
+}

src/main/java/appeng/parts/misc/PartSharedStorageBus.java

@@ -1,226 +0,0 @@
-/*
- * This file is part of Applied Energistics 2.
- * Copyright (c) 2013 - 2018, AlgorithmX2, All rights reserved.
- *
- * Applied Energistics 2 is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * Applied Energistics 2 is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with Applied Energistics 2.  If not, see <http://www.gnu.org/licenses/lgpl>.
- */
-
-package appeng.parts.misc;
-
-
-import java.util.Collections;
-import java.util.List;
-
-import appeng.api.config.AccessRestriction;
-import appeng.fluids.parts.PartFluidInterface;
-import appeng.fluids.tile.TileFluidInterface;
-import appeng.tile.misc.TileInterface;
-import appeng.tile.networking.TileCableBus;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.tileentity.TileEntity;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.IBlockAccess;
-
-import appeng.api.AEApi;
-import appeng.api.networking.events.MENetworkCellArrayUpdate;
-import appeng.api.networking.events.MENetworkChannelsChanged;
-import appeng.api.networking.events.MENetworkEventSubscribe;
-import appeng.api.networking.events.MENetworkPowerStatusChange;
-import appeng.api.networking.ticking.IGridTickable;
-import appeng.api.parts.IPartCollisionHelper;
-import appeng.api.storage.ICellContainer;
-import appeng.api.storage.ICellInventory;
-import appeng.api.storage.IMEInventoryHandler;
-import appeng.api.storage.IStorageChannel;
-import appeng.api.storage.channels.IItemStorageChannel;
-import appeng.api.util.AECableType;
-import appeng.api.util.IConfigManager;
-import appeng.helpers.IPriorityHost;
-import appeng.me.GridAccessException;
-import appeng.parts.automation.PartUpgradeable;
-
-
-/**
- * @author BrockWS
- * @version rv6 - 22/05/2018
- * @since rv6 22/05/2018
- */
-public abstract class PartSharedStorageBus extends PartUpgradeable implements IGridTickable, ICellContainer, IPriorityHost
-{
-	private boolean wasActive = false;
-	private int priority = 0;
-	protected boolean accessChanged;
-
-	public PartSharedStorageBus( ItemStack is )
-	{
-		super( is );
-	}
-
-	protected void updateStatus()
-	{
-		final boolean currentActive = this.getProxy().isActive();
-		if( this.wasActive != currentActive )
-		{
-			this.wasActive = currentActive;
-			try
-			{
-				this.getProxy().getGrid().postEvent( new MENetworkCellArrayUpdate() );
-				this.getHost().markForUpdate();
-			}
-			catch( final GridAccessException ignore )
-			{
-				// :P
-			}
-		}
-	}
-
-	@MENetworkEventSubscribe
-	public void updateChannels( final MENetworkChannelsChanged changedChannels )
-	{
-		this.updateStatus();
-	}
-
-	/**
-	 * Helper method to get this parts storage channel
-	 *
-	 * @return Storage channel
-	 */
-	public IStorageChannel getStorageChannel()
-	{
-		return AEApi.instance().storage().getStorageChannel( IItemStorageChannel.class );
-	}
-
-	protected abstract void resetCache();
-
-	protected abstract void resetCache( boolean fullReset );
-
-	@Override
-	public List<IMEInventoryHandler> getCellArray( final IStorageChannel channel )
-	{
-		return Collections.emptyList();
-	}
-
-	@Override
-	public void blinkCell( int slot )
-	{
-	}
-
-	@Override
-	public void saveChanges( ICellInventory<?> cellInventory )
-	{
-	}
-
-	@Override
-	public int getPriority()
-	{
-		return this.priority;
-	}
-
-	@Override
-	public void setPriority( final int newValue )
-	{
-		this.priority = newValue;
-		this.getHost().markForSave();
-		this.resetCache( true );
-	}
-
-	@Override
-	@MENetworkEventSubscribe
-	public void powerRender( final MENetworkPowerStatusChange c )
-	{
-		this.updateStatus();
-	}
-
-	@Override
-	public void upgradesChanged()
-	{
-		super.upgradesChanged();
-		this.resetCache( true );
-	}
-
-	@Override
-	public void updateSetting( final IConfigManager manager, final Enum settingName, final Enum newValue )
-	{
-		if( settingName instanceof AccessRestriction )
-		{
-			this.accessChanged = true;
-		}
-		this.resetCache( true );
-		this.getHost().markForSave();
-	}
-
-	@Override
-	public void onNeighborChanged( IBlockAccess w, BlockPos pos, BlockPos neighbor )
-	{
-		if( pos.offset( this.getSide().getFacing() ).equals( neighbor ) )
-		{
-
-			final TileEntity te = w.getTileEntity( neighbor );
-
-			// In case the TE was destroyed, we have to do a full reset immediately.
-			if( te instanceof TileCableBus )
-			{
-				if( ( (TileCableBus) te ).getPart( this.getSide().getOpposite() ) instanceof PartFluidInterface )
-				{
-					this.resetCache( true );
-					this.resetCache();
-				}
-			}
-			if( te == null || te instanceof TileFluidInterface )
-			{
-				this.resetCache( true );
-				this.resetCache();
-			}
-			else
-			{
-				this.resetCache( false );
-			}
-		}
-	}
-
-	@Override
-	public void readFromNBT( final NBTTagCompound data )
-	{
-		super.readFromNBT( data );
-		this.priority = data.getInteger( "priority" );
-	}
-
-	@Override
-	public void writeToNBT( final NBTTagCompound data )
-	{
-		super.writeToNBT( data );
-		data.setInteger( "priority", this.priority );
-	}
-
-	@Override
-	public void getBoxes( final IPartCollisionHelper bch )
-	{
-		bch.addBox( 3, 3, 15, 13, 13, 16 );
-		bch.addBox( 2, 2, 14, 14, 14, 15 );
-		bch.addBox( 5, 5, 12, 11, 11, 14 );
-	}
-
-	@Override
-	protected int getUpgradeSlots()
-	{
-		return 5;
-	}
-
-	@Override
-	public float getCableConnectionLength( AECableType cable )
-	{
-		return 4;
-	}
-}

src/main/java/appeng/parts/p2p/PartP2PFluids.java

@@ -83,10 +83,19 @@ public class PartP2PFluids extends PartP2PTunnel<PartP2PFluids> implements IFlui
 
 		if( this.isOutput() )
 		{
-			final PartP2PFluids in = this.getInput();
-			if( in != null )
+			try
 			{
-				in.onTunnelNetworkChange();
+				for( PartP2PFluids in : this.getInputs() )
+				{
+					if( in != null )
+					{
+						in.onTunnelNetworkChange();
+					}
+				}
+			}
+			catch( GridAccessException e )
+			{
+				e.printStackTrace();
 			}
 		}
 	}
@@ -124,13 +133,21 @@ public class PartP2PFluids extends PartP2PTunnel<PartP2PFluids> implements IFlui
 	{
 		if( !this.isOutput() )
 		{
-			final PartP2PFluids tun = this.getInput();
-			if( tun != null )
+			try
 			{
-				return ACTIVE_TANK;
+				for( PartP2PFluids tun : this.getInputs() )
+				{
+					if( tun != null )
+					{
+						return ACTIVE_TANK;
+					}
+				}
+			}
+			catch( GridAccessException e )
+			{
+				e.printStackTrace();
 			}
 		}
-
 		return INACTIVE_TANK;
 	}
 

src/main/java/appeng/parts/p2p/PartP2PItems.java

@@ -33,10 +33,6 @@ import net.minecraftforge.items.IItemHandler;
 import net.minecraftforge.items.wrapper.EmptyHandler;
 
 import appeng.api.networking.IGridNode;
-import appeng.api.networking.events.MENetworkBootingStatusChange;
-import appeng.api.networking.events.MENetworkChannelsChanged;
-import appeng.api.networking.events.MENetworkEventSubscribe;
-import appeng.api.networking.events.MENetworkPowerStatusChange;
 import appeng.api.networking.ticking.IGridTickable;
 import appeng.api.networking.ticking.TickRateModulation;
 import appeng.api.networking.ticking.TickingRequest;
@@ -74,10 +70,22 @@ public class PartP2PItems extends PartP2PTunnel<PartP2PItems> implements IItemHa
 	public void onNeighborChanged( IBlockAccess w, BlockPos pos, BlockPos neighbor )
 	{
 		this.cachedInv = null;
-		final PartP2PItems input = this.getInput();
-		if( input != null && this.isOutput() )
+		try
 		{
-			input.onTunnelNetworkChange();
+			if( this.isOutput() )
+			{
+				for( PartP2PItems input : this.getInputs() )
+				{
+					if( input != null )
+					{
+						input.onTunnelNetworkChange();
+					}
+				}
+			}
+		}
+		catch( GridAccessException e )
+		{
+			e.printStackTrace();
 		}
 	}
 
@@ -162,51 +170,6 @@ public class PartP2PItems extends PartP2PTunnel<PartP2PItems> implements IItemHa
 		return wasReq ? TickRateModulation.FASTER : TickRateModulation.SLOWER;
 	}
 
-	@MENetworkEventSubscribe
-	public void changeStateA( final MENetworkBootingStatusChange bs )
-	{
-		if( !this.isOutput() )
-		{
-			this.cachedInv = null;
-			final int olderSize = this.oldSize;
-			this.oldSize = this.getDestination().getSlots();
-			if( olderSize != this.oldSize )
-			{
-				this.getHost().notifyNeighbors();
-			}
-		}
-	}
-
-	@MENetworkEventSubscribe
-	public void changeStateB( final MENetworkChannelsChanged bs )
-	{
-		if( !this.isOutput() )
-		{
-			this.cachedInv = null;
-			final int olderSize = this.oldSize;
-			this.oldSize = this.getDestination().getSlots();
-			if( olderSize != this.oldSize )
-			{
-				this.getHost().notifyNeighbors();
-			}
-		}
-	}
-
-	@MENetworkEventSubscribe
-	public void changeStateC( final MENetworkPowerStatusChange bs )
-	{
-		if( !this.isOutput() )
-		{
-			this.cachedInv = null;
-			final int olderSize = this.oldSize;
-			this.oldSize = this.getDestination().getSlots();
-			if( olderSize != this.oldSize )
-			{
-				this.getHost().notifyNeighbors();
-			}
-		}
-	}
-
 	@Override
 	public void onTunnelNetworkChange()
 	{
@@ -222,10 +185,19 @@ public class PartP2PItems extends PartP2PTunnel<PartP2PItems> implements IItemHa
 		}
 		else
 		{
-			final PartP2PItems input = this.getInput();
-			if( input != null )
+			try
 			{
-				input.getHost().notifyNeighbors();
+				for( PartP2PItems input : this.getInputs() )
+				{
+					if( input != null )
+					{
+						input.getHost().notifyNeighbors();
+					}
+				}
+			}
+			catch( GridAccessException e )
+			{
+				e.printStackTrace();
 			}
 		}
 	}

src/main/java/appeng/parts/p2p/PartP2PLight.java

@@ -32,8 +32,6 @@ import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
 
 import appeng.api.networking.IGridNode;
-import appeng.api.networking.events.MENetworkChannelsChanged;
-import appeng.api.networking.events.MENetworkPowerStatusChange;
 import appeng.api.networking.ticking.IGridTickable;
 import appeng.api.networking.ticking.TickRateModulation;
 import appeng.api.networking.ticking.TickingRequest;
@@ -62,20 +60,6 @@ public class PartP2PLight extends PartP2PTunnel<PartP2PLight> implements IGridTi
 		super( is );
 	}
 
-	@Override
-	public void chanRender( final MENetworkChannelsChanged c )
-	{
-		this.onTunnelNetworkChange();
-		super.chanRender( c );
-	}
-
-	@Override
-	public void powerRender( final MENetworkPowerStatusChange c )
-	{
-		this.onTunnelNetworkChange();
-		super.powerRender( c );
-	}
-
 	@Override
 	public void writeToStream( final ByteBuf data ) throws IOException
 	{
@@ -115,9 +99,17 @@ public class PartP2PLight extends PartP2PTunnel<PartP2PLight> implements IGridTi
 			this.lastValue = newLevel;
 			try
 			{
+				int light = 0;
+				for( PartP2PLight src : this.getInputs() )
+				{
+					if( src != null && src.getProxy().isActive() )
+					{
+						light = Math.max( light, src.lastValue );
+					}
+				}
 				for( final PartP2PLight out : this.getOutputs() )
 				{
-					out.setLightLevel( this.lastValue );
+					out.setLightLevel( light );
 				}
 			}
 			catch( final GridAccessException e )
@@ -196,15 +188,23 @@ public class PartP2PLight extends PartP2PTunnel<PartP2PLight> implements IGridTi
 	{
 		if( this.isOutput() )
 		{
-			final PartP2PLight src = this.getInput();
-			if( src != null && src.getProxy().isActive() )
-			{
-				this.setLightLevel( src.lastValue );
-			}
-			else
+			try
 			{
+				int light = 0;
+				for( PartP2PLight src : this.getInputs() )
+				{
+					if( src != null && src.getProxy().isActive() )
+					{
+						light = Math.max( light, src.lastValue );
+					}
+				}
+				this.setLightLevel( light );
 				this.getHost().markForUpdate();
 			}
+			catch( GridAccessException e )
+			{
+				e.printStackTrace();
+			}
 		}
 		else
 		{

src/main/java/appeng/parts/p2p/PartP2PRedstone.java

@@ -31,10 +31,6 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
 
-import appeng.api.networking.events.MENetworkBootingStatusChange;
-import appeng.api.networking.events.MENetworkChannelsChanged;
-import appeng.api.networking.events.MENetworkEventSubscribe;
-import appeng.api.networking.events.MENetworkPowerStatusChange;
 import appeng.api.parts.IPartModel;
 import appeng.items.parts.PartModels;
 import appeng.me.GridAccessException;
@@ -60,20 +56,25 @@ public class PartP2PRedstone extends PartP2PTunnel<PartP2PRedstone>
 		super( is );
 	}
 
-	@MENetworkEventSubscribe
-	public void changeStateA( final MENetworkBootingStatusChange bs )
-	{
-		this.setNetworkReady();
-	}
-
 	private void setNetworkReady()
 	{
 		if( this.isOutput() )
 		{
-			final PartP2PRedstone in = this.getInput();
-			if( in != null )
+			try
 			{
-				this.putInput( in.power );
+				int power = 0;
+				for( PartP2PRedstone in : this.getInputs() )
+				{
+					if( in != null )
+					{
+						power = Math.max( power, in.power );
+					}
+				}
+				this.putInput( power );
+			}
+			catch( GridAccessException e )
+			{
+				e.printStackTrace();
 			}
 		}
 	}
@@ -86,12 +87,20 @@ public class PartP2PRedstone extends PartP2PTunnel<PartP2PRedstone>
 		}
 
 		this.recursive = true;
-		if( this.isOutput() && this.getProxy().isActive() )
+		if( this.isOutput() )
 		{
-			final int newPower = (Integer) o;
-			if( this.power != newPower )
+			if( this.getProxy().isActive() )
 			{
-				this.power = newPower;
+				final int newPower = (Integer) o;
+				if( this.power != newPower )
+				{
+					this.power = newPower;
+					this.notifyNeighbors();
+				}
+			}
+			else
+			{
+				this.power = 0;
 				this.notifyNeighbors();
 			}
 		}
@@ -111,18 +120,6 @@ public class PartP2PRedstone extends PartP2PTunnel<PartP2PRedstone>
 		}
 	}
 
-	@MENetworkEventSubscribe
-	public void changeStateB( final MENetworkChannelsChanged bs )
-	{
-		this.setNetworkReady();
-	}
-
-	@MENetworkEventSubscribe
-	public void changeStateC( final MENetworkPowerStatusChange bs )
-	{
-		this.setNetworkReady();
-	}
-
 	@Override
 	public void readFromNBT( final NBTTagCompound tag )
 	{
@@ -167,7 +164,22 @@ public class PartP2PRedstone extends PartP2PTunnel<PartP2PRedstone>
 
 				this.power = b.getWeakPower( state, this.getTile().getWorld(), target, srcSide );
 				this.power = Math.max( this.power, b.getWeakPower( state, this.getTile().getWorld(), target, srcSide ) );
-				this.sendToOutput( this.power );
+				int powerOut = this.power;
+				try
+				{
+					for( PartP2PRedstone in : this.getInputs() )
+					{
+						if( in != null )
+						{
+							powerOut = Math.max( in.power, powerOut );
+						}
+					}
+				}
+				catch( GridAccessException e )
+				{
+					e.printStackTrace();
+				}
+				this.sendToOutput( powerOut );
 			}
 			else
 			{

src/main/java/appeng/parts/p2p/PartP2PTunnel.java

@@ -24,6 +24,10 @@ import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Optional;
 
+import appeng.api.networking.events.MENetworkBootingStatusChange;
+import appeng.api.networking.events.MENetworkChannelsChanged;
+import appeng.api.networking.events.MENetworkEventSubscribe;
+import appeng.api.networking.events.MENetworkPowerStatusChange;
 import io.netty.buffer.ByteBuf;
 
 import net.minecraft.entity.player.EntityPlayer;
@@ -53,6 +57,7 @@ import appeng.me.cache.P2PCache;
 import appeng.me.cache.helpers.TunnelCollection;
 import appeng.parts.PartBasicState;
 import appeng.util.Platform;
+import org.lwjgl.input.Keyboard;
 
 
 public abstract class PartP2PTunnel<T extends PartP2PTunnel> extends PartBasicState
@@ -77,26 +82,13 @@ public abstract class PartP2PTunnel<T extends PartP2PTunnel> extends PartBasicSt
 		return null;
 	}
 
-	public T getInput()
+	public TunnelCollection<T> getInputs() throws GridAccessException
 	{
-		if( this.getFrequency() == 0 )
+		if( this.getProxy().isActive() && this.getFrequency() != 0 )
 		{
-			return null;
+			return (TunnelCollection<T>) this.getProxy().getP2P().getInputs( this.getFrequency(), this.getClass() );
 		}
-
-		try
-		{
-			final PartP2PTunnel tunnel = this.getProxy().getP2P().getInput( this.getFrequency() );
-			if( this.getClass().isInstance( tunnel ) )
-			{
-				return (T) tunnel;
-			}
-		}
-		catch( final GridAccessException e )
-		{
-			// :P
-		}
-		return null;
+		return new TunnelCollection( new ArrayList(), this.getClass() );
 	}
 
 	public TunnelCollection<T> getOutputs() throws GridAccessException
@@ -164,6 +156,30 @@ public abstract class PartP2PTunnel<T extends PartP2PTunnel> extends PartBasicSt
 		super.writeToStream( data );
 		data.writeShort( this.getFrequency() );
 	}
+	
+	@Override
+	@MENetworkEventSubscribe
+	public void chanRender( final MENetworkChannelsChanged c )
+	{
+		this.onTunnelNetworkChange();
+		super.chanRender( c );
+	}
+
+	@Override
+	@MENetworkEventSubscribe
+	public void powerRender( final MENetworkPowerStatusChange c )
+	{
+		this.onTunnelNetworkChange();
+		super.powerRender( c );
+	}
+
+	@Override
+	@MENetworkEventSubscribe
+	public void bootingRender( final MENetworkBootingStatusChange bs )
+	{
+		this.onTunnelNetworkChange();
+		super.bootingRender( bs );
+	}
 
 	@Override
 	public float getCableConnectionLength( AECableType cable )
@@ -189,8 +205,13 @@ public abstract class PartP2PTunnel<T extends PartP2PTunnel> extends PartBasicSt
 		{
 			return false;
 		}
-
-		final ItemStack is = player.getHeldItem( hand );
+		
+		boolean pasteAsOutput = true;
+		ItemStack is = player.getHeldItem( hand );
+		if (is.isEmpty()) {
+			pasteAsOutput = false;
+			is = player.getHeldItemOffhand();
+		}
 
 		// UniqueIdentifier id = GameRegistry.findUniqueIdentifierFor( is.getItem() );
 		// AELog.info( "ID:" + id.toString() + " : " + is.getItemDamage() );
@@ -211,14 +232,29 @@ public abstract class PartP2PTunnel<T extends PartP2PTunnel> extends PartBasicSt
 					final IPart testPart = ( (IPartItem) newType.getItem() ).createPartFromItemStack( newType );
 					if( testPart instanceof PartP2PTunnel )
 					{
+
+						try
+						{
+							this.getProxy().getP2P().removeTunnel( this, this.getFrequency() );
+						}
+						catch( GridAccessException e )
+						{
+							e.printStackTrace();
+						}
+
 						this.getHost().removePart( this.getSide(), true );
+
 						final AEPartLocation dir = this.getHost().addPart( newType, this.getSide(), player, hand );
 						final IPart newBus = this.getHost().getPart( dir );
 
 						if( newBus instanceof PartP2PTunnel )
 						{
 							final PartP2PTunnel newTunnel = (PartP2PTunnel) newBus;
-							newTunnel.setOutput( true );
+							
+							if( pasteAsOutput )
+							{
+								newTunnel.setOutput( true );
+							}
 
 							try
 							{
@@ -295,7 +331,17 @@ public abstract class PartP2PTunnel<T extends PartP2PTunnel> extends PartBasicSt
 				final boolean oldOutput = this.isOutput();
 				final short myFreq = this.getFrequency();
 
+				try
+				{
+					this.getProxy().getP2P().removeTunnel( this, this.getFrequency() );
+				}
+				catch( GridAccessException e )
+				{
+					e.printStackTrace();
+				}
+
 				this.getHost().removePart( this.getSide(), false );
+
 				final AEPartLocation dir = this.getHost().addPart( newType, this.getSide(), player, hand );
 				final IPart newBus = this.getHost().getPart( dir );
 
@@ -303,7 +349,6 @@ public abstract class PartP2PTunnel<T extends PartP2PTunnel> extends PartBasicSt
 				{
 					final PartP2PTunnel newTunnel = (PartP2PTunnel) newBus;
 					newTunnel.setOutput( oldOutput );
-					newTunnel.onTunnelNetworkChange();
 
 					try
 					{
@@ -314,9 +359,10 @@ public abstract class PartP2PTunnel<T extends PartP2PTunnel> extends PartBasicSt
 					{
 						// :P
 					}
+					newTunnel.onTunnelNetworkChange();
+
 				}
 
-				Platform.notifyBlocksOfNeighbors( this.getTile().getWorld(), this.getTile().getPos() );
 				return true;
 			}
 		}
@@ -353,7 +399,17 @@ public abstract class PartP2PTunnel<T extends PartP2PTunnel> extends PartBasicSt
 
 					final ItemStack newType = this.getHost().getPart( this.getSide() ).getItemStack( PartItemStack.WRENCH );
 
+					try
+					{
+						this.getProxy().getP2P().removeTunnel( this, this.getFrequency() );
+					}
+					catch( GridAccessException e )
+					{
+						e.printStackTrace();
+					}
+
 					this.getHost().removePart( this.getSide(), false );
+
 					final AEPartLocation dir = this.getHost().addPart( newType, this.getSide(), player, hand );
 					final IPart newBus = this.getHost().getPart( dir );
 
@@ -361,14 +417,17 @@ public abstract class PartP2PTunnel<T extends PartP2PTunnel> extends PartBasicSt
 					{
 						final PartP2PTunnel newTunnel = (PartP2PTunnel) newBus;
 						newTunnel.setOutput( false );
-						newTunnel.onTunnelNetworkChange();
 						newTunnel.getProxy().getP2P().updateFreq( newTunnel, newFreq );
+
+						newTunnel.onTunnelNetworkChange();
 					}
 				}
 				else
 				{
 					this.getProxy().getP2P().updateFreq( this, newFreq );
+					this.onTunnelNetworkChange();
 				}
+				Platform.notifyBlocksOfNeighbors( this.getTile().getWorld(), this.getTile().getPos() );
 			}
 			catch( final GridAccessException e )
 			{
@@ -418,7 +477,6 @@ public abstract class PartP2PTunnel<T extends PartP2PTunnel> extends PartBasicSt
 
 	public void onTunnelNetworkChange()
 	{
-
 	}
 
 	protected void queueTunnelDrain( final PowerUnits unit, final double f )

src/main/java/appeng/parts/reporting/AbstractPartMonitor.java

@@ -417,7 +417,7 @@ public abstract class AbstractPartMonitor extends AbstractPartDisplay implements
 	@Override
 	public void onStackChange( IItemList<?> o, IAEStack<?> fullStack, IAEStack<?> diffStack, IActionSource src, IStorageChannel<?> chan )
 	{
-		this.configuredAmount = this.configuredAmount + diffStack.getStackSize();
+		this.configuredAmount = fullStack.getStackSize();
 
 		if( this.configuredItem != null )
 		{

src/main/java/appeng/parts/reporting/PartExpandedProcessingPatternTerminal.java

@@ -0,0 +1,138 @@
+package appeng.parts.reporting;
+
+import appeng.api.implementations.ICraftingPatternItem;
+import appeng.api.networking.crafting.ICraftingPatternDetails;
+import appeng.api.parts.IPartModel;
+import appeng.api.storage.data.IAEItemStack;
+import appeng.core.AppEng;
+import appeng.core.sync.GuiBridge;
+import appeng.helpers.Reflected;
+import appeng.items.parts.PartModels;
+import appeng.parts.PartModel;
+import appeng.tile.inventory.AppEngInternalInventory;
+import appeng.util.inv.InvOperation;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.items.IItemHandler;
+
+import static appeng.helpers.PatternHelper.PROCESSING_INPUT_LIMIT;
+import static appeng.helpers.PatternHelper.PROCESSING_OUTPUT_LIMIT;
+
+
+public class PartExpandedProcessingPatternTerminal extends AbstractPartTerminal
+{
+    @PartModels
+    public static final ResourceLocation MODEL_OFF = new ResourceLocation( AppEng.MOD_ID, "part/expanded_processing_pattern_terminal_off" );
+    @PartModels
+    public static final ResourceLocation MODEL_ON = new ResourceLocation( AppEng.MOD_ID, "part/expanded_processing_pattern_terminal_on" );
+
+    public static final IPartModel MODELS_OFF = new PartModel( MODEL_BASE, MODEL_OFF, MODEL_STATUS_OFF );
+    public static final IPartModel MODELS_ON = new PartModel( MODEL_BASE, MODEL_ON, MODEL_STATUS_ON );
+    public static final IPartModel MODELS_HAS_CHANNEL = new PartModel( MODEL_BASE, MODEL_ON, MODEL_STATUS_HAS_CHANNEL );
+
+    private final AppEngInternalInventory crafting = new AppEngInternalInventory( this, PROCESSING_INPUT_LIMIT );
+
+    private final AppEngInternalInventory output = new AppEngInternalInventory( this, PROCESSING_OUTPUT_LIMIT );
+    private final AppEngInternalInventory pattern = new AppEngInternalInventory( this, 2 );
+
+    @Reflected
+    public PartExpandedProcessingPatternTerminal( final ItemStack is )
+    {
+        super( is );
+    }
+
+    @Override
+    public void readFromNBT( NBTTagCompound data )
+    {
+        super.readFromNBT( data );
+        this.crafting.readFromNBT( data, "processingGrid" );
+        this.pattern.readFromNBT( data, "pattern" );
+        this.output.readFromNBT( data, "outputList" );
+    }
+
+    @Override
+    public void writeToNBT( NBTTagCompound data )
+    {
+        super.writeToNBT( data );
+        this.crafting.writeToNBT( data, "processingGrid" );
+        this.pattern.writeToNBT( data, "pattern" );
+        this.output.writeToNBT( data, "outputList" );
+    }
+
+    @Override
+    public GuiBridge getGui( final EntityPlayer p )
+    {
+        int x = (int) p.posX;
+        int y = (int) p.posY;
+        int z = (int) p.posZ;
+        if( this.getHost().getTile() != null )
+        {
+            x = this.getTile().getPos().getX();
+            y = this.getTile().getPos().getY();
+            z = this.getTile().getPos().getZ();
+        }
+
+        if( GuiBridge.GUI_EXPANDED_PROCESSING_PATTERN_TERMINAL.hasPermissions( this.getHost().getTile(), x, y, z, this.getSide(), p ) )
+        {
+            return GuiBridge.GUI_EXPANDED_PROCESSING_PATTERN_TERMINAL;
+        }
+        return GuiBridge.GUI_ME;
+    }
+
+    @Override
+    public void onChangeInventory( final IItemHandler inv, final int slot, final InvOperation mc, final ItemStack removedStack, final ItemStack newStack )
+    {
+        if( inv == this.pattern && slot == 1 )
+        {
+            final ItemStack is = this.pattern.getStackInSlot( 1 );
+            if( !is.isEmpty() && is.getItem() instanceof ICraftingPatternItem )
+            {
+                final ICraftingPatternItem pattern = (ICraftingPatternItem) is.getItem();
+                final ICraftingPatternDetails details = pattern.getPatternForItem( is, this.getHost().getTile().getWorld() );
+                if( details != null )
+                {
+                    for( int x = 0; x < this.crafting.getSlots() && x < details.getInputs().length; x++ )
+                    {
+                        final IAEItemStack item = details.getInputs()[x];
+                        this.crafting.setStackInSlot( x, item == null ? ItemStack.EMPTY : item.createItemStack() );
+                    }
+
+                    for( int x = 0; x < this.output.getSlots() && x < details.getOutputs().length; x++ )
+                    {
+                        final IAEItemStack item = details.getOutputs()[x];
+                        this.output.setStackInSlot( x, item == null ? ItemStack.EMPTY : item.createItemStack() );
+                    }
+                }
+            }
+        }
+
+        this.getHost().markForSave();
+    }
+
+    @Override
+    public IItemHandler getInventoryByName( final String name )
+    {
+        if( name.equals( "crafting" ) )
+        {
+            return this.crafting;
+        }
+        if( name.equals( "output" ) )
+        {
+            return this.output;
+        }
+        if( name.equals( "pattern" ) )
+        {
+            return this.pattern;
+        }
+        return super.getInventoryByName( name );
+    }
+
+    @Override
+    public IPartModel getStaticModels()
+    {
+        return this.selectModel( MODELS_OFF, MODELS_ON, MODELS_HAS_CHANNEL );
+    }
+}
+

src/main/java/appeng/tile/inventory/AppEngInternalInventory.java

@@ -123,7 +123,7 @@ public class AppEngInternalInventory extends ItemStackHandler implements Iterabl
 			ItemStack oldStack = this.previousStack;
 			InvOperation op = InvOperation.SET;
 
-			if( newStack.isEmpty() || oldStack.isEmpty() || ItemStack.areItemsEqual( newStack, oldStack ) )
+			if( newStack.isEmpty() || oldStack.isEmpty() || ( oldStack.getCount() < oldStack.getMaxStackSize() && oldStack.getCount() < this.getSlotLimit( slot ) && ItemStack.areItemsEqual( newStack, oldStack ) ) )
 			{
 				if( newStack.getCount() > oldStack.getCount() )
 				{

src/main/java/appeng/tile/networking/TileEnergyCell.java

@@ -155,7 +155,7 @@ public class TileEnergyCell extends AENetworkTile implements IAEPowerStorage
 			return 0;
 		}
 
-		if( this.internalCurrentPower < 0.01 && amt > 0.01 )
+		if( this.internalCurrentPower < 0.01 && amt > 0 )
 		{
 			this.getProxy().getNode().getGrid().postEvent( new MENetworkPowerStorage( this, PowerEventType.PROVIDE_POWER ) );
 		}
@@ -217,7 +217,7 @@ public class TileEnergyCell extends AENetworkTile implements IAEPowerStorage
 
 		final boolean wasFull = this.internalCurrentPower >= this.getInternalMaxPower() - 0.001;
 
-		if( wasFull && amt > 0.001 )
+		if( wasFull && amt > 0 )
 		{
 			try
 			{

src/main/java/appeng/tile/storage/TileChest.java

@@ -26,6 +26,8 @@ import java.util.List;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
+import appeng.me.storage.BasicCellInventoryHandler;
+import appeng.me.storage.CreativeCellInventory;
 import io.netty.buffer.ByteBuf;
 
 import net.minecraft.entity.player.EntityPlayer;
@@ -493,12 +495,12 @@ public class TileChest extends AENetworkPowerTile implements IMEChest, ITerminal
 
 			try
 			{
-				this.getProxy().getGrid().postEvent( new MENetworkCellArrayUpdate() );
 				if( this.getProxy().isActive() )
 				{
 					final IStorageGrid gs = this.getProxy().getStorage();
 					Platform.postChanges( gs, removed, added, this.mySrc );
 				}
+				this.getProxy().getGrid().postEvent( new MENetworkCellArrayUpdate() );
 			}
 			catch( final GridAccessException ignored )
 			{
@@ -735,7 +737,15 @@ public class TileChest extends AENetworkPowerTile implements IMEChest, ITerminal
 			{
 				return input;
 			}
-			return super.injectItems( input, mode, src );
+			T injected = super.injectItems( input, mode, src );
+			if (mode == Actionable.MODULATE && ( injected == null || injected.getStackSize() != input.getStackSize() ))
+			{
+				if( TileChest.this.getProxy().isActive() && this.getInternalHandler().getCellInv() != null )
+				{
+					TileChest.this.cellHandler.postChangesToListeners(Collections.singletonList( input.copy().setStackSize( input.getStackSize() - ( injected == null ? 0 : injected.getStackSize() ) ) ), TileChest.this.mySrc  );
+				}
+			}
+			return injected;
 		}
 
 		private boolean securityCheck( final EntityPlayer player, final SecurityPermissions requiredPermission )
@@ -779,7 +789,15 @@ public class TileChest extends AENetworkPowerTile implements IMEChest, ITerminal
 			{
 				return null;
 			}
-			return super.extractItems( request, mode, src );
+			T extracted = super.extractItems( request, mode, src );
+			if( mode == Actionable.MODULATE && extracted != null )
+			{
+				if( TileChest.this.getProxy().isActive() && this.getInternalHandler().getCellInv() != null )
+				{
+					TileChest.this.cellHandler.postChangesToListeners(Collections.singletonList( request.copy().setStackSize( -extracted.getStackSize() ) ), TileChest.this.mySrc  );
+				}
+			}
+			return extracted;
 		}
 	}
 

src/main/java/appeng/tile/storage/TileDrive.java

@@ -263,12 +263,12 @@ public class TileDrive extends AENetworkInvTile implements IChestOrDrive, IPrior
 
 		try
 		{
-			this.getProxy().getGrid().postEvent( new MENetworkCellArrayUpdate() );
 			if( this.getProxy().isActive() )
 			{
 				final IStorageGrid gs = this.getProxy().getStorage();
 				Platform.postChanges( gs, removed, added, this.mySrc );
 			}
+			this.getProxy().getGrid().postEvent( new MENetworkCellArrayUpdate() );
 		}
 		catch( final GridAccessException ignored )
 		{

src/main/java/appeng/util/item/AEItemStack.java

@@ -53,6 +53,7 @@ public final class AEItemStack extends AEStack<IAEItemStack> implements IAEItemS
     private String displayName;
     @SideOnly(Side.CLIENT)
     private List<String> tooltip;
+    private ItemStack cachedItemStack;
 
     private AEItemStack(final AEItemStack is) {
         this.setStackSize(is.getStackSize());
@@ -250,6 +251,18 @@ public final class AEItemStack extends AEStack<IAEItemStack> implements IAEItemS
         return this.isSameType(is);
     }
 
+    @Override
+    public ItemStack getCachedItemStack()
+    {
+        return this.cachedItemStack;
+    }
+
+    @Override
+    public void setCachedItemStack( ItemStack is )
+    {
+        this.cachedItemStack = is;
+    }
+
     @Override
     public String toString() {
         return this.getStackSize() + "x" + this.getDefinition().getItem().getRegistryName();

src/main/java/appeng/util/item/OreHelper.java

@@ -19,13 +19,8 @@
 package appeng.util.item;
 
 
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
+import java.util.*;
+import java.util.concurrent.ConcurrentMap;
 
 import com.google.common.cache.CacheBuilder;
 import com.google.common.cache.CacheLoader;
@@ -116,7 +111,7 @@ public class OreHelper
 	boolean sameOre( final AEItemStack aeItemStack, final IAEItemStack is )
 	{
 		final OreReference a = aeItemStack.getOre().orElse( null );
-		final OreReference b = aeItemStack.getOre().orElse( null );
+		final OreReference b = ( (AEItemStack) is ).getOre().orElse( null );
 
 		return this.sameOre( a, b );
 	}
@@ -160,8 +155,53 @@ public class OreHelper
 				}
 			}
 			return false;
-		} )
-				.orElse( false );
+		} ).orElse( false );
+	}
+
+	public Set<Integer> getMatchingOre( String allow )
+	{
+		List<String> matchingOres = new ArrayList<>();
+		ConcurrentMap<String, List<ItemStack>> oreKeys = oreDictCache.asMap();
+
+		oreKeys.forEach( ( s, l ) -> {
+
+			if( allow.startsWith( "*" ) && allow.endsWith( "*" ) )
+			{
+				if( s.contains( allow.substring( 1, allow.length() - 1 ) ) )
+				{
+					matchingOres.add( s );
+				}
+			}
+			else if( allow.startsWith( "*" ) )
+			{
+				if( s.endsWith( allow.substring( 1 ) ) )
+				{
+					matchingOres.add( s );
+				}
+			}
+			else if( allow.endsWith( "*" ) )
+			{
+				if( s.startsWith( allow.substring( 0, allow.length() - 1 ) ) )
+				{
+					matchingOres.add( s );
+				}
+			}
+			else
+			{
+				if( s.matches( allow ) )
+				{
+					matchingOres.add( s );
+				}
+			}
+		} );
+
+		Set<Integer> oreIDs = new HashSet<>();
+		for( String matchingOre : matchingOres )
+		{
+			oreIDs.add( OreDictionary.getOreID( matchingOre ) );
+		}
+
+		return oreIDs;
 	}
 
 	List<ItemStack> getCachedOres( final String oreName )

src/main/java/appeng/util/item/OreReference.java

@@ -65,8 +65,8 @@ public class OreReference
 		return this.aeOtherOptions;
 	}
 
-	Collection<Integer> getOres()
-	{
-		return this.ores;
-	}
+	public Collection<Integer> getOres()
+    {
+        return this.ores;
+    }
 }

src/main/java/appeng/util/prioritylist/OreDictPriorityList.java

@@ -0,0 +1,51 @@
+package appeng.util.prioritylist;
+
+import appeng.api.storage.data.IAEStack;
+import appeng.util.item.AEItemStack;
+import appeng.util.item.OreReference;
+
+import java.util.ArrayList;
+import java.util.Set;
+
+
+public class OreDictPriorityList<T extends IAEStack<T>> implements IPartitionList<T>
+{
+    private final Set<Integer> oreIDs;
+    private final String oreMatch;
+
+    public OreDictPriorityList( Set<Integer> oreIDs, String oreMatch )
+    {
+        this.oreIDs = oreIDs;
+        this.oreMatch = oreMatch;
+    }
+
+    @Override
+    public boolean isListed( final T input )
+    {
+        OreReference or = ( (AEItemStack) input ).getOre().orElse( null );
+        if( or != null )
+        {
+            for( Integer oreID : or.getOres() )
+            {
+                if( this.oreIDs.contains( oreID ) )
+                {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public boolean isEmpty()
+    {
+        return oreMatch.equals( "" );
+    }
+
+    @Override
+    public Iterable<T> getItems()
+    {
+        return new ArrayList<>();
+    }
+
+}

src/main/resources/assets/appliedenergistics2/lang/en_us.lang

@@ -133,6 +133,7 @@ gui.appliedenergistics2.SecurityCardEditor=Biometric Card Editor
 gui.appliedenergistics2.Encoded=Encoded
 gui.appliedenergistics2.Priority=Priority
 gui.appliedenergistics2.StorageBus=Storage Bus
+gui.appliedenergistics2.OreDictStorageBus=Ore Dictionary Storage Bus
 gui.appliedenergistics2.StorageBusFluids=Fluid Storage Bus
 gui.appliedenergistics2.EnergyDrain=Passive Drain
 gui.appliedenergistics2.Installed=Installed
@@ -405,8 +406,10 @@ waila.appliedenergistics2.Showing=Showing
 waila.appliedenergistics2.Contains=Contains
 waila.appliedenergistics2.Channels=%1$d of %2$d Channels
 waila.appliedenergistics2.P2PUnlinked=Unlinked
-waila.appliedenergistics2.P2PInputOneOutput=Linked (Input Side)
-waila.appliedenergistics2.P2PInputManyOutputs=Linked (Input Side) - %d Outputs
+waila.appliedenergistics2.p2p_input_one_output=Linked (Input Side) - 1 Output
+waila.appliedenergistics2.p2p_input_many_outputs=Linked (Input Side) - %d Outputs
+waila.appliedenergistics2.p2p_output_one_input=Linked (Output Side) - 1 Input
+waila.appliedenergistics2.p2p_output_many_inputs=Linked (Output Side) - %d Inputs
 waila.appliedenergistics2.P2POutput=Linked (Output Side)
 
 // TheOneProbe
@@ -420,8 +423,10 @@ theoneprobe.appliedenergistics2.showing=Showing
 theoneprobe.appliedenergistics2.contains=Contains
 theoneprobe.appliedenergistics2.channels=%1$d of %2$d Channels
 theoneprobe.appliedenergistics2.p2p_unlinked=Unlinked
-theoneprobe.appliedenergistics2.p2p_input_one_output=Linked (Input Side)
+theoneprobe.appliedenergistics2.p2p_input_one_output=Linked (Input Side) - 1 Output
 theoneprobe.appliedenergistics2.p2p_input_many_outputs=Linked (Input Side) - %d Outputs
+theoneprobe.appliedenergistics2.p2p_output_one_input=Linked (Output Side) - 1 Input
+theoneprobe.appliedenergistics2.p2p_output_many_inputs=Linked (Output Side) - %d Inputs
 theoneprobe.appliedenergistics2.p2p_output=Linked (Output Side)
 theoneprobe.appliedenergistics2.p2p_frequency=Frequency: %1$s
 theoneprobe.appliedenergistics2.stored_energy=%1$d / %2$d
@@ -531,8 +536,10 @@ item.appliedenergistics2.multi_part.level_emitter.name=ME Level Emitter
 item.appliedenergistics2.multi_part.fluid_level_emitter.name=ME Fluid Level Emitter
 item.appliedenergistics2.multi_part.p2p_tunnel.name=P2P Tunnel
 item.appliedenergistics2.multi_part.pattern_terminal.name=ME Pattern Terminal
+item.appliedenergistics2.multi_part.expanded_processing_pattern_terminal.name=ME Extended Processing Pattern Terminal
 item.appliedenergistics2.multi_part.quartz_fiber.name=Quartz Fiber
 item.appliedenergistics2.multi_part.storage_bus.name=ME Storage Bus
+item.appliedenergistics2.multi_part.oredict_storage_bus.name=ME OreDict Storage Bus
 item.appliedenergistics2.multi_part.fluid_storage_bus.name=ME Fluid Storage Bus
 item.appliedenergistics2.multi_part.terminal.name=ME Terminal
 item.appliedenergistics2.multi_part.inverted_toggle_bus.name=ME Inverted Toggle Bus

src/main/resources/assets/appliedenergistics2/models/item/part/expanded_processing_pattern_terminal.json

@@ -0,0 +1,9 @@
+{
+    "parent": "appliedenergistics2:item/part/display",
+    "textures": {
+        "front": "appliedenergistics2:items/part/expanded_processing_pattern_terminal",
+        "front_bright": "appliedenergistics2:parts/expanded_processing_pattern_terminal_bright",
+        "front_medium": "appliedenergistics2:parts/expanded_processing_pattern_terminal_medium",
+        "front_dark": "appliedenergistics2:parts/pattern_terminal_dark"
+    }
+}

src/main/resources/assets/appliedenergistics2/models/item/part/oredict_storage_bus.json

@@ -0,0 +1,106 @@
+{
+    "parent": "appliedenergistics2:item/part/part",
+    "textures": {
+        "sides": "appliedenergistics2:parts/storage_bus_sides",
+        "back": "appliedenergistics2:parts/storage_bus_back",
+        "front": "appliedenergistics2:items/part/oredict_storage_bus"
+    },
+    "elements": [
+        {
+            "from": [
+                3,
+                3,
+                6
+            ],
+            "to": [
+                13,
+                13,
+                7
+            ],
+            "faces": {
+                "north": {
+                    "texture": "#front"
+                },
+                "south": {
+                    "texture": "#back"
+                },
+                "east": {
+                    "texture": "#sides"
+                },
+                "west": {
+                    "texture": "#sides"
+                },
+                "up": {
+                    "texture": "#sides"
+                },
+                "down": {
+                    "texture": "#sides"
+                }
+            }
+        },
+        {
+            "from": [
+                2,
+                2,
+                7
+            ],
+            "to": [
+                14,
+                14,
+                8
+            ],
+            "faces": {
+                "north": {
+                    "texture": "#front"
+                },
+                "south": {
+                    "texture": "#back"
+                },
+                "east": {
+                    "texture": "#sides"
+                },
+                "west": {
+                    "texture": "#sides"
+                },
+                "up": {
+                    "texture": "#sides"
+                },
+                "down": {
+                    "texture": "#sides"
+                }
+            }
+        },
+        {
+            "from": [
+                5,
+                5,
+                8
+            ],
+            "to": [
+                11,
+                11,
+                10
+            ],
+            "faces": {
+                "north": {
+                    "texture": "#front"
+                },
+                "south": {
+                    "texture": "#back"
+                },
+                "east": {
+                    "texture": "#sides"
+                },
+                "west": {
+                    "texture": "#sides"
+                },
+                "up": {
+                    "texture": "#sides"
+                },
+                "down": {
+                    "texture": "#sides"
+                }
+            }
+        }
+    ]
+}

src/main/resources/assets/appliedenergistics2/models/part/expanded_processing_pattern_terminal_off.json

@@ -0,0 +1,8 @@
+{
+    "parent": "appliedenergistics2:part/display_off",
+    "textures": {
+        "lightsBright": "appliedenergistics2:parts/expanded_processing_pattern_terminal_bright",
+        "lightsMedium": "appliedenergistics2:parts/expanded_processing_pattern_terminal_medium",
+        "lightsDark": "appliedenergistics2:parts/pattern_terminal_dark"
+    }
+}

src/main/resources/assets/appliedenergistics2/models/part/expanded_processing_pattern_terminal_on.json

@@ -0,0 +1,76 @@
+{
+    "ae2_uvl_marker": true,
+    "textures": {
+        "lightsBright": "appliedenergistics2:parts/expanded_processing_pattern_terminal_bright",
+        "lightsMedium": "appliedenergistics2:parts/expanded_processing_pattern_terminal_medium",
+        "lightsDark": "appliedenergistics2:parts/pattern_terminal_dark"
+    },
+    "elements": [
+        {
+            "from": [
+                2,
+                2,
+                0
+            ],
+            "to": [
+                14,
+                14,
+                2
+            ],
+            "faces": {
+                "north": {
+                    "texture": "#lightsBright",
+                    "tintindex": 3,
+                    "uvlightmap": {
+                        "sky": 0.007,
+                        "block": 0.007
+                    }
+                }
+            }
+        },
+        {
+            "from": [
+                2,
+                2,
+                0
+            ],
+            "to": [
+                14,
+                14,
+                2
+            ],
+            "faces": {
+                "north": {
+                    "texture": "#lightsMedium",
+                    "tintindex": 2,
+                    "uvlightmap": {
+                        "sky": 0.007,
+                        "block": 0.007
+                    }
+                }
+            }
+        },
+        {
+            "from": [
+                2,
+                2,
+                0
+            ],
+            "to": [
+                14,
+                14,
+                2
+            ],
+            "faces": {
+                "north": {
+                    "texture": "#lightsDark",
+                    "tintindex": 1,
+                    "uvlightmap": {
+                        "sky": 0.007,
+                        "block": 0.007
+                    }
+                }
+            }
+        }
+    ]
+}

src/main/resources/assets/appliedenergistics2/models/part/oredict_storage_bus_base.json

@@ -0,0 +1,130 @@
+{
+    "textures": {
+        "sides": "appliedenergistics2:parts/storage_bus_sides",
+        "sidesStatus": "appliedenergistics2:parts/monitor_sides_status",
+        "back": "appliedenergistics2:parts/storage_bus_back",
+        "front": "appliedenergistics2:items/part/oredict_storage_bus",
+        "particle": "appliedenergistics2:parts/storage_bus_back"
+    },
+    "elements": [
+        {
+            "from": [
+                3,
+                3,
+                0
+            ],
+            "to": [
+                13,
+                13,
+                1
+            ],
+            "faces": {
+                "down": {
+                    "texture": "#sides"
+                },
+                "up": {
+                    "texture": "#sides"
+                },
+                "south": {
+                    "texture": "#back"
+                },
+                "east": {
+                    "texture": "#sides"
+                },
+                "north": {
+                    "texture": "#front"
+                },
+                "west": {
+                    "texture": "#sides"
+                }
+            }
+        },
+        {
+            "from": [
+                2,
+                2,
+                1
+            ],
+            "to": [
+                14,
+                14,
+                2
+            ],
+            "faces": {
+                "down": {
+                    "texture": "#sides"
+                },
+                "up": {
+                    "texture": "#sides"
+                },
+                "south": {
+                    "texture": "#back"
+                },
+                "east": {
+                    "texture": "#sides"
+                },
+                "north": {
+                    "texture": "#front"
+                },
+                "west": {
+                    "texture": "#sides"
+                }
+            }
+        },
+        {
+            "from": [
+                5,
+                5,
+                3
+            ],
+            "to": [
+                11,
+                11,
+                4
+            ],
+            "faces": {
+                "down": {
+                    "texture": "#sides"
+                },
+                "up": {
+                    "texture": "#sides"
+                },
+                "south": {
+                    "texture": "#back"
+                },
+                "east": {
+                    "texture": "#sides"
+                },
+                "west": {
+                    "texture": "#sides"
+                }
+            }
+        },
+        {
+            "from": [
+                5,
+                5,
+                2
+            ],
+            "to": [
+                11,
+                11,
+                3
+            ],
+            "faces": {
+                "down": {
+                    "texture": "#sides"
+                },
+                "up": {
+                    "texture": "#sides"
+                },
+                "east": {
+                    "texture": "#sides"
+                },
+                "west": {
+                    "texture": "#sides"
+                }
+            }
+        }
+    ]
+}

src/main/resources/assets/appliedenergistics2/recipes/network/parts/terminal_expanded_processing.json

@@ -0,0 +1,41 @@
+{
+  "conditions": [
+    {
+      "type": "forge:and",
+      "values": [
+        {
+          "type": "appliedenergistics2:part_exists",
+          "part": "part.pattern_terminal"
+        },
+        {
+          "type": "appliedenergistics2:material_exists",
+          "material": "material.calculation_processor"
+        }
+      ]
+    }
+  ],
+  "result": {
+    "type": "appliedenergistics2:part",
+    "part": "part.expanded_processing_pattern_terminal"
+  },
+  "type": "appliedenergistics2:part_shaped",
+  "pattern": [
+    "c c",
+    "tft",
+    "c c"
+  ],
+  "key": {
+    "f": {
+      "type": "appliedenergistics2:part",
+      "part": "cable_glass.fluix"
+    },
+    "t": {
+      "type": "appliedenergistics2:part",
+      "part": "part.pattern_terminal"
+    },
+    "c": {
+      "type": "appliedenergistics2:part",
+      "part": "material.calculation_processor"
+    }
+  }
+}