From 3eb8c7a8fca3f22475d53e30f0b90a6737f313fa Mon Sep 17 00:00:00 2001 From: bculkin2442 Date: Thu, 24 May 2018 15:53:20 -0400 Subject: Initial commit --- .../main/java/fyresmodjam/misc/ItemStatHelper.java | 551 +++++++++++++++++++++ 1 file changed, 551 insertions(+) create mode 100755 YWD/src/main/java/fyresmodjam/misc/ItemStatHelper.java (limited to 'YWD/src/main/java/fyresmodjam/misc/ItemStatHelper.java') diff --git a/YWD/src/main/java/fyresmodjam/misc/ItemStatHelper.java b/YWD/src/main/java/fyresmodjam/misc/ItemStatHelper.java new file mode 100755 index 0000000..352fc76 --- /dev/null +++ b/YWD/src/main/java/fyresmodjam/misc/ItemStatHelper.java @@ -0,0 +1,551 @@ +package fyresmodjam.misc; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Random; + +import cpw.mods.fml.common.eventhandler.SubscribeEvent; +import cpw.mods.fml.common.gameevent.PlayerEvent.ItemCraftedEvent; +import fyresmodjam.blessings.BlessingUtils; +import fyresmodjam.handlers.NewPacketHandler; +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.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.minecraftforge.common.MinecraftForge; +import net.minecraftforge.event.entity.living.LivingHurtEvent; +import net.minecraftforge.event.entity.player.PlayerDropsEvent; + +@SuppressWarnings("rawtypes") +public class ItemStatHelper { + public static HashMap> statTrackersByClass = new HashMap>(); + + public static ArrayList genericTrackers = new ArrayList(); + + public static ArrayList skip = new ArrayList(); + + public static void addStatTracker(ItemStatTracker statTracker) { + if (statTracker.classes != null) { + for (Class c : statTracker.classes) { + if (!statTrackersByClass.containsKey(c)) { + statTrackersByClass.put(c, + new ArrayList()); + } + + 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.stackTagCompound; + 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.entity.worldObj.isRemote) { + if (BlessingUtils.hasDisadvantage("Permadeath")) { + event.setCanceled(true); + } + } + } + + @SubscribeEvent + public void livingHurt(LivingHurtEvent event) { + if (!event.entity.worldObj.isRemote) { + float damageMultiplier = 1.0F; + + try { + damageMultiplier = handlePlayerWeakening( + event, damageMultiplier); + } catch (NullPointerException npex) { + damageMultiplier = 1.0F; + } + + if (BlessingUtils.hasBlessing(event.entity)) { + damageMultiplier = BlessingUtils + .getBlessingInstance( + BlessingUtils.getBlessing( + event.entity)) + .onIncomingDamage(event, + damageMultiplier); + } + + if (event.isCanceled()) { + return; + } + + if (event.entity instanceof EntityLivingBase) { + EntityLivingBase entity = (EntityLivingBase) event.entity; + + damageMultiplier = getArmorReduction( + damageMultiplier, entity); + } + + if (event.source != null && event.source + .getEntity() != null) { + if (event.source.getEntity() instanceof EntityLivingBase) { + handleWeaponDamage(event); + } + + String mob = EntityStatHelper + .getUnalteredName( + event.entity); + + if (ConfigData.enableMobKillStats + && event.source.getEntity() instanceof EntityPlayer + && event.source.getEntity() + .getEntityData() + .hasKey("KillStats") + && event.source.getEntity() + .getEntityData() + .getCompoundTag("KillStats") + .hasKey(mob)) { + damageMultiplier = handleMobKnowledgeBonus( + event, + damageMultiplier, + mob); + } + + String weapon = "misc"; + if (ConfigData.enableWeaponKillStats + && event.source.getEntity() instanceof EntityPlayer + && event.source.getEntity() + .getEntityData() + .hasKey("WeaponStats") + && event.source.getEntity() + .getEntityData() + .getCompoundTag("WeaponStats") + .hasKey(weapon)) { + damageMultiplier = handleWeaponKnowledgeBonus( + event, + damageMultiplier, + weapon); + } + + if (BlessingUtils.hasBlessing(event.source + .getEntity())) { + damageMultiplier = BlessingUtils + .getBlessingInstance( + BlessingUtils.getBlessing( + event.source.getEntity())) + .onOutgoingDamage( + event, + damageMultiplier); + } + } + + if (event.isCanceled()) { + return; + } + + if (event.ammount < event.entityLiving + .getHealth()) { + event.ammount = (float) Math.max(0.5, + event.ammount * damageMultiplier); + } + } + } + + private float handleWeaponKnowledgeBonus(LivingHurtEvent event, + float damageMultiplier, String weapon) { + EntityPlayer player = (EntityPlayer) event.source + .getEntity(); + + if (player.getHeldItem() == null) { + weapon = "fist"; + } else if (player.getHeldItem().getItem() != null && player + .getHeldItem() + .getItem() instanceof ItemSword + || player.getHeldItem() + .getItem() instanceof ItemBow + || player.getHeldItem() + .getItem() instanceof ItemAxe) { + weapon = EntityStatHelper.getUnalteredItemName( + player.getHeldItem().getItem()); + } + + int kills = event.source.getEntity().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(event.source.getEntity())) { + if (BlessingUtils.hasBlessing( + event.source.getEntity())) { + pickedDamageBonus = BlessingUtils + .getBlessingInstance( + event.source.getEntity()) + .adjustMobKnowledgeBonus( + event, + pickedDamageBonus); + } + } + + damageMultiplier += pickedDamageBonus; + return damageMultiplier; + } + + private float handleMobKnowledgeBonus(LivingHurtEvent event, + float damageMultiplier, String mob) { + int kills = event.source.getEntity().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(event.source.getEntity())) { + if (BlessingUtils.hasBlessing( + event.source.getEntity())) { + pickedDamageBonus = BlessingUtils + .getBlessingInstance( + event.source.getEntity()) + .adjustMobKnowledgeBonus( + event, + pickedDamageBonus); + } + } + + damageMultiplier += pickedDamageBonus; + return damageMultiplier; + } + + private void handleWeaponDamage(LivingHurtEvent event) { + EntityLivingBase entity = (EntityLivingBase) event.source + .getEntity(); + + ItemStack held = entity.getEquipmentInSlot(0); + + if (held != null && ((event.source.getDamageType() + .equals("player") + || event.source.getDamageType() + .equals("mob") + || (held.getItem() == Items.bow + && event.source.isProjectile())))) { + String s = getStat(held, "BonusDamage"); + if (s != null) { + event.ammount += Float.parseFloat(s.trim() + .replace(",", ".")); + } + } + } + + private float getArmorReduction(float damageMultiplier, + EntityLivingBase entity) { + for (int i = 0; i < 4; i++) { + ItemStack stack = entity.getEquipmentInSlot(i + 1); + 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.source.getDamageType() + .equals("player")) { + damageMultiplier -= 0.25F; + } + } else if (BlessingUtils.hasDisadvantage("Tougher Mobs")) { + if (event.entity instanceof EntityMob) { + damageMultiplier -= 0.25F; + } + } + return damageMultiplier; + } + + public static ArrayList temp = new ArrayList(); + + @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 list = null; + + if (statTrackersByClass + .containsKey(itemClass)) { + list = new ArrayList(); + 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.worldObj.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 (ConfigData.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); + } +} -- cgit v1.2.3