Crafting is now possible ( not complete but possible )

2014-06-19 01:28:45 -05:00
parent 32ee57c3a9
commit b8a8f2f202
12 changed files with 455 additions and 27 deletions
@@ -1,19 +1,39 @@
 package appeng.me.cluster.implementations;

+import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedList;
+import java.util.Map;
+import java.util.Map.Entry;

+import net.minecraft.inventory.InventoryCrafting;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+import appeng.api.AEApi;
 import appeng.api.config.Actionable;
+import appeng.api.config.FuzzyMode;
 import appeng.api.networking.IGrid;
 import appeng.api.networking.IGridHost;
 import appeng.api.networking.IGridNode;
+import appeng.api.networking.crafting.ICraftingMedium;
+import appeng.api.networking.crafting.ICraftingPatternDetails;
 import appeng.api.networking.events.MENetworkCraftingCpuChange;
 import appeng.api.networking.security.BaseActionSource;
+import appeng.api.networking.storage.IStorageGrid;
+import appeng.api.storage.IMEInventory;
 import appeng.api.storage.data.IAEItemStack;
 import appeng.api.storage.data.IAEStack;
+import appeng.api.storage.data.IItemList;
 import appeng.api.util.WorldCoord;
+import appeng.container.ContainerNull;
+import appeng.core.AELog;
+import appeng.crafting.CraftBranchFailure;
+import appeng.crafting.CraftingJob;
+import appeng.crafting.MECraftingInventory;
+import appeng.me.cache.CraftingCache;
 import appeng.me.cluster.IAECluster;
 import appeng.tile.crafting.TileCraftingTile;
+import appeng.util.item.AEItemStack;

 public class CraftingCPUCluster implements IAECluster
 {
@@ -22,12 +42,29 @@ public class CraftingCPUCluster implements IAECluster
 	public WorldCoord max;
 	public boolean isDestroyed = false;

+	class TaskProgress
+	{
+
+		int value;
+	};
+
 	private LinkedList<TileCraftingTile> tiles = new LinkedList();

 	int accelerator = 0;
 	private LinkedList<TileCraftingTile> storage = new LinkedList<TileCraftingTile>();
 	private LinkedList<TileCraftingTile> status = new LinkedList<TileCraftingTile>();

+	/**
+	 * crafting job info
+	 */
+	MECraftingInventory inventory = new MECraftingInventory();
+
+	IAEItemStack finalOutput;
+
+	boolean waiting = false;
+	Map<ICraftingPatternDetails, TaskProgress> tasks = new HashMap<ICraftingPatternDetails, TaskProgress>();
+	IItemList<IAEItemStack> waitingFor = AEApi.instance().storage().createItemList();
+
 	@Override
 	public Iterator<IGridHost> getTiles()
 	{
@@ -90,7 +127,9 @@ public class CraftingCPUCluster implements IAECluster
 	{
 		if ( input instanceof IAEItemStack )
 		{
-			// TODO Auto-generated method stub
+			IAEItemStack is = waitingFor.findPrecise( (IAEItemStack) input );
+			if ( is != null && is.getStackSize() > 0 )
+				return true;
 		}
 		return false;
 	}
@@ -99,9 +138,206 @@ public class CraftingCPUCluster implements IAECluster
 	{
 		if ( input instanceof IAEItemStack )
 		{
-			// TODO Auto-generated method stub
+			IAEItemStack what = (IAEItemStack) input;
+			IAEItemStack is = waitingFor.findPrecise( what );
+
+			if ( is != null && is.getStackSize() > 0 )
+			{
+				waiting = false;
+
+				if ( is.getStackSize() >= input.getStackSize() )
+				{
+					is.decStackSize( input.getStackSize() );
+
+					if ( finalOutput.equals( input ) )
+						return input; // ignore it.
+
+					return inventory.injectItems( what, Actionable.MODULATE, src );
+				}
+
+				IAEItemStack insert = what.copy();
+				insert.setStackSize( is.getStackSize() );
+				what.decStackSize( is.getStackSize() );
+				is.setStackSize( 0 );
+
+				if ( finalOutput.equals( input ) )
+					return input; // ignore it.
+
+				inventory.injectItems( insert, Actionable.MODULATE, src );
+
+				return what;
+			}
 		}
+
 		return input;
 	}

+	private boolean canCraft(IAEItemStack[] condencedInputs)
+	{
+		for (IAEItemStack is : condencedInputs)
+		{
+			IAEItemStack avail = inventory.extractItems( is, Actionable.SIMULATE, null );
+			if ( avail == null || avail.getStackSize() < is.getStackSize() )
+				return false;
+		}
+		return true;
+	}
+
+	public void updateCraftingLogic(IGrid grid, CraftingCache cc)
+	{
+		if ( waiting || tasks.isEmpty() ) // nothing to do here...
+			return;
+
+		int remainingOperations = accelerator + 1;
+		boolean didsomething = false;
+
+		for (Entry<ICraftingPatternDetails, TaskProgress> e : tasks.entrySet())
+		{
+			if ( e.getValue().value <= 0 )
+				continue;
+
+			ICraftingPatternDetails details = e.getKey();
+			if ( canCraft( details.getCondencedInputs() ) )
+			{
+				InventoryCrafting ic = null;
+
+				for (ICraftingMedium m : cc.getMediums( e.getKey() ))
+				{
+					if ( !m.isBusy() )
+					{
+						if ( ic == null )
+						{
+							ic = new InventoryCrafting( new ContainerNull(), 3, 3 );
+
+							IAEItemStack[] input = details.getInputs();
+							for (int x = 0; x < input.length; x++)
+							{
+								if ( input[x] != null )
+								{
+									boolean found = true;
+
+									if ( details.isCraftable() )
+									{
+										for (IAEItemStack fuzz : inventory.getItemList().findFuzzy( input[x], FuzzyMode.IGNORE_ALL ))
+										{
+											IAEItemStack ais = inventory.extractItems( fuzz, Actionable.MODULATE, null );
+											ItemStack is = ais == null ? null : ais.getItemStack();
+
+											if ( is != null && details.isValidItemForSlot( x, is, getWorld() ) )
+											{
+												ic.setInventorySlotContents( x, is );
+												found = true;
+												break;
+											}
+										}
+									}
+									else
+									{
+										IAEItemStack ais = inventory.extractItems( input[x].copy(), Actionable.MODULATE, null );
+										ItemStack is = ais == null ? null : ais.getItemStack();
+
+										if ( is != null )
+										{
+											ic.setInventorySlotContents( x, is );
+											found = true;
+											continue;
+										}
+									}
+
+									if ( !found )
+										break;
+								}
+							}
+						}
+
+						if ( m.pushPattern( details, ic ) )
+						{
+							didsomething = true;
+							remainingOperations--;
+
+							for (IAEItemStack out : details.getCondencedOutputs())
+								waitingFor.add( out.copy() );
+
+							ic = null; // hand off complete!
+
+							e.getValue().value--;
+							if ( e.getValue().value <= 0 )
+								continue;
+
+							if ( remainingOperations == 0 )
+								return;
+						}
+					}
+				}
+
+				if ( ic != null )
+				{
+					// put stuff back..
+					for (int x = 0; x < ic.getSizeInventory(); x++)
+					{
+						ItemStack is = ic.getStackInSlot( x );
+						if ( is != null )
+							inventory.injectItems( AEItemStack.create( is ), Actionable.MODULATE, null );
+					}
+				}
+			}
+		}
+
+		if ( remainingOperations > 0 && didsomething == false )
+			waiting = true;
+	}
+
+	private World getWorld()
+	{
+		return null;
+	}
+
+	public boolean submitJob(IGrid g, CraftingJob job, BaseActionSource src)
+	{
+		Iterator<Entry<ICraftingPatternDetails, TaskProgress>> i = tasks.entrySet().iterator();
+		while (i.hasNext())
+		{
+			if ( i.next().getValue().value <= 0 )
+				i.remove();
+		}
+
+		if ( !tasks.isEmpty() || !waitingFor.isEmpty() )
+			return false;
+
+		IStorageGrid sg = g.getCache( IStorageGrid.class );
+		IMEInventory<IAEItemStack> storage = sg.getItemInventory();
+		MECraftingInventory ci = new MECraftingInventory( storage, true, false, false );
+
+		try
+		{
+			job.tree.setJob( ci, this, src );
+			ci.commit( src );
+			finalOutput = job.getOutput();
+			waiting = false;
+			return true;
+		}
+		catch (CraftBranchFailure e)
+		{
+			tasks.clear();
+			inventory.getItemList().resetStatus();
+			AELog.error( e );
+		}
+
+		return false;
+	}
+
+	public void addStorage(IAEItemStack extractItems)
+	{
+		inventory.injectItems( extractItems, Actionable.MODULATE, null );
+	}
+
+	public void addCrafting(ICraftingPatternDetails details, long crafts)
+	{
+		TaskProgress i = tasks.get( details );
+
+		if ( i == null )
+			tasks.put( details, i = new TaskProgress() );
+
+		i.value += crafts;
+	}
 }