Initial commit

13 files changed, 1874 insertions, 0 deletions

diff --git a/YWD/src/main/java/fyresmodjam/misc/ArmorStatTracker.java b/YWD/src/main/java/fyresmodjam/misc/ArmorStatTracker.java
new file mode 100755
index 0000000..80a8c2a
--- /dev/null
+++ b/YWD/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/YWD/src/main/java/fyresmodjam/misc/BehaviorDispenseTrap.java b/YWD/src/main/java/fyresmodjam/misc/BehaviorDispenseTrap.java
new file mode 100755
index 0000000..ee06715
--- /dev/null
+++ b/YWD/src/main/java/fyresmodjam/misc/BehaviorDispenseTrap.java
@@ -0,0 +1,45 @@
+package fyresmodjam.misc;

+

+import fyresmodjam.ModjamMod;

+import net.minecraft.block.BlockDispenser;

+import net.minecraft.dispenser.BehaviorDefaultDispenseItem;

+import net.minecraft.dispenser.IBlockSource;

+import net.minecraft.item.ItemStack;

+import net.minecraft.util.EnumFacing;

+import net.minecraft.world.World;

+

+public class BehaviorDispenseTrap extends BehaviorDefaultDispenseItem {

+

+	private final BehaviorDefaultDispenseItem field_96465_b = new BehaviorDefaultDispenseItem();

+

+	@Override

+	public ItemStack dispenseStack(IBlockSource par1IBlockSource,

+			ItemStack par2ItemStack) {

+

+		EnumFacing enumfacing = BlockDispenser.func_149937_b(

+				par1IBlockSource.getBlockMetadata());

+

+		World world = par1IBlockSource.getWorld();

+

+		int i = par1IBlockSource.getXInt()

+				+ enumfacing.getFrontOffsetX();

+		int j = par1IBlockSource.getYInt()

+				+ enumfacing.getFrontOffsetY();

+		int k = par1IBlockSource.getZInt()

+				+ enumfacing.getFrontOffsetZ();

+

+		if (!ModjamMod.blockTrap.canPlaceBlockAt(world, i, j, k)) {

+			return field_96465_b.dispense(par1IBlockSource,

+					par2ItemStack);

+		}

+

+		world.setBlock(i, j, k, ModjamMod.blockTrap,

+				par2ItemStack.getItemDamage(), 0);

+		world.markBlockForUpdate(i, j, k);

+

+		par2ItemStack.splitStack(1);

+

+		return par2ItemStack;

+

+	}

+}

diff --git a/YWD/src/main/java/fyresmodjam/misc/ConfigData.java b/YWD/src/main/java/fyresmodjam/misc/ConfigData.java
new file mode 100644
index 0000000..0d7a328
--- /dev/null
+++ b/YWD/src/main/java/fyresmodjam/misc/ConfigData.java
@@ -0,0 +1,140 @@
+package fyresmodjam.misc;
+
+import org.lwjgl.input.Keyboard;
+
+import net.minecraftforge.common.config.Configuration;
+
+public class ConfigData {
+	/*
+	 * Starting ID for achievements
+	 */
+	public static int achievementID = 2500;
+
+	/*
+	 * Keybindings
+	 */
+	public static int	examineKey	= Keyboard.KEY_X;
+	public static int	blessingKey	= Keyboard.KEY_K;
+
+	/*
+	 * World generation settings
+	 */
+	// Pillars
+	public static int	pillarGenChance		= 75;
+	public static int	maxPillarsPerChunk	= 3;
+	public static boolean	spawnRandomPillars	= true;
+	// Towers
+	public static int	towerGenChance	= 225;
+	public static boolean	spawnTowers	= true;
+	// Traps
+	public static int	trapGenChance		= 300;
+	public static boolean	spawnTraps		= true;
+	public static boolean	trapsBelowGroundOnly	= false;
+	// Mushrooms
+	public static int mushroomReplaceChance = 15;
+
+	/*
+	 * Statistic tracking
+	 */
+	public static boolean	enableWeaponKillStats	= true;
+	public static boolean	enableMobKillStats	= true;
+	public static boolean	enableCraftingStats	= true;
+
+	/*
+	 * Blessing/Mark parameters
+	 */
+	public static final double RETALIATION_CHANCE = 0.05;
+
+	/*
+	 * Misc. Toggles
+	 */
+	public static boolean	pillarGlow			= true;
+	public static boolean	disableDisadvantages		= false;
+	public static boolean	versionChecking			= true;
+	public static boolean	showAllPillarsInCreative	= false;
+	public static void loadFromConfig(Configuration config) {
+		pillarGlow = config
+				.get(Configuration.CATEGORY_GENERAL,
+						"pillar_glow",
+						pillarGlow)
+				.getBoolean(pillarGlow);
+	
+		pillarGenChance = config
+				.get(Configuration.CATEGORY_GENERAL,
+						"pillar_gen_difficulty",
+						pillarGenChance)
+				.getInt();
+		maxPillarsPerChunk = config.get(
+				Configuration.CATEGORY_GENERAL,
+				"max_pillars_per_chunk",
+				maxPillarsPerChunk).getInt();
+		towerGenChance = config
+				.get(Configuration.CATEGORY_GENERAL,
+						"tower_gen_difficulty",
+						towerGenChance)
+				.getInt();
+		trapGenChance = config
+				.get(Configuration.CATEGORY_GENERAL,
+						"trap_gen_difficulty",
+						trapGenChance)
+				.getInt();
+		mushroomReplaceChance = config.get(
+				Configuration.CATEGORY_GENERAL,
+				"mushroom_replace_difficulty",
+				mushroomReplaceChance).getInt();
+	
+		spawnTraps = !(config
+				.get(Configuration.CATEGORY_GENERAL,
+						"disable_traps",
+						!spawnTraps)
+				.getBoolean(!spawnTraps));
+		spawnTowers = config
+				.get(Configuration.CATEGORY_GENERAL,
+						"spawn_towers",
+						spawnTowers)
+				.getBoolean(spawnTowers);
+		spawnRandomPillars = config.get(
+				Configuration.CATEGORY_GENERAL,
+				"spawn_random_pillars",
+				spawnRandomPillars)
+				.getBoolean(spawnRandomPillars);
+		disableDisadvantages = config.get(
+				Configuration.CATEGORY_GENERAL,
+				"disable_disadvantages",
+				disableDisadvantages)
+				.getBoolean(disableDisadvantages);
+		versionChecking = config
+				.get(Configuration.CATEGORY_GENERAL,
+						"version_checking",
+						versionChecking)
+				.getBoolean(versionChecking);
+	
+		showAllPillarsInCreative = config.get(
+				Configuration.CATEGORY_GENERAL,
+				"show_all_pillars_in_creative",
+				showAllPillarsInCreative)
+				.getBoolean(showAllPillarsInCreative);
+	
+		enableMobKillStats = config.get(
+				Configuration.CATEGORY_GENERAL,
+				"enable_mob_kill_stats",
+				enableMobKillStats)
+				.getBoolean(enableMobKillStats);
+		enableWeaponKillStats = config.get(
+				Configuration.CATEGORY_GENERAL,
+				"enable_weapon_kill_stats",
+				enableWeaponKillStats)
+				.getBoolean(enableWeaponKillStats);
+		enableCraftingStats = config.get(
+				Configuration.CATEGORY_GENERAL,
+				"enable_crafting_stats",
+				enableCraftingStats)
+				.getBoolean(enableCraftingStats);
+	
+		trapsBelowGroundOnly = config.get(
+				Configuration.CATEGORY_GENERAL,
+				"traps_below_ground_only",
+				trapsBelowGroundOnly)
+				.getBoolean(trapsBelowGroundOnly);
+	}
+}
\ No newline at end of file
diff --git a/YWD/src/main/java/fyresmodjam/misc/CreativeTabModjamMod.java b/YWD/src/main/java/fyresmodjam/misc/CreativeTabModjamMod.java
new file mode 100755
index 0000000..718e9e5
--- /dev/null
+++ b/YWD/src/main/java/fyresmodjam/misc/CreativeTabModjamMod.java
@@ -0,0 +1,77 @@
+package fyresmodjam.misc;

+

+import java.lang.reflect.Field;

+import java.util.ArrayList;

+import java.util.List;

+

+import cpw.mods.fml.relauncher.Side;

+import cpw.mods.fml.relauncher.SideOnly;

+import fyresmodjam.ModjamMod;

+import net.minecraft.block.Block;

+import net.minecraft.creativetab.CreativeTabs;

+import net.minecraft.item.Item;

+import net.minecraft.item.ItemStack;

+

+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 displayAllReleventItems(List par1List) {

+		try {

+			ArrayList<ItemStack> list = new ArrayList<ItemStack>();

+

+			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;

+					}

+					item.getSubItems(item, this, list);

+				} 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 Item getTabIconItem() {

+		return ModjamMod.itemTrap;

+	}

+

+}

diff --git a/YWD/src/main/java/fyresmodjam/misc/DamageSourceRetaliation.java b/YWD/src/main/java/fyresmodjam/misc/DamageSourceRetaliation.java
new file mode 100644
index 0000000..2dc89fd
--- /dev/null
+++ b/YWD/src/main/java/fyresmodjam/misc/DamageSourceRetaliation.java
@@ -0,0 +1,11 @@
+package fyresmodjam.misc;
+
+import net.minecraft.util.DamageSource;
+
+public class DamageSourceRetaliation extends DamageSource {
+
+	public DamageSourceRetaliation(String name) {
+		super(name);
+	}
+
+}
diff --git a/YWD/src/main/java/fyresmodjam/misc/DamageSources.java b/YWD/src/main/java/fyresmodjam/misc/DamageSources.java
new file mode 100644
index 0000000..b1fdc01
--- /dev/null
+++ b/YWD/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/YWD/src/main/java/fyresmodjam/misc/EntityStat.java b/YWD/src/main/java/fyresmodjam/misc/EntityStat.java
new file mode 100755
index 0000000..84afd71
--- /dev/null
+++ b/YWD/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.getCommandSenderName();
+	}
+
+	public void modifyEntity(Entity entity) {
+	}
+}
\ No newline at end of file
diff --git a/YWD/src/main/java/fyresmodjam/misc/EntityStatHelper.java b/YWD/src/main/java/fyresmodjam/misc/EntityStatHelper.java
new file mode 100755
index 0000000..92635b9
--- /dev/null
+++ b/YWD/src/main/java/fyresmodjam/misc/EntityStatHelper.java
@@ -0,0 +1,751 @@
+package fyresmodjam.misc;

+

+import java.lang.reflect.Constructor;

+import java.util.ArrayList;

+import java.util.HashMap;

+import java.util.Random;

+

+import cpw.mods.fml.common.eventhandler.SubscribeEvent;

+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.Entity.EnumEntitySize;

+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.StatCollector;

+import net.minecraft.world.World;

+import net.minecraftforge.common.MinecraftForge;

+import net.minecraftforge.event.entity.EntityJoinWorldEvent;

+import net.minecraftforge.event.entity.living.LivingDeathEvent;

+

+@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<Class, EntityStatTracker> statTrackersByClass = new HashMap<Class, EntityStatTracker>();

+

+	public static ArrayList<EntityStatTracker> genericTrackers = new ArrayList<EntityStatTracker>();

+

+	public static ArrayList<EntityStatTracker>	temp	= new ArrayList<EntityStatTracker>();

+	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 StatCollector.translateToLocal(

+				item.getUnlocalizedName() + ".name");

+	}

+

+	public static String getUnalteredName(Entity entity) {

+		String s = EntityList.getEntityString(entity);

+

+		if (s == null) {

+			s = "generic";

+		}

+

+		return StatCollector

+				.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;

+

+		if (par1 != entity.width || par2 != entity.height) {

+			f2 = entity.width;

+			entity.width = par1;

+			entity.height = par2;

+			entity.boundingBox.maxX = entity.boundingBox.minX

+					+ entity.width;

+			entity.boundingBox.maxZ = entity.boundingBox.minZ

+					+ entity.width;

+			entity.boundingBox.maxY = entity.boundingBox.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 (ConfigData.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";

+

+		if (player.getHeldItem() == null) {

+			weapon = "fist";

+		} else if (player.getHeldItem().getItem() != null) {

+			weapon = getUnalteredItemName(

+					player.getHeldItem().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 (ConfigData.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) {

+		if (!event.entity.getEntityData().hasKey("Blessing")

+				&& CommonTickHandler.worldData.blessingByPlayer

+						.containsKey(event.entity

+								.getCommandSenderName())) {

+			event.entity.getEntityData().setString("Blessing",

+					CommonTickHandler.worldData.blessingByPlayer

+							.get(event.entity

+									.getCommandSenderName()));

+

+			NewPacketHandler.UPDATE_BLESSING.sendToPlayer(

+					(EntityPlayer) event.entity,

+					event.entity.getEntityData()

+							.getString("Blessing"));

+

+			CommonTickHandler.worldData.blessingByPlayer

+					.remove(event.entity

+							.getCommandSenderName());

+			CommonTickHandler.worldData.markDirty();

+		}

+

+		if (!event.entity.getEntityData().hasKey("PotionKnowledge")

+				&& CommonTickHandler.worldData.potionKnowledgeByPlayer

+						.containsKey(event.entity

+								.getCommandSenderName())) {

+			event.entity.getEntityData().setIntArray(

+					"PotionKnowledge",

+					CommonTickHandler.worldData.potionKnowledgeByPlayer

+							.get(event.entity

+									.getCommandSenderName()));

+

+			NewPacketHandler.UPDATE_POTION_KNOWLEDGE

+					.sendToPlayer((EntityPlayer) event.entity,

+							event.entity.getEntityData()

+									.getIntArray("PotionKnowledge"));

+

+			CommonTickHandler.worldData.potionKnowledgeByPlayer

+					.remove(event.entity

+							.getCommandSenderName());

+			CommonTickHandler.worldData.markDirty();

+		}

+

+		if (!event.entity.getEntityData().hasKey("KillStats")

+				&& CommonTickHandler.worldData.killStatsByPlayer

+						.containsKey(event.entity

+								.getCommandSenderName())) {

+			event.entity.getEntityData().setTag("KillStats",

+					CommonTickHandler.worldData.killStatsByPlayer

+							.get(event.entity

+									.getCommandSenderName()));

+

+			CommonTickHandler.worldData.killStatsByPlayer

+					.remove(event.entity

+							.getCommandSenderName());

+			CommonTickHandler.worldData.markDirty();

+		}

+

+		if (!event.entity.getEntityData().hasKey("WeaponStats")

+				&& CommonTickHandler.worldData.weaponStatsByPlayer

+						.containsKey(event.entity

+								.getCommandSenderName())) {

+			event.entity.getEntityData().setTag("WeaponStats",

+					CommonTickHandler.worldData.weaponStatsByPlayer

+							.get(event.entity

+									.getCommandSenderName()));

+

+			CommonTickHandler.worldData.killStatsByPlayer

+					.remove(event.entity

+							.getCommandSenderName());

+			CommonTickHandler.worldData.markDirty();

+		}

+

+		if (!event.entity.getEntityData().hasKey("CraftingStats")

+				&& CommonTickHandler.worldData.craftingStatsByPlayer

+						.containsKey(event.entity

+								.getCommandSenderName())) {

+			event.entity.getEntityData().setTag(

+					"CraftingStats",

+					CommonTickHandler.worldData.craftingStatsByPlayer

+							.get(event.entity

+									.getCommandSenderName()));

+

+			CommonTickHandler.worldData.craftingStatsByPlayer

+					.remove(event.entity

+							.getCommandSenderName());

+			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.entity 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,

+				ConfigData.spawnTraps,

+				CommonTickHandler.worldData.rewardLevels,

+				CommonTickHandler.worldData.mushroomColors);

+

+		CommonTickHandler.worldData.markDirty();

+	}

+

+	private void cloneMob(EntityJoinWorldEvent event) {

+		event.entity.getEntityData().setBoolean("isClone", true);

+

+		Entity entityNew = null;

+

+		try {

+			Constructor[] constructors = event.entity

+					.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.entity

+							.getClass()

+							.getConstructors()[i]

+									.newInstance(event.world);

+				}

+			}

+

+		} catch (Exception e) {

+			e.printStackTrace();

+		}

+

+		if (entityNew != null) {

+			entityNew.setLocationAndAngles(event.entity.posX,

+					event.entity.posY,

+					event.entity.posZ,

+					event.entity.rotationYaw,

+					event.entity.rotationPitch);

+

+			entityNew.getEntityData().setBoolean("isClone",

+					true);

+

+			entityNew.dimension = event.entity.dimension;

+

+			CommonTickHandler.addLater.add(entityNew);

+		}

+	}

+

+	@SubscribeEvent

+	public void entityJoinWorld(EntityJoinWorldEvent event) {

+		if (!event.world.isRemote) {

+			processEntity(event.entity, ModjamMod.r);

+

+			boolean isClone = isEntityClone(event);

+

+			if (shouldCloneMob(event, isClone)) {

+				cloneMob(event);

+			}

+

+			if (event.entity instanceof EntityPlayer) {

+				addPlayerStats(event);

+			}

+		}

+	}

+

+	private void handleBlessings(LivingDeathEvent event) {

+		String blessing = event.source.getEntity().getEntityData()

+				.getString("Blessing");

+

+		BlessingUtils.getBlessingInstance(blessing).onMobKill(event);

+	}

+

+	private boolean isEntityClone(EntityJoinWorldEvent event) {

+		if (event.entity.getEntityData().hasKey("isClone")) {

+			return event.entity.getEntityData()

+					.getBoolean("isClone");

+		} else {

+			return false;

+		}

+	}

+

+	@SuppressWarnings("unchecked")

+	@SubscribeEvent

+	public void livingDeath(LivingDeathEvent event) {

+		if (!event.entity.worldObj.isRemote) {

+			if (event.entity.worldObj.getGameRules()

+					.getGameRuleBooleanValue(

+							"doMobLoot")) {

+

+				if (event.entity instanceof EntityLivingBase

+						&& event.source != null

+						&& event.source.getEntity() != null) {

+					if (BlessingUtils.hasBlessing(event.source.getEntity())) {

+						handleBlessings(event);

+					}

+				}

+

+				int level = 0;

+

+				if (event.entity.getEntityData()

+						.hasKey("Level")) {

+					level = Integer.parseInt(

+							event.entity.getEntityData()

+									.getString("Level"));

+				}

+

+				if (ModjamMod.r.nextInt(30) == 0

+						|| level == 5) {

+					event.entity.entityDropItem(

+							new ItemStack(ModjamMod.mysteryPotion,

+									1,

+									ModjamMod.r.nextInt(

+											13)),

+							event.entity.height

+									/ 2);

+				}

+			}

+

+			if (CommonTickHandler.worldData.currentTask

+					.equals("Kill")

+					&& FyresWorldData.validMobs[CommonTickHandler.worldData.currentTaskID]

+							.isAssignableFrom(

+									event.entity.getClass())) {

+				advanceKillTaskProgress(event);

+			}

+

+			if (!CommonTickHandler.worldData.enderDragonKilled

+					&& event.entity 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,

+								ConfigData.spawnTraps,

+								CommonTickHandler.worldData.rewardLevels,

+								CommonTickHandler.worldData.mushroomColors);

+				CommonTickHandler.worldData.markDirty();

+			}

+		}

+

+		if (event.entity instanceof EntityPlayer) {

+			EntityPlayer player = (EntityPlayer) event.entity;

+

+			player.triggerAchievement(ModjamMod.losingIsFun);

+

+			CommonTickHandler.worldData.blessingByPlayer.put(

+					player.getCommandSenderName(),

+					player.getEntityData().getString(

+							"Blessing"));

+

+			CommonTickHandler.worldData.potionKnowledgeByPlayer

+					.put(player.getCommandSenderName(),

+							player.getEntityData()

+									.getIntArray("PotionKnowledge"));

+

+			if (player.getEntityData() != null

+					&& player.getEntityData().hasKey(

+							"KillStats")) {

+				CommonTickHandler.worldData.killStatsByPlayer

+						.put(player.getCommandSenderName(),

+								player.getEntityData()

+										.getCompoundTag("KillStats"));

+			}

+

+			if (player.getEntityData() != null

+					&& player.getEntityData().hasKey(

+							"WeaponStats")) {

+				CommonTickHandler.worldData.weaponStatsByPlayer

+						.put(player.getCommandSenderName(),

+								player.getEntityData()

+										.getCompoundTag("WeaponStats"));

+			}

+

+			if (player.getEntityData() != null

+					&& player.getEntityData().hasKey(

+							"CraftingStats")) {

+				CommonTickHandler.worldData.craftingStatsByPlayer

+						.put(player.getCommandSenderName(),

+								player.getEntityData()

+										.getCompoundTag("CraftingStats"));

+			}

+		} else if (event.source != null

+				&& event.source.getEntity() != null

+				&& event.source.getEntity() instanceof EntityPlayer) {

+			EntityPlayer player = (EntityPlayer) event.source

+					.getEntity();

+			String mob = getUnalteredName(event.entity);

+

+			if (CommonTickHandler.worldData.getDisadvantage()

+					.equals("Trigger-happy")

+					&& ModjamMod.r.nextInt(10) == 0) {

+				player.worldObj.createExplosion(player,

+						event.entity.posX,

+						event.entity.posY,

+						event.entity.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.entity instanceof EntityMob)

+				&& !(event.entity instanceof EntityDragon)

+				&& !isClone && ModjamMod.r.nextInt(3) == 0;

+	}

+}

diff --git a/YWD/src/main/java/fyresmodjam/misc/EntityStatTracker.java b/YWD/src/main/java/fyresmodjam/misc/EntityStatTracker.java
new file mode 100755
index 0000000..f059141
--- /dev/null
+++ b/YWD/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<EntityStat> stats = new ArrayList<EntityStat>();
+
+	public void addStat(EntityStat stat) {
+		if (!stats.contains(stat)) {
+			stats.add(stat);
+		}
+	}
+}
\ No newline at end of file
diff --git a/YWD/src/main/java/fyresmodjam/misc/ItemStat.java b/YWD/src/main/java/fyresmodjam/misc/ItemStat.java
new file mode 100755
index 0000000..888a34c
--- /dev/null
+++ b/YWD/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/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<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.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<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.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);

+	}

+}

diff --git a/YWD/src/main/java/fyresmodjam/misc/ItemStatTracker.java b/YWD/src/main/java/fyresmodjam/misc/ItemStatTracker.java
new file mode 100755
index 0000000..743f853
--- /dev/null
+++ b/YWD/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<ItemStat> stats = new ArrayList<ItemStat>();
+
+	public void addStat(ItemStat stat) {
+		if (!stats.contains(stat)) {
+			stats.add(stat);
+		}
+	}
+}
\ No newline at end of file
diff --git a/YWD/src/main/java/fyresmodjam/misc/WeaponRankStat.java b/YWD/src/main/java/fyresmodjam/misc/WeaponRankStat.java
new file mode 100755
index 0000000..e844dc2
--- /dev/null
+++ b/YWD/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