API fun

BM_src/WayofTime/alchemicalWizardry/api/alchemy/AlchemicalPotionCreationHandler.java

@@ -0,0 +1,82 @@
+package WayofTime.alchemicalWizardry.api.alchemy;
+
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.potion.Potion;
+
+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));
+        //EXAMPLE: addPotion(new ItemStack(Item.ghastTear), Potion.regeneration.id, 450);
+    }
+
+    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;
+    }
+}

BM_src/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.itemID == itemStack.itemID && comparedStack.getItemDamage() == itemStack.getItemDamage();
+                }
+            } else if (!(itemStack.getItem() instanceof ItemBlock))
+            {
+                return comparedStack.itemID == itemStack.itemID && comparedStack.getItemDamage() == itemStack.getItemDamage();
+            }
+        }
+
+        return false;
+    }
+
+    public ItemStack getItemStack()
+    {
+        return itemStack;
+    }
+
+    public int getPotionID()
+    {
+        return this.potionID;
+    }
+
+    public int getTickDuration()
+    {
+        return this.tickDuration;
+    }
+}

BM_src/WayofTime/alchemicalWizardry/api/altarRecipeRegistry/AltarRecipe.java

@@ -0,0 +1,70 @@
+package WayofTime.alchemicalWizardry.api.altarRecipeRegistry;
+
+import net.minecraft.item.ItemStack;
+
+public class AltarRecipe 
+{
+	public int minTier;
+	public int liquidRequired;
+	public boolean canBeFilled; //Tells the system that the item is an orb
+	public int consumptionRate;
+	public int drainRate;
+	public ItemStack requiredItem;
+	public ItemStack result;
+	
+	public AltarRecipe(ItemStack result, ItemStack requiredItem, int minTier, int liquidRequired, int consumptionRate, int drainRate, boolean canBeFilled)
+	{
+		this.result = result;
+		this.requiredItem = requiredItem;
+		this.minTier = minTier;
+		this.liquidRequired = liquidRequired;
+		this.consumptionRate = consumptionRate;
+		this.drainRate = drainRate;
+		this.canBeFilled = canBeFilled;
+	}
+	
+	public ItemStack getResult()
+	{
+		return this.result;
+	}
+	
+	public ItemStack getRequiredItem()
+	{
+		return this.requiredItem;
+	}
+	
+	public boolean doesRequiredItemMatch(ItemStack comparedStack, int tierCheck)
+	{
+		if(comparedStack == null || this.requiredItem == null)
+		{
+			return false;
+		}
+		
+		return tierCheck>=minTier && this.requiredItem.isItemEqual(comparedStack);
+	}
+	
+	public int getMinTier()
+	{
+		return this.minTier;
+	}
+	
+	public int getLiquidRequired()
+	{
+		return this.liquidRequired;
+	}
+	
+	public int getConsumptionRate()
+	{
+		return this.consumptionRate;
+	}
+	
+	public int getDrainRate()
+	{
+		return this.drainRate;
+	}
+	
+	public boolean getCanBeFilled()
+	{
+		return this.canBeFilled;
+	}
+}

BM_src/WayofTime/alchemicalWizardry/api/altarRecipeRegistry/AltarRecipeRegistry.java

@@ -0,0 +1,64 @@
+package WayofTime.alchemicalWizardry.api.altarRecipeRegistry;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import net.minecraft.block.Block;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+
+public class AltarRecipeRegistry 
+{
+	public static List<AltarRecipe> altarRecipes = new LinkedList();
+	
+	public static void registerAltarRecipe(ItemStack result, ItemStack requiredItem, int minTier, int liquidRequired, int consumptionRate, int drainRate, boolean canBeFilled)
+	{
+		altarRecipes.add(new AltarRecipe(result, requiredItem, minTier, liquidRequired, consumptionRate, drainRate, canBeFilled));
+		//EXAMPLE: registerAltarRecipe(new ItemStack(ModItems.telepositionFocus), new ItemStack(Item.enderPearl),4,2000,10,10,false);
+	}
+	
+	public static void registerAltarOrbRecipe(ItemStack orbStack, int minTier, int consumptionRate)
+	{
+		registerAltarRecipe(null, orbStack, minTier, 0, consumptionRate, 0, true);
+		//EXAMPLE: registerAltarOrbRecipe(new ItemStack(ModItems.weakBloodOrb),1,2);
+	}
+	
+	public static boolean isRequiredItemValid(ItemStack testItem, int currentTierAltar)
+	{
+		for(AltarRecipe recipe : altarRecipes)
+		{
+			if(recipe.doesRequiredItemMatch(testItem, currentTierAltar))
+			{
+				return true;
+			}
+		}
+		
+		return false;
+	}
+	
+	public static ItemStack getItemForItemAndTier(ItemStack testItem, int currentTierAltar)
+	{
+		for(AltarRecipe recipe : altarRecipes)
+		{
+			if(recipe.doesRequiredItemMatch(testItem, currentTierAltar))
+			{
+				return recipe.getResult().copy();
+			}
+		}
+		
+		return null;
+	}
+	
+	public static AltarRecipe getAltarRecipeForItemAndTier(ItemStack testItem, int currentTierAltar)
+	{
+		for(AltarRecipe recipe : altarRecipes)
+		{
+			if(recipe.doesRequiredItemMatch(testItem, currentTierAltar))
+			{
+				return recipe;
+			}
+		}
+		
+		return null;
+	}
+}

BM_src/WayofTime/alchemicalWizardry/api/items/interfaces/ArmourUpgrade.java

@@ -0,0 +1,15 @@
+package WayofTime.alchemicalWizardry.api.items.interfaces;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+public interface ArmourUpgrade
+{
+    //Called when the armour ticks
+    public void onArmourUpdate(World world, EntityPlayer player, ItemStack thisItemStack);
+
+    public boolean isUpgrade();
+
+    public int getEnergyForTenSeconds();
+}

BM_src/WayofTime/alchemicalWizardry/api/items/interfaces/IBindable.java

@@ -0,0 +1,5 @@
+package WayofTime.alchemicalWizardry.api.items.interfaces;
+
+public interface IBindable
+{
+}

BM_src/WayofTime/alchemicalWizardry/api/items/interfaces/IBloodOrb.java

@@ -0,0 +1,8 @@
+package WayofTime.alchemicalWizardry.api.items.interfaces;
+
+public interface IBloodOrb 
+{
+	public int getMaxEssence();
+	
+	public int getOrbLevel();
+}

BM_src/WayofTime/alchemicalWizardry/api/rituals/IMasterRitualStone.java

@@ -0,0 +1,30 @@
+package WayofTime.alchemicalWizardry.api.rituals;
+
+import net.minecraft.world.World;
+
+public interface IMasterRitualStone 
+{
+	public void performRitual(World world, int x, int y, int z, int ritualID);
+	
+    public String getOwner();
+
+    public void setCooldown(int newCooldown);
+
+    public int getCooldown();
+
+    public void setVar1(int newVar1);
+
+    public int getVar1();
+
+    public void setActive(boolean active);
+
+    public int getDirection();
+    
+    public World getWorldObj();
+    
+    public int getXCoord();
+    
+    public int getYCoord();
+    
+    public int getZCoord();
+}

BM_src/WayofTime/alchemicalWizardry/api/rituals/IRitualStone.java

@@ -0,0 +1,6 @@
+package WayofTime.alchemicalWizardry.api.rituals;
+
+public interface IRitualStone 
+{
+
+}

BM_src/WayofTime/alchemicalWizardry/api/rituals/RitualComponent.java

@@ -0,0 +1,43 @@
+package WayofTime.alchemicalWizardry.api.rituals;
+
+public class RitualComponent
+{
+    private int x;
+    private int y;
+    private int z;
+    private int stoneType;
+    public static final int BLANK = 0;
+    public static final int WATER = 1;
+    public static final int FIRE = 2;
+    public static final int EARTH = 3;
+    public static final int AIR = 4;
+    public static final int DUSK = 5;
+
+    public RitualComponent(int x, int y, int z, int stoneType)
+    {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.stoneType = stoneType;
+    }
+
+    public int getX()
+    {
+        return this.x;
+    }
+
+    public int getY()
+    {
+        return this.y;
+    }
+
+    public int getZ()
+    {
+        return this.z;
+    }
+
+    public int getStoneType()
+    {
+        return this.stoneType;
+    }
+}

BM_src/WayofTime/alchemicalWizardry/api/rituals/RitualEffect.java

@@ -0,0 +1,13 @@
+package WayofTime.alchemicalWizardry.api.rituals;
+
+public abstract class RitualEffect
+{
+    public abstract void performEffect(IMasterRitualStone ritualStone);
+
+    public abstract int getCostPerRefresh();
+
+    public int getInitialCooldown()
+    {
+        return 0;
+    }
+}

BM_src/WayofTime/alchemicalWizardry/api/rituals/Rituals.java

@@ -0,0 +1,263 @@
+package WayofTime.alchemicalWizardry.api.rituals;
+
+import net.minecraft.block.Block;
+import net.minecraft.world.World;
+import net.minecraftforge.oredict.OreDictionary;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Rituals
+{
+    private List<RitualComponent> components;
+    private int crystalLevel;
+    private int actCost;
+    private RitualEffect effect;
+    private String name;
+
+    public static List<Rituals> ritualList = new ArrayList();
+
+    public Rituals(List<RitualComponent> components, int crystalLevel, int actCost, RitualEffect effect, String name)
+    {
+        this.components = components;
+        this.crystalLevel = crystalLevel;
+        this.actCost = actCost;
+        this.effect = effect;
+        this.name = name;
+    }
+
+    public Rituals(List<RitualComponent> components, int crystalLevel, int actCost, RitualEffect effect)
+    {
+        this.components = components;
+        this.crystalLevel = crystalLevel;
+        this.actCost = actCost;
+        this.effect = effect;
+        this.name = "";
+    }
+
+    public static int checkValidRitual(World world, int x, int y, int z)
+    {
+        for (int i = 1; i <= ritualList.size(); i++)
+        {
+            if (checkRitualIsValid(world, x, y, z, i))
+            {
+                return i;
+            }
+        }
+
+        return 0;
+    }
+
+    public static boolean canCrystalActivate(int ritual, int crystalLevel)
+    {
+        if (ritual <= ritualList.size())
+        {
+            return ritualList.get(ritual - 1).crystalLevel <= crystalLevel;
+        } else
+        {
+            return false;
+        }
+    }
+
+    public static boolean checkRitualIsValid(World world, int x, int y, int z, int ritualID)
+    {
+        int direction = Rituals.getDirectionOfRitual(world, x, y, z, ritualID);
+
+        if (direction != -1)
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * 1 - NORTH
+     * 2 - EAST
+     * 3 - SOUTH
+     * 4 - WEST
+     */
+    public static boolean checkDirectionOfRitualValid(World world, int x, int y, int z, int ritualID, int direction)
+    {
+        List<RitualComponent> ritual = Rituals.getRitualList(ritualID);
+
+        if (ritual == null)
+        {
+            return false;
+        }
+
+        Block test = null;
+
+        switch (direction)
+        {
+            case 1:
+                for (RitualComponent rc : ritual)
+                {
+                    test = Block.blocksList[world.getBlockId(x + rc.getX(), y + rc.getY(), z + rc.getZ())];
+
+                    if (!(test instanceof IRitualStone))
+                    {
+                        return false;
+                    }
+
+                    if (world.getBlockMetadata(x + rc.getX(), y + rc.getY(), z + rc.getZ()) != rc.getStoneType())
+                    {
+                        return false;
+                    }
+                }
+
+                return true;
+
+            case 2:
+                for (RitualComponent rc : ritual)
+                {
+                    test = Block.blocksList[world.getBlockId(x - rc.getZ(), y + rc.getY(), z + rc.getX())];
+
+                    if (!(test instanceof IRitualStone))
+                    {
+                        return false;
+                    }
+
+                    if (world.getBlockMetadata(x - rc.getZ(), y + rc.getY(), z + rc.getX()) != rc.getStoneType())
+                    {
+                        return false;
+                    }
+                }
+
+                return true;
+
+            case 3:
+                for (RitualComponent rc : ritual)
+                {
+                    test = Block.blocksList[world.getBlockId(x - rc.getX(), y + rc.getY(), z - rc.getZ())];
+
+                    if (!(test instanceof IRitualStone))
+                    {
+                        return false;
+                    }
+
+                    if (world.getBlockMetadata(x - rc.getX(), y + rc.getY(), z - rc.getZ()) != rc.getStoneType())
+                    {
+                        return false;
+                    }
+                }
+
+                return true;
+
+            case 4:
+                for (RitualComponent rc : ritual)
+                {
+                    test = Block.blocksList[world.getBlockId(x + rc.getZ(), y + rc.getY(), z - rc.getX())];
+
+                    if (!(test instanceof IRitualStone))
+                    {
+                        return false;
+                    }
+
+                    if (world.getBlockMetadata(x + rc.getZ(), y + rc.getY(), z - rc.getX()) != rc.getStoneType())
+                    {
+                        return false;
+                    }
+                }
+
+                return true;
+        }
+
+        return false;
+    }
+
+    public static int getDirectionOfRitual(World world, int x, int y, int z, int ritualID)
+    {
+        for (int i = 1; i <= 4; i++)
+        {
+            if (Rituals.checkDirectionOfRitualValid(world, x, y, z, ritualID, i))
+            {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    public static int getCostForActivation(int ritualID)
+    {
+        if (ritualID <= ritualList.size())
+        {
+            return ritualList.get(ritualID - 1).actCost;
+        } else
+        {
+            return 0;
+        }
+    }
+
+    public static int getInitialCooldown(int ritualID)
+    {
+        if (ritualID <= ritualList.size())
+        {
+            RitualEffect ef = ritualList.get(ritualID - 1).effect;
+
+            if (ef != null)
+            {
+                OreDictionary d;
+                return ef.getInitialCooldown();
+            }
+        }
+
+        return 0;
+    }
+
+    public static List<RitualComponent> getRitualList(int ritualID)
+    {
+        if (ritualID <= ritualList.size())
+        {
+            return ritualList.get(ritualID - 1).obtainComponents();
+        } else
+        {
+            return null;
+        }
+    }
+
+    private List<RitualComponent> obtainComponents()
+    {
+        return this.components;
+    }
+
+    private int getCrystalLevel()
+    {
+        return this.crystalLevel;
+    }
+
+    public static void performEffect(IMasterRitualStone ritualStone, int ritualID)
+    {
+        if (ritualID <= ritualList.size())
+        {
+            RitualEffect ef = ritualList.get(ritualID - 1).effect;
+
+            if (ef != null)
+            {
+                ef.performEffect(ritualStone);
+            }
+        }
+    }
+
+    public static int getNumberOfRituals()
+    {
+        return ritualList.size();
+    }
+
+    public String getRitualName()
+    {
+        return this.name;
+    }
+
+    public static String getNameOfRitual(int id)
+    {
+        if (ritualList.get(id) != null)
+        {
+            return ritualList.get(id).getRitualName();
+        } else
+        {
+            return "";
+        }
+    }
+}

BM_src/WayofTime/alchemicalWizardry/api/soulNetwork/LifeEssenceNetwork.java

@@ -0,0 +1,26 @@
+package WayofTime.alchemicalWizardry.api.soulNetwork;
+
+import net.minecraft.nbt.NBTTagCompound;
+
+public class LifeEssenceNetwork extends net.minecraft.world.WorldSavedData
+{
+    public int currentEssence;
+
+    public LifeEssenceNetwork(String par1Str)
+    {
+        super(par1Str);
+        currentEssence = 0;
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound nbttagcompound)
+    {
+        currentEssence = nbttagcompound.getInteger("currentEssence");
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound nbttagcompound)
+    {
+        nbttagcompound.setInteger("currentEssence", currentEssence);
+    }
+}

BM_src/WayofTime/alchemicalWizardry/api/soulNetwork/SoulNetworkHandler.java

@@ -0,0 +1,223 @@
+package WayofTime.alchemicalWizardry.api.soulNetwork;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.util.DamageSource;
+import net.minecraft.world.World;
+
+public class SoulNetworkHandler 
+{
+	public static int syphonFromNetwork(ItemStack ist, int damageToBeDone)
+	{
+		if (ist.getTagCompound() != null && !(ist.getTagCompound().getString("ownerName").equals("")))
+        {
+            String ownerName = ist.getTagCompound().getString("ownerName");
+
+            if (MinecraftServer.getServer() == null)
+            {
+                return 0;
+            }
+
+            World world = MinecraftServer.getServer().worldServers[0];
+            LifeEssenceNetwork data = (LifeEssenceNetwork) world.loadItemData(LifeEssenceNetwork.class, ownerName);
+
+            if (data == null)
+            {
+                data = new LifeEssenceNetwork(ownerName);
+                world.setItemData(ownerName, data);
+            }
+
+            if (data.currentEssence >= damageToBeDone)
+            {
+                data.currentEssence -= damageToBeDone;
+                data.markDirty();
+                return damageToBeDone;
+            }
+        }
+		return 0;
+	}
+	
+	/**
+	 * Master method used to syphon from the player's network, and will damage them accordingly if they do not have enough LP.
+	 * Does not drain on the client side.
+	 * 
+	 * @param ist		Owned itemStack
+	 * @param player	Player using the item
+	 * @param damageToBeDone
+	 * @return	True if server-sided, false if client-sided
+	 */
+	public static boolean syphonAndDamageFromNetwork(ItemStack ist, EntityPlayer player, int damageToBeDone)
+    {
+		if(player.worldObj.isRemote)
+		{
+			return false;
+		}
+		
+       	int amount = SoulNetworkHandler.syphonFromNetwork(ist, damageToBeDone);
+        
+        hurtPlayer(player, damageToBeDone-amount);  
+
+        return true;
+    }
+	
+	public static boolean canSyphonFromOnlyNetwork(ItemStack ist, int damageToBeDone)
+    {
+        if (ist.getTagCompound() != null && !(ist.getTagCompound().getString("ownerName").equals("")))
+        {
+            String ownerName = ist.getTagCompound().getString("ownerName");
+
+            if (MinecraftServer.getServer() == null)
+            {
+                return false;
+            }
+
+            World world = MinecraftServer.getServer().worldServers[0];
+            LifeEssenceNetwork data = (LifeEssenceNetwork) world.loadItemData(LifeEssenceNetwork.class, ownerName);
+
+            if (data == null)
+            {
+                data = new LifeEssenceNetwork(ownerName);
+                world.setItemData(ownerName, data);
+            }
+
+            return data.currentEssence >= damageToBeDone;
+        }
+
+        return false;
+    }
+	
+	public static int getCurrentEssence(String ownerName)
+	{
+		if (MinecraftServer.getServer() == null)
+        {
+            return 0;
+        }
+
+        World world = MinecraftServer.getServer().worldServers[0];
+        LifeEssenceNetwork data = (LifeEssenceNetwork) world.loadItemData(LifeEssenceNetwork.class, ownerName);
+
+        if (data == null)
+        {
+            data = new LifeEssenceNetwork(ownerName);
+            world.setItemData(ownerName, data);
+        }
+        
+        return data.currentEssence;
+	}
+	
+	public static void setCurrentEssence(String ownerName, int essence)
+	{
+		if (MinecraftServer.getServer() == null)
+        {
+            return;
+        }
+
+        World world = MinecraftServer.getServer().worldServers[0];
+        LifeEssenceNetwork data = (LifeEssenceNetwork) world.loadItemData(LifeEssenceNetwork.class, ownerName);
+
+        if (data == null)
+        {
+            data = new LifeEssenceNetwork(ownerName);
+            world.setItemData(ownerName, data);
+        }
+        
+        data.currentEssence = essence;
+        data.markDirty();
+	}
+	
+	/**
+	 * A method to add to an owner's network up to a maximum value.
+	 * 
+	 * @param ownerName
+	 * @param addedEssence
+	 * @param maximum
+	 * @return amount added to the network
+	 */
+	public static int addCurrentEssenceToMaximum(String ownerName, int addedEssence, int maximum)
+	{
+		if (MinecraftServer.getServer() == null)
+        {
+            return 0;
+        }
+
+        World world = MinecraftServer.getServer().worldServers[0];
+        LifeEssenceNetwork data = (LifeEssenceNetwork) world.loadItemData(LifeEssenceNetwork.class, ownerName);
+
+        if (data == null)
+        {
+            data = new LifeEssenceNetwork(ownerName);
+            world.setItemData(ownerName, data);
+        }
+        
+        int currEss = data.currentEssence;
+        
+        if(currEss>=maximum)
+        {
+        	return 0;
+        }
+        
+        int newEss = Math.min(maximum, currEss+addedEssence);
+        data.currentEssence = newEss;
+        
+		return newEss-currEss;
+	}
+	
+	public static void hurtPlayer(EntityPlayer user, int energySyphoned)
+    {
+        if (energySyphoned < 100 && energySyphoned > 0)
+        {
+            if (!user.capabilities.isCreativeMode)
+            {
+                user.setHealth((user.getHealth() - 1));
+
+                if (user.getHealth() <= 0.0005f)
+                {
+                    user.onDeath(DamageSource.generic);
+                }
+            }
+        } else if (energySyphoned >= 100)
+        {
+            if (!user.capabilities.isCreativeMode)
+            {
+                for (int i = 0; i < ((energySyphoned + 99) / 100); i++)
+                {
+                    user.setHealth((user.getHealth() - 1));
+
+                    if (user.getHealth() <= 0.0005f)
+                    {
+                        user.onDeath(DamageSource.generic);
+                        break;
+                    }
+                }
+            }
+        }
+    }
+	
+	public static void checkAndSetItemOwner(ItemStack item, EntityPlayer player)
+    {
+        if (item.stackTagCompound == null)
+        {
+            item.setTagCompound(new NBTTagCompound());
+        }
+
+        if (item.stackTagCompound.getString("ownerName").equals(""))
+        {
+            item.stackTagCompound.setString("ownerName", player.getEntityName());
+        }
+    }
+
+    public static void checkAndSetItemOwner(ItemStack item, String ownerName)
+    {
+        if (item.stackTagCompound == null)
+        {
+            item.setTagCompound(new NBTTagCompound());
+        }
+
+        if (item.stackTagCompound.getString("ownerName").equals(""))
+        {
+            item.stackTagCompound.setString("ownerName", ownerName);
+        }
+    }
+}