Added a Repairing Living Armour Upgrade (trained by damaging the chestplate of the Living Armour while you have a full set on - it repairs all of your armour pieces over time)

Added the stat trackers for various Living Armour Downgrades.

changelog.txt

@@ -5,6 +5,7 @@ Version 2.1.0-66
 - Added a potion effect called "(-) Immunity", which allows the training of Living Armour Downgrades. This potion is crafted using a Draft of Angelus with a potion flask. Check the uses of the flask!
 - Added some more framework for the Living Armour Downgrades.
 - Modified the Grim Reaper's Sprint so it is better at later levels.
+- Added a Repairing Living Armour Upgrade (trained by damaging the chestplate of the Living Armour while you have a full set on - it repairs all of your armour pieces over time)
 
 ------------------------------------------------------
 Version 2.1.0-65

src/main/java/WayofTime/bloodmagic/item/armour/ItemLivingArmour.java

@@ -41,6 +41,7 @@ import WayofTime.bloodmagic.api.util.helper.NetworkHelper;
 import WayofTime.bloodmagic.client.IMeshProvider;
 import WayofTime.bloodmagic.item.ItemComponent;
 import WayofTime.bloodmagic.livingArmour.LivingArmour;
+import WayofTime.bloodmagic.livingArmour.tracker.StatTrackerRepairing;
 import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeElytra;
 import WayofTime.bloodmagic.network.BloodMagicPacketHandler;
 import WayofTime.bloodmagic.network.PlayerFallDistancePacketProcessor;
@@ -233,6 +234,7 @@ public class ItemLivingArmour extends ItemArmor implements ISpecialArmor, IMeshP
     {
         if (this == ModItems.LIVING_ARMOUR_CHEST)
         {
+            int preDamage = stack.getItemDamage();
             if (source.isUnblockable())
             {
                 return;
@@ -252,6 +254,21 @@ public class ItemLivingArmour extends ItemArmor implements ISpecialArmor, IMeshP
             }
 
             stack.damageItem(damage, entity);
+
+            int receivedDamage = stack.getItemDamage() - preDamage;
+            if (entity instanceof EntityPlayer)
+            {
+                EntityPlayer player = (EntityPlayer) entity;
+                if (LivingArmour.hasFullSet(player))
+                {
+                    LivingArmour armour = ItemLivingArmour.getLivingArmour(stack);
+                    if (armour != null)
+                    {
+                        StatTrackerRepairing.incrementCounter(armour, receivedDamage);
+                    }
+                }
+            }
+
         } else
         {
             stack.damageItem(damage, entity);

src/main/java/WayofTime/bloodmagic/livingArmour/LivingArmour.java

@@ -167,7 +167,7 @@ public class LivingArmour implements ILivingArmour
                 continue;
             }
 
-            if (world.isRemote && upgrade.runOnClient())
+            if ((world.isRemote && upgrade.runOnClient()) || !world.isRemote)
             {
                 upgrade.onTick(world, player, this);
             }

src/main/java/WayofTime/bloodmagic/livingArmour/tracker/StatTrackerRepairing.java

@@ -0,0 +1,124 @@
+package WayofTime.bloodmagic.livingArmour.tracker;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+import WayofTime.bloodmagic.api.Constants;
+import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
+import WayofTime.bloodmagic.api.livingArmour.StatTracker;
+import WayofTime.bloodmagic.livingArmour.LivingArmour;
+import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeRepairing;
+import WayofTime.bloodmagic.util.Utils;
+
+public class StatTrackerRepairing extends StatTracker
+{
+    public double totalDamage = 0;
+
+    public static HashMap<LivingArmour, Integer> changeMap = new HashMap<LivingArmour, Integer>();
+    public static int[] damageRequired = new int[] { 500 };
+
+    public static void incrementCounter(LivingArmour armour, int receivedDamage)
+    {
+        changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + receivedDamage : receivedDamage);
+    }
+
+    @Override
+    public String getUniqueIdentifier()
+    {
+        return Constants.Mod.MODID + ".tracker.repair";
+    }
+
+    @Override
+    public void resetTracker()
+    {
+        this.totalDamage = 0;
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound tag)
+    {
+        totalDamage = tag.getDouble(Constants.Mod.MODID + ".tracker.repair");
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound tag)
+    {
+        tag.setDouble(Constants.Mod.MODID + ".tracker.repair", totalDamage);
+    }
+
+    @Override
+    public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour)
+    {
+        if (changeMap.containsKey(livingArmour))
+        {
+            double change = Math.abs(changeMap.get(livingArmour));
+            if (change > 0)
+            {
+                totalDamage += Math.abs(changeMap.get(livingArmour));
+
+                changeMap.put(livingArmour, 0);
+
+                this.markDirty();
+
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    @Override
+    public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour)
+    {
+        if (changeMap.containsKey(livingArmour))
+        {
+            changeMap.remove(livingArmour);
+        }
+    }
+
+    @Override
+    public List<LivingArmourUpgrade> getUpgrades()
+    {
+        List<LivingArmourUpgrade> upgradeList = new ArrayList<LivingArmourUpgrade>();
+
+        for (int i = 0; i < 1; i++)
+        {
+            if (totalDamage >= damageRequired[i])
+            {
+                upgradeList.add(new LivingArmourUpgradeRepairing(i));
+            }
+        }
+
+        return upgradeList;
+    }
+
+    @Override
+    public double getProgress(LivingArmour livingArmour, int currentLevel)
+    {
+        return Utils.calculateStandardProgress(totalDamage, damageRequired, currentLevel);
+    }
+
+    @Override
+    public boolean providesUpgrade(String key)
+    {
+        return key.equals(Constants.Mod.MODID + ".upgrade.repair");
+    }
+
+    @Override
+    public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade)
+    {
+        if (upgrade instanceof LivingArmourUpgradeRepairing)
+        {
+            int level = upgrade.getUpgradeLevel();
+            if (level < damageRequired.length)
+            {
+                totalDamage = Math.max(totalDamage, damageRequired[level]);
+                this.markDirty();
+            }
+        }
+    }
+}

src/main/java/WayofTime/bloodmagic/livingArmour/tracker/downgrade/StatTrackerBattleHungry.java

@@ -0,0 +1,130 @@
+package WayofTime.bloodmagic.livingArmour.tracker.downgrade;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+import WayofTime.bloodmagic.api.Constants;
+import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
+import WayofTime.bloodmagic.api.livingArmour.StatTracker;
+import WayofTime.bloodmagic.livingArmour.LivingArmour;
+import WayofTime.bloodmagic.livingArmour.downgrade.LivingArmourUpgradeBattleHungry;
+import WayofTime.bloodmagic.util.Utils;
+
+public class StatTrackerBattleHungry extends StatTracker
+{
+    public double totalDamageDealt = 0;
+
+    public static HashMap<LivingArmour, Double> changeMap = new HashMap<LivingArmour, Double>();
+    public static int[] damageRequired = new int[] { 200, 800, 1300, 2500, 3800, 5000 };
+
+    public static void incrementCounter(LivingArmour armour, double damage)
+    {
+        changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + damage : damage);
+    }
+
+    @Override
+    public String getUniqueIdentifier()
+    {
+        return Constants.Mod.MODID + ".tracker.battleHunger";
+    }
+
+    @Override
+    public void resetTracker()
+    {
+        this.totalDamageDealt = 0;
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound tag)
+    {
+        totalDamageDealt = tag.getDouble(Constants.Mod.MODID + ".tracker.battleHunger");
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound tag)
+    {
+        tag.setDouble(Constants.Mod.MODID + ".tracker.battleHunger", totalDamageDealt);
+    }
+
+    @Override
+    public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour)
+    {
+        if (changeMap.containsKey(livingArmour))
+        {
+            double change = Math.abs(changeMap.get(livingArmour));
+            if (change > 0)
+            {
+                totalDamageDealt += Math.abs(changeMap.get(livingArmour));
+                System.out.println(totalDamageDealt);
+                changeMap.put(livingArmour, 0d);
+
+                this.markDirty();
+
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    @Override
+    public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour)
+    {
+        if (changeMap.containsKey(livingArmour))
+        {
+            changeMap.remove(livingArmour);
+        }
+    }
+
+    @Override
+    public List<LivingArmourUpgrade> getUpgrades()
+    {
+        List<LivingArmourUpgrade> upgradeList = new ArrayList<LivingArmourUpgrade>();
+
+        for (int i = 0; i < 5; i++)
+        {
+            if (totalDamageDealt >= damageRequired[i])
+            {
+                upgradeList.add(new LivingArmourUpgradeBattleHungry(i));
+            }
+        }
+
+        return upgradeList;
+    }
+
+    @Override
+    public double getProgress(LivingArmour livingArmour, int currentLevel)
+    {
+        return Utils.calculateStandardProgress(totalDamageDealt, damageRequired, currentLevel);
+    }
+
+    @Override
+    public boolean providesUpgrade(String key)
+    {
+        return key.equals(Constants.Mod.MODID + ".upgrade.battleHunger");
+    }
+
+    @Override
+    public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade)
+    {
+        if (upgrade instanceof LivingArmourUpgradeBattleHungry)
+        {
+            int level = upgrade.getUpgradeLevel();
+            if (level < damageRequired.length)
+            {
+                totalDamageDealt = Math.max(totalDamageDealt, damageRequired[level]);
+                this.markDirty();
+            }
+        }
+    }
+
+    @Override
+    public boolean isTrackerDowngrade()
+    {
+        return true;
+    }
+}

src/main/java/WayofTime/bloodmagic/livingArmour/tracker/downgrade/StatTrackerMeleeDecrease.java

@@ -59,7 +59,6 @@ public class StatTrackerMeleeDecrease extends StatTracker
             if (change > 0)
             {
                 totalDamageDealt += Math.abs(changeMap.get(livingArmour));
-                System.out.println(totalDamageDealt);
                 changeMap.put(livingArmour, 0d);
 
                 this.markDirty();

src/main/java/WayofTime/bloodmagic/livingArmour/tracker/downgrade/StatTrackerQuenched.java

@@ -0,0 +1,129 @@
+package WayofTime.bloodmagic.livingArmour.tracker.downgrade;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+import WayofTime.bloodmagic.api.Constants;
+import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
+import WayofTime.bloodmagic.api.livingArmour.StatTracker;
+import WayofTime.bloodmagic.livingArmour.LivingArmour;
+import WayofTime.bloodmagic.livingArmour.downgrade.LivingArmourUpgradeQuenched;
+import WayofTime.bloodmagic.util.Utils;
+
+public class StatTrackerQuenched extends StatTracker
+{
+    public int totalQuafs = 0;
+
+    public static HashMap<LivingArmour, Integer> changeMap = new HashMap<LivingArmour, Integer>();
+    public static int[] quafsRequired = new int[] { 16 };
+
+    public static void incrementCounter(LivingArmour armour)
+    {
+        changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + 1 : 1);
+    }
+
+    @Override
+    public String getUniqueIdentifier()
+    {
+        return Constants.Mod.MODID + ".tracker.quenched";
+    }
+
+    @Override
+    public void resetTracker()
+    {
+        this.totalQuafs = 0;
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound tag)
+    {
+        totalQuafs = tag.getInteger(Constants.Mod.MODID + ".tracker.quenched");
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound tag)
+    {
+        tag.setInteger(Constants.Mod.MODID + ".tracker.quenched", totalQuafs);
+    }
+
+    @Override
+    public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour)
+    {
+        if (changeMap.containsKey(livingArmour))
+        {
+            int change = Math.abs(changeMap.get(livingArmour));
+            if (change > 0)
+            {
+                totalQuafs += Math.abs(changeMap.get(livingArmour));
+                changeMap.put(livingArmour, 0);
+
+                this.markDirty();
+
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    @Override
+    public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour)
+    {
+        if (changeMap.containsKey(livingArmour))
+        {
+            changeMap.remove(livingArmour);
+        }
+    }
+
+    @Override
+    public List<LivingArmourUpgrade> getUpgrades()
+    {
+        List<LivingArmourUpgrade> upgradeList = new ArrayList<LivingArmourUpgrade>();
+
+        for (int i = 0; i < 1; i++)
+        {
+            if (totalQuafs >= quafsRequired[i])
+            {
+                upgradeList.add(new LivingArmourUpgradeQuenched(i));
+            }
+        }
+
+        return upgradeList;
+    }
+
+    @Override
+    public double getProgress(LivingArmour livingArmour, int currentLevel)
+    {
+        return Utils.calculateStandardProgress(totalQuafs, quafsRequired, currentLevel);
+    }
+
+    @Override
+    public boolean providesUpgrade(String key)
+    {
+        return key.equals(Constants.Mod.MODID + ".upgrade.quenched");
+    }
+
+    @Override
+    public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade)
+    {
+        if (upgrade instanceof LivingArmourUpgradeQuenched)
+        {
+            int level = upgrade.getUpgradeLevel();
+            if (level < quafsRequired.length)
+            {
+                totalQuafs = Math.max(totalQuafs, quafsRequired[level]);
+                this.markDirty();
+            }
+        }
+    }
+
+    @Override
+    public boolean isTrackerDowngrade()
+    {
+        return true;
+    }
+}

src/main/java/WayofTime/bloodmagic/livingArmour/upgrade/LivingArmourUpgradeRepairing.java

@@ -0,0 +1,87 @@
+package WayofTime.bloodmagic.livingArmour.upgrade;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.inventory.EntityEquipmentSlot;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+import WayofTime.bloodmagic.api.Constants;
+import WayofTime.bloodmagic.api.livingArmour.ILivingArmour;
+import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
+
+public class LivingArmourUpgradeRepairing extends LivingArmourUpgrade
+{
+    public static final int[] costs = new int[] { 15 };
+    public static final int[] repairDelay = new int[] { 200 };
+
+    int maxRepair = 1;
+
+    int delay = 0;
+
+    public LivingArmourUpgradeRepairing(int level)
+    {
+        super(level);
+    }
+
+    @Override
+    public void onTick(World world, EntityPlayer player, ILivingArmour livingArmour)
+    {
+        if (delay <= 0)
+        {
+            delay = repairDelay[this.level];
+
+            EntityEquipmentSlot randomSlot = EntityEquipmentSlot.values()[2 + world.rand.nextInt(4)];
+            ItemStack repairStack = player.getItemStackFromSlot(randomSlot);
+            if (repairStack != null)
+            {
+                if (repairStack.isItemStackDamageable() && repairStack.isItemDamaged())
+                {
+                    int toRepair = Math.min(maxRepair, repairStack.getItemDamage());
+                    if (toRepair > 0)
+                    {
+                        repairStack.setItemDamage(repairStack.getItemDamage() - toRepair);
+                    }
+                }
+            }
+        } else
+        {
+            delay--;
+        }
+    }
+
+    @Override
+    public String getUniqueIdentifier()
+    {
+        return Constants.Mod.MODID + ".upgrade.repair";
+    }
+
+    @Override
+    public int getMaxTier()
+    {
+        return 1; // Set to here until I can add more upgrades to it.
+    }
+
+    @Override
+    public int getCostOfUpgrade()
+    {
+        return costs[this.level];
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound tag)
+    {
+        tag.setInteger("repairingDelay", delay);
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound tag)
+    {
+        delay = tag.getInteger("repairingDelay");
+    }
+
+    @Override
+    public String getUnlocalizedName()
+    {
+        return tooltipBase + "repair";
+    }
+}

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

@@ -24,11 +24,14 @@ import WayofTime.bloodmagic.livingArmour.tracker.StatTrackerMovement;
 import WayofTime.bloodmagic.livingArmour.tracker.StatTrackerNightSight;
 import WayofTime.bloodmagic.livingArmour.tracker.StatTrackerPhysicalProtect;
 import WayofTime.bloodmagic.livingArmour.tracker.StatTrackerPoison;
+import WayofTime.bloodmagic.livingArmour.tracker.StatTrackerRepairing;
 import WayofTime.bloodmagic.livingArmour.tracker.StatTrackerSelfSacrifice;
 import WayofTime.bloodmagic.livingArmour.tracker.StatTrackerSolarPowered;
 import WayofTime.bloodmagic.livingArmour.tracker.StatTrackerSprintAttack;
 import WayofTime.bloodmagic.livingArmour.tracker.StatTrackerStepAssist;
+import WayofTime.bloodmagic.livingArmour.tracker.downgrade.StatTrackerBattleHungry;
 import WayofTime.bloodmagic.livingArmour.tracker.downgrade.StatTrackerMeleeDecrease;
+import WayofTime.bloodmagic.livingArmour.tracker.downgrade.StatTrackerQuenched;
 import WayofTime.bloodmagic.livingArmour.tracker.downgrade.StatTrackerSlowness;
 import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeArrowShot;
 import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeCriticalStrike;
@@ -46,6 +49,7 @@ import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeMeleeDamage;
 import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeNightSight;
 import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradePhysicalProtect;
 import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradePoisonResist;
+import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeRepairing;
 import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeSelfSacrifice;
 import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeSolarPowered;
 import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeSpeed;
@@ -76,9 +80,12 @@ public class ModArmourTrackers
         LivingArmourHandler.registerStatTracker(StatTrackerCriticalStrike.class);
         LivingArmourHandler.registerStatTracker(StatTrackerFireResist.class);
         LivingArmourHandler.registerStatTracker(StatTrackerNightSight.class);
+        LivingArmourHandler.registerStatTracker(StatTrackerRepairing.class);
 
         LivingArmourHandler.registerStatTracker(StatTrackerMeleeDecrease.class);
         LivingArmourHandler.registerStatTracker(StatTrackerSlowness.class);
+        LivingArmourHandler.registerStatTracker(StatTrackerBattleHungry.class);
+        LivingArmourHandler.registerStatTracker(StatTrackerQuenched.class);
 
         LivingArmourHandler.registerArmourUpgrade(new LivingArmourUpgradeSpeed(0));
         LivingArmourHandler.registerArmourUpgrade(new LivingArmourUpgradeDigging(0));
@@ -101,6 +108,7 @@ public class ModArmourTrackers
         LivingArmourHandler.registerArmourUpgrade(new LivingArmourUpgradeElytra(0));
         LivingArmourHandler.registerArmourUpgrade(new LivingArmourUpgradeFireResist(0));
         LivingArmourHandler.registerArmourUpgrade(new LivingArmourUpgradeNightSight(0));
+        LivingArmourHandler.registerArmourUpgrade(new LivingArmourUpgradeRepairing(0));
 
         LivingArmourHandler.registerArmourUpgrade(new LivingArmourUpgradeSlowness(0));
         LivingArmourHandler.registerArmourUpgrade(new LivingArmourUpgradeCrippledArm(0));

src/main/java/WayofTime/bloodmagic/util/handler/event/CraftingHandler.java

@@ -1,5 +1,16 @@
 package WayofTime.bloodmagic.util.handler.event;
 
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.init.Items;
+import net.minecraft.item.EnumDyeColor;
+import net.minecraft.item.ItemBanner;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.ForgeModContainer;
+import net.minecraftforge.event.AnvilUpdateEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import WayofTime.bloodmagic.ConfigHandler;
 import WayofTime.bloodmagic.annot.Handler;
 import WayofTime.bloodmagic.api.BloodMagicAPI;
@@ -11,17 +22,6 @@ import WayofTime.bloodmagic.api.util.helper.ItemHelper;
 import WayofTime.bloodmagic.api.util.helper.NBTHelper;
 import WayofTime.bloodmagic.item.ItemInscriptionTool;
 import WayofTime.bloodmagic.registry.ModItems;
-import net.minecraft.init.Items;
-import net.minecraft.item.EnumDyeColor;
-import net.minecraft.item.ItemBanner;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraftforge.common.ForgeModContainer;
-import net.minecraftforge.event.AnvilUpdateEvent;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
-
-import java.util.ArrayList;
-import java.util.List;
 
 @Handler
 public class CraftingHandler

src/main/java/WayofTime/bloodmagic/util/handler/event/LivingArmourHandler.java

@@ -12,6 +12,7 @@ import net.minecraft.item.ItemStack;
 import net.minecraft.util.EnumHand;
 import net.minecraft.world.World;
 import net.minecraftforge.event.entity.living.LivingDeathEvent;
+import net.minecraftforge.event.entity.living.LivingEntityUseItemEvent;
 import net.minecraftforge.event.entity.living.LivingEvent;
 import net.minecraftforge.event.entity.player.ArrowLooseEvent;
 import net.minecraftforge.event.entity.player.PlayerInteractEvent;
@@ -28,6 +29,7 @@ import WayofTime.bloodmagic.livingArmour.downgrade.LivingArmourUpgradeQuenched;
 import WayofTime.bloodmagic.livingArmour.tracker.StatTrackerArrowShot;
 import WayofTime.bloodmagic.livingArmour.tracker.StatTrackerGrimReaperSprint;
 import WayofTime.bloodmagic.livingArmour.tracker.StatTrackerJump;
+import WayofTime.bloodmagic.livingArmour.tracker.downgrade.StatTrackerQuenched;
 import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeArrowShot;
 import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeGrimReaperSprint;
 import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeJump;
@@ -38,6 +40,34 @@ import WayofTime.bloodmagic.registry.ModPotions;
 @Handler
 public class LivingArmourHandler
 {
+
+    @SubscribeEvent
+    public void onFinishedItem(LivingEntityUseItemEvent.Finish event)
+    {
+        if (event.getEntityLiving() instanceof EntityPlayer)
+        {
+            EntityPlayer player = (EntityPlayer) event.getEntityLiving();
+            ItemStack heldStack = event.getItem();
+
+            if (heldStack != null && heldStack.getItemUseAction() == EnumAction.DRINK)
+            {
+                if (player.getItemInUseCount() <= 1)
+                {
+                    if (LivingArmour.hasFullSet(player))
+                    {
+                        ItemStack chestStack = player.getItemStackFromSlot(EntityEquipmentSlot.CHEST);
+                        LivingArmour armour = ItemLivingArmour.getLivingArmour(chestStack);
+                        if (armour != null)
+                        {
+                            //Stat tracker~
+                            StatTrackerQuenched.incrementCounter(armour);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     @SubscribeEvent
     public void onPlayerClick(PlayerInteractEvent event)
     {
@@ -63,6 +93,8 @@ public class LivingArmourHandler
 
                     if (event.getItemStack() != null && event.getItemStack().getItemUseAction() == EnumAction.DRINK)
                     {
+                        ItemStack drinkStack = event.getItemStack();
+
                         //TODO: See if the item is a splash potion? Those should be usable.
                         LivingArmourUpgrade upgrade = ItemLivingArmour.getUpgrade(Constants.Mod.MODID + ".upgrade.quenched", chestStack);
 

src/main/java/WayofTime/bloodmagic/util/handler/event/StatTrackerHandler.java

@@ -34,6 +34,7 @@ import WayofTime.bloodmagic.livingArmour.tracker.StatTrackerNightSight;
 import WayofTime.bloodmagic.livingArmour.tracker.StatTrackerPhysicalProtect;
 import WayofTime.bloodmagic.livingArmour.tracker.StatTrackerSolarPowered;
 import WayofTime.bloodmagic.livingArmour.tracker.StatTrackerSprintAttack;
+import WayofTime.bloodmagic.livingArmour.tracker.downgrade.StatTrackerBattleHungry;
 import WayofTime.bloodmagic.livingArmour.tracker.downgrade.StatTrackerMeleeDecrease;
 import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeDigging;
 import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeExperience;
@@ -166,6 +167,9 @@ public class StatTrackerHandler
                         if (player.isPotionActive(MobEffects.WEAKNESS))
                             StatTrackerMeleeDecrease.incrementCounter(armour, amount);
 
+                        if (player.isPotionActive(MobEffects.HUNGER))
+                            StatTrackerBattleHungry.incrementCounter(armour, amount);
+
                         if (player.worldObj.getLight(player.getPosition()) <= 9)
                             StatTrackerNightSight.incrementCounter(armour, amount);
 

src/main/resources/assets/bloodmagic/lang/en_US.lang

@@ -486,6 +486,7 @@ tooltip.BloodMagic.livingArmour.upgrade.sprintAttack=Charging Strike
 tooltip.BloodMagic.livingArmour.upgrade.criticalStrike=True Strike
 tooltip.BloodMagic.livingArmour.upgrade.elytra=Elytra
 tooltip.BloodMagic.livingArmour.upgrade.nightSight=Nocturnal Prowess
+tooltip.BloodMagic.livingArmour.upgrade.repair=Repairing
 
 
 tooltip.BloodMagic.livingArmour.upgrade.slowness=Limp Leg