Testing the creation of hell

src/main/java/WayofTime/alchemicalWizardry/api/alchemy/AlchemicalPotionCreationHandler.java

@@ -0,0 +1,79 @@
+package WayofTime.alchemicalWizardry.api.alchemy;
+
+import net.minecraft.item.ItemStack;
+
+import java.util.ArrayList;
+
+public class AlchemicalPotionCreationHandler
+{
+    public static ArrayList<AlchemyPotionHandlerComponent> registeredPotionEffects = new ArrayList();
+
+    public static void addPotion(ItemStack itemStack, int potionID, int tickDuration)
+    {
+        registeredPotionEffects.add(new AlchemyPotionHandlerComponent(itemStack, potionID, tickDuration));
+    }
+
+    public static int getPotionIDForStack(ItemStack itemStack)
+    {
+        for (AlchemyPotionHandlerComponent aphc : registeredPotionEffects)
+        {
+            if (aphc.compareItemStack(itemStack))
+            {
+                return aphc.getPotionID();
+            }
+        }
+
+        return -1;
+    }
+
+    public static int getPotionTickDurationForStack(ItemStack itemStack)
+    {
+        {
+            for (AlchemyPotionHandlerComponent aphc : registeredPotionEffects)
+            {
+                if (aphc.compareItemStack(itemStack))
+                {
+                    return aphc.getTickDuration();
+                }
+            }
+
+            return -1;
+        }
+    }
+
+    public static boolean containsRegisteredPotionIngredient(ItemStack[] stackList)
+    {
+        for (ItemStack is : stackList)
+        {
+            for (AlchemyPotionHandlerComponent aphc : registeredPotionEffects)
+            {
+                if (aphc.compareItemStack(is))
+                {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    public static int getRegisteredPotionIngredientPosition(ItemStack[] stackList)
+    {
+        int i = 0;
+
+        for (ItemStack is : stackList)
+        {
+            for (AlchemyPotionHandlerComponent aphc : registeredPotionEffects)
+            {
+                if (aphc.compareItemStack(is))
+                {
+                    return i;
+                }
+            }
+
+            i++;
+        }
+
+        return -1;
+    }
+}

src/main/java/WayofTime/alchemicalWizardry/api/alchemy/AlchemyPotionHandlerComponent.java

@@ -0,0 +1,52 @@
+package WayofTime.alchemicalWizardry.api.alchemy;
+
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+
+public class AlchemyPotionHandlerComponent
+{
+    private ItemStack itemStack;
+    private int potionID;
+    private int tickDuration;
+
+    public AlchemyPotionHandlerComponent(ItemStack itemStack, int potionID, int tickDuration)
+    {
+        this.itemStack = itemStack;
+        this.potionID = potionID;
+        this.tickDuration = tickDuration;
+    }
+
+    public boolean compareItemStack(ItemStack comparedStack)
+    {
+        if (comparedStack != null && itemStack != null)
+        {
+            if (comparedStack.getItem() instanceof ItemBlock)
+            {
+                if (itemStack.getItem() instanceof ItemBlock)
+                {
+                    return comparedStack.getItem().equals(itemStack.getItem()) && comparedStack.getItemDamage() == itemStack.getItemDamage();
+                }
+            } else if (!(itemStack.getItem() instanceof ItemBlock))
+            {
+                return comparedStack.getItem().equals(itemStack.getItem()) && comparedStack.getItemDamage() == itemStack.getItemDamage();
+            }
+        }
+
+        return false;
+    }
+
+    public ItemStack getItemStack()
+    {
+        return itemStack;
+    }
+
+    public int getPotionID()
+    {
+        return this.potionID;
+    }
+
+    public int getTickDuration()
+    {
+        return this.tickDuration;
+    }
+}

src/main/java/WayofTime/alchemicalWizardry/api/alchemy/AlchemyPotionHelper.java

@@ -0,0 +1,76 @@
+package WayofTime.alchemicalWizardry.api.alchemy;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.potion.Potion;
+import net.minecraft.potion.PotionEffect;
+
+public class AlchemyPotionHelper
+{
+    private int potionID;
+    private int tickDuration;
+    private int concentration;
+    private int durationFactor;
+
+    public AlchemyPotionHelper(int potionID, int tickDuration, int concentration, int durationFactor)
+    {
+        this.potionID = potionID;
+        this.tickDuration = tickDuration;
+        this.concentration = concentration;
+        this.durationFactor = durationFactor;
+    }
+
+    public void setConcentration(int concentration)
+    {
+        this.concentration = concentration;
+    }
+
+    public void setDurationFactor(int durationFactor)
+    {
+        this.durationFactor = durationFactor;
+    }
+
+    public int getPotionID()
+    {
+        return this.potionID;
+    }
+
+    public int getTickDuration()
+    {
+        return this.tickDuration;
+    }
+
+    public int getConcentration()
+    {
+        return this.concentration;
+    }
+
+    public int getdurationFactor()
+    {
+        return this.durationFactor;
+    }
+
+    public PotionEffect getPotionEffect()
+    {
+        if (potionID == Potion.heal.id || potionID == Potion.harm.id)
+        {
+            return (new PotionEffect(potionID, 1, concentration));
+        }
+
+        return (new PotionEffect(potionID, (int) (tickDuration * Math.pow(0.5f, concentration) * Math.pow(8.0f / 3.0f, durationFactor)), concentration));
+    }
+
+    public static AlchemyPotionHelper readEffectFromNBT(NBTTagCompound tagCompound)
+    {
+        return new AlchemyPotionHelper(tagCompound.getInteger("potionID"), tagCompound.getInteger("tickDuration"), tagCompound.getInteger("concentration"), tagCompound.getInteger("durationFactor"));
+    }
+
+    public static NBTTagCompound setEffectToNBT(AlchemyPotionHelper aph)
+    {
+        NBTTagCompound tagCompound = new NBTTagCompound();
+        tagCompound.setInteger("potionID", aph.getPotionID());
+        tagCompound.setInteger("tickDuration", aph.getTickDuration());
+        tagCompound.setInteger("concentration", aph.getConcentration());
+        tagCompound.setInteger("durationFactor", aph.getdurationFactor());
+        return tagCompound;
+    }
+}

src/main/java/WayofTime/alchemicalWizardry/api/alchemy/AlchemyRecipe.java

@@ -0,0 +1,143 @@
+package WayofTime.alchemicalWizardry.api.alchemy;
+
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.oredict.OreDictionary;
+
+public class AlchemyRecipe
+{
+    private ItemStack output;
+    private ItemStack[] recipe;
+    private int bloodOrbLevel;
+    private int amountNeeded;
+
+    public AlchemyRecipe(ItemStack output, int amountNeeded, ItemStack[] recipe, int bloodOrbLevel)
+    {
+        this.output = output;
+        this.recipe = recipe;
+        this.amountNeeded = amountNeeded;
+        this.bloodOrbLevel = bloodOrbLevel;
+    }
+
+    public boolean doesRecipeMatch(ItemStack[] items, int slottedBloodOrbLevel)
+    {
+        if (slottedBloodOrbLevel < bloodOrbLevel)
+        {
+            return false;
+        }
+
+        ItemStack[] recipe = new ItemStack[5];
+
+        if (items.length < 5)
+        {
+            return false;
+        }
+
+        if (this.recipe.length != 5)
+        {
+            ItemStack[] newRecipe = new ItemStack[5];
+
+            for (int i = 0; i < 5; i++)
+            {
+                if (i + 1 > this.recipe.length)
+                {
+                    newRecipe[i] = null;
+                } else
+                {
+                    newRecipe[i] = this.recipe[i];
+                }
+            }
+
+            recipe = newRecipe;
+        } else
+        {
+            recipe = this.recipe;
+        }
+
+        boolean[] checkList = new boolean[5];
+
+        for (int i = 0; i < 5; i++)
+        {
+            checkList[i] = false;
+        }
+
+        for (int i = 0; i < 5; i++)
+        {
+            ItemStack recipeItemStack = recipe[i];
+
+            if (recipeItemStack == null)
+            {
+                continue;
+            }
+
+            boolean test = false;
+
+            for (int j = 0; j < 5; j++)
+            {
+                if (checkList[j])
+                {
+                    continue;
+                }
+
+                ItemStack checkedItemStack = items[j];
+
+                if (checkedItemStack == null)
+                {
+                    continue;
+                }
+
+                boolean quickTest = false;
+
+                if (recipeItemStack.getItem() instanceof ItemBlock)
+                {
+                    if (checkedItemStack.getItem() instanceof ItemBlock)
+                    {
+                        quickTest = true;
+                    }
+                } else if (!(checkedItemStack.getItem() instanceof ItemBlock))
+                {
+                    quickTest = true;
+                }
+
+                if (!quickTest)
+                {
+                    continue;
+                }
+
+                if ((checkedItemStack.getItemDamage() == recipeItemStack.getItemDamage() || OreDictionary.WILDCARD_VALUE == recipeItemStack.getItemDamage()) && checkedItemStack.getItem() == recipeItemStack.getItem())
+                {
+                    test = true;
+                    checkList[j] = true;
+                    break;
+                }
+            }
+
+            if (!test)
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public ItemStack getResult()
+    {
+        return output.copy();
+    }
+
+    public int getAmountNeeded()
+    {
+        return this.amountNeeded;
+    }
+
+    public ItemStack[] getRecipe()
+    {
+        return this.recipe;
+    }
+
+    public int getOrbLevel()
+    {
+        return this.bloodOrbLevel;
+    }
+}

src/main/java/WayofTime/alchemicalWizardry/api/alchemy/AlchemyRecipeRegistry.java

@@ -0,0 +1,85 @@
+package WayofTime.alchemicalWizardry.api.alchemy;
+
+import WayofTime.alchemicalWizardry.api.items.interfaces.IBloodOrb;
+import net.minecraft.item.ItemStack;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class AlchemyRecipeRegistry
+{
+    public static List<AlchemyRecipe> recipes = new ArrayList();
+
+    public static void registerRecipe(ItemStack output, int amountNeeded, ItemStack[] recipe, int bloodOrbLevel)
+    {
+        recipes.add(new AlchemyRecipe(output, amountNeeded, recipe, bloodOrbLevel));
+    }
+
+    public static ItemStack getResult(ItemStack[] recipe, ItemStack bloodOrb)
+    {
+        if (bloodOrb == null)
+        {
+            return null;
+        }
+
+        if (!(bloodOrb.getItem() instanceof IBloodOrb))
+        {
+            return null;
+        }
+
+        int bloodOrbLevel = ((IBloodOrb) bloodOrb.getItem()).getOrbLevel();
+
+        for (AlchemyRecipe ar : recipes)
+        {
+            if (ar.doesRecipeMatch(recipe, bloodOrbLevel))
+            {
+                return (ar.getResult());
+            }
+        }
+
+        return null;
+    }
+
+    public static int getAmountNeeded(ItemStack[] recipe, ItemStack bloodOrb)
+    {
+        if (bloodOrb == null)
+        {
+            return 0;
+        }
+
+        if (!(bloodOrb.getItem() instanceof IBloodOrb))
+        {
+            return 0;
+        }
+
+        int bloodOrbLevel = ((IBloodOrb) bloodOrb.getItem()).getOrbLevel();
+
+        for (AlchemyRecipe ar : recipes)
+        {
+            if (ar.doesRecipeMatch(recipe, bloodOrbLevel))
+            {
+                return (ar.getAmountNeeded());
+            }
+        }
+
+        return 0;
+    }
+
+    public static ItemStack[] getRecipeForItemStack(ItemStack itemStack)
+    {
+        for (AlchemyRecipe ar : recipes)
+        {
+            ItemStack result = ar.getResult();
+
+            if (result != null)
+            {
+                if (result.isItemEqual(itemStack))
+                {
+                    return ar.getRecipe();
+                }
+            }
+        }
+
+        return null;
+    }
+}

src/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/IAlchemyGoggles.java

@@ -0,0 +1,10 @@
+package WayofTime.alchemicalWizardry.api.alchemy.energy;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+public interface IAlchemyGoggles
+{
+    public boolean showIngameHUD(World world, ItemStack stack, EntityPlayer player);
+}

src/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/IReagentContainer.java

@@ -0,0 +1,16 @@
+package WayofTime.alchemicalWizardry.api.alchemy.energy;
+
+public interface IReagentContainer
+{
+    public ReagentStack getReagent();
+
+    public int getReagentStackAmount();
+
+    public int getCapacity();
+
+    public int fill(ReagentStack resource, boolean doFill);
+
+    public ReagentStack drain(int maxDrain, boolean doDrain);
+
+    public ReagentContainerInfo getInfo();
+}

src/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/IReagentHandler.java

@@ -0,0 +1,18 @@
+package WayofTime.alchemicalWizardry.api.alchemy.energy;
+
+import net.minecraftforge.common.util.ForgeDirection;
+
+public interface IReagentHandler
+{
+    int fill(ForgeDirection from, ReagentStack resource, boolean doFill);
+
+    ReagentStack drain(ForgeDirection from, ReagentStack resource, boolean doDrain);
+
+    ReagentStack drain(ForgeDirection from, int maxDrain, boolean doDrain);
+
+    boolean canFill(ForgeDirection from, Reagent reagent);
+
+    boolean canDrain(ForgeDirection from, Reagent reagent);
+
+    ReagentContainerInfo[] getContainerInfo(ForgeDirection from);
+}

src/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/ISegmentedReagentHandler.java

@@ -0,0 +1,14 @@
+package WayofTime.alchemicalWizardry.api.alchemy.energy;
+
+import java.util.Map;
+
+public interface ISegmentedReagentHandler extends IReagentHandler
+{
+    public int getNumberOfTanks();
+
+    public int getTanksTunedToReagent(Reagent reagent);
+
+    public void setTanksTunedToReagent(Reagent reagent, int total);
+
+    public Map<Reagent, Integer> getAttunedTankMap();
+}

src/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/Reagent.java

@@ -0,0 +1,52 @@
+package WayofTime.alchemicalWizardry.api.alchemy.energy;
+
+public class Reagent
+{
+    public final String name;
+
+    public static final int REAGENT_SIZE = 1000;
+
+    private int colourRed = 0;
+    private int colourGreen = 0;
+    private int colourBlue = 0;
+    private int colourIntensity = 255;
+
+    public Reagent(String name)
+    {
+        this.name = name;
+    }
+
+    public void setColour(int red, int green, int blue, int intensity)
+    {
+        this.colourRed = red;
+        this.colourGreen = green;
+        this.colourBlue = blue;
+        this.colourIntensity = intensity;
+    }
+
+    public int getColourRed()
+    {
+        return colourRed;
+    }
+
+    public int getColourGreen()
+    {
+        return colourGreen;
+    }
+
+    public int getColourBlue()
+    {
+        return colourBlue;
+    }
+
+    public int getColourIntensity()
+    {
+        return colourIntensity;
+    }
+
+    @Override
+    public boolean equals(Object o)
+    {
+        return o instanceof Reagent ? this == o && name.equals(((Reagent) o).name) : false;
+    }
+}

src/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/ReagentContainer.java

@@ -0,0 +1,153 @@
+package WayofTime.alchemicalWizardry.api.alchemy.energy;
+
+import net.minecraft.nbt.NBTTagCompound;
+
+public class ReagentContainer implements IReagentContainer
+{
+    protected ReagentStack reagentStack;
+    protected int capacity;
+
+    public ReagentContainer(int capacity)
+    {
+        this(null, capacity);
+    }
+
+    public ReagentContainer(ReagentStack stack, int capacity)
+    {
+        this.reagentStack = stack;
+        this.capacity = capacity;
+    }
+
+    public ReagentContainer(Reagent reagent, int amount, int capacity)
+    {
+        this(new ReagentStack(reagent, amount), capacity);
+    }
+
+    public static ReagentContainer readFromNBT(NBTTagCompound nbt)
+    {
+        ReagentStack reagent = ReagentStack.loadReagentStackFromNBT(nbt);
+        int capacity = nbt.getInteger("capacity");
+
+        if (reagent != null)
+        {
+            return new ReagentContainer(reagent, capacity);
+        } else
+        {
+            return new ReagentContainer(null, capacity);
+        }
+    }
+
+    public NBTTagCompound writeToNBT(NBTTagCompound nbt)
+    {
+        if (reagentStack != null)
+        {
+            reagentStack.writeToNBT(nbt);
+        }
+
+        nbt.setInteger("capacity", capacity);
+
+        return nbt;
+    }
+
+    @Override
+    public ReagentStack getReagent()
+    {
+        return reagentStack;
+    }
+
+    @Override
+    public int getReagentStackAmount()
+    {
+        if (reagentStack == null)
+        {
+            return 0;
+        }
+        return reagentStack.amount;
+    }
+
+    @Override
+    public int getCapacity()
+    {
+        return capacity;
+    }
+
+    @Override
+    public int fill(ReagentStack resource, boolean doFill)
+    {
+        if (resource == null)
+        {
+            return 0;
+        }
+
+        if (!doFill)
+        {
+            if (reagentStack == null)
+            {
+                return Math.min(capacity, resource.amount);
+            }
+
+            if (!reagentStack.isReagentEqual(resource))
+            {
+                return 0;
+            }
+
+            return Math.min(capacity - reagentStack.amount, resource.amount);
+        }
+
+        if (reagentStack == null)
+        {
+            reagentStack = new ReagentStack(resource, Math.min(capacity, resource.amount));
+
+            return reagentStack.amount;
+        }
+
+        if (!reagentStack.isReagentEqual(resource))
+        {
+            return 0;
+        }
+        int filled = capacity - reagentStack.amount;
+
+        if (resource.amount < filled)
+        {
+            reagentStack.amount += resource.amount;
+            filled = resource.amount;
+        } else
+        {
+            reagentStack.amount = capacity;
+        }
+
+        return filled;
+    }
+
+    @Override
+    public ReagentStack drain(int maxDrain, boolean doDrain)
+    {
+        if (reagentStack == null)
+        {
+            return null;
+        }
+
+        int drained = maxDrain;
+        if (reagentStack.amount < drained)
+        {
+            drained = reagentStack.amount;
+        }
+
+        ReagentStack stack = new ReagentStack(reagentStack, drained);
+        if (doDrain)
+        {
+            reagentStack.amount -= drained;
+            if (reagentStack.amount <= 0)
+            {
+                reagentStack = null;
+            }
+        }
+        return stack;
+    }
+
+    @Override
+    public ReagentContainerInfo getInfo()
+    {
+        return new ReagentContainerInfo(this);
+    }
+}

src/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/ReagentContainerInfo.java

@@ -0,0 +1,19 @@
+package WayofTime.alchemicalWizardry.api.alchemy.energy;
+
+public final class ReagentContainerInfo
+{
+    public final ReagentStack reagent;
+    public final int capacity;
+
+    public ReagentContainerInfo(ReagentStack reagent, int capacity)
+    {
+        this.reagent = reagent;
+        this.capacity = capacity;
+    }
+
+    public ReagentContainerInfo(IReagentContainer tank)
+    {
+        this.reagent = tank.getReagent();
+        this.capacity = tank.getCapacity();
+    }
+}

src/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/ReagentRegistry.java

@@ -0,0 +1,174 @@
+package WayofTime.alchemicalWizardry.api.alchemy.energy;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import net.minecraft.item.ItemStack;
+
+public class ReagentRegistry
+{
+    public static Map<String, Reagent> reagentList = new HashMap();
+    public static Map<ItemStack, ReagentStack> itemToReagentMap = new HashMap();
+
+    public static Reagent sanctusReagent;
+    public static Reagent incendiumReagent;
+    public static Reagent aquasalusReagent;
+    public static Reagent magicalesReagent;
+    public static Reagent aetherReagent;
+    public static Reagent crepitousReagent;
+    public static Reagent crystallosReagent;
+    public static Reagent terraeReagent;
+    public static Reagent tenebraeReagent;
+
+    public static Reagent offensaReagent;
+    public static Reagent praesidiumReagent;
+    public static Reagent orbisTerraeReagent;
+    public static Reagent virtusReagent;
+    public static Reagent reductusReagent;
+    public static Reagent potentiaReagent;
+
+    public static void initReagents()
+    {
+        sanctusReagent = new Reagent("sanctus");
+        incendiumReagent = new Reagent("incendium");
+        aquasalusReagent = new Reagent("aquasalus");
+        magicalesReagent = new Reagent("magicales");
+        aetherReagent = new Reagent("aether");
+        crepitousReagent = new Reagent("crepitous");
+        crystallosReagent = new Reagent("crystallos");
+        terraeReagent = new Reagent("terrae");
+        tenebraeReagent = new Reagent("tenebrae");
+        offensaReagent = new Reagent("offensa");
+        praesidiumReagent = new Reagent("praesidium");
+        orbisTerraeReagent = new Reagent("orbisTerrae");
+        virtusReagent = new Reagent("virtus");
+        reductusReagent = new Reagent("reductus");
+        potentiaReagent = new Reagent("potentia");
+
+        sanctusReagent.setColour(255, 255, 0, 255);
+        incendiumReagent.setColour(255, 0, 0, 255);
+        aquasalusReagent.setColour(47, 0, 196, 255);
+        magicalesReagent.setColour(150, 0, 146, 255);
+        aetherReagent.setColour(105, 223, 86, 255);
+        crepitousReagent.setColour(145, 145, 145, 255);
+        crystallosReagent.setColour(135, 255, 231, 255);
+        terraeReagent.setColour(147, 48, 13, 255);
+        tenebraeReagent.setColour(86, 86, 86, 255);
+        offensaReagent.setColour(126, 0, 0, 255);
+        praesidiumReagent.setColour(135, 135, 135, 255);
+        orbisTerraeReagent.setColour(32, 94, 14, 255);
+        virtusReagent.setColour(180, 0, 0, 255);
+        reductusReagent.setColour(20, 93, 2, 255);
+        potentiaReagent.setColour(64, 81, 208, 255);
+
+        registerReagent("sanctus", sanctusReagent);
+        registerReagent("incendium", incendiumReagent);
+        registerReagent("aquasalus", aquasalusReagent);
+        registerReagent("magicales", magicalesReagent);
+        registerReagent("aether", aetherReagent);
+        registerReagent("crepitous", crepitousReagent);
+        registerReagent("crystallos", crystallosReagent);
+        registerReagent("terrae", terraeReagent);
+        registerReagent("tenebrae", tenebraeReagent);
+        registerReagent("offensa", offensaReagent);
+        registerReagent("praesidium", praesidiumReagent);
+        registerReagent("orbisTerrae", orbisTerraeReagent);
+        registerReagent("virtus", virtusReagent);
+        registerReagent("reductus", reductusReagent);
+        registerReagent("potentia", potentiaReagent);
+    }
+
+    public static boolean registerReagent(String key, Reagent reagent)
+    {
+        if (reagentList.containsKey(key) || reagent == null)
+        {
+            return false;
+        }
+
+        reagentList.put(key, reagent);
+
+        return true;
+    }
+
+    public static Reagent getReagentForKey(String key)
+    {
+        if (reagentList.containsKey(key))
+        {
+            return reagentList.get(key);
+        }
+
+        return null;
+    }
+
+    public static String getKeyForReagent(Reagent reagent)
+    {
+        if (reagentList.containsValue(reagent))
+        {
+            Set<Entry<String, Reagent>> set = reagentList.entrySet();
+            for (Entry<String, Reagent> entry : set)
+            {
+                if (entry.getValue().equals(reagent))
+                {
+                    return entry.getKey();
+                }
+            }
+        }
+
+        return "";
+    }
+
+    public static void registerItemAndReagent(ItemStack stack, ReagentStack reagentStack)
+    {
+        itemToReagentMap.put(stack, reagentStack);
+    }
+
+    public static ReagentStack getReagentStackForItem(ItemStack stack)
+    {
+        if (stack == null)
+        {
+            return null;
+        }
+
+        for (Entry<ItemStack, ReagentStack> entry : itemToReagentMap.entrySet())
+        {
+            if (entry.getKey() != null && entry.getKey().isItemEqual(stack))
+            {
+                if (entry.getValue() == null)
+                {
+                    return null;
+                } else
+                {
+                    return entry.getValue().copy();
+                }
+            }
+        }
+
+        return null;
+    }
+
+    public static ItemStack getItemForReagent(Reagent reagent)
+    {
+        if (reagent == null)
+        {
+            return null;
+        }
+
+        for (Entry<ItemStack, ReagentStack> entry : itemToReagentMap.entrySet())
+        {
+            if (entry.getValue() != null && entry.getValue().reagent == reagent)
+            {
+                if (entry.getKey() == null)
+                {
+                    return null;
+                } else
+                {
+                    return entry.getKey().copy();
+                }
+            }
+        }
+
+        return null;
+    }
+}

src/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/ReagentStack.java

@@ -0,0 +1,63 @@
+package WayofTime.alchemicalWizardry.api.alchemy.energy;
+
+import net.minecraft.nbt.NBTTagCompound;
+
+public class ReagentStack
+{
+    public Reagent reagent;
+    public int amount;
+
+    public ReagentStack(Reagent reagent, int amount)
+    {
+        this.reagent = reagent;
+        this.amount = amount;
+    }
+
+    public ReagentStack(ReagentStack reagentStack, int amount)
+    {
+        this(reagentStack.reagent, amount);
+    }
+
+    public static ReagentStack loadReagentStackFromNBT(NBTTagCompound tag)
+    {
+        Reagent reagent = ReagentRegistry.getReagentForKey(tag.getString("Reagent"));
+
+        if (reagent == null)
+        {
+            return null;
+        }
+
+        int amount = tag.getInteger("amount");
+        ReagentStack stack = new ReagentStack(reagent, amount);
+
+        return stack;
+    }
+
+    public NBTTagCompound writeToNBT(NBTTagCompound tag)
+    {
+        tag.setString("Reagent", ReagentRegistry.getKeyForReagent(this.reagent));
+        tag.setInteger("amount", this.amount);
+
+        return tag;
+    }
+
+    public ReagentStack splitStack(int amount)
+    {
+        ReagentStack copyStack = this.copy();
+        int splitAmount = Math.min(amount, this.amount);
+        copyStack.amount = splitAmount;
+        this.amount -= splitAmount;
+
+        return copyStack;
+    }
+
+    public ReagentStack copy()
+    {
+        return new ReagentStack(this.reagent, this.amount);
+    }
+
+    public boolean isReagentEqual(ReagentStack other)
+    {
+        return other != null && this.reagent == other.reagent;
+    }
+}

src/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/TileReagentHandler.java

@@ -0,0 +1,66 @@
+
+package WayofTime.alchemicalWizardry.api.alchemy.energy;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.ForgeDirection;
+
+public class TileReagentHandler extends TileEntity implements IReagentHandler
+{
+    protected ReagentContainer tank = new ReagentContainer(4000);
+
+    @Override
+    public void readFromNBT(NBTTagCompound tag)
+    {
+        super.readFromNBT(tag);
+        tank.readFromNBT(tag);
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound tag)
+    {
+        super.writeToNBT(tag);
+        tank.writeToNBT(tag);
+    }
+
+    /* IReagentHandler */
+    @Override
+    public int fill(ForgeDirection from, ReagentStack resource, boolean doFill)
+    {
+        return tank.fill(resource, doFill);
+    }
+
+    @Override
+    public ReagentStack drain(ForgeDirection from, ReagentStack resource, boolean doDrain)
+    {
+        if (resource == null || !resource.isReagentEqual(tank.getReagent()))
+        {
+            return null;
+        }
+        return tank.drain(resource.amount, doDrain);
+    }
+
+    @Override
+    public ReagentStack drain(ForgeDirection from, int maxDrain, boolean doDrain)
+    {
+        return tank.drain(maxDrain, doDrain);
+    }
+
+    @Override
+    public boolean canFill(ForgeDirection from, Reagent reagent)
+    {
+        return true;
+    }
+
+    @Override
+    public boolean canDrain(ForgeDirection from, Reagent reagent)
+    {
+        return true;
+    }
+
+    @Override
+    public ReagentContainerInfo[] getContainerInfo(ForgeDirection from)
+    {
+        return new ReagentContainerInfo[]{tank.getInfo()};
+    }
+}

src/main/java/WayofTime/alchemicalWizardry/api/alchemy/energy/TileSegmentedReagentHandler.java

@@ -0,0 +1,283 @@
+
+package WayofTime.alchemicalWizardry.api.alchemy.energy;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.Constants;
+import net.minecraftforge.common.util.ForgeDirection;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+public class TileSegmentedReagentHandler extends TileEntity implements ISegmentedReagentHandler
+{
+    protected ReagentContainer[] tanks;
+    protected Map<Reagent, Integer> attunedTankMap;
+
+    public TileSegmentedReagentHandler()
+    {
+        this(1);
+    }
+
+    public TileSegmentedReagentHandler(int numberOfTanks)
+    {
+        this(numberOfTanks, 1000);
+    }
+
+    public TileSegmentedReagentHandler(int numberOfTanks, int tankSize)
+    {
+        super();
+
+        this.attunedTankMap = new HashMap();
+        this.tanks = new ReagentContainer[numberOfTanks];
+        for (int i = 0; i < numberOfTanks; i++)
+        {
+            this.tanks[i] = new ReagentContainer(tankSize);
+        }
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound tag)
+    {
+        super.readFromNBT(tag);
+
+        NBTTagList tagList = tag.getTagList("reagentTanks", Constants.NBT.TAG_COMPOUND);
+
+        int size = tagList.tagCount();
+        this.tanks = new ReagentContainer[size];
+
+        for (int i = 0; i < size; i++)
+        {
+            NBTTagCompound savedTag = tagList.getCompoundTagAt(i);
+            this.tanks[i] = ReagentContainer.readFromNBT(savedTag);
+        }
+
+        NBTTagList attunedTagList = tag.getTagList("attunedTankMap", Constants.NBT.TAG_COMPOUND);
+
+        for (int i = 0; i < attunedTagList.tagCount(); i++)
+        {
+            NBTTagCompound savedTag = attunedTagList.getCompoundTagAt(i);
+            Reagent reagent = ReagentRegistry.getReagentForKey(savedTag.getString("reagent"));
+            this.attunedTankMap.put(reagent, savedTag.getInteger("amount"));
+        }
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound tag)
+    {
+        super.writeToNBT(tag);
+
+        NBTTagList tagList = new NBTTagList();
+
+        for (int i = 0; i < this.tanks.length; i++)
+        {
+            NBTTagCompound savedTag = new NBTTagCompound();
+            if (this.tanks[i] != null)
+            {
+                this.tanks[i].writeToNBT(savedTag);
+            }
+            tagList.appendTag(savedTag);
+        }
+
+        tag.setTag("reagentTanks", tagList);
+
+        NBTTagList attunedTagList = new NBTTagList();
+
+        for (Entry<Reagent, Integer> entry : this.attunedTankMap.entrySet())
+        {
+            NBTTagCompound savedTag = new NBTTagCompound();
+            savedTag.setString("reagent", ReagentRegistry.getKeyForReagent(entry.getKey()));
+            savedTag.setInteger("amount", entry.getValue());
+            attunedTagList.appendTag(savedTag);
+        }
+
+        tag.setTag("attunedTankMap", attunedTagList);
+    }
+
+    /* ISegmentedReagentHandler */
+    @Override
+    public int fill(ForgeDirection from, ReagentStack resource, boolean doFill)
+    {
+        int totalFill = 0;
+
+        boolean useTankLimit = !this.attunedTankMap.isEmpty();
+
+        if (resource != null)
+        {
+            int totalTanksFillable = useTankLimit ? this.getTanksTunedToReagent(resource.reagent) : this.tanks.length;
+            int tanksFilled = 0;
+
+            int maxFill = resource.amount;
+
+            for (int i = this.tanks.length - 1; i >= 0; i--)
+            {
+                ReagentStack remainingStack = resource.copy();
+                remainingStack.amount = maxFill - totalFill;
+
+                boolean doesReagentMatch = tanks[i].getReagent() == null ? false : tanks[i].getReagent().isReagentEqual(remainingStack);
+
+                if (doesReagentMatch)
+                {
+                    totalFill += tanks[i].fill(remainingStack, doFill);
+                    tanksFilled++;
+                } else
+                {
+                    continue;
+                }
+
+                if (totalFill >= maxFill || tanksFilled >= totalTanksFillable)
+                {
+                    return totalFill;
+                }
+            }
+
+            if (tanksFilled >= totalTanksFillable)
+            {
+                return totalFill;
+            }
+
+            for (int i = this.tanks.length - 1; i >= 0; i--)
+            {
+                ReagentStack remainingStack = resource.copy();
+                remainingStack.amount = maxFill - totalFill;
+
+                boolean isTankEmpty = tanks[i].getReagent() == null;
+
+                if (isTankEmpty)
+                {
+                    totalFill += tanks[i].fill(remainingStack, doFill);
+                    tanksFilled++;
+                } else
+                {
+                    continue;
+                }
+
+                if (totalFill >= maxFill || tanksFilled >= totalTanksFillable)
+                {
+                    return totalFill;
+                }
+            }
+        }
+        return totalFill;
+    }
+
+    @Override
+    public ReagentStack drain(ForgeDirection from, ReagentStack resource, boolean doDrain)
+    {
+        if (resource == null)
+        {
+            return null;
+        }
+
+        int maxDrain = resource.amount;
+        Reagent reagent = resource.reagent;
+        int drained = 0;
+
+        for (int i = 0; i < tanks.length; i++)
+        {
+            if (drained >= maxDrain)
+            {
+                break;
+            }
+
+            if (resource.isReagentEqual(tanks[i].getReagent()))
+            {
+                ReagentStack drainStack = tanks[i].drain(maxDrain - drained, doDrain);
+                if (drainStack != null)
+                {
+                    drained += drainStack.amount;
+                }
+            }
+        }
+
+        return new ReagentStack(reagent, drained);
+    }
+
+    /* Only returns the amount from the first available tank */
+    @Override
+    public ReagentStack drain(ForgeDirection from, int maxDrain, boolean doDrain)
+    {
+        for (int i = 0; i < tanks.length; i++)
+        {
+            ReagentStack stack = tanks[i].drain(maxDrain, doDrain);
+            if (stack != null)
+            {
+                return stack;
+            }
+        }
+
+        return null;
+    }
+
+    @Override
+    public boolean canFill(ForgeDirection from, Reagent reagent)
+    {
+        return true;
+    }
+
+    @Override
+    public boolean canDrain(ForgeDirection from, Reagent reagent)
+    {
+        return true;
+    }
+
+    @Override
+    public ReagentContainerInfo[] getContainerInfo(ForgeDirection from)
+    {
+        ReagentContainerInfo[] info = new ReagentContainerInfo[this.getNumberOfTanks()];
+        for (int i = 0; i < this.getNumberOfTanks(); i++)
+        {
+            info[i] = tanks[i].getInfo();
+        }
+        return info;
+    }
+
+    @Override
+    public int getNumberOfTanks()
+    {
+        return tanks.length;
+    }
+
+    @Override
+    public int getTanksTunedToReagent(Reagent reagent)
+    {
+        if (this.attunedTankMap.containsKey(reagent) && this.attunedTankMap.get(reagent) != null)
+        {
+            return this.attunedTankMap.get(reagent);
+        }
+        return 0;
+    }
+
+    @Override
+    public void setTanksTunedToReagent(Reagent reagent, int total)
+    {
+        if (total == 0 && this.attunedTankMap.containsKey(reagent))
+        {
+            this.attunedTankMap.remove(reagent);
+            return;
+        }
+
+        this.attunedTankMap.put(reagent, new Integer(total));
+    }
+
+    @Override
+    public Map<Reagent, Integer> getAttunedTankMap()
+    {
+        return this.attunedTankMap;
+    }
+
+    public boolean areTanksEmpty()
+    {
+        for (int i = 0; i < this.tanks.length; i++)
+        {
+            if (tanks[i] != null && tanks[i].reagentStack != null)
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}