resonant-induction/archive/java/resonantinduction/mechanical/fluid/FluidCraftingHandler.java

299 lines
10 KiB
Java
Raw Normal View History

package resonantinduction.mechanical.fluid;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import net.minecraft.block.Block;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidRegistry;
import net.minecraftforge.fluids.FluidStack;
import resonantinduction.mechanical.fluid.network.IFluidRecipeCrafter;
import resonantinduction.mechanical.fluid.network.FluidRecipeInfo.SimpleFluidRecipe;
import calclavia.lib.utility.FluidHelper;
import com.builtbroken.common.Pair;
import com.builtbroken.common.Triple;
/**
* Handles all kinds of process involving mixing Fluids with other fluids and/or Items, Blocks,
* ItemStack, or Liquids
*
* @author DarkGuardsman
*/
public class FluidCraftingHandler
{
/** Map of results of two different liquids merging */
public static HashMap<Pair<Object, Object>, Object> fluidMergeResults = new HashMap<Pair<Object, Object>, Object>();
static
{
registerRecipe(FluidRegistry.LAVA, FluidRegistry.WATER, Block.obsidian);
registerRecipe(FluidRegistry.WATER, FluidRegistry.LAVA, Block.cobblestone);
}
/**
* Creates a very basic A + B = C result for mixing two objects together. Suggest that the use
* of a SimpleFluidRecipe i used instead to create a more refined fluid mixing that takes into
* account ratios, and fluid volumes
*/
public static void registerRecipe(Object a, Object b, Object c)
{
if (a != null && b != null && c != null)
{
registerFluidRecipe(new SimpleFluidRecipe(a, b, c));
}
}
public static void registerFluidRecipe(SimpleFluidRecipe recipe)
{
if (recipe != null && recipe.recipeObjectA != null && recipe.recipeObjectB != null && recipe.recipeObjectC != null)
{
if (!fluidMergeResults.containsKey(new Pair<Object, Object>(recipe.recipeObjectA, recipe.recipeObjectB)))
{
fluidMergeResults.put(new Pair<Object, Object>(recipe.recipeObjectA, recipe.recipeObjectB), recipe);
}
if (recipe.canBeReversed)
{
if (!fluidMergeResults.containsKey(new Pair<Object, Object>(recipe.recipeObjectB, recipe.recipeObjectA)))
{
fluidMergeResults.put(new Pair<Object, Object>(recipe.recipeObjectB, recipe.recipeObjectA), recipe);
}
}
}
}
public static void loadPotionRecipes()
{
// TODO load the process by which a potion would be created threw fliud crafting
}
/**
* Does the fluid recipe crafting for the crafter object. Requires that the object fully use all
* methods from the #IFluidRecipeCrafter
*
* @param crafter - crafting object, recommend it be a tile but can be anything as long as the
* method are used correctly. In some recipe cases when the setRecipeObjectContent nothing will
* be used. If result is null assume not crafting was performed. If there is a result the
* crafter couldn't use the output to reduce the input values. From here the IFluidRecipeCrafter
* will need to process the output and decress the input values correctly
*/
public static void craft(IFluidRecipeCrafter crafter)
{
Object received = crafter.getReceivingObjectStack();
int receivedVolume = 0;
Object input = crafter.getInputObjectStack();
int inputVolume = 0;
if (crafter != null && received != null && input != null)
{
// Trip input values so they will match the correct mapped values
if (received instanceof FluidStack)
{
receivedVolume = ((FluidStack) received).amount;
received = FluidHelper.getStack((FluidStack) received, 1);
}
if (received instanceof ItemStack)
{
receivedVolume = ((ItemStack) received).stackSize;
((ItemStack) received).stackSize = 1;
}
if (input instanceof FluidStack)
{
inputVolume = ((FluidStack) input).amount;
input = FluidHelper.getStack((FluidStack) input, 1);
}
if (input instanceof ItemStack)
{
receivedVolume = ((ItemStack) input).stackSize;
((ItemStack) input).stackSize = 1;
}
// Get result
Object result = fluidMergeResults.containsKey(new Pair<Object, Object>(crafter.getReceivingObjectStack(), crafter.getInputObjectStack()));
// reset stack sized
if (received instanceof FluidStack)
{
((FluidStack) received).amount = receivedVolume;
}
if (received instanceof ItemStack)
{
((ItemStack) received).stackSize = receivedVolume;
}
if (input instanceof FluidStack)
{
((FluidStack) input).amount = inputVolume;
}
if (input instanceof ItemStack)
{
((ItemStack) input).stackSize = inputVolume;
}
if (result != null)
{
if (result instanceof SimpleFluidRecipe)
{
Triple<Integer, Integer, Pair<Object, Integer>> re = ((SimpleFluidRecipe) result).mix(crafter.getInputObjectStack(), crafter.getInputObjectStack());
crafter.setRecipeObjectContent(received, re.getA(), input, re.getB(), re.getC().left(), re.getC().right());
}
}
crafter.setRecipeObjectContent(received, 0, input, 0, result, 0);
}
}
/** Merges two fluids together that don't result in damage to the network */
public static FluidStack mergeFluidStacks(FluidStack stackOne, FluidStack stackTwo)
{
FluidStack resultStack = null;
if (stackTwo != null && stackOne != null && stackOne.isFluidEqual(stackTwo))
{
resultStack = stackOne.copy();
resultStack.amount += stackTwo.amount;
}
else if (stackOne == null && stackTwo != null)
{
resultStack = stackTwo.copy();
}
else if (stackOne != null && stackTwo == null)
{
resultStack = stackOne.copy();
}
else if (stackTwo != null && stackOne != null && !stackOne.isFluidEqual(stackTwo))
{
System.out.println("preforming fluid merge event");
Object result = fluidMergeResults.get(new Pair<Fluid, Fluid>(stackOne.getFluid(), stackTwo.getFluid()));
/* Try to merge fluids by mod defined rules first */
if (result != null)
{
System.out.println("result = " + result.toString());
if (result instanceof Fluid)
{
resultStack = new FluidStack(((Fluid) result).getID(), stackOne.amount + stackTwo.amount);
}
else if (result instanceof FluidStack)
{
resultStack = ((FluidStack) result).copy();
resultStack.amount = stackOne.amount + stackTwo.amount;
}
else if (result instanceof String && ((String) result).startsWith("Liquid:"))
{
resultStack = new FluidStack(FluidRegistry.getFluid(((String) result).replace("Liquid:", "")), stackOne.amount + stackTwo.amount);
}
else if (result instanceof SimpleFluidRecipe)
{
Triple<Integer, Integer, Pair<Object, Integer>> re = ((SimpleFluidRecipe) result).mix(stackOne, stackTwo);
if (re.getC().left() instanceof FluidStack)
{
resultStack = FluidHelper.getStack((FluidStack) re.getC().left(), re.getC().right());
}
else if (re.getC().left() instanceof FluidStack)
{
resultStack = new FluidStack((Fluid) re.getC().left(), re.getC().right());
}
}
}
if (resultStack == null)
{
System.out.println("Merging fluids into a waste fluid stack");
Fluid waste = FluidRegistry.getFluid("waste");
if (waste == null)
{
System.out.println("[FluidNetworkHelper] Attempted to merge two fluids into a waste fluid stack but Forge fluid registry return null for waste. Possible that waste fluid was disabled or not registered correctly.");
return null;
}
/* If both liquids are waste then copy fluidStack lists then merge */
if (stackTwo.fluidID == waste.getID() && stackOne.fluidID == waste.getID())
{
List<FluidStack> stacks = new ArrayList<FluidStack>();
stacks.addAll(getStacksFromWaste(stackOne.copy()));
stacks.addAll(getStacksFromWaste(stackTwo.copy()));
resultStack = createNewWasteStack(stacks.toArray(new FluidStack[stacks.size()]));
}
else
{
resultStack = createNewWasteStack(stackOne.copy(), stackTwo.copy());
}
}
}
return resultStack;
}
/** Gets the fluidStacks that make up a waste FluidStack */
public static List<FluidStack> getStacksFromWaste(FluidStack wasteStack)
{
List<FluidStack> stacks = new ArrayList<FluidStack>();
if (wasteStack.fluidID == FluidRegistry.getFluidID("waste"))
{
for (int i = 1; i <= wasteStack.tag.getInteger("liquids"); i++)
{
FluidStack readStack = FluidStack.loadFluidStackFromNBT(wasteStack.tag.getCompoundTag("Liquid" + i));
if (readStack != null)
{
stacks.add(readStack);
}
}
}
return stacks;
}
/** Creates a new waste stack from the listed fluidStacks */
public static FluidStack createNewWasteStack(FluidStack... liquids)
{
FluidStack stack = new FluidStack(FluidRegistry.getFluid("waste"), 0);
stack.tag = new NBTTagCompound();
if (liquids != null)
{
int count = 0;
for (int i = 0; i < liquids.length; i++)
{
if (liquids[i] != null)
{
if (!liquids[i].getFluid().equals(stack.getFluid()))
{
count++;
stack.tag.setCompoundTag("Liquids" + count, liquids[i].writeToNBT(new NBTTagCompound()));
stack.amount += liquids[i].amount;
}
else
{
for (FluidStack loadStack : getStacksFromWaste(liquids[i]))
{
count++;
stack.tag.setCompoundTag("Liquids" + count, loadStack.writeToNBT(new NBTTagCompound()));
stack.amount += loadStack.amount;
}
}
}
}
stack.tag.setInteger("liquids", count);
}
return stack;
}
/**
* Gets the result of the merge of the two fluids, order of merge does matter and will produce
* different results.
*
* @param stackOne - Receiving fluid, eg the one that is not moving
* @param stackTwo - Flowing fluid, eg the one moving into the first fluid
* @return Object result of the merge, can be anything from string, ItemStack, Item, Block, or
* enum action
*/
public static Object getMergeResult(FluidStack stackOne, FluidStack stackTwo)
{
FluidStack sampleStackOne, sampleStackTwo;
if (stackOne != null && stackTwo != null && !stackOne.equals(stackTwo))
{
sampleStackOne = FluidHelper.getStack(stackOne, 1);
sampleStackTwo = FluidHelper.getStack(stackTwo, 1);
if (fluidMergeResults.containsKey(new Pair<Object, Object>(sampleStackOne, sampleStackTwo)))
{
return fluidMergeResults.get(new Pair<Object, Object>(sampleStackOne, sampleStackTwo));
}
}
return null;
}
}