lauchmelder/BloodMagic
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Run formatter

Browse source
This commit is contained in:
Nicholas Ignoffo 2017-08-15 21:30:48 -07:00
parent 61c44a831b
commit 08258fd6ef
606 changed files with 13464 additions and 22975 deletions
Download patch file Download diff file Expand all files Collapse all files

88
src/main/java/WayofTime/bloodmagic/livingArmour/tracker/StatTrackerArrowProtect.java
View file

@ -1,63 +1,49 @@
package WayofTime.bloodmagic.livingArmour.tracker;
import WayofTime.bloodmagic.BloodMagic;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeArrowProtect;
import WayofTime.bloodmagic.util.Utils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import WayofTime.bloodmagic.BloodMagic;
import WayofTime.bloodmagic.util.Utils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeArrowProtect;
public class StatTrackerArrowProtect extends StatTracker
{
public class StatTrackerArrowProtect extends StatTracker {
public static HashMap<LivingArmour, Double> changeMap = new HashMap<LivingArmour, Double>();
public static int[] damageRequired = new int[]{30, 200, 400, 800, 1500, 2500, 3500, 5000, 7000, 15000};
public int totalDamage = 0;
public static HashMap<LivingArmour, Double> changeMap = new HashMap<LivingArmour, Double>();
public static int[] damageRequired = new int[] { 30, 200, 400, 800, 1500, 2500, 3500, 5000, 7000, 15000 };
public static void incrementCounter(LivingArmour armour, double damage)
{
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + damage : damage);
}
@Override
public String getUniqueIdentifier()
{
public String getUniqueIdentifier() {
return BloodMagic.MODID + ".tracker.arrowProtect";
}
@Override
public void resetTracker()
{
public void resetTracker() {
this.totalDamage = 0;
}
@Override
public void readFromNBT(NBTTagCompound tag)
{
public void readFromNBT(NBTTagCompound tag) {
totalDamage = tag.getInteger(BloodMagic.MODID + ".tracker.arrowProtect");
}
@Override
public void writeToNBT(NBTTagCompound tag)
{
public void writeToNBT(NBTTagCompound tag) {
tag.setInteger(BloodMagic.MODID + ".tracker.arrowProtect", totalDamage);
}
@Override
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
double change = Math.abs(changeMap.get(livingArmour));
if (change > 0)
{
if (change > 0) {
totalDamage += Math.abs(changeMap.get(livingArmour));
changeMap.put(livingArmour, 0d);
@ -72,23 +58,18 @@ public class StatTrackerArrowProtect extends StatTracker
}
@Override
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
changeMap.remove(livingArmour);
}
}
@Override
public List<LivingArmourUpgrade> getUpgrades()
{
public List<LivingArmourUpgrade> getUpgrades() {
List<LivingArmourUpgrade> upgradeList = new ArrayList<LivingArmourUpgrade>();
for (int i = 0; i < 10; i++)
{
if (totalDamage >= damageRequired[i])
{
for (int i = 0; i < 10; i++) {
if (totalDamage >= damageRequired[i]) {
upgradeList.add(new LivingArmourUpgradeArrowProtect(i));
}
}
@ -97,28 +78,27 @@ public class StatTrackerArrowProtect extends StatTracker
}
@Override
public double getProgress(LivingArmour livingArmour, int currentLevel)
{
public double getProgress(LivingArmour livingArmour, int currentLevel) {
return Utils.calculateStandardProgress(totalDamage, damageRequired, currentLevel);
}
@Override
public boolean providesUpgrade(String key)
{
public boolean providesUpgrade(String key) {
return key.equals(BloodMagic.MODID + ".upgrade.arrowProtect");
}
@Override
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade)
{
if (upgrade instanceof LivingArmourUpgradeArrowProtect)
{
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade) {
if (upgrade instanceof LivingArmourUpgradeArrowProtect) {
int level = upgrade.getUpgradeLevel();
if (level < damageRequired.length)
{
if (level < damageRequired.length) {
totalDamage = Math.max(totalDamage, damageRequired[level]);
this.markDirty();
}
}
}
public static void incrementCounter(LivingArmour armour, double damage) {
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + damage : damage);
}
}

82
src/main/java/WayofTime/bloodmagic/livingArmour/tracker/StatTrackerArrowShot.java
View file

@ -1,63 +1,49 @@
package WayofTime.bloodmagic.livingArmour.tracker;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import WayofTime.bloodmagic.BloodMagic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeArrowShot;
import WayofTime.bloodmagic.util.Utils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
public class StatTrackerArrowShot extends StatTracker
{
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class StatTrackerArrowShot extends StatTracker {
public static HashMap<LivingArmour, Integer> changeMap = new HashMap<LivingArmour, Integer>();
public static int[] shotsRequired = new int[]{50, 200, 700, 1500, 3000};
public int totalShots = 0;
public static HashMap<LivingArmour, Integer> changeMap = new HashMap<LivingArmour, Integer>();
public static int[] shotsRequired = new int[] { 50, 200, 700, 1500, 3000 };
public static void incrementCounter(LivingArmour armour)
{
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + 1 : 1);
}
@Override
public String getUniqueIdentifier()
{
public String getUniqueIdentifier() {
return BloodMagic.MODID + ".tracker.trickShot";
}
@Override
public void resetTracker()
{
public void resetTracker() {
this.totalShots = 0;
}
@Override
public void readFromNBT(NBTTagCompound tag)
{
public void readFromNBT(NBTTagCompound tag) {
totalShots = tag.getInteger(BloodMagic.MODID + ".tracker.trickShot");
}
@Override
public void writeToNBT(NBTTagCompound tag)
{
public void writeToNBT(NBTTagCompound tag) {
tag.setInteger(BloodMagic.MODID + ".tracker.trickShot", totalShots);
}
@Override
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
int change = Math.abs(changeMap.get(livingArmour));
if (change > 0)
{
if (change > 0) {
totalShots += Math.abs(changeMap.get(livingArmour));
changeMap.put(livingArmour, 0);
@ -72,23 +58,18 @@ public class StatTrackerArrowShot extends StatTracker
}
@Override
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
changeMap.remove(livingArmour);
}
}
@Override
public List<LivingArmourUpgrade> getUpgrades()
{
public List<LivingArmourUpgrade> getUpgrades() {
List<LivingArmourUpgrade> upgradeList = new ArrayList<LivingArmourUpgrade>();
for (int i = 0; i < 5; i++)
{
if (totalShots >= shotsRequired[i])
{
for (int i = 0; i < 5; i++) {
if (totalShots >= shotsRequired[i]) {
upgradeList.add(new LivingArmourUpgradeArrowShot(i));
}
}
@ -97,28 +78,27 @@ public class StatTrackerArrowShot extends StatTracker
}
@Override
public double getProgress(LivingArmour livingArmour, int currentLevel)
{
public double getProgress(LivingArmour livingArmour, int currentLevel) {
return Utils.calculateStandardProgress(totalShots, shotsRequired, currentLevel);
}
@Override
public boolean providesUpgrade(String key)
{
public boolean providesUpgrade(String key) {
return key.equals(BloodMagic.MODID + ".upgrade.arrowShot");
}
@Override
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade)
{
if (upgrade instanceof LivingArmourUpgradeArrowShot)
{
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade) {
if (upgrade instanceof LivingArmourUpgradeArrowShot) {
int level = upgrade.getUpgradeLevel();
if (level < shotsRequired.length)
{
if (level < shotsRequired.length) {
totalShots = Math.max(totalShots, shotsRequired[level]);
this.markDirty();
}
}
}
public static void incrementCounter(LivingArmour armour) {
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + 1 : 1);
}
}

82
src/main/java/WayofTime/bloodmagic/livingArmour/tracker/StatTrackerCriticalStrike.java
View file

@ -1,63 +1,49 @@
package WayofTime.bloodmagic.livingArmour.tracker;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import WayofTime.bloodmagic.BloodMagic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeCriticalStrike;
import WayofTime.bloodmagic.util.Utils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
public class StatTrackerCriticalStrike extends StatTracker
{
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class StatTrackerCriticalStrike extends StatTracker {
public static HashMap<LivingArmour, Double> changeMap = new HashMap<LivingArmour, Double>();
public static int[] damageRequired = new int[]{200, 800, 1300, 2500, 3800};
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 };
public static void incrementCounter(LivingArmour armour, double damage)
{
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + damage : damage);
}
@Override
public String getUniqueIdentifier()
{
public String getUniqueIdentifier() {
return BloodMagic.MODID + ".tracker.criticalStrike";
}
@Override
public void resetTracker()
{
public void resetTracker() {
this.totalDamageDealt = 0;
}
@Override
public void readFromNBT(NBTTagCompound tag)
{
public void readFromNBT(NBTTagCompound tag) {
totalDamageDealt = tag.getDouble(BloodMagic.MODID + ".tracker.criticalStrike");
}
@Override
public void writeToNBT(NBTTagCompound tag)
{
public void writeToNBT(NBTTagCompound tag) {
tag.setDouble(BloodMagic.MODID + ".tracker.criticalStrike", totalDamageDealt);
}
@Override
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
double change = Math.abs(changeMap.get(livingArmour));
if (change > 0)
{
if (change > 0) {
totalDamageDealt += Math.abs(changeMap.get(livingArmour));
changeMap.put(livingArmour, 0d);
@ -72,23 +58,18 @@ public class StatTrackerCriticalStrike extends StatTracker
}
@Override
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
changeMap.remove(livingArmour);
}
}
@Override
public List<LivingArmourUpgrade> getUpgrades()
{
public List<LivingArmourUpgrade> getUpgrades() {
List<LivingArmourUpgrade> upgradeList = new ArrayList<LivingArmourUpgrade>();
for (int i = 0; i < 5; i++)
{
if (totalDamageDealt >= damageRequired[i])
{
for (int i = 0; i < 5; i++) {
if (totalDamageDealt >= damageRequired[i]) {
upgradeList.add(new LivingArmourUpgradeCriticalStrike(i));
}
}
@ -97,28 +78,27 @@ public class StatTrackerCriticalStrike extends StatTracker
}
@Override
public double getProgress(LivingArmour livingArmour, int currentLevel)
{
public double getProgress(LivingArmour livingArmour, int currentLevel) {
return Utils.calculateStandardProgress(totalDamageDealt, damageRequired, currentLevel);
}
@Override
public boolean providesUpgrade(String key)
{
public boolean providesUpgrade(String key) {
return key.equals(BloodMagic.MODID + ".upgrade.criticalStrike");
}
@Override
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade)
{
if (upgrade instanceof LivingArmourUpgradeCriticalStrike)
{
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade) {
if (upgrade instanceof LivingArmourUpgradeCriticalStrike) {
int level = upgrade.getUpgradeLevel();
if (level < damageRequired.length)
{
if (level < damageRequired.length) {
totalDamageDealt = Math.max(totalDamageDealt, damageRequired[level]);
this.markDirty();
}
}
}
public static void incrementCounter(LivingArmour armour, double damage) {
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + damage : damage);
}
}

82
src/main/java/WayofTime/bloodmagic/livingArmour/tracker/StatTrackerDigging.java
View file

@ -1,63 +1,49 @@
package WayofTime.bloodmagic.livingArmour.tracker;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import WayofTime.bloodmagic.BloodMagic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeDigging;
import WayofTime.bloodmagic.util.Utils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
public class StatTrackerDigging extends StatTracker
{
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class StatTrackerDigging extends StatTracker {
public static HashMap<LivingArmour, Integer> changeMap = new HashMap<LivingArmour, Integer>();
public static int[] blocksRequired = new int[]{128, 512, 1024, 2048, 8192, 16000, 32000, 50000, 80000, 150000};
public int totalBlocksDug = 0;
public static HashMap<LivingArmour, Integer> changeMap = new HashMap<LivingArmour, Integer>();
public static int[] blocksRequired = new int[] { 128, 512, 1024, 2048, 8192, 16000, 32000, 50000, 80000, 150000 };
public static void incrementCounter(LivingArmour armour)
{
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + 1 : 1);
}
@Override
public String getUniqueIdentifier()
{
public String getUniqueIdentifier() {
return BloodMagic.MODID + ".tracker.digging";
}
@Override
public void resetTracker()
{
public void resetTracker() {
this.totalBlocksDug = 0;
}
@Override
public void readFromNBT(NBTTagCompound tag)
{
public void readFromNBT(NBTTagCompound tag) {
totalBlocksDug = tag.getInteger(BloodMagic.MODID + ".tracker.digging");
}
@Override
public void writeToNBT(NBTTagCompound tag)
{
public void writeToNBT(NBTTagCompound tag) {
tag.setInteger(BloodMagic.MODID + ".tracker.digging", totalBlocksDug);
}
@Override
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
int change = Math.abs(changeMap.get(livingArmour));
if (change > 0)
{
if (change > 0) {
totalBlocksDug += Math.abs(changeMap.get(livingArmour));
changeMap.put(livingArmour, 0);
@ -72,23 +58,18 @@ public class StatTrackerDigging extends StatTracker
}
@Override
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
changeMap.remove(livingArmour);
}
}
@Override
public List<LivingArmourUpgrade> getUpgrades()
{
public List<LivingArmourUpgrade> getUpgrades() {
List<LivingArmourUpgrade> upgradeList = new ArrayList<LivingArmourUpgrade>();
for (int i = 0; i < 10; i++)
{
if (totalBlocksDug >= blocksRequired[i])
{
for (int i = 0; i < 10; i++) {
if (totalBlocksDug >= blocksRequired[i]) {
upgradeList.add(new LivingArmourUpgradeDigging(i));
}
}
@ -97,28 +78,27 @@ public class StatTrackerDigging extends StatTracker
}
@Override
public double getProgress(LivingArmour livingArmour, int currentLevel)
{
public double getProgress(LivingArmour livingArmour, int currentLevel) {
return Utils.calculateStandardProgress(totalBlocksDug, blocksRequired, currentLevel);
}
@Override
public boolean providesUpgrade(String key)
{
public boolean providesUpgrade(String key) {
return key.equals(BloodMagic.MODID + ".upgrade.digging");
}
@Override
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade)
{
if (upgrade instanceof LivingArmourUpgradeDigging)
{
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade) {
if (upgrade instanceof LivingArmourUpgradeDigging) {
int level = upgrade.getUpgradeLevel();
if (level < blocksRequired.length)
{
if (level < blocksRequired.length) {
totalBlocksDug = Math.max(totalBlocksDug, blocksRequired[level]);
this.markDirty();
}
}
}
public static void incrementCounter(LivingArmour armour) {
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + 1 : 1);
}
}

82
src/main/java/WayofTime/bloodmagic/livingArmour/tracker/StatTrackerExperience.java
View file

@ -1,63 +1,49 @@
package WayofTime.bloodmagic.livingArmour.tracker;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import WayofTime.bloodmagic.BloodMagic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeExperience;
import WayofTime.bloodmagic.util.Utils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
public class StatTrackerExperience extends StatTracker
{
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class StatTrackerExperience extends StatTracker {
public static HashMap<LivingArmour, Integer> changeMap = new HashMap<LivingArmour, Integer>();
public static int[] experienceRequired = new int[]{100, 400, 1000, 1600, 3200, 5000, 7000, 9200, 11500, 140000};
public double totalExperienceGained = 0;
public static HashMap<LivingArmour, Integer> changeMap = new HashMap<LivingArmour, Integer>();
public static int[] experienceRequired = new int[] { 100, 400, 1000, 1600, 3200, 5000, 7000, 9200, 11500, 140000 };
public static void incrementCounter(LivingArmour armour, int exp)
{
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + exp : exp);
}
@Override
public String getUniqueIdentifier()
{
public String getUniqueIdentifier() {
return BloodMagic.MODID + ".tracker.experienced";
}
@Override
public void resetTracker()
{
public void resetTracker() {
this.totalExperienceGained = 0;
}
@Override
public void readFromNBT(NBTTagCompound tag)
{
public void readFromNBT(NBTTagCompound tag) {
totalExperienceGained = tag.getDouble(BloodMagic.MODID + ".tracker.experienced");
}
@Override
public void writeToNBT(NBTTagCompound tag)
{
public void writeToNBT(NBTTagCompound tag) {
tag.setDouble(BloodMagic.MODID + ".tracker.experienced", totalExperienceGained);
}
@Override
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
double change = Math.abs(changeMap.get(livingArmour));
if (change > 0)
{
if (change > 0) {
totalExperienceGained += Math.abs(changeMap.get(livingArmour));
changeMap.put(livingArmour, 0);
@ -72,23 +58,18 @@ public class StatTrackerExperience extends StatTracker
}
@Override
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
changeMap.remove(livingArmour);
}
}
@Override
public List<LivingArmourUpgrade> getUpgrades()
{
public List<LivingArmourUpgrade> getUpgrades() {
List<LivingArmourUpgrade> upgradeList = new ArrayList<LivingArmourUpgrade>();
for (int i = 0; i < 10; i++)
{
if (totalExperienceGained >= experienceRequired[i])
{
for (int i = 0; i < 10; i++) {
if (totalExperienceGained >= experienceRequired[i]) {
upgradeList.add(new LivingArmourUpgradeExperience(i));
}
}
@ -97,28 +78,27 @@ public class StatTrackerExperience extends StatTracker
}
@Override
public double getProgress(LivingArmour livingArmour, int currentLevel)
{
public double getProgress(LivingArmour livingArmour, int currentLevel) {
return Utils.calculateStandardProgress(totalExperienceGained, experienceRequired, currentLevel);
}
@Override
public boolean providesUpgrade(String key)
{
public boolean providesUpgrade(String key) {
return key.equals(BloodMagic.MODID + ".upgrade.experienced");
}
@Override
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade)
{
if (upgrade instanceof LivingArmourUpgradeExperience)
{
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade) {
if (upgrade instanceof LivingArmourUpgradeExperience) {
int level = upgrade.getUpgradeLevel();
if (level < experienceRequired.length)
{
if (level < experienceRequired.length) {
totalExperienceGained = Math.max(totalExperienceGained, experienceRequired[level]);
this.markDirty();
}
}
}
public static void incrementCounter(LivingArmour armour, int exp) {
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + exp : exp);
}
}

82
src/main/java/WayofTime/bloodmagic/livingArmour/tracker/StatTrackerFallProtect.java
View file

@ -1,63 +1,49 @@
package WayofTime.bloodmagic.livingArmour.tracker;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import WayofTime.bloodmagic.BloodMagic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeFallProtect;
import WayofTime.bloodmagic.util.Utils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
public class StatTrackerFallProtect extends StatTracker
{
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class StatTrackerFallProtect extends StatTracker {
public static HashMap<LivingArmour, Double> changeMap = new HashMap<LivingArmour, Double>();
public static int[] damageRequired = new int[]{30, 200, 400, 800, 1500};
public int totalDamage = 0;
public static HashMap<LivingArmour, Double> changeMap = new HashMap<LivingArmour, Double>();
public static int[] damageRequired = new int[] { 30, 200, 400, 800, 1500 };
public static void incrementCounter(LivingArmour armour, double damage)
{
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + damage : damage);
}
@Override
public String getUniqueIdentifier()
{
public String getUniqueIdentifier() {
return BloodMagic.MODID + ".tracker.fallProtect";
}
@Override
public void resetTracker()
{
public void resetTracker() {
this.totalDamage = 0;
}
@Override
public void readFromNBT(NBTTagCompound tag)
{
public void readFromNBT(NBTTagCompound tag) {
totalDamage = tag.getInteger(BloodMagic.MODID + ".tracker.fallProtect");
}
@Override
public void writeToNBT(NBTTagCompound tag)
{
public void writeToNBT(NBTTagCompound tag) {
tag.setInteger(BloodMagic.MODID + ".tracker.fallProtect", totalDamage);
}
@Override
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
double change = Math.abs(changeMap.get(livingArmour));
if (change > 0)
{
if (change > 0) {
totalDamage += Math.abs(changeMap.get(livingArmour));
changeMap.put(livingArmour, 0d);
@ -72,23 +58,18 @@ public class StatTrackerFallProtect extends StatTracker
}
@Override
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
changeMap.remove(livingArmour);
}
}
@Override
public List<LivingArmourUpgrade> getUpgrades()
{
public List<LivingArmourUpgrade> getUpgrades() {
List<LivingArmourUpgrade> upgradeList = new ArrayList<LivingArmourUpgrade>();
for (int i = 0; i < 5; i++)
{
if (totalDamage >= damageRequired[i])
{
for (int i = 0; i < 5; i++) {
if (totalDamage >= damageRequired[i]) {
upgradeList.add(new LivingArmourUpgradeFallProtect(i));
}
}
@ -97,28 +78,27 @@ public class StatTrackerFallProtect extends StatTracker
}
@Override
public double getProgress(LivingArmour livingArmour, int currentLevel)
{
public double getProgress(LivingArmour livingArmour, int currentLevel) {
return Utils.calculateStandardProgress(totalDamage, damageRequired, currentLevel);
}
@Override
public boolean providesUpgrade(String key)
{
public boolean providesUpgrade(String key) {
return key.equals(BloodMagic.MODID + ".upgrade.fallProtect");
}
@Override
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade)
{
if (upgrade instanceof LivingArmourUpgradeFallProtect)
{
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade) {
if (upgrade instanceof LivingArmourUpgradeFallProtect) {
int level = upgrade.getUpgradeLevel();
if (level < damageRequired.length)
{
if (level < damageRequired.length) {
totalDamage = Math.max(totalDamage, damageRequired[level]);
this.markDirty();
}
}
}
public static void incrementCounter(LivingArmour armour, double damage) {
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + damage : damage);
}
}

63
src/main/java/WayofTime/bloodmagic/livingArmour/tracker/StatTrackerFireResist.java
View file

@ -1,53 +1,45 @@
package WayofTime.bloodmagic.livingArmour.tracker;
import java.util.ArrayList;
import java.util.List;
import WayofTime.bloodmagic.BloodMagic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeFireResist;
import WayofTime.bloodmagic.util.Utils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
public class StatTrackerFireResist extends StatTracker
{
import java.util.ArrayList;
import java.util.List;
public class StatTrackerFireResist extends StatTracker {
public static int[] fireTicksRequired = new int[]{60 * 20, 3 * 60 * 20, 10 * 60 * 20, 20 * 60 * 20, 25 * 60 * 20};
public int totalFireTicks = 0;
public static int[] fireTicksRequired = new int[] { 60 * 20, 3 * 60 * 20, 10 * 60 * 20, 20 * 60 * 20, 25 * 60 * 20 };
@Override
public String getUniqueIdentifier()
{
public String getUniqueIdentifier() {
return BloodMagic.MODID + ".tracker.fire";
}
@Override
public void resetTracker()
{
public void resetTracker() {
this.totalFireTicks = 0;
}
@Override
public void readFromNBT(NBTTagCompound tag)
{
public void readFromNBT(NBTTagCompound tag) {
totalFireTicks = tag.getInteger(BloodMagic.MODID + ".tracker.fire");
}
@Override
public void writeToNBT(NBTTagCompound tag)
{
public void writeToNBT(NBTTagCompound tag) {
tag.setInteger(BloodMagic.MODID + ".tracker.fire", totalFireTicks);
}
@Override
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (player.isBurning())
{
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (player.isBurning()) {
totalFireTicks++;
this.markDirty();
return true;
@ -57,20 +49,16 @@ public class StatTrackerFireResist extends StatTracker
}
@Override
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour) {
}
@Override
public List<LivingArmourUpgrade> getUpgrades()
{
public List<LivingArmourUpgrade> getUpgrades() {
List<LivingArmourUpgrade> upgradeList = new ArrayList<LivingArmourUpgrade>();
for (int i = 0; i < 5; i++)
{
if (totalFireTicks >= fireTicksRequired[i])
{
for (int i = 0; i < 5; i++) {
if (totalFireTicks >= fireTicksRequired[i]) {
upgradeList.add(new LivingArmourUpgradeFireResist(i));
}
}
@ -79,25 +67,20 @@ public class StatTrackerFireResist extends StatTracker
}
@Override
public double getProgress(LivingArmour livingArmour, int currentLevel)
{
public double getProgress(LivingArmour livingArmour, int currentLevel) {
return Utils.calculateStandardProgress(totalFireTicks, fireTicksRequired, currentLevel);
}
@Override
public boolean providesUpgrade(String key)
{
public boolean providesUpgrade(String key) {
return key.equals(BloodMagic.MODID + ".upgrade.fireResist");
}
@Override
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade)
{
if (upgrade instanceof LivingArmourUpgradeFireResist)
{
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade) {
if (upgrade instanceof LivingArmourUpgradeFireResist) {
int level = upgrade.getUpgradeLevel();
if (level < fireTicksRequired.length)
{
if (level < fireTicksRequired.length) {
totalFireTicks = Math.max(totalFireTicks, fireTicksRequired[level]);
this.markDirty();
}

76
src/main/java/WayofTime/bloodmagic/livingArmour/tracker/StatTrackerFood.java
View file

@ -1,58 +1,51 @@
package WayofTime.bloodmagic.livingArmour.tracker;
import WayofTime.bloodmagic.BloodMagic;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeKnockbackResist;
import WayofTime.bloodmagic.util.Utils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import WayofTime.bloodmagic.BloodMagic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeKnockbackResist;
import WayofTime.bloodmagic.util.Utils;
public class StatTrackerFood extends StatTracker
{
public class StatTrackerFood extends StatTracker {
public static Map<EntityPlayer, Integer> lastFoodEatenMap = new HashMap<EntityPlayer, Integer>();
public static int[] foodRequired = new int[] { 100, 200, 300, 500, 1000 };
public static int[] foodRequired = new int[]{100, 200, 300, 500, 1000};
public int foodEaten = 0;
@Override
public String getUniqueIdentifier()
{
public String getUniqueIdentifier() {
return BloodMagic.MODID + ".tracker.foodEaten";
}
@Override
public void resetTracker()
{
public void resetTracker() {
this.foodEaten = 0;
}
@Override
public void readFromNBT(NBTTagCompound tag)
{
public void readFromNBT(NBTTagCompound tag) {
foodEaten = tag.getInteger(BloodMagic.MODID + ".tracker.foodEaten");
}
@Override
public void writeToNBT(NBTTagCompound tag)
{
public void writeToNBT(NBTTagCompound tag) {
tag.setInteger(BloodMagic.MODID + ".tracker.foodEaten", foodEaten);
}
@Override
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (!lastFoodEatenMap.containsKey(player))
{
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (!lastFoodEatenMap.containsKey(player)) {
lastFoodEatenMap.put(player, 20);
return false;
}
@ -61,8 +54,7 @@ public class StatTrackerFood extends StatTracker
int prevFood = lastFoodEatenMap.get(player);
lastFoodEatenMap.put(player, currentFood);
if (currentFood > prevFood)
{
if (currentFood > prevFood) {
foodEaten += (currentFood - prevFood);
markDirty();
@ -74,23 +66,18 @@ public class StatTrackerFood extends StatTracker
}
@Override
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (lastFoodEatenMap.containsKey(player))
{
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (lastFoodEatenMap.containsKey(player)) {
lastFoodEatenMap.remove(player);
}
}
@Override
public List<LivingArmourUpgrade> getUpgrades()
{
public List<LivingArmourUpgrade> getUpgrades() {
List<LivingArmourUpgrade> upgradeList = new ArrayList<LivingArmourUpgrade>();
for (int i = 0; i < foodRequired.length; i++)
{
if (foodEaten >= foodRequired[i])
{
for (int i = 0; i < foodRequired.length; i++) {
if (foodEaten >= foodRequired[i]) {
upgradeList.add(new LivingArmourUpgradeKnockbackResist(i));
}
}
@ -99,25 +86,20 @@ public class StatTrackerFood extends StatTracker
}
@Override
public double getProgress(LivingArmour livingArmour, int currentLevel)
{
public double getProgress(LivingArmour livingArmour, int currentLevel) {
return Utils.calculateStandardProgress(foodEaten, foodRequired, currentLevel);
}
@Override
public boolean providesUpgrade(String key)
{
public boolean providesUpgrade(String key) {
return key.equals(BloodMagic.MODID + ".upgrade.knockback");
}
@Override
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade)
{
if (upgrade instanceof LivingArmourUpgradeKnockbackResist)
{
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade) {
if (upgrade instanceof LivingArmourUpgradeKnockbackResist) {
int level = upgrade.getUpgradeLevel();
if (level < foodRequired.length)
{
if (level < foodRequired.length) {
foodEaten = Math.max(foodEaten, foodRequired[level]);
this.markDirty();
}

82
src/main/java/WayofTime/bloodmagic/livingArmour/tracker/StatTrackerGraveDigger.java
View file

@ -1,63 +1,49 @@
package WayofTime.bloodmagic.livingArmour.tracker;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import WayofTime.bloodmagic.BloodMagic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeGraveDigger;
import WayofTime.bloodmagic.util.Utils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
public class StatTrackerGraveDigger extends StatTracker
{
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class StatTrackerGraveDigger extends StatTracker {
public static HashMap<LivingArmour, Double> changeMap = new HashMap<LivingArmour, Double>();
public static int[] damageRequired = new int[]{200, 800, 1300, 2500, 3800, 5000, 7000, 9200, 11500, 140000};
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, 7000, 9200, 11500, 140000 };
public static void incrementCounter(LivingArmour armour, double damage)
{
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + damage : damage);
}
@Override
public String getUniqueIdentifier()
{
public String getUniqueIdentifier() {
return BloodMagic.MODID + ".tracker.graveDigger";
}
@Override
public void resetTracker()
{
public void resetTracker() {
this.totalDamageDealt = 0;
}
@Override
public void readFromNBT(NBTTagCompound tag)
{
public void readFromNBT(NBTTagCompound tag) {
totalDamageDealt = tag.getDouble(BloodMagic.MODID + ".tracker.graveDigger");
}
@Override
public void writeToNBT(NBTTagCompound tag)
{
public void writeToNBT(NBTTagCompound tag) {
tag.setDouble(BloodMagic.MODID + ".tracker.graveDigger", totalDamageDealt);
}
@Override
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
double change = Math.abs(changeMap.get(livingArmour));
if (change > 0)
{
if (change > 0) {
totalDamageDealt += Math.abs(changeMap.get(livingArmour));
changeMap.put(livingArmour, 0d);
@ -72,23 +58,18 @@ public class StatTrackerGraveDigger extends StatTracker
}
@Override
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
changeMap.remove(livingArmour);
}
}
@Override
public List<LivingArmourUpgrade> getUpgrades()
{
public List<LivingArmourUpgrade> getUpgrades() {
List<LivingArmourUpgrade> upgradeList = new ArrayList<LivingArmourUpgrade>();
for (int i = 0; i < 10; i++)
{
if (totalDamageDealt >= damageRequired[i])
{
for (int i = 0; i < 10; i++) {
if (totalDamageDealt >= damageRequired[i]) {
upgradeList.add(new LivingArmourUpgradeGraveDigger(i));
}
}
@ -97,28 +78,27 @@ public class StatTrackerGraveDigger extends StatTracker
}
@Override
public double getProgress(LivingArmour livingArmour, int currentLevel)
{
public double getProgress(LivingArmour livingArmour, int currentLevel) {
return Utils.calculateStandardProgress(totalDamageDealt, damageRequired, currentLevel);
}
@Override
public boolean providesUpgrade(String key)
{
public boolean providesUpgrade(String key) {
return key.equals(BloodMagic.MODID + ".upgrade.graveDigger");
}
@Override
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade)
{
if (upgrade instanceof LivingArmourUpgradeGraveDigger)
{
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade) {
if (upgrade instanceof LivingArmourUpgradeGraveDigger) {
int level = upgrade.getUpgradeLevel();
if (level < damageRequired.length)
{
if (level < damageRequired.length) {
totalDamageDealt = Math.max(totalDamageDealt, damageRequired[level]);
this.markDirty();
}
}
}
public static void incrementCounter(LivingArmour armour, double damage) {
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + damage : damage);
}
}

95
src/main/java/WayofTime/bloodmagic/livingArmour/tracker/StatTrackerGrimReaperSprint.java
View file

@ -1,70 +1,49 @@
package WayofTime.bloodmagic.livingArmour.tracker;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import WayofTime.bloodmagic.BloodMagic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeGrimReaperSprint;
import WayofTime.bloodmagic.util.Utils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
public class StatTrackerGrimReaperSprint extends StatTracker
{
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class StatTrackerGrimReaperSprint extends StatTracker {
public static HashMap<LivingArmour, Integer> changeMap = new HashMap<LivingArmour, Integer>();
public static int[] deathsRequired = new int[]{6, 10, 15, 25, 50, 70, 90, 120, 150, 200}; //TODO: Modify
public int totalDeaths = 0;
public static HashMap<LivingArmour, Integer> changeMap = new HashMap<LivingArmour, Integer>();
public static int[] deathsRequired = new int[] { 6, 10, 15, 25, 50, 70, 90, 120, 150, 200 }; //TODO: Modify
public static void incrementCounter(LivingArmour armour)
{
StatTracker tracker = armour.getTracker(BloodMagic.MODID + ".tracker.grimReaper");
if (tracker instanceof StatTrackerGrimReaperSprint)
{
((StatTrackerGrimReaperSprint) tracker).totalDeaths++;
System.out.println(((StatTrackerGrimReaperSprint) tracker).totalDeaths);
tracker.markDirty();
}
// changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + 1 : 1);
}
@Override
public String getUniqueIdentifier()
{
public String getUniqueIdentifier() {
return BloodMagic.MODID + ".tracker.grimReaper";
}
@Override
public void resetTracker()
{
public void resetTracker() {
this.totalDeaths = 0;
}
@Override
public void readFromNBT(NBTTagCompound tag)
{
public void readFromNBT(NBTTagCompound tag) {
totalDeaths = tag.getInteger(BloodMagic.MODID + ".tracker.grimReaper");
}
@Override
public void writeToNBT(NBTTagCompound tag)
{
public void writeToNBT(NBTTagCompound tag) {
tag.setInteger(BloodMagic.MODID + ".tracker.grimReaper", totalDeaths);
}
@Override
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
double change = Math.abs(changeMap.get(livingArmour));
if (change > 0)
{
if (change > 0) {
totalDeaths += Math.abs(changeMap.get(livingArmour));
changeMap.put(livingArmour, 0);
@ -79,23 +58,18 @@ public class StatTrackerGrimReaperSprint extends StatTracker
}
@Override
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
changeMap.remove(livingArmour);
}
}
@Override
public List<LivingArmourUpgrade> getUpgrades()
{
public List<LivingArmourUpgrade> getUpgrades() {
List<LivingArmourUpgrade> upgradeList = new ArrayList<LivingArmourUpgrade>();
for (int i = 0; i < 10; i++)
{
if (totalDeaths >= deathsRequired[i])
{
for (int i = 0; i < 10; i++) {
if (totalDeaths >= deathsRequired[i]) {
upgradeList.add(new LivingArmourUpgradeGrimReaperSprint(i));
}
}
@ -104,28 +78,33 @@ public class StatTrackerGrimReaperSprint extends StatTracker
}
@Override
public double getProgress(LivingArmour livingArmour, int currentLevel)
{
public double getProgress(LivingArmour livingArmour, int currentLevel) {
return Utils.calculateStandardProgress(totalDeaths, deathsRequired, currentLevel);
}
@Override
public boolean providesUpgrade(String key)
{
public boolean providesUpgrade(String key) {
return key.equals(BloodMagic.MODID + ".upgrade.grimReaper");
}
@Override
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade)
{
if (upgrade instanceof LivingArmourUpgradeGrimReaperSprint)
{
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade) {
if (upgrade instanceof LivingArmourUpgradeGrimReaperSprint) {
int level = upgrade.getUpgradeLevel();
if (level < deathsRequired.length)
{
if (level < deathsRequired.length) {
totalDeaths = Math.max(totalDeaths, deathsRequired[level]);
this.markDirty();
}
}
}
public static void incrementCounter(LivingArmour armour) {
StatTracker tracker = armour.getTracker(BloodMagic.MODID + ".tracker.grimReaper");
if (tracker instanceof StatTrackerGrimReaperSprint) {
((StatTrackerGrimReaperSprint) tracker).totalDeaths++;
System.out.println(((StatTrackerGrimReaperSprint) tracker).totalDeaths);
tracker.markDirty();
}
// changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + 1 : 1);
}
}

82
src/main/java/WayofTime/bloodmagic/livingArmour/tracker/StatTrackerHealthboost.java
View file

@ -1,63 +1,49 @@
package WayofTime.bloodmagic.livingArmour.tracker;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import WayofTime.bloodmagic.BloodMagic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeHealthboost;
import WayofTime.bloodmagic.util.Utils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
public class StatTrackerHealthboost extends StatTracker
{
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class StatTrackerHealthboost extends StatTracker {
public static HashMap<LivingArmour, Double> changeMap = new HashMap<LivingArmour, Double>();
public static int[] healthedRequired = new int[]{80, 200, 340, 540, 800, 1600, 2800, 5000, 7600, 10000};
public double totalHealthGenned = 0;
public static HashMap<LivingArmour, Double> changeMap = new HashMap<LivingArmour, Double>();
public static int[] healthedRequired = new int[] { 80, 200, 340, 540, 800, 1600, 2800, 5000, 7600, 10000 };
public static void incrementCounter(LivingArmour armour, double health)
{
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + health : health);
}
@Override
public String getUniqueIdentifier()
{
public String getUniqueIdentifier() {
return BloodMagic.MODID + ".tracker.health";
}
@Override
public void resetTracker()
{
public void resetTracker() {
this.totalHealthGenned = 0;
}
@Override
public void readFromNBT(NBTTagCompound tag)
{
public void readFromNBT(NBTTagCompound tag) {
totalHealthGenned = tag.getDouble(BloodMagic.MODID + ".tracker.health");
}
@Override
public void writeToNBT(NBTTagCompound tag)
{
public void writeToNBT(NBTTagCompound tag) {
tag.setDouble(BloodMagic.MODID + ".tracker.health", totalHealthGenned);
}
@Override
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
double change = Math.abs(changeMap.get(livingArmour));
if (change > 0)
{
if (change > 0) {
totalHealthGenned += Math.abs(changeMap.get(livingArmour));
changeMap.put(livingArmour, 0d);
@ -72,23 +58,18 @@ public class StatTrackerHealthboost extends StatTracker
}
@Override
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
changeMap.remove(livingArmour);
}
}
@Override
public List<LivingArmourUpgrade> getUpgrades()
{
public List<LivingArmourUpgrade> getUpgrades() {
List<LivingArmourUpgrade> upgradeList = new ArrayList<LivingArmourUpgrade>();
for (int i = 0; i < 10; i++)
{
if (totalHealthGenned >= healthedRequired[i])
{
for (int i = 0; i < 10; i++) {
if (totalHealthGenned >= healthedRequired[i]) {
upgradeList.add(new LivingArmourUpgradeHealthboost(i));
}
}
@ -97,28 +78,27 @@ public class StatTrackerHealthboost extends StatTracker
}
@Override
public double getProgress(LivingArmour livingArmour, int currentLevel)
{
public double getProgress(LivingArmour livingArmour, int currentLevel) {
return Utils.calculateStandardProgress(totalHealthGenned, healthedRequired, currentLevel);
}
@Override
public boolean providesUpgrade(String key)
{
public boolean providesUpgrade(String key) {
return key.equals(BloodMagic.MODID + ".upgrade.health");
}
@Override
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade)
{
if (upgrade instanceof LivingArmourUpgradeHealthboost)
{
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade) {
if (upgrade instanceof LivingArmourUpgradeHealthboost) {
int level = upgrade.getUpgradeLevel();
if (level < healthedRequired.length)
{
if (level < healthedRequired.length) {
totalHealthGenned = Math.max(totalHealthGenned, healthedRequired[level]);
this.markDirty();
}
}
}
public static void incrementCounter(LivingArmour armour, double health) {
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + health : health);
}
}

79
src/main/java/WayofTime/bloodmagic/livingArmour/tracker/StatTrackerJump.java
View file

@ -1,64 +1,51 @@
package WayofTime.bloodmagic.livingArmour.tracker;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import WayofTime.bloodmagic.BloodMagic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeJump;
import WayofTime.bloodmagic.util.Utils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
public class StatTrackerJump extends StatTracker
{
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class StatTrackerJump extends StatTracker {
public static HashMap<LivingArmour, Integer> changeMap = new HashMap<LivingArmour, Integer>();
public static int[] jumpsRequired = new int[] { 30, 200, 400, 700, 1100, 1500, 2000, 2800, 3600, 5000 }; //testing
public static int[] jumpsRequired = new int[]{30, 200, 400, 700, 1100, 1500, 2000, 2800, 3600, 5000}; //testing
public int totalJumps = 0;
public static void incrementCounter(LivingArmour armour)
{
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + 1 : 1);
}
@Override
public String getUniqueIdentifier()
{
public String getUniqueIdentifier() {
return BloodMagic.MODID + ".tracker.jump";
}
@Override
public void resetTracker()
{
public void resetTracker() {
this.totalJumps = 0;
}
@Override
public void readFromNBT(NBTTagCompound tag)
{
public void readFromNBT(NBTTagCompound tag) {
totalJumps = tag.getInteger(BloodMagic.MODID + ".tracker.jump");
}
@Override
public void writeToNBT(NBTTagCompound tag)
{
public void writeToNBT(NBTTagCompound tag) {
tag.setInteger(BloodMagic.MODID + ".tracker.jump", totalJumps);
}
@Override
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
int change = Math.abs(changeMap.get(livingArmour));
if (change > 0)
{
if (change > 0) {
totalJumps += Math.abs(changeMap.get(livingArmour));
changeMap.put(livingArmour, 0);
@ -73,23 +60,18 @@ public class StatTrackerJump extends StatTracker
}
@Override
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
changeMap.remove(livingArmour);
}
}
@Override
public List<LivingArmourUpgrade> getUpgrades()
{
public List<LivingArmourUpgrade> getUpgrades() {
List<LivingArmourUpgrade> upgradeList = new ArrayList<LivingArmourUpgrade>();
for (int i = 0; i < 10; i++)
{
if (totalJumps >= jumpsRequired[i])
{
for (int i = 0; i < 10; i++) {
if (totalJumps >= jumpsRequired[i]) {
upgradeList.add(new LivingArmourUpgradeJump(i));
}
}
@ -98,28 +80,27 @@ public class StatTrackerJump extends StatTracker
}
@Override
public double getProgress(LivingArmour livingArmour, int currentLevel)
{
public double getProgress(LivingArmour livingArmour, int currentLevel) {
return Utils.calculateStandardProgress(totalJumps, jumpsRequired, currentLevel);
}
@Override
public boolean providesUpgrade(String key)
{
public boolean providesUpgrade(String key) {
return key.equals(BloodMagic.MODID + ".upgrade.jump");
}
@Override
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade)
{
if (upgrade instanceof LivingArmourUpgradeJump)
{
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade) {
if (upgrade instanceof LivingArmourUpgradeJump) {
int level = upgrade.getUpgradeLevel();
if (level < jumpsRequired.length)
{
if (level < jumpsRequired.length) {
totalJumps = Math.max(totalJumps, jumpsRequired[level]);
this.markDirty();
}
}
}
public static void incrementCounter(LivingArmour armour) {
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + 1 : 1);
}
}

82
src/main/java/WayofTime/bloodmagic/livingArmour/tracker/StatTrackerMeleeDamage.java
View file

@ -1,63 +1,49 @@
package WayofTime.bloodmagic.livingArmour.tracker;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import WayofTime.bloodmagic.BloodMagic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeMeleeDamage;
import WayofTime.bloodmagic.util.Utils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
public class StatTrackerMeleeDamage extends StatTracker
{
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class StatTrackerMeleeDamage extends StatTracker {
public static HashMap<LivingArmour, Double> changeMap = new HashMap<LivingArmour, Double>();
public static int[] damageRequired = new int[]{200, 800, 1300, 2500, 3800, 5000, 7000, 9200, 11500, 140000};
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, 7000, 9200, 11500, 140000 };
public static void incrementCounter(LivingArmour armour, double damage)
{
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + damage : damage);
}
@Override
public String getUniqueIdentifier()
{
public String getUniqueIdentifier() {
return BloodMagic.MODID + ".tracker.meleeDamage";
}
@Override
public void resetTracker()
{
public void resetTracker() {
this.totalDamageDealt = 0;
}
@Override
public void readFromNBT(NBTTagCompound tag)
{
public void readFromNBT(NBTTagCompound tag) {
totalDamageDealt = tag.getDouble(BloodMagic.MODID + ".tracker.meleeDamage");
}
@Override
public void writeToNBT(NBTTagCompound tag)
{
public void writeToNBT(NBTTagCompound tag) {
tag.setDouble(BloodMagic.MODID + ".tracker.meleeDamage", totalDamageDealt);
}
@Override
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
double change = Math.abs(changeMap.get(livingArmour));
if (change > 0)
{
if (change > 0) {
totalDamageDealt += Math.abs(changeMap.get(livingArmour));
changeMap.put(livingArmour, 0d);
@ -72,23 +58,18 @@ public class StatTrackerMeleeDamage extends StatTracker
}
@Override
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
changeMap.remove(livingArmour);
}
}
@Override
public List<LivingArmourUpgrade> getUpgrades()
{
public List<LivingArmourUpgrade> getUpgrades() {
List<LivingArmourUpgrade> upgradeList = new ArrayList<LivingArmourUpgrade>();
for (int i = 0; i < 10; i++)
{
if (totalDamageDealt >= damageRequired[i])
{
for (int i = 0; i < 10; i++) {
if (totalDamageDealt >= damageRequired[i]) {
upgradeList.add(new LivingArmourUpgradeMeleeDamage(i));
}
}
@ -97,28 +78,27 @@ public class StatTrackerMeleeDamage extends StatTracker
}
@Override
public double getProgress(LivingArmour livingArmour, int currentLevel)
{
public double getProgress(LivingArmour livingArmour, int currentLevel) {
return Utils.calculateStandardProgress(totalDamageDealt, damageRequired, currentLevel);
}
@Override
public boolean providesUpgrade(String key)
{
public boolean providesUpgrade(String key) {
return key.equals(BloodMagic.MODID + ".upgrade.meleeDamage");
}
@Override
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade)
{
if (upgrade instanceof LivingArmourUpgradeMeleeDamage)
{
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade) {
if (upgrade instanceof LivingArmourUpgradeMeleeDamage) {
int level = upgrade.getUpgradeLevel();
if (level < damageRequired.length)
{
if (level < damageRequired.length) {
totalDamageDealt = Math.max(totalDamageDealt, damageRequired[level]);
this.markDirty();
}
}
}
public static void incrementCounter(LivingArmour armour, double damage) {
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + damage : damage);
}
}

76
src/main/java/WayofTime/bloodmagic/livingArmour/tracker/StatTrackerMovement.java
View file

@ -1,73 +1,64 @@
package WayofTime.bloodmagic.livingArmour.tracker;
import WayofTime.bloodmagic.BloodMagic;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeSpeed;
import WayofTime.bloodmagic.util.Utils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import WayofTime.bloodmagic.BloodMagic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeSpeed;
import WayofTime.bloodmagic.util.Utils;
public class StatTrackerMovement extends StatTracker
{
public class StatTrackerMovement extends StatTracker {
public static Map<EntityPlayer, Double> lastPosX = new HashMap<EntityPlayer, Double>();
public static Map<EntityPlayer, Double> lastPosZ = new HashMap<EntityPlayer, Double>();
public static int[] blocksRequired = new int[] { 200, 1000, 2000, 4000, 7000, 15000, 25000, 35000, 50000, 70000 };
public static int[] blocksRequired = new int[]{200, 1000, 2000, 4000, 7000, 15000, 25000, 35000, 50000, 70000};
public double totalMovement = 0;
@Override
public String getUniqueIdentifier()
{
public String getUniqueIdentifier() {
return BloodMagic.MODID + ".tracker.movement";
}
@Override
public void resetTracker()
{
public void resetTracker() {
this.totalMovement = 0;
}
@Override
public void readFromNBT(NBTTagCompound tag)
{
public void readFromNBT(NBTTagCompound tag) {
totalMovement = tag.getDouble(BloodMagic.MODID + ".tracker.movement");
}
@Override
public void writeToNBT(NBTTagCompound tag)
{
public void writeToNBT(NBTTagCompound tag) {
tag.setDouble(BloodMagic.MODID + ".tracker.movement", totalMovement);
}
@Override
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (!lastPosX.containsKey(player))
{
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (!lastPosX.containsKey(player)) {
lastPosX.put(player, player.posX);
lastPosZ.put(player, player.posZ);
return false;
}
if (!player.onGround)
{
if (!player.onGround) {
return false;
}
double distanceTravelled = Math.sqrt(Math.pow(lastPosX.get(player) - player.posX, 2) + Math.pow(lastPosZ.get(player) - player.posZ, 2));
if (distanceTravelled > 0.0001 && distanceTravelled < 2)
{
if (distanceTravelled > 0.0001 && distanceTravelled < 2) {
totalMovement += distanceTravelled;
lastPosX.put(player, player.posX);
@ -85,20 +76,16 @@ public class StatTrackerMovement extends StatTracker
}
@Override
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour) {
}
@Override
public List<LivingArmourUpgrade> getUpgrades()
{
public List<LivingArmourUpgrade> getUpgrades() {
List<LivingArmourUpgrade> upgradeList = new ArrayList<LivingArmourUpgrade>();
for (int i = 0; i < 10; i++)
{
if (totalMovement >= blocksRequired[i])
{
for (int i = 0; i < 10; i++) {
if (totalMovement >= blocksRequired[i]) {
upgradeList.add(new LivingArmourUpgradeSpeed(i));
}
}
@ -107,25 +94,20 @@ public class StatTrackerMovement extends StatTracker
}
@Override
public double getProgress(LivingArmour livingArmour, int currentLevel)
{
public double getProgress(LivingArmour livingArmour, int currentLevel) {
return Utils.calculateStandardProgress(totalMovement, blocksRequired, currentLevel);
}
@Override
public boolean providesUpgrade(String key)
{
public boolean providesUpgrade(String key) {
return key.equals(BloodMagic.MODID + ".upgrade.movement");
}
@Override
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade)
{
if (upgrade instanceof LivingArmourUpgradeSpeed)
{
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade) {
if (upgrade instanceof LivingArmourUpgradeSpeed) {
int level = upgrade.getUpgradeLevel();
if (level < blocksRequired.length)
{
if (level < blocksRequired.length) {
totalMovement = Math.max(totalMovement, blocksRequired[level]);
this.markDirty();
}

96
src/main/java/WayofTime/bloodmagic/livingArmour/tracker/StatTrackerNightSight.java
View file

@ -1,72 +1,57 @@
package WayofTime.bloodmagic.livingArmour.tracker;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import WayofTime.bloodmagic.BloodMagic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.MobEffects;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeNightSight;
import WayofTime.bloodmagic.util.Utils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.MobEffects;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
public class StatTrackerNightSight extends StatTracker
{
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class StatTrackerNightSight extends StatTracker {
public static HashMap<LivingArmour, Double> changeMap = new HashMap<LivingArmour, Double>();
public static int[] damageRequired = new int[]{0, 200, 800, 1300, 2500, 3800, 5000, 7000, 9200, 11500};
public static int neededNightVision = 3 * 60 * 20;
public double totalDamageDealt = 0;
public int totalNightVision = 0;
public static HashMap<LivingArmour, Double> changeMap = new HashMap<LivingArmour, Double>();
public static int[] damageRequired = new int[] { 0, 200, 800, 1300, 2500, 3800, 5000, 7000, 9200, 11500 };
public static int neededNightVision = 3 * 60 * 20;
public static void incrementCounter(LivingArmour armour, double damage)
{
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + damage : damage);
}
@Override
public String getUniqueIdentifier()
{
public String getUniqueIdentifier() {
return BloodMagic.MODID + ".tracker.nightSight";
}
@Override
public void resetTracker()
{
public void resetTracker() {
this.totalDamageDealt = 0;
this.totalNightVision = 0;
}
@Override
public void readFromNBT(NBTTagCompound tag)
{
public void readFromNBT(NBTTagCompound tag) {
totalDamageDealt = tag.getDouble(BloodMagic.MODID + ".tracker.nightSight");
totalNightVision = tag.getInteger(BloodMagic.MODID + ".tracker.nightSightVision");
}
@Override
public void writeToNBT(NBTTagCompound tag)
{
public void writeToNBT(NBTTagCompound tag) {
tag.setDouble(BloodMagic.MODID + ".tracker.nightSight", totalDamageDealt);
tag.setInteger(BloodMagic.MODID + ".tracker.nightSightVision", totalNightVision);
}
@Override
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour) {
boolean test = false;
if (changeMap.containsKey(livingArmour))
{
if (changeMap.containsKey(livingArmour)) {
double change = Math.abs(changeMap.get(livingArmour));
if (change > 0)
{
if (change > 0) {
totalDamageDealt += Math.abs(changeMap.get(livingArmour));
changeMap.put(livingArmour, 0d);
@ -75,14 +60,12 @@ public class StatTrackerNightSight extends StatTracker
}
}
if (world.getLight(player.getPosition()) <= 9 && player.isPotionActive(MobEffects.NIGHT_VISION))
{
if (world.getLight(player.getPosition()) <= 9 && player.isPotionActive(MobEffects.NIGHT_VISION)) {
totalNightVision++;
test = true;
}
if (test)
{
if (test) {
this.markDirty();
}
@ -90,28 +73,22 @@ public class StatTrackerNightSight extends StatTracker
}
@Override
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
changeMap.remove(livingArmour);
}
}
@Override
public List<LivingArmourUpgrade> getUpgrades()
{
public List<LivingArmourUpgrade> getUpgrades() {
List<LivingArmourUpgrade> upgradeList = new ArrayList<LivingArmourUpgrade>();
if (totalNightVision < neededNightVision)
{
if (totalNightVision < neededNightVision) {
return upgradeList;
}
for (int i = 0; i < 10; i++)
{
if (totalDamageDealt >= damageRequired[i])
{
for (int i = 0; i < 10; i++) {
if (totalDamageDealt >= damageRequired[i]) {
upgradeList.add(new LivingArmourUpgradeNightSight(i));
}
}
@ -120,29 +97,28 @@ public class StatTrackerNightSight extends StatTracker
}
@Override
public double getProgress(LivingArmour livingArmour, int currentLevel)
{
public double getProgress(LivingArmour livingArmour, int currentLevel) {
return Utils.calculateStandardProgress(totalDamageDealt, damageRequired, currentLevel);
}
@Override
public boolean providesUpgrade(String key)
{
public boolean providesUpgrade(String key) {
return key.equals(BloodMagic.MODID + ".upgrade.nightSight");
}
@Override
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade)
{
if (upgrade instanceof LivingArmourUpgradeNightSight)
{
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade) {
if (upgrade instanceof LivingArmourUpgradeNightSight) {
int level = upgrade.getUpgradeLevel();
if (level < damageRequired.length)
{
if (level < damageRequired.length) {
totalDamageDealt = Math.max(totalDamageDealt, damageRequired[level]);
totalNightVision = neededNightVision;
this.markDirty();
}
}
}
public static void incrementCounter(LivingArmour armour, double damage) {
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + damage : damage);
}
}

82
src/main/java/WayofTime/bloodmagic/livingArmour/tracker/StatTrackerPhysicalProtect.java
View file

@ -1,63 +1,49 @@
package WayofTime.bloodmagic.livingArmour.tracker;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import WayofTime.bloodmagic.BloodMagic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradePhysicalProtect;
import WayofTime.bloodmagic.util.Utils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
public class StatTrackerPhysicalProtect extends StatTracker
{
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class StatTrackerPhysicalProtect extends StatTracker {
public static HashMap<LivingArmour, Double> changeMap = new HashMap<LivingArmour, Double>();
public static int[] damageRequired = new int[]{30, 50, 80, 140, 200, 300, 400, 500, 650, 800};
public int totalDamage = 0;
public static HashMap<LivingArmour, Double> changeMap = new HashMap<LivingArmour, Double>();
public static int[] damageRequired = new int[] { 30, 50, 80, 140, 200, 300, 400, 500, 650, 800 };
public static void incrementCounter(LivingArmour armour, double damage)
{
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + damage : damage);
}
@Override
public String getUniqueIdentifier()
{
public String getUniqueIdentifier() {
return BloodMagic.MODID + ".tracker.physicalProtect";
}
@Override
public void resetTracker()
{
public void resetTracker() {
this.totalDamage = 0;
}
@Override
public void readFromNBT(NBTTagCompound tag)
{
public void readFromNBT(NBTTagCompound tag) {
totalDamage = tag.getInteger(BloodMagic.MODID + ".tracker.physicalProtect");
}
@Override
public void writeToNBT(NBTTagCompound tag)
{
public void writeToNBT(NBTTagCompound tag) {
tag.setInteger(BloodMagic.MODID + ".tracker.physicalProtect", totalDamage);
}
@Override
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
double change = Math.abs(changeMap.get(livingArmour));
if (change > 0)
{
if (change > 0) {
totalDamage += Math.abs(changeMap.get(livingArmour));
changeMap.put(livingArmour, 0d);
@ -72,23 +58,18 @@ public class StatTrackerPhysicalProtect extends StatTracker
}
@Override
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
changeMap.remove(livingArmour);
}
}
@Override
public List<LivingArmourUpgrade> getUpgrades()
{
public List<LivingArmourUpgrade> getUpgrades() {
List<LivingArmourUpgrade> upgradeList = new ArrayList<LivingArmourUpgrade>();
for (int i = 0; i < 10; i++)
{
if (totalDamage >= damageRequired[i])
{
for (int i = 0; i < 10; i++) {
if (totalDamage >= damageRequired[i]) {
upgradeList.add(new LivingArmourUpgradePhysicalProtect(i));
}
}
@ -97,28 +78,27 @@ public class StatTrackerPhysicalProtect extends StatTracker
}
@Override
public double getProgress(LivingArmour livingArmour, int currentLevel)
{
public double getProgress(LivingArmour livingArmour, int currentLevel) {
return Utils.calculateStandardProgress(totalDamage, damageRequired, currentLevel);
}
@Override
public boolean providesUpgrade(String key)
{
public boolean providesUpgrade(String key) {
return key.equals(BloodMagic.MODID + ".upgrade.physicalProtect");
}
@Override
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade)
{
if (upgrade instanceof LivingArmourUpgradePhysicalProtect)
{
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade) {
if (upgrade instanceof LivingArmourUpgradePhysicalProtect) {
int level = upgrade.getUpgradeLevel();
if (level < damageRequired.length)
{
if (level < damageRequired.length) {
totalDamage = Math.max(totalDamage, damageRequired[level]);
this.markDirty();
}
}
}
public static void incrementCounter(LivingArmour armour, double damage) {
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + damage : damage);
}
}

65
src/main/java/WayofTime/bloodmagic/livingArmour/tracker/StatTrackerPoison.java
View file

@ -1,54 +1,46 @@
package WayofTime.bloodmagic.livingArmour.tracker;
import java.util.ArrayList;
import java.util.List;
import WayofTime.bloodmagic.BloodMagic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.MobEffects;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradePoisonResist;
import WayofTime.bloodmagic.util.Utils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.MobEffects;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
public class StatTrackerPoison extends StatTracker
{
import java.util.ArrayList;
import java.util.List;
public class StatTrackerPoison extends StatTracker {
public static int[] poisonTicksRequired = new int[]{60 * 20, 3 * 60 * 20, 10 * 60 * 20, 20 * 60 * 20, 25 * 60 * 20};
public int totalPoisonTicks = 0;
public static int[] poisonTicksRequired = new int[] { 60 * 20, 3 * 60 * 20, 10 * 60 * 20, 20 * 60 * 20, 25 * 60 * 20 };
@Override
public String getUniqueIdentifier()
{
public String getUniqueIdentifier() {
return BloodMagic.MODID + ".tracker.poison";
}
@Override
public void resetTracker()
{
public void resetTracker() {
this.totalPoisonTicks = 0;
}
@Override
public void readFromNBT(NBTTagCompound tag)
{
public void readFromNBT(NBTTagCompound tag) {
totalPoisonTicks = tag.getInteger(BloodMagic.MODID + ".tracker.poison");
}
@Override
public void writeToNBT(NBTTagCompound tag)
{
public void writeToNBT(NBTTagCompound tag) {
tag.setInteger(BloodMagic.MODID + ".tracker.poison", totalPoisonTicks);
}
@Override
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (player.isPotionActive(MobEffects.POISON))
{
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (player.isPotionActive(MobEffects.POISON)) {
totalPoisonTicks++;
this.markDirty();
return true;
@ -58,20 +50,16 @@ public class StatTrackerPoison extends StatTracker
}
@Override
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour) {
}
@Override
public List<LivingArmourUpgrade> getUpgrades()
{
public List<LivingArmourUpgrade> getUpgrades() {
List<LivingArmourUpgrade> upgradeList = new ArrayList<LivingArmourUpgrade>();
for (int i = 0; i < 5; i++)
{
if (totalPoisonTicks >= poisonTicksRequired[i])
{
for (int i = 0; i < 5; i++) {
if (totalPoisonTicks >= poisonTicksRequired[i]) {
upgradeList.add(new LivingArmourUpgradePoisonResist(i));
}
}
@ -80,25 +68,20 @@ public class StatTrackerPoison extends StatTracker
}
@Override
public double getProgress(LivingArmour livingArmour, int currentLevel)
{
public double getProgress(LivingArmour livingArmour, int currentLevel) {
return Utils.calculateStandardProgress(totalPoisonTicks, poisonTicksRequired, currentLevel);
}
@Override
public boolean providesUpgrade(String key)
{
public boolean providesUpgrade(String key) {
return key.equals(BloodMagic.MODID + ".upgrade.poisonResist");
}
@Override
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade)
{
if (upgrade instanceof LivingArmourUpgradePoisonResist)
{
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade) {
if (upgrade instanceof LivingArmourUpgradePoisonResist) {
int level = upgrade.getUpgradeLevel();
if (level < poisonTicksRequired.length)
{
if (level < poisonTicksRequired.length) {
totalPoisonTicks = Math.max(totalPoisonTicks, poisonTicksRequired[level]);
this.markDirty();
}

82
src/main/java/WayofTime/bloodmagic/livingArmour/tracker/StatTrackerRepairing.java
View file

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

79
src/main/java/WayofTime/bloodmagic/livingArmour/tracker/StatTrackerSelfSacrifice.java
View file

@ -1,64 +1,51 @@
package WayofTime.bloodmagic.livingArmour.tracker;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import WayofTime.bloodmagic.BloodMagic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeSelfSacrifice;
import WayofTime.bloodmagic.util.Utils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
public class StatTrackerSelfSacrifice extends StatTracker
{
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class StatTrackerSelfSacrifice extends StatTracker {
public static HashMap<LivingArmour, Integer> changeMap = new HashMap<LivingArmour, Integer>();
public static int[] sacrificesRequired = new int[] { 30, 200, 400, 700, 1100, 1500, 2000, 2800, 3600, 5000 }; //testing
public static int[] sacrificesRequired = new int[]{30, 200, 400, 700, 1100, 1500, 2000, 2800, 3600, 5000}; //testing
public int totalSacrifices = 0;
public static void incrementCounter(LivingArmour armour, int hearts)
{
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + hearts : hearts);
}
@Override
public String getUniqueIdentifier()
{
public String getUniqueIdentifier() {
return BloodMagic.MODID + ".tracker.selfSacrifice";
}
@Override
public void resetTracker()
{
public void resetTracker() {
this.totalSacrifices = 0;
}
@Override
public void readFromNBT(NBTTagCompound tag)
{
public void readFromNBT(NBTTagCompound tag) {
totalSacrifices = tag.getInteger(BloodMagic.MODID + ".tracker.selfSacrifice");
}
@Override
public void writeToNBT(NBTTagCompound tag)
{
public void writeToNBT(NBTTagCompound tag) {
tag.setInteger(BloodMagic.MODID + ".tracker.selfSacrifice", totalSacrifices);
}
@Override
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
int change = Math.abs(changeMap.get(livingArmour));
if (change > 0)
{
if (change > 0) {
totalSacrifices += Math.abs(changeMap.get(livingArmour));
changeMap.put(livingArmour, 0);
@ -73,23 +60,18 @@ public class StatTrackerSelfSacrifice extends StatTracker
}
@Override
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
changeMap.remove(livingArmour);
}
}
@Override
public List<LivingArmourUpgrade> getUpgrades()
{
public List<LivingArmourUpgrade> getUpgrades() {
List<LivingArmourUpgrade> upgradeList = new ArrayList<LivingArmourUpgrade>();
for (int i = 0; i < 10; i++)
{
if (totalSacrifices >= sacrificesRequired[i])
{
for (int i = 0; i < 10; i++) {
if (totalSacrifices >= sacrificesRequired[i]) {
upgradeList.add(new LivingArmourUpgradeSelfSacrifice(i));
}
}
@ -98,28 +80,27 @@ public class StatTrackerSelfSacrifice extends StatTracker
}
@Override
public double getProgress(LivingArmour livingArmour, int currentLevel)
{
public double getProgress(LivingArmour livingArmour, int currentLevel) {
return Utils.calculateStandardProgress(totalSacrifices, sacrificesRequired, currentLevel);
}
@Override
public boolean providesUpgrade(String key)
{
public boolean providesUpgrade(String key) {
return key.equals(BloodMagic.MODID + ".upgrade.selfSacrifice");
}
@Override
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade)
{
if (upgrade instanceof LivingArmourUpgradeSelfSacrifice)
{
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade) {
if (upgrade instanceof LivingArmourUpgradeSelfSacrifice) {
int level = upgrade.getUpgradeLevel();
if (level < sacrificesRequired.length)
{
if (level < sacrificesRequired.length) {
totalSacrifices = Math.max(totalSacrifices, sacrificesRequired[level]);
this.markDirty();
}
}
}
public static void incrementCounter(LivingArmour armour, int hearts) {
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + hearts : hearts);
}
}

82
src/main/java/WayofTime/bloodmagic/livingArmour/tracker/StatTrackerSolarPowered.java
View file

@ -1,63 +1,49 @@
package WayofTime.bloodmagic.livingArmour.tracker;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import WayofTime.bloodmagic.BloodMagic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeSolarPowered;
import WayofTime.bloodmagic.util.Utils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
public class StatTrackerSolarPowered extends StatTracker
{
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class StatTrackerSolarPowered extends StatTracker {
public static HashMap<LivingArmour, Double> changeMap = new HashMap<LivingArmour, Double>();
public static int[] healthedRequired = new int[]{70, 150, 300, 500, 700, 1400, 2400, 4000, 7000, 9000};
public double totalHealthGenned = 0;
public static HashMap<LivingArmour, Double> changeMap = new HashMap<LivingArmour, Double>();
public static int[] healthedRequired = new int[] { 70, 150, 300, 500, 700, 1400, 2400, 4000, 7000, 9000 };
public static void incrementCounter(LivingArmour armour, double health)
{
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + health : health);
}
@Override
public String getUniqueIdentifier()
{
public String getUniqueIdentifier() {
return BloodMagic.MODID + ".tracker.solarPowered";
}
@Override
public void resetTracker()
{
public void resetTracker() {
this.totalHealthGenned = 0;
}
@Override
public void readFromNBT(NBTTagCompound tag)
{
public void readFromNBT(NBTTagCompound tag) {
totalHealthGenned = tag.getDouble(BloodMagic.MODID + ".tracker.solarPowered");
}
@Override
public void writeToNBT(NBTTagCompound tag)
{
public void writeToNBT(NBTTagCompound tag) {
tag.setDouble(BloodMagic.MODID + ".tracker.solarPowered", totalHealthGenned);
}
@Override
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
double change = Math.abs(changeMap.get(livingArmour));
if (change > 0)
{
if (change > 0) {
totalHealthGenned += Math.abs(changeMap.get(livingArmour));
changeMap.put(livingArmour, 0d);
@ -72,23 +58,18 @@ public class StatTrackerSolarPowered extends StatTracker
}
@Override
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
changeMap.remove(livingArmour);
}
}
@Override
public List<LivingArmourUpgrade> getUpgrades()
{
public List<LivingArmourUpgrade> getUpgrades() {
List<LivingArmourUpgrade> upgradeList = new ArrayList<LivingArmourUpgrade>();
for (int i = 0; i < 10; i++)
{
if (totalHealthGenned >= healthedRequired[i])
{
for (int i = 0; i < 10; i++) {
if (totalHealthGenned >= healthedRequired[i]) {
upgradeList.add(new LivingArmourUpgradeSolarPowered(i));
}
}
@ -97,28 +78,27 @@ public class StatTrackerSolarPowered extends StatTracker
}
@Override
public double getProgress(LivingArmour livingArmour, int currentLevel)
{
public double getProgress(LivingArmour livingArmour, int currentLevel) {
return Utils.calculateStandardProgress(totalHealthGenned, healthedRequired, currentLevel);
}
@Override
public boolean providesUpgrade(String key)
{
public boolean providesUpgrade(String key) {
return key.equals(BloodMagic.MODID + ".upgrade.solarPowered");
}
@Override
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade)
{
if (upgrade instanceof LivingArmourUpgradeSolarPowered)
{
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade) {
if (upgrade instanceof LivingArmourUpgradeSolarPowered) {
int level = upgrade.getUpgradeLevel();
if (level < healthedRequired.length)
{
if (level < healthedRequired.length) {
totalHealthGenned = Math.max(totalHealthGenned, healthedRequired[level]);
this.markDirty();
}
}
}
public static void incrementCounter(LivingArmour armour, double health) {
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + health : health);
}
}

82
src/main/java/WayofTime/bloodmagic/livingArmour/tracker/StatTrackerSprintAttack.java
View file

@ -1,63 +1,49 @@
package WayofTime.bloodmagic.livingArmour.tracker;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import WayofTime.bloodmagic.BloodMagic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeSprintAttack;
import WayofTime.bloodmagic.util.Utils;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
public class StatTrackerSprintAttack extends StatTracker
{
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public class StatTrackerSprintAttack extends StatTracker {
public static HashMap<LivingArmour, Double> changeMap = new HashMap<LivingArmour, Double>();
public static int[] damageRequired = new int[]{200, 800, 1300, 2500, 3800};
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 };
public static void incrementCounter(LivingArmour armour, double damage)
{
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + damage : damage);
}
@Override
public String getUniqueIdentifier()
{
public String getUniqueIdentifier() {
return BloodMagic.MODID + ".tracker.sprintAttack";
}
@Override
public void resetTracker()
{
public void resetTracker() {
this.totalDamageDealt = 0;
}
@Override
public void readFromNBT(NBTTagCompound tag)
{
public void readFromNBT(NBTTagCompound tag) {
totalDamageDealt = tag.getDouble(BloodMagic.MODID + ".tracker.sprintAttack");
}
@Override
public void writeToNBT(NBTTagCompound tag)
{
public void writeToNBT(NBTTagCompound tag) {
tag.setDouble(BloodMagic.MODID + ".tracker.sprintAttack", totalDamageDealt);
}
@Override
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
double change = Math.abs(changeMap.get(livingArmour));
if (change > 0)
{
if (change > 0) {
totalDamageDealt += Math.abs(changeMap.get(livingArmour));
changeMap.put(livingArmour, 0d);
@ -72,23 +58,18 @@ public class StatTrackerSprintAttack extends StatTracker
}
@Override
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (changeMap.containsKey(livingArmour))
{
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (changeMap.containsKey(livingArmour)) {
changeMap.remove(livingArmour);
}
}
@Override
public List<LivingArmourUpgrade> getUpgrades()
{
public List<LivingArmourUpgrade> getUpgrades() {
List<LivingArmourUpgrade> upgradeList = new ArrayList<LivingArmourUpgrade>();
for (int i = 0; i < 5; i++)
{
if (totalDamageDealt >= damageRequired[i])
{
for (int i = 0; i < 5; i++) {
if (totalDamageDealt >= damageRequired[i]) {
upgradeList.add(new LivingArmourUpgradeSprintAttack(i));
}
}
@ -97,28 +78,27 @@ public class StatTrackerSprintAttack extends StatTracker
}
@Override
public double getProgress(LivingArmour livingArmour, int currentLevel)
{
public double getProgress(LivingArmour livingArmour, int currentLevel) {
return Utils.calculateStandardProgress(totalDamageDealt, damageRequired, currentLevel);
}
@Override
public boolean providesUpgrade(String key)
{
public boolean providesUpgrade(String key) {
return key.equals(BloodMagic.MODID + ".upgrade.sprintAttack");
}
@Override
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade)
{
if (upgrade instanceof LivingArmourUpgradeSprintAttack)
{
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade) {
if (upgrade instanceof LivingArmourUpgradeSprintAttack) {
int level = upgrade.getUpgradeLevel();
if (level < damageRequired.length)
{
if (level < damageRequired.length) {
totalDamageDealt = Math.max(totalDamageDealt, damageRequired[level]);
this.markDirty();
}
}
}
public static void incrementCounter(LivingArmour armour, double damage) {
changeMap.put(armour, changeMap.containsKey(armour) ? changeMap.get(armour) + damage : damage);
}
}

66
src/main/java/WayofTime/bloodmagic/livingArmour/tracker/StatTrackerStepAssist.java
View file

@ -1,21 +1,20 @@
package WayofTime.bloodmagic.livingArmour.tracker;
import WayofTime.bloodmagic.BloodMagic;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeStepAssist;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import WayofTime.bloodmagic.BloodMagic;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.livingArmour.StatTracker;
import WayofTime.bloodmagic.livingArmour.LivingArmour;
import WayofTime.bloodmagic.livingArmour.upgrade.LivingArmourUpgradeStepAssist;
public class StatTrackerStepAssist extends StatTracker
{
public class StatTrackerStepAssist extends StatTracker {
public static Map<EntityPlayer, Double> lastPosX = new HashMap<EntityPlayer, Double>();
public static Map<EntityPlayer, Double> lastPosZ = new HashMap<EntityPlayer, Double>();
@ -24,49 +23,41 @@ public class StatTrackerStepAssist extends StatTracker
public double totalMovement = 0;
@Override
public String getUniqueIdentifier()
{
public String getUniqueIdentifier() {
return BloodMagic.MODID + ".tracker.stepAssist";
}
@Override
public void resetTracker()
{
public void resetTracker() {
this.totalMovement = 0;
}
@Override
public void readFromNBT(NBTTagCompound tag)
{
public void readFromNBT(NBTTagCompound tag) {
totalMovement = tag.getDouble(BloodMagic.MODID + ".tracker.stepAssist");
}
@Override
public void writeToNBT(NBTTagCompound tag)
{
public void writeToNBT(NBTTagCompound tag) {
tag.setDouble(BloodMagic.MODID + ".tracker.stepAssist", totalMovement);
}
@Override
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
if (!lastPosX.containsKey(player))
{
public boolean onTick(World world, EntityPlayer player, LivingArmour livingArmour) {
if (!lastPosX.containsKey(player)) {
lastPosX.put(player, player.posX);
lastPosZ.put(player, player.posZ);
return false;
}
if (!player.onGround || player.stepHeight < 1)
{
if (!player.onGround || player.stepHeight < 1) {
return false;
}
double distanceTravelled = Math.sqrt(Math.pow(lastPosX.get(player) - player.posX, 2) + Math.pow(lastPosZ.get(player) - player.posZ, 2));
if (distanceTravelled > 0.0001 && distanceTravelled < 2)
{
if (distanceTravelled > 0.0001 && distanceTravelled < 2) {
double previousMovement = totalMovement;
totalMovement += distanceTravelled;
@ -85,18 +76,15 @@ public class StatTrackerStepAssist extends StatTracker
}
@Override
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour)
{
public void onDeactivatedTick(World world, EntityPlayer player, LivingArmour livingArmour) {
}
@Override
public List<LivingArmourUpgrade> getUpgrades()
{
public List<LivingArmourUpgrade> getUpgrades() {
List<LivingArmourUpgrade> upgradeList = new ArrayList<LivingArmourUpgrade>();
if (totalMovement >= blocksRequired)
{
if (totalMovement >= blocksRequired) {
upgradeList.add(new LivingArmourUpgradeStepAssist(0));
}
@ -104,8 +92,7 @@ public class StatTrackerStepAssist extends StatTracker
}
@Override
public double getProgress(LivingArmour livingArmour, int currentLevel)
{
public double getProgress(LivingArmour livingArmour, int currentLevel) {
if (currentLevel == 1)
return 1.0D;
@ -113,16 +100,13 @@ public class StatTrackerStepAssist extends StatTracker
}
@Override
public boolean providesUpgrade(String key)
{
public boolean providesUpgrade(String key) {
return key.equals(BloodMagic.MODID + ".upgrade.stepAssist");
}
@Override
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade)
{
if (upgrade instanceof LivingArmourUpgradeStepAssist)
{
public void onArmourUpgradeAdded(LivingArmourUpgrade upgrade) {
if (upgrade instanceof LivingArmourUpgradeStepAssist) {
totalMovement = Math.max(totalMovement, blocksRequired);
this.markDirty();
}