Started work on Demon Will Inversion system.

src/main/java/WayofTime/bloodmagic/demonAura/PosXY.java

@@ -0,0 +1,36 @@
+package WayofTime.bloodmagic.demonAura;
+
+import lombok.AllArgsConstructor;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.ToString;
+
+@EqualsAndHashCode
+@ToString
+@NoArgsConstructor
+@AllArgsConstructor
+@Setter
+public class PosXY implements Comparable<PosXY>
+{
+    public int x;
+    public int y;
+
+    @Override
+    public int compareTo(PosXY c)
+    {
+        return this.y == c.y ? this.x - c.x : this.y - c.y;
+    }
+
+    public float getDistanceSquared(int x, int z)
+    {
+        float f = this.x - x;
+        float f2 = this.y - z;
+        return f * f + f2 * f2;
+    }
+
+    public float getDistanceSquaredToChunkCoordinates(PosXY c)
+    {
+        return getDistanceSquared(c.x, c.y);
+    }
+}

src/main/java/WayofTime/bloodmagic/demonAura/WillChunk.java

@@ -0,0 +1,41 @@
+package WayofTime.bloodmagic.demonAura;
+
+import java.lang.ref.WeakReference;
+
+import lombok.Getter;
+import lombok.Setter;
+import net.minecraft.world.chunk.Chunk;
+import WayofTime.bloodmagic.api.soul.DemonWillHolder;
+
+@Getter
+@Setter
+public class WillChunk
+{
+    PosXY loc;
+    private short base;
+    private DemonWillHolder currentWill = new DemonWillHolder();
+    private WeakReference<Chunk> chunkRef;
+
+    public WillChunk(PosXY loc)
+    {
+        this.loc = loc;
+    }
+
+    public WillChunk(Chunk chunk, short base, DemonWillHolder currentWill)
+    {
+        this.loc = new PosXY(chunk.xPosition, chunk.zPosition);
+        this.chunkRef = new WeakReference(chunk);
+        this.base = base;
+        this.currentWill = currentWill;
+    }
+
+    public boolean isModified()
+    {
+        if ((this.chunkRef != null) && (this.chunkRef.get() != null))
+        {
+            return ((Chunk) this.chunkRef.get()).needsSaving(false);
+        }
+
+        return false;
+    }
+}

src/main/java/WayofTime/bloodmagic/demonAura/WillWorld.java

@@ -0,0 +1,41 @@
+package WayofTime.bloodmagic.demonAura;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+import lombok.Getter;
+import lombok.Setter;
+
+public class WillWorld
+{
+    int dim;
+    @Getter
+    @Setter
+    ConcurrentHashMap<PosXY, WillChunk> willChunks = new ConcurrentHashMap<PosXY, WillChunk>();
+
+//    private static ConcurrentHashMap<PosXY, AspectList> nodeTickets = new ConcurrentHashMap();
+
+    public WillWorld(int dim)
+    {
+        this.dim = dim;
+    }
+
+    public WillChunk getWillChunkAt(int x, int y)
+    {
+        return getWillChunkAt(new PosXY(x, y));
+    }
+
+    public WillChunk getWillChunkAt(PosXY loc)
+    {
+        return this.willChunks.get(loc);
+    }
+
+//    public static ConcurrentHashMap<PosXY, AspectList> getNodeTickets()
+//    {
+//        return nodeTickets;
+//    }
+//
+//    public static void setNodeTickets(ConcurrentHashMap<PosXY, AspectList> nodeTickets)
+//    {
+//        nodeTickets = nodeTickets;
+//    }
+}

src/main/java/WayofTime/bloodmagic/demonAura/WorldDemonWillHandler.java

@@ -0,0 +1,135 @@
+package WayofTime.bloodmagic.demonAura;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import net.minecraft.util.BlockPos;
+import net.minecraft.world.World;
+import net.minecraft.world.chunk.Chunk;
+import WayofTime.bloodmagic.api.BloodMagicAPI;
+import WayofTime.bloodmagic.api.soul.DemonWillHolder;
+import WayofTime.bloodmagic.api.soul.EnumDemonWillType;
+
+public class WorldDemonWillHandler
+{
+    static ConcurrentHashMap<Integer, WillWorld> containedWills = new ConcurrentHashMap<Integer, WillWorld>();
+    public static ConcurrentHashMap<Integer, CopyOnWriteArrayList<PosXY>> dirtyChunks = new ConcurrentHashMap<Integer, CopyOnWriteArrayList<PosXY>>();
+    public static ConcurrentHashMap<Integer, BlockPos> taintTrigger = new ConcurrentHashMap<Integer, BlockPos>();
+
+    public static WillWorld getAuraWorld(int dim)
+    {
+        return containedWills.get(dim);
+    }
+
+    public static WillChunk getWillChunk(int dim, int x, int y)
+    {
+        if (containedWills.containsKey(dim))
+        {
+            return (containedWills.get(dim)).getWillChunkAt(x, y);
+        }
+
+        return null;
+    }
+
+    public static void addWillWorld(int dim)
+    {
+        if (!containedWills.containsKey(dim))
+        {
+            containedWills.put(dim, new WillWorld(dim));
+            BloodMagicAPI.getLogger().info("Creating demon will cache for world " + dim);
+        }
+    }
+
+    public static void removeWillWorld(int dim)
+    {
+        containedWills.remove(dim);
+        BloodMagicAPI.getLogger().info("Removing demon will cache for world " + dim);
+    }
+
+    public static void addWillChunk(int dim, Chunk chunk, short base, DemonWillHolder currentWill)
+    {
+        WillWorld aw = containedWills.get(dim);
+        if (aw == null)
+        {
+            aw = new WillWorld(dim);
+        }
+        aw.getWillChunks().put(new PosXY(chunk.xPosition, chunk.zPosition), new WillChunk(chunk, base, currentWill));
+
+        containedWills.put(dim, aw);
+    }
+
+    public static void removeWillChunk(int dim, int x, int y)
+    {
+        WillWorld aw = containedWills.get(dim);
+        if (aw != null)
+        {
+            WillChunk chunk = aw.getWillChunks().remove(new PosXY(x, y));
+            if (chunk != null)
+            {
+                markChunkAsDirty(chunk, dim);
+            }
+        }
+    }
+
+    public static double drainWill(World world, BlockPos pos, EnumDemonWillType type, double amount, boolean doDrain)
+    {
+        WillChunk willChunk = getWillChunk(world, pos);
+
+        DemonWillHolder currentWill = willChunk.getCurrentWill();
+        double drain = Math.min(currentWill.getWill(type), amount);
+        if (!doDrain)
+        {
+            return drain;
+        }
+
+        drain = currentWill.drainWill(type, drain);
+        markChunkAsDirty(willChunk, world.provider.getDimensionId());
+
+        return drain;
+    }
+
+    public static double fillWillToMaximum(World world, BlockPos pos, EnumDemonWillType type, double amount, double max, boolean doFill)
+    {
+        WillChunk willChunk = getWillChunk(world, pos);
+
+        DemonWillHolder currentWill = willChunk.getCurrentWill();
+        double fill = Math.min(amount, max - currentWill.getWill(type));
+        if (!doFill)
+        {
+            return fill;
+        }
+
+        fill = currentWill.addWill(type, amount, max);
+        markChunkAsDirty(willChunk, world.provider.getDimensionId());
+
+        return fill;
+    }
+
+    public static WillChunk getWillChunk(World world, BlockPos pos)
+    {
+        return getWillChunk(world.provider.getDimensionId(), pos.getX() >> 4, pos.getZ() >> 4);
+    }
+
+    private static void markChunkAsDirty(WillChunk chunk, int dim)
+    {
+        if (chunk.isModified())
+        {
+            return;
+        }
+        PosXY pos = new PosXY(chunk.loc.x, chunk.loc.y);
+        if (!dirtyChunks.containsKey(dim))
+        {
+            dirtyChunks.put(dim, new CopyOnWriteArrayList<PosXY>());
+        }
+        CopyOnWriteArrayList<PosXY> dc = dirtyChunks.get(dim);
+        if (!dc.contains(pos))
+        {
+            dc.add(pos);
+        }
+    }
+
+    public static void generateWill(Chunk chunk)
+    {
+        addWillChunk(chunk.getWorld().provider.getDimensionId(), chunk, (short) 1, new DemonWillHolder());
+    }
+}