Added a bit of framework for the incense system.

src/main/java/WayofTime/bloodmagic/BloodMagic.java

@@ -25,6 +25,7 @@ import WayofTime.bloodmagic.registry.ModItems;
 import WayofTime.bloodmagic.registry.ModPotions;
 import WayofTime.bloodmagic.registry.ModRecipes;
 import WayofTime.bloodmagic.registry.ModRituals;
+import WayofTime.bloodmagic.registry.ModTranquilityHandlers;
 
 @Mod(modid = Constants.Mod.MODID, name = Constants.Mod.NAME, version = Constants.Mod.VERSION, dependencies = Constants.Mod.DEPEND, guiFactory = "WayofTime.bloodmagic.client.gui.config.ConfigGuiFactory")
 @Getter
@@ -69,6 +70,7 @@ public class BloodMagic
         ModEntities.init();
         ModCompatibility.registerModCompat();
         ModCompatibility.loadCompat(ICompatibility.InitializationPhase.PRE_INIT);
+        ModTranquilityHandlers.init();
 
         proxy.preInit();
     }

src/main/java/WayofTime/bloodmagic/api/incense/EnumTranquilityType.java

@@ -0,0 +1,8 @@
+package WayofTime.bloodmagic.api.incense;
+
+public enum EnumTranquilityType
+{
+    PLANT(),
+    WATER(),
+    FIRE();
+}

src/main/java/WayofTime/bloodmagic/api/incense/IIncensePath.java

@@ -0,0 +1,15 @@
+package WayofTime.bloodmagic.api.incense;
+
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.util.BlockPos;
+import net.minecraft.world.World;
+
+public interface IIncensePath
+{
+    /**
+     * Goes from 0 to however far this path block can be from the altar while
+     * still functioning. 0 represents a block that can work when it is two
+     * blocks horizontally away from the altar.
+     */
+    int getLevelOfPath(World world, BlockPos pos, IBlockState state);
+}

src/main/java/WayofTime/bloodmagic/api/incense/IncenseTranquilityRegistry.java

@@ -0,0 +1,33 @@
+package WayofTime.bloodmagic.api.incense;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.util.BlockPos;
+import net.minecraft.world.World;
+
+public class IncenseTranquilityRegistry
+{
+    public static List<TranquilityHandler> handlerList = new ArrayList<TranquilityHandler>();
+
+    public static void registerTranquilityHandler(TranquilityHandler handler)
+    {
+        handlerList.add(handler);
+    }
+
+    public static TranquilityStack getTranquilityOfBlock(World world, BlockPos pos, Block block, IBlockState state)
+    {
+        for (TranquilityHandler handler : handlerList)
+        {
+            TranquilityStack tranq = handler.getTranquilityOfBlock(world, pos, block, state);
+            if (tranq != null)
+            {
+                return tranq;
+            }
+        }
+
+        return null;
+    }
+}

src/main/java/WayofTime/bloodmagic/api/incense/TranquilityHandler.java

@@ -0,0 +1,11 @@
+package WayofTime.bloodmagic.api.incense;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.util.BlockPos;
+import net.minecraft.world.World;
+
+public abstract class TranquilityHandler
+{
+    public abstract TranquilityStack getTranquilityOfBlock(World world, BlockPos pos, Block block, IBlockState state);
+}

src/main/java/WayofTime/bloodmagic/api/incense/TranquilityStack.java

@@ -0,0 +1,13 @@
+package WayofTime.bloodmagic.api.incense;
+
+public class TranquilityStack
+{
+    public final EnumTranquilityType type;
+    public double value;
+
+    public TranquilityStack(EnumTranquilityType type, double value)
+    {
+        this.type = type;
+        this.value = value;
+    }
+}

src/main/java/WayofTime/bloodmagic/incense/PlantTranquilityHandler.java

@@ -0,0 +1,32 @@
+package WayofTime.bloodmagic.incense;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockLeaves;
+import net.minecraft.block.BlockLog;
+import net.minecraft.block.IGrowable;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.util.BlockPos;
+import net.minecraft.world.World;
+import net.minecraftforge.common.IPlantable;
+import WayofTime.bloodmagic.api.incense.EnumTranquilityType;
+import WayofTime.bloodmagic.api.incense.TranquilityHandler;
+import WayofTime.bloodmagic.api.incense.TranquilityStack;
+
+public class PlantTranquilityHandler extends TranquilityHandler
+{
+    @Override
+    public TranquilityStack getTranquilityOfBlock(World world, BlockPos pos, Block block, IBlockState state)
+    {
+        if (block instanceof IGrowable || block instanceof IPlantable)
+        {
+            return new TranquilityStack(EnumTranquilityType.PLANT, 1);
+        }
+
+        if (block instanceof BlockLog || block instanceof BlockLeaves)
+        {
+            return new TranquilityStack(EnumTranquilityType.PLANT, 0.5);
+        }
+
+        return null;
+    }
+}

src/main/java/WayofTime/bloodmagic/incense/WaterTranquilityHandler.java

@@ -0,0 +1,30 @@
+package WayofTime.bloodmagic.incense;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.init.Blocks;
+import net.minecraft.util.BlockPos;
+import net.minecraft.world.World;
+import WayofTime.bloodmagic.api.incense.EnumTranquilityType;
+import WayofTime.bloodmagic.api.incense.TranquilityHandler;
+import WayofTime.bloodmagic.api.incense.TranquilityStack;
+import WayofTime.bloodmagic.registry.ModBlocks;
+
+public class WaterTranquilityHandler extends TranquilityHandler
+{
+    @Override
+    public TranquilityStack getTranquilityOfBlock(World world, BlockPos pos, Block block, IBlockState state)
+    {
+        if (block == Blocks.water || block == Blocks.flowing_water)
+        {
+            return new TranquilityStack(EnumTranquilityType.WATER, 1);
+        }
+
+        if (block == ModBlocks.lifeEssence)
+        {
+            return new TranquilityStack(EnumTranquilityType.WATER, 2);
+        }
+
+        return null;
+    }
+}

src/main/java/WayofTime/bloodmagic/registry/ModTranquilityHandlers.java

@@ -0,0 +1,12 @@
+package WayofTime.bloodmagic.registry;
+
+import WayofTime.bloodmagic.api.incense.IncenseTranquilityRegistry;
+import WayofTime.bloodmagic.incense.PlantTranquilityHandler;
+
+public class ModTranquilityHandlers
+{
+    public static void init()
+    {
+        IncenseTranquilityRegistry.registerTranquilityHandler(new PlantTranquilityHandler());
+    }
+}

src/main/java/WayofTime/bloodmagic/tile/TileIncenseAltar.java

@@ -0,0 +1,130 @@
+package WayofTime.bloodmagic.tile;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.BlockPos;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.ITickable;
+import WayofTime.bloodmagic.api.incense.EnumTranquilityType;
+import WayofTime.bloodmagic.api.incense.IIncensePath;
+import WayofTime.bloodmagic.api.incense.IncenseTranquilityRegistry;
+import WayofTime.bloodmagic.api.incense.TranquilityStack;
+import WayofTime.bloodmagic.api.ritual.AreaDescriptor;
+
+public class TileIncenseAltar extends TileInventory implements ITickable
+{
+    public AreaDescriptor incenseArea = new AreaDescriptor.Rectangle(new BlockPos(-5, -5, -5), 11);
+    public static int maxCheckRange = 5;
+    public Map<EnumTranquilityType, Double> tranquilityMap = new HashMap<EnumTranquilityType, Double>();
+
+    public TileIncenseAltar()
+    {
+        super(1, "incenseAltar");
+    }
+
+    @Override
+    public void update()
+    {
+        AxisAlignedBB aabb = incenseArea.getAABB(getPos());
+        List<EntityPlayer> playerList = worldObj.getEntitiesWithinAABB(EntityPlayer.class, aabb);
+        if (playerList.isEmpty())
+        {
+            return;
+        }
+
+    }
+
+    public void recheckConstruction()
+    {
+        //TODO: Check the physical construction of the incense altar to determine the maximum length.
+        int maxLength = 3; //Max length of the path. The path starts two blocks away from the center block.
+        int yOffset = 0;
+
+        Map<EnumTranquilityType, Double> tranquilityMap = new HashMap<EnumTranquilityType, Double>();
+
+        for (int currentDistance = 2; currentDistance < currentDistance + maxLength; currentDistance++)
+        {
+            boolean canFormRoad = false;
+
+            level: for (int i = -maxCheckRange + yOffset; i <= maxCheckRange + yOffset; i++)
+            {
+                BlockPos verticalPos = pos.add(0, i, 0);
+
+                canFormRoad = true;
+                for (EnumFacing horizontalFacing : EnumFacing.HORIZONTALS)
+                {
+                    BlockPos facingOffsetPos = verticalPos.offset(horizontalFacing, currentDistance);
+                    for (int j = -1; j <= 1; j++)
+                    {
+                        BlockPos offsetPos = facingOffsetPos.offset(horizontalFacing.rotateY(), j);
+                        IBlockState state = worldObj.getBlockState(offsetPos);
+                        Block block = state.getBlock();
+                        if (!(block instanceof IIncensePath && ((IIncensePath) block).getLevelOfPath(worldObj, offsetPos, state) >= currentDistance - 2))
+                        {
+                            canFormRoad = false;
+                            break level;
+                        }
+                    }
+                }
+
+                if (canFormRoad)
+                {
+                    yOffset = i;
+                }
+            }
+
+            if (canFormRoad)
+            {
+                for (int i = -currentDistance; i <= currentDistance; i++)
+                {
+                    for (int j = -currentDistance; j <= currentDistance; j++)
+                    {
+                        if (Math.abs(i) != currentDistance && Math.abs(j) != currentDistance)
+                        {
+                            break; //TODO: Can make this just set j to currentDistance to speed it up.
+                        }
+
+                        for (int y = -1 + yOffset; y <= 1 + yOffset; y++)
+                        {
+                            BlockPos offsetPos = pos.add(i, yOffset, j);
+                            IBlockState state = worldObj.getBlockState(offsetPos);
+                            Block block = state.getBlock();
+                            TranquilityStack stack = IncenseTranquilityRegistry.getTranquilityOfBlock(worldObj, offsetPos, block, state);
+                            if (stack != null)
+                            {
+                                if (!tranquilityMap.containsKey(stack.type))
+                                {
+                                    tranquilityMap.put(stack.type, stack.value);
+                                } else
+                                {
+                                    tranquilityMap.put(stack.type, tranquilityMap.get(stack.type) + stack.value);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        this.tranquilityMap = tranquilityMap;
+
+        double totalTranquility = 0;
+        for (Entry<EnumTranquilityType, Double> entry : tranquilityMap.entrySet())
+        {
+            totalTranquility += entry.getValue();
+        }
+
+        if (totalTranquility <= 0)
+        {
+            return;
+        }
+
+    }
+}