From b8b41aa5846dae5a9bbf4fee82020f1d9e2b2a48 Mon Sep 17 00:00:00 2001 From: Benjamin Culkin Date: Mon, 12 Aug 2024 17:08:54 -0400 Subject: Initial commit --- .../java/fyresmodjam/misc/ArmorStatTracker.java | 79 +++ .../fyresmodjam/misc/CreativeTabModjamMod.java | 81 +++ src/main/java/fyresmodjam/misc/DamageSources.java | 22 + src/main/java/fyresmodjam/misc/EntityStat.java | 27 + .../java/fyresmodjam/misc/EntityStatHelper.java | 740 +++++++++++++++++++++ .../java/fyresmodjam/misc/EntityStatTracker.java | 29 + src/main/java/fyresmodjam/misc/ItemStat.java | 30 + src/main/java/fyresmodjam/misc/ItemStatHelper.java | 565 ++++++++++++++++ .../java/fyresmodjam/misc/ItemStatTracker.java | 29 + src/main/java/fyresmodjam/misc/WeaponRankStat.java | 83 +++ 10 files changed, 1685 insertions(+) create mode 100644 src/main/java/fyresmodjam/misc/ArmorStatTracker.java create mode 100644 src/main/java/fyresmodjam/misc/CreativeTabModjamMod.java create mode 100644 src/main/java/fyresmodjam/misc/DamageSources.java create mode 100644 src/main/java/fyresmodjam/misc/EntityStat.java create mode 100644 src/main/java/fyresmodjam/misc/EntityStatHelper.java create mode 100644 src/main/java/fyresmodjam/misc/EntityStatTracker.java create mode 100644 src/main/java/fyresmodjam/misc/ItemStat.java create mode 100644 src/main/java/fyresmodjam/misc/ItemStatHelper.java create mode 100644 src/main/java/fyresmodjam/misc/ItemStatTracker.java create mode 100644 src/main/java/fyresmodjam/misc/WeaponRankStat.java (limited to 'src/main/java/fyresmodjam/misc') diff --git a/src/main/java/fyresmodjam/misc/ArmorStatTracker.java b/src/main/java/fyresmodjam/misc/ArmorStatTracker.java new file mode 100644 index 0000000..80a8c2a --- /dev/null +++ b/src/main/java/fyresmodjam/misc/ArmorStatTracker.java @@ -0,0 +1,79 @@ +package fyresmodjam.misc; + +import java.util.Random; + +import fyresmodjam.ModjamMod; +import net.minecraft.item.ItemBow; +import net.minecraft.item.ItemStack; + +public final class ArmorStatTracker extends ItemStat { + public String[][] prefixesByRank = { + { + "Old", "Broken", "Worn", "Weak" + }, { + "Average", "Decent", "Modest", + "Ordinary" + }, { + "Polished", "Tough", "Hardened", + "Durable" + }, { + "Elite", "Astonishing", + "Reinforced", "Resilient" + }, { + "Godly", "Divine", "Fabled", + "Legendary" + } + }; + + public ArmorStatTracker(String name, Object value) { + super(name, value); + } + + @Override + public Object getNewValue(ItemStack stack, Random r) { + int i = 1; + for (; i < 5; i++) { + if (ModjamMod.r.nextInt(10) < 7) { + break; + } + } + return i; + } + + @Override + public void modifyStack(ItemStack stack, Random r) { + int rank = Integer.parseInt( + stack.getTagCompound().getString(name)); + float damageReduction = (rank - 1) + r.nextFloat() * 0.5F; + + ItemStatHelper.giveStat(stack, "DamageReduction", + String.format("%.2f", damageReduction)); + ItemStatHelper.addLore(stack, !String + .format("%.2f", damageReduction) + .equals("0.00") ? "\u00A77\u00A7o " + + (damageReduction > 0 + ? "+" + : "") + + String.format("%.2f", + damageReduction) + + "% damage reduction" + : null); + + ItemStatHelper.addLore(stack, "\u00A7eRank: " + rank); + } + + @Override + public String getAlteredStackName(ItemStack stack, Random r) { + String[] list = prefixesByRank[Integer.parseInt( + stack.getTagCompound().getString(name)) + - 1]; + String prefix = list[r.nextInt(list.length)]; + + if (prefix.equals("Sharp") + && stack.getItem() instanceof ItemBow) { + prefix = "Long"; + } + + return "\u00A7f" + prefix + " " + stack.getDisplayName(); + } +} \ No newline at end of file diff --git a/src/main/java/fyresmodjam/misc/CreativeTabModjamMod.java b/src/main/java/fyresmodjam/misc/CreativeTabModjamMod.java new file mode 100644 index 0000000..821af0f --- /dev/null +++ b/src/main/java/fyresmodjam/misc/CreativeTabModjamMod.java @@ -0,0 +1,81 @@ +package fyresmodjam.misc; + +import java.lang.reflect.Field; +import java.util.ArrayList; +import java.util.List; + +import fyresmodjam.ModjamMod; +import net.minecraft.block.Block; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.init.Items; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.NonNullList; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; + +public class CreativeTabModjamMod extends CreativeTabs { + + public CreativeTabModjamMod(int par1, String par2Str) { + super(par1, par2Str); + } + + @Override + @SideOnly(Side.CLIENT) + public ItemStack getIconItemStack() { + return new ItemStack(ModjamMod.itemTrap, 1, 0); + } + + @Override + public String getTranslatedTabLabel() { + return "The \"You Will Die\" Mod"; + } + + @Override + public void displayAllRelevantItems( + NonNullList par1List) { + try { + ArrayList list = new ArrayList(); + /* + for (Field f : ModjamMod.class.getFields()) { + if (f.getType() == Item.class) { + Item item = (Item) f.get( + ModjamMod.instance); + if (item == null || item + .getCreativeTab() == null) { + continue; + } + + } else if (f.getType() == Block.class) { + Block block = (Block) f.get( + ModjamMod.instance); + if (block == null || block + .getCreativeTabToDisplayOn() == null) { + continue; + } + block.getSubBlocks(block.getItem( + null, 0, 0, 0), + this, list); + } + } + + for (ItemStack i : list) { + if (i == null || i.getItem() == null) { + continue; + } + if (i.getItem().getIconIndex(i) != null) { + par1List.add(i); + } + } + */ + } catch (Exception e) { + e.printStackTrace(); + } + } + + @Override + public ItemStack getTabIconItem() { + return new ItemStack(Items.SPAWN_EGG); + } + +} diff --git a/src/main/java/fyresmodjam/misc/DamageSources.java b/src/main/java/fyresmodjam/misc/DamageSources.java new file mode 100644 index 0000000..b1fdc01 --- /dev/null +++ b/src/main/java/fyresmodjam/misc/DamageSources.java @@ -0,0 +1,22 @@ +package fyresmodjam.misc; + +import net.minecraft.util.DamageSource; + +public class DamageSources { + private static boolean isInitted = false; + + public static DamageSource inferno, retaliation; + + public static void doInit() { + if (isInitted) { + inferno = new DamageSource("inferno") + .setDamageBypassesArmor() + .setDamageIsAbsolute(); + + retaliation = new DamageSource("retaliation") + .setDamageBypassesArmor(); + + isInitted = true; + } + } +} \ No newline at end of file diff --git a/src/main/java/fyresmodjam/misc/EntityStat.java b/src/main/java/fyresmodjam/misc/EntityStat.java new file mode 100644 index 0000000..ce1247f --- /dev/null +++ b/src/main/java/fyresmodjam/misc/EntityStat.java @@ -0,0 +1,27 @@ +package fyresmodjam.misc; + +import java.util.Random; + +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLiving; + +public class EntityStat { + public String name; + public String value; + + public EntityStat(String name, String value) { + this.name = name; + this.value = value; + } + + public Object getNewValue(Random r) { + return value; + } + + public String getAlteredEntityName(EntityLiving entity) { + return entity.getName(); + } + + public void modifyEntity(Entity entity) { + } +} \ No newline at end of file diff --git a/src/main/java/fyresmodjam/misc/EntityStatHelper.java b/src/main/java/fyresmodjam/misc/EntityStatHelper.java new file mode 100644 index 0000000..7022fed --- /dev/null +++ b/src/main/java/fyresmodjam/misc/EntityStatHelper.java @@ -0,0 +1,740 @@ +package fyresmodjam.misc; + +import java.lang.reflect.Constructor; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Random; + +import fyresmodjam.ModjamMod; +import fyresmodjam.blessings.BlessingUtils; +import fyresmodjam.handlers.CommonTickHandler; +import fyresmodjam.handlers.NewPacketHandler; +import fyresmodjam.worldgen.FyresWorldData; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityList; +import net.minecraft.entity.EntityLiving; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.boss.EntityDragon; +import net.minecraft.entity.monster.EntityMob; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumHand; +import net.minecraft.util.math.AxisAlignedBB; +import net.minecraft.util.text.translation.I18n; +import net.minecraft.world.World; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.event.entity.EntityJoinWorldEvent; +import net.minecraftforge.event.entity.living.LivingDeathEvent; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; + +@SuppressWarnings("rawtypes") +public class EntityStatHelper { + + public static String[] knowledge = { + "Clueless", "Novice", "Competent", "Talented", + "Expert", "Professional", "Master", "Legendary" + }; + + public static int[] killCount = { + 0, 10, 25, 50, 100, 250, 500, 1000 + }; + + public static float[] damageBonus = { + 0, 0.01F, 0.025F, 0.05F, 0.075F, 0.1F, 0.15F, 0.2F + }; + public static String[] damageBonusString = { + "0", "1", "2.5", "5", "7.5", "10", "15", "20" + }; + + public static HashMap statTrackersByClass = new HashMap(); + + public static ArrayList genericTrackers = new ArrayList(); + + public static ArrayList temp = new ArrayList(); + public static boolean b = false; + + public static void addStatTracker(EntityStatTracker statTracker) { + if (statTracker.classes != null) { + for (Class c : statTracker.classes) { + statTrackersByClass.put(c, statTracker); + } + + if (statTracker.instanceAllowed) { + genericTrackers.add(statTracker); + } + } + } + + public static String getStat(Entity entity, String name) { + String s = null; + + if (entity.getEntityData() != null + && entity.getEntityData().hasKey(name)) { + s = entity.getEntityData().getString(name); + } + + return s; + } + + public static String getUnalteredItemName(Item item) { + return I18n.translateToLocal( + item.getUnlocalizedName() + ".name"); + } + + public static String getUnalteredName(Entity entity) { + String s = EntityList.getEntityString(entity); + + if (s == null) { + s = "generic"; + } + + return I18n.translateToLocal("entity." + s + ".name"); + } + + public static Entity giveStat(Entity entity, String name, + Object value) { + if (entity != null && name != null && value != null) { + entity.getEntityData().setString(name, + value.toString()); + } + + return entity; + } + + public static boolean hasStat(Entity entity, String name) { + if (entity.getEntityData() != null + && entity.getEntityData().hasKey(name)) { + return true; + } + + return false; + } + + @SuppressWarnings("unchecked") + public static void processEntity(Entity entity, Random r) { + if (entity == null) { + return; + } + + temp.clear(); + + if (statTrackersByClass.containsKey(entity.getClass())) { + temp.add(statTrackersByClass + .get(entity.getClass())); + } + + for (EntityStatTracker e : genericTrackers) { + if (!temp.contains(e)) { + for (Class c : e.classes) { + if (c.isAssignableFrom(entity + .getClass())) { + temp.add(e); + break; + } + } + } + } + + if (!temp.isEmpty()) { + String processed = EntityStatHelper.getStat(entity, + "processed"); + + if (processed == null + || processed.equals("false")) { + EntityStatHelper.giveStat(entity, + "processed", "true"); + + for (EntityStatTracker statTracker : temp) { + for (EntityStat s : statTracker.stats) { + giveStat(entity, s.name, s + .getNewValue(r) + .toString()); + + if (entity instanceof EntityLiving) { + setName((EntityLiving) entity, + s.getAlteredEntityName( + (EntityLiving) entity)); + } + + s.modifyEntity(entity); + } + } + } + } + } + + public static void setEntitySize(Entity entity, float par1, + float par2) { + /* + * float f2; // TODO fix this if (par1 != entity.width || + * par2 != entity.height) { f2 = entity.width; entity.width + * = par1; entity.height = par2; AxisAlignedBB + * entityBoundingBox = entity.getEntityBoundingBox(); + * entityBoundingBox.maxX = entityBoundingBox.minX + + * entity.width; entityBoundingBox.maxZ = + * entityBoundingBox.minZ + entity.width; + * entityBoundingBox.maxY = entityBoundingBox.minY + + * entity.height; } + * + * f2 = par1 % 2.0F; + * + * if (f2 < 0.375D) { entity.myEntitySize = + * EnumEntitySize.SIZE_1; } else if (f2 < 0.75D) { + * entity.myEntitySize = EnumEntitySize.SIZE_2; } else if + * (f2 < 1.0D) { entity.myEntitySize = + * EnumEntitySize.SIZE_3; } else if (f2 < 1.375D) { + * entity.myEntitySize = EnumEntitySize.SIZE_4; } else if + * (f2 < 1.75D) { entity.myEntitySize = + * EnumEntitySize.SIZE_5; } else { entity.myEntitySize = + * EnumEntitySize.SIZE_6; } + */ + } + + public static Entity setName(EntityLiving entity, String name) { + entity.setCustomNameTag(name); + + return entity; + } + + private void addOnKillStats(EntityPlayer player, String mob) { + if (!player.getEntityData().hasKey("KillStats")) { + player.getEntityData().setTag("KillStats", + new NBTTagCompound()); + } + + NBTTagCompound killStats = player.getEntityData() + .getCompoundTag("KillStats"); + + if (!killStats.hasKey(mob)) { + killStats.setInteger(mob, 0); + + if (!killStats.hasKey("TrackedMobList")) { + killStats.setString("TrackedMobList", mob); + } else { + killStats.setString("TrackedMobList", + killStats.getString( + "TrackedMobList") + + ";" + + mob); + } + } + + killStats.setInteger(mob, killStats.getInteger(mob) + 1); + + if (ModjamMod.enableMobKillStats) { + for (int i = 0; i < knowledge.length; i++) { + if (killCount[i] == killStats + .getInteger(mob)) { + NewPacketHandler.SEND_MESSAGE + .sendToPlayer(player, + "\u00A7o\u00A73You've become a " + + knowledge[i].toLowerCase() + + " " + + mob.toLowerCase() + + " slayer! (+" + + damageBonusString[i] + + "% damage against " + + mob.toLowerCase() + + "s.)" + + (i < knowledge.length + - 1 ? " " + (killCount[i + 1] - killCount[i]) + " " + mob.toLowerCase() + " kills to next rank." : "")); + break; + } + } + + int count = 0; + + if (killStats.hasKey("TrackedMobList") && killStats + .getString("TrackedMobList") != null + && killStats.getString( + "TrackedMobList") + .length() > 0) { + for (String object : killStats.getString( + "TrackedMobList") + .split(";")) { + if (killStats.hasKey(object) + && killStats.getInteger( + object) >= killCount[2]) { + count++; + } + } + } + + if (count >= 5) { + // player.triggerAchievement( + // ModjamMod.theHunt); + } + } + + String weapon = "misc"; + + ItemStack heldItem = player + .getHeldItem(EnumHand.MAIN_HAND); + if (heldItem == null) { + weapon = "fist"; + } else if (heldItem.getItem() != null) { + weapon = getUnalteredItemName(heldItem.getItem()); + } + + if (!player.getEntityData().hasKey("WeaponStats")) { + player.getEntityData().setTag("WeaponStats", + new NBTTagCompound()); + } + NBTTagCompound weaponStats = player.getEntityData() + .getCompoundTag("WeaponStats"); + + if (!weaponStats.hasKey(weapon)) { + weaponStats.setInteger(weapon, 0); + + if (!weaponStats.hasKey("TrackedItemList")) { + weaponStats.setString("TrackedItemList", + weapon); + } else { + weaponStats.setString("TrackedItemList", + weaponStats.getString( + "TrackedItemList") + + ";" + + weapon); + } + } + + weaponStats.setInteger(weapon, + weaponStats.getInteger(weapon) + 1); + + if (ModjamMod.enableWeaponKillStats) { + for (int i = 0; i < knowledge.length; i++) { + if (killCount[i] * 2 == weaponStats + .getInteger(weapon)) { + NewPacketHandler.SEND_MESSAGE + .sendToPlayer(player, + "\u00A7o\u00A73You've become a " + + knowledge[i].toLowerCase() + + " " + + weapon.toLowerCase() + + " user! (+" + + damageBonusString[i] + + "% damage with " + + weapon.toLowerCase() + + "s.)" + + (i < knowledge.length + - 1 ? " " + (killCount[i + 1] * 2 - killCount[i] * 2) + " " + weapon.toLowerCase() + " kills to next rank." : "")); + break; + } + } + + int count = 0; + + if (weaponStats.hasKey("TrackedItemList") + && weaponStats.getString( + "TrackedItemList") != null + && weaponStats.getString( + "TrackedItemList") + .length() > 0) { + for (String object : weaponStats.getString( + "TrackedItemList") + .split(";")) { + if (weaponStats.hasKey(object) + && weaponStats.getInteger( + object) >= killCount[1] + * 2) { + count++; + } + } + } + + if (count >= 10) { + // player.triggerAchievement( + // ModjamMod.jackOfAllTrades); + } + } + } + + private void addPlayerStats(EntityJoinWorldEvent event) { + Entity entity = event.getEntity(); + String entityName = entity.getName(); + + if (!entity.getEntityData().hasKey("Blessing") + && CommonTickHandler.worldData.blessingByPlayer + .containsKey(entityName)) { + entity.getEntityData().setString("Blessing", + CommonTickHandler.worldData.blessingByPlayer + .get(entityName)); + + NewPacketHandler.UPDATE_BLESSING.sendToPlayer( + (EntityPlayer) entity, + entity.getEntityData().getString( + "Blessing")); + + CommonTickHandler.worldData.blessingByPlayer + .remove(entityName); + CommonTickHandler.worldData.markDirty(); + } + + if (!entity.getEntityData().hasKey("PotionKnowledge") + && CommonTickHandler.worldData.potionKnowledgeByPlayer + .containsKey(entityName)) { + entity.getEntityData().setIntArray( + "PotionKnowledge", + CommonTickHandler.worldData.potionKnowledgeByPlayer + .get(entityName)); + + NewPacketHandler.UPDATE_POTION_KNOWLEDGE + .sendToPlayer((EntityPlayer) entity, + entity.getEntityData() + .getIntArray("PotionKnowledge")); + + CommonTickHandler.worldData.potionKnowledgeByPlayer + .remove(entityName); + CommonTickHandler.worldData.markDirty(); + } + + if (!entity.getEntityData().hasKey("KillStats") + && CommonTickHandler.worldData.killStatsByPlayer + .containsKey(entityName)) { + entity.getEntityData().setTag("KillStats", + CommonTickHandler.worldData.killStatsByPlayer + .get(entityName)); + + CommonTickHandler.worldData.killStatsByPlayer + .remove(entityName); + CommonTickHandler.worldData.markDirty(); + } + + if (!entity.getEntityData().hasKey("WeaponStats") + && CommonTickHandler.worldData.weaponStatsByPlayer + .containsKey(entityName)) { + entity.getEntityData().setTag("WeaponStats", + CommonTickHandler.worldData.weaponStatsByPlayer + .get(entityName)); + + CommonTickHandler.worldData.killStatsByPlayer + .remove(entityName); + CommonTickHandler.worldData.markDirty(); + } + + if (!entity.getEntityData().hasKey("CraftingStats") + && CommonTickHandler.worldData.craftingStatsByPlayer + .containsKey(entityName)) { + entity.getEntityData().setTag("CraftingStats", + CommonTickHandler.worldData.craftingStatsByPlayer + .get(entityName)); + + CommonTickHandler.worldData.craftingStatsByPlayer + .remove(entityName); + CommonTickHandler.worldData.markDirty(); + } + } + + private void advanceKillTaskProgress(LivingDeathEvent event) { + CommonTickHandler.worldData.progress++; + + String name1 = CommonTickHandler.worldData.currentTask + .equals("Kill") ? FyresWorldData.validMobNames[CommonTickHandler.worldData.currentTaskID] + : FyresWorldData.validItems[CommonTickHandler.worldData.currentTaskID] + .getDisplayName(); + + if (name1.contains("Block")) { + if (name1.contains("Block")) { + name1 = name1.replace("Block", "Blocks") + .replace("block", + "blocks"); + } + } else { + name1 += "s"; + } + + NewPacketHandler.SEND_MESSAGE.sendToAllPlayers( + "\u00A7fCurrent Goal Progress: " + + CommonTickHandler.worldData.progress + + "/" + + CommonTickHandler.worldData.currentTaskAmount + + " " + name1 + " " + + CommonTickHandler.worldData.currentTask + + "ed."); + + if (CommonTickHandler.worldData.progress >= CommonTickHandler.worldData.currentTaskAmount) { + CommonTickHandler.worldData.progress = 0; + CommonTickHandler.worldData.tasksCompleted++; + + NewPacketHandler.LEVEL_UP.sendToAllPlayers( + CommonTickHandler.worldData.rewardLevels); + + if (!CommonTickHandler.worldData.enderDragonKilled + && event.getEntity() instanceof EntityDragon) { + CommonTickHandler.worldData.enderDragonKilled = true; + } + + CommonTickHandler.worldData.giveNewTask(); + + NewPacketHandler.SEND_MESSAGE.sendToAllPlayers( + "\u00A7eA world goal has been completed!" + + (!CommonTickHandler.worldData + .getDisadvantage() + .equals("None") ? " World disadvantage has been lifted!" + : "")); + + NewPacketHandler.SEND_MESSAGE.sendToAllPlayers( + "\u00A7eA new world goal has been set: " + + (CommonTickHandler.worldData.currentTask + + " " + + CommonTickHandler.worldData.currentTaskAmount + + " " + + (CommonTickHandler.worldData.currentTask + .equals("Kill") ? FyresWorldData.validMobNames[CommonTickHandler.worldData.currentTaskID] + : FyresWorldData.validItems[CommonTickHandler.worldData.currentTaskID] + .getDisplayName()) + + "s. (" + + CommonTickHandler.worldData.progress + + " " + + CommonTickHandler.worldData.currentTask + + "ed)")); + + CommonTickHandler.worldData.currentDisadvantage = "None"; + } + + NewPacketHandler.UPDATE_WORLD_DATA.sendToAllPlayers( + CommonTickHandler.worldData.potionValues, + CommonTickHandler.worldData.potionDurations, + CommonTickHandler.worldData + .getDisadvantage(), + CommonTickHandler.worldData.currentTask, + CommonTickHandler.worldData.currentTaskID, + CommonTickHandler.worldData.currentTaskAmount, + CommonTickHandler.worldData.progress, + CommonTickHandler.worldData.tasksCompleted, + CommonTickHandler.worldData.enderDragonKilled, + ModjamMod.spawnTraps, + CommonTickHandler.worldData.rewardLevels, + CommonTickHandler.worldData.mushroomColors); + + CommonTickHandler.worldData.markDirty(); + } + + private void cloneMob(EntityJoinWorldEvent event) { + event.getEntity().getEntityData().setBoolean("isClone", + true); + + Entity entityNew = null; + + try { + Constructor[] constructors = event.getEntity() + .getClass().getConstructors(); + + for (int i = 0; i < constructors.length; i++) { + Class[] parameters = constructors[i] + .getParameterTypes(); + + if (parameters.length == 1 && parameters[0] + .equals(World.class)) { + entityNew = (Entity) event + .getEntity() + .getClass() + .getConstructors()[i] + .newInstance(event + .getWorld()); + } + } + + } catch (Exception e) { + e.printStackTrace(); + } + + if (entityNew != null) { + entityNew.setLocationAndAngles( + event.getEntity().posX, + event.getEntity().posY, + event.getEntity().posZ, + event.getEntity().rotationYaw, + event.getEntity().rotationPitch); + + entityNew.getEntityData().setBoolean("isClone", + true); + + entityNew.dimension = event.getEntity().dimension; + + CommonTickHandler.addLater.add(entityNew); + } + } + + @SubscribeEvent + public void entityJoinWorld(EntityJoinWorldEvent event) { + if (!event.getWorld().isRemote) { + processEntity(event.getEntity(), ModjamMod.r); + + boolean isClone = isEntityClone(event); + + if (shouldCloneMob(event, isClone)) { + cloneMob(event); + } + + if (event.getEntity() instanceof EntityPlayer) { + addPlayerStats(event); + } + } + } + + private void handleBlessings(LivingDeathEvent event) { + String blessing = event.getSource().getTrueSource() + .getEntityData().getString("Blessing"); + + BlessingUtils.getBlessingInstance(blessing) + .onMobKill(event); + } + + private boolean isEntityClone(EntityJoinWorldEvent event) { + if (event.getEntity().getEntityData().hasKey("isClone")) { + return event.getEntity().getEntityData() + .getBoolean("isClone"); + } else { + return false; + } + } + + @SuppressWarnings("unchecked") + @SubscribeEvent + public void livingDeath(LivingDeathEvent event) { + if (!event.getEntity().world.isRemote) { + if (event.getEntity().world.getGameRules() + .getBoolean("doMobLoot")) { + + if (event.getEntity() instanceof EntityLivingBase + && event.getSource() != null + && event.getSource() + .getTrueSource() != null) { + if (BlessingUtils.hasBlessing(event + .getSource() + .getTrueSource())) { + handleBlessings(event); + } + } + + int level = 0; + + if (event.getEntity().getEntityData() + .hasKey("Level")) { + level = Integer.parseInt( + event.getEntity().getEntityData() + .getString("Level")); + } + + if (ModjamMod.r.nextInt(30) == 0 + || level == 5) { + event.getEntity().entityDropItem( + new ItemStack(ModjamMod.mysteryPotion, + 1, + ModjamMod.r.nextInt( + 13)), + event.getEntity().height + / 2); + } + } + + if (CommonTickHandler.worldData.currentTask + .equals("Kill") + && FyresWorldData.validMobs[CommonTickHandler.worldData.currentTaskID] + .isAssignableFrom( + event.getEntity().getClass())) { + advanceKillTaskProgress(event); + } + + if (!CommonTickHandler.worldData.enderDragonKilled + && event.getEntity() instanceof EntityDragon) { + CommonTickHandler.worldData.enderDragonKilled = true; + NewPacketHandler.UPDATE_WORLD_DATA + .sendToAllPlayers( + CommonTickHandler.worldData.potionValues, + CommonTickHandler.worldData.potionDurations, + CommonTickHandler.worldData + .getDisadvantage(), + CommonTickHandler.worldData.currentTask, + CommonTickHandler.worldData.currentTaskID, + CommonTickHandler.worldData.currentTaskAmount, + CommonTickHandler.worldData.progress, + CommonTickHandler.worldData.tasksCompleted, + CommonTickHandler.worldData.enderDragonKilled, + ModjamMod.spawnTraps, + CommonTickHandler.worldData.rewardLevels, + CommonTickHandler.worldData.mushroomColors); + CommonTickHandler.worldData.markDirty(); + } + } + + if (event.getEntity() instanceof EntityPlayer) { + EntityPlayer player = (EntityPlayer) event.getEntity(); + + //player.triggerAchievement(ModjamMod.losingIsFun); + + CommonTickHandler.worldData.blessingByPlayer.put( + player.getName(), + player.getEntityData().getString( + "Blessing")); + + CommonTickHandler.worldData.potionKnowledgeByPlayer + .put(player.getName(), + player.getEntityData() + .getIntArray("PotionKnowledge")); + + if (player.getEntityData() != null + && player.getEntityData().hasKey( + "KillStats")) { + CommonTickHandler.worldData.killStatsByPlayer + .put(player.getName(), + player.getEntityData() + .getCompoundTag("KillStats")); + } + + if (player.getEntityData() != null + && player.getEntityData().hasKey( + "WeaponStats")) { + CommonTickHandler.worldData.weaponStatsByPlayer + .put(player.getName(), + player.getEntityData() + .getCompoundTag("WeaponStats")); + } + + if (player.getEntityData() != null + && player.getEntityData().hasKey( + "CraftingStats")) { + CommonTickHandler.worldData.craftingStatsByPlayer + .put(player.getName(), + player.getEntityData() + .getCompoundTag("CraftingStats")); + } + } else if (event.getSource() != null + && event.getSource().getTrueSource() != null + && event.getSource().getTrueSource() instanceof EntityPlayer) { + EntityPlayer player = (EntityPlayer) event.getSource() + .getTrueSource(); + String mob = getUnalteredName(event.getEntity()); + + if (CommonTickHandler.worldData.getDisadvantage() + .equals("Trigger-happy") + && ModjamMod.r.nextInt(10) == 0) { + player.world.createExplosion(player, + event.getEntity().posX, + event.getEntity().posY, + event.getEntity().posZ, 1, + true); + } + + addOnKillStats(player, mob); + } + } + + public void register() { + MinecraftForge.EVENT_BUS.register(this); + } + + private boolean shouldCloneMob(EntityJoinWorldEvent event, + boolean isClone) { + return CommonTickHandler.worldData != null + && CommonTickHandler.worldData + .getDisadvantage() + .equals("Increased Mob Spawn") + && (event.getEntity() instanceof EntityMob) + && !(event.getEntity() instanceof EntityDragon) + && !isClone && ModjamMod.r.nextInt(3) == 0; + } +} diff --git a/src/main/java/fyresmodjam/misc/EntityStatTracker.java b/src/main/java/fyresmodjam/misc/EntityStatTracker.java new file mode 100644 index 0000000..f059141 --- /dev/null +++ b/src/main/java/fyresmodjam/misc/EntityStatTracker.java @@ -0,0 +1,29 @@ +package fyresmodjam.misc; + +import java.util.ArrayList; + +public class EntityStatTracker { + public Class[] classes; + + public boolean instanceAllowed = false; + + public EntityStatTracker(Class[] classes, + boolean instancesAllowed) { + this.classes = classes; + instanceAllowed = instancesAllowed; + } + + public EntityStatTracker(Class c, boolean instancesAllowed) { + this(new Class[] { + c + }, instancesAllowed); + } + + public ArrayList stats = new ArrayList(); + + public void addStat(EntityStat stat) { + if (!stats.contains(stat)) { + stats.add(stat); + } + } +} \ No newline at end of file diff --git a/src/main/java/fyresmodjam/misc/ItemStat.java b/src/main/java/fyresmodjam/misc/ItemStat.java new file mode 100644 index 0000000..888a34c --- /dev/null +++ b/src/main/java/fyresmodjam/misc/ItemStat.java @@ -0,0 +1,30 @@ +package fyresmodjam.misc; + +import java.util.Random; + +import net.minecraft.item.ItemStack; + +public class ItemStat { + public String name; + public String value; + + public ItemStat(String name, Object value) { + this.name = name; + this.value = value.toString(); + } + + public Object getNewValue(ItemStack stack, Random r) { + return value; + } + + public String getLore(ItemStack stack) { + return null; + } + + public String getAlteredStackName(ItemStack stack, Random r) { + return stack.getDisplayName(); + } + + public void modifyStack(ItemStack stack, Random r) { + } +} \ No newline at end of file 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); + } +} diff --git a/src/main/java/fyresmodjam/misc/ItemStatTracker.java b/src/main/java/fyresmodjam/misc/ItemStatTracker.java new file mode 100644 index 0000000..743f853 --- /dev/null +++ b/src/main/java/fyresmodjam/misc/ItemStatTracker.java @@ -0,0 +1,29 @@ +package fyresmodjam.misc; + +import java.util.ArrayList; + +public class ItemStatTracker { + public Class[] classes; + + public boolean instanceAllowed = false; + + public ItemStatTracker(Class[] classes, + boolean instanceAllowed) { + this.classes = classes; + this.instanceAllowed = instanceAllowed; + } + + public ItemStatTracker(Class c, boolean instanceAllowed) { + this(new Class[] { + c + }, instanceAllowed); + } + + public ArrayList stats = new ArrayList(); + + public void addStat(ItemStat stat) { + if (!stats.contains(stat)) { + stats.add(stat); + } + } +} \ No newline at end of file diff --git a/src/main/java/fyresmodjam/misc/WeaponRankStat.java b/src/main/java/fyresmodjam/misc/WeaponRankStat.java new file mode 100644 index 0000000..e844dc2 --- /dev/null +++ b/src/main/java/fyresmodjam/misc/WeaponRankStat.java @@ -0,0 +1,83 @@ +package fyresmodjam.misc; + +import java.util.Random; + +import fyresmodjam.ModjamMod; +import net.minecraft.item.ItemBow; +import net.minecraft.item.ItemStack; + +public final class WeaponRankStat extends ItemStat { + /* + * @formatter:off + */ + public String[][] prefixesByRank = { + { + "Old", "Dull", "Broken", "Worn" + }, + { + "Average", "Decent", "Modest", "Ordinary" + }, + { + "Strong", "Sharp", "Polished", "Refined" + }, + { + "Powerful", "Ruthless", "Elite", "Astonishing" + }, + { + "Godly", "Divine", "Fabled", "Legendary" + } + }; + /* + * @formatter:on + */ + public WeaponRankStat(String name, Object value) { + super(name, value); + } + + @Override + public Object getNewValue(ItemStack stack, Random r) { + int i = 1; + for (; i < 5; i++) { + if (ModjamMod.r.nextInt(10) < 7) { + break; + } + } + return i; + } + + @Override + public void modifyStack(ItemStack stack, Random r) { + int rank = Integer.parseInt( + stack.getTagCompound().getString(name)); + float bonusDamage = ((float) rank - 1) / 2 + + (r.nextInt(rank + 1) * r.nextFloat()); + + ItemStatHelper.giveStat(stack, "BonusDamage", + String.format("%.2f", bonusDamage)); + ItemStatHelper.addLore(stack, !String.format("%.2f", + bonusDamage) + .equals("0.00") ? "\u00A77\u00A7o " + + (bonusDamage > 0 ? "+" + : "") + + String.format("%.2f", + bonusDamage) + + " bonus damage" : null); + + ItemStatHelper.addLore(stack, "\u00A7eRank: " + rank); + } + + @Override + public String getAlteredStackName(ItemStack stack, Random r) { + String[] list = prefixesByRank[Integer.parseInt( + stack.getTagCompound().getString(name)) + - 1]; + String prefix = list[r.nextInt(list.length)]; + + if (prefix.equals("Sharp") + && stack.getItem() instanceof ItemBow) { + prefix = "Long"; + } + + return "\u00A7f" + prefix + " " + stack.getDisplayName(); + } +} \ No newline at end of file -- cgit v1.2.3