From b8b41aa5846dae5a9bbf4fee82020f1d9e2b2a48 Mon Sep 17 00:00:00 2001 From: Benjamin Culkin Date: Mon, 12 Aug 2024 17:08:54 -0400 Subject: Initial commit --- src/main/java/fyresmodjam/misc/ItemStatHelper.java | 565 +++++++++++++++++++++ 1 file changed, 565 insertions(+) create mode 100644 src/main/java/fyresmodjam/misc/ItemStatHelper.java (limited to 'src/main/java/fyresmodjam/misc/ItemStatHelper.java') 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> 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.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 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.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); + } +} -- cgit v1.2.3