Refactor everything to WayofTime.bloodmagic.*

src/main/java/WayofTime/bloodmagic/api/event/AddToNetworkEvent.java

@@ -0,0 +1,24 @@
+package WayofTime.bloodmagic.api.event;
+
+import net.minecraftforge.fml.common.eventhandler.Event;
+
+public class AddToNetworkEvent extends Event {
+
+    public String ownerNetwork;
+    public int addedAmount;
+    public int maximum;
+
+    /**
+     * This event is called whenever the network is added to. If cancelled, no LP will be drained from the source. If result is set to Result.DENY,
+     * the LP will still be drained but the soul network will not be added to.
+     *
+     * @param ownerNetwork	Key used for the soul network
+     * @param addedAmount	Amount added
+     * @param maximum		Ceiling that the network can add to
+     */
+    public AddToNetworkEvent(String ownerNetwork, int addedAmount, int maximum) {
+        this.ownerNetwork = ownerNetwork;
+        this.addedAmount = addedAmount;
+        this.maximum = maximum;
+    }
+}

src/main/java/WayofTime/bloodmagic/api/event/ItemBindEvent.java

@@ -0,0 +1,21 @@
+package WayofTime.bloodmagic.api.event;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fml.common.eventhandler.Cancelable;
+import net.minecraftforge.fml.common.eventhandler.Event;
+
+@Cancelable
+public class ItemBindEvent extends Event {
+
+    public final EntityPlayer player;
+    public String key;
+    public ItemStack itemStack;
+
+    public ItemBindEvent(EntityPlayer player, String key, ItemStack itemStack) {
+        super();
+        this.player = player;
+        this.key = key;
+        this.itemStack = itemStack;
+    }
+}

src/main/java/WayofTime/bloodmagic/api/event/RitualEvent.java

@@ -0,0 +1,86 @@
+package WayofTime.bloodmagic.api.event;
+
+import WayofTime.bloodmagic.api.ritual.IMasterRitualStone;
+import WayofTime.bloodmagic.api.ritual.Ritual;
+import WayofTime.bloodmagic.api.ritual.imperfect.IImperfectRitualStone;
+import WayofTime.bloodmagic.api.ritual.imperfect.ImperfectRitual;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fml.common.eventhandler.Cancelable;
+import net.minecraftforge.fml.common.eventhandler.Event;
+
+public class RitualEvent extends Event {
+
+    public final IMasterRitualStone mrs;
+    public final String ownerName;
+    public final Ritual ritual;
+
+    private RitualEvent(IMasterRitualStone mrs, String ownerName, Ritual ritual) {
+        this.mrs = mrs;
+        this.ownerName = ownerName;
+        this.ritual = ritual;
+    }
+
+    /**
+     * This event is called when a ritual is activated. If cancelled, it will not activate.
+     *
+     * {@link WayofTime.bloodmagic.api.util.helper.RitualHelper#activate(IMasterRitualStone, Ritual, EntityPlayer)}
+     */
+    @Cancelable
+    public static class RitualActivatedEvent extends RitualEvent {
+        public final EntityPlayer player;
+        public final ItemStack crystalStack;
+        public int crystalTier;
+
+        public RitualActivatedEvent(IMasterRitualStone mrs, String owner, Ritual ritual, EntityPlayer player, ItemStack activationCrystal, int crystalTier) {
+            super(mrs, owner, ritual);
+
+            this.player = player;
+            this.crystalStack = activationCrystal;
+            this.crystalTier = crystalTier;
+        }
+    }
+
+    /**
+     * This event is called when a Ritual effect is performed. If cancelled, the effect will not happen.
+     *
+     * {@link WayofTime.bloodmagic.api.util.helper.RitualHelper#perform(IMasterRitualStone, Ritual)}
+     */
+    @Cancelable
+    public static class RitualRunEvent extends RitualEvent {
+
+        public RitualRunEvent(IMasterRitualStone mrs, String owner, Ritual ritual) {
+            super(mrs, owner, ritual);
+        }
+    }
+
+    /**
+     * This event is called when a Ritual is stopped by a {@link Ritual.BreakType}.
+     *
+     * {@link WayofTime.bloodmagic.api.util.helper.RitualHelper#stop(IMasterRitualStone, Ritual, Ritual.BreakType)}
+     */
+    public static class RitualStopEvent extends RitualEvent {
+
+        public final Ritual.BreakType method;
+
+        public RitualStopEvent(IMasterRitualStone mrs, String owner, Ritual ritual, Ritual.BreakType method) {
+            super(mrs, owner, ritual);
+
+            this.method = method;
+        }
+    }
+
+    @Cancelable
+    public static class ImperfectRitualActivatedEvent extends Event {
+
+        public final IImperfectRitualStone ims;
+        public final String ownerName;
+        public final ImperfectRitual imperfectRitual;
+
+        public ImperfectRitualActivatedEvent(IImperfectRitualStone ims, String ownerName, ImperfectRitual imperfectRitual) {
+            this.ims = ims;
+            this.ownerName = ownerName;
+            this.imperfectRitual = imperfectRitual;
+        }
+    }
+}

src/main/java/WayofTime/bloodmagic/api/event/SoulNetworkEvent.java

@@ -0,0 +1,62 @@
+package WayofTime.bloodmagic.api.event;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fml.common.eventhandler.Cancelable;
+import net.minecraftforge.fml.common.eventhandler.Event;
+
+public class SoulNetworkEvent extends Event {
+
+    public String ownerName;
+    public int syphon;
+
+    public SoulNetworkEvent(String ownerName, int syphon) {
+        this.ownerName = ownerName;
+        this.syphon = syphon;
+    }
+
+    @Cancelable
+    public static class ItemDrainInContainerEvent extends SoulNetworkEvent {
+
+        public ItemStack stack;
+
+        public ItemDrainInContainerEvent(ItemStack stack, String ownerName, int syphon) {
+            super(ownerName, syphon);
+            this.stack = stack;
+        }
+    }
+
+    @Cancelable
+    public static class PlayerDrainNetworkEvent extends SoulNetworkEvent {
+
+        public final EntityPlayer player;
+        public boolean shouldDamage; //If true, will damage regardless of if the network had enough inside it
+
+        public PlayerDrainNetworkEvent(EntityPlayer player, String ownerNetwork, int drainAmount) {
+            super(ownerNetwork, drainAmount);
+            this.shouldDamage = false;
+            this.player = player;
+        }
+    }
+
+    @Cancelable
+    public static class ItemDrainNetworkEvent extends PlayerDrainNetworkEvent {
+
+        public final ItemStack itemStack;
+        public float damageAmount; //Amount of damage that would incur if the network could not drain properly
+
+        /**
+         * Set result to deny the action i.e. damage/drain anyways. Cancelling event prevents action without penalties
+         *
+         * @param player		Player using the item
+         * @param ownerNetwork	Network that the item is tied to
+         * @param itemStack		Item used
+         * @param drainAmount	Original drain amount - change to alter cost
+         */
+        public ItemDrainNetworkEvent(EntityPlayer player, String ownerNetwork, ItemStack itemStack, int drainAmount) {
+            super(player, ownerNetwork, drainAmount);
+            this.itemStack = itemStack;
+            this.damageAmount = (float)(drainAmount) / 100.0f;
+        }
+    }
+}