diff options
Diffstat (limited to 'src/main/java/fyresmodjam/misc/ItemStatHelper.java')
| -rw-r--r-- | src/main/java/fyresmodjam/misc/ItemStatHelper.java | 565 |
1 files changed, 565 insertions, 0 deletions
diff --git a/src/main/java/fyresmodjam/misc/ItemStatHelper.java b/src/main/java/fyresmodjam/misc/ItemStatHelper.java new file mode 100644 index 0000000..9b32fd5 --- /dev/null +++ b/src/main/java/fyresmodjam/misc/ItemStatHelper.java @@ -0,0 +1,565 @@ +package fyresmodjam.misc;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Random;
+
+import fyresmodjam.ModjamMod;
+import fyresmodjam.blessings.BlessingUtils;
+import fyresmodjam.handlers.NewPacketHandler;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.monster.EntityMob;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Items;
+import net.minecraft.inventory.EntityEquipmentSlot;
+import net.minecraft.item.ItemAxe;
+import net.minecraft.item.ItemBow;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.ItemSword;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.nbt.NBTTagString;
+import net.minecraft.util.EnumHand;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.entity.living.LivingHurtEvent;
+import net.minecraftforge.event.entity.player.PlayerDropsEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.common.gameevent.PlayerEvent.ItemCraftedEvent;
+
+@SuppressWarnings("rawtypes")
+public class ItemStatHelper {
+ public static HashMap<Class, ArrayList<ItemStatTracker>> statTrackersByClass = new HashMap<Class, ArrayList<ItemStatTracker>>();
+
+ public static ArrayList<ItemStatTracker> genericTrackers = new ArrayList<ItemStatTracker>();
+
+ public static ArrayList<Class> skip = new ArrayList<Class>();
+
+ public static void addStatTracker(ItemStatTracker statTracker) {
+ if (statTracker.classes != null) {
+ for (Class c : statTracker.classes) {
+ if (!statTrackersByClass.containsKey(c)) {
+ statTrackersByClass.put(c,
+ new ArrayList<ItemStatTracker>());
+ }
+
+ statTrackersByClass.get(c)
+ .add(statTracker);
+ }
+ }
+
+ if (statTracker.instanceAllowed) {
+ genericTrackers.add(statTracker);
+ }
+ }
+
+ public static ItemStack giveStat(ItemStack stack, String name,
+ Object value) {
+ if (!stack.hasTagCompound()) {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ NBTTagCompound data = stack.getTagCompound();
+ data.setString(name, value.toString());
+ return stack;
+ }
+
+ public static ItemStack setName(ItemStack stack, String name) {
+ if (!stack.hasTagCompound()) {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ if (!stack.getTagCompound().hasKey("display")) {
+ stack.getTagCompound().setTag("display",
+ new NBTTagCompound());
+ }
+
+ stack.getTagCompound().getCompoundTag("display")
+ .setString("Name", name);
+
+ return stack;
+ }
+
+ public static ItemStack addLore(ItemStack stack, String lore) {
+ if (!stack.hasTagCompound()) {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ if (!stack.getTagCompound().hasKey("display")) {
+ stack.getTagCompound().setTag("display",
+ new NBTTagCompound());
+ }
+
+ if (!stack.getTagCompound().getCompoundTag("display")
+ .hasKey("Lore")) {
+ stack.getTagCompound().getCompoundTag("display")
+ .setTag("Lore", new NBTTagList());
+ }
+
+ if (lore != null) {
+ ((NBTTagList) stack.getTagCompound()
+ .getCompoundTag("display")
+ .getTag("Lore")).appendTag(
+ new NBTTagString(
+ lore));
+ }
+
+ return stack;
+ }
+
+ public static String getName(ItemStack stack) {
+ if (stack.getTagCompound() != null
+ && stack.getTagCompound().hasKey("display")
+ && stack.getTagCompound()
+ .getCompoundTag("display")
+ .hasKey("Name")) {
+ return stack.getTagCompound()
+ .getCompoundTag("display")
+ .getString("Name");
+ }
+
+ return null;
+ }
+
+ public static String getStat(ItemStack stack, String name) {
+ String s = null;
+ if (stack.getTagCompound() != null
+ && stack.getTagCompound().hasKey(name)) {
+ s = stack.getTagCompound().getString(name);
+ }
+
+ return s;
+ }
+
+ public static boolean hasStat(ItemStack stack, String name) {
+ if (stack.getTagCompound() != null
+ && stack.getTagCompound().hasKey(name)) {
+ return true;
+ }
+
+ return false;
+ }
+
+ @SubscribeEvent
+ public void playerDrops(PlayerDropsEvent event) {
+ if (!event.getEntity().world.isRemote) {
+ if (BlessingUtils.hasDisadvantage("Permadeath")) {
+ event.setCanceled(true);
+ }
+ }
+ }
+
+ @SubscribeEvent
+ public void livingHurt(LivingHurtEvent event) {
+ if (!event.getEntity().world.isRemote) {
+ float damageMultiplier = 1.0F;
+
+ try {
+ damageMultiplier = handlePlayerWeakening(
+ event, damageMultiplier);
+ } catch (NullPointerException npex) {
+ damageMultiplier = 1.0F;
+ }
+
+ if (BlessingUtils.hasBlessing(event.getEntity())) {
+ damageMultiplier = BlessingUtils
+ .getBlessingInstance(
+ BlessingUtils.getBlessing(
+ event.getEntity()))
+ .onIncomingDamage(event,
+ damageMultiplier);
+ }
+
+ if (event.isCanceled()) {
+ return;
+ }
+
+ if (event.getEntity() instanceof EntityLivingBase) {
+ EntityLivingBase entity = (EntityLivingBase) event
+ .getEntity();
+
+ damageMultiplier = getArmorReduction(
+ damageMultiplier, entity);
+ }
+
+ Entity trueSource = event.getSource()
+ .getTrueSource();
+
+ if (event.getSource() != null
+ && trueSource != null) {
+ if (trueSource instanceof EntityLivingBase) {
+ handleWeaponDamage(event);
+ }
+
+ String mob = EntityStatHelper
+ .getUnalteredName(event
+ .getEntity());
+
+ if (ModjamMod.enableMobKillStats
+ && trueSource instanceof EntityPlayer
+ && trueSource.getEntityData()
+ .hasKey("KillStats")
+ && trueSource.getEntityData()
+ .getCompoundTag("KillStats")
+ .hasKey(mob)) {
+ damageMultiplier = handleMobKnowledgeBonus(
+ event,
+ damageMultiplier,
+ mob);
+ }
+
+ String weapon = "misc";
+ if (ModjamMod.enableWeaponKillStats
+ && trueSource instanceof EntityPlayer
+ && trueSource.getEntityData()
+ .hasKey("WeaponStats")
+ && trueSource.getEntityData()
+ .getCompoundTag("WeaponStats")
+ .hasKey(weapon)) {
+ damageMultiplier = handleWeaponKnowledgeBonus(
+ event,
+ damageMultiplier,
+ weapon);
+ }
+
+ if (BlessingUtils
+ .hasBlessing(trueSource)) {
+ damageMultiplier = BlessingUtils
+ .getBlessingInstance(
+ BlessingUtils.getBlessing(
+ trueSource))
+ .onOutgoingDamage(
+ event,
+ damageMultiplier);
+ }
+ }
+
+ if (event.isCanceled()) {
+ return;
+ }
+
+ if (event.getAmount() < event.getEntityLiving()
+ .getHealth()) {
+ event.setAmount((float) Math.max(0.5, event
+ .getAmount()
+ * damageMultiplier));
+ }
+ }
+ }
+
+ private float handleWeaponKnowledgeBonus(LivingHurtEvent event,
+ float damageMultiplier, String weapon) {
+ EntityPlayer player = (EntityPlayer) event.getSource()
+ .getTrueSource();
+
+ ItemStack heldItem = player
+ .getHeldItem(EnumHand.MAIN_HAND);
+ if (heldItem == null) {
+ weapon = "fist";
+ } else if (heldItem.getItem() != null
+ && heldItem.getItem() instanceof ItemSword
+ || heldItem.getItem() instanceof ItemBow
+ || heldItem.getItem() instanceof ItemAxe) {
+ weapon = EntityStatHelper.getUnalteredItemName(
+ heldItem.getItem());
+ }
+
+ int kills = player.getEntityData()
+ .getCompoundTag("WeaponStats")
+ .getInteger(weapon);
+
+ int last = 0;
+ for (int i = 0; i < EntityStatHelper.killCount.length; i++) {
+ if (kills >= EntityStatHelper.killCount[i] * 2) {
+ last = i;
+ continue;
+ } else {
+ break;
+ }
+ }
+
+ float pickedDamageBonus = EntityStatHelper.damageBonus[last];
+
+ if (BlessingUtils.hasBlessing(player)) {
+ if (BlessingUtils.hasBlessing(player)) {
+ pickedDamageBonus = BlessingUtils
+ .getBlessingInstance(
+ player)
+ .adjustMobKnowledgeBonus(
+ event,
+ pickedDamageBonus);
+ }
+ }
+
+ damageMultiplier += pickedDamageBonus;
+ return damageMultiplier;
+ }
+
+ private float handleMobKnowledgeBonus(LivingHurtEvent event,
+ float damageMultiplier, String mob) {
+ Entity trueSource = event.getSource().getTrueSource();
+
+ int kills = trueSource.getEntityData()
+ .getCompoundTag("KillStats")
+ .getInteger(mob);
+
+ int last = 0;
+ for (int i = 0; i < EntityStatHelper.killCount.length; i++) {
+ if (kills >= EntityStatHelper.killCount[i]) {
+ last = i;
+ continue;
+ } else {
+ break;
+ }
+ }
+
+ float pickedDamageBonus = EntityStatHelper.damageBonus[last];
+
+ if (BlessingUtils.hasBlessing(trueSource)) {
+ if (BlessingUtils.hasBlessing(trueSource)) {
+ pickedDamageBonus = BlessingUtils
+ .getBlessingInstance(
+ trueSource)
+ .adjustMobKnowledgeBonus(
+ event,
+ pickedDamageBonus);
+ }
+ }
+
+ damageMultiplier += pickedDamageBonus;
+ return damageMultiplier;
+ }
+
+ private void handleWeaponDamage(LivingHurtEvent event) {
+ EntityLivingBase entity = (EntityLivingBase) event
+ .getSource().getTrueSource();
+
+ ItemStack held = entity.getHeldItemMainhand();
+
+ if (held != null && ((event.getSource().getDamageType()
+ .equals("player")
+ || event.getSource().getDamageType()
+ .equals("mob")
+ || (held.getItem() == Items.BOW && event
+ .getSource()
+ .isProjectile())))) {
+ String s = getStat(held, "BonusDamage");
+ if (s != null) {
+ event.setAmount(event.getAmount()
+ + Float.parseFloat(s.trim()
+ .replace(",", ".")));
+ }
+ }
+ }
+
+ private float getArmorReduction(float damageMultiplier,
+ EntityLivingBase entity) {
+ EntityEquipmentSlot slots[] = new EntityEquipmentSlot[] {
+ EntityEquipmentSlot.CHEST,
+ EntityEquipmentSlot.FEET,
+ EntityEquipmentSlot.HEAD,
+ EntityEquipmentSlot.LEGS
+ };
+
+ for (EntityEquipmentSlot slot : slots) {
+ ItemStack stack = entity
+ .getItemStackFromSlot(slot);
+ if (stack == null || stack.getTagCompound() == null
+ || !stack.getTagCompound().hasKey(
+ "DamageReduction")) {
+ continue;
+ }
+
+ damageMultiplier -= Float.parseFloat(stack
+ .getTagCompound()
+ .getString("DamageReduction")
+ .trim().replace(",", ".")) * 0.01F;
+ }
+ return damageMultiplier;
+ }
+
+ private float handlePlayerWeakening(LivingHurtEvent event,
+ float damageMultiplier) {
+ if (BlessingUtils.hasDisadvantage("Weak")) {
+ if (event.getSource().getDamageType()
+ .equals("player")) {
+ damageMultiplier -= 0.25F;
+ }
+ } else if (BlessingUtils.hasDisadvantage("Tougher Mobs")) {
+ if (event.getEntity() instanceof EntityMob) {
+ damageMultiplier -= 0.25F;
+ }
+ }
+ return damageMultiplier;
+ }
+
+ public static ArrayList<ItemStatTracker> temp = new ArrayList<ItemStatTracker>();
+
+ @SuppressWarnings("unchecked")
+ public static void processItemStack(ItemStack stack, Random r) {
+ if (stack == null) {
+ return;
+ }
+
+ temp.clear();
+
+ Class itemClass = stack.getItem().getClass();
+
+ if (statTrackersByClass.containsKey(itemClass)) {
+ temp.addAll(statTrackersByClass.get(itemClass));
+ }
+
+ for (ItemStatTracker e : genericTrackers) {
+ if (!temp.contains(e)) {
+ for (Class c : e.classes) {
+ if (c.isAssignableFrom(
+ itemClass)) {
+ ArrayList<ItemStatTracker> list = null;
+
+ if (statTrackersByClass
+ .containsKey(itemClass)) {
+ list = new ArrayList<ItemStatTracker>();
+ statTrackersByClass
+ .put(itemClass, list);
+ } else {
+ list = statTrackersByClass
+ .get(itemClass);
+ }
+
+ try {
+ if (!statTrackersByClass
+ .get(itemClass)
+ .contains(e)) {
+ list.add(e);
+ }
+
+ temp.add(e);
+
+ break;
+ } catch (NullPointerException npex) {
+
+ }
+ }
+ }
+ }
+ }
+
+ if (!temp.isEmpty()) {
+ if (!stack.hasTagCompound()) {
+ stack.setTagCompound(new NBTTagCompound());
+ }
+
+ String processed = ItemStatHelper.getStat(stack,
+ "processed");
+
+ if (processed == null
+ || processed.equals("false")) {
+ stack.getTagCompound().setTag("Lore",
+ new NBTTagList());
+
+ ItemStatHelper.giveStat(stack, "processed",
+ "true");
+
+ for (ItemStatTracker statTracker : temp) {
+ for (ItemStat s : statTracker.stats) {
+ giveStat(stack, s.name, s
+ .getNewValue(stack,
+ r)
+ .toString());
+
+ String lore = s.getLore(
+ stack);
+ if (lore != null) {
+ addLore(stack, lore);
+ }
+
+ setName(stack, s.getAlteredStackName(
+ stack, r));
+
+ s.modifyStack(stack, r);
+ }
+ }
+ }
+ } else {
+ skip.add(itemClass);
+ }
+ }
+
+ @SubscribeEvent
+ public void onCrafting(ItemCraftedEvent event) {
+
+ EntityPlayer player = event.player;
+ ItemStack item = event.crafting;
+
+ if (!player.world.isRemote) {
+ String itemName = null;
+
+ if (item.getItem() != null && item
+ .getItem() instanceof ItemSword
+ || item.getItem() instanceof ItemBow
+ || item.getItem() instanceof ItemAxe) {
+ itemName = EntityStatHelper
+ .getUnalteredItemName(item
+ .getItem());
+ }
+
+ if (ModjamMod.enableCraftingStats
+ && itemName != null) {
+ if (!player.getEntityData()
+ .hasKey("CraftingStats")) {
+ player.getEntityData().setTag(
+ "CraftingStats",
+ new NBTTagCompound());
+ }
+ NBTTagCompound craftingStats = player
+ .getEntityData()
+ .getCompoundTag("CraftingStats");
+
+ if (!craftingStats.hasKey(itemName)) {
+ craftingStats.setInteger(itemName,
+ 0);
+
+ if (!craftingStats.hasKey(
+ "TrackedItemList")) {
+ craftingStats.setString(
+ "TrackedItemList",
+ itemName);
+ } else {
+ craftingStats.setString(
+ "TrackedItemList",
+ craftingStats.getString(
+ "TrackedItemList")
+ + ";"
+ + itemName);
+ }
+ }
+
+ craftingStats.setInteger(itemName,
+ craftingStats.getInteger(
+ itemName)
+ + 1);
+
+ for (int i = 0; i < EntityStatHelper.knowledge.length; i++) {
+ if (EntityStatHelper.killCount[i] == craftingStats
+ .getInteger(itemName)) {
+ NewPacketHandler.SEND_MESSAGE
+ .sendToPlayer(player,
+ "\u00A7o\u00A73You've become a "
+ + EntityStatHelper.knowledge[i]
+ .toLowerCase()
+ + " "
+ + itemName.toLowerCase()
+ + " smith! ("
+ + (i < EntityStatHelper.knowledge.length
+ - 1 ? (EntityStatHelper.killCount[i + 1] * 2 - EntityStatHelper.killCount[i] * 2) + " " + itemName.toLowerCase() + " crafts to next rank." : ""));
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ public void register() {
+ MinecraftForge.EVENT_BUS.register(this);
+ }
+}
|