refactor: clean source code

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/pom.xml

@@ -0,0 +1,21 @@
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>com.mineplex</groupId>
+        <artifactId>mineplex-parent</artifactId>
+        <version>dev-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>mineplex-minecraft-game-classcombat</artifactId>
+
+    <dependencies>
+        <dependency>
+            <groupId>${project.groupId}</groupId>
+            <artifactId>mineplex-minecraft-game-core</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+    </dependencies>
+</project>

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Class/ClassManager.java

@@ -0,0 +1,421 @@
+package mineplex.minecraft.game.classcombat.Class;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.player.PlayerCommandPreprocessEvent;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import com.google.gson.Gson;
+
+import mineplex.core.MiniClientPlugin;
+import mineplex.core.account.CoreClientManager;
+import mineplex.core.account.event.ClientWebResponseEvent;
+import mineplex.core.account.permissions.Permission;
+import mineplex.core.account.permissions.PermissionGroup;
+import mineplex.core.common.util.Callback;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.donation.DonationManager;
+import mineplex.core.gadget.GadgetManager;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Class.repository.ClassRepository;
+import mineplex.minecraft.game.classcombat.Class.repository.token.ClientClassTokenWrapper;
+import mineplex.minecraft.game.classcombat.Class.repository.token.CustomBuildToken;
+import mineplex.minecraft.game.classcombat.Skill.ISkill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.item.ItemFactory;
+
+public class ClassManager extends MiniClientPlugin<ClientClass> implements IClassFactory
+{
+	public enum Perm implements Permission
+	{
+		VIEW_OTHER_SKILLS,
+	}
+
+	private CoreClientManager _clientManager;
+	private DonationManager _donationManager;
+	private SkillFactory _skillFactory;
+	private ItemFactory _itemFactory;
+	private ClassRepository _repository;
+	private GadgetManager _gadgetManager;
+	private Map<String, IPvpClass> _classes;
+	private Map<Integer, IPvpClass> _classSalesPackageIdMap;
+
+	private final Object _clientLock = new Object();
+	
+	private boolean _enabled = true;
+	
+	private Map<String, Callback<String>> _messageSuppressed;
+
+	public ClassManager(JavaPlugin plugin, CoreClientManager clientManager, DonationManager donationManager,
+						SkillFactory skillFactory, ItemFactory itemFactory)
+	{
+		super("Class Manager", plugin);
+
+		_plugin = plugin;
+		_clientManager = clientManager;
+		_donationManager = donationManager;
+		_skillFactory = skillFactory;
+		_itemFactory = itemFactory;
+		_repository = new ClassRepository();
+		_classes = new HashMap<>();
+		_classSalesPackageIdMap = new HashMap<>();
+		_messageSuppressed = new ConcurrentHashMap<>();
+
+		PopulateClasses();
+		
+		generatePermissions();
+	}
+	
+	public ClassManager(JavaPlugin plugin, CoreClientManager clientManager, DonationManager donationManager, GadgetManager gadgetManager,
+						SkillFactory skillFactory, ItemFactory itemFactory)
+	{
+		super("Class Manager", plugin);
+
+		_plugin = plugin;
+		_clientManager = clientManager;
+		_donationManager = donationManager;
+		_gadgetManager = gadgetManager;
+		_skillFactory = skillFactory;
+		_itemFactory = itemFactory;
+		_repository = new ClassRepository();
+		_classes = new HashMap<>();
+		_classSalesPackageIdMap = new HashMap<>();
+		_messageSuppressed = new ConcurrentHashMap<>();
+
+		PopulateClasses();
+		
+		generatePermissions();
+	}
+	
+	private void generatePermissions()
+	{
+
+		PermissionGroup.MOD.setPermission(Perm.VIEW_OTHER_SKILLS, true, true);
+	}
+
+	@EventHandler
+	public void OnClientWebResponse(ClientWebResponseEvent event)
+	{
+		ClientClassTokenWrapper token = new Gson().fromJson(event.GetResponse(), ClientClassTokenWrapper.class);
+		LoadClassBuilds(token, event.getUniqueId());
+	}
+
+	private void LoadClassBuilds(ClientClassTokenWrapper token, UUID uuid)
+	{
+		synchronized (_clientLock)
+		{
+			Set(uuid,
+					new ClientClass(this, _skillFactory, _itemFactory, _clientManager.Get(uuid), _donationManager
+							.Get(uuid), token.DonorToken));
+		}
+	}
+
+	private void PopulateClasses()
+	{
+		_classes.clear();
+
+		AddKnight();
+		AddRanger();
+		AddBrute();
+		AddMage();
+		AddAssassin();
+
+		/*
+		 * AddClass(new PvpClass(this, 6, ClassType.Shapeshifter, new String[] {
+		 * "Able to transform into various creatures." },
+		 * Material.LEATHER_HELMET, Material.LEATHER_CHESTPLATE,
+		 * Material.LEATHER_LEGGINGS, Material.LEATHER_BOOTS, Color.fromRGB(20,
+		 * 100, 0)));
+		 */
+		
+		for (IPvpClass pvpClass : GetAllClasses())
+		{
+			CustomBuildToken customBuild = pvpClass.getDefaultBuild();
+			ISkill swordSkill = _skillFactory.GetSkill(customBuild.SwordSkill);
+			ISkill axeSkill = _skillFactory.GetSkill(customBuild.AxeSkill);
+			ISkill bowSkill = _skillFactory.GetSkill(customBuild.BowSkill);
+			ISkill classPassiveASkill = _skillFactory.GetSkill(customBuild.ClassPassiveASkill);
+			ISkill classPassiveBSkill = _skillFactory.GetSkill(customBuild.ClassPassiveBSkill);
+			ISkill globalPassive = _skillFactory.GetSkill(customBuild.GlobalPassiveSkill);
+
+			if (swordSkill != null)
+				swordSkill.setFree(true);
+
+			if (axeSkill != null)
+				axeSkill.setFree(true);
+
+			if (bowSkill != null)
+				bowSkill.setFree(true);
+
+			if (classPassiveASkill != null)
+				classPassiveASkill.setFree(true);
+
+			if (classPassiveBSkill != null)
+				classPassiveBSkill.setFree(true);
+
+			if (globalPassive != null)
+				globalPassive.setFree(true);
+		}
+	}
+
+	private void AddAssassin()
+	{
+		CustomBuildToken customBuild = new CustomBuildToken(ClassType.Assassin);
+		customBuild.Name = "Default Build";
+
+		customBuild.SwordSkill = "Evade";
+		customBuild.SwordSkillLevel = 1;
+		customBuild.AxeSkill = "Leap";
+		customBuild.AxeSkillLevel = 3;
+		customBuild.BowSkill = "Smoke Arrow";
+		customBuild.BowSkillLevel = 2;
+		customBuild.ClassPassiveASkill = "Smoke Bomb";
+		customBuild.ClassPassiveASkillLevel = 2;
+		customBuild.ClassPassiveBSkill = "Combo Attack";
+		customBuild.ClassPassiveBSkillLevel = 2;
+		customBuild.GlobalPassiveSkill = "Break Fall";
+		customBuild.GlobalPassiveSkillLevel = 1;
+
+		AddClass(new PvpClass(this, 5, ClassType.Assassin, customBuild, new String[] { "Extremely nimble and smart.",
+				"Excels at ambushing and takedowns.", "", "Permanent Speed II" }, Material.LEATHER_HELMET,
+				Material.LEATHER_CHESTPLATE, Material.LEATHER_LEGGINGS, Material.LEATHER_BOOTS, null));
+	}
+
+	private void AddMage()
+	{
+		CustomBuildToken customBuild = new CustomBuildToken(ClassType.Mage);
+		customBuild.Name = "Default Build";
+
+		customBuild.SwordSkill = "Inferno";
+		customBuild.SwordSkillLevel = 3;
+		customBuild.AxeSkill = "Fire Blast";
+		customBuild.AxeSkillLevel = 3;
+		customBuild.BowSkill = "";
+		customBuild.ClassPassiveASkill = "Immolate";
+		customBuild.ClassPassiveASkillLevel = 1;
+		customBuild.ClassPassiveBSkill = "Magma Blade";
+		customBuild.ClassPassiveBSkillLevel = 2;
+		customBuild.GlobalPassiveSkill = "Break Fall";
+		customBuild.GlobalPassiveSkillLevel = 2;
+
+		AddClass(new PvpClass(this, 4, ClassType.Mage, customBuild, new String[] { "Trained in the ancient arts.",
+				"Able to adapt to many roles in combat." }, Material.GOLD_HELMET, Material.GOLD_CHESTPLATE,
+				Material.GOLD_LEGGINGS, Material.GOLD_BOOTS, null));
+	}
+
+	private void AddBrute()
+	{
+		CustomBuildToken customBuild = new CustomBuildToken(ClassType.Brute);
+		customBuild.Name = "Default Build";
+
+		customBuild.SwordSkill = "Block Toss";
+		customBuild.SwordSkillLevel = 4;
+		customBuild.AxeSkill = "Seismic Slam";
+		customBuild.AxeSkillLevel = 3;
+		customBuild.BowSkill = "";
+		customBuild.BowSkillLevel = 0;
+		customBuild.ClassPassiveASkill = "Stampede";
+		customBuild.ClassPassiveASkillLevel = 2;
+		customBuild.ClassPassiveBSkill = "Crippling Blow";
+		customBuild.ClassPassiveBSkillLevel = 1;
+		customBuild.GlobalPassiveSkill = "Recharge";
+		customBuild.GlobalPassiveSkillLevel = 1;
+
+		AddClass(new PvpClass(this, 3, ClassType.Brute, customBuild, new String[] { "Uses pure strength to dominate.",
+				"Great at crowd control." }, Material.DIAMOND_HELMET, Material.DIAMOND_CHESTPLATE,
+				Material.DIAMOND_LEGGINGS, Material.DIAMOND_BOOTS, null));
+	}
+
+	private void AddRanger()
+	{
+		CustomBuildToken customBuild = new CustomBuildToken(ClassType.Ranger);
+		customBuild.Name = "Default Build";
+
+		customBuild.SwordSkill = "Disengage";
+		customBuild.SwordSkillLevel = 3;
+		customBuild.AxeSkill = "Agility";
+		customBuild.AxeSkillLevel = 2;
+		customBuild.BowSkill = "Napalm Shot";
+		customBuild.BowSkillLevel = 3;
+		customBuild.ClassPassiveASkill = "Barrage";
+		customBuild.ClassPassiveASkillLevel = 2;
+		customBuild.ClassPassiveBSkill = "Barbed Arrows";
+		customBuild.ClassPassiveBSkillLevel = 1;
+		customBuild.GlobalPassiveSkill = "Resistance";
+		customBuild.GlobalPassiveSkillLevel = 1;
+
+		AddClass(new PvpClass(this, -1, ClassType.Ranger, customBuild, new String[] { "Mastery with a Bow and Arrow.",
+				"Adept in Wilderness Survival" }, Material.CHAINMAIL_HELMET, Material.CHAINMAIL_CHESTPLATE,
+				Material.CHAINMAIL_LEGGINGS, Material.CHAINMAIL_BOOTS, null));
+	}
+
+	private void AddKnight()
+	{
+		CustomBuildToken customBuild = new CustomBuildToken(ClassType.Knight);
+		customBuild.Name = "Default Build";
+
+		customBuild.SwordSkill = "Hilt Smash";
+		customBuild.SwordSkillLevel = 3;
+		customBuild.AxeSkill = "Bulls Charge";
+		customBuild.AxeSkillLevel = 3;
+		customBuild.BowSkill = "";
+		customBuild.ClassPassiveASkill = "Swordsmanship";
+		customBuild.ClassPassiveASkillLevel = 2;
+		customBuild.ClassPassiveBSkill = "Vengeance";
+		customBuild.ClassPassiveBSkillLevel = 2;
+		customBuild.GlobalPassiveSkill = "Resistance";
+		customBuild.GlobalPassiveSkillLevel = 2;
+
+		AddClass(new PvpClass(this, -1, ClassType.Knight, customBuild, new String[] {
+				"Trained in the arts of melee combat.", "Able to stand his ground against foes." },
+				Material.IRON_HELMET, Material.IRON_CHESTPLATE, Material.IRON_LEGGINGS, Material.IRON_BOOTS, null));
+	}
+
+	public IPvpClass GetClass(String className)
+	{
+		return _classes.get(className);
+	}
+
+	public IPvpClass GetClass(int id)
+	{
+		return _classSalesPackageIdMap.get(id);
+	}
+
+	public Collection<IPvpClass> GetAllClasses()
+	{
+		return _classes.values();
+	}
+
+	public void AddClass(PvpClass newClass)
+	{
+		_classes.put(newClass.GetName(), newClass);
+	}
+
+	@Override
+	public Collection<IPvpClass> GetGameClasses()
+	{
+		return _classes.values();
+	}
+
+	@EventHandler
+	public void update(UpdateEvent event)
+	{
+		if (!_enabled)
+			return;
+		
+		if (event.getType() != UpdateType.FAST)
+			return;
+
+		for (IPvpClass cur : _classes.values())
+		{
+			cur.checkEquip();
+		}
+	}
+
+	public SkillFactory GetSkillFactory()
+	{
+		return _skillFactory;
+	}
+	
+	public ItemFactory GetItemFactory()
+	{
+		return _itemFactory;
+	}
+
+	@Override
+	protected ClientClass addPlayer(UUID uuid)
+	{
+		return new ClientClass(this, _skillFactory, _itemFactory, _clientManager.Get(uuid), _donationManager.Get(uuid), null);
+	}
+
+	public ClassRepository GetRepository()
+	{
+		return _repository;
+	}
+	
+	public GadgetManager getGadgetManager()
+	{
+		return _gadgetManager;
+	}
+
+	@EventHandler
+	public void SkillDisplay(PlayerCommandPreprocessEvent event)
+	{
+		if (!_enabled)
+			return;
+		
+		if (event.getMessage().length() < 1)
+			return;
+		
+		String[] args = event.getMessage().toLowerCase().split(" ");
+		
+		if (args[0].equals("/skill"))
+		{
+			Player target = event.getPlayer();
+			
+			//Target Other
+			if (args.length > 1 && _clientManager.Get(event.getPlayer()).hasPermission(Perm.VIEW_OTHER_SKILLS))
+			{
+				target = UtilPlayer.searchOnline(event.getPlayer(), args[1], true);
+				
+				if (target == null)
+				{
+					return;
+				}
+			}
+			
+			ClientClass client = Get(target.getUniqueId());
+
+			if (client == null)
+			{
+				event.getPlayer().sendMessage(target.getName() + " does not have a ClientClass.");
+			}
+			else
+			{
+				client.DisplaySkills(event.getPlayer());
+			}
+
+			event.setCancelled(true);
+		}
+	}
+	
+	public void setEnabled(boolean var)
+	{
+		_enabled = var;
+	}
+	
+	public void hideNextEquipMessage(String name)
+	{
+		_messageSuppressed.put(name, new Callback<String>()
+		{
+			public void run(String name)
+			{
+				_messageSuppressed.remove(name);
+			}
+		});
+	}
+	
+	public void forceRemoveFromSuppressed(String name)
+	{
+		_messageSuppressed.remove(name);
+	}
+	
+	public Callback<String> getMessageSuppressedCallback(String name)
+	{
+		return _messageSuppressed.get(name);
+	}
+	
+	public CoreClientManager getClientManager()
+	{
+		return _clientManager;
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Class/ClientClass.java

@@ -0,0 +1,637 @@
+package mineplex.minecraft.game.classcombat.Class;
+
+import java.util.AbstractMap;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map.Entry;
+
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+import mineplex.core.account.CoreClient;
+import mineplex.core.common.util.C;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.NautHashMap;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.donation.Donor;
+import mineplex.core.itemstack.ItemStackFactory;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Class.event.ClassEquipEvent;
+import mineplex.minecraft.game.classcombat.Class.repository.token.ClientClassToken;
+import mineplex.minecraft.game.classcombat.Class.repository.token.CustomBuildToken;
+import mineplex.minecraft.game.classcombat.Class.repository.token.SlotToken;
+import mineplex.minecraft.game.classcombat.Skill.ISkill;
+import mineplex.minecraft.game.classcombat.Skill.ISkill.SkillType;
+import mineplex.minecraft.game.classcombat.Skill.Knight.AxeThrow;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.item.ItemFactory;
+import mineplex.minecraft.game.classcombat.shop.ClassShopManager;
+
+public class ClientClass
+{	
+	private ClassManager _classFactory;
+	private SkillFactory _skillFactory;
+	private ItemFactory _itemFactory;
+	private CoreClient _client;
+	private Donor _donor;
+	
+	private IPvpClass _gameClass;
+	private NautHashMap<SkillType, ISkill> _skillMap = new NautHashMap<SkillType, ISkill>();
+	
+	private IPvpClass _lastClass;
+	private NautHashMap<Integer, ItemStack> _lastItems = new NautHashMap<Integer, ItemStack>();
+	private ItemStack[] _lastArmor = new ItemStack[4];
+	private NautHashMap<SkillType, Entry<ISkill, Integer>> _lastSkillMap = new NautHashMap<SkillType, Entry<ISkill, Integer>>();
+	
+    private NautHashMap<IPvpClass, HashMap<Integer, CustomBuildToken>> _customBuilds;
+    private NautHashMap<IPvpClass, CustomBuildToken> _activeCustomBuilds;
+    
+    private CustomBuildToken _savingCustomBuild;
+    
+    public ClientClass(ClassManager classFactory, SkillFactory skillFactory, ItemFactory itemFactory, CoreClient client, Donor donor, ClientClassToken token)
+    {
+    	_classFactory = classFactory;
+    	_skillFactory = skillFactory;
+    	_itemFactory = itemFactory;
+    	_client = client;
+    	_donor = donor;
+    	
+    	Load(token);
+    }
+    
+    public void Load(ClientClassToken token)
+    {
+        _customBuilds = new NautHashMap<>();
+        _activeCustomBuilds = new NautHashMap<>();
+        
+	    for (IPvpClass pvpClass : _classFactory.GetAllClasses())
+	    {
+	    	_customBuilds.put(pvpClass, new HashMap<>());
+	    	_customBuilds.get(pvpClass).put(0, pvpClass.getDefaultBuild());
+	    }
+	    
+	    if (token == null)
+	    	return;
+	    
+	    for (CustomBuildToken buildToken : token.CustomBuilds)
+	    {
+	    	IPvpClass pvpClass = _classFactory.GetClass(buildToken.PvpClass);
+	    	
+	    	ISkill swordSkill = _skillFactory.GetSkill(buildToken.SwordSkill);
+	    	ISkill axeSkill = _skillFactory.GetSkill(buildToken.AxeSkill);
+	    	ISkill bowSkill = _skillFactory.GetSkill(buildToken.BowSkill);
+	    	ISkill classPassiveASkill = _skillFactory.GetSkill(buildToken.ClassPassiveASkill);
+	    	ISkill classPassiveBSkill = _skillFactory.GetSkill(buildToken.ClassPassiveBSkill);
+	    	ISkill globalPassive = _skillFactory.GetSkill(buildToken.GlobalPassiveSkill);
+	    	
+	    	int skillTokenUsage = 0;
+	    	int itemTokenUsage = 0;
+	    	
+	    	if (!buildToken.SwordSkill.isEmpty())
+	    	{
+	    		if (!ValidSkill(buildToken.SwordSkill, swordSkill, SkillType.Sword))
+	    			continue;
+	    		else
+	    			skillTokenUsage += swordSkill.GetTokenCost() * buildToken.SwordSkillLevel;
+	    	}
+	    	
+	    	if (!buildToken.AxeSkill.isEmpty())
+	    	{
+	    		if (!ValidSkill(buildToken.AxeSkill, axeSkill, SkillType.Axe))
+	    			continue;
+	    		else
+	    			skillTokenUsage += axeSkill.GetTokenCost() * buildToken.AxeSkillLevel;
+	    	}		
+	    	
+	    	if (!buildToken.BowSkill.isEmpty())
+	    	{
+	    		if (!ValidSkill(buildToken.BowSkill, bowSkill, SkillType.Bow))
+	    			continue;
+	    		else
+	    			skillTokenUsage += bowSkill.GetTokenCost() * buildToken.BowSkillLevel;
+	    	}	
+	    	
+	    	if (!buildToken.ClassPassiveASkill.isEmpty())
+	    	{
+	    		if (!ValidSkill(buildToken.ClassPassiveASkill, classPassiveASkill, SkillType.PassiveA))
+	    			continue;
+	    		else
+	    			skillTokenUsage += classPassiveASkill.GetTokenCost() * buildToken.ClassPassiveASkillLevel;
+	    	}	
+	    	
+	    	if (!buildToken.ClassPassiveBSkill.isEmpty())
+	    	{
+	    		if (!ValidSkill(buildToken.ClassPassiveBSkill, classPassiveBSkill, SkillType.PassiveB)) 
+	    			continue;
+	    		else
+	    			skillTokenUsage += classPassiveBSkill.GetTokenCost() * buildToken.ClassPassiveBSkillLevel;
+	    	}		
+	    	
+	    	if (!buildToken.GlobalPassiveSkill.isEmpty())
+	    	{
+	    		if (!ValidSkill(buildToken.GlobalPassiveSkill, globalPassive, SkillType.GlobalPassive))
+	    			continue;
+	    		else
+	    			skillTokenUsage += globalPassive.GetTokenCost() * buildToken.GlobalPassiveSkillLevel;
+	    	}	
+
+	    	for (SlotToken slotToken : buildToken.Slots)
+	    	{
+	    		if (slotToken == null)
+	    			continue;
+
+				if (slotToken.Name == null)
+					continue;
+	    		
+	    		if (slotToken.Material == null)
+	    			continue;
+	    		
+	    		if (slotToken.Material.isEmpty())
+	    			continue;
+	    		
+	    		if (_itemFactory.GetItem("Cobweb".equalsIgnoreCase(slotToken.Name) ? "Web" : slotToken.Name) != null)
+	    		{
+	    			itemTokenUsage += _itemFactory.GetItem("Cobweb".equalsIgnoreCase(slotToken.Name) ? "Web" : slotToken.Name).getTokenCost();
+	    		}
+	    	}
+	    	
+	    	itemTokenUsage += buildToken.ItemTokens;
+	    	skillTokenUsage += buildToken.SkillTokens;
+	    	
+	    	if (itemTokenUsage > CustomBuildToken.MAX_ITEM_TOKENS || skillTokenUsage > CustomBuildToken.MAX_SKILL_TOKENS)
+	    	{
+	    		System.out.println(buildToken.PvpClass + " " + buildToken.CustomBuildId  + "'s item tokens :" + itemTokenUsage + " skill tokens :" + skillTokenUsage);
+	    		continue;
+	    	}
+	    	
+	    	/*
+	    	if (allEmpty)
+	    	{
+	    		buildToken.SkillTokens = CustomBuildToken.MAX_SKILL_TOKENS;
+	    		buildToken.ItemTokens = CustomBuildToken.MAX_ITEM_TOKENS;
+	    		
+		    	if (!buildToken.SwordSkill.isEmpty() && ValidSkill(buildToken.SwordSkill, swordSkill, SkillType.Sword))
+		    		buildToken.SkillTokens -= swordSkill.GetTokenCost();
+		    	
+		    	if (!buildToken.AxeSkill.isEmpty() && ValidSkill(buildToken.AxeSkill, axeSkill, SkillType.Axe))
+		    		buildToken.SkillTokens -= axeSkill.GetTokenCost();
+		    	
+		    	if (!buildToken.BowSkill.isEmpty() && ValidSkill(buildToken.BowSkill, bowSkill, SkillType.Bow))
+		    		buildToken.SkillTokens -= bowSkill.GetTokenCost();
+		    	
+		    	if (!buildToken.ClassPassiveASkill.isEmpty() && ValidSkill(buildToken.ClassPassiveASkill, classPassiveASkill, SkillType.PassiveA))
+		    		buildToken.SkillTokens -= classPassiveASkill.GetTokenCost();
+		    	
+		    	if (!buildToken.ClassPassiveBSkill.isEmpty() && ValidSkill(buildToken.ClassPassiveBSkill, classPassiveBSkill, SkillType.PassiveB)) 
+		    		buildToken.SkillTokens -= classPassiveBSkill.GetTokenCost();
+		    	
+		    	if (!buildToken.GlobalPassiveSkill.isEmpty() && ValidSkill(buildToken.GlobalPassiveSkill, globalPassive, SkillType.GlobalPassive))
+		    		buildToken.SkillTokens -= globalPassive.GetTokenCost();
+	    	}
+	    	*/
+	    	
+	    	if (buildToken.CustomBuildNumber == 0)
+	    	{
+	    		_activeCustomBuilds.put(pvpClass, buildToken);
+	    	}
+	    	else
+	    	{
+	    		_customBuilds.get(pvpClass).put(buildToken.CustomBuildNumber, buildToken);
+	    	}
+	    }
+    }
+    
+	public NautHashMap<Integer, ItemStack> GetDefaultItems()
+	{
+		return _lastItems;
+	}
+
+	public void SetDefaultHead(ItemStack armor)
+	{
+		_lastArmor[3] = armor;
+	}
+
+	public void SetDefaultChest(ItemStack armor)
+	{
+		_lastArmor[2] = armor;
+	}
+
+	public void SetDefaultLegs(ItemStack armor)
+	{
+		_lastArmor[1] = armor;
+	}
+
+	public void SetDefaultFeet(ItemStack armor)
+	{
+		_lastArmor[0] = armor;
+	}
+    
+	public void SaveActiveCustomBuild() 
+	{
+		_savingCustomBuild.PlayerName = _client.getName();
+		
+		_classFactory.GetRepository().SaveCustomBuild(_savingCustomBuild);
+		_savingCustomBuild = null;
+	}
+
+	public void SetSavingCustomBuild(IPvpClass pvpClass, CustomBuildToken customBuild)
+	{
+		_savingCustomBuild = customBuild;
+		_savingCustomBuild.PvpClass = pvpClass.GetName();
+		
+		_customBuilds.get(pvpClass).put(_savingCustomBuild.CustomBuildNumber, _savingCustomBuild);
+	}
+	
+	public void SetActiveCustomBuild(IPvpClass pvpClass, CustomBuildToken customBuild)
+	{
+		customBuild.Active = true;
+		_activeCustomBuilds.put(pvpClass, customBuild);
+	}
+	
+	public CustomBuildToken GetActiveCustomBuild(IPvpClass pvpClass)
+	{
+		return _activeCustomBuilds.get(pvpClass);
+	}
+	
+	public CustomBuildToken GetSavingCustomBuild() 
+	{
+		return _savingCustomBuild;
+	}
+
+	public boolean IsSavingCustomBuild() 
+	{
+		return _savingCustomBuild != null;
+	}
+	
+    public HashMap<Integer, CustomBuildToken> GetCustomBuilds(IPvpClass pvpClass)
+    {
+    	return _customBuilds.get(pvpClass);
+    }
+    
+	public void EquipCustomBuild(CustomBuildToken customBuild) 
+	{
+		EquipCustomBuild(customBuild, true);
+	}
+    
+	public void EquipCustomBuild(CustomBuildToken customBuild, boolean notify) 
+	{
+		EquipCustomBuild(customBuild, true, false);
+	}
+	
+	public void EquipCustomBuild(CustomBuildToken customBuild, boolean notify, boolean skillsOnly) 
+	{
+		_lastClass = _classFactory.GetClass(customBuild.PvpClass);
+
+		if (_lastClass == null)
+			return;
+		
+		_lastSkillMap.remove(SkillType.Class);
+
+		SetDefaultHead(ItemStackFactory.Instance.CreateStack(_lastClass.GetHead()));
+		SetDefaultChest(ItemStackFactory.Instance.CreateStack(_lastClass.GetChestplate()));
+		SetDefaultLegs(ItemStackFactory.Instance.CreateStack(_lastClass.GetLeggings()));
+		SetDefaultFeet(ItemStackFactory.Instance.CreateStack(_lastClass.GetBoots()));
+		
+		if (!customBuild.SwordSkill.isEmpty())
+			_lastSkillMap.put(SkillType.Sword, new AbstractMap.SimpleEntry<ISkill, Integer>(_skillFactory.GetSkill(customBuild.SwordSkill), customBuild.SwordSkillLevel));
+		else
+			_lastSkillMap.remove(SkillType.Sword);
+
+		if (!customBuild.AxeSkill.isEmpty())
+			_lastSkillMap.put(SkillType.Axe, new AbstractMap.SimpleEntry<ISkill, Integer>(_skillFactory.GetSkill(customBuild.AxeSkill), customBuild.AxeSkillLevel));
+		else
+			_lastSkillMap.remove(SkillType.Axe);
+
+		if (!customBuild.BowSkill.isEmpty())
+			_lastSkillMap.put(SkillType.Bow, new AbstractMap.SimpleEntry<ISkill, Integer>(_skillFactory.GetSkill(customBuild.BowSkill), customBuild.BowSkillLevel));
+		else
+			_lastSkillMap.remove(SkillType.Bow);
+
+		if (!customBuild.ClassPassiveASkill.isEmpty())
+			_lastSkillMap.put(SkillType.PassiveA, new AbstractMap.SimpleEntry<ISkill, Integer>(_skillFactory.GetSkill(customBuild.ClassPassiveASkill), customBuild.ClassPassiveASkillLevel));
+		else
+			_lastSkillMap.remove(SkillType.PassiveA);
+
+		if (!customBuild.ClassPassiveBSkill.isEmpty())
+			_lastSkillMap.put(SkillType.PassiveB, new AbstractMap.SimpleEntry<ISkill, Integer>(_skillFactory.GetSkill(customBuild.ClassPassiveBSkill), customBuild.ClassPassiveBSkillLevel));
+		else
+			_lastSkillMap.remove(SkillType.PassiveB);
+
+		if (!customBuild.GlobalPassiveSkill.isEmpty())
+			_lastSkillMap.put(SkillType.GlobalPassive, new AbstractMap.SimpleEntry<ISkill, Integer>(_skillFactory.GetSkill(customBuild.GlobalPassiveSkill), customBuild.GlobalPassiveSkillLevel));
+		else
+			_lastSkillMap.remove(SkillType.GlobalPassive);
+		
+		for (int i = 0; i < 9; i++)
+		{
+			SlotToken token = customBuild.Slots.get(i);
+			
+			if (token == null || token.Material == null || token.Material.isEmpty())
+			{
+				_lastItems.put(i, null);
+				continue;
+			}
+			
+			ItemStack itemStack = ItemStackFactory.Instance.CreateStack(Enum.valueOf(Material.class, token.Material), (byte)0, token.Amount, token.Name);
+			
+			if (token.Name.contains("Booster"))
+				itemStack.addUnsafeEnchantment(Enchantment.DURABILITY, 5);
+			
+			_lastItems.put(i, itemStack);
+		}
+		
+		ResetToDefaults(!skillsOnly, !skillsOnly);
+		
+		// Event
+		ClassEquipEvent event = new ClassEquipEvent(this, customBuild, _client.GetPlayer());
+		UtilServer.getServer().getPluginManager().callEvent(event);
+		
+		if (event.isCancelled())
+		{
+			return;
+		}
+		
+		if (notify)
+		{
+			ListSkills(_client.GetPlayer());
+			_client.GetPlayer().playSound(_client.GetPlayer().getLocation(), Sound.LEVEL_UP, 1f, 1f);
+
+			_client.GetPlayer().sendMessage(F.main("Class", "You equipped " + F.skill(customBuild.Name) + "."));
+		}
+		
+		UtilServer.runSyncLater(() -> validateClassSkills(_client.GetPlayer()), 20L);
+	}
+
+	public void ListSkills(Player caller) 
+	{
+		UtilPlayer.message(caller, F.main("Skill", "Listing Class Skills:"));
+
+		for (SkillType type : SkillType.values())
+			if ((caller != null && caller.isOp()) || type != SkillType.Class)
+				if (_skillMap.containsKey(type))
+					UtilPlayer.message(caller, F.desc(type.toString(), _skillMap.get(type).GetName() + " Lvl" + _skillMap.get(type).getLevel(caller)));
+	}
+	
+	public void ResetSkills(Player player)
+	{
+		for (ISkill skill : GetSkills())
+		{
+			skill.Reset(player);
+		}
+	}
+	
+	public void ResetItems()
+	{
+		_client.GetPlayer().getInventory().clear();
+		
+		for (Entry<Integer, ItemStack> defaultItem : GetDefaultItems().entrySet())
+		{
+			_client.GetPlayer().getInventory().setItem(defaultItem.getKey(), defaultItem.getValue());
+		}
+		
+		for (ISkill skill : _skillMap.values())
+		{
+			if (skill instanceof AxeThrow)
+			{
+				((AxeThrow)skill).Reset(_client.GetPlayer());
+			}
+		}
+	}
+	
+	public void ResetToDefaults(boolean equipItems, boolean equipDefaultArmor)
+	{
+		if (_lastClass == null)
+		{
+			_lastClass = _classFactory.GetClass("Knight");
+			
+			_lastArmor[3] = ItemStackFactory.Instance.CreateStack(_lastClass.GetHead());
+			_lastArmor[2] = ItemStackFactory.Instance.CreateStack(_lastClass.GetChestplate());
+			_lastArmor[1] = ItemStackFactory.Instance.CreateStack(_lastClass.GetLeggings());
+			_lastArmor[0] = ItemStackFactory.Instance.CreateStack(_lastClass.GetBoots());
+			
+			EquipCustomBuild(_customBuilds.get(_lastClass).get(0));
+		}	
+		
+		SetGameClass(_lastClass);
+		
+		if (equipDefaultArmor)
+		{
+			if (_lastArmor[3] != null)
+				_client.GetPlayer().getInventory().setHelmet(_lastArmor[3].clone());
+	
+			if (_lastArmor[2] != null)
+				_client.GetPlayer().getInventory().setChestplate(_lastArmor[2].clone());
+	
+			if (_lastArmor[1] != null)
+				_client.GetPlayer().getInventory().setLeggings(_lastArmor[1].clone());
+	
+			if (_lastArmor[0] != null)
+				_client.GetPlayer().getInventory().setBoots(_lastArmor[0].clone());
+		}
+		
+		if (equipItems)
+		{			
+			ResetItems();
+		}
+
+		ClearSkills();
+		
+		if (_skillFactory.GetSkill(_gameClass.GetName() + " Class") != null)
+		{
+			AddSkill(_skillFactory.GetSkill(_gameClass.GetName() + " Class"), 1);
+		}
+		
+		for (Entry<ISkill, Integer> skill : _lastSkillMap.values())
+		{
+			AddSkill(skill.getKey(), skill.getValue());
+		}
+	}
+    
+	public void ClearSkills()
+	{
+		if (_skillMap != null)
+		{
+			for (ISkill skill : _skillMap.values())
+			{
+				skill.RemoveUser(_client.GetPlayer());
+			}
+		}
+
+		_skillMap.clear();
+	}
+	
+	public void ClearDefaultSkills()
+	{
+		_lastSkillMap = new NautHashMap<SkillType, Entry<ISkill, Integer>>();
+	}
+    
+	public void SetGameClass(IPvpClass gameClass) 
+	{
+		ClearSkills();
+
+		_gameClass = gameClass;
+	}
+    
+	public IPvpClass GetGameClass() 
+	{
+		return _gameClass;
+	}
+
+	public boolean IsGameClass(ClassType... types)
+	{
+		if (GetGameClass() == null)
+			return false;
+
+		for (ClassType type : types)
+		{
+			if (type == GetGameClass().GetType())
+			{
+				return true;
+			}
+		}
+
+		return false;
+	}
+	
+	public Collection<ISkill> GetSkills() 
+	{
+		if (_skillMap == null)
+			_skillMap = new NautHashMap<SkillType, ISkill>();
+
+		return _skillMap.values();
+	}
+	
+	public Collection<Entry<ISkill, Integer>> GetDefaultSkills() 
+	{
+		return _lastSkillMap.values();
+	}
+
+	public ISkill GetSkillByType(SkillType skillType)
+	{
+		if (_skillMap == null)
+			_skillMap = new NautHashMap<SkillType, ISkill>();
+
+		if (_skillMap.containsKey(skillType))
+			return _skillMap.get(skillType);
+
+		return null;
+	}
+	
+	public void AddSkill(ISkill skill, int level) 
+	{
+		if (skill == null)
+			return;
+		
+		if (_skillMap == null)
+			_skillMap = new NautHashMap<SkillType, ISkill>();
+
+		if (_skillMap.get(skill.GetSkillType()) != null)
+			_skillMap.get(skill.GetSkillType()).RemoveUser(_client.GetPlayer());
+
+		_skillMap.put(skill.GetSkillType(), skill);
+		_lastSkillMap.put(skill.GetSkillType(), new AbstractMap.SimpleEntry<ISkill, Integer>(skill, level));
+		
+		skill.AddUser(_client.GetPlayer(), level);
+		
+		if (IsSavingCustomBuild())
+			_savingCustomBuild.setSkill(skill, level);
+	}
+
+	public void RemoveSkill(ISkill skill) 
+	{
+		if (skill == null)
+			return;
+		
+		if (_skillMap == null)
+			return;
+
+		_skillMap.remove(skill.GetSkillType());
+		_lastSkillMap.remove(skill.GetSkillType());
+		
+		if (IsSavingCustomBuild())
+			_savingCustomBuild.removeSkill(skill);
+
+		skill.RemoveUser(_client.GetPlayer());
+	}
+
+	public ItemStack[] GetDefaultArmor()
+	{
+		return _lastArmor;
+	}
+
+	public void ClearDefaults()
+	{
+		_lastItems.clear();
+		_lastArmor = new ItemStack[4];
+		_lastSkillMap.clear();
+	}
+	
+	private boolean ValidSkill(String skillName, ISkill skill, SkillType expectedType)
+	{
+		try
+		{
+			if (skillName == null || skill == null || expectedType == null)
+			{
+				return false;
+			}
+			
+			if (!skillName.isEmpty() && (skill.GetSkillType() != expectedType || !skill.IsFree() && !_donor.ownsUnknownSalesPackage("Champions " + skillName) && !_client.hasPermission(ClassShopManager.Perm.SKILL_UNLOCK_LEGACY) && !_donor.ownsUnknownSalesPackage("Competitive ULTRA")))
+			{
+				return false;
+			}
+		}
+		catch (NullPointerException ex) 
+		{
+			System.out.println("Somehow a Nullpointer happens here if someone uses /disguise.\n" + 
+					"shouldnt be a problem because Youtube+ can have all skills.");
+		}
+    	return true;
+	}
+
+	public void DisplaySkills(Player player)
+	{
+		String bar = "------------------------------------------";
+		player.sendMessage(bar);
+		for (SkillType type : _lastSkillMap.keySet())
+		{
+			if (_lastSkillMap.get(type).getKey() == null)
+				continue;
+			player.sendMessage(C.cGreen + type + ": " + C.cWhite + _lastSkillMap.get(type).getKey().GetName() + " " + _lastSkillMap.get(type).getValue());
+		}
+		player.sendMessage(bar);
+	}
+	
+	//This is used to fix a dual class bug using Twitch broadcasting GUI (F6)
+	public void validateClassSkills(Player player)
+	{
+		if (_gameClass == null || _skillMap == null)
+			return;
+		
+		for (SkillType type : SkillType.values())
+		{
+			if (type == SkillType.GlobalPassive)
+			{
+				continue;
+			}
+			
+			if (!_skillMap.containsKey(type))
+			{
+				continue;
+			}
+			
+			ISkill skill = _skillMap.get(type);
+			
+			if (skill.GetClassType() != _gameClass.GetType())
+			{
+				skill.Reset(player);
+				RemoveSkill(skill);
+								
+				System.out.println("[" + player.getName() + " / " + _gameClass.GetType() + "] Removed Invalid " + skill.GetClassType() + " Skill (" + skill.GetName() + ")");
+			}
+		}
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Class/IClassFactory.java

@@ -0,0 +1,8 @@
+package mineplex.minecraft.game.classcombat.Class;
+
+import java.util.Collection;
+
+public interface IClassFactory
+{
+	Collection<IPvpClass> GetGameClasses();
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Class/IPvpClass.java

@@ -0,0 +1,39 @@
+package mineplex.minecraft.game.classcombat.Class;
+
+import java.util.HashSet;
+
+import mineplex.minecraft.game.classcombat.Class.repository.token.CustomBuildToken;
+import mineplex.minecraft.game.classcombat.Skill.ISkill;
+
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+
+public interface IPvpClass
+{
+	public enum ClassType
+	{
+		Global,
+		Knight,
+		Ranger,
+		Assassin,
+		Mage,
+		Brute,
+		Shifter
+	}
+	
+	int GetSalesPackageId();
+    String GetName();
+    ClassType GetType();
+    Material GetHead();
+    Material GetChestplate();
+    Material GetLeggings();
+    Material GetBoots();
+    HashSet<ISkill> GetSkills();
+    
+    void checkEquip();
+	Integer GetCost();
+	boolean IsFree();
+	String[] GetDesc();
+	void ApplyArmor(Player caller);
+	CustomBuildToken getDefaultBuild();
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Class/PvpClass.java

@@ -0,0 +1,303 @@
+package mineplex.minecraft.game.classcombat.Class;
+
+import java.util.HashSet;
+
+import mineplex.core.common.util.Callback;
+import mineplex.core.common.util.UtilGear;
+import mineplex.core.gadget.types.GadgetType;
+import mineplex.core.itemstack.ItemStackFactory;
+import mineplex.minecraft.game.classcombat.Class.repository.token.CustomBuildToken;
+import mineplex.minecraft.game.classcombat.Skill.ISkill;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Color;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+import org.bukkit.inventory.meta.LeatherArmorMeta;
+
+public class PvpClass implements IPvpClass
+{
+	private ClassType _type;
+	private CustomBuildToken _customBuild;
+	private int _salesPackageId;
+	private String[] _desc;
+	private int _cost;
+	private boolean _free;
+	
+	private Material _head;
+	private Material _chest;
+	private Material _legs;
+	private Material _boots;
+	
+	private Color _leatherColor = null;
+
+	private HashSet<ISkill> _skillSet;
+	
+	private ClassManager _classes;
+	
+	public PvpClass(ClassManager classes, int salesPackageId, ClassType type, CustomBuildToken customBuild, String[] desc, Material head, Material chest, Material legs, Material boots, Color leatherColor)
+	{
+		_classes = classes;
+		_salesPackageId = salesPackageId;
+		_cost = 5000;
+		_desc = desc;
+		
+		_type = type;
+		
+		_customBuild = customBuild;
+		_customBuild.PvpClass = type.name();
+
+		_head = head;
+		_chest = chest;
+		_legs = legs;
+		_boots = boots;
+
+		_skillSet = new HashSet<ISkill>();
+		_skillSet.addAll(_classes.GetSkillFactory().GetSkillsFor(this));
+		_skillSet.addAll(_classes.GetSkillFactory().GetGlobalSkillsFor(this));
+		
+		_leatherColor = leatherColor;
+	}
+
+	@Override
+	public String GetName() 
+	{
+		return _type.name();
+	}
+
+	@Override
+	public ClassType GetType()
+	{
+		return _type;
+	}
+
+	@Override
+	public Material GetHead() 
+	{
+		return _head;
+	}
+
+	@Override
+	public Material GetChestplate() 
+	{
+		return _chest;
+	}
+
+	@Override
+	public Material GetLeggings() 
+	{
+		return _legs;
+	}
+
+	@Override
+	public Material GetBoots() 
+	{
+		return _boots;
+	}
+
+	@Override
+	public HashSet<ISkill> GetSkills() 
+	{
+		return _skillSet;
+	}
+	
+	public void checkEquip()
+	{
+		for (Player cur : Bukkit.getOnlinePlayers())
+		{
+			ClientClass client = _classes.Get(cur);
+			
+			//Check Unequip
+			if (client.GetGameClass() != null)
+				if (client.GetGameClass().GetType() == _type)
+				{
+					PlayerInventory inv = cur.getInventory();
+		
+					//Helm
+					if (_head != null)
+						if (!UtilGear.isMat(inv.getHelmet(), _head))
+						{
+							Unequip(cur);
+							continue;
+						}
+		
+					//Chest
+					if (_chest != null)
+						if (!UtilGear.isMat(inv.getChestplate(), _chest))
+						{
+							Unequip(cur);
+							continue;
+						}
+		
+					//Legs
+					if (_legs != null)
+						if (!UtilGear.isMat(inv.getLeggings(), _legs))
+						{
+							Unequip(cur);
+							continue;
+						}
+		
+					//Boots
+					if (_boots != null)
+						if (!UtilGear.isMat(inv.getBoots(), _boots))
+						{
+							Unequip(cur);
+							continue;
+						}
+					
+					if (_leatherColor != null)
+					{
+						if (!((LeatherArmorMeta)inv.getHelmet().getItemMeta()).getColor().equals(_leatherColor) ||
+							!((LeatherArmorMeta)inv.getChestplate().getItemMeta()).getColor().equals(_leatherColor)|| 
+							!((LeatherArmorMeta)inv.getLeggings().getItemMeta()).getColor().equals(_leatherColor) ||
+							!((LeatherArmorMeta)inv.getBoots().getItemMeta()).getColor().equals(_leatherColor))
+						{
+							Unequip(cur);
+							continue;
+						}
+					}
+				}
+
+			//Check Equip
+			if (client.GetGameClass() == null || client.GetGameClass().GetType() == null || 
+					(_leatherColor != null && client.GetGameClass().GetType() != this.GetType()))
+			{
+				PlayerInventory inv = cur.getInventory();
+
+				//Helm
+				if (_head != null)
+					if (!UtilGear.isMat(inv.getHelmet(), _head))
+						continue;
+
+				//Chest
+				if (_chest != null)
+					if (!UtilGear.isMat(inv.getChestplate(), _chest))
+						continue;
+
+				//Legs
+				if (_legs != null)
+					if (!UtilGear.isMat(inv.getLeggings(), _legs))
+						continue;
+
+				//Boots
+				if (_boots != null)
+					if (!UtilGear.isMat(inv.getBoots(), _boots))
+						continue;
+
+				if (_leatherColor != null)
+				{
+					if (!((LeatherArmorMeta)inv.getHelmet().getItemMeta()).getColor().equals(_leatherColor) ||
+						!((LeatherArmorMeta)inv.getChestplate().getItemMeta()).getColor().equals(_leatherColor)|| 
+						!((LeatherArmorMeta)inv.getLeggings().getItemMeta()).getColor().equals(_leatherColor) ||
+						!((LeatherArmorMeta)inv.getBoots().getItemMeta()).getColor().equals(_leatherColor))
+						continue;
+				}
+				
+				if (_classes.getGadgetManager() != null && _classes.getGadgetManager().getActive(cur, GadgetType.COSTUME) != null)
+					continue;
+			
+				Equip(cur, _classes.getMessageSuppressedCallback(cur.getName()) == null);
+				Callback<String> callback = _classes.getMessageSuppressedCallback(cur.getName());
+				if (callback != null) callback.run(cur.getName());
+			}
+		}
+	}
+
+	public void Equip(Player player, boolean inform)
+	{		
+		ClientClass client = _classes.Get(player);
+		
+		CustomBuildToken customBuild = client.GetActiveCustomBuild(this);
+		
+		if (customBuild != null)
+		{
+			client.EquipCustomBuild(customBuild, inform, true);
+		}
+		else
+		{
+			client.SetGameClass(this);
+			client.EquipCustomBuild(client.GetCustomBuilds(this).get(0), inform, true);
+		}
+		
+		//Ensure Sneak Removed
+		player.setSneaking(false);
+	}
+
+	public void Unequip(Player player)
+	{
+		_classes.Get(player).SetGameClass(null);
+
+		// UtilPlayer.message(player, F.main("Class", "Armor Class: " + F.oo("None", false)));
+	}
+
+    @Override
+    public int GetSalesPackageId()
+    {
+        return _salesPackageId;
+    }
+
+	@Override
+	public Integer GetCost() 
+	{
+		return _cost;
+	}
+
+	@Override
+	public String[] GetDesc()
+	{
+		return _desc;
+	}
+	
+	@Override
+	public boolean IsFree()
+	{
+		return _free;
+	}
+
+	@Override
+	public void ApplyArmor(Player caller) 
+	{
+		ItemStack head = ItemStackFactory.Instance.CreateStack(GetHead(), 1);
+		ItemStack chest = ItemStackFactory.Instance.CreateStack(GetChestplate(), 1);
+		ItemStack legs = ItemStackFactory.Instance.CreateStack(GetLeggings(), 1);
+		ItemStack boots = ItemStackFactory.Instance.CreateStack(GetBoots(), 1);
+		
+		if (_leatherColor != null)
+		{ 
+			LeatherArmorMeta meta;
+			
+			//Head
+			meta = (LeatherArmorMeta)head.getItemMeta();
+			meta.setColor(_leatherColor);
+			head.setItemMeta(meta);
+			
+			//Chest
+			meta = (LeatherArmorMeta)chest.getItemMeta();
+			meta.setColor(_leatherColor);
+			chest.setItemMeta(meta);
+			
+			//Legs
+			meta = (LeatherArmorMeta)legs.getItemMeta();
+			meta.setColor(_leatherColor);
+			legs.setItemMeta(meta);
+			
+			//Boots
+			meta = (LeatherArmorMeta)boots.getItemMeta();
+			meta.setColor(_leatherColor);
+			boots.setItemMeta(meta);
+		}
+		
+		caller.getInventory().setHelmet(head);
+		caller.getInventory().setChestplate(chest);
+		caller.getInventory().setLeggings(legs);
+		caller.getInventory().setBoots(boots);
+	}
+
+	@Override
+	public CustomBuildToken getDefaultBuild()
+	{
+		return _customBuild;
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Class/event/ClassEquipEvent.java

@@ -0,0 +1,62 @@
+package mineplex.minecraft.game.classcombat.Class.event;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+import mineplex.minecraft.game.classcombat.Class.ClientClass;
+import mineplex.minecraft.game.classcombat.Class.repository.token.CustomBuildToken;
+
+public class ClassEquipEvent extends Event
+{
+	private static final HandlerList handlers = new HandlerList();
+	
+	private ClientClass _client;
+	private Player _user;
+	private CustomBuildToken _build;
+	
+	private boolean _cancelled;
+	
+	public ClassEquipEvent(ClientClass client, CustomBuildToken build, Player user)
+	{
+		_client = client;
+		_build = build;
+		_user = user;
+	}
+	
+	public ClientClass getPlayer()
+	{
+		return _client;
+	}
+	
+	public CustomBuildToken getBuild()
+	{
+		return _build;
+	}
+	
+	public Player getUser()
+	{
+		return _user;
+	}
+	
+	public void setCancelled(boolean cancelled)
+	{
+		_cancelled = cancelled;
+	}
+	
+	public boolean isCancelled()
+	{
+		return _cancelled;
+	}
+	
+	public HandlerList getHandlers()
+	{
+		return handlers;
+	}
+	
+	public static HandlerList getHandlerList()
+	{
+		return handlers;
+	}
+	
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Class/event/ClassSetupEvent.java

@@ -0,0 +1,94 @@
+package mineplex.minecraft.game.classcombat.Class.event;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Class.repository.token.CustomBuildToken;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public class ClassSetupEvent extends Event 
+{
+	public enum SetupType
+	{
+		OpenMain,
+		
+		ApplyDefaultBuilt,
+		
+		OpenCustomBuilds,
+		
+		ApplyCustomBuild,
+		SaveEditCustomBuild,
+		EditCustomBuild,
+		DeleteCustomBuild,
+		
+		Close
+	}
+	
+    private static final HandlerList handlers = new HandlerList();
+    
+    private Player _player;
+    private SetupType _actionType;
+    private ClassType _classType;
+    private int _position = 0; //0 = Null, 1-5 = Slot
+    private CustomBuildToken _classBuild;
+    
+    private boolean _cancelled = false;
+
+    public ClassSetupEvent(Player player, SetupType type, ClassType classType, int position, CustomBuildToken build) 
+    {
+    	_player = player;
+    	
+    	_actionType = type;
+    	_classType = classType;
+    	
+    	_position = position;
+    	
+    	_classBuild = build;
+    }
+  
+    public HandlerList getHandlers() 
+    {
+        return handlers;
+    }
+ 
+    public static HandlerList getHandlerList() 
+    {
+        return handlers;
+    }
+
+	public SetupType GetType() 
+	{
+		return _actionType;
+	}
+
+	public int GetPosition() 
+	{
+		return _position;
+	}
+	
+	public Player GetPlayer()
+	{
+		return _player;
+	}
+
+	public ClassType GetClassType() 
+	{
+		return _classType;
+	}
+	
+	public CustomBuildToken GetBuild()
+	{
+		return _classBuild;
+	}
+	
+	public void SetCancelled(boolean cancel)
+	{
+		_cancelled = cancel;
+	}
+	
+	public boolean IsCancelled()
+	{
+		return _cancelled;
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Class/repository/ClassRepository.java

@@ -0,0 +1,18 @@
+package mineplex.minecraft.game.classcombat.Class.repository;
+
+import mineplex.core.database.MinecraftRepository;
+import mineplex.minecraft.game.classcombat.Class.repository.token.CustomBuildToken;
+import mineplex.serverdata.database.DBPool;
+
+public class ClassRepository extends MinecraftRepository
+{
+	public ClassRepository()
+	{
+		super(DBPool.getAccount());
+	}
+
+	public void SaveCustomBuild(CustomBuildToken token)
+	{
+		handleAsyncMSSQLCall("PlayerAccount/SaveCustomBuild", token);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Class/repository/token/ClassToken.java

@@ -0,0 +1,12 @@
+package mineplex.minecraft.game.classcombat.Class.repository.token;
+
+import mineplex.core.donation.repository.GameSalesPackageToken;
+
+public class ClassToken 
+{
+    public int PvpClassId;
+
+    public String Name;
+
+    public GameSalesPackageToken SalesPackage;
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Class/repository/token/ClientClassToken.java

@@ -0,0 +1,8 @@
+package mineplex.minecraft.game.classcombat.Class.repository.token;
+
+import java.util.List;
+
+public class ClientClassToken
+{
+    public List<CustomBuildToken> CustomBuilds;
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Class/repository/token/ClientClassTokenWrapper.java

@@ -0,0 +1,7 @@
+package mineplex.minecraft.game.classcombat.Class.repository.token;
+
+public class ClientClassTokenWrapper
+{
+	public String Name;
+	public ClientClassToken DonorToken;
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Class/repository/token/CustomBuildToken.java

@@ -0,0 +1,359 @@
+package mineplex.minecraft.game.classcombat.Class.repository.token;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.bukkit.Material;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.ISkill;
+import mineplex.minecraft.game.classcombat.item.Item;
+
+public class CustomBuildToken
+{
+	public static final int MAX_SKILL_TOKENS = 12;
+	public static final int MAX_ITEM_TOKENS = 12;
+	
+	public int CustomBuildId;
+
+	public String PlayerName;
+	public String Name;
+	public boolean Active;
+
+	public Integer CustomBuildNumber = 0;
+
+	public String PvpClass = "";
+
+	public String SwordSkill = "";
+	public Integer SwordSkillLevel = 0;
+
+	public String AxeSkill = "";
+	public Integer AxeSkillLevel = 0;
+
+	public String BowSkill = "";
+	public Integer BowSkillLevel = 0;
+
+	public String ClassPassiveASkill = "";
+	public Integer ClassPassiveASkillLevel = 0;
+
+	public String ClassPassiveBSkill = "";
+	public Integer ClassPassiveBSkillLevel = 0;
+
+	public String GlobalPassiveSkill = "";
+	public Integer GlobalPassiveSkillLevel = 0;
+
+	public final List<SlotToken> Slots = new ArrayList<>(9);
+
+	public int SkillTokens = MAX_SKILL_TOKENS;
+	public int ItemTokens = 1;
+	
+	public CustomBuildToken() { }
+	
+	public CustomBuildToken(ClassType gameClassType)
+	{
+		PvpClass = gameClassType.name();
+		
+		for (int i = 0; i < 9; i++)
+		{
+			Slots.add(new SlotToken());
+		}
+		
+		Slots.set(0, new SlotToken("Standard Sword", Material.IRON_SWORD, 1));
+		Slots.set(1, new SlotToken("Standard Axe", Material.IRON_AXE, 1));
+		
+		for (int i = 2; i < 9; i++)
+		{
+			Slots.set(i, new SlotToken("Mushroom Soup", Material.MUSHROOM_SOUP, 1));
+		}
+		
+		if (gameClassType == ClassType.Assassin || gameClassType == ClassType.Ranger)
+		{
+			Slots.set(2, new SlotToken("Standard Bow", Material.BOW, 1));
+			Slots.set(3, new SlotToken(gameClassType.name() + " Arrows", Material.ARROW, gameClassType == ClassType.Assassin ? 12 : 24));
+			ItemTokens = 1;
+		}
+		else
+		{
+			if (gameClassType != ClassType.Mage)
+			{
+				Slots.set(7, new SlotToken("Water Bottle", Material.POTION, 1));
+			}
+			else
+			{
+				Slots.set(7, new SlotToken("Web", Material.WEB, 3));
+			}
+			
+			Slots.set(8, new SlotToken());
+			ItemTokens = 0;
+		}
+	}
+	
+	public void printInfo()
+	{
+		System.out.println("CustomBuildId : " + CustomBuildId);
+		System.out.println("PlayerName : " + PlayerName);
+		System.out.println("Name : " + Name);
+		System.out.println("Active : " + Active);
+
+		System.out.println("CustomBuildNumber : " + CustomBuildNumber);
+
+		System.out.println("PvpClass : " + PvpClass);
+
+		System.out.println("SwordSkill : " + SwordSkill);
+		System.out.println("SwordLevel : " + SwordSkillLevel);
+
+		System.out.println("AxeSkill : " + AxeSkill);
+		System.out.println("AxeLevel : " + AxeSkillLevel);
+
+		System.out.println("BowSkill : " + BowSkill);
+		System.out.println("BowLevel : " + BowSkillLevel);
+
+		System.out.println("ClassPassiveASkill : " + ClassPassiveASkill);
+		System.out.println("ClassPassiveALevel : " + ClassPassiveASkillLevel);
+
+		System.out.println("ClassPassiveBSkill : " + ClassPassiveBSkill);
+		System.out.println("ClassPassiveBLevel : " + ClassPassiveBSkillLevel);
+
+		System.out.println("GlobalPassiveSkill : " + GlobalPassiveSkill);
+		System.out.println("GlobalPassiveLevel : " + GlobalPassiveSkillLevel);
+
+		for (SlotToken token : Slots)
+		{
+			token.printInfo();
+		}
+	}
+
+	public void setSkill(ISkill skill, int level)
+	{
+		switch (skill.GetSkillType())
+		{
+			case Axe:
+				AxeSkill = skill.GetName();
+				AxeSkillLevel = level;
+				break;
+			case Bow:
+				BowSkill = skill.GetName();
+				BowSkillLevel = level;
+				break;
+			case Class:
+				break;
+			case GlobalPassive:
+				GlobalPassiveSkill = skill.GetName();
+				GlobalPassiveSkillLevel = level;
+				break;
+			case PassiveA:
+				ClassPassiveASkill = skill.GetName();
+				ClassPassiveASkillLevel = level;
+				break;
+			case PassiveB:
+				ClassPassiveBSkill = skill.GetName();
+				ClassPassiveBSkillLevel = level;
+				break;
+			case Sword:
+				SwordSkill = skill.GetName();
+				SwordSkillLevel = level;
+				break;
+			default:
+				break;
+		}
+		
+		SkillTokens -= skill.GetTokenCost() * level;
+	}
+	
+	public void removeSkill(ISkill skill)
+	{
+		int level = 0;
+		
+		switch (skill.GetSkillType())
+		{
+			case Axe:
+				AxeSkill = "";
+				level = AxeSkillLevel;
+				AxeSkillLevel = 0;
+				break;
+			case Bow:
+				BowSkill = "";
+				level = BowSkillLevel;
+				BowSkillLevel = 0;
+				break;
+			case Class:
+				break;
+			case GlobalPassive:
+				GlobalPassiveSkill = "";
+				level = GlobalPassiveSkillLevel;
+				GlobalPassiveSkillLevel = 0;
+				break;
+			case PassiveA:
+				ClassPassiveASkill = "";
+				level = ClassPassiveASkillLevel;
+				ClassPassiveASkillLevel = 0;
+				break;
+			case PassiveB:
+				ClassPassiveBSkill = "";
+				level = ClassPassiveBSkillLevel;
+				ClassPassiveBSkillLevel = 0;
+				break;
+			case Sword:
+				SwordSkill = "";
+				level = SwordSkillLevel;
+				SwordSkillLevel = 0;
+				break;
+			default:
+				break;
+		}
+		
+		SkillTokens += skill.GetTokenCost() * level;
+	}
+
+	public boolean hasSkill(ISkill skill)
+	{
+		return SwordSkill.equalsIgnoreCase(skill.GetName()) 
+				|| AxeSkill.equalsIgnoreCase(skill.GetName()) 
+				|| BowSkill.equalsIgnoreCase(skill.GetName())
+				|| ClassPassiveASkill.equalsIgnoreCase(skill.GetName())
+				|| ClassPassiveBSkill.equalsIgnoreCase(skill.GetName())
+				|| GlobalPassiveSkill.equalsIgnoreCase(skill.GetName());
+	}
+
+	public int getLevel(ISkill skill)
+	{
+		switch (skill.GetSkillType())
+		{
+			case Axe:
+				return AxeSkillLevel;
+			case Bow:
+				return BowSkillLevel;
+			case GlobalPassive:
+				return GlobalPassiveSkillLevel;
+			case PassiveA:
+				return ClassPassiveASkillLevel;
+			case PassiveB:
+				return ClassPassiveBSkillLevel;
+			case Sword:
+				return SwordSkillLevel;
+			default:
+				return 0;
+		}
+	}
+
+	public boolean hasItem(Material material, String name)
+	{
+		for (SlotToken token : Slots)
+		{
+			// Stupid json crap giving me null values.
+			if (token == null)
+				continue;
+			
+			if (token.Material == null)
+				continue;
+			
+			if (token.Name == null)
+				continue;
+			
+			if (token.Material.equalsIgnoreCase(material.name()) && token.Name.equalsIgnoreCase(name))
+				return true;
+		}
+		
+		return false;
+	}
+	
+	public boolean hasItemType(Material material)
+	{
+		for (SlotToken token : Slots)
+		{
+			// Stupid json crap giving me null values.
+			if (token == null)
+				continue;
+			
+			if (token.Material == null)
+				continue;
+			
+			if (token.Material.equalsIgnoreCase(material.name()))
+				return true;
+		}
+		
+		return false;
+	}
+	
+	public boolean hasItemWithNameLike(String name)
+	{
+		for (SlotToken token : Slots)
+		{
+			// Stupid json crap giving me null values.
+			if (token == null)
+				continue;
+			
+			token.printInfo();
+			
+			if (token.Name == null)
+				continue;
+			
+			if (token.Name.contains(name))
+			{ 
+				return true;
+			}
+		}
+		
+		return false;
+	}
+	
+	public int getLastItemIndexWithNameLike(String name)
+	{
+		for (int i = Slots.size() - 1; i >= 0; i--)
+		{
+			SlotToken token = Slots.get(i);
+			
+			// Stupid json crap giving me null values.
+			if (token == null)
+				continue;
+			
+			if (token.Name == null)
+				continue;
+			
+			if (token.Name.contains(name))
+				return Slots.indexOf(token);
+		}
+		
+		return -1;
+	}
+	
+	public int getItemIndexWithNameLike(String name)
+	{
+		for (SlotToken token : Slots)
+		{
+			// Stupid json crap giving me null values.
+			if (token == null)
+				continue;
+			
+			if (token.Name == null)
+				continue;
+			
+			if (token.Name.contains(name))
+				return Slots.indexOf(token);
+		}
+		
+		return -1;
+	}
+
+	public void addItem(Item item, int index)
+	{		
+		SlotToken token = Slots.get(index);
+
+		token.Material = item.GetType().name();
+		token.Amount = item.GetAmount();
+		token.Name = item.GetName();
+
+		ItemTokens -= item.getTokenCost();
+	}
+	
+	public void removeItem(Item item, int index)
+	{
+		SlotToken token = Slots.get(index);
+
+		token.Material = null;
+		token.Amount = 0;
+		token.Name = null;
+		
+		ItemTokens += item.getTokenCost();
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Class/repository/token/SlotToken.java

@@ -0,0 +1,26 @@
+package mineplex.minecraft.game.classcombat.Class.repository.token;
+
+import org.bukkit.Material;
+
+public class SlotToken 
+{
+	public String Name = "";
+	public String Material = "";
+	public int Amount = 0;
+	
+	public SlotToken() { }
+	
+	public SlotToken(String name, Material material, int amount)
+	{
+		Name = name;
+		Material = material.name();
+		Amount = amount;
+	}
+
+	public void printInfo()
+	{
+		System.out.println("Name : " + Name);
+		System.out.println("Material : " + Material);
+		System.out.println("Amount : " + Amount);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Condition/SkillConditionEffect.java

@@ -0,0 +1,32 @@
+package mineplex.minecraft.game.classcombat.Condition;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.minecraft.game.core.condition.ConditionEffect;
+import mineplex.minecraft.game.core.condition.ConditionManager;
+import mineplex.minecraft.game.classcombat.Skill.event.SkillTriggerEvent;
+
+public class SkillConditionEffect extends ConditionEffect
+{
+	public SkillConditionEffect(ConditionManager manager)
+	{
+		super(manager);
+	}
+
+	@EventHandler(priority = EventPriority.LOW)
+	public void Silence(SkillTriggerEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+
+		if (!Manager.IsSilenced(event.GetPlayer(), event.GetSkillName()))
+			return;
+
+		//Set Damage
+		event.SetCancelled(true);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Condition/SkillConditionManager.java

@@ -0,0 +1,22 @@
+package mineplex.minecraft.game.classcombat.Condition;
+
+import org.bukkit.plugin.java.JavaPlugin;
+
+import mineplex.minecraft.game.core.condition.ConditionEffect;
+import mineplex.minecraft.game.core.condition.ConditionManager;
+
+public class SkillConditionManager extends ConditionManager
+{
+	public SkillConditionManager(JavaPlugin plugin)
+	{
+		super(plugin);
+	}
+	
+	public ConditionEffect Effect()
+	{
+		if (Effect == null)
+			Effect = new SkillConditionEffect(this);		
+
+		return Effect;
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Assassin/Assassin.java

@@ -0,0 +1,121 @@
+package mineplex.minecraft.game.classcombat.Skill.Assassin;
+
+import org.bukkit.entity.Arrow;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.inventory.PlayerInventory;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.core.energy.event.EnergyEvent;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.core.updater.UpdateType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class Assassin extends Skill
+{
+	public Assassin(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Permanent Speed II.",
+				"Fall damage reduced by 1.5.",
+				"Arrows deal 37.5% less damage."
+				});
+	}
+
+	@EventHandler
+	public void Update(UpdateEvent event)
+	{
+		if (event.getType() == UpdateType.FAST)
+			for (Player cur : GetUsers())
+				Factory.Condition().Factory().Speed(GetName(), cur, cur, 1.9, 1, false, false, false);
+		
+		if (event.getType() == UpdateType.SLOWER)
+			for (Player cur : GetUsers())
+			{
+				PlayerInventory inv = cur.getInventory();
+				
+				if (inv.getHelmet() != null && inv.getHelmet().getDurability() > 0)
+					inv.getHelmet().setDurability((short) (inv.getHelmet().getDurability()-1));
+				
+				if (inv.getChestplate() != null && inv.getChestplate().getDurability() > 0)
+					inv.getChestplate().setDurability((short) (inv.getChestplate().getDurability()-1));
+				
+				if (inv.getLeggings() != null && inv.getLeggings().getDurability() > 0)
+					inv.getLeggings().setDurability((short) (inv.getLeggings().getDurability()-1));
+				
+				if (inv.getBoots() != null && inv.getBoots().getDurability() > 0)
+					inv.getBoots().setDurability((short) (inv.getBoots().getDurability()-1));
+			}
+	}
+	
+	@EventHandler(priority = EventPriority.HIGH)
+	public void AttackDamage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+
+		if (event.GetCause() != DamageCause.ENTITY_ATTACK)
+			return;
+
+		Player damager = event.GetDamagerPlayer(false);
+		if (damager == null)	return;
+
+		int level = getLevel(damager);
+		if (level == 0)		return;
+
+		event.SetKnockback(false);
+		event.AddMod(damager.getName(), GetName(), 0, false);
+	}
+	
+	@EventHandler(priority = EventPriority.HIGH)
+	public void FallDamage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+		{
+			return;
+		}
+
+		Player player = event.GetDamageePlayer();
+
+		if (player == null)
+		{
+			return;
+		}
+
+		int level = getLevel(player);
+
+		if (level == 0)
+		{
+			return;
+		}
+
+		if (event.GetCause() == DamageCause.FALL)
+		{
+			event.AddMod(null, GetName(), -1.5, false);
+		}
+		else if (event.GetCause() == DamageCause.PROJECTILE && event.GetProjectile() instanceof Arrow)
+		{
+			event.AddMod(null, GetName(), -event.GetDamage() * 0.375, false);
+		}
+	}
+	
+	@EventHandler
+	public void CancelEnergy(EnergyEvent event)
+	{
+		if (getLevel(event.GetPlayer()) > 0)
+			event.setCancelled(true);
+	}
+	
+	@Override
+	public void Reset(Player player) 
+	{
+
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Assassin/BackStab.java

@@ -0,0 +1,74 @@
+package mineplex.minecraft.game.classcombat.Skill.Assassin;
+
+import org.bukkit.Effect;
+import org.bukkit.Sound;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.util.Vector;
+
+import mineplex.core.recharge.Recharge;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class BackStab extends Skill
+{
+	public BackStab(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Attacks from behind opponents",
+				"deal #1.5#1.5 additional damage.",
+				});
+	}
+	
+	@EventHandler(priority = EventPriority.HIGH)
+	public void Damage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+		
+		if (event.GetCause() != DamageCause.ENTITY_ATTACK)
+			return;
+
+		Player damager = event.GetDamagerPlayer(false);
+		if (damager == null)	return;
+
+		int level = getLevel(damager);
+		if (level == 0)		return;
+
+		LivingEntity damagee = event.GetDamageeEntity();
+		if (damagee == null)	return;
+
+		Vector look = damagee.getLocation().getDirection();
+		look.setY(0);
+		look.normalize();
+
+		Vector from = damager.getLocation().toVector().subtract(damagee.getLocation().toVector());
+		from.setY(0);
+		from.normalize();
+
+		Vector check = new Vector(look.getX() * -1, 0, look.getZ() * -1);
+		if (check.subtract(from).length() < 0.8)
+		{
+			//Damage
+			event.AddMod(damager.getName(), GetName(), 1.5 + 1.5 * level, true);
+			
+			//Effect
+			damagee.getWorld().playSound(damagee.getLocation(), Sound.HURT_FLESH, 1f, 2f);	
+			damagee.getWorld().playEffect(damagee.getLocation(), Effect.STEP_SOUND, 55);
+		}
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Assassin/Blink.java

@@ -0,0 +1,346 @@
+package mineplex.minecraft.game.classcombat.Skill.Assassin;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Effect;
+import org.bukkit.GameMode;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.craftbukkit.v1_8_R3.entity.CraftEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.block.Action;
+import org.bukkit.potion.PotionEffectType;
+import org.bukkit.util.Vector;
+
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilAlg;
+import mineplex.core.common.util.UtilBlock;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilMath;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.common.util.UtilTime;
+import mineplex.core.common.util.UtilWorld;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.Skill.event.SkillTeleportEvent;
+import net.minecraft.server.v1_8_R3.AxisAlignedBB;
+import net.minecraft.server.v1_8_R3.Entity;
+
+public class Blink extends SkillActive
+{
+	private Map<Player, Location> _loc = new HashMap<>();
+	private Map<Player, Long> _blinkTime = new HashMap<>();
+	private boolean _allowTrapping = false;
+	
+	public Blink(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[]  
+				{
+				"Instantly teleport forwards #9#3 Blocks.",
+				"Cannot be used while Slowed.",
+				"",
+				"Using again within #6#-1 seconds De-Blinks,",
+				"returning you to your original location.",
+				"Cannot be used while Slowed."
+				});
+	}
+
+	@SuppressWarnings("deprecation")
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (player.hasPotionEffect(PotionEffectType.SLOW))
+		{
+			UtilPlayer.message(player, F.main(GetClassType().name(), "You cannot use " + F.skill(GetName()) + " while Slowed."));
+			return false;
+		}
+		else if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+		
+		// Check to see if teleporting event is valid
+		Location destination = getDestination(player, getMaxRange(player));
+		SkillTeleportEvent teleportEvent = new SkillTeleportEvent(player, destination);
+		Bukkit.getPluginManager().callEvent(teleportEvent);
+		
+		if (teleportEvent.isCancelled()) return false;	// Teleport cancelled
+
+		//Deblink
+		if (_loc.containsKey(player) && _blinkTime.containsKey(player))
+		{
+			long time = _blinkTime.get(player);
+
+			if (!UtilTime.elapsed(time, 6000 - (1000 * level)))
+			{
+				//Require 500ms after blink to deblink
+				if (UtilTime.elapsed(time, 500))
+					Deblink(player, level);
+				
+				return false;
+			}
+		}
+
+		return true;
+	}
+	
+	public void blinky(Player player)
+	{
+		Location start = player.getLocation().add(new Vector(0, 0.2, 0));
+		Location test = null;
+		Location end = start.clone();
+		Vector dir = player.getLocation().getDirection();
+		AxisAlignedBB box = null;
+		Entity ent = ((CraftEntity)player).getHandle();
+		double maxRange = getMaxRange(player);
+		double range = 0;
+		
+		rangeLoop: while (range <= maxRange)
+		{
+			test = start.clone().add(dir.clone().multiply(range));
+			float halfWidth = ent.width / 2;
+			float length = ent.length;
+			box = new AxisAlignedBB(test.getX() - halfWidth, test.getY(), test.getZ() - halfWidth, test.getX() + halfWidth, test.getY() + length, test.getZ() + halfWidth);
+			
+			//Lock Players
+			playerLoop: for (Player cur : player.getWorld().getPlayers())
+			{
+				if (cur.equals(player) || cur.getGameMode() == GameMode.SPECTATOR || UtilPlayer.isSpectator(cur))
+				{
+					continue playerLoop;
+				}
+
+				if (UtilMath.offset(test, cur.getLocation()) > 1)
+				{
+					continue playerLoop;
+				}
+
+				//Action
+				Location target = cur.getLocation().add(player.getLocation().subtract(cur.getLocation()).toVector().normalize());
+				player.teleport(UtilWorld.locMerge(player.getLocation(), target));
+
+				//Inform
+				UtilPlayer.message(player, F.main(GetClassType().name(), "You used " + F.skill(GetName()) + "."));
+
+				//Effect
+				player.getWorld().playEffect(player.getLocation(), Effect.BLAZE_SHOOT, 0);
+				return;
+			}
+			
+			for (Block b : UtilBlock.getInBoundingBox(player.getWorld(), box))
+			{
+				if (UtilBlock.airFoliage(b))
+				{
+					if (b.getType() == Material.STRING && _allowTrapping)
+					{
+						break rangeLoop;
+					}
+				}
+				else
+				{
+					break rangeLoop;
+				}
+			}
+			
+			range += 0.2;
+			end = test.clone();
+			//Smoke Trail
+			UtilParticle.PlayParticle(ParticleType.LARGE_SMOKE, end.clone().add(0, 0.5, 0), 0, 0, 0, 0, 1,
+					ViewDist.LONGER, UtilServer.getPlayers());
+		}
+		
+		_loc.put(player, player.getLocation());
+		
+		if (range > 0)
+		{
+			player.teleport(end);
+		}
+		player.setFallDistance(0);
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		Location start = player.getLocation().add(new Vector(0, 0.2, 0));
+		Location test = null;
+		Location end = start.clone();
+		Vector dir = player.getLocation().getDirection();
+		AxisAlignedBB box = null;
+		Entity ent = ((CraftEntity)player).getHandle();
+		double maxRange = getMaxRange(player);
+		double range = 0;
+		
+		rangeLoop: while (range <= maxRange)
+		{
+			test = start.clone().add(dir.clone().multiply(range));
+			float halfWidth = ent.width / 2;
+			float length = ent.length;
+			box = new AxisAlignedBB(test.getX() - halfWidth, test.getY(), test.getZ() - halfWidth, test.getX() + halfWidth, test.getY() + length, test.getZ() + halfWidth);
+			
+			//Lock Players
+			playerLoop: for (Player cur : player.getWorld().getPlayers())
+			{
+				if (cur.equals(player) || cur.getGameMode() == GameMode.SPECTATOR || UtilPlayer.isSpectator(cur))
+				{
+					continue playerLoop;
+				}
+
+				if (UtilMath.offset(test, cur.getLocation()) > 1)
+				{
+					continue playerLoop;
+				}
+
+				//Action
+				Location target = cur.getLocation().add(player.getLocation().subtract(cur.getLocation()).toVector().normalize());
+				player.teleport(UtilWorld.locMerge(player.getLocation(), target));
+
+				//Inform
+				UtilPlayer.message(player, F.main(GetClassType().name(), "You used " + F.skill(GetName()) + "."));
+
+				//Effect
+				player.getWorld().playEffect(player.getLocation(), Effect.BLAZE_SHOOT, 0);
+				return;
+			}
+			
+			for (Block b : UtilBlock.getInBoundingBox(player.getWorld(), box))
+			{
+				if (UtilBlock.airFoliage(b))
+				{
+					if (b.getType() == Material.TRIPWIRE && _allowTrapping)
+					{
+						break rangeLoop;
+					}
+				}
+				else
+				{
+					break rangeLoop;
+				}
+			}
+			
+			range += 0.2;
+			end = test.clone();
+			//Smoke Trail
+			UtilParticle.PlayParticle(ParticleType.LARGE_SMOKE, end.clone().add(0, 0.5, 0), 0, 0, 0, 0, 1,
+					ViewDist.LONGER, UtilServer.getPlayers());
+		}
+		
+		_loc.put(player, player.getLocation());
+		
+		if (range > 0)
+		{
+			player.teleport(end);
+		}
+		
+		player.setFallDistance(0);
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You used " + F.skill(GetName()) + "."));
+
+		//Effect
+		player.getWorld().playEffect(player.getLocation(), Effect.BLAZE_SHOOT, 0);
+
+		//Record
+		_blinkTime.put(player, System.currentTimeMillis());
+	}
+
+	public void Deblink(Player player, int level)
+	{
+		Location target = _loc.remove(player);
+		if (!player.getWorld().equals(target.getWorld()))
+		{
+			UtilPlayer.message(player, F.main(GetClassType().name(), "You cannot use " + F.skill("De-Blink") + " between worlds!"));
+			return;
+		}
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You used " + F.skill("De-Blink") + "."));
+
+		//Smoke Trail
+		Block lastSmoke = player.getLocation().getBlock();
+
+		double curRange = 0;
+
+		boolean done = false;
+		while (!done)
+		{
+			Vector vec = UtilAlg.getTrajectory(player.getLocation(), 
+					new Location(player.getWorld(), target.getX(), target.getY(), target.getZ()));
+
+			Location newTarget = player.getLocation().add(vec.multiply(curRange));
+
+			//Progress Forwards
+			curRange += 0.2;
+
+			//Smoke Trail
+			UtilParticle.PlayParticle(ParticleType.LARGE_SMOKE, newTarget.clone().add(0, 0.5, 0), 0, 0, 0, 0, 1,
+					ViewDist.LONGER, UtilServer.getPlayers());
+				
+			lastSmoke = newTarget.getBlock();
+
+			if (UtilMath.offset(newTarget, target) < 0.4)
+						done = true;
+					
+					if (curRange > 24)
+				done = true;
+
+			if (curRange > 24)
+				done = true;
+		}
+
+		target.setYaw(player.getLocation().getYaw());
+		target.setPitch(player.getLocation().getPitch());
+		
+		player.teleport(target);
+		
+		player.setFallDistance(0);
+
+		//Effect
+		player.getWorld().playEffect(player.getLocation(), Effect.BLAZE_SHOOT, 0);
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_loc.remove(player);
+		_blinkTime.remove(player);
+	}
+	
+	private double getMaxRange(Player player)
+	{
+		return 9 + (getLevel(player) * 3);
+	}
+	
+	private Location getDestination(Player player, double range)
+	{
+		return player.getLocation().add(player.getLocation().getDirection().multiply(range).add(new Vector(0, 0.4, 0)));
+	}
+	
+	public boolean isAllowTrapping()
+	{
+		return _allowTrapping;
+	}
+	
+	public void setAllowTrapping(boolean allowTrapping)
+	{
+		_allowTrapping = allowTrapping;
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Assassin/ComboAttack.java

@@ -0,0 +1,117 @@
+package mineplex.minecraft.game.classcombat.Skill.Assassin;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.WeakHashMap;
+
+import org.bukkit.Sound;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+
+import mineplex.core.common.util.UtilTime;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+
+public class ComboAttack extends Skill
+{
+	private final Map<Player, Float> _repeat = new WeakHashMap<>();
+	private final Map<Player, Long> _last = new WeakHashMap<>();
+	private final Map<Player, Integer> _lastTarget = new WeakHashMap<>();
+
+	public ComboAttack(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Each time you attack, your damage",
+				"increases by 1.",
+				"Maximum of #0#1 bonus damage.",
+				"",
+				"Not attacking for 2 seconds clears",
+				"your bonus damage."
+				});
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void Damage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+
+		if (event.GetCause() != DamageCause.ENTITY_ATTACK)
+			return;
+		
+		//Damager
+		Player damager = event.GetDamagerPlayer(false);
+		if (damager == null)	return;
+
+		int level = getLevel(damager);
+		if (level == 0)			return;
+		
+		LivingEntity target = event.GetDamageeEntity();
+		if (target == null)		return;
+		
+		Integer lastId = _lastTarget.put(damager, target.getEntityId());
+		if (lastId == null || lastId != target.getEntityId())
+		{
+			_repeat.remove(damager);
+			_last.remove(damager);
+		}
+
+		if (!_repeat.containsKey(damager))
+		{
+			_repeat.put(damager, 0.5f);
+		}
+
+		//Damage
+		event.AddMod(damager.getName(), GetName(), _repeat.get(damager), true);
+
+		//Increase Repeat
+		_repeat.put(damager, Math.min(level, _repeat.get(damager) + 1f));
+		_last.put(damager, System.currentTimeMillis());
+		
+		//Sound
+		damager.getWorld().playSound(damager.getLocation(), Sound.NOTE_STICKS, 1f, 0.7f + (0.3f * _repeat.get(damager)));
+	}
+
+	@EventHandler
+	public void Update(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.FAST)
+			return;
+
+		Set<Player>	remove = new HashSet<>();
+
+		for (Player cur : _repeat.keySet())
+		{
+			if (UtilTime.elapsed(_last.get(cur), 2000))
+			{
+				remove.add(cur);
+			}
+		}
+
+		for (Player cur : remove)
+		{
+			_repeat.remove(cur);
+			_last.remove(cur);
+			_lastTarget.remove(cur);
+		}
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_repeat.remove(player);
+		_last.remove(player);
+		_lastTarget.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Assassin/Evade.java

@@ -0,0 +1,233 @@
+package mineplex.minecraft.game.classcombat.Skill.Assassin;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import org.bukkit.Effect;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.BlockFace;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.util.Vector;
+
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilAlg;
+import mineplex.core.common.util.UtilBlock;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilTime;
+import mineplex.core.recharge.Recharge;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+
+public class Evade extends SkillActive
+{
+
+	private final Map<Player, Long> _active = new HashMap<>();
+
+	public Evade(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Block attacks to evade them and",
+				"teleport behind the attacker.",
+				"",
+				"Crouch and Evade to teleport backwards."
+				});
+	}
+	
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+		
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		_active.put(player, System.currentTimeMillis());
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You prepared to " + F.skill(GetName()) + "."));
+	}
+
+	@EventHandler(priority = EventPriority.NORMAL)
+	public void Damage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+
+		if (event.GetCause() != DamageCause.ENTITY_ATTACK)
+			return;
+
+		//Damagee
+		Player damagee = event.GetDamageePlayer();
+		if (damagee == null)	return;
+
+		//Blocking
+		if (!damagee.isBlocking())
+			return;
+
+		//Active
+		if (!_active.containsKey(damagee))
+			return;
+
+		//Damager
+		LivingEntity damager = event.GetDamagerEntity(false);
+		if (damager == null)	return;
+
+		//Level
+		int level = getLevel(damagee);
+		if (level == 0)			return;
+
+		//Cancel
+		event.SetCancelled(GetName());
+		
+		_active.remove(damagee);
+
+		//Effect
+		for (int i=0 ; i<3 ; i++)
+			damagee.getWorld().playEffect(damagee.getLocation(), Effect.SMOKE, 5);
+
+		//Location
+		Location target;
+		if (damagee.isSneaking())
+		{
+			target = FindLocationBack(damager, damagee);
+		}
+		else
+		{
+			target = FindLocationBehind(damager, damagee);
+		}
+
+		if (target == null)	
+			return;
+		
+		//Effect
+		UtilParticle.PlayParticleToAll(ParticleType.LARGE_SMOKE, damagee.getLocation(), (float)(Math.random() - 0.5), (float)(Math.random() * 1.4), (float)(Math.random() - 0.5), 0, 10, ViewDist.NORMAL);
+
+		//Action
+		damagee.teleport(target);
+
+		//Cloak
+		if (damagee.isSneaking())
+		{
+			Factory.Condition().Factory().Cloak(GetName(), damagee, damagee, 0.1, false, false);
+		}
+
+		event.SetCancelled("Evaded");
+
+		//Inform
+		UtilPlayer.message(damagee, F.main(GetClassType().name(), "You used " + F.skill(GetName(level)) + "."));
+		UtilPlayer.message(damager, F.main(GetClassType().name(), F.name(damagee.getName()) +" used " + F.skill(GetName(level)) + "."));
+		Recharge.Instance.useForce(damagee, GetName(), 250, true);
+	}
+
+	private Location FindLocationBehind(LivingEntity damager, Player damagee) 
+	{
+		double curMult = 0;
+		double maxMult = 1.5;
+
+		double rate = 0.1;
+
+		Location lastValid = damager.getLocation();
+
+		while (curMult <= maxMult)
+		{
+			Vector vec = UtilAlg.getTrajectory(damager, damagee).multiply(curMult);
+			Location loc = damager.getLocation().subtract(vec);
+
+			if (!UtilBlock.airFoliage(loc.getBlock()) || !UtilBlock.airFoliage(loc.getBlock().getRelative(BlockFace.UP)))
+				return lastValid;
+
+			lastValid = loc;
+
+			curMult += rate;
+		}
+
+		return lastValid;
+	}
+
+	private Location FindLocationBack(LivingEntity damager, Player damagee) 
+	{
+		double curMult = 0;
+		double maxMult = 3;
+
+		double rate = 0.1;
+
+		Location lastValid = damagee.getLocation();
+
+		while (curMult <= maxMult)
+		{
+			Vector vec = UtilAlg.getTrajectory(damager, damagee).multiply(curMult);
+			Location loc = damagee.getLocation().add(vec);
+
+			if (!UtilBlock.airFoliage(loc.getBlock()) || !UtilBlock.airFoliage(loc.getBlock().getRelative(BlockFace.UP)))
+				return lastValid;
+
+			lastValid = loc;
+
+			curMult += rate;
+		}
+
+		return lastValid;
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_active.remove(player);
+	}
+	
+	@EventHandler
+	public void clean(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		Iterator<Player> activeIter = _active.keySet().iterator();
+		
+		while (activeIter.hasNext())
+		{
+			Player player = activeIter.next();
+			
+			if (!player.isOnline() || !player.isBlocking() || UtilTime.elapsed(_active.get(player), 1000))
+			{
+				activeIter.remove();
+				UtilPlayer.message(player, F.main(GetClassType().name(), "You failed to " + F.skill(GetName()) + "."));
+				Recharge.Instance.useForce(player, GetName(), 16000, true);
+			}
+		}
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Assassin/Flash.java

@@ -0,0 +1,234 @@
+package mineplex.minecraft.game.classcombat.Skill.Assassin;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import net.minecraft.server.v1_8_R3.AxisAlignedBB;
+import net.minecraft.server.v1_8_R3.Entity;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.block.Block;
+import org.bukkit.craftbukkit.v1_8_R3.entity.CraftEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.Action;
+import org.bukkit.potion.PotionEffectType;
+import org.bukkit.util.Vector;
+
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilBlock;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilItem;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.recharge.Recharge;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.Skill.event.SkillTeleportEvent;
+
+public class Flash extends SkillActive
+{
+
+	private final Map<Player, Integer> _flash = new HashMap<>();
+	private boolean _allowTrapping = false, _startWithCharges = true;
+
+	public Flash(SkillFactory skills, String name, ClassType classType, SkillType skillType,
+				 int cost, int levels,
+				 int energy, int energyMod,
+				 long recharge, long rechargeMod, boolean rechargeInform,
+				 Material[] itemArray,
+				 Action[] actionArray)
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod,
+				recharge, rechargeMod, rechargeInform,
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[]
+				{
+						"Teleport forwards 6 Blocks.",
+						"Store up to #1#1 Flash Charges.",
+						"Cannot be used while Slowed."
+				});
+	}
+
+	@Override
+	public String GetRechargeString()
+	{
+		return "Recharge: 4 Seconds per Charge";
+	}
+
+	@SuppressWarnings("deprecation")
+	@Override
+	public boolean CustomCheck(Player player, int level)
+	{
+		if (player.hasPotionEffect(PotionEffectType.SLOW))
+		{
+			UtilPlayer.message(player, F.main(GetClassType().name(), "You cannot use " + F.skill(GetName()) + " while Slowed."));
+			return false;
+		}
+
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		// Check to see if teleporting event is valid
+		Location destination = getDestination(player, getMaxRange(player));
+		SkillTeleportEvent teleportEvent = new SkillTeleportEvent(player, destination);
+		Bukkit.getPluginManager().callEvent(teleportEvent);
+
+		if (teleportEvent.isCancelled()) return false;    // Teleport cancelled
+
+		//No Flash
+		_flash.putIfAbsent(player, _startWithCharges ? 1 + level : 1);
+
+		if (_flash.get(player) == 0)
+		{
+			UtilPlayer.message(player, F.main("Skill", "You have no " + F.skill(GetName() + " Charges") + "."));
+			return false;
+		}
+
+		return true;
+	}
+
+	@EventHandler
+	public void recharge(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+		{
+			return;
+		}
+
+		_flash.entrySet().forEach(entry ->
+		{
+			Player cur = entry.getKey();
+			int charges = entry.getValue();
+			int level = getLevel(cur);
+
+			if (charges >= 1 + level || !Recharge.Instance.use(cur, "Flash Recharge", 4000, false, false))
+			{
+				return;
+			}
+
+			entry.setValue(charges + 1);
+
+			//Inform
+			UtilPlayer.message(cur, F.main(GetClassType().name(), "Flash Charges: " + F.elem((charges + 1) + "")));
+		});
+	}
+
+	@SuppressWarnings("deprecation")
+	@Override
+	public void Skill(Player player, int level)
+	{
+		//Use Recharge
+		Recharge.Instance.use(player, "Flash Recharge", 8000, false, false);
+
+		_flash.put(player, _flash.get(player) - 1);
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "Flash Charges: " + F.elem(_flash.get(player) + "")));
+
+		Location start = player.getLocation().add(new Vector(0, 0.2, 0));
+		Location test;
+		Location end = start.clone();
+		Vector dir = player.getLocation().getDirection();
+		AxisAlignedBB box;
+		Entity ent = ((CraftEntity) player).getHandle();
+		double maxRange = getMaxRange(player);
+		double range = 0;
+
+		rangeLoop:
+		while (range <= maxRange)
+		{
+			test = start.clone().add(dir.clone().multiply(range));
+			float halfWidth = ent.width / 2;
+			float length = ent.length;
+			box = new AxisAlignedBB(test.getX() - halfWidth, test.getY(), test.getZ() - halfWidth, test.getX() + halfWidth, test.getY() + length, test.getZ() + halfWidth);
+			for (Block b : UtilBlock.getInBoundingBox(player.getWorld(), box))
+			{
+				if (b.getType() == Material.STEP || b.getType() == Material.WOOD_STEP || b.getType() == Material.STONE_SLAB2)
+				{
+					boolean bottom = false;
+					int data = b.getData();
+					if (data <= 7)
+					{
+						bottom = true;
+					}
+
+					boolean locIsBottom = (Math.max(test.getY(), b.getY()) - Math.min(test.getY(), b.getY())) < 0.5;
+
+					if (bottom == locIsBottom)
+					{
+						break rangeLoop;
+					}
+				}
+				else if (UtilItem.isBoundless(b.getType()))
+				{
+					if (b.getType() == Material.TRIPWIRE && _allowTrapping)
+					{
+						break rangeLoop;
+					}
+				}
+				else
+				{
+					break rangeLoop;
+				}
+			}
+
+			range += 0.1;
+			end = test.clone();
+			//Smoke Trail
+			UtilParticle.PlayParticleToAll(ParticleType.FIREWORKS_SPARK, end.clone().add(0, 0.5, 0), 0, 0, 0, 0, 1, ViewDist.LONG);
+		}
+
+		if (range > 0)
+		{
+			player.teleport(end);
+		}
+
+		player.setFallDistance(0);
+
+		//Effect
+		player.getWorld().playSound(player.getLocation(), Sound.WITHER_SHOOT, 0.4f, 1.2f);
+		player.getWorld().playSound(player.getLocation(), Sound.SILVERFISH_KILL, 1f, 1.6f);
+	}
+
+	@Override
+	public void Reset(Player player)
+	{
+		_flash.remove(player);
+	}
+
+	private double getMaxRange(Player player)
+	{
+		return 6;
+	}
+
+	private Location getDestination(Player player, double range)
+	{
+		return player.getLocation().add(player.getLocation().getDirection().multiply(range).add(new Vector(0, 0.4, 0)));
+	}
+
+	public void setAllowTrapping(boolean allowTrapping)
+	{
+		_allowTrapping = allowTrapping;
+	}
+
+	public void setStartWithCharges(boolean startWithCharges)
+	{
+		_startWithCharges = startWithCharges;
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Assassin/Illusion.java

@@ -0,0 +1,231 @@
+package mineplex.minecraft.game.classcombat.Skill.Assassin;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.UUID;
+
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Skeleton;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityDeathEvent;
+import org.bukkit.inventory.ItemStack;
+
+import com.mojang.authlib.GameProfile;
+
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilAction;
+import mineplex.core.common.util.UtilBlock;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilMath;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.disguise.disguises.DisguisePlayer;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.core.utils.UtilGameProfile;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.event.ClassCombatCreatureAllowSpawnEvent;
+import mineplex.minecraft.game.core.condition.Condition.ConditionType;
+
+public class Illusion extends SkillActive
+{
+	private HashMap<Player, Skeleton> _active = new HashMap<Player, Skeleton>();
+
+	public Illusion(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Hold Block to go invisible and create an",
+				"illusion of yourself that runs towards",
+				"your target location.",
+				"",
+				"Invisibility ends if you release Block",
+				"or your Illusion is killed.",
+				"",
+				"Illusion lasts up to #2#1 seconds.",
+				"",
+				"Gives Slow 2 for up to 4 seconds",
+				"to nearby players upon ending."
+				});
+		
+		setAchievementSkill(true);
+	}
+	
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+		
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		//Spawn
+		ClassCombatCreatureAllowSpawnEvent enableEvent = new ClassCombatCreatureAllowSpawnEvent(player.getWorld().getName(), true);
+		UtilServer.getServer().getPluginManager().callEvent(enableEvent);
+		
+		Skeleton skel = player.getWorld().spawn(player.getLocation(), Skeleton.class);
+		skel.teleport(player.getLocation());
+		UtilEnt.vegetate(skel);
+		UtilEnt.silence(skel, true);
+		
+		skel.setMaxHealth(14);
+		skel.setHealth(14);
+		
+		ClassCombatCreatureAllowSpawnEvent disableEvent = new ClassCombatCreatureAllowSpawnEvent(player.getWorld().getName(), false);
+		UtilServer.getServer().getPluginManager().callEvent(disableEvent);
+		
+		skel.getEquipment().setHelmet(player.getInventory().getHelmet());
+		skel.getEquipment().setChestplate(player.getInventory().getChestplate());
+		skel.getEquipment().setLeggings(player.getInventory().getLeggings());
+		skel.getEquipment().setBoots(player.getInventory().getBoots());
+		skel.getEquipment().setItemInHand(Math.random() > 0.5 ? player.getItemInHand() : new ItemStack(Material.IRON_AXE));
+
+		//Get in range
+		ArrayList<UUID> inRange = new ArrayList<>();
+		for (Player other : UtilServer.getPlayers())
+			if (UtilMath.offset2d(skel, other) < 70)
+				inRange.add(other.getUniqueId());
+				
+		//Disguise
+		GameProfile profile = UtilGameProfile.getGameProfile(player);
+
+		try
+		{
+			UtilGameProfile.changeId(profile, UUID.randomUUID());
+			DisguisePlayer disguise = new DisguisePlayer(skel, profile);
+			Factory.Disguise().disguise(disguise, attempted -> inRange.contains(attempted.getUniqueId()));
+		}
+		catch (ReflectiveOperationException ex)
+		{
+			ex.printStackTrace();
+		}
+
+		//Invis
+		Factory.Condition().Factory().untrueCloak(GetName(), player, player, 2 + 1*level, false);
+		
+		_active.put(player, skel);
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You used " + F.skill(GetName()) + "."));
+	}
+
+	@EventHandler
+	public void update(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		for (Player cur : GetUsers())
+		{
+			if (!_active.containsKey(cur))
+				continue;
+
+			Skeleton skel = _active.get(cur);
+			
+			if (Factory.Condition().GetActiveCondition(cur, ConditionType.UNTRUE_CLOAK) == null ||
+				!UtilPlayer.isBlocking(cur) || 
+				//!Factory.Energy().Use(cur, getName(), 0.625 - (getLevel(cur) * 0.025), true, true) ||
+				skel == null ||
+				!skel.isValid())
+			{
+				end(cur);
+				continue;
+			}
+			else
+			{
+				if (UtilEnt.isGrounded(skel) &&
+					(!UtilBlock.airFoliage(skel.getLocation().add(skel.getLocation().getDirection()).getBlock()) ||
+					!UtilBlock.airFoliage(skel.getLocation().add(skel.getLocation().getDirection().multiply(2)).getBlock())))
+				{
+					UtilAction.velocity(skel, 0.6, 0.4, 1, false);
+				}
+				
+				UtilEnt.CreatureMoveFast(skel, cur.getTargetBlock((HashSet<Byte>)null, 30).getLocation().add(0, 2, 0), 1.8f);
+			}
+		}
+	}
+	
+	@EventHandler(priority = EventPriority.HIGHEST)
+	public void illusionDeath(EntityDeathEvent event)
+	{
+		if (_active.containsValue(event.getEntity()))
+		{
+			event.getDrops().clear();
+			event.getEntity().remove();
+		}
+	}
+	
+	private void end(Player player)
+	{
+		Factory.Condition().EndCondition(player, null, GetName());
+		
+		Skeleton skel = _active.remove(player);
+		if (skel == null)
+			return;
+					
+		//Level
+		int level = getLevel(player);
+		
+		//Blind
+		HashMap<LivingEntity, Double> targets = UtilEnt.getInRadius(skel.getLocation(), 6d + 0.5 * level);
+		for (LivingEntity cur : targets.keySet())
+		{
+			if (cur.equals(player))
+				continue;
+			
+			if (cur instanceof Player && !Factory.Relation().canHurt(player, (Player)cur))
+			{
+				continue;
+			}
+
+			//Condition
+			Factory.Condition().Factory().Slow(GetName(), cur, player, 4 * targets.get(cur), 1, false, false, false, false);
+		}
+		
+		//Effect
+		UtilParticle.PlayParticle(ParticleType.LARGE_SMOKE, skel.getLocation().add(0, 1, 0), 0.3f, 0.3f, 0.3f, 0.06f, 30,
+				ViewDist.LONGER, UtilServer.getPlayers());
+		
+		for (int i=0 ; i<2 ; i++)
+			skel.getWorld().playSound(skel.getLocation(), Sound.FIZZ, 2f, 0.4f);
+		
+		skel.getEquipment().clear();
+		skel.remove();
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		end(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Assassin/Leap.java

@@ -0,0 +1,213 @@
+package mineplex.minecraft.game.classcombat.Skill.Assassin;
+
+import org.bukkit.Effect;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.potion.PotionEffectType;
+import org.bukkit.util.Vector;
+
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilAction;
+import mineplex.core.common.util.UtilBlock;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilTime;
+import mineplex.core.recharge.Recharge;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+
+public class Leap extends SkillActive
+{
+	public Leap(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray); 
+
+		SetDesc(new String[] 
+				{
+				"Take a great leap forwards.",
+				"",	
+				"Wall Kick by using Leap with your",
+				"back against a wall. This doesn't",
+				"trigger Leaps Recharge but has a cooldown",
+				"of 1.5 seconds.",
+				"",
+				"Cannot be used while Slowed."
+				});
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{		
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		if (UtilTime.elapsed(Factory.Movement().Get(player).LastGrounded, 8000))
+		{
+			UtilPlayer.message(player, F.main(GetClassType().name(), "You cannot use " + F.skill(GetName()) + " while airborne."));
+		}
+
+		if (player.hasPotionEffect(PotionEffectType.SLOW))
+		{
+			UtilPlayer.message(player, F.main(GetClassType().name(), "You cannot use " + F.skill(GetName()) + " while Slowed."));
+			return false;
+		}
+
+		//Wall Kick
+		if (WallJump(player, level))
+			return false;
+
+		return true;
+	}
+
+	public void DoLeap(Player player, int level, boolean wallkick)
+	{
+		//Action
+		if (!wallkick)
+			UtilAction.velocity(player, 1.2, 0.2, 1, true);
+		else
+		{
+			Vector vec = player.getLocation().getDirection();
+			vec.setY(0);
+			UtilAction.velocity(player, vec, 0.7, false, 0, 0.7, 2, true);
+		}
+
+		//Inform
+		if (!wallkick)
+			UtilPlayer.message(player, F.main(GetClassType().name(), "You used " + F.skill(GetName(level)) + "."));
+		else
+			UtilPlayer.message(player, F.main(GetClassType().name(), "You used " + F.skill("Wall Kick") + "."));
+
+		//Effect
+		player.getWorld().playEffect(player.getLocation(), Effect.STEP_SOUND, 80);
+		player.getWorld().playSound(player.getLocation(), Sound.BAT_TAKEOFF, 2f, 1.2f);
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		DoLeap(player, level, false);
+	}
+
+	public boolean WallJump(Player player, int level)
+	{
+		if (level == 0)		return false;
+
+		//Recharge & Energy
+		if (!Recharge.Instance.use(player, "Wall Kick", 1500, false, false))
+			return false;
+
+		//Direction
+		Vector vec = player.getLocation().getDirection();
+
+		//Logic
+		boolean xPos = true;
+		boolean zPos = true;
+
+		if (vec.getX() < 0)		xPos = false;
+		if (vec.getZ() < 0)		zPos = false;
+
+		for (int y=0 ; y<=0 ; y++)
+		{
+			for (int x=-1 ; x<=1 ; x++)
+			{
+				for (int z=-1 ; z<=1 ; z++)
+				{
+					if (x == 0 && z == 0)
+						continue;
+
+					if (	(xPos && x > 0) ||
+							(zPos && z > 0) ||
+							(!xPos && x < 0) ||
+							(!zPos && z < 0))
+						continue;						
+
+					if (UtilBlock.airFoliage(player.getLocation().getBlock().getRelative(x, y, z)))
+						continue;
+
+					Block forward = null;
+
+					//Forward Down
+					if (Math.abs(vec.getX()) > Math.abs(vec.getZ()))
+					{
+						if (xPos)	forward = player.getLocation().getBlock().getRelative(1, 0, 0);
+						else		forward = player.getLocation().getBlock().getRelative(-1, 0, 0);	
+					}
+					else
+					{ 
+						if (zPos)	forward = player.getLocation().getBlock().getRelative(0, 0, 1);
+						else		forward = player.getLocation().getBlock().getRelative(0, 0, -1);	
+					}
+
+					if (!UtilBlock.airFoliage(forward))
+						continue;
+
+					//Forward Up
+					if (Math.abs(vec.getX()) > Math.abs(vec.getZ()))
+					{
+						if (xPos)	forward = player.getLocation().getBlock().getRelative(1, 1, 0);
+						else		forward = player.getLocation().getBlock().getRelative(-1, 1, 0);	 
+					}
+					else
+					{
+						if (zPos)	forward = player.getLocation().getBlock().getRelative(0, 1, 1);
+						else		forward = player.getLocation().getBlock().getRelative(0, 1, -1);	
+					}
+
+					if (!UtilBlock.airFoliage(forward))
+						continue;
+
+					DoLeap(player, level, true);
+
+					return true;
+				}
+			}
+		}
+
+		return false;
+	}
+	
+	@EventHandler(priority = EventPriority.HIGH)
+	public void Damage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+
+		if (event.GetCause() != DamageCause.FALL)
+			return;
+
+		Player player = event.GetDamageePlayer();
+		if (player == null)		return;
+
+		int level = getLevel(player);
+		if (level == 0)			return;
+
+		event.AddMod(null, GetName(), -2, false);
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Assassin/MarkedForDeath.java

@@ -0,0 +1,238 @@
+package mineplex.minecraft.game.classcombat.Skill.Assassin;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Arrow;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.event.entity.EntityShootBowEvent;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+
+public class MarkedForDeath extends SkillActive
+{
+
+	private final Map<Player, MarkedData> _data = new HashMap<>();
+
+	public MarkedForDeath(SkillFactory skills, String name, ClassType classType, SkillType skillType,
+						  int cost, int levels,
+						  int energy, int energyMod,
+						  long recharge, long rechargeMod, boolean rechargeInform,
+						  Material[] itemArray,
+						  Action[] actionArray)
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod,
+				recharge, rechargeMod, rechargeInform,
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[]
+				{
+						"Your next arrow will mark players,",
+						"making them take #2.5#1.5 more damage",
+						"from the next melee attack.",
+						"",
+						"Lasts for #3#1 seconds."
+				});
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level)
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main(GetClassType().name(), "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level)
+	{
+		_data.put(player, new MarkedData(player));
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You prepared " + F.skill(GetName(level)) + "."));
+
+		//Effect
+		player.getWorld().playSound(player.getLocation(), Sound.BLAZE_BREATH, 2.5f, 2.0f);
+	}
+
+	@EventHandler
+	public void ShootBow(EntityShootBowEvent event)
+	{
+		if (!(event.getEntity() instanceof Player) || !(event.getProjectile() instanceof Arrow))
+		{
+			return;
+		}
+
+		Player player = (Player) event.getEntity();
+		MarkedData data = _data.get(player);
+
+		if (data == null || data.Arrow != null)
+		{
+			return;
+		}
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You used " + F.skill(GetName(getLevel(player))) + "."));
+		data.Arrow = event.getProjectile();
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void DamageMark(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+		{
+			return;
+		}
+
+		Projectile projectile = event.GetProjectile();
+
+		if (projectile == null)
+		{
+			return;
+		}
+
+		Player damager = event.GetDamagerPlayer(true);
+		MarkedData data = _data.get(damager);
+		int level = getLevel(damager);
+
+		if (damager == null || data == null || level == 0 || !projectile.equals(data.Arrow))
+		{
+			return;
+		}
+
+		LivingEntity damagee = event.GetDamageeEntity();
+
+		//Effect
+		damagee.getWorld().playSound(damagee.getLocation(), Sound.BLAZE_BREATH, 2.5f, 2.0f);
+
+		//Inform
+		UtilPlayer.message(event.GetDamageePlayer(), F.main(GetClassType().name(), F.name(damager.getName()) + " hit you with " + F.skill(GetName(level)) + "."));
+		UtilPlayer.message(damager, F.main(GetClassType().name(), "You hit " + F.name(UtilEnt.getName(damagee)) + " with " + F.skill(GetName(level)) + "."));
+
+		//Mark
+		data.Timeout = System.currentTimeMillis() + (3000 + 1000 * level);
+		data.Damage = 2.5 + 1.5 * level;
+		data.Marked = damagee;
+
+		//Remove
+		projectile.remove();
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void DamageAmplify(CustomDamageEvent event)
+	{
+		if (event.IsCancelled() || event.GetCause() != DamageCause.ENTITY_ATTACK)
+		{
+			return;
+		}
+
+		Player damager = event.GetDamagerPlayer(false);
+
+		if (damager == null)
+		{
+			return;
+		}
+
+		MarkedData data = _data.get(damager);
+
+		if (data == null || !event.GetDamageeEntity().equals(data.Marked) || data.isExpired())
+		{
+			return;
+		}
+
+		_data.remove(damager);
+		event.AddMod(GetName(), GetName(), data.Damage, true);
+	}
+
+	@EventHandler
+	public void playerDeath(PlayerDeathEvent event)
+	{
+		Player killed = event.getEntity(), killer = killed.getKiller();
+		MarkedData data = _data.get(killer);
+
+		if (data == null || !killed.equals(data.Marked))
+		{
+			return;
+		}
+
+		UtilPlayer.health(killer, 2 + getLevel(killer));
+	}
+
+	@EventHandler
+	public void Particle(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+		{
+			return;
+		}
+
+		_data.values().forEach(data ->
+		{
+			if (data.Arrow != null && data.Arrow.isValid())
+			{
+				UtilParticle.PlayParticleToAll(ParticleType.MOB_SPELL, data.Arrow.getLocation(), null, 0, 1, ViewDist.LONG);
+			}
+		});
+	}
+
+	@Override
+	public void Reset(Player player)
+	{
+		_data.remove(player);
+	}
+
+	@EventHandler
+	public void playerQuit(PlayerQuitEvent event)
+	{
+		Reset(event.getPlayer());
+	}
+
+	private class MarkedData
+	{
+
+		final Player Shooter;
+		LivingEntity Marked;
+		Entity Arrow;
+		double Damage;
+		long Timeout;
+
+		MarkedData(Player shooter)
+		{
+			Shooter = shooter;
+		}
+
+		boolean isExpired()
+		{
+			return Timeout > 0 && System.currentTimeMillis() > Timeout;
+		}
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Assassin/Recall.java

@@ -0,0 +1,194 @@
+package mineplex.minecraft.game.classcombat.Skill.Assassin;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Map;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.player.PlayerDropItemEvent;
+import org.bukkit.potion.PotionEffectType;
+
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilAlg;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilGear;
+import mineplex.core.common.util.UtilMath;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.recharge.Recharge;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.Skill.event.SkillTriggerEvent;
+
+public class Recall extends Skill
+{
+
+	private final Map<Player, LinkedList<Location>> _mainLocMap = new HashMap<>();
+	private final Map<Player, LinkedList<Location>> _secondaryLocMap = new HashMap<>();
+	private final Map<Player, LinkedList<Double>> _secondaryHealthMap = new HashMap<>();
+	
+	public Recall(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Drop Axe/Sword to Use.",
+				"",
+				"Go back in time #3#1 seconds,",
+				"restoring your location and",
+				"regeneration 3 for #2#+1 seconds",
+				"Cannot be used while Slowed.",
+				"",
+				"Hold shift when using to go",
+				"back 2 seconds, restoring your",
+				"location and up to #1.5#0.5 health.",
+				});
+	}
+
+	@Override
+	public String GetRechargeString()
+	{
+		return "Recharge: #35#-5 Seconds";
+	}
+	
+	@EventHandler
+	public void use(PlayerDropItemEvent event)
+	{
+		Player player = event.getPlayer();
+
+		int level = getLevel(player);
+		if (level == 0)
+			return;
+		
+		if (!UtilGear.isWeapon(event.getItemDrop().getItemStack()))
+			return;
+
+		event.setCancelled(true);
+
+		boolean secondary = player.isSneaking();
+
+		if (!secondary && player.hasPotionEffect(PotionEffectType.SLOW))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " while Slowed."));
+			return;
+		}
+
+		if (isInWater(player))
+		{
+			player.sendMessage(F.main("Skill", "You cannot use " + F.skill(GetName()) +" while in water."));
+			return;
+		}
+
+		//Check Allowed
+		SkillTriggerEvent trigger = new SkillTriggerEvent(player, GetName(), GetClassType());
+		Bukkit.getServer().getPluginManager().callEvent(trigger);
+		
+		if (trigger.IsCancelled())
+			return;
+
+		if (!Recharge.Instance.use(player, GetName(), GetName(level), secondary ? 18000 - (level * 2000) : 35000 - (level * 5000), true, false))
+			return;
+
+		LinkedList<Location> locs = secondary ? _secondaryLocMap.remove(player) : _mainLocMap.remove(player);
+		if (locs == null)
+			return;
+
+		LinkedList<Double> health =  _secondaryHealthMap.remove(player);
+		if (health == null)
+			return;
+
+		Factory.runSync(() ->
+		{
+			if (player.isDead() || !player.getWorld().equals(locs.getLast().getWorld()))
+			{
+				return;
+			}
+
+			if (secondary)
+			{
+				//Heal
+				double newHealth = Math.min(health.getLast(), player.getHealth() + 1.5 + (level / 2D));
+				player.setHealth(newHealth);
+			}
+			else
+			{
+				Factory.Condition().Factory().Regen(GetName(), player, player, 1 + level, 2, false, true, false);
+			}
+
+			//Effect
+			player.getWorld().playSound(player.getLocation(), Sound.ZOMBIE_UNFECT, 2f, 2f);
+
+			//Teleport
+			Location current = player.getLocation();
+			Location target = locs.getLast();
+
+			player.teleport(target);
+
+			//Inform
+			UtilPlayer.message(player, F.main(GetClassType().name(), "You used " + F.skill((secondary ? "Secondary " : "") + GetName(level)) + "."));
+
+			//Effect
+			player.getWorld().playSound(player.getLocation(), Sound.ZOMBIE_UNFECT, 2f, 2f);
+
+			while (UtilMath.offsetSquared(current, target) > 0.25)
+			{
+				UtilParticle.PlayParticleToAll(ParticleType.WITCH_MAGIC, current, 0, 1f, 0, 0, 1, ViewDist.LONG);
+				current = current.add(UtilAlg.getTrajectory(current, target).multiply(0.1));
+			}
+		});
+	}
+
+	@EventHandler
+	public void storeLocation(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		for (Player cur : GetUsers())
+		{
+			//Store
+			_mainLocMap.computeIfAbsent(cur, (key) -> new LinkedList<>()).addFirst(cur.getLocation());
+			_secondaryLocMap.computeIfAbsent(cur, (key) -> new LinkedList<>()).addFirst(cur.getLocation());
+			_secondaryHealthMap.computeIfAbsent(cur, (key) -> new LinkedList<>()).addFirst(cur.getHealth());
+			
+			int level = getLevel(cur);
+			
+			long maxMainSize = (3 + level) * 20;
+			long maxSecondarySize = 2 * 20;
+			
+			//Cull
+			if (_mainLocMap.get(cur).size() > maxMainSize)
+			{
+				_mainLocMap.get(cur).removeLast();
+			}
+			
+			if (_secondaryLocMap.get(cur).size() > maxSecondarySize)
+			{
+				_secondaryLocMap.get(cur).removeLast();
+			}
+
+			if (_secondaryHealthMap.get(cur).size() > maxSecondarySize)
+			{
+				_secondaryHealthMap.get(cur).removeLast();
+			}
+		}
+	}
+	
+	@Override
+	public void Reset(Player player) 
+	{
+		_mainLocMap.remove(player);
+		_secondaryLocMap.remove(player);
+		_secondaryHealthMap.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Assassin/RecallOld.java

@@ -0,0 +1,209 @@
+package mineplex.minecraft.game.classcombat.Skill.Assassin;
+
+import java.util.HashMap;
+import java.util.HashSet;
+
+import org.bukkit.Effect;
+import org.bukkit.Sound;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.inventory.InventoryPickupItemEvent;
+import org.bukkit.event.player.PlayerDropItemEvent;
+import org.bukkit.event.player.PlayerPickupItemEvent;
+import org.bukkit.util.Vector;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.core.common.util.C;
+import mineplex.core.common.util.F;
+import mineplex.core.itemstack.ItemStackFactory;
+import mineplex.core.recharge.Recharge;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.common.util.UtilGear;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.common.util.UtilTime;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.core.common.util.UtilTime.TimeUnit;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class RecallOld extends Skill
+{
+	private HashMap<Player, Item> _items = new HashMap<Player, Item>();
+	private HashMap<Player, Long> _time = new HashMap<Player, Long>();
+	private HashMap<Player, Long> _informed = new HashMap<Player, Long>();
+	
+	public RecallOld(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Place a recall marker on the ground.",
+				"Use recall again within #15#5 seconds",
+				"to return to original location."
+				});
+	}
+
+	@Override
+	public String GetEnergyString()
+	{
+		return "Energy: #60#-15";
+	}
+	
+	@Override
+	public String GetRechargeString()
+	{
+		return "Recharge: #90#-15 Seconds";
+	}
+	
+	@EventHandler
+	public void Activate(PlayerDropItemEvent event)
+	{
+		Player player = event.getPlayer();
+		
+		int level = getLevel(player);
+		if (level == 0)		return;
+		
+		if (!UtilGear.isWeapon(event.getItemDrop().getItemStack()))
+			return;
+
+		event.setCancelled(true);
+
+		//Mark
+		if (!_items.containsKey(player))
+		{
+			//Check Energy - DO NOT USE YET
+			if (!Factory.Energy().Use(player, GetName(level), 60 - (15 * level), false, true))
+				return;
+
+			//Use Recharge
+			if (!Recharge.Instance.use(player, GetName(), GetName(level), 90000 - (15000 - level), true, false))
+				return;
+
+			//Use Energy
+			Factory.Energy().Use(player, GetName(level), 60, true, true);
+			
+			//Item
+			Item item = player.getWorld().dropItem(player.getEyeLocation(), ItemStackFactory.Instance.CreateStack(2261));
+			item.setVelocity(new Vector(0, -1, 0));
+			
+			//Save
+			_items.put(player, item);
+			_time.put(player, System.currentTimeMillis() + 15000 + (5000 * level));
+			_informed.put(player, 20000L);
+			
+			//Inform
+			UtilPlayer.message(player, F.main(GetClassType().name(), "You prepared " + F.skill(GetName(level)) + "."));
+			
+			//Effect
+			player.getWorld().playEffect(player.getLocation(), Effect.STEP_SOUND, 133);
+			
+		}
+		//Return
+		else
+		{
+			//Effect
+			player.getWorld().playEffect(player.getLocation(), Effect.STEP_SOUND, 133);
+			player.getWorld().playSound(player.getLocation(), Sound.ZOMBIE_UNFECT, 2f, 2f);
+			UtilParticle.PlayParticle(ParticleType.WITCH_MAGIC, player.getLocation(),
+					(float)(Math.random() - 0.5), (float)(Math.random() * 1.4), (float)(Math.random() - 0.5), 0, 20,
+					ViewDist.LONGER, UtilServer.getPlayers());
+			
+			//Return
+			Item item = _items.remove(player);
+			Factory.Teleport().TP(player, item.getLocation());
+			item.remove();
+			
+			//Inform
+			UtilPlayer.message(player, F.main(GetClassType().name(), "You used " + F.skill(GetName(level)) + "."));
+			
+			//Effect
+			player.getWorld().playSound(player.getLocation(), Sound.ZOMBIE_UNFECT, 2f, 2f);
+			UtilParticle.PlayParticle(ParticleType.WITCH_MAGIC, player.getLocation(),
+					(float)(Math.random() - 0.5), (float)(Math.random() * 1.4), (float)(Math.random() - 0.5), 0, 20,
+					ViewDist.LONGER, UtilServer.getPlayers());
+			
+			Reset(player);
+			
+		}
+	}
+	
+	@EventHandler
+	public void Update(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.FAST)
+			return;
+		
+		HashSet<Player> expired = new HashSet<Player>();
+		
+		for (Player cur : _time.keySet())
+		{
+			if (System.currentTimeMillis() > _time.get(cur))
+				expired.add(cur);
+			else
+			{
+				long time = (_time.get(cur) - System.currentTimeMillis());
+				if (time < _informed.get(cur))
+				{
+					UtilPlayer.message(cur, F.main(GetClassType().name(), 
+							"Recall Time: " + F.time(UtilTime.convertString(_informed.get(cur), 0, TimeUnit.FIT))));
+					_informed.put(cur, _informed.get(cur) - 5000);
+				}		
+			}
+		}
+			
+		
+		for (Player cur : expired)
+		{
+			_time.remove(cur);
+			_informed.remove(cur);
+			
+			Item item = _items.remove(cur);
+			if (item != null)	
+			{
+				item.getWorld().playEffect(item.getLocation(), Effect.STEP_SOUND, 133);
+				item.remove();
+				
+				//Inform
+				UtilPlayer.message(cur, F.main(GetClassType().name(), 
+						"Recall Time: " + C.cRed + "Expired"));
+			}	
+		}
+	}
+	
+	@EventHandler
+	public void ItemPickup(PlayerPickupItemEvent event)
+	{
+		if (event.isCancelled())
+			return;
+		
+		if (_items.containsValue(event.getItem()))
+			event.setCancelled(true);
+	}
+	
+	@EventHandler
+	public void HopperPickup(InventoryPickupItemEvent event)
+	{
+		if (event.isCancelled())
+			return;
+		
+		if (_items.containsValue(event.getItem()))
+			event.setCancelled(true);
+	}
+	
+	@Override
+	public void Reset(Player player) 
+	{
+		if (_items.containsKey(player))
+			_items.get(player).remove();
+		
+		_items.remove(player);
+		_time.remove(player);
+		_informed.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Assassin/ShockingStrikes.java

@@ -0,0 +1,104 @@
+package mineplex.minecraft.game.classcombat.Skill.Assassin;
+
+import java.util.Map;
+import java.util.WeakHashMap;
+
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+
+import mineplex.core.common.util.UtilGear;
+import mineplex.core.recharge.Recharge;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+
+public class ShockingStrikes extends Skill
+{
+
+	private final Map<Player, ComboData> _combos = new WeakHashMap<>();
+
+	public ShockingStrikes(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Your attacks shock targets for", 
+				"#0#1 seconds, giving them:",
+				"Slow 1: Every third hit",
+				"Blindness: Every #6#-1 seconds",
+				"Screen-Shake: Every time",
+				});
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void Damage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+
+		if (event.GetCause() != DamageCause.ENTITY_ATTACK)
+			return;
+
+		Player damager = event.GetDamagerPlayer(false);
+		if (damager == null)	return;
+		
+		if (!UtilGear.isWeapon(damager.getItemInHand()))
+			return;
+
+		int level = getLevel(damager);
+		if (level == 0)		return;
+
+		LivingEntity damagee = event.GetDamageeEntity();
+		if (damagee == null)	return;
+
+		ComboData data = _combos.get(damager);
+
+		if (data == null || data.Amount > 0 && !damagee.equals(data.Damagee))
+		{
+			data = new ComboData(damagee);
+			_combos.put(damager, data);
+		}
+
+		data.Amount++;
+
+		Factory.Condition().Factory().Shock(GetName(), damagee, damager, level, false, false);
+
+		if (data.Amount % 3 == 0)
+		{
+			Factory.Condition().Factory().Slow(GetName(), damagee, damager, level, 0, false, false, true, false);
+		}
+
+		//Damage
+		event.AddMod(damager.getName(), GetName(), 0, true);
+
+		String name = "Blinding Strike";
+
+		if (Recharge.Instance.use(damager, name, name + " " + level, 6000 + (1000 * level), false, false))
+		{
+			Factory.Condition().Factory().Blind(name, damagee, damager, level, 1, true, true, false);
+		}
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_combos.remove(player);
+	}
+
+	private class ComboData
+	{
+
+		final LivingEntity Damagee;
+		int Amount;
+
+		ComboData(LivingEntity damagee)
+		{
+			Damagee = damagee;
+		}
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Assassin/SilencingArrow.java

@@ -0,0 +1,185 @@
+package mineplex.minecraft.game.classcombat.Skill.Assassin;
+
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Arrow;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityShootBowEvent;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.core.common.util.F;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class SilencingArrow extends SkillActive
+{
+
+	private final Set<Entity> _arrows = new HashSet<>();
+	private final Set<Player> _silence = new HashSet<>();
+
+	public SilencingArrow(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Your next arrow will Silence",
+				"target for 3 seconds.",
+				"",
+				"Silence stops skills being used."
+				});
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		//Action
+		_silence.add(player);
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You prepared " + F.skill(GetName(level)) + "."));
+
+		//Effect
+		player.getWorld().playSound(player.getLocation(), Sound.BLAZE_BREATH, 2.5f, 2.0f);
+	}
+
+	@EventHandler
+	public void ShootBow(EntityShootBowEvent event)
+	{
+		if (!(event.getEntity() instanceof Player))
+			return;
+
+		if (!(event.getProjectile() instanceof Arrow))
+			return;
+
+		Player player = (Player)event.getEntity();
+
+		if (!_silence.remove(player))
+			return;
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You fired " + F.skill(GetName(getLevel(player))) + "."));
+
+		_arrows.add(event.getProjectile());
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void Damage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+		
+		if (event.GetCause() != DamageCause.PROJECTILE)
+			return;
+
+		Projectile projectile = event.GetProjectile();
+		if (projectile == null)	return;
+
+		if (!_arrows.contains((Entity)projectile))
+			return;
+
+		LivingEntity damagee = event.GetDamageeEntity();
+		if (damagee == null)	return;
+
+		Player damager = event.GetDamagerPlayer(true);
+		if (damager == null)	return;
+
+		//Level
+		int level = getLevel(damager);
+		if (level == 0)			return;
+
+		//Confuse
+		Factory.Condition().Factory().Silence(GetName(), damagee, damager, 3, true, true);
+
+		//Effect
+		damagee.getWorld().playSound(damagee.getLocation(), Sound.BLAZE_BREATH, 2.5f, 2.0f);
+
+		//Inform
+		UtilPlayer.message(event.GetDamageePlayer(), F.main(GetClassType().name(), F.name(damager.getName()) +" hit you with " + F.skill(GetName(level)) + "."));
+		UtilPlayer.message(damager, F.main(GetClassType().name(), "You hit " + F.name(UtilEnt.getName(damagee)) +" with " + F.skill(GetName(level)) + "."));
+		
+		//Damage
+		event.AddMod(damager.getName(), GetName(), 0, true);
+		
+		_arrows.remove(projectile);
+		
+		//Remove
+		projectile.remove();
+	}
+
+	@EventHandler
+	public void Particle(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+		
+		for (Entity ent : _arrows)
+		{
+			UtilParticle.PlayParticle(ParticleType.SPELL, ent.getLocation(), 0, 0, 0, 0, 1,
+					ViewDist.MAX, UtilServer.getPlayers());
+		}
+	}
+	
+	@EventHandler
+	public void Clean(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.SEC)
+			return;
+		
+		for (Iterator<Entity> arrowIterator = _arrows.iterator(); arrowIterator.hasNext();) 
+		{
+			Entity arrow = arrowIterator.next();
+			
+			if (arrow.isDead() || !arrow.isValid() || arrow.isOnGround())
+				arrowIterator.remove();
+		}
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_silence.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Assassin/SmokeArrow.java

@@ -0,0 +1,185 @@
+package mineplex.minecraft.game.classcombat.Skill.Assassin;
+
+import java.util.HashSet;
+import java.util.Iterator;
+
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Arrow;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityShootBowEvent;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.core.common.util.F;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class SmokeArrow extends SkillActive
+{
+	private HashSet<Entity> _arrows = new HashSet<Entity>();
+	private HashSet<Player> _poison = new HashSet<Player>();
+
+	public SmokeArrow(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Your next arrow will give Blindness",
+				"and Slow 2 to target for #3#1 seconds."
+				});
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main(GetClassType().name(), "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		//Action
+		_poison.add(player);
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You prepared " + F.skill(GetName(level)) + "."));
+
+		//Effect
+		player.getWorld().playSound(player.getLocation(), Sound.BLAZE_BREATH, 2.5f, 2.0f);
+	}
+
+	@EventHandler
+	public void ShootBow(EntityShootBowEvent event)
+	{
+		if (!(event.getEntity() instanceof Player))
+			return;
+
+		if (!(event.getProjectile() instanceof Arrow))
+			return;
+
+		Player player = (Player)event.getEntity();
+
+		if (!_poison.remove(player))
+			return;
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You fired " + F.skill(GetName(getLevel(player))) + "."));
+
+		_arrows.add(event.getProjectile());
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void Damage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+		
+		if (event.GetCause() != DamageCause.PROJECTILE)
+			return;
+
+		Projectile projectile = event.GetProjectile();
+		if (projectile == null)	return;
+
+		if (!_arrows.contains((Entity)projectile))
+			return;
+
+		LivingEntity damagee = event.GetDamageeEntity();
+		if (damagee == null)	return;
+
+		Player damager = event.GetDamagerPlayer(true);
+		if (damager == null)	return;
+
+		//Level
+		int level = getLevel(damager);
+		if (level == 0)			return;
+
+		//Confuse
+		double dur = 3 + level;
+		Factory.Condition().Factory().Blind(GetName(), damagee, damager, dur, 0, true, true, true);
+		Factory.Condition().Factory().Slow(GetName(), damagee, damager, dur, 1, true, true, true, true);
+
+		//Effect
+		damagee.getWorld().playSound(damagee.getLocation(), Sound.BLAZE_BREATH, 2.5f, 2.0f);
+
+		//Inform
+		UtilPlayer.message(event.GetDamageePlayer(), F.main(GetClassType().name(), F.name(damager.getName()) +" hit you with " + F.skill(GetName(level)) + "."));
+		UtilPlayer.message(damager, F.main(GetClassType().name(), "You hit " + F.name(UtilEnt.getName(damagee)) +" with " + F.skill(GetName(level)) + "."));
+
+		//Damage
+		event.AddMod(damager.getName(), GetName(), 0, true);
+		
+		//Effect
+		UtilParticle.PlayParticle(ParticleType.LARGE_EXPLODE, projectile.getLocation(), 0, 0, 0, 0, 1,
+				ViewDist.MAX, UtilServer.getPlayers());
+		
+		//Remove
+		projectile.remove();
+	}
+	
+	@EventHandler
+	public void Particle(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+		
+		for (Entity ent : _arrows)
+		{
+			UtilParticle.PlayParticle(ParticleType.LARGE_SMOKE, ent.getLocation(), 0, 0, 0, 0, 1,
+					ViewDist.MAX, UtilServer.getPlayers());
+		}
+	}
+
+	@EventHandler
+	public void Clean(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.SEC)
+			return;
+		
+		for (Iterator<Entity> arrowIterator = _arrows.iterator(); arrowIterator.hasNext();) 
+		{
+			Entity arrow = arrowIterator.next();
+			
+			if (arrow.isDead() || !arrow.isValid() || arrow.isOnGround())
+				arrowIterator.remove();
+		}
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_poison.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Assassin/SmokeBomb.java

@@ -0,0 +1,196 @@
+package mineplex.minecraft.game.classcombat.Skill.Assassin;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Effect;
+import org.bukkit.Sound;
+import org.bukkit.craftbukkit.v1_8_R3.inventory.CraftInventoryCrafting;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+import org.bukkit.event.player.PlayerDropItemEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilGear;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.recharge.Recharge;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.Skill.event.SkillTriggerEvent;
+import mineplex.minecraft.game.core.condition.Condition;
+import mineplex.minecraft.game.core.condition.Condition.ConditionType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+
+public class SmokeBomb extends Skill
+{
+	public SmokeBomb(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Drop Axe/Sword to Use.",
+				"",
+				"Create a smokey explosion, giving",
+				"Blindness to players within #2#1 Blocks",
+				"for #1#1 seconds.",
+				"",
+				"You go invisible for #1#2 seconds."
+				});
+	}
+
+	@Override
+	public String GetRechargeString()
+	{
+		return "Recharge: #45#-5 Seconds";
+	}
+
+	@EventHandler
+	public void Use(PlayerDropItemEvent event)
+	{
+		Player player = event.getPlayer();
+		
+		if (!(player.getOpenInventory().getTopInventory() instanceof CraftInventoryCrafting))
+		{
+			return;
+		}
+		
+		int level = getLevel(player);
+		if (level == 0)		return;
+
+		if (!UtilGear.isWeapon(event.getItemDrop().getItemStack()))
+			return;
+
+		event.setCancelled(true);
+
+		//Check Allowed
+		SkillTriggerEvent trigger = new SkillTriggerEvent(player, GetName(), GetClassType());
+		Bukkit.getServer().getPluginManager().callEvent(trigger);
+
+		if (trigger.IsCancelled())
+			return;
+		
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return;
+		}
+
+		if (!Recharge.Instance.use(player, GetName(), GetName(level), 45000 - (level * 5000), true, false))
+			return;
+
+		//Action
+		Factory.Condition().Factory().untrueCloak(GetName(), player, player, 1 + level * 2, false);
+
+		//Effect
+		UtilParticle.PlayParticleToAll(ParticleType.HUGE_EXPLOSION, player.getLocation(), 0, 0, 0, 0, 1, ViewDist.LONG);
+
+		for (Player other : UtilPlayer.getNearby(player.getLocation(), 2 + level))
+		{
+			if (other.equals(player) || !Factory.Relation().canHurt(player, other))
+			{
+				continue;
+			}
+
+			Factory.Condition().Factory().Blind(GetName(), other, player, 1 + level, 0, false, false, false);
+		}
+
+		for (int i=0 ; i<3 ; i++)
+			player.getWorld().playSound(player.getLocation(), Sound.FIZZ, 2f, 0.5f);
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You used " + F.skill(GetName(level)) + "."));
+	}
+
+	@EventHandler(priority = EventPriority.MONITOR)
+	public void EndDamagee(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+		{
+			return;
+		}
+
+		Player damagee = event.GetDamageePlayer();
+		if (damagee == null)	return;
+
+		if (getLevel(damagee) == 0)
+			return;
+		
+		if (event.GetDamage() <= 0)
+			return;
+
+		//End
+		Factory.Condition().EndCondition(damagee, null, GetName());
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void EndDamager(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+
+		Player damager = event.GetDamagerPlayer(true);
+		if (damager == null)	return;
+
+		if (getLevel(damager) == 0)
+			return;
+
+		//End
+		Factory.Condition().EndCondition(damager, null, GetName());
+	}
+
+	@EventHandler
+	public void EndInteract(PlayerInteractEvent event)
+	{
+		if (getLevel(event.getPlayer()) == 0)
+			return;
+
+		Factory.Condition().EndCondition(event.getPlayer(), null, GetName());
+	}
+	
+	@EventHandler
+	public void closeInv(InventoryCloseEvent event)
+	{
+		if (getLevel(event.getPlayer()) == 0)
+		{
+			return;
+		}
+		
+		event.getPlayer().getInventory().addItem(event.getPlayer().getItemOnCursor());
+		event.getPlayer().setItemOnCursor(null);
+	}
+	
+	@EventHandler
+	public void Smoke(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.FAST)
+			return;
+
+		for (Player cur : GetUsers())
+		{
+			Condition cond = Factory.Condition().GetActiveCondition(cur, ConditionType.UNTRUE_CLOAK);
+			if (cond == null)		continue;
+
+			if (!cond.GetReason().equals(GetName()))
+				continue;
+
+			//Smoke
+			cur.getWorld().playEffect(cur.getLocation(), Effect.SMOKE, 4);
+		}
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		//Remove Condition
+		Factory.Condition().EndCondition(player, null, GetName());
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Assassin/Stealth.java

@@ -0,0 +1,242 @@
+package mineplex.minecraft.game.classcombat.Skill.Assassin;
+
+import java.util.HashSet;
+
+import org.bukkit.Sound;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.player.PlayerDropItemEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.potion.PotionEffectType;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.core.common.util.F;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.common.util.UtilGear;
+import mineplex.core.common.util.UtilMath;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.common.util.UtilTime;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.minecraft.game.core.condition.Condition.ConditionType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.Skill.event.SkillTriggerEvent;
+
+public class Stealth extends Skill
+{
+	private HashSet<Player> _active = new HashSet<Player>();
+
+	public Stealth(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Drop Axe/Sword to Toggle",
+				"",
+				"Move stealthily, becoming completely",
+				"Invisible, but also Slow #4#-1.",
+				"",
+				"Stealth ends if you an enemy comes",
+				"within #10#-2 Blocks of you, or you attack.",
+				});
+	}
+
+	@Override
+	public String GetEnergyString()
+	{
+		return "Energy: #13#1 per Second";
+	}
+
+	@EventHandler
+	public void Crouch(PlayerDropItemEvent event)
+	{
+		Player player = event.getPlayer();
+
+		if (getLevel(player) == 0)
+			return;
+
+		if (!UtilGear.isWeapon(event.getItemDrop().getItemStack()))
+			return;
+
+		event.setCancelled(true);
+
+		//Check Allowed
+		SkillTriggerEvent trigger = new SkillTriggerEvent(player, GetName(), GetClassType());
+		UtilServer.getServer().getPluginManager().callEvent(trigger);
+		if (trigger.IsCancelled())
+			return;
+
+		if (!_active.remove(player))
+		{
+			if (player.hasPotionEffect(PotionEffectType.SLOW))
+			{
+				UtilPlayer.message(player, F.main(GetClassType().name(), "You cannot use " + F.skill(GetName()) + " while Slowed."));
+				return;
+			}
+
+			if (!UtilTime.elapsed(Factory.Combat().getLog(player).GetLastCombat(), 4000))
+			{
+				UtilPlayer.message(player, F.main(GetClassType().name(), "You cannot use " + F.skill(GetName()) + " while in Combat."));
+				return;
+			}
+
+			Add(player);
+		}
+		else
+		{
+			Remove(player, player);
+		}
+	}
+
+	public void Add(Player player)
+	{
+		_active.add(player);
+
+		int level = getLevel(player);
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "Stealth: " + F.oo("Enabled", true)));
+
+		//Conditions
+		Factory.Condition().Factory().Cloak(GetName(), player, player, 120000, false, true);
+		Factory.Condition().Factory().Slow(GetName(), player, player, 120000, 3-level, false, false, false, true);
+
+		//Sound
+		player.getWorld().playSound(player.getLocation(), Sound.BLAZE_BREATH, 0.5f, 0.5f);
+
+		//Effect
+		UtilParticle.PlayParticle(ParticleType.LARGE_SMOKE, player.getLocation(), 
+				(float)(Math.random() - 0.5), (float)(Math.random() * 1.4), (float)(Math.random() - 0.5), 0, 10,
+				ViewDist.MAX, UtilServer.getPlayers());
+	}
+
+	public void Remove(Player player, LivingEntity source)
+	{
+		_active.remove(player);
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "Stealth: " + F.oo("Disabled", false)));
+
+		//Conditions
+		Factory.Condition().EndCondition(player, null, GetName());
+
+		//Effect
+		UtilParticle.PlayParticle(ParticleType.LARGE_SMOKE, player.getLocation(), 
+				(float)(Math.random() - 0.5), (float)(Math.random() * 1.4), (float)(Math.random() - 0.5), 0, 10,
+				ViewDist.MAX, UtilServer.getPlayers());
+	}
+
+	@EventHandler
+	public void EndProx(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.FAST)
+			return;
+
+		for (Player cur : GetUsers())
+		{
+			int level = getLevel(cur);
+			if (level == 0)		continue;
+
+			//Proximity Decloak
+			if (_active.contains(cur)) 	
+				for (Player other : cur.getWorld().getPlayers())
+				{
+					if (other.equals(cur))
+						continue;
+
+					if (UtilMath.offset(cur, other) > 8 - 2*level)
+						continue;
+
+					if (!Factory.Relation().canHurt(cur, other))
+						continue;
+
+					Remove(cur, other);
+					break;
+				}
+		}
+	}
+
+	@EventHandler 
+	public void EndInteract(PlayerInteractEvent event)
+	{
+		Player player = event.getPlayer();
+
+		if (!_active.contains(player))
+			return;
+
+		Remove(player, player);
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void EndDamage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+
+		Player damagee = event.GetDamageePlayer();
+		if (damagee != null)	return;
+		{
+			if (_active.contains(damagee))
+			{
+				Remove(damagee, event.GetDamagerEntity(true));
+			}
+		}
+
+		Player damager = event.GetDamagerPlayer(true);
+		if (damager != null)	return;
+		{
+			if (_active.contains(damager))
+			{
+				Remove(damager, event.GetDamagerEntity(true));
+			}
+		}
+	}
+
+	@EventHandler
+	public void Energy(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		for (Player cur : GetUsers())
+		{
+			if (!_active.contains(cur))
+				continue;
+
+			//Level
+			if (getLevel(cur) == 0)
+			{
+				Remove(cur, null);	
+				continue;
+			}
+
+			//Silence
+			if (Factory.Condition().IsSilenced(cur, null))
+			{
+				Remove(cur, null);
+				continue;
+			}
+
+			if (!Factory.Energy().Use(cur, GetName(), 0.9 - (0.1 * getLevel(cur)), true, false))
+			{
+				Remove(cur, null);
+				continue;
+			}
+		}	
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_active.remove(player);
+		Factory.Condition().EndCondition(player, ConditionType.CLOAK, GetName());
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Assassin/ViperStrikes.java

@@ -0,0 +1,65 @@
+package mineplex.minecraft.game.classcombat.Skill.Assassin;
+
+import org.bukkit.Sound;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+import mineplex.core.common.util.UtilGear;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+
+public class ViperStrikes extends Skill
+{
+	public ViperStrikes(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Your attacks give",
+				"enemies Poison 1",
+				"for #2#2 seconds."
+				});
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void Damage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+
+		if (event.GetCause() != DamageCause.ENTITY_ATTACK)
+			return;
+
+		Player damager = event.GetDamagerPlayer(false);
+		if (damager == null)	return;
+		
+		if (!UtilGear.isWeapon(damager.getItemInHand()))
+			return;
+
+		int level = getLevel(damager);
+		if (level == 0)		return;
+
+		LivingEntity damagee = event.GetDamageeEntity();
+		if (damagee == null)	return;
+		
+		Factory.Damage().NewDamageEvent(damagee, damager, null, DamageCause.CUSTOM, 0, false, true, true, damager.getName(), GetName());
+		damagee.addPotionEffect(new PotionEffect(PotionEffectType.POISON, 20 * (2 + (2 * level)), 0));
+		
+		//Sound
+		damager.getWorld().playSound(damager.getLocation(), Sound.SPIDER_IDLE, 1f, 2f);
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Brute/BlockToss.java

@@ -0,0 +1,470 @@
+package mineplex.minecraft.game.classcombat.Skill.Brute;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map.Entry;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Effect;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.FallingBlock;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityChangeBlockEvent;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.event.entity.ItemSpawnEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.world.ChunkUnloadEvent;
+
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilAction;
+import mineplex.core.common.util.UtilBlock;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilEvent;
+import mineplex.core.common.util.UtilEvent.ActionType;
+import mineplex.core.common.util.UtilGear;
+import mineplex.core.common.util.UtilMath;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.projectile.IThrown;
+import mineplex.core.projectile.ProjectileUser;
+import mineplex.core.recharge.Recharge;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.SkillCharge;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.Skill.event.BlockTossExpireEvent;
+import mineplex.minecraft.game.classcombat.Skill.event.BlockTossLandEvent;
+import mineplex.minecraft.game.classcombat.Skill.event.SkillEvent;
+import mineplex.minecraft.game.classcombat.Skill.event.SkillTriggerEvent;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+
+public class BlockToss extends SkillCharge implements IThrown
+{
+	private HashMap<Player, FallingBlock> _holding = new HashMap<Player, FallingBlock>();
+	private HashMap<FallingBlock, Player> _falling = new HashMap<FallingBlock, Player>();
+
+	private Material[] _blacklist = new Material[]
+			{
+				Material.TNT,
+				Material.IRON_DOOR,
+				Material.IRON_DOOR_BLOCK,
+				Material.WOOD_DOOR,
+				Material.WOODEN_DOOR,
+				Material.ENCHANTMENT_TABLE,
+				Material.CHEST,
+				Material.FURNACE,
+				Material.BURNING_FURNACE,
+				Material.WORKBENCH,
+				Material.WATER,
+				Material.STATIONARY_WATER,
+				Material.LAVA,
+				Material.STATIONARY_LAVA,
+				Material.STONE_PLATE,
+				Material.WOOD_PLATE,
+				Material.GOLD_PLATE,
+				Material.IRON_PLATE,
+				Material.STONE_BUTTON,
+				Material.WOOD_BUTTON,
+				Material.LEVER,
+				Material.BARRIER,
+			};
+
+	public BlockToss(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels,
+				0.01f, 0.005f);
+
+		SetDesc(new String[] 
+				{
+				"Hold Block to pick up a block,",
+				"Release Block to throw it,",
+				"dealing up to #6#1 damage.",
+				"",
+				GetChargeString(),
+				});
+	}
+	
+	@Override
+	public String GetRechargeString()
+	{
+		return "Recharge: " + "1.5 Seconds";
+	}
+
+	@EventHandler
+	public void Grab(PlayerInteractEvent event)
+	{	 	
+		Player player = event.getPlayer();
+
+		if (!UtilEvent.isAction(event, ActionType.R_BLOCK))
+			return;
+
+		if (!UtilGear.isSword(player.getItemInHand()))
+			return;
+		
+		//Check Allowed
+		SkillTriggerEvent trigger = new SkillTriggerEvent(player, GetName(), GetClassType());
+		Bukkit.getServer().getPluginManager().callEvent(trigger);
+		
+		if (trigger.IsCancelled())
+			return;
+		
+		if (_holding.containsKey(player))
+			return;
+
+		//Level
+		int level = getLevel(player);
+		if (level == 0)		return;
+		
+		//Recharge
+		if (!Recharge.Instance.usable(player, GetName()))
+			return;
+		
+		//Water
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return;
+		}
+	
+		Block grab = event.getClickedBlock();
+
+		//Blacklist
+		for (Material mat : _blacklist)
+			if (mat == grab.getType())
+			{
+				UtilPlayer.message(player, F.main("Game", "You cannot grab this block."));
+				return;
+			}
+		//Usable
+		if (UtilBlock.usable(grab))
+			return;
+
+		//Door and Banner
+		if (grab.getRelative(BlockFace.UP).getTypeId() == 64 || grab.getRelative(BlockFace.UP).getTypeId() == 71 || grab.getRelative(BlockFace.UP).getType() == Material.STANDING_BANNER)
+		{
+			UtilPlayer.message(player, F.main(GetName(), "You cannot grab this block."));
+			return;
+		}
+
+		// Ladder and beacon grabs
+		if (grab.getType() == Material.LADDER || grab.getType() == Material.BEACON  || grab.getType() == Material.WEB || grab.getType() == Material.STANDING_BANNER || grab.getType() == Material.WALL_BANNER)		
+		{
+			UtilPlayer.message(player, F.main(GetName(), "You cannot grab this block."));
+			return;
+		}
+
+		//TrapDoor or ladder
+		for (int x = -1; x <= 1; x++)
+		{
+		    for (int z = -1; z <= 1; z++)
+		    {
+		        if (x != z && (z == 0 || x == 0))
+		        {
+		            Block block = grab.getRelative(x, 0, z);
+		            
+		            if (block.getType() == Material.TRAP_DOOR || block.getType() == Material.LADDER)
+		            {
+		                UtilPlayer.message(player, F.main(GetName(), "You cannot grab this block."));
+		                return;
+		            }
+		        }
+		    }
+		}
+		
+		if (Factory.BlockRestore().contains(grab))
+		{
+			UtilPlayer.message(player, F.main(GetName(), "You cannot grab this block."));
+			return;
+		}
+
+		//Block to Item
+		FallingBlock block  = player.getWorld().spawnFallingBlock(player.getEyeLocation(), event.getClickedBlock().getType(), event.getClickedBlock().getData());
+		block.setDropItem(false);
+
+		//Action
+		player.eject();
+		player.setPassenger(block);
+		_holding.put(player, block);
+		_falling.put(block, player);
+
+		//Effect
+		player.getWorld().playEffect(event.getClickedBlock().getLocation(), Effect.STEP_SOUND, block.getMaterial().getId());
+	}
+	
+	@EventHandler
+	public void Damage(EntityDamageByEntityEvent event)
+	{
+		Entity vehicle = event.getEntity().getVehicle();
+		
+		if (_holding.containsKey(vehicle))
+		{
+			Player attacker = (Player) event.getDamager();
+			
+			//Forward Damage
+			Factory.Damage().NewDamageEvent((Player) vehicle, attacker, Factory.Damage().GetProjectile(event),
+					event.getCause(), event.getDamage(),  true, false, false, null, null, event.isCancelled());
+		}
+	}
+	
+	@EventHandler
+	public void Throw(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		HashSet<Player> voidSet = new HashSet<Player>();
+		HashSet<Player> throwSet = new HashSet<Player>();
+
+		for (Player cur : _holding.keySet())
+		{
+			if (cur.getPassenger() == null)
+			{
+				voidSet.add(cur);
+				continue;	
+			}
+
+			if (_holding.get(cur).getVehicle() == null)
+			{
+				voidSet.add(cur);
+				continue;	
+			}
+
+			if (!_holding.get(cur).getVehicle().equals(cur))
+			{
+				voidSet.add(cur);
+				continue;	
+			}
+
+			//Throw
+			if (!cur.isBlocking())
+				throwSet.add(cur);
+
+			//Charged Tick
+			Charge(cur);
+		}
+
+		for (Player cur : voidSet)
+		{
+			FallingBlock block = _holding.remove(cur);
+			_charge.remove(cur);
+			block.remove();
+		}
+
+		for (Player cur : throwSet)
+		{
+			Recharge.Instance.recharge(cur, GetName());
+			Recharge.Instance.use(cur, GetName(), 1500, false, true);
+			
+			FallingBlock block = _holding.remove(cur);
+			float charge = _charge.remove(cur);
+			
+			//Throw 
+			cur.eject();
+			double mult = Math.max(0.4, charge * 2);
+			
+			Material mat = Material.getMaterial(block.getBlockId());
+			
+			//Action
+			UtilAction.velocity(block, cur.getLocation().getDirection(), mult, false, 0, 0, 1, true);
+			Factory.Projectile().AddThrow(block, cur, this, -1, true, true, true, true, 
+					null, 0, 0, null, 0, UpdateType.FASTEST, 1.2f);
+			
+			// Generic Event
+			UtilServer.getServer().getPluginManager().callEvent(new SkillEvent(cur, GetName(), ClassType.Brute));
+		}
+	}
+	
+	@EventHandler(priority = EventPriority.HIGH)
+	public void Knockback(CustomDamageEvent event)
+	{
+		Player damager = event.GetDamagerPlayer(true);
+		if (damager == null)	return;
+		
+		if (event.GetReason() == null || !event.GetReason().equals(GetName()))
+			return;
+		
+		event.AddKnockback(GetName(), 1.5d);
+	}
+
+	@Override
+	public void Collide(LivingEntity target, Block block, ProjectileUser data) 
+	{
+		if (target == null)
+			return;
+
+		int level = getLevel(data.getThrower());
+		
+		//Damage Event
+		Factory.Damage().NewDamageEvent(target, data.getThrower(), null,
+				DamageCause.CUSTOM, data.getThrown().getVelocity().length() * (3 + 0.6 * level), true, true, false,
+				UtilEnt.getName(data.getThrower()), GetName());
+
+		//Block to Item
+		if (data.getThrown() instanceof FallingBlock)
+		{
+			FallingBlock thrown = (FallingBlock) data.getThrown();
+
+			FallingBlock newThrown  = data.getThrown().getWorld().spawnFallingBlock(data.getThrown().getLocation(), thrown.getMaterial(), thrown.getBlockData());
+			newThrown.setDropItem(false);
+
+			//Remove Old
+			_falling.remove(thrown);
+			thrown.remove();
+
+			//Add New
+			if (data.getThrower() instanceof Player)
+				_falling.put(newThrown, (Player)data.getThrower());
+		}
+	}
+
+	@Override
+	public void Idle(ProjectileUser data) 
+	{
+
+	}
+
+	@Override
+	public void Expire(ProjectileUser data) 
+	{
+
+	}	
+
+	@EventHandler
+	public void blockSolidify(EntityChangeBlockEvent event)
+	{
+		if (_falling.containsKey(event.getEntity()))
+		{
+			event.setCancelled(true);
+			
+			createBlock((FallingBlock)event.getEntity(), event.getBlock());
+			
+			_falling.remove(event.getEntity());
+		}
+	}
+	
+	@EventHandler
+	public void CreateBlock(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		Iterator<FallingBlock> fallIter = _falling.keySet().iterator();
+		
+		while (fallIter.hasNext())
+		{
+			FallingBlock fall = fallIter.next();
+			
+			if (!fall.isDead() && fall.isValid())
+				continue;
+			
+			fallIter.remove();
+
+			Block block = fall.getLocation().getBlock();
+
+			// Call and trigger block expiry event
+			BlockTossExpireEvent expireEvent = new BlockTossExpireEvent(block);
+			Bukkit.getServer().getPluginManager().callEvent(expireEvent);
+
+			if (!expireEvent.isCancelled()) createBlock(fall, block);
+		}
+	}
+	
+	public void createBlock(FallingBlock fall, Block block)
+	{
+		if (!UtilBlock.airFoliage(block))
+			return;
+		
+		int id = fall.getBlockId();
+		
+		if (id == 12)	id = Material.SANDSTONE.getId();
+		if (id == 13)	id = Material.STONE.getId();
+		
+		//Block Replace
+		Factory.BlockRestore().add(block, id, (byte)0, 10000);
+
+		//Effect
+		block.getWorld().playEffect(block.getLocation(), Effect.STEP_SOUND, block.getTypeId());
+	}
+
+	@EventHandler
+	public void onBlockLand(EntityChangeBlockEvent event)
+	{
+		if (event.getEntity() instanceof FallingBlock)
+		{
+			if (!event.getBlock().getType().isSolid())	// Falling block is landing and turning block from air to type
+			{
+				BlockTossLandEvent landEvent = new BlockTossLandEvent(event.getBlock(), ((FallingBlock) event.getEntity()));
+				Bukkit.getServer().getPluginManager().callEvent(landEvent);
+
+				if (landEvent.isCancelled())
+				{
+					event.setCancelled(true);
+				}
+			}
+		}
+	}
+
+	@EventHandler
+	public void ItemSpawn(ItemSpawnEvent event)
+	{
+		int id = event.getEntity().getItemStack().getTypeId();
+
+		if (
+				id != 1 &&
+						id != 2 &&
+						id != 3 &&
+						id != 4 &&
+						id != 12 &&
+						id != 13 &&
+						id != 80)
+			return;
+
+		for (FallingBlock block : _falling.keySet())
+			if (UtilMath.offset(event.getEntity().getLocation(), block.getLocation()) < 1)
+				event.setCancelled(true);
+	}
+	
+	@EventHandler
+	public void expireUnload(ChunkUnloadEvent event)
+	{
+		Iterator<Entry<FallingBlock, Player>> iterator = _falling.entrySet().iterator();
+		while (iterator.hasNext())
+		{
+			Entry<FallingBlock, Player> entry = iterator.next();
+			FallingBlock key = entry.getKey();
+			
+			if (key.getLocation().getChunk().equals(event.getChunk()))
+			{
+				key.remove();
+				iterator.remove();
+			}
+		}
+	}
+	
+	@Override
+	public void ChunkUnload(ProjectileUser data)
+	{
+		data.getThrown().remove();
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		if (_holding.containsKey(player))
+		{
+			player.eject();
+		}
+		
+		_holding.remove(player);
+		_charge.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Brute/Bloodlust.java

@@ -0,0 +1,149 @@
+package mineplex.minecraft.game.classcombat.Skill.Brute;
+
+import java.util.Map;
+import java.util.WeakHashMap;
+
+import org.bukkit.Sound;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilMath;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.core.combat.event.CombatDeathEvent;
+
+public class Bloodlust extends Skill
+{
+
+	private final Map<Player, Long> _time = new WeakHashMap<>();
+	private final Map<Player, Integer> _str = new WeakHashMap<>();
+
+	public Bloodlust(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Killing an enemy within 4#4 blocks",
+				"you go into a Bloodlust,",
+				"receiving Speed 1 and",
+				"Strength 1 for #4#2 seconds.",
+				"You also heal #0#1 health.",
+				"",
+				"Bloodlust can stack up to 3 times,",
+				"boosting the level of Speed by 1."
+				});
+	}
+
+	@EventHandler(priority = EventPriority.LOWEST)
+	public void PlayerDeath(CombatDeathEvent event)
+	{
+		if (!(event.GetEvent().getEntity() instanceof Player))
+			return;
+
+		if (event.GetLog().GetKiller() == null || !event.GetLog().GetKiller().IsPlayer())
+			return;
+		
+		Player player = UtilPlayer.searchExact(event.GetLog().GetKiller().GetName());
+		if (player == null)
+			return;
+
+		if (!Factory.Relation().canHurt(player, (Player)event.GetEvent().getEntity()))
+			return;
+
+		if (player.equals(event.GetEvent().getEntity()))
+			return;
+
+		//Level
+		int level = getLevel(player);
+		if (level == 0)		
+			return;
+		
+		//Offset
+		double distance = 4 + (4 * level);
+		if (UtilMath.offset(event.GetEvent().getEntity().getLocation(), player.getLocation()) > distance)
+			return;
+
+		//Strength
+		int str = 0;
+		if (_str.containsKey(player))
+			str = _str.get(player) + 1;
+		str = Math.min(str, 2);
+		_str.put(player, str);
+
+		//Time
+		double dur = 4 + (2 * level); 
+		_time.put(player, (System.currentTimeMillis() + (long)(dur*1000)));
+
+		//Condition
+		Factory.Condition().Factory().Speed(GetName(), player, event.GetEvent().getEntity(), dur, str, false, true, true);
+		Factory.Condition().Factory().Strength(GetName(), player, event.GetEvent().getEntity(), dur, 0, false, true, true);
+
+		UtilPlayer.health(player, level);
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You entered " + F.skill(GetName(level)) + " at " + F.elem("Level " + (str+1)) + "."));
+
+		//Effect
+		player.getWorld().playSound(player.getLocation(), Sound.ZOMBIE_PIG_ANGRY, 2f, 0.6f);
+
+	}
+
+	@EventHandler
+	public void Update(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.FAST)
+			return;
+
+		for (Player cur : GetUsers())
+			Expire(cur);
+	}
+
+	public boolean Expire(Player player)
+	{
+		if (!_time.containsKey(player))
+			return false;
+
+		if (System.currentTimeMillis() > _time.get(player))
+		{
+			int str = _str.remove(player);
+			UtilPlayer.message(player, F.main(GetClassType().name(), "Your " + F.skill(GetName(getLevel(player))) + " has ended at " + F.elem("Level " + (str+1)) + "."));
+			_time.remove(player);
+
+			return true;
+		}
+
+		return false;
+	}
+
+	@EventHandler
+	public void Particle(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		for (Entity ent : _str.keySet())
+		{
+			UtilParticle.PlayParticleToAll(ParticleType.RED_DUST, ent.getLocation(),
+					(float)(Math.random() - 0.5), 0.2f + (float)Math.random(), (float)(Math.random() - 0.5), 0, _str.get(ent) * 2,
+					ViewDist.NORMAL);
+		}
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_time.remove(player);
+		_str.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Brute/Brute.java

@@ -0,0 +1,53 @@
+package mineplex.minecraft.game.classcombat.Skill.Brute;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityShootBowEvent;
+
+import mineplex.core.energy.event.EnergyEvent;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.Skill.Global.BowDeficiencySkill;
+
+public class Brute extends BowDeficiencySkill
+{
+	public Brute(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+					"You take 8 more damage from enemy attacks",
+					"to counter the strength of Diamond Armor.",
+					"",
+					"25% reduction in Arrow Velocity."
+				});
+	}
+	
+	@EventHandler(priority = EventPriority.HIGH)
+	public void Damage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+
+		Player damagee = event.GetDamageePlayer();
+		if (damagee == null)	return;
+
+		int level = getLevel(damagee);
+		if (level == 0)		return;
+
+		//Damage
+		event.AddMod(damagee.getName(), GetName(), 0, false);
+		event.SetBrute();
+	}
+	
+	@EventHandler
+	public void CancelEnergy(EnergyEvent event)
+	{
+		if (getLevel(event.GetPlayer()) > 0)
+			event.setCancelled(true);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Brute/Colossus.java

@@ -0,0 +1,69 @@
+package mineplex.minecraft.game.classcombat.Skill.Brute;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class Colossus extends Skill
+{
+	public Colossus(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"You are so huge that you take",
+				"33% less knockback from attacks",
+				"and while sneaking you take no",
+				"knockback."
+				});
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void Damage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+		{
+			return;
+		}
+
+		Player damagee = event.GetDamageePlayer(), damager = event.GetDamagerPlayer(true);
+
+		if (damagee == null || damager == null)
+		{
+			return;
+		}
+
+		int damageeeLevel = getLevel(damagee), damagerLevel = getLevel(damager);
+		DamageCause cause = event.GetCause();
+
+		if (damageeeLevel > 0 && (cause == DamageCause.ENTITY_ATTACK || cause == DamageCause.PROJECTILE))
+		{
+			if (damagee.isSneaking())
+			{
+				event.SetKnockback(false);
+			}
+			else
+			{
+				event.AddKnockback(GetName(), 0.66);
+			}
+		}
+
+		if (damagerLevel > 0)
+		{
+			event.AddMod(GetName(), -0.5);
+		}
+	}
+
+	@Override
+	public void Reset(Player player)
+	{
+
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Brute/CripplingBlow.java

@@ -0,0 +1,71 @@
+package mineplex.minecraft.game.classcombat.Skill.Brute;
+
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.core.common.util.UtilGear;
+import mineplex.core.common.util.UtilServer;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.Skill.event.SkillEvent;
+
+public class CripplingBlow extends Skill
+{
+	public CripplingBlow(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Your powerful axe attacks give",
+				"targets Slow 2 for 1.5 second,",
+				"as well as 25% less knockback."
+				});
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void Damage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+		
+		if (event.GetCause() != DamageCause.ENTITY_ATTACK)
+			return;
+
+		LivingEntity damagee = event.GetDamageeEntity();
+		if (damagee == null)	return;
+
+		//Damager
+		Player damager = event.GetDamagerPlayer(false);
+		if (damager == null)	return;
+
+		//Maul
+		if (!UtilGear.isAxe(damager.getItemInHand()))
+			return;
+
+		//Level
+		int level = getLevel(damager);
+		if (level == 0)			return;
+
+		//Stun
+		Factory.Condition().Factory().Slow(GetName(), damagee, damager, 0.5 + 0.5 * 1, 1, false, true, false, true);
+
+		//Damage
+		event.AddMod(damager.getName(), GetName(), 0, true);
+		event.AddKnockback(GetName(), 0.75);
+		
+		//Event
+		UtilServer.getServer().getPluginManager().callEvent(new SkillEvent(damager, GetName(), ClassType.Brute, damagee));
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Brute/DwarfToss.java

@@ -0,0 +1,395 @@
+package mineplex.minecraft.game.classcombat.Skill.Brute;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.bukkit.EntityEffect;
+import org.bukkit.Material;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+import org.spigotmc.event.entity.EntityDismountEvent;
+
+import mineplex.core.Managers;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilAction;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilMath;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.core.visibility.VisibilityManager;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.Skill.event.SkillEvent;
+import mineplex.minecraft.game.classcombat.Skill.event.SkillTriggerEvent;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+
+public class DwarfToss extends SkillActive
+{
+
+	private final Set<Player> _used = new HashSet<>();
+	private final Map<Player, LivingEntity> _holding = new HashMap<>();
+	private final Map<Player, Long> _time = new HashMap<>();
+
+	public DwarfToss(SkillFactory skills, String name, ClassType classType, SkillType skillType,
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Hold Block to pick up target player.",
+				"Release Block to throw target player.",
+				"",
+				"Players you are holding cannot harm",
+				"you, or be harmed by others.",
+				"",
+				"Takes 2.5 seconds to fully charge."
+				});
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		return !_used.contains(player);
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You failed " + F.skill(GetName()) + "."));
+	}
+
+	@EventHandler
+	public void Miss(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		_used.clear();
+	}
+
+	public boolean CanUse(Player player)
+	{
+		int level = getLevel(player);
+		if (level == 0)		return false;
+		
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+		
+		//Check Material
+		if (player.getItemInHand() != null)
+			if (!_itemSet.contains(player.getItemInHand().getType()))
+				return false;
+
+		//Check Allowed
+		SkillTriggerEvent trigger = new SkillTriggerEvent(player, GetName(), GetClassType());
+		UtilServer.getServer().getPluginManager().callEvent(trigger);
+		if (trigger.IsCancelled())
+			return false;
+
+		//Check Energy/Recharge
+		return EnergyRechargeCheck(player, level);
+	}
+	
+	//getEntity is the vehicle
+	@EventHandler
+	public void PreventDismount(EntityDismountEvent event)
+	{
+		if (event.isCancelled())
+			return;
+		
+		if (!(event.getDismounted() instanceof Player))
+			return;
+		
+		if (!(event.getEntity() instanceof Player))
+			return;
+		
+		if (event.getDismounted().equals(_holding.get(event.getEntity())))
+		{
+			event.setCancelled(true);
+		}
+	}
+
+	@EventHandler
+	public void Grab(PlayerInteractEntityEvent event)
+	{
+		if (event.isCancelled())
+			return;
+		
+		Player player = event.getPlayer();
+
+		//Level
+		int level = getLevel(player);
+		if (level == 0)			return;
+
+		//Set Used
+		_used.add(player);
+
+		if (!CanUse(player))
+			return;
+
+		if (!(event.getRightClicked() instanceof LivingEntity))
+			return;
+
+		LivingEntity target = (LivingEntity)event.getRightClicked();
+
+		if (target instanceof Player)
+		{
+			if (UtilPlayer.isSpectator(target))
+			{
+				UtilPlayer.message(player, F.main(GetClassType().name(), F.name(((Player)target).getName()) + " is not attackable."));
+				return;
+			}
+		}
+
+		//Distance
+		if (UtilMath.offset(player.getLocation(), target.getLocation()) > 4)
+		{
+			UtilPlayer.message(player, F.main(GetClassType().name(), F.name(UtilEnt.getName(target)) + " is too far away."));
+			return;
+		}	
+
+		//Hold Loop
+		if (target instanceof Player && _holding.containsKey(target))
+		{
+			if (_holding.get(target).equals(player))
+			{
+				UtilPlayer.message(player, F.main(GetClassType().name(), F.name(target.getName()) + " is already holding you."));
+				return;
+			}
+		}
+
+		if (_holding.containsValue(target))
+		{
+			UtilPlayer.message(player, F.main(GetClassType().name(), F.name(UtilEnt.getName(target)) + " is already being held."));
+			return;
+		}
+
+		//Obstruct Check
+		/*
+		if (target instanceof Player)
+			for (int i = 0 ; i < 10 ; i++)			
+			{
+				Block block = player.getWorld().getBlockAt(player.getEyeLocation()
+						.add((target.getEyeLocation().toVector().subtract(player.getEyeLocation().toVector())).multiply(i/10d)));
+
+				if (!UtilBlock.airFoliage(block))
+				{
+					UtilPlayer.message(player, F.main(GetClassType().name(), F.name(((Player)target).getName()) + " is obstructed by blocks."));
+					return;
+				}
+			}
+		*/
+
+		//Action
+		target.leaveVehicle();
+		player.eject();
+		player.setPassenger(target);
+		_holding.put(player, target);
+		_time.put(player, System.currentTimeMillis());
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You picked up " + F.name(UtilEnt.getName(target)) + " with " + F.skill(GetName()) + "."));
+		UtilPlayer.message(target, F.main(GetClassType().name(), F.name(player.getName()) + " grabbed you with " + F.skill(GetName()) + "."));
+
+		//Hide!
+		if (target instanceof Player)
+		{
+			Managers.require(VisibilityManager.class).hidePlayer(player, (Player) target, "Dwarf Toss Pickup");
+		}
+		
+		//Event
+		UtilServer.getServer().getPluginManager().callEvent(new SkillEvent(player, GetName(), ClassType.Brute, target));
+
+		//Effect
+		target.playEffect(EntityEffect.HURT);
+	}
+
+
+	@EventHandler(priority = EventPriority.LOWEST)
+	public void DamageePassenger(CustomDamageEvent event) 
+	{
+		if (event.IsCancelled())
+			return;
+
+		LivingEntity damagee = event.GetDamageeEntity();
+		if (damagee == null)	return;
+
+		if (!_holding.containsValue(damagee))
+			return;
+
+		event.SetCancelled(GetName());
+	}
+
+	@EventHandler(priority = EventPriority.LOW)
+	public void DamagerPassenger(CustomDamageEvent event) 
+	{
+		if (event.IsCancelled())
+			return;
+
+		Player damagee = event.GetDamageePlayer();
+		if (damagee == null)	return;
+
+		LivingEntity damager = event.GetDamagerPlayer(true);
+		if (damager == null)	return;
+
+		if (!_holding.containsKey(damagee))
+			return;
+
+		if (!_holding.get(damagee).equals(damager))
+			return;
+
+		//Inform
+		UtilPlayer.message(damager, F.main(GetClassType().name(), "You cannot attack " + F.name(damagee.getName()) + "."));
+
+		event.SetCancelled(GetName());
+	}
+
+	@EventHandler
+	public void ThrowExpire(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		Set<Player> voidSet = new HashSet<>();
+		Set<Player> throwSet = new HashSet<>();
+
+		for (Player cur : _holding.keySet())
+		{
+			if (cur.getPassenger() == null)
+			{
+				voidSet.add(cur);
+				continue;	
+			}
+
+			if (_holding.get(cur).getVehicle() == null)
+			{
+				voidSet.add(cur);
+				continue;	
+			}
+
+			if (!_holding.get(cur).getVehicle().equals(cur))
+			{
+				voidSet.add(cur);
+				continue;	
+			}
+
+			//Expire 
+			if (!UtilPlayer.isBlocking(cur) || System.currentTimeMillis() - _time.get(cur) > 5000)
+			{
+				throwSet.add(cur);
+			}			
+		}
+
+		VisibilityManager vm = Managers.require(VisibilityManager.class);
+		
+		for (Player cur : voidSet)
+		{
+			LivingEntity target = _holding.remove(cur);
+			_time.remove(cur);
+
+			UtilPlayer.message(cur, F.main(GetClassType().name(), F.name(UtilEnt.getName(target)) + " escaped your " + F.skill(GetName()) + "."));
+			
+			//Show!
+			if (target instanceof Player)
+			{
+				vm.showPlayer(cur, (Player) target, "Dwarf Toss Pickup");
+			}
+		}
+
+		for (final Player cur : throwSet)
+		{
+			final LivingEntity target = _holding.remove(cur);			
+			long time = _time.remove(cur);
+			
+			//Time Reduce
+			double timeScale = 1;
+			long chargeTime = 2500;
+
+			if (time < chargeTime)
+			{
+				timeScale = Math.max(0.25, ((double)time/(double) chargeTime));
+			}
+			
+			//Show!
+			if (target instanceof Player)
+			{
+				vm.showPlayer(cur, (Player) target, "Dwarf Toss Pickup");
+			}
+			
+			//Throw
+			cur.eject();
+			target.leaveVehicle();
+			final double mult = (1.8) * timeScale;
+			
+			//Protection
+			Factory.Condition().Factory().Invulnerable(GetName(), target, target, 1.25, false, false);
+			
+			//Delay
+			Factory.runSyncLater(() ->
+			{
+				UtilAction.velocity(target, cur.getLocation().getDirection(), mult, false, 0, 0.2, 1.2, true);
+
+				//Condition
+				Factory.Condition().Factory().Falling(GetName(), target, cur, 10, false, true);
+
+				//Effect
+				target.playEffect(EntityEffect.HURT);
+			}, 5);
+
+			//Inform
+			UtilPlayer.message(cur, F.main(GetClassType().name(), "You threw " + F.name(UtilEnt.getName(target)) + " with " + F.skill(GetName()) + "."));
+			UtilPlayer.message(target, F.main(GetClassType().name(), F.name(cur.getName()) + " threw you with " + F.skill(GetName()) + "."));
+		}
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		player.eject();
+		player.leaveVehicle();
+		
+		VisibilityManager vm = Managers.require(VisibilityManager.class);
+		
+		for (Player cur : _holding.keySet())
+		{
+			if (cur.equals(player) || _holding.get(cur).equals(player))
+			{
+				cur.eject();
+				
+				LivingEntity target = _holding.remove(cur);
+				_time.remove(cur);
+				
+				//Show!
+				if (target instanceof Player)
+				{
+					vm.showPlayer(cur, (Player) target, "Dwarf Toss Pickup");
+				}
+			}
+		}
+		
+		_holding.remove(player);
+		_time.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Brute/FleshHook.java

@@ -0,0 +1,192 @@
+package mineplex.minecraft.game.classcombat.Skill.Brute;
+
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+
+import mineplex.core.common.util.UtilEnt;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.core.common.util.F;
+import mineplex.core.itemstack.ItemStackFactory;
+import mineplex.core.projectile.IThrown;
+import mineplex.core.projectile.ProjectileUser;
+import mineplex.core.recharge.Recharge;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.common.util.UtilAction;
+import mineplex.core.common.util.UtilAlg;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.minecraft.game.classcombat.Skill.SkillActiveCharge;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.Skill.event.SkillEvent;
+import mineplex.minecraft.game.classcombat.Skill.event.SkillTriggerEvent;
+
+public class FleshHook extends SkillActiveCharge implements IThrown
+{
+	public FleshHook(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray,
+				0.01f, 0.005f);
+
+		SetDesc(new String[] 
+				{
+				"Hold Block to charge Flesh Hook.",
+				"Release Block to release it.",
+				"",
+				GetChargeString(),
+				"",
+				"If Flesh Hook hits a player, it",
+				"deals up to #5#1 damage, and rips them",
+				"towards you with #1.2#0.3 velocity.",
+				});
+	}
+	
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		//Start Charge 
+		_charge.put(player, 0f);
+	}
+
+	@EventHandler
+	public void ChargeRelease(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		for (Player cur : GetUsers())
+		{
+			//Not Charging
+			if (!_charge.containsKey(cur))
+				continue;
+
+			//Level
+			int level = getLevel(cur);
+			if (level == 0)			return;
+
+			//Add Charge
+			if (UtilPlayer.isBlocking(cur))
+			{
+				Charge(cur);
+			}
+
+			//Release Charge
+			else if (_charge.containsKey(cur))
+			{
+				double charge = _charge.remove(cur);
+
+				//Action
+				Item item = cur.getWorld().dropItem(cur.getEyeLocation().add(cur.getLocation().getDirection()), ItemStackFactory.Instance.CreateStack(131));
+				UtilAction.velocity(item, cur.getLocation().getDirection(), 
+						1 + charge, false, 0, 0.2, 20, false);
+				 
+				Factory.Projectile().AddThrow(item, cur, this, -1, true, true, true, true, 
+						Sound.FIRE_IGNITE, 1.4f, 0.8f, ParticleType.CRIT, UpdateType.TICK, 0.6f, charge);
+				
+				//Inform
+				UtilPlayer.message(cur, F.main(GetClassType().name(), "You used " + F.skill(GetName(level)) + "."));
+
+				//Effect
+				item.getWorld().playSound(item.getLocation(), Sound.IRONGOLEM_THROW, 2f, 0.8f);
+				
+				Recharge.Instance.useForce(cur, GetName(), Recharge(level));
+			}	
+		}
+	}
+
+	@Override
+	public void Collide(LivingEntity target, Block block, ProjectileUser data) 
+	{
+		//Remove
+		double velocity = data.getThrown().getVelocity().length();
+		data.getThrown().remove();
+
+		if (!(data.getThrower() instanceof Player))
+			return;
+
+		Player player = (Player)data.getThrower();
+
+		//Level
+		int level = getLevel(player);
+		if (level == 0)				return;
+
+		if (target == null)
+			return;
+		
+		SkillTriggerEvent triggerEvent = new SkillTriggerEvent(player , GetName(), GetClassType(), target);
+		UtilServer.getServer().getPluginManager().callEvent(triggerEvent);
+		
+		if (triggerEvent.IsCancelled()) return;
+
+		//Pull
+		UtilAction.velocity(target, 
+				UtilAlg.getTrajectory(target.getLocation(), player.getLocation()), 
+				velocity, false, 0, 0.7, 1.2, true);
+		
+		//Condition
+		Factory.Condition().Factory().Falling(GetName(), target, player, 10, false, true);
+
+		//Damage Event
+		Factory.Damage().NewDamageEvent(target, player, null, 
+				DamageCause.CUSTOM, (5 + level) * data.getCharge(), false, true, false,
+				player.getName(), GetName());
+		
+
+		//Event
+		if (target != null)
+			UtilServer.getServer().getPluginManager().callEvent(new SkillEvent(player, GetName(), ClassType.Brute, target));
+		
+		//Inform
+		UtilPlayer.message(target, F.main(GetClassType().name(), F.name(player.getName()) + " pulled you with " + F.skill(GetName(level)) + "."));
+	}
+
+	@Override
+	public void Idle(ProjectileUser data) 
+	{
+		//Remove
+		data.getThrown().remove();
+	}
+
+	@Override
+	public void Expire(ProjectileUser data) 
+	{
+		//Remove
+		data.getThrown().remove();
+	}
+	
+	@Override
+	public void ChunkUnload(ProjectileUser data)
+	{
+		data.getThrown().remove();
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Brute/Intimidation.java

@@ -0,0 +1,129 @@
+package mineplex.minecraft.game.classcombat.Skill.Brute;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Color;
+import org.bukkit.Location;
+import org.bukkit.Sound;
+import org.bukkit.craftbukkit.v1_8_R3.inventory.CraftInventoryCrafting;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.player.PlayerDropItemEvent;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilGear;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilTime;
+import mineplex.core.common.util.particles.ColoredParticle;
+import mineplex.core.common.util.particles.DustSpellColor;
+import mineplex.core.recharge.Recharge;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.Skill.event.SkillTriggerEvent;
+
+public class Intimidation extends Skill
+{
+
+	private final Set<Player> _active = new HashSet<>();
+	private final DustSpellColor _color = new DustSpellColor(Color.PURPLE);
+
+	public Intimidation(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Drop Axe/Sword to Use.",
+				"",
+				"You intimidate nearby enemies;",
+				"Enemies within #10#1 blocks receive Slow 1.",
+				"",
+				"Lasts for #10#1."
+				});
+	}
+
+	@Override
+	public String GetRechargeString()
+	{
+		return "Recharge: #15#-1.5 Seconds.";
+	}
+
+	@EventHandler
+	public void Use(PlayerDropItemEvent event)
+	{
+		Player player = event.getPlayer();
+
+		if (!(player.getOpenInventory().getTopInventory() instanceof CraftInventoryCrafting))
+		{
+			return;
+		}
+
+		int level = getLevel(player);
+
+		if (level == 0 || !UtilGear.isWeapon(event.getItemDrop().getItemStack()) || _active.contains(player) || !Recharge.Instance.usable(player, GetName(), true))
+		{
+			return;
+		}
+
+		event.setCancelled(true);
+
+		//Check Allowed
+		SkillTriggerEvent trigger = new SkillTriggerEvent(player, GetName(), GetClassType());
+		Bukkit.getServer().getPluginManager().callEvent(trigger);
+
+		if (trigger.IsCancelled())
+		{
+			return;
+		}
+
+		_active.add(player);
+		player.getWorld().playSound(player.getLocation(), Sound.HORSE_SKELETON_HIT, 1, 1);
+		player.sendMessage(F.main("Skill", "You used " + F.skill(GetName(level)) + "."));
+
+		long start = System.currentTimeMillis(), length = 10000 + (level * 1000);
+
+		Factory.runSyncTimer(new BukkitRunnable()
+		{
+			@Override
+			public void run()
+			{
+				if (!_active.contains(player) || UtilTime.elapsed(start, length))
+				{
+					Recharge.Instance.use(player, GetName(), 15000 - (1500 * level), true, false);
+					Reset(player);
+					cancel();
+					return;
+				}
+
+				player.setExp(1 - ((System.currentTimeMillis() - start) / (float) length));
+
+				Location location = player.getLocation();
+
+				new ColoredParticle(ParticleType.RED_DUST, _color, location.clone().add(Math.random() - 0.5, Math.random() + 0.5, Math.random() - 0.5))
+						.display();
+
+				UtilPlayer.getInRadius(location, 10 + level).forEach((other, scale) ->
+				{
+					if (other.equals(player) || !Factory.Relation().canHurt(player, other))
+					{
+						return;
+					}
+
+					Factory.Condition().Factory().Slow(GetName(), other, player, 0.9, 0, false, true, false, true);
+				});
+			}
+		}, 0, 1);
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_active.remove(player);
+		player.setExp(0);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Brute/Overwhelm.java

@@ -0,0 +1,66 @@
+package mineplex.minecraft.game.classcombat.Skill.Brute;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+
+public class Overwhelm extends Skill
+{
+	public Overwhelm(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"For every 1 health you have more",
+				"than your target, you deal 0.25",
+				"bonus damage",
+				"",				
+				"Maximum of #0.5#0.5 bonus damage."
+				});
+	}
+	
+	@EventHandler(priority = EventPriority.HIGH)
+	public void Damage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+		
+		if (event.GetCause() != DamageCause.ENTITY_ATTACK)
+			return;
+
+		LivingEntity damagee = event.GetDamageeEntity();
+		if (damagee == null)	return;
+
+		//Damager
+		Player damager = event.GetDamagerPlayer(false);
+		if (damager == null)	return;
+
+		double diff = (damager.getHealth() - damagee.getHealth()) * 0.25;
+		
+		if (diff <= 0)
+			return;
+		
+		//Level
+		int level = getLevel(damager);
+		if (level == 0)			return;
+		
+		diff = Math.min(diff, 0.5 + 0.5 * level);
+
+		//Damage
+		event.AddMod(damager.getName(), GetName(), diff, true);
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Brute/SeismicSlam.java

@@ -0,0 +1,203 @@
+package mineplex.minecraft.game.classcombat.Skill.Brute;
+
+import java.util.*;
+
+import org.bukkit.*;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.entity.*;
+import org.bukkit.event.*;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.*;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.event.player.*;
+import org.bukkit.util.Vector;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.core.common.util.F;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.common.util.UtilAction;
+import mineplex.core.common.util.UtilAlg;
+import mineplex.core.common.util.UtilBlock;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.common.util.UtilTime;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.Skill.event.SkillEvent;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+
+public class SeismicSlam extends SkillActive
+{
+	public static class SeismicSlamEvent extends PlayerEvent
+	{
+		private static final HandlerList handlers = new HandlerList();
+
+		public static HandlerList getHandlerList()
+		{
+			return handlers;
+		}
+
+		@Override
+		public HandlerList getHandlers()
+		{
+			return getHandlerList();
+		}
+
+		private final List<LivingEntity> _targets;
+
+		public SeismicSlamEvent(Player who, Collection<LivingEntity> targets)
+		{
+			super(who);
+
+			_targets = new ArrayList<>(targets);
+		}
+
+		public List<LivingEntity> getTargets()
+		{
+			return _targets;
+		}
+	}
+
+	private HashMap<LivingEntity, Long> _live = new HashMap<LivingEntity, Long>();
+
+	public SeismicSlam(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Jump up and slam back into the ground.",
+				"Players within #5.5#0.5 Blocks take up to",
+				"#1#1 damage and are smashed away from you.",
+				});
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		//Action
+		Vector vec = player.getLocation().getDirection();
+		if (vec.getY() < 0)
+			vec.setY(vec.getY() * -1);
+		
+		UtilAction.velocity(player, vec, 0.6, false, 0, 0.8, 0.8, true);
+
+		//Record
+		_live.put(player, System.currentTimeMillis());
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You used " + F.skill(GetName(level)) + "."));
+	}
+
+	@EventHandler
+	public void Slam(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		for (Player player : GetUsers())
+		{
+			if (!_live.containsKey(player))
+				continue;
+
+			int level = getLevel(player);
+			if (level == 0)		continue;
+
+			if (!UtilTime.elapsed(_live.get(player), 1000))  
+				continue;
+			
+			if (!UtilTime.elapsed(_live.get(player), 4000) && !UtilEnt.isGrounded(player))
+				continue;
+
+			_live.remove(player);
+
+			//Action
+			HashMap<LivingEntity, Double> targets = UtilEnt.getInRadius(player.getLocation(), 5.5d + 0.5 * level);
+			for (LivingEntity cur : targets.keySet())
+			{
+				if (cur.equals(player))
+					continue;
+
+				//Damage Event
+				Factory.Damage().NewDamageEvent(cur, player, null, 
+						DamageCause.CUSTOM, (1+level) * targets.get(cur) + 0.5, false, true, false,
+						player.getName(), GetName());	
+
+				//Velocity
+				UtilAction.velocity(cur, 
+						UtilAlg.getTrajectory2d(player.getLocation().toVector(), cur.getLocation().toVector()), 
+						0.6 + 2 * targets.get(cur), true, 0, 0.2 + 1.0 * targets.get(cur), 1.4, true);
+				
+				//Condition
+				Factory.Condition().Factory().Falling(GetName(), cur, player, 10, false, true);
+
+				//Inform
+				if (cur instanceof Player)
+					UtilPlayer.message((Player)cur, F.main(GetClassType().name(), F.name(player.getName()) +" hit you with " + F.skill(GetName(level)) + "."));	
+			}
+
+			//Effect
+			player.getWorld().playSound(player.getLocation(), Sound.ZOMBIE_WOOD, 2f, 0.2f);
+			for (Block cur : UtilBlock.getInRadius(player.getLocation(), 4d).keySet())
+				if (UtilBlock.airFoliage(cur.getRelative(BlockFace.UP)) && !UtilBlock.airFoliage(cur))
+					cur.getWorld().playEffect(cur.getLocation(), Effect.STEP_SOUND, cur.getTypeId());
+			
+			//Event
+			UtilServer.getServer().getPluginManager().callEvent(new SkillEvent(player, GetName(), ClassType.Brute, targets.keySet()));
+
+			Bukkit.getPluginManager().callEvent(new SeismicSlamEvent(player, targets.keySet()));
+		}	
+	}
+	
+	@EventHandler(priority = EventPriority.HIGH)
+	public void FallDamage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+		
+		if (event.GetCause() != DamageCause.FALL)
+			return;
+
+		Player damagee = event.GetDamageePlayer();
+		if (damagee == null)	return;
+
+		int level = getLevel(damagee);
+		if (level == 0)		return;
+
+		double amount = Math.min(3, event.GetDamage());
+		
+		//Damage
+		event.AddMod(damagee.getName(), GetName(), -amount, false);
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_live.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Brute/Stampede.java

@@ -0,0 +1,189 @@
+package mineplex.minecraft.game.classcombat.Skill.Brute;
+
+import java.util.WeakHashMap;
+
+import org.bukkit.Sound;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.potion.PotionEffectType;
+
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.common.util.UtilTime;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.Skill.event.SkillEvent;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+
+public class Stampede extends Skill
+{
+	private WeakHashMap<Player, Long> _sprintTime = new WeakHashMap<Player, Long>();
+	private WeakHashMap<Player, Integer> _sprintStr = new WeakHashMap<Player, Integer>();
+
+	public Stampede(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"You slowly build up speed as you",
+				"sprint. You gain a level of Speed",
+				"for every #5#-1 seconds, up to a max",
+				"of Speed 2.",
+				"",
+				"Attacking during stampede deals",
+				"#0.25#0.25 bonus damage,",
+				"and +50% knockback per speed level.",
+				"",
+				"Resets if you take damage."
+				});
+	}
+
+	@EventHandler
+	public void Skill(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.FASTER)
+			return;
+
+		for (Player cur : GetUsers())
+		{
+			int level = getLevel(cur);
+			if (level == 0)		continue;
+
+			//Active - Check for Disable
+			if (_sprintTime.containsKey(cur))
+			{
+				//Stopped
+				if (!cur.isSprinting() || cur.getLocation().getBlock().isLiquid())
+				{
+					_sprintTime.remove(cur);
+					_sprintStr.remove(cur);
+					cur.removePotionEffect(PotionEffectType.SPEED);
+					continue;
+				}
+
+				long time = _sprintTime.get(cur);
+				int str = _sprintStr.get(cur);
+
+				//Apply Speed
+				if (str > 0)
+					Factory.Condition().Factory().Speed(GetName(), cur, cur, 1.9, str-1, false, true, true);
+
+				//Upgrade Speed
+				if (!UtilTime.elapsed(time, 5000 - (1000 * level)))
+					continue;
+
+				_sprintTime.put(cur, System.currentTimeMillis());
+
+				if (str < 2)
+				{	
+					_sprintStr.put(cur, str+1);
+
+					//Effect
+					cur.getWorld().playSound(cur.getLocation(), Sound.ZOMBIE_IDLE, 2f, 0.2f * str+1);
+				}
+				
+				//Event
+				UtilServer.getServer().getPluginManager().callEvent(new SkillEvent(cur, GetName(), ClassType.Brute));
+			}
+			else if (cur.isSprinting() || !cur.getLocation().getBlock().isLiquid())
+			{
+				//Start Timer
+				if (!_sprintTime.containsKey(cur))
+				{
+					_sprintTime.put(cur, System.currentTimeMillis());
+					_sprintStr.put(cur, 0);
+				}
+			}
+		}
+	}
+
+	@EventHandler
+	public void Particle(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+		
+		for (Entity ent : _sprintStr.keySet())
+		{
+			UtilParticle.PlayParticle(ParticleType.CRIT, ent.getLocation(), 
+					(float)(Math.random() - 0.5), 0.2f + (float)Math.random(), (float)(Math.random() - 0.5), 0, _sprintStr.get(ent) * 2,
+					ViewDist.NORMAL, UtilServer.getPlayers());
+		}
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void Damage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+		
+		if (event.GetCause() != DamageCause.ENTITY_ATTACK)
+			return;
+
+		Player damager = event.GetDamagerPlayer(false);
+		if (damager == null)	return;
+
+		if (!_sprintStr.containsKey(damager))
+			return;
+
+		if (_sprintStr.get(damager) == 0)
+			return;
+
+		int level = getLevel(damager);
+		if (level == 0)			return;
+
+		LivingEntity damagee = event.GetDamageeEntity();
+		if (damagee == null)	return;
+
+		//Remove
+		_sprintTime.remove(damager);
+		int str = _sprintStr.remove(damager);
+		damager.removePotionEffect(PotionEffectType.SPEED);
+
+		//Damage
+		event.AddMod(damager.getName(), GetName(), 0.25 + (0.25 * level), true);
+		event.AddKnockback(GetName(), 1 + 0.5 * str);
+
+		//Inform
+		UtilPlayer.message(damager, F.main(GetClassType().name(), "You used " + F.skill(GetName(level)) + "."));
+		UtilPlayer.message(damagee, F.main(GetClassType().name(), F.name(damager.getName()) + " hit you with " + F.skill(GetName(level)) + "."));
+
+		//Effect
+		damager.getWorld().playSound(damager.getLocation(), Sound.ZOMBIE_WOOD, 1f, 0.4f * str); 
+		
+		//Event
+		UtilServer.getServer().getPluginManager().callEvent(new SkillEvent(damager, GetName(), ClassType.Brute, damagee));
+	}
+	
+	@EventHandler(priority = EventPriority.HIGH)
+	public void DamageCancel(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+		
+		Player damagee = event.GetDamageePlayer();
+		if (damagee == null)	return;
+		
+		Reset(damagee);
+		Factory.Condition().EndCondition(damagee, null, GetName());
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_sprintTime.remove(player);
+		_sprintStr.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Brute/Takedown.java

@@ -0,0 +1,188 @@
+package mineplex.minecraft.game.classcombat.Skill.Brute;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.util.Vector;
+
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilAction;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilTime;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+
+public class Takedown extends SkillActive
+{
+
+	private final Map<LivingEntity, Long> _live = new HashMap<>();
+
+	public Takedown(SkillFactory skills, String name, ClassType classType, SkillType skillType,
+			int cost, int levels,
+			int energy, int energyMod,
+			long recharge, long rechargeMod, boolean rechargeInform,
+			Material[] itemArray,
+			Action[] actionArray)
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod,
+				recharge, rechargeMod, rechargeInform,
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[]
+				{
+				"Hurl yourself towards an opponent.",
+				"If you collide with them, you deal",
+				"#5#1 damage and take #1.5#0.5 damage.",
+				"You both receive Slow 4 for #2.5#0.5 seconds."
+				});
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level)
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		if (UtilEnt.isGrounded(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " while grounded."));
+			return false;
+		}
+
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level)
+	{
+		//Action
+		Vector vec = player.getLocation().getDirection();
+
+		UtilAction.velocity(player, vec, 1.2, false, 0, 0.2, 0.4, false);
+
+		//Record
+		_live.put(player, System.currentTimeMillis());
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You used " + F.skill(GetName(level)) + "."));
+	}
+
+	@EventHandler
+	public void End(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		//End
+		for (Player player : GetUsers())
+		{
+			if (!UtilEnt.isGrounded(player))
+				continue;
+
+			if (!_live.containsKey(player))
+				continue;
+
+			int level = getLevel(player);
+			if (level == 0)		continue;
+
+			if (!UtilTime.elapsed(_live.get(player), 1000))
+				continue;
+
+			_live.remove(player);
+		}
+		
+		//Collide
+		_live.keySet().removeIf(entity ->
+		{
+			Player player = (Player) entity;
+
+			for (Player other : UtilPlayer.getNearby(player.getLocation(), 2))
+			{
+				if (player.equals(other) || !Factory.Relation().canHurt(player, other))
+				{
+					continue;
+				}
+
+				DoTakeDown(player, other);
+				return true;
+			}
+
+			return false;
+		});
+	}
+
+	private void DoTakeDown(Player damager, LivingEntity damagee)
+	{
+		int level = getLevel(damager);
+		int damage = 5 + level;
+
+		//Damage Event
+		CustomDamageEvent customDamageEvent = Factory.Damage().NewDamageEvent(damagee, damager, null,
+				DamageCause.CUSTOM, damage, false, true, false,
+				damager.getName(), GetName());
+
+		if (!customDamageEvent.IsCancelled())
+		{
+			//Conditions
+			double duration = 2.5 + (level / 2D);
+
+			Factory.Condition().Factory().Slow(GetName(), damagee, damager, duration, 3, false, true, true, true);
+			Factory.Condition().Factory().Slow(GetName(), damager, damager, duration, 3, false, true, true, true);
+			Factory.Condition().Factory().Jump(GetName(), damagee, damager, duration, 250, false, false, false);
+			Factory.Condition().Factory().Jump(GetName(), damager, damager, duration, 250, false, false, false);
+			Factory.Damage().NewDamageEvent(damager, damagee, null, DamageCause.CUSTOM, 1.5 + (level / 2D), false, true, false, GetName(), GetName() + " Recoil");
+
+			UtilAction.zeroVelocity(damagee);
+			UtilAction.zeroVelocity(damager);
+
+			//Inform
+			UtilPlayer.message(damager, F.main(GetClassType().name(), "You hit " + F.name(UtilEnt.getName(damagee)) + " with " + F.skill(GetName(level)) + "."));
+			UtilPlayer.message(damagee, F.main(GetClassType().name(), F.name(damager.getName()) + " hit you with " + F.skill(GetName(level)) + "."));
+
+			//Sound
+			damager.getWorld().playSound(damager.getLocation(), Sound.ZOMBIE_WOOD, 1f, 0.5f);
+		}
+	}
+
+	@EventHandler
+	public void Particle(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		for (Entity ent : _live.keySet())
+		{
+			UtilParticle.PlayParticleToAll(ParticleType.CRIT, ent.getLocation(),
+					(float)(Math.random() - 0.5), (float)(Math.random() * 1.4), (float)(Math.random() - 0.5), 0, 4,
+					ViewDist.LONG);
+		}
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_live.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Brute/Taunt.java

@@ -0,0 +1,136 @@
+package mineplex.minecraft.game.classcombat.Skill.Brute;
+
+import java.util.HashMap;
+
+import org.bukkit.GameMode;
+import org.bukkit.Material;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.Action;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.core.common.util.F;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.common.util.UtilAction;
+import mineplex.core.common.util.UtilAlg;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilMath;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.common.util.UtilTime;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class Taunt extends SkillActive
+{
+	private HashMap<LivingEntity, Long> _live = new HashMap<LivingEntity, Long>();
+
+	public Taunt(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Shout a taunt that forces all",
+				"enemies within #6#0 blocks to",
+				"run towards you for #1.5#0.5 seconds."
+				});
+		
+		this.setAchievementSkill(true);
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		//Record
+		_live.put(player, System.currentTimeMillis());
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You used " + F.skill(GetName(level)) + "."));
+	}
+
+	@EventHandler
+	public void End(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.FASTEST)
+			return;
+
+		//End
+		for (Player player : GetUsers())
+		{
+			if (!UtilEnt.isGrounded(player))
+				continue;
+
+			if (!_live.containsKey(player))
+				continue;
+
+			int level = getLevel(player);
+			if (level == 0)		continue;
+
+			if (!UtilTime.elapsed(_live.get(player), 1500 + 500*level))  
+				continue;
+
+			_live.remove(player);			
+		}	
+
+		//Collide
+		for (Player player : GetUsers())
+			if (_live.containsKey(player))
+				for (Player other : player.getWorld().getPlayers())
+					if (!UtilPlayer.isSpectator(other))
+						if (!other.equals(player))
+							if (Factory.Relation().canHurt(player, other))
+								if (UtilMath.offset(player, other) < 7 && UtilMath.offset(player, other) > 2)
+								{
+									UtilAction.velocity(other, UtilAlg.getTrajectory(other, player), 0.4, false, 0, 0, 0.4, false);
+								}
+	}
+
+	@EventHandler
+	public void Particle(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		for (Entity ent : _live.keySet())
+		{
+			UtilParticle.PlayParticle(ParticleType.ENCHANTMENT_TABLE, ent.getLocation().add(0, 2, 0), 
+					0, 0, 0, 6f, 8,
+					ViewDist.NORMAL, UtilServer.getPlayers());
+		}
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_live.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Brute/WhirlwindAxe.java

@@ -0,0 +1,140 @@
+package mineplex.minecraft.game.classcombat.Skill.Brute;
+
+import java.util.HashMap;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilAction;
+import mineplex.core.common.util.UtilAlg;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilMath;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class WhirlwindAxe extends SkillActive
+{
+	public WhirlwindAxe(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Whirl your axes around rapidly dealing",
+				"up to #3#1 damage to enemies within",
+				"#4#1 blocks, pulling them towards you.",
+				});
+		
+		this.setAchievementSkill(true);
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		return true;
+	}
+
+	@Override
+	public void Skill(final Player player, int level) 
+	{
+		//Pull + Damage
+		HashMap<LivingEntity, Double> targets = UtilEnt.getInRadius(player.getLocation(), 4d + 1 * level);
+		for (LivingEntity cur : targets.keySet())
+		{
+			if (cur.equals(player))
+				continue;
+			
+			if (cur instanceof Player)
+				if (!Factory.Relation().canHurt((Player)cur, player))
+					continue;
+			
+			//Damage Event
+			if (UtilMath.offset(cur, player) < 4)
+			{
+				Factory.Damage().NewDamageEvent(cur, player, null, 
+						DamageCause.CUSTOM, 2 + (1 + level) * targets.get(cur), false, true, false,
+						player.getName(), GetName());
+			}
+				
+			//Velocity
+			UtilAction.velocity(cur, 
+					UtilAlg.getTrajectory2d(cur.getLocation().toVector(), player.getLocation().toVector()), 
+					1.6 - 0.6*targets.get(cur), true, 0, 0.2, 1, true);
+			
+			//Inform
+			if (cur instanceof Player)
+				UtilPlayer.message((Player)cur, F.main(GetClassType().name(), F.name(player.getName()) +" hit you with " + F.skill(GetName(level)) + "."));	
+		}
+				
+		//Animation
+		for (double i=0 ; i<Math.PI * 2 ; i += 0.1)
+		{
+			final double j = i;
+			
+			final int ticksLived = player.getTicksLived();
+			final Location loc = player.getLocation();
+			
+			Bukkit.getServer().getScheduler().runTaskLater(Factory.getPlugin(), new Runnable()
+			{
+				@Override
+				public void run()
+				{
+					double x = Math.sin(j + (ticksLived/50d)) * (j%(Math.PI/2d)) * 3;
+					double z = Math.cos(j + (ticksLived/50d)) * (j%(Math.PI/2d)) * 3;
+					
+					UtilParticle.PlayParticle(ParticleType.FIREWORKS_SPARK, loc.clone().add(x, 1, z), 0f, 0f, 0f, 0, 1,
+							ViewDist.LONG, UtilServer.getPlayers());
+					
+					x = Math.sin(j + (ticksLived/50d) + Math.PI/4) * (j%(Math.PI/2d)) * 3;
+					z = Math.cos(j + (ticksLived/50d) + Math.PI/4) * (j%(Math.PI/2d)) * 3;
+					
+					UtilParticle.PlayParticle(ParticleType.FIREWORKS_SPARK, loc.clone().add(x, 1, z), 0f, 0f, 0f, 0, 1,
+							ViewDist.LONG, UtilServer.getPlayers());
+					
+					//Sound
+					player.getWorld().playSound(player.getLocation(), Sound.STEP_WOOL, 2f, 1f + (float)((j%(Math.PI/2d))/(Math.PI/2)));
+				}
+			}, (long) ((Math.PI/2d - (j%(Math.PI/2d))) * 8));
+		}
+		
+		
+		
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You used " + F.skill(GetName(level)) + "."));
+	}
+
+	@Override
+	public void Reset(Player player)
+	{
+		
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Global/BowDeficiencySkill.java

@@ -0,0 +1,57 @@
+package mineplex.minecraft.game.classcombat.Skill.Global;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.entity.EntityShootBowEvent;
+
+/**
+ * The BowDeficiencySkill provides a reduction in overall arrow velocity and damage to owners.
+ * @author MrTwiggy
+ *
+ */
+public class BowDeficiencySkill extends Skill
+{
+
+	public BowDeficiencySkill(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int maxLevel) 
+	{
+		super(skills, name, classType, skillType, cost, maxLevel);
+	}
+
+	/**
+	 * Reduce outgoing arrow velocity by bow deficiency owners.
+	 * @param event
+	 */
+	@EventHandler
+	public void BowShoot(EntityShootBowEvent event)
+	{
+		if (getLevel(event.getEntity()) == 0)
+			return;
+		
+		event.getProjectile().setVelocity(event.getProjectile().getVelocity().multiply(0.75));
+	}
+	
+	/**
+	 * Reduce damage output of arrows shot by bow deficiency owners.
+	 * @param event
+	 */
+	@EventHandler
+	public void onArrowDamage(CustomDamageEvent event)
+	{
+		// Check to see if arrow was shot by owner of this Skill.
+		if (event.GetProjectile() == null || getLevel(event.GetDamagerEntity(true)) == 0)
+			return;
+		
+		event.AddMod("BowDeficiencySkill", -2.0d);
+	}
+
+	@Override
+	public void Reset(Player player)
+	{
+		
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Global/BreakFall.java

@@ -0,0 +1,49 @@
+package mineplex.minecraft.game.classcombat.Skill.Global;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class BreakFall extends Skill
+{
+	public BreakFall(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"You roll when you hit the ground;",
+				"Fall damage is reduced by #0.5#1.5 .",
+				});
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void Damage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+
+		if (event.GetCause() != DamageCause.FALL)
+			return;
+
+		Player player = event.GetDamageePlayer();
+		if (player == null)		return;
+
+		int level = getLevel(player);
+		if (level == 0)			return;
+
+		event.AddMod(null, GetName(), -0.5 - (1.5 * level), false);
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Global/Cooldown.java

@@ -0,0 +1,42 @@
+package mineplex.minecraft.game.classcombat.Skill.Global;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+
+import mineplex.core.recharge.RechargeEvent;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class Cooldown extends Skill
+{
+	public Cooldown(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"You quickly recover from using skills;",
+				"Skill cooldowns are reduced by #0#12 %.",
+				});
+	}
+
+	@EventHandler
+	public void Resist(RechargeEvent event)
+	{
+		int level = getLevel(event.GetPlayer());
+		if (level <= 0)
+			return;
+		
+		
+		double reduction = 0.12f * level;
+
+		event.SetRecharge((long) (event.GetRecharge() * (1 - reduction)));
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Global/Fitness.java

@@ -0,0 +1,32 @@
+package mineplex.minecraft.game.classcombat.Skill.Global;
+
+import org.bukkit.entity.Player;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class Fitness extends Skill
+{
+	public Fitness(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Maximum Energy is increased by #0#27 ( #0#15 %)."
+				});
+	}
+	
+	@Override
+	public void OnPlayerAdd(Player player)
+	{
+		Factory.Energy().AddEnergyMaxMod(player, GetName(), 18 * getLevel(player));
+	}
+	
+	@Override
+	public void Reset(Player player) 
+	{
+		Factory.Energy().RemoveEnergyMaxMod(player, GetName());
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Global/Pistol.java

@@ -0,0 +1,204 @@
+package mineplex.minecraft.game.classcombat.Skill.Global;
+
+import org.bukkit.Effect;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.block.Action;
+
+import mineplex.core.common.util.UtilEnt;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilBlock;
+import mineplex.core.common.util.UtilInv;
+import mineplex.core.common.util.UtilMath;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class Pistol extends SkillActive
+{
+	public Pistol(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+            int cost, int levels, 
+            int energy, int energyMod, 
+            long recharge, long rechargeMod, boolean rechargeInform, 
+            Material[] itemArray, 
+            Action[] actionArray) 
+    {
+        super(skills, name, classType, skillType,
+                cost, levels,
+                energy, energyMod, 
+                recharge, rechargeMod, rechargeInform, 
+                itemArray,
+                actionArray);
+
+	SetDesc(new String[] 
+	{
+	"Pew Pew"
+	});
+    }
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		//Use Gunpowder
+		if (!UtilInv.remove(player, Material.MELON_SEEDS, (byte)0, 1))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You need " + F.item("Pistol Ammo") + " to use " + F.skill(GetName()) + "."));
+			return false;
+		}
+
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		//Action
+		double sharpness = 0.1;
+
+		double travel = 0;
+		double maxTravel = 100;
+
+		double hitBox = 0.5;
+
+		//Effect
+		player.getWorld().playEffect(player.getEyeLocation().add(player.getLocation().getDirection()), Effect.SMOKE, 4);
+		player.getWorld().playSound(player.getEyeLocation(), Sound.EXPLODE, 0.6f, 2f);
+
+		while (travel < maxTravel)
+		{
+			Location loc = player.getEyeLocation().add(player.getLocation().getDirection().multiply(travel));
+			for (Entity ent : player.getWorld().getEntities())
+			{
+				if (!(ent instanceof LivingEntity))
+					continue;
+
+				LivingEntity cur = (LivingEntity)ent;
+
+				if (cur.equals(player))
+					continue;
+
+				if (cur instanceof Player)
+				{
+					if (UtilMath.offset(loc, ((Player)cur).getEyeLocation()) < 0.3)
+					{
+						rifleHit(cur, player, true);
+						player.getWorld().playSound(loc, Sound.BLAZE_HIT, 0.4f, 2f);
+						return;
+					}
+					else if (UtilMath.offset2d(loc, cur.getLocation()) < hitBox)
+					{
+						if (loc.getY() > cur.getLocation().getY() && loc.getY() < cur.getEyeLocation().getY())
+						{
+							rifleHit(cur, player, false);
+							player.getWorld().playSound(loc, Sound.BLAZE_HIT, 0.4f, 2f);
+							return;
+						}		
+					}
+				}
+				else 
+				{
+					if (UtilMath.offset(loc, cur.getEyeLocation()) < 0.3)
+					{
+						rifleHit(cur, player, true);
+						player.getWorld().playSound(loc, Sound.BLAZE_HIT, 0.4f, 2f);
+						return;
+					}
+					else if (UtilMath.offset2d(loc, cur.getLocation()) < hitBox)
+					{
+						if (loc.getY() > cur.getLocation().getY() && loc.getY() < cur.getLocation().getY() + 1)
+						{
+							rifleHit(cur, player, false);
+							player.getWorld().playSound(loc, Sound.BLAZE_HIT, 0.4f, 2f);
+							return;
+						}		
+					}
+				}
+
+				if (UtilMath.offset2d(loc, cur.getLocation()) < hitBox)
+				{
+					if (loc.getY() > cur.getLocation().getY() && loc.getY() < cur.getEyeLocation().getY())
+					{
+						rifleHit(cur, player, false);
+						player.getWorld().playSound(loc, Sound.BLAZE_HIT, 0.4f, 2f);
+						return;
+					}		
+				}
+			}	
+
+			if (UtilBlock.solid(loc.getBlock()))
+			{
+				loc.getBlock().getWorld().playEffect(loc, Effect.STEP_SOUND, loc.getBlock().getTypeId());
+				player.getWorld().playSound(player.getLocation(), Sound.BLAZE_HIT, 0.4f, 2f);
+				return;
+			}
+
+			travel += sharpness;
+		}
+	}
+
+	public void rifleHit(LivingEntity hit, Player attacker, boolean headshot) 
+	{
+		/*
+		int damage = 12;
+		if (headshot)
+		{
+			if (hit instanceof Player)
+			{
+				Player damagee = (Player)hit;
+				if (Factory.Clans().CUtil().canHurt(damagee, attacker))
+				{
+					if (damagee.getInventory().getHelmet() == null)
+					{
+						//Damage
+						damage = 500;
+						damagee.getWorld().playEffect(damagee.getEyeLocation(), Effect.STEP_SOUND, 55);
+
+						//Inform
+						UtilServer.broadcast(F.main("Item", F.name(((Player)hit).getName()) + " was headshotted by " + F.name(attacker.getName()) + " with " + F.item("Rifle") + "."));
+					}
+					else
+					{
+						int id = 55;
+						if (damagee.getInventory().getHelmet().getType() == Material.IRON_HELMET)	id = 42;
+						if (damagee.getInventory().getHelmet().getType() == Material.GOLD_HELMET)	id = 41;
+						if (damagee.getInventory().getHelmet().getType() == Material.DIAMOND_HELMET)	id = 57;
+						if (damagee.getInventory().getHelmet().getType() == Material.CHAINMAIL_HELMET)	id = 4;
+						if (damagee.getInventory().getHelmet().getType() == Material.LEATHER_HELMET)	id = 17;
+						damagee.getWorld().playEffect(damagee.getEyeLocation(), Effect.STEP_SOUND, id);	
+							
+						Item item = damagee.getWorld().dropItemNaturally(damagee.getEyeLocation(), damagee.getInventory().getHelmet());
+						item.setPickupDelay(60);
+						damagee.getInventory().setHelmet(null);
+					}
+				}
+			}
+			else
+			{
+				hit.getWorld().playEffect(hit.getEyeLocation(), Effect.STEP_SOUND, 55);
+				damage = 500;
+			}
+		}
+
+		if (damage > 0)
+			return;
+		//UtilPlayer.Damage(hit, attacker, damage, getName(), true, true, false);
+		*/
+	}
+
+	@Override
+	public void Reset(Player player)
+	{
+	
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Global/Rations.java

@@ -0,0 +1,56 @@
+package mineplex.minecraft.game.classcombat.Skill.Global;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.common.util.UtilTime;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class Rations extends Skill
+{
+	public Rations(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"After not moving for #4#-1 seconds,",
+				"you snack on rations, replenishing",
+				"#0#1 hunger every second."
+				});
+	}
+
+	@EventHandler
+	public void Update(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.SEC)
+			return;
+
+		for (Player cur : UtilServer.getPlayers())
+		{
+			int level = getLevel(cur);
+			
+			if (level > 0)
+			{
+				if (UtilTime.elapsed(Factory.Movement().Get(cur).LastMovement, 7000 - (1000 * level)))
+				{
+					cur.setSaturation(0f);
+					cur.setExhaustion(0f);
+					UtilPlayer.hunger(cur, level);	
+				}
+			}
+		}
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Global/Recharge.java

@@ -0,0 +1,53 @@
+package mineplex.minecraft.game.classcombat.Skill.Global;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+
+import mineplex.core.energy.event.EnergyEvent;
+import mineplex.core.energy.event.EnergyEvent.EnergyChangeReason;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class Recharge extends Skill
+{
+	public Recharge(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"For every second since you",
+				"last used Energy, you receive",
+				"+ #0#20 % Energy regenerate rate.",
+				"",
+				"Maximum of + #0#100 % bonus."
+				});
+	}
+	
+	@EventHandler
+	public void Skill(EnergyEvent event)
+	{
+		if (event.GetReason() != EnergyChangeReason.Recharge)
+			return;
+		
+		int level = getLevel(event.GetPlayer());
+		if (level <= 0)
+			return;
+		
+		long duration = System.currentTimeMillis() - Factory.Energy().Get(event.GetPlayer()).LastEnergy;
+		
+		int bonus = (int) (duration / 1000);
+		
+		if (bonus > 5)
+			bonus = 5;
+		
+		event.AddMod(bonus * (level * 0.08));
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Global/Resistance.java

@@ -0,0 +1,64 @@
+package mineplex.minecraft.game.classcombat.Skill.Global;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+
+import mineplex.minecraft.game.core.condition.Condition.ConditionType;
+import mineplex.minecraft.game.core.condition.events.ConditionApplyEvent;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class Resistance extends Skill
+{
+	public Resistance(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Your body and mind is exceptionally resistant.",
+				"Durations on you are #20#15 % shorter for;",
+				"Slow, Fire, Shock, Confusion, Poison,",
+				"Blindness and Jump Prevention"
+				});
+	}
+
+	@EventHandler
+	public void Resist(ConditionApplyEvent event)
+	{
+		//Dont Resist Self Condition
+		if (event.GetCondition().GetReason().equalsIgnoreCase("Hold Position"))
+		{
+			return;
+		}
+
+		ConditionType type = event.GetCondition().GetType();
+
+		switch (type)
+		{
+			case BURNING:
+			case SLOW:
+			case SHOCK:
+			case CONFUSION:
+			case POISON:
+			case BLINDNESS:
+				int level = getLevel(event.GetCondition().GetEnt());
+
+				if (level == 0)
+				{
+					return;
+				}
+
+				double reduction = -0.20f - (0.15f * level);
+				event.GetCondition().ModifyTicks((int) (event.GetCondition().GetTicksTotal() * reduction));
+				break;
+		}
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Global/Swim.java

@@ -0,0 +1,69 @@
+package mineplex.minecraft.game.classcombat.Skill.Global;
+
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.player.PlayerToggleSneakEvent;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.core.common.util.UtilAction;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class Swim extends Skill
+{
+	public Swim(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Tap Crouch to Swim forwards."
+				});
+	}
+	
+	@Override
+	public String GetEnergyString()
+	{
+		return "Energy: 5";
+	}
+
+	@EventHandler(priority=EventPriority.HIGHEST)
+	public void Crouch(PlayerToggleSneakEvent event)
+	{
+		if (event.isCancelled())
+			return;
+		
+		Player player = event.getPlayer();
+
+		//Water
+		if (player.getLocation().getBlock().getTypeId() != 8 && player.getLocation().getBlock().getTypeId() != 9)
+			return;
+
+		//Level
+		int level = getLevel(player);
+		
+		if (level == 0)		
+			return;
+
+		//Recharge
+		if (!mineplex.core.recharge.Recharge.Instance.use(player, GetName(), GetName(level), 800, false, false))
+			return;
+
+		if (!Factory.Energy().Use(player, GetName(level), 5, true, false))
+			return;
+
+		//Action
+		UtilAction.velocity(player, 0.6, 0.2, 0.6, false);
+
+		//Effect
+		player.getWorld().playSound(player.getLocation(), Sound.SPLASH, 0.3f, 2f);
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/ISkill.java

@@ -0,0 +1,45 @@
+package mineplex.minecraft.game.classcombat.Skill;
+
+import java.util.Set;
+
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+
+public interface ISkill
+{
+	public enum SkillType
+	{ 
+		Axe,
+		Bow,
+		Sword,
+		PassiveA,
+		PassiveB,
+		GlobalPassive,
+		Class,
+	}
+	
+    String GetName();
+    int getLevel(Entity ent);
+    ClassType GetClassType();
+    SkillType GetSkillType();
+    int GetGemCost();
+    int GetTokenCost();
+    boolean IsFree();
+    void setFree(boolean free);
+    String[] GetDesc(int level);
+    void Reset(Player player);
+    
+    Set<Player> GetUsers();
+    void AddUser(Player player, int level);
+    void RemoveUser(Player player);
+    
+	Integer GetSalesPackageId();
+	int getMaxLevel();
+	
+	boolean isAchievementSkill();
+
+	void setLocationFilter(LocationFilter locationFilter);
+	LocationFilter getLocationFilter();
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/ISkillFactory.java

@@ -0,0 +1,15 @@
+package mineplex.minecraft.game.classcombat.Skill;
+
+import java.util.HashMap;
+import java.util.List;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass;
+
+public interface ISkillFactory
+{
+    List<ISkill> GetGlobalSkillsFor(IPvpClass gameClass);
+    List<ISkill> GetSkillsFor(IPvpClass gameClass);
+    HashMap<ISkill, Integer> GetDefaultSkillsFor(IPvpClass gameClass);
+}
+
+

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Knight/AxeThrow.java

@@ -0,0 +1,235 @@
+package mineplex.minecraft.game.classcombat.Skill.Knight;
+
+import java.util.HashMap;
+import java.util.Iterator;
+
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.event.player.PlayerPickupItemEvent;
+import org.bukkit.util.Vector;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilAction;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilInv;
+import mineplex.core.common.util.UtilMath;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.projectile.IThrown;
+import mineplex.core.projectile.ProjectileUser;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class AxeThrow extends SkillActive implements IThrown
+{
+	private HashMap<Item, Player> _thrown = new HashMap<Item, Player>();
+	
+	public AxeThrow(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Throw your axe with #0.7#0.1 velocity, ",
+				"dealing #4.5#0.5 damage.",
+				"",
+				"You pull your axe back to you when it",
+				"collides with anything.",
+				"",
+				"Your axe is returned to you if you do",
+				"not pick it up within #15#-1 seconds."
+				});
+		
+		setAchievementSkill(true);
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		//Inform
+		UtilPlayer.message(player, F.main("Game", "You used " + F.skill(GetName()) + "."));
+		
+		//Throw
+		Item item = player.getWorld().dropItem(player.getEyeLocation(), player.getItemInHand());
+		UtilAction.velocity(item, player.getLocation().getDirection(), 0.7 + 0.1 * level, false, 0, 0.2, 10, true);
+		
+		player.setItemInHand(null);
+		
+		//Projectile
+		Factory.Projectile().AddThrow(item, player, this, -1, true, true, true, false, 0.4f);
+		
+		//Store
+		_thrown.put(item, player);
+	}
+	
+	@Override
+	public void Collide(LivingEntity target, Block block, ProjectileUser data) 
+	{
+		Rebound(data.getThrower(), data.getThrown());
+		
+		if (target == null)
+			return;
+		
+		int level = getLevel(data.getThrower());
+		if (level <= 0)
+			return;
+		
+		double damage = 4.5 + 0.5 * level;
+		
+		//Damage Event
+		Factory.Damage().NewDamageEvent(target, data.getThrower(), null,
+				DamageCause.CUSTOM, damage, true, true, false,
+				UtilEnt.getName(data.getThrower()), GetName());
+	}
+
+	@Override
+	public void Idle(ProjectileUser data) 
+	{
+		Rebound(data.getThrower(), data.getThrown());
+	}
+
+	@Override
+	public void Expire(ProjectileUser data) 
+	{
+		Rebound(data.getThrower(), data.getThrown());
+	}
+
+	public void Rebound(LivingEntity player, Entity ent)
+	{
+		ent.getWorld().playSound(ent.getLocation(), Sound.ZOMBIE_WOOD, 0.6f, 0.5f);
+		
+		double mult = 0.5 + (0.6 * (UtilMath.offset(player.getLocation(), ent.getLocation())/16d));
+		
+		//Velocity
+		ent.setVelocity(player.getLocation().toVector().subtract(ent.getLocation().toVector()).normalize().add(new Vector(0, 0.4, 0)).multiply(mult));
+		
+		//Ticks
+		if (ent instanceof Item)
+			((Item)ent).setPickupDelay(5);
+	}
+	
+	@EventHandler
+	public void pickup(PlayerPickupItemEvent event)
+	{
+		if (!_thrown.containsKey(event.getItem()))
+			return;
+		
+		event.setCancelled(true);
+		
+		Player player = _thrown.remove(event.getItem());
+		
+		player.getInventory().addItem(event.getItem().getItemStack());
+		
+		UtilInv.Update(event.getPlayer());
+		
+		event.getItem().remove();
+		
+		player.playSound(player.getLocation(), Sound.CHICKEN_EGG_POP, 1f, 1f);
+	}
+	
+	@EventHandler
+	public void timeout(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.FAST)
+			return;
+		
+		Iterator<Item> itemIterator = _thrown.keySet().iterator();
+		
+		while (itemIterator.hasNext())
+		{
+			Item item = itemIterator.next();
+			
+			Player player = _thrown.get(item);
+			if (!player.isOnline())
+			{
+				item.remove();
+				itemIterator.remove();
+				continue;
+			}
+			
+			int level = getLevel(player);
+			
+			if (item.getTicksLived() > 300 - level * 20)
+			{
+				_thrown.get(item).getInventory().addItem(item.getItemStack());
+				item.remove();
+				itemIterator.remove();
+			}
+		}
+	}
+	
+	@EventHandler
+	public void death(PlayerDeathEvent event)
+	{
+		Iterator<Item> i = _thrown.keySet().iterator();
+		
+		while (i.hasNext())
+		{
+			Item item = i.next();
+			Player player = _thrown.get(item);
+			
+			if (player.equals(event.getEntity()))
+			{
+				i.remove();
+				item.remove();
+			}
+		}
+	}
+	
+	@Override
+	public void Reset(Player player) 
+	{
+		Iterator<Item> i = _thrown.keySet().iterator();
+		
+		while (i.hasNext())
+		{
+			Item item = i.next();
+			Player thrower = _thrown.get(item);
+			
+			if (player.equals(thrower))
+			{
+				i.remove();
+				item.remove();
+			}
+		}
+	}
+	
+	@Override
+	public void ChunkUnload(ProjectileUser data)
+	{
+		data.getThrown().remove();
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Knight/BullsCharge.java

@@ -0,0 +1,143 @@
+package mineplex.minecraft.game.classcombat.Skill.Knight;
+
+import org.bukkit.Effect;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.potion.PotionEffectType;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.minecraft.game.core.condition.Condition.ConditionType;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class BullsCharge extends SkillActive
+{
+	public BullsCharge(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Charge forwards with Speed II for",
+				"#3#1 seconds. If you attack during this",
+				"time, your target receives Slow 2",
+				"for #2.5#0.5 seconds, as well as no knockback."
+				});
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		//Action
+		Factory.Condition().Factory().Speed(GetName(), player, player, 3 + level, 1, false, true, true);
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You used " + F.skill(GetName(level)) + "."));
+
+		//Effect
+		player.getWorld().playSound(player.getLocation(), Sound.ENDERMAN_SCREAM, 1.5f, 0f);
+		player.getWorld().playEffect(player.getLocation(), Effect.STEP_SOUND, 49);
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void Damage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+		
+		if (event.GetCause() != DamageCause.ENTITY_ATTACK)
+			return;
+
+		Player damager = event.GetDamagerPlayer(true);
+		LivingEntity damagee = event.GetDamageeEntity();
+
+		if (damager == null || damagee == null)
+			return;
+		
+		//Isn't using Bulls Charge
+		if (!Factory.Condition().HasCondition(damager, ConditionType.SPEED, GetName()))
+			return;
+
+		//Level
+		int level = getLevel(damager);
+		if (level == 0)				return;
+
+		//Condition
+		Factory.Condition().Factory().Slow(GetName(), damagee, damager, 2.5 + (0.5 * level), 1, false, true, true, true);
+		Factory.Condition().EndCondition(damager, ConditionType.SPEED, GetName());
+
+		//Damage
+		//event.AddMod(damager.getName(), getName(), level, true);
+		event.SetKnockback(false);
+		
+		//Effect
+		damager.getWorld().playSound(damager.getLocation(), Sound.ENDERMAN_SCREAM, 1.5f, 0f);
+		damager.getWorld().playSound(damager.getLocation(), Sound.ZOMBIE_METAL, 1.5f, 0.5f);
+
+		//Inform
+		UtilPlayer.message(damagee, F.main(GetClassType().name(), 
+				F.name(damager.getName()) + " hit you with " + F.skill(GetName(level)) + "."));
+		
+		UtilPlayer.message(damager, F.main(GetClassType().name(), 
+				"You hit " + F.name(UtilEnt.getName(damagee)) +" with " + F.skill(GetName(level)) + "."));
+	}
+	
+	@EventHandler
+	public void Particle(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+		
+		for (Player player : GetUsers())
+		{
+			if (player.hasPotionEffect(PotionEffectType.SPEED))
+				UtilParticle.PlayParticle(ParticleType.CRIT, player.getLocation(), 
+					(float)(Math.random() - 0.5), 0.2f + (float)(Math.random() * 1), (float)(Math.random() - 0.5), 0, 3,
+					ViewDist.LONG, UtilServer.getPlayers());
+		}
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Knight/Cleave.java

@@ -0,0 +1,80 @@
+package mineplex.minecraft.game.classcombat.Skill.Knight;
+
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.core.common.util.UtilGear;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class Cleave extends Skill
+{
+	public Cleave(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Your attacks deal #25#25 % damage to",
+				"all enemies within 3 Blocks",
+				"of your target enemy.",
+				"",
+				"This only works with Axes."
+				});
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void Skill(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+		
+		if (event.GetCause() != DamageCause.ENTITY_ATTACK)
+			return;
+
+		if (event.GetReason() != null)
+			return;
+		
+		//Damager
+		Player damager = event.GetDamagerPlayer(false);
+		if (damager == null)	return;
+
+		if (!UtilGear.isAxe(damager.getItemInHand()))
+			return;
+
+		int level = getLevel(damager);
+		if (level == 0)		return;
+
+		//Damagee
+		LivingEntity damagee = event.GetDamageeEntity();
+		if (damagee == null)	return;
+
+		//Damage
+		event.AddMod(damager.getName(), GetName(), 0, false);
+
+		//Splash
+		for (Player other : UtilPlayer.getNearby(damagee.getLocation(), 3))
+		{
+			if (!other.equals(damagee) && !other.equals(damager))
+				if (Factory.Relation().canHurt(damager, other))
+				{
+					//Damage Event
+					Factory.Damage().NewDamageEvent(other, damager, null, 
+							DamageCause.ENTITY_ATTACK, (0.25 + (level * 0.25)) * event.GetDamageInitial(), true, false, false,
+							damager.getName(), GetName());
+				}
+		}
+	}
+
+	@Override
+	public void Reset(Player player)
+	{
+
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Knight/DefensiveStance.java

@@ -0,0 +1,130 @@
+package mineplex.minecraft.game.classcombat.Skill.Knight;
+
+import java.util.HashMap;
+
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.util.Vector;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.core.common.util.UtilAlg;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilTime;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class DefensiveStance extends SkillActive
+{
+	private HashMap<Player, Long> _useTime = new HashMap<Player, Long>();
+	
+	public DefensiveStance(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"While Blocking, you take 80% less",
+				"damage from attacks infront of you."
+				});
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		_useTime.put(player, System.currentTimeMillis());
+	}
+	
+	@EventHandler(priority = EventPriority.HIGH)
+	public void AntiTurtle(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+
+		if (event.GetCause() != DamageCause.ENTITY_ATTACK && event.GetCause() != DamageCause.PROJECTILE)
+			return;
+
+		Player damager = event.GetDamagerPlayer(false);
+		if (damager == null)	return;
+
+		if (!_useTime.containsKey(damager))
+			return;
+		
+		if (UtilTime.elapsed(_useTime.get(damager), 400))
+			return;
+		
+		event.SetCancelled(GetName() + " Attack");
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void Damagee(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+
+		if (event.GetCause() != DamageCause.ENTITY_ATTACK && event.GetCause() != DamageCause.PROJECTILE)
+			return;
+		
+		if (isInWater(event.GetDamageeEntity()))
+			return;
+
+		Player damagee = event.GetDamageePlayer();
+		if (damagee == null)	return;
+
+		if (!damagee.isBlocking())
+			return;
+		
+		int level = getLevel(damagee);
+		if (level == 0)		return;
+
+		LivingEntity damager = event.GetDamagerEntity(true);
+		if (damager == null)	return;
+
+		Vector look = damagee.getLocation().getDirection();
+		look.setY(0);
+		look.normalize();
+
+		Vector from = UtilAlg.getTrajectory(damagee, damager);
+		from.normalize();
+
+		if (damagee.getLocation().getDirection().subtract(from).length() > 1.4)
+		{
+			return;
+		}
+
+		//Damage
+		event.AddMult(GetName(), GetName(), 0.2, false);
+		event.SetKnockback(false);
+
+		//Effect
+		damagee.getWorld().playSound(damagee.getLocation(), Sound.ZOMBIE_METAL, 1f, 2f);
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_useTime.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Knight/Deflection.java

@@ -0,0 +1,97 @@
+package mineplex.minecraft.game.classcombat.Skill.Knight;
+
+import java.util.HashMap;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.recharge.Recharge;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.core.updater.UpdateType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class Deflection extends Skill
+{
+	private HashMap<Player, Integer> _charges = new HashMap<Player, Integer>();
+
+	public Deflection(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Prepare to deflect incoming attacks.",
+				"You gain 1 Charge every #5#-1 seconds.",
+				"You can store a maximum of #1#1 Charges.",
+				"",
+				"When you are attacked, the damage is",
+				"reduced by the number of your Charges,",
+				"and your Charges are reset to 0.",
+				});
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void DecreaseDamage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+		
+		if (event.GetCause() != DamageCause.ENTITY_ATTACK)
+			return;
+
+		//Damagee
+		Player damagee = event.GetDamageePlayer();
+		if (damagee == null)	return;
+
+		if (!_charges.containsKey(damagee))
+			return;
+
+		event.AddMod(damagee.getName(), GetName(), -_charges.remove(damagee), false);
+		
+		//Cooldown
+		int level = getLevel(damagee);
+		Recharge.Instance.useForce(damagee, GetName(), 5000 - (1000 * level));
+	}
+	
+	@EventHandler
+	public void Charge(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+		
+		for (Player cur : GetUsers())
+		{
+			int level = getLevel(cur);
+			
+			if (!Recharge.Instance.use(cur, GetName(), 5000 - (1000 * level), false, false))
+				continue;
+					
+			int max = 1 + (1 * level);
+			
+			int charge = 1;
+			if (_charges.containsKey(cur))
+				charge += _charges.get(cur);
+			
+			if (charge <= max)
+			{
+				_charges.put(cur, charge);
+				
+				//Inform
+				UtilPlayer.message(cur, F.main(GetClassType().name(), "Deflection Charges: " + F.elem(charge+"")));
+			}
+		}
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_charges.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Knight/Fortitude.java

@@ -0,0 +1,131 @@
+package mineplex.minecraft.game.classcombat.Skill.Knight;
+
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map.Entry;
+import java.util.WeakHashMap;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.common.util.UtilTime;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class Fortitude extends Skill
+{
+	private WeakHashMap<Player, Double> _preHealth = new WeakHashMap<Player, Double>();
+	private WeakHashMap<Player, Double> _health = new WeakHashMap<Player, Double>();
+	private WeakHashMap<Player, Long> _last = new WeakHashMap<Player, Long>();
+
+	public Fortitude(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"After taking damage, you regenerate",
+				"up to #0#1 of the health you lost.",
+				"",
+				"You restore health at a rate of",
+				"1 health per #3#-0.5 seconds.",
+				"",
+				"This does not stack, and is reset if",
+				"you are hit again."
+				});
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void RegisterPre(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+		
+		Player damagee = event.GetDamageePlayer();
+		if (damagee == null)	return;
+		
+		if (getLevel(damagee) <= 0)
+			return;
+		
+		_preHealth.put(damagee, damagee.getHealth());
+	}
+	
+	@EventHandler(priority = EventPriority.MONITOR)
+	public void RegisterLast(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+		
+		//Damager
+		Player damagee = event.GetDamageePlayer();
+		if (damagee == null)	return;
+		
+		int level = getLevel(damagee);
+		if (level  == 0)		return;
+		
+		if (!_preHealth.containsKey(damagee))
+			return;
+		
+		double diff = _preHealth.remove(damagee) - damagee.getHealth();
+		
+		_health.put(damagee, Math.min(level, diff));
+		_last.put(damagee, System.currentTimeMillis());
+	}
+
+	@EventHandler
+	public void Update(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.FASTER)
+			return;
+
+		Iterator<Entry<Player, Double>> healthIterator = _health.entrySet().iterator();
+		
+		while (healthIterator.hasNext())
+		{
+			Entry<Player, Double> entry = healthIterator.next();
+			
+			int level = getLevel(entry.getKey());
+			if (level == 0)		
+				continue;
+			
+			if (!UtilTime.elapsed(_last.get(entry.getKey()), 3000 - (500 * level)))
+				continue;
+			
+			//Work out healing
+			double toHeal = Math.min(entry.getValue(), 1);
+			entry.setValue(entry.getValue() - toHeal);
+			
+			//Heal
+			UtilPlayer.health(entry.getKey(), toHeal);
+			
+			//Effect
+			UtilParticle.PlayParticle(ParticleType.HEART, entry.getKey().getEyeLocation(), 0, 0.2f, 0, 0, 1,
+					ViewDist.NORMAL, UtilServer.getPlayers());
+			
+			//Finished
+			if (entry.getValue() <= 0)
+				healthIterator.remove();
+			
+			//Last Tick
+			_last.put(entry.getKey(), System.currentTimeMillis());
+		}
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_preHealth.remove(player);
+		_health.remove(player);
+		_last.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Knight/HiltSmash.java

@@ -0,0 +1,200 @@
+package mineplex.minecraft.game.classcombat.Skill.Knight;
+
+import java.util.HashSet;
+
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.core.common.util.F;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilMath;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.Skill.event.SkillTriggerEvent;
+
+public class HiltSmash extends SkillActive
+{
+	private HashSet<Player>	_used = new HashSet<Player>();
+
+	public HiltSmash(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Smash the hilt of your sword into",
+				"your opponent, dealing #1#1 damage",
+				"and Slow 3 for #0.5#0.5 seconds."
+				});
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+		
+		if (_used.contains(player))
+			return false;
+
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You missed " + F.skill(GetName()) + "."));
+	}
+
+	@EventHandler
+	public void Miss(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		_used.clear();
+	}
+
+	public boolean CanUse(Player player)
+	{
+		int level = getLevel(player);
+		if (level == 0)
+			return false;
+
+		//Check Material
+		if (!_itemSet.contains(player.getItemInHand().getType()))
+			return false;
+
+		//Check Allowed
+		SkillTriggerEvent trigger = new SkillTriggerEvent(player, GetName(), GetClassType());
+		UtilServer.getServer().getPluginManager().callEvent(trigger);
+		if (trigger.IsCancelled())
+			return false;
+
+		//Check Energy/Recharge
+		if (!EnergyRechargeCheck(player, level))
+			return false;
+		
+		//Water
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		//Allow
+		return true;
+	}
+
+	@EventHandler
+	public void Hit(PlayerInteractEntityEvent event)
+	{
+		if (event.isCancelled())
+			return;
+	
+		if (isInWater(event.getPlayer()))
+			return;
+		
+		Player player = event.getPlayer();
+
+		//Level
+		int level = getLevel(player);
+		if (level == 0)			return;
+
+		if (!CanUse(player))
+			return;
+
+		Entity ent = event.getRightClicked();
+
+		if (UtilPlayer.isSpectator(ent))
+			return;
+		
+		if (ent == null)
+			return;
+
+		if (!(ent instanceof LivingEntity))
+			return;
+		
+		if (UtilMath.offset(player, ent) > 4)
+		{
+			UtilPlayer.message(player, F.main(GetClassType().name(), "You missed " + F.skill(GetName()) + "."));
+			return;
+		}
+
+		//Set Used
+		_used.add(player);
+
+		//Damage Event
+		Factory.Damage().NewDamageEvent((LivingEntity)ent, player, null, 
+				DamageCause.CUSTOM, 1 + level, false, true, false,
+				player.getName(), GetName());
+		
+		//Sound
+		player.getWorld().playSound(player.getLocation(), Sound.ZOMBIE_WOOD, 1f, 1.4f);
+	}
+
+	@EventHandler
+	public void Damage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+
+		if (event.GetCause() != DamageCause.CUSTOM)
+			return;
+
+		Player damager = event.GetDamagerPlayer(false);
+		if (damager == null)	return;
+
+		int level = getLevel(damager);
+		if (level == 0)			return;
+
+		LivingEntity damagee = event.GetDamageeEntity();
+		if (damagee == null)	return;
+
+		if (event.GetReason() == null || !event.GetReason().contains(GetName()))
+			return;
+
+		//Condition
+		Factory.Condition().Factory().Slow(GetName(), damagee, damager, 0.5 + 0.5 * level, 2, false, true, true, true);
+
+		//Effect
+		damagee.getWorld().playSound(damagee.getLocation(), Sound.ZOMBIE_WOOD, 1f, 1.2f);
+
+		//Inform
+		UtilPlayer.message(damager, F.main(GetClassType().name(), "You used " + F.skill(GetName()) + "."));
+		UtilPlayer.message(damagee, F.main(GetClassType().name(), F.name(damager.getName()) + " hit you with " + F.skill(GetName(level)) + "."));
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_used.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Knight/HoldPosition.java

@@ -0,0 +1,166 @@
+package mineplex.minecraft.game.classcombat.Skill.Knight;
+
+import mineplex.core.common.util.UtilEnt;
+import mineplex.minecraft.game.core.condition.events.ConditionExpireEvent;
+import org.bukkit.Effect;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.Action;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.minecraft.game.core.condition.Condition;
+import mineplex.minecraft.game.core.condition.Condition.ConditionType;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class HoldPosition extends SkillActive
+{
+	public HoldPosition(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Hold your position, gaining",
+				"Protection 3, Slow 3 and no",
+				"knockback for #3#1 seconds."
+				});
+	}
+
+	private final Map<Player, Integer> _foodLevel = new HashMap<>();
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		double duration = 3 + (1 * level);
+
+		//Action
+		Factory.Condition().Factory().Slow(GetName(), player, player, duration, 2, false, true, false, true);
+		Factory.Condition().Factory().Protection(GetName(), player, player, duration, 2, false, false, true);
+		Factory.Condition().Factory().ArcadeHungerDisable(GetName(), player, player, duration, false);
+		Factory.Condition().Factory().Jump(GetName(), player, player, duration, 250, false, false, false);
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You used " + F.skill(GetName(level)) + "."));
+
+		//Effect
+		player.getWorld().playSound(player.getLocation(), Sound.ENDERMAN_SCREAM, 1.5f, 0f);
+		player.getWorld().playEffect(player.getLocation(), Effect.STEP_SOUND, 49);
+
+		_foodLevel.put(player, player.getFoodLevel());
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void Damage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+
+		Player damagee = event.GetDamageePlayer();
+		if (damagee == null)	return;
+
+		int level = getLevel(damagee);
+		if (level == 0)		return;
+
+		Condition data = Factory.Condition().GetActiveCondition(damagee, ConditionType.DAMAGE_RESISTANCE);
+		if (data == null)	return;
+
+		if (!data.GetReason().equals(GetName()))
+			return;
+
+		//Damage
+		event.AddMod(damagee.getName(), GetName(), 0, false);
+		event.SetKnockback(false);
+	}
+
+	@EventHandler
+	public void Particle(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		for (Player player : GetUsers())
+		{
+			Condition data = Factory.Condition().GetActiveCondition(player, ConditionType.DAMAGE_RESISTANCE);
+			if (data == null)	continue;
+
+			if (!data.GetReason().equals(GetName()))
+				continue;
+
+			UtilParticle.PlayParticle(ParticleType.MOB_SPELL, player.getLocation(), 
+					(float)(Math.random() - 0.5), 0.2f + (float)(Math.random() * 1), (float)(Math.random() - 0.5), 0, 3 + getLevel(player),
+					ViewDist.NORMAL, UtilServer.getPlayers());
+			
+			player.setFoodLevel(2);
+			player.setSprinting(false);
+		}
+	}
+
+	@EventHandler
+	public void on(ConditionExpireEvent event)
+	{
+		if (event.getCondition().GetReason().equals(GetName()) && event.getCondition().GetEnt() instanceof Player)
+		{
+			if (event.getCondition().GetType() == ConditionType.DAMAGE_RESISTANCE)
+			{
+				Player player = ((Player) event.getCondition().GetEnt());
+				if (_foodLevel.get(player) != null)
+				{
+					player.setFoodLevel(_foodLevel.get(player));
+				}
+				// Could be null value. Sanity check
+				_foodLevel.remove(player);
+			}
+		}
+	}
+
+	@EventHandler
+	public void on(PlayerQuitEvent event)
+	{
+		_foodLevel.remove(event.getPlayer());
+	}
+
+	@Override
+	public void Reset(Player player)
+	{
+		player.setFoodLevel(20);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Knight/Knight.java

@@ -0,0 +1,31 @@
+package mineplex.minecraft.game.classcombat.Skill.Knight;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.entity.EntityShootBowEvent;
+
+import mineplex.core.energy.event.EnergyEvent;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.Skill.Global.BowDeficiencySkill;
+
+public class Knight extends BowDeficiencySkill
+{
+	public Knight(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"25% reduction in Arrow Velocity."
+				});
+	}
+
+	@EventHandler
+	public void CancelEnergy(EnergyEvent event)
+	{
+		if (getLevel(event.GetPlayer()) > 0)
+			event.setCancelled(true);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Knight/LevelField.java

@@ -0,0 +1,189 @@
+package mineplex.minecraft.game.classcombat.Skill.Knight;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.bukkit.craftbukkit.v1_8_R3.inventory.CraftInventoryCrafting;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.event.player.PlayerDropItemEvent;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilGear;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.common.util.UtilTime;
+import mineplex.core.recharge.Recharge;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.Skill.event.SkillTriggerEvent;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+
+public class LevelField extends Skill
+{
+
+	private final Set<Player> _active = new HashSet<>();
+
+	public LevelField(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels)
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[]
+				{
+						"Drop Axe/Sword to Use.",
+						"",
+						"You deal X more damage.",
+						"You take X less damage.",
+						"X = (Nearby Enemies) - (Nearby Allies)",
+						"Players within #4#2 Blocks are considered.",
+						"",
+						"Damage can be altered a maximum of #1#1.",
+						"You can not deal less damage, or take",
+						"more damage via this.",
+						"",
+						"Lasts for #6#1."
+				});
+	}
+
+	@Override
+	public String GetRechargeString()
+	{
+		return "Recharge: #16#-1 Seconds";
+	}
+
+	@EventHandler
+	public void Use(PlayerDropItemEvent event)
+	{
+		Player player = event.getPlayer();
+
+		if (!(player.getOpenInventory().getTopInventory() instanceof CraftInventoryCrafting))
+		{
+			return;
+		}
+
+		int level = getLevel(player);
+
+		if (level == 0 || !UtilGear.isWeapon(event.getItemDrop().getItemStack()) || !Recharge.Instance.usable(player, GetName(), true))
+		{
+			return;
+		}
+
+		event.setCancelled(true);
+
+		//Check Allowed
+		SkillTriggerEvent trigger = new SkillTriggerEvent(player, GetName(), GetClassType());
+		UtilServer.CallEvent(trigger);
+
+		if (trigger.IsCancelled())
+		{
+			return;
+		}
+
+		long start = System.currentTimeMillis();
+		_active.add(player);
+
+		player.sendMessage(F.main("Skill", "You used " + F.skill(GetName(level)) + "."));
+
+		Factory.runSyncTimer(new BukkitRunnable()
+		{
+			@Override
+			public void run()
+			{
+				if (!player.isOnline() || UtilTime.elapsed(start, 6000 + (1000 * level)))
+				{
+					Recharge.Instance.use(player, GetName(), 16000 - (1000 * level), true, false);
+					Reset(player);
+					cancel();
+					return;
+				}
+
+				UtilParticle.playParticleFor(player, ParticleType.HAPPY_VILLAGER, player.getLocation().add(0, 0.5, 0), 1, 0.3F, 1, 0, 1, ViewDist.LONG);
+			}
+		}, 0, 2);
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void alterDamage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled() || event.GetCause() != DamageCause.ENTITY_ATTACK)
+		{
+			return;
+		}
+
+		Player damagee = event.GetDamageePlayer(), damager = event.GetDamagerPlayer(false);
+
+		if (damagee == null || damager == null)
+		{
+			return;
+		}
+
+		{
+			int level = getLevel(damagee);
+
+			if (level == 0)
+			{
+				return;
+			}
+
+			event.AddMod(damagee.getName(), GetName(), getAlteration(damagee, level, false), false);
+		}
+		{
+			int level = getLevel(damager);
+
+			if (level == 0)
+			{
+				return;
+			}
+
+			event.AddMod(damager.getName(), GetName(), getAlteration(damager, level, true), false);
+		}
+	}
+
+	private int getAlteration(Player player, int level, boolean positive)
+	{
+		int alt = 0;
+
+		for (Player other : UtilPlayer.getNearby(player.getLocation(), 4 + (2 * level)))
+		{
+			if (player.equals(other))
+			{
+				alt--;
+			}
+			else if (Factory.Relation().canHurt(player, other))
+			{
+				alt++;
+			}
+			else
+			{
+				alt--;
+			}
+		}
+
+		int limit = 1 + level;
+
+		alt = Math.min(alt, limit);
+		alt = Math.max(alt, -limit);
+
+		if (positive)
+		{
+			return Math.max(0, alt);
+		}
+		else
+		{
+			return Math.min(0, -alt);
+		}
+	}
+
+	@Override
+	public void Reset(Player player)
+	{
+		_active.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Knight/PowerChop.java

@@ -0,0 +1,107 @@
+package mineplex.minecraft.game.classcombat.Skill.Knight;
+
+import java.util.WeakHashMap;
+
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+
+import mineplex.core.common.util.UtilEnt;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilGear;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilTime;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class PowerChop extends SkillActive
+{
+	private WeakHashMap<Player, Long> _charge = new WeakHashMap<Player, Long>();
+
+	public PowerChop(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Put more strength into your next",
+				"axe attack, causing it to deal",
+				"2 bonus damage.",
+				"",
+				"Attack must be made within",
+				"0.5 seconds of being used."
+				});
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		return mineplex.core.recharge.Recharge.Instance.use(player, GetName() + " Cooldown", 250, false, false);
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		//Action
+		_charge.put(player, System.currentTimeMillis());
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You prepared " + F.skill(GetName(level)) + "."));
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void Damage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+
+		if (event.GetCause() != DamageCause.ENTITY_ATTACK)
+			return;
+
+		Player damager = event.GetDamagerPlayer(false);
+		if (damager == null)		return;
+
+		if (!UtilGear.isAxe(damager.getItemInHand()))
+			return;
+
+		if (!_charge.containsKey(damager))
+			return;
+		
+		if (UtilTime.elapsed(_charge.remove(damager), 500))
+			return;
+		
+		//Damage
+		event.AddMod(damager.getName(), GetName(), 2, true);
+
+		//Effect
+		damager.getWorld().playSound(damager.getLocation(), Sound.IRONGOLEM_HIT, 1f, 1f);
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_charge.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Knight/Riposte.java

@@ -0,0 +1,202 @@
+package mineplex.minecraft.game.classcombat.Skill.Knight;
+
+import java.util.HashMap;
+import java.util.HashSet;
+
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+
+import mineplex.core.common.util.UtilEnt;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class Riposte extends SkillActive
+{
+	private HashMap<Player, Long> _prepare = new HashMap<Player, Long>();
+	private HashMap<Player, LivingEntity> _block = new HashMap<Player, LivingEntity>();
+
+	public Riposte(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Block an incoming attack to parry,",
+				"then quickly return the attack ",
+				"to riposte.",
+				"",
+				"If successful, you deal an additional",
+				"#0#0.5 bonus damage.",
+				"",
+				"You must block, parry, then riposte",
+				"all within 1 second of each other."
+				});
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+		
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		//Prepare
+		_prepare.put(player, System.currentTimeMillis() + 1000);
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You prepared to " + F.skill(GetName(level)) + "."));
+	}
+
+	@EventHandler(priority = EventPriority.NORMAL)
+	public void DoParry(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+		
+		if (event.GetCause() != DamageCause.ENTITY_ATTACK)
+			return;
+
+		//Damagee
+		Player damagee = event.GetDamageePlayer();
+		if (damagee == null)	return;
+
+		//Blocking
+		if (!damagee.isBlocking())
+			return;
+
+		if (!_prepare.containsKey(damagee))
+			return;
+
+		//Damager
+		LivingEntity damager = event.GetDamagerEntity(false);
+		if (damager == null)	return;
+
+		//Level
+		int level = getLevel(damagee);
+		if (level == 0)			return;
+
+		//Prepare
+		if (!_block.containsKey(damagee))
+		{
+			//Cancel
+			event.SetCancelled(GetName() + " Parry");
+
+			//Add
+			_block.put(damagee, damager);
+			_prepare.put(damagee, System.currentTimeMillis() + 1000);
+
+			//Effect
+			damager.getWorld().playSound(damager.getLocation(), Sound.ZOMBIE_METAL, 0.5f, 1.6f);
+			
+			Factory.Condition().Factory().Invulnerable(GetName(), damagee, damagee, 0.3, false, false);
+
+			//Inform
+			UtilPlayer.message(damagee, F.main(GetClassType().name(), "You parried with " + F.skill(GetName(level)) + "."));
+			UtilPlayer.message(event.GetDamagerPlayer(false), F.main(GetClassType().name(), F.name(damagee.getName()) + " parried with " + F.skill(GetName(level)) + "."));
+		}
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void DoRiposte(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+		
+		if (event.GetCause() != DamageCause.ENTITY_ATTACK)
+			return;
+
+		//Damager
+		Player damager = event.GetDamagerPlayer(false);
+		if (damager == null)	return;
+
+		if (!_prepare.containsKey(damager))
+			return;
+
+		//Level
+		int level = getLevel(damager);
+		if (level == 0)			return;
+
+		//Counter
+		if (_block.containsKey(damager))
+		{
+			//End
+			LivingEntity target = _block.remove(damager);
+			_prepare.remove(damager);
+
+			//Damage
+			event.AddMod(damager.getName(), GetName(), 0.5 * level, true);
+
+			//Effect
+			damager.getWorld().playSound(damager.getLocation(), Sound.ZOMBIE_METAL, 1f, 1.2f);
+
+			//UtilPlayer.health(damager, 1);
+			//UtilParticle.PlayParticle(ParticleType.HEART, damager.getEyeLocation(), 0, 0.3f, 0, 0, 1);
+
+			//Inform
+			UtilPlayer.message(damager, F.main(GetClassType().name(), "You countered with " + F.skill(GetName(level)) + "."));
+			UtilPlayer.message(target, F.main(GetClassType().name(), F.name(damager.getName()) + " countered with " + F.skill(GetName(level)) + "."));
+		}
+	}
+
+	@EventHandler
+	public void End(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		HashSet<Player>	expired = new HashSet<Player>();
+
+		for (Player cur : _prepare.keySet())
+			if (System.currentTimeMillis() > _prepare.get(cur))
+				expired.add(cur);
+
+		for (Player cur : expired)
+		{
+			//Remove
+			_prepare.remove(cur);
+			_block.remove(cur);
+
+			//Inform
+			UtilPlayer.message(cur, F.main(GetClassType().name(), "You failed to " + F.skill(GetName()) + "."));
+		}
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_prepare.remove(player);
+		_block.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Knight/ShieldSmash.java

@@ -0,0 +1,131 @@
+package mineplex.minecraft.game.classcombat.Skill.Knight;
+
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.block.Action;
+import org.bukkit.util.Vector;
+
+import mineplex.core.common.util.UtilEnt;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilAction;
+import mineplex.core.common.util.UtilMath;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class ShieldSmash extends SkillActive
+{
+	public ShieldSmash(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Smash your shield into an enemy,",
+				"dealing #1.6#0.2 knockback."
+				});
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		if (!mineplex.core.recharge.Recharge.Instance.use(player, GetName() + " Cooldown", 250, false, false))
+			return false;
+
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		//AoE Area
+		Location loc = player.getLocation();
+		loc.add(player.getLocation().getDirection().setY(0).normalize().multiply(1.5));
+		loc.add(0, 0.8, 0);
+		
+		//Particle
+		UtilParticle.PlayParticle(ParticleType.CLOUD, loc, 0, 0, 0, 0.05f, 6,
+				ViewDist.LONG, UtilServer.getPlayers());
+		UtilParticle.PlayParticle(ParticleType.LARGE_EXPLODE, loc, 0, 0, 0, 0, 1,
+				ViewDist.LONG, UtilServer.getPlayers());
+		
+		boolean hit = false;
+
+		for (Entity other : player.getWorld().getEntities())
+		{
+			if (!(other instanceof LivingEntity))
+				continue;
+			
+			LivingEntity cur = (LivingEntity)other;
+
+			if (cur.equals(player))
+				continue;
+			
+			if (UtilPlayer.isSpectator(cur))
+				continue;
+
+			if (UtilMath.offset(loc, cur.getLocation()) > 2.5)
+				continue;
+
+			hit = true;
+			
+			Vector dir = player.getLocation().getDirection();
+			if (dir.getY() < 0)
+				dir.setY(0);
+			
+			//Velocity
+			UtilAction.velocity(cur, dir, 1.6 + 0.2 * level, false, 0, 0.3, 0.8 + 0.05 * level, true);
+			
+			//Condition
+			Factory.Condition().Factory().Falling(GetName(), cur, player, 10, false, true);
+			
+			//Inform
+			UtilPlayer.message(cur, F.main(GetClassType().name(), F.name(player.getName()) +" hit you with " + F.skill(GetName(level)) + "."));
+		}
+		
+		if (hit)
+		{
+			//Inform
+			UtilPlayer.message(player, F.main("Skill", "You used " + F.skill(GetName(level)) + "."));
+			
+			//Sound
+			player.getWorld().playSound(player.getLocation(), Sound.ZOMBIE_METAL, 1f, 0.9f);
+		}
+		else
+		{
+			//Inform
+			UtilPlayer.message(player, F.main("Skill", "You missed " + F.skill(GetName(level)) + "."));
+		}	
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Knight/Swordsmanship.java

@@ -0,0 +1,103 @@
+package mineplex.minecraft.game.classcombat.Skill.Knight;
+
+import java.util.HashMap;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilGear;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.recharge.Recharge;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.core.updater.UpdateType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class Swordsmanship extends Skill
+{
+	private HashMap<Player, Integer> _charges = new HashMap<Player, Integer>();
+	
+	public Swordsmanship(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Prepare a powerful sword attack;",
+				"You gain 1 Charge every #5#-1 seconds.",
+				"You can store a maximum of #1#1 Charges.",
+				"",
+				"When you next attack, your damage is",
+				"increased by the number of your Charges,",
+				"and your Charges are reset to 0.",
+				"",
+				"This only applies for Swords."
+				});
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void IncreaseDamage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+		
+		if (event.GetCause() != DamageCause.ENTITY_ATTACK)
+			return;
+
+		//Damagee
+		Player damager = event.GetDamagerPlayer(false);
+		if (damager == null)	return;
+
+		if (!_charges.containsKey(damager))
+			return;
+		
+		if (!UtilGear.isSword(damager.getItemInHand()))
+			return;
+
+		event.AddMod(damager.getName(), GetName(), _charges.remove(damager), false);
+		
+		//Cooldown
+		int level = getLevel(damager);
+		Recharge.Instance.useForce(damager, GetName(), 5000 - (1000 * level));
+	}
+	
+	@EventHandler
+	public void Charge(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+		
+		for (Player cur : GetUsers())
+		{
+			int level = getLevel(cur);
+			
+			if (!Recharge.Instance.use(cur, GetName(), 5000 - (1000 * level), false, false))
+				continue;
+						
+			int max = 1 + level;
+			
+			int charge = 1;
+			if (_charges.containsKey(cur))
+				charge += _charges.get(cur);
+			
+			if (charge <= max)
+			{
+				_charges.put(cur, charge);
+				
+				//Inform
+				UtilPlayer.message(cur, F.main(GetClassType().name(), "Swordsmanship Charges: " + F.elem(charge+"")));
+			}
+		}
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_charges.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Knight/Vengeance.java

@@ -0,0 +1,115 @@
+package mineplex.minecraft.game.classcombat.Skill.Knight;
+
+import java.util.HashMap;
+import java.util.WeakHashMap;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class Vengeance extends Skill
+{
+	private WeakHashMap<Player, HashMap<String, Integer>> _vengeance = new WeakHashMap<Player, HashMap<String, Integer>>();
+
+	public Vengeance(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"When you attack someone, your damage",
+				"is increased by #0#0.5 for each time the",
+				"enemy hurt you since you last hit them,",
+				"up to a maximum of #0#1 bonus damage."
+				});
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void RegisterDamage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+		
+		if (event.GetCause() != DamageCause.ENTITY_ATTACK && event.GetCause() != DamageCause.PROJECTILE)
+			return;
+
+		//Damagee
+		Player damagee = event.GetDamageePlayer();
+		if (damagee == null)	return;
+
+		int level = getLevel(damagee);
+		if (level == 0)			return;
+
+		//Damager
+		Player damager = event.GetDamagerPlayer(false);
+		if (damager == null)	return;
+
+		if (!_vengeance.containsKey(damagee))
+			_vengeance.put(damagee, new HashMap<String, Integer>());
+
+		//Register Hit
+		if (!_vengeance.get(damagee).containsKey(damager.getName()))
+		{
+			//Ignore the first melee hit, or 1v1 duels are extremely unfair.
+			if (event.GetCause() != DamageCause.PROJECTILE)
+				_vengeance.get(damagee).put(damager.getName(), 0);
+			else
+				_vengeance.get(damagee).put(damager.getName(), 1);
+		}
+		else
+		{
+			_vengeance.get(damagee).put(damager.getName(), _vengeance.get(damagee).get(damager.getName()) + 1);
+		}
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void IncreaseDamage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+		
+		if (event.GetCause() != DamageCause.ENTITY_ATTACK)
+			return;
+ 
+		//Damager
+		Player damager = event.GetDamagerPlayer(false);
+		if (damager == null)	return;
+
+		int level = getLevel(damager);
+		if (level == 0)			return;
+
+		if (!_vengeance.containsKey(damager))
+			return;
+
+		//Damagee
+		Player damagee = event.GetDamageePlayer();
+		if (damagee == null)	return;
+
+		if (!_vengeance.get(damager).containsKey(damagee.getName()))
+			return;
+		
+		if (_vengeance.get(damager).get(damagee.getName()) == 0)
+			return;
+		
+		int hits = _vengeance.get(damager).remove(damagee.getName());
+		
+		double damage = (double)hits * (0.5 * level);
+		
+		damage = Math.min(damage, level * 1);
+		
+		//Increase
+		event.AddMod(damager.getName(), GetName(), damage, true);
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_vengeance.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/LocationFilter.java

@@ -0,0 +1,18 @@
+package mineplex.minecraft.game.classcombat.Skill;
+
+import org.bukkit.Location;
+
+/*
+ * Determines whether a location is acceptable for an action to be performed
+ */
+public interface LocationFilter
+{
+	LocationFilter ACCEPT_ALL = location -> true;
+
+	/*
+	 * Check if the given location is acceptable
+	 * @param location The location to check
+	 * @return Whether the location is valid, or invalid
+	 */
+	boolean accept(Location location);
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Mage/ArcticArmor.java

@@ -0,0 +1,299 @@
+package mineplex.minecraft.game.classcombat.Skill.Mage;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.event.player.PlayerDropItemEvent;
+
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilBlock;
+import mineplex.core.common.util.UtilGear;
+import mineplex.core.common.util.UtilMath;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.Skill.event.SkillTriggerEvent;
+
+public class ArcticArmor extends Skill
+{
+
+	private static final double DELTA_THETA = Math.PI / 10;
+	private static final double FENCE_FROM_CENTER_DIST = 0.95;
+
+	private final Set<Player> _active = new HashSet<>();
+
+	public ArcticArmor(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels)
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[]
+				{
+						"Drop Axe/Sword to Toggle.",
+						"",
+						"Create a freezing area around you",
+						"in a #3#1 Block radius. Allies inside",
+						"this area receive Protection 2.",
+						"",
+						"You receive Protection 2."
+				});
+	}
+
+	@Override
+	public String GetEnergyString()
+	{
+		return "Energy: #11#-1 per Second";
+	}
+
+	@EventHandler
+	public void Toggle(PlayerDropItemEvent event)
+	{
+		Player player = event.getPlayer();
+
+		if (getLevel(player) == 0)
+			return;
+
+		if (!UtilGear.isWeapon(event.getItemDrop().getItemStack()))
+			return;
+
+		event.setCancelled(true);
+
+		//Check Allowed
+		SkillTriggerEvent trigger = new SkillTriggerEvent(player, GetName(), GetClassType());
+		UtilServer.getServer().getPluginManager().callEvent(trigger);
+		if (trigger.IsCancelled())
+			return;
+
+		if (_active.contains(player))
+		{
+			Remove(player);
+		}
+		else
+		{
+			if (!Factory.Energy().Use(player, "Enable " + GetName(), 10, true, true))
+				return;
+
+			Add(player);
+		}
+	}
+
+	public void Add(Player player)
+	{
+		_active.add(player);
+		UtilPlayer.message(player, F.main(GetClassType().name(), F.skill(GetName()) + ": " + F.oo("Enabled", true)));
+	}
+
+	public void Remove(Player player)
+	{
+		_active.remove(player);
+		UtilPlayer.message(player, F.main(GetClassType().name(), F.skill(GetName()) + ": " + F.oo("Disabled", false)));
+		Factory.Condition().EndCondition(player, null, GetName());
+	}
+
+	@EventHandler
+	public void Audio(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.SEC)
+			return;
+
+		for (Player cur : _active)
+			cur.getWorld().playSound(cur.getLocation(), Sound.AMBIENCE_RAIN, 0.3f, 0f);
+	}
+
+	@EventHandler
+	public void SnowAura(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		for (Player cur : GetUsers())
+		{
+			if (!_active.contains(cur))
+				continue;
+
+			//Level
+			int level = getLevel(cur);
+			if (level == 0)
+			{
+				Remove(cur);
+				continue;
+			}
+
+			//Check Allowed
+			SkillTriggerEvent trigger = new SkillTriggerEvent(cur, GetName(), GetClassType());
+			UtilServer.getServer().getPluginManager().callEvent(trigger);
+			if (trigger.IsCancelled())
+			{
+				Remove(cur);
+				continue;
+			}
+
+			//Energy
+			if (!Factory.Energy().Use(cur, GetName(), 0.55 - (level * 0.05), true, true))
+			{
+				Remove(cur);
+				continue;
+			}
+
+			//Blocks
+			Location location = cur.getLocation();
+			double duration = 2000;
+			int radius = 3 + level;
+
+			UtilBlock.getInRadius(location, radius).forEach((block, scale) ->
+			{
+				Block up = block.getRelative(BlockFace.UP);
+
+				if (block.getType().toString().contains("BANNER") || up.isLiquid() || block.getLocation().getY() > cur.getLocation().getY())
+				{
+					return;
+				}
+
+				//Freeze
+				Material type = block.getType();
+
+				if (UtilBlock.water(type) || type == Material.ICE)
+				{
+					for (Player player : block.getWorld().getPlayers())
+					{
+						if (UtilPlayer.isSpectator(player))
+						{
+							continue;
+						}
+
+						Location playerLocation = player.getLocation();
+						Block playerBlock = playerLocation.getBlock();
+						Location moveTo = null;
+
+						// Force players up if they try and get themselves stuck
+						if (playerBlock.equals(block))
+						{
+							moveTo = playerLocation.add(0, 1, 0);
+						}
+						else
+						{
+							Location blockLocation = block.getLocation().add(0.5, 0, 0.5);
+
+							for (BlockFace face : UtilBlock.horizontals)
+							{
+								Block nextBlock = block.getRelative(face);
+
+								if (UtilBlock.isFence(nextBlock) && playerBlock.equals(nextBlock) && Math.abs(playerLocation.getX() - blockLocation.getX()) < FENCE_FROM_CENTER_DIST && Math.abs(playerLocation.getZ() - blockLocation.getZ()) < FENCE_FROM_CENTER_DIST)
+								{
+									moveTo = block.getLocation().add(0.5, 1, 0.5);
+
+									moveTo.setYaw(playerLocation.getYaw());
+									moveTo.setPitch(playerLocation.getPitch());
+									break;
+								}
+							}
+						}
+
+						// Only move the player if they are being moved into air
+						if (moveTo != null && moveTo.getBlock().getType() == Material.AIR)
+						{
+							player.teleport(moveTo);
+						}
+					}
+
+					Factory.BlockRestore().add(block, 79, (byte) 0, (long) (duration * (1 + scale)));
+				}
+			});
+
+			location.add(0, 0.1, 0);
+
+			for (double t = 0; t < 2 * Math.PI; t += DELTA_THETA)
+			{
+				double x = radius * Math.cos(t), z = radius * Math.sin(t);
+
+				location.add(x, 0, z);
+
+				UtilParticle.PlayParticleToAll(ParticleType.SNOW_SHOVEL, location, 0.5F, 0.5F, 0.5F, 0, 1, ViewDist.LONG);
+
+				location.subtract(x, 0, z);
+			}
+		}
+	}
+
+	@EventHandler
+	public void ProtectionAura(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.FAST)
+		{
+			return;
+		}
+
+		for (Player cur : _active)
+		{
+			//Protection
+			for (Player other : UtilPlayer.getNearby(cur.getLocation(), 3 + getLevel(cur)))
+			{
+				if (!Factory.Relation().canHurt(cur, other) || other.equals(cur))
+				{
+					Factory.Condition().Factory().Protection(GetName(), other, cur, 1.9, 1, false, true, true);
+				}
+			}
+		}
+	}
+
+	@EventHandler
+	public void Damage(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.FAST)
+			return;
+
+		for (Player cur : UtilServer.getPlayers())
+		{
+			if (UtilPlayer.isSpectator(cur))
+				continue;
+
+			if (cur.getEyeLocation().getBlock().getType() == Material.ICE)
+			{
+				if (!Factory.BlockRestore().contains(cur.getEyeLocation().getBlock()))
+					continue;
+
+				Player damager = null;
+				double closest = 0;
+
+				for (Player player : _active)
+				{
+					if (player.equals(cur))
+						continue;
+
+					double dist = UtilMath.offsetSquared(player, cur);
+
+					if (dist < 25 && (damager == null || dist < closest))
+					{
+						damager = player;
+						closest = dist;
+					}
+				}
+
+				//Damage Event
+				Factory.Damage().NewDamageEvent(cur, damager, null,
+						DamageCause.CUSTOM, 2, false, true, false,
+						damager == null ? null : damager.getName(), "Arctic Ice");
+			}
+		}
+	}
+
+	@Override
+	public void Reset(Player player)
+	{
+		_active.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Mage/Blizzard.java

@@ -0,0 +1,261 @@
+
+package mineplex.minecraft.game.classcombat.Skill.Mage;
+
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.WeakHashMap;
+
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.entity.Snowball;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.util.Vector;
+
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilAction;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilMath;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+
+public class Blizzard extends SkillActive
+{
+
+	private final Set<Player> _active = new HashSet<>();
+	private final Map<Projectile, Player> _snowball = new WeakHashMap<>();
+
+	public Blizzard(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Hold Block to release a Blizzard.",
+				"Releases #1#1 snowballs per wave",
+				"which push players away from you."
+				});
+	}
+
+	@Override
+	public String GetEnergyString()
+	{
+		return "Energy: 31#-1 per Second";
+	}
+	
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		return true;
+	}
+	
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		_active.add(player);
+	}
+	
+	@EventHandler
+	public void Energy(UpdateEvent event) 
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		for (Player cur : GetUsers())
+		{
+			if (!_active.contains(cur))
+				continue;
+			
+			if (!cur.isBlocking())
+			{
+				_active.remove(cur);
+				continue;
+			}
+
+			//Level
+			int level = getLevel(cur);
+			if (level == 0)			
+			{
+				_active.remove(cur);
+				continue;
+			}
+
+			//Energy
+			if (!Factory.Energy().Use(cur, GetName(), 1.55 - level * 0.05, true, true))
+			{
+				_active.remove(cur);
+			}
+		}
+	}
+
+	@EventHandler
+	public void Snow(UpdateEvent event) 
+	{
+		if (event.getType() != UpdateType.FASTEST)
+			return;
+
+		for (Player cur : GetUsers())
+		{
+			if (!_active.contains(cur))
+				continue;
+			
+			if (!cur.isBlocking())
+			{
+				_active.remove(cur);
+				continue;
+			}
+
+			//Level
+			int level = getLevel(cur);
+			if (level == 0)			
+			{
+				_active.remove(cur);
+				continue;
+			}
+
+			//Target
+//			HashSet<Byte> ignore = new HashSet<Byte>();
+//			ignore.add((byte) 0);
+//			ignore.add((byte) 78);
+//			ignore.add((byte) 80);
+
+//			Block target = cur.getTargetBlock(ignore, 7);
+
+			//Snowballs
+//			if (target == null || target.getType() == Material.AIR || UtilMath.offset(target.getLocation(), cur.getLocation()) > 5)
+//				for (int i=0 ; i<1+level ; i++)
+//				{
+//					Projectile snow = cur.launchProjectile(Snowball.class);
+//					
+//					double mult = 0.25 + 0.15 * level;
+//					double x = (0.2 - (UtilMath.r(40)/100d)) * mult;
+//					double y = (UtilMath.r(20)/100d) * mult;
+//					double z = (0.2 - (UtilMath.r(40)/100d)) * mult;
+//					
+//					
+//					
+//					snow.setVelocity(cur.getLocation().getDirection().add(new Vector(x,y,z)).multiply(2));
+//					_snowball.put(snow, cur);
+//				}
+//
+//			if (target == null || target.getType() == Material.AIR)				
+//				continue;
+//
+//			if (UtilMath.offset(target.getLocation(), cur.getLocation()) > 7)
+//				continue;
+//
+//			HashMap<Block, Double> blocks = UtilBlock.getInRadius(target.getLocation(), 2d, 1);
+//			for (Block block : blocks.keySet())
+//			{
+//				Factory.BlockRestore().Snow(block, (byte)(1 + (int)(2*blocks.get(block))), (byte)(7*level), 2500, 250, 3);
+//			}
+			
+			//Snowballs
+			for (int i=0 ; i<1+level ; i++)
+			{
+				Projectile snow = cur.launchProjectile(Snowball.class);
+				
+				double mult = 0.25 + 0.15 * level;
+				double x = (0.2 - (UtilMath.r(40)/100d)) * mult;
+				double y = (UtilMath.r(20)/100d) * mult;
+				double z = (0.2 - (UtilMath.r(40)/100d)) * mult;
+				
+				
+				
+				snow.setVelocity(cur.getLocation().getDirection().add(new Vector(x,y,z)).multiply(2));
+				_snowball.put(snow, cur);
+			}
+
+			//Effect
+//			target.getWorld().playEffect(target.getLocation(), Effect.STEP_SOUND, 80);
+			cur.getWorld().playSound(cur.getLocation(), Sound.STEP_SNOW, 0.1f, 0.5f);
+		}
+	}
+
+	@EventHandler(priority = EventPriority.LOW)
+	public void Snowball(CustomDamageEvent event)
+	{		
+		if (event.GetCause() != DamageCause.PROJECTILE)
+			return;
+
+		Projectile proj = event.GetProjectile();
+		if (proj == null)		return;
+
+		if (!(proj instanceof Snowball))
+			return;
+		
+		if (!_snowball.containsKey(proj))
+			return;
+
+		LivingEntity damagee = event.GetDamageeEntity();
+		if (damagee == null)	return;
+
+		event.SetCancelled(GetName());
+		UtilAction.velocity(damagee, proj.getVelocity().multiply(0.1).add(new Vector(0, 0.15, 0)));
+	}
+
+//	@EventHandler
+//	public void SnowballForm(ProjectileHitEvent event)
+//	{
+//		if (!(event.getEntity() instanceof Snowball))
+//			return;
+//		
+//		if (_snowball.remove(event.getEntity()) == null)
+//			return;
+//
+//		Factory.BlockRestore().Snow(event.getEntity().getLocation().getBlock(), (byte)1, (byte)7, 2000, 250, 0);
+//	}
+	
+	@EventHandler
+	public void clearInvalidSnowballedPlayers(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.FASTER)
+			return;
+		
+		for (Iterator<Entry<Projectile, Player>> snowBallIterator = _snowball.entrySet().iterator(); snowBallIterator.hasNext();) 
+		{
+			Entry<Projectile, Player> entry = snowBallIterator.next();
+			
+			if (!entry.getKey().isValid() || entry.getKey().getTicksLived() > 25 || !entry.getValue().isOnline())
+			{
+				snowBallIterator.remove();
+				entry.getKey().remove();
+			}
+		}
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_active.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Mage/FireBlast.java

@@ -0,0 +1,127 @@
+package mineplex.minecraft.game.classcombat.Skill.Mage;
+
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.LargeFireball;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.ProjectileHitEvent;
+import org.bukkit.util.Vector;
+
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilAction;
+import mineplex.core.common.util.UtilAlg;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.event.FireballHitEntityEvent;
+
+public class FireBlast extends SkillActive
+{
+	public FireBlast(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Launch a fireball which explodes on impact",
+				"dealing large knockback to enemies within",
+				"#6#0.5 Blocks range. Also ignites enemies",
+				"for up to #2#2 seconds."
+				});
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		//Action
+		LargeFireball ball = player.launchProjectile(LargeFireball.class);
+		ball.setShooter(player);
+		ball.setIsIncendiary(false);		
+		ball.setYield(0);
+		ball.setBounce(false);
+		ball.teleport(player.getEyeLocation().add(player.getLocation().getDirection().multiply(1)));
+		ball.setVelocity(new Vector(0,0,0));
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You used " + F.skill(GetName(level)) + "."));
+
+		//Effect
+		player.getWorld().playSound(player.getLocation(), Sound.GHAST_FIREBALL, 1f, 0.8f);
+	}
+
+	@EventHandler
+	public void Collide(ProjectileHitEvent event)
+	{
+		Projectile proj = event.getEntity();
+
+		if (!(proj instanceof LargeFireball))
+			return;
+
+		if (proj.getShooter() == null)
+			return;
+
+		if (!(proj.getShooter() instanceof Player))
+			return;
+		
+		Player player = (Player)proj.getShooter();
+
+		//Level
+		int level = getLevel(player);
+		if (level == 0)				return;
+
+		//Velocity Players
+		UtilEnt.getInRadius(proj.getLocation(), 5.5 + (0.5 * level)).forEach((cur, range) ->
+		{
+			FireballHitEntityEvent fireballEvent = new FireballHitEntityEvent(proj, cur);
+			UtilServer.CallEvent(fireballEvent);
+			
+			if (fireballEvent.isCancelled())
+			{
+				return;
+			}
+			
+			//Damage Event
+			Factory.Condition().Factory().Ignite(GetName(), cur, player, (2 + (1 * level)) * range, false, false);
+
+			//Condition
+			Factory.Condition().Factory().Falling(GetName(), cur, player, 10, false, true);
+			
+			//Velocity
+			UtilAction.velocity(cur, UtilAlg.getTrajectory(proj.getLocation().add(0, -0.5, 0), cur.getEyeLocation()), 1.6 * range, false, 0, 0.8 * range, 1.2, true);
+		});
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Mage/Fissure.java

@@ -0,0 +1,107 @@
+package mineplex.minecraft.game.classcombat.Skill.Mage;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.Action;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.core.common.util.F;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class Fissure extends SkillActive 
+{
+
+	private final Set<FissureData> _active = new HashSet<>();
+	
+	public Fissure(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Fissures the earth infront of you,",
+				"creating an impassable wall.",
+				"",
+				"Players struck by the initial slam",
+				"receive Slow 2 for #2#0.5 seconds",
+				"",
+				"Players struck by the fissure",
+				"receive #2#0.4 damage plus an ",
+				"additional #0.6#0.2 damage for",
+				"every block fissure has travelled."
+				});
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+		
+		if (!UtilEnt.isGrounded(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " while airborne."));
+			return false;
+		}
+
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		FissureData data = new FissureData(this, player, level, player.getLocation().getDirection(), player.getLocation().add(0, -0.4, 0));
+		_active.add(data);
+		
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You used " + F.skill(GetName(level)) + "."));
+	}
+	
+	@EventHandler
+	public void Update(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+		{
+			return;
+		}
+
+		_active.removeIf(data ->
+		{
+			if (data.Update())
+			{
+				data.Clear();
+				return true;
+			}
+
+			return false;
+		});
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Mage/FissureData.java

@@ -0,0 +1,216 @@
+package mineplex.minecraft.game.classcombat.Skill.Mage;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilBlock;
+import mineplex.core.common.util.UtilMath;
+import mineplex.core.common.util.UtilPlayer;
+
+import mineplex.core.common.util.UtilServer;
+import mineplex.minecraft.game.classcombat.Skill.Mage.events.FissureModifyBlockEvent;
+import org.bukkit.Effect;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.entity.Player;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.util.Vector;
+
+public class FissureData 
+{
+	private Fissure Host;
+
+	private Player _player;
+	private int _level;
+
+	private Vector _vec;
+	private Location _loc;
+	private Location _startLoc;
+
+	private int _height = 0;
+	private int _handled = 0;
+
+	private HashSet<Player> _hit = new HashSet<Player>();
+
+	private ArrayList<Block> _path = new ArrayList<Block>();
+
+	public FissureData(Fissure host, Player player, int level, Vector vec, Location loc)
+	{
+		Host = host;
+
+		vec.setY(0);
+		vec.normalize();
+		vec.multiply(0.1);
+
+		this._player = player;
+		this._level = level;
+		this._vec = vec;
+		this._loc = loc;
+		this._startLoc = new Location(loc.getWorld(), loc.getX(), loc.getY(), loc.getZ());
+
+		MakePath();
+	}
+
+	private void MakePath() 
+	{	
+		while (UtilMath.offset2d(_loc, _startLoc) < 14) 
+		{
+			_loc.add(_vec);
+
+			Block block = _loc.getBlock();
+
+			if (block.equals(_startLoc.getBlock()))
+				continue;
+
+			if (_path.contains(block))
+				continue;
+
+			//Up
+			if (UtilBlock.solid(block.getRelative(BlockFace.UP)))
+			{
+				_loc.add(0, 1, 0);
+				block = _loc.getBlock();
+
+				if (UtilBlock.solid(block.getRelative(BlockFace.UP)))
+					return;
+			}
+
+			//Down
+			else if (!UtilBlock.solid(block))
+			{
+				_loc.add(0, -1, 0);
+				block = _loc.getBlock();
+
+				if (!UtilBlock.solid(block))
+					return;
+			}
+
+			if (UtilMath.offset(block.getLocation().add(0.5, 0.5, 0.5), _loc) > 0.5)
+				continue;
+
+			_path.add(block);
+
+			//Effect
+			_loc.getWorld().playEffect(block.getLocation(), Effect.STEP_SOUND, block.getTypeId());
+
+			//Slow
+			for (Player cur : block.getWorld().getPlayers())
+			{
+				if (UtilPlayer.isSpectator(cur)) continue;
+				
+				if (!cur.equals(_player))
+				{
+					if (UtilMath.offset(block.getLocation().add(0.5, 0.5, 0.5), cur.getLocation()) < 1.5)
+					{
+						//Condition
+						Host.Factory.Condition().Factory().Slow("Fissure", cur, _player, 1 + _level, 1, false, true, true, true);
+					}
+				}
+			}
+		}
+	}
+
+	public boolean Update() 
+	{
+		if (_handled >= _path.size())
+			return true;
+
+		Block block = _path.get(_handled);
+
+		//Cannot raise TNT/WATER
+		if (block.getType() == Material.TNT || block.isLiquid())
+		{
+			return false;
+		}
+		FissureModifyBlockEvent event = UtilServer.CallEvent(new FissureModifyBlockEvent(block));
+		if (event.isCancelled())
+		{
+			return false;
+		}
+		if (block.getType().toString().contains("BANNER"))
+			return false;
+		if (block.getRelative(BlockFace.UP).getType().toString().contains("BANNER"))
+			return false;
+		if (block.getType() == Material.ANVIL)
+			return false;
+		if (block.getRelative(BlockFace.UP).getType() == Material.ANVIL)
+			return false;
+
+		Block up = block.getRelative(0, _height + 1, 0);
+
+		//Done Column
+		if (!UtilBlock.airFoliage(up))
+		{
+			_loc.getWorld().playEffect(up.getLocation(), Effect.STEP_SOUND, up.getTypeId());
+			_height = 0;
+			_handled++;
+			return false;
+		}
+
+		//Boost Column
+		if (block.getTypeId() == 1)		Host.Factory.BlockRestore().add(block, 4, block.getData(), 14000);
+		if (block.getTypeId() == 2)		Host.Factory.BlockRestore().add(block, 3, block.getData(), 14000);
+		if (block.getTypeId() == 98)	Host.Factory.BlockRestore().add(block, 98, (byte) 0, 14000);
+		Host.Factory.BlockRestore().add(up, block.getTypeId(), block.getData(), 10000 - (1000 * _height));
+		_height++;
+
+		//Effect
+		up.getWorld().playEffect(up.getLocation(), Effect.STEP_SOUND, block.getTypeId());
+
+		//Damage
+		for (Player cur : up.getWorld().getPlayers())
+		{
+			if (UtilPlayer.isSpectator(cur))
+				continue;
+			
+			if (!cur.equals(_player))
+			{
+				//Teleport
+				if (cur.getLocation().getBlock().equals(block))
+				{
+					cur.teleport(cur.getLocation().add(0, 1, 0));
+				}
+
+				//Damage
+				if (!_hit.contains(cur))
+				{
+					if (UtilMath.offset(up.getLocation().add(0.5, 0.5, 0.5), cur.getLocation()) < 1.8)
+					{
+						_hit.add(cur);
+
+						double damage = 2 + (0.4 * _level) + (_handled * (0.7 + 0.1 * _level));
+
+						//Damage Event
+						Host.Factory.Damage().NewDamageEvent(cur, _player, null, 
+								DamageCause.CUSTOM, damage, true, false, false,
+								_player.getName(), "Fissure");
+
+						//Inform
+						UtilPlayer.message(cur, F.main(Host.GetClassType().name(), F.name(_player.getName()) +" hit you with " + F.skill(Host.GetName(_level)) + "."));
+					}
+				}
+			}
+		}
+		//Next Column
+		if (_height >= Math.min(3, _handled/2 + 1))
+		{
+			_height = 0;
+			_handled++;
+		}
+
+		return (_handled >= _path.size());
+	}
+
+	public void Clear() 
+	{
+		_hit.clear();
+		_path.clear();
+		Host = null;
+		_player = null;
+		_loc = null;
+		_startLoc = null;
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Mage/FreezingBlast.java

@@ -0,0 +1,157 @@
+package mineplex.minecraft.game.classcombat.Skill.Mage;
+
+import java.util.HashMap;
+
+import org.bukkit.Effect;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.block.Action;
+
+import mineplex.core.common.util.UtilEnt;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.core.common.util.F;
+import mineplex.core.itemstack.ItemStackFactory;
+import mineplex.core.projectile.IThrown;
+import mineplex.core.projectile.ProjectileUser;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.common.util.UtilBlock;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class FreezingBlast extends SkillActive implements IThrown
+{
+	public FreezingBlast(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Launch a freezing blast;",
+				"Creates long lasting Snow, and",
+				"gives Slow 4 to nearby players.",
+				"",
+				"Direct hit applies Frost Armor,",
+				"giving Protection 4 and Slow 4",
+				"for 10 seconds.",
+				});
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		//Action
+		Item item = player.getWorld().dropItem(player.getEyeLocation().add(player.getLocation().getDirection()), ItemStackFactory.Instance.CreateStack(79));
+		item.setVelocity(player.getLocation().getDirection());
+		Factory.Projectile().AddThrow(item, player, this, -1, true, true, true, true, 
+				Sound.FIZZ, 0.6f, 1.6f, null, 0, UpdateType.FASTEST, 1f);
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You used " + F.skill(GetName(level)) + "."));
+
+		//Effect
+		item.getWorld().playSound(item.getLocation(), Sound.SILVERFISH_HIT, 2f, 1f);
+	}
+
+	@Override
+	public void Collide(LivingEntity target, Block block, ProjectileUser data) 
+	{
+		Action(target, data);
+	}
+
+	@Override
+	public void Idle(ProjectileUser data) 
+	{
+		Action(null, data);	
+	}
+
+	@Override
+	public void Expire(ProjectileUser data) 
+	{
+		Action(null, data);	
+	}
+
+	public void Action(LivingEntity target, ProjectileUser data)
+	{
+		//Effect
+		data.getThrown().getWorld().playEffect(data.getThrown().getLocation(), Effect.STEP_SOUND, 79);
+
+		//Remove
+		data.getThrown().remove();
+
+		//Thrower
+		if (!(data.getThrower() instanceof Player))
+			return;
+
+		Player player = (Player)data.getThrower();
+
+		//Level
+		int level = getLevel(player);
+		if (level == 0)				return;
+
+		//Snow Spread
+		HashMap<Block, Double> blocks = UtilBlock.getInRadius(data.getThrown().getLocation(), 4d);
+		for (Block cur : blocks.keySet()) 
+		{
+			if (UtilBlock.airFoliage(cur) && UtilBlock.solid(cur.getRelative(BlockFace.DOWN)))
+			{
+				Factory.BlockRestore().snow(cur, (byte) (7 * blocks.get(cur)), (byte) 7, (long) (15000 * (1 + blocks.get(cur))), 1000, 0);
+				cur.getWorld().playEffect(cur.getLocation(), Effect.STEP_SOUND, 80);
+			}
+		}
+
+		//Slow Players
+		for (Player curPlayer : UtilPlayer.getNearby(data.getThrown().getLocation(), 4))
+			Factory.Condition().Factory().Slow(GetName(), curPlayer, player, 2.9, 0, false, true, true, true);
+
+		if (target == null)
+			return;
+
+		//Freeze
+		Factory.Condition().Factory().Protection(GetName(), target, player, 10, 3, false, true, true);
+		Factory.Condition().Factory().Slow(GetName(), target, player, 10, 3, false, true, true, true);
+
+		//Inform
+		UtilPlayer.message(target, F.main(GetClassType().name(), F.name(player.getName()) + " used " + F.skill("Frost Armor") + " on you."));
+
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+
+	}
+	
+	@Override
+	public void ChunkUnload(ProjectileUser data)
+	{
+		data.getThrown().remove();
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Mage/GlacialBlade.java

@@ -0,0 +1,125 @@
+package mineplex.minecraft.game.classcombat.Skill.Mage;
+
+import org.bukkit.Effect;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.core.itemstack.ItemStackFactory;
+import mineplex.core.projectile.IThrown;
+import mineplex.core.projectile.ProjectileUser;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.common.util.UtilAction;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class GlacialBlade extends SkillActive implements IThrown
+{
+	public GlacialBlade(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Swinging your sword releases a",
+				"shard of ice, dealing 3.5 damage",
+				"to anything it hits.",
+				"",
+				"Will not work if enemies are close."
+				});
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		for (Player cur : UtilPlayer.getNearby(player.getLocation(), 4))
+			if (cur.equals(player))
+				continue;
+			else if (Factory.Relation().canHurt(cur, player))
+				return false;
+		
+		return !isInWater(player);
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		//Action
+		Item item = player.getWorld().dropItem(player.getEyeLocation().add(player.getLocation().getDirection()).subtract(0, 0.2, 0), ItemStackFactory.Instance.CreateStack(370));
+		UtilAction.velocity(item, player.getLocation().getDirection(), 1.6, false, 0, 0.2, 10, false);
+		Factory.Projectile().AddThrow(item, player, this, -1, true, true, true, true, 
+				null, 0, 0, ParticleType.SNOW_SHOVEL, UpdateType.TICK, 0.3f);
+
+		//Effect
+		item.getWorld().playSound(item.getLocation(), Sound.ORB_PICKUP, 1f, 2f);
+	}
+
+	@Override
+	public void Collide(LivingEntity target, Block block, ProjectileUser data) 
+	{		
+		//Effect
+		data.getThrown().getWorld().playEffect(data.getThrown().getLocation(), Effect.STEP_SOUND, 20);
+
+		//Remove
+		data.getThrown().remove();
+
+		if (target == null)
+			return;
+
+		//Damage
+		Factory.Damage().NewDamageEvent(target, data.getThrower(), null,
+				DamageCause.CUSTOM, 3.5, false, true, false,
+				UtilEnt.getName(data.getThrower()), GetName());
+	}
+
+	@Override
+	public void Idle(ProjectileUser data) 
+	{
+		//Effect
+		data.getThrown().getWorld().playEffect(data.getThrown().getLocation(), Effect.STEP_SOUND, 20);
+
+		//Remove
+		data.getThrown().remove();
+	}
+
+	@Override
+	public void Expire(ProjectileUser data) 
+	{
+		//Effect
+		data.getThrown().getWorld().playEffect(data.getThrown().getLocation(), Effect.STEP_SOUND, 20);
+
+		//Remove
+		data.getThrown().remove();
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+
+	}
+	
+	@Override
+	public void ChunkUnload(ProjectileUser data)
+	{
+		data.getThrown().remove();
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Mage/IcePrison.java

@@ -0,0 +1,203 @@
+package mineplex.minecraft.game.classcombat.Skill.Mage;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.bukkit.Effect;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.block.BlockFadeEvent;
+
+import mineplex.core.common.util.UtilEnt;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.core.common.util.F;
+import mineplex.core.itemstack.ItemStackFactory;
+import mineplex.core.projectile.IThrown;
+import mineplex.core.projectile.ProjectileUser;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.common.util.UtilBlock;
+import mineplex.core.common.util.UtilMath;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class IcePrison extends SkillActive implements IThrown
+{
+	public IcePrison(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Launch an icy orb. When it collides,",
+				"it creates a hollow sphere of ice",
+				"thats lasts for #3#1 seconds.",
+				});
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		//Action
+		Item item = player.getWorld().dropItem(player.getEyeLocation().add(player.getLocation().getDirection()), ItemStackFactory.Instance.CreateStack(79));
+		item.setVelocity(player.getLocation().getDirection());
+		Factory.Projectile().AddThrow(item, player, this, -1, true, true, true, true, 
+				Sound.FIZZ, 0.6f, 1.6f, ParticleType.SNOW_SHOVEL, UpdateType.TICK, 1.5f); 
+ 
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You used " + F.skill(GetName(level)) + ".")); 
+
+		//Effect
+		item.getWorld().playSound(item.getLocation(), Sound.SILVERFISH_HIT, 2f, 1f);
+	}
+
+	@Override
+	public void Collide(LivingEntity target, Block block, ProjectileUser data) 
+	{
+		Action(target, data);
+	}
+
+	@Override
+	public void Idle(ProjectileUser data) 
+	{
+		Action(null, data);	
+	}
+
+	@Override
+	public void Expire(ProjectileUser data) 
+	{
+		Action(null, data);	
+	}
+
+	public void Action(LivingEntity target, ProjectileUser data)
+	{
+		//Effect
+		data.getThrown().getWorld().playEffect(data.getThrown().getLocation(), Effect.STEP_SOUND, 79);
+
+		//Remove
+		data.getThrown().remove();
+
+		//Thrower
+		if (!(data.getThrower() instanceof Player))
+			return;
+
+		Player player = (Player)data.getThrower();
+
+		//Level
+		int level = getLevel(player);
+		if (level == 0)				return;
+
+		Block block = data.getThrown().getLocation().getBlock();
+
+		//Sphere
+		HashMap<Block, Double> blocks = UtilBlock.getInRadius(block, 3.8d);
+		// To save having to calculate everything again
+		Set<Block> acceptable = new HashSet<>();
+		boolean failed = false;
+		for (Block cur : blocks.keySet()) 
+		{
+			if (!UtilBlock.airFoliage(cur))
+				continue;
+
+			if (UtilMath.offset(block.getLocation(), cur.getLocation()) <= 2.9)
+				continue;
+			
+			//Leave roof hole
+			if (cur.getX() == block.getX() && cur.getZ() == block.getZ() && cur.getY() > block.getY())
+				continue;
+
+			if (getLocationFilter().accept(cur.getLocation()))
+			{
+				acceptable.add(cur);
+			}
+			else
+			{
+				failed = true;
+				break;
+			}
+		}
+
+		if (!failed)
+		{
+			for (Block cur : acceptable)
+			{
+				FreezeBlock(cur, block, level);
+			}
+		}
+		else
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " here."));
+		}
+
+		/*
+		FreezeBlock(block.getRelative(3, 0, 3), block, level);
+		FreezeBlock(block.getRelative(-3, 0, -3), block, level);
+		FreezeBlock(block.getRelative(-3, 0, 3), block, level);
+		FreezeBlock(block.getRelative(3, 0, -3), block, level);
+		*/
+	}
+	
+	public void FreezeBlock(Block freeze, Block mid, int level)
+	{
+		if (!UtilBlock.airFoliage(freeze))
+			return;
+		
+		long time = 3500 + (1000 * level);
+		
+		int yDiff = freeze.getY() - mid.getY();
+		
+		time -= yDiff * 1000 - Math.random() * 1000;
+
+		Factory.BlockRestore().add(freeze, 79, (byte) 0, time);
+		freeze.getWorld().playEffect(freeze.getLocation(), Effect.STEP_SOUND, 79);
+	}
+	
+	@EventHandler
+	public void BlockFade(BlockFadeEvent event)
+	{
+		if (event.getBlock().getType() == Material.ICE)
+			event.setCancelled(true);
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+
+	}
+	
+	@Override
+	public void ChunkUnload(ProjectileUser data)
+	{
+		data.getThrown().remove();
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Mage/Immolate.java

@@ -0,0 +1,227 @@
+package mineplex.minecraft.game.classcombat.Skill.Mage;
+
+import java.util.HashSet;
+
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.entity.EntityCombustEvent;
+import org.bukkit.event.player.PlayerDropItemEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.util.Vector;
+
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilGear;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.itemstack.ItemStackFactory;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.Skill.event.SkillTriggerEvent;
+
+public class Immolate extends Skill
+{
+	private HashSet<Entity> _active = new HashSet<Entity>();
+
+	public Immolate(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Drop Axe/Sword to Toggle.",
+				"",
+				"Ignite yourself in flaming fury.",
+				"You receive Strength #1#1 , Speed 1,",
+				"Fire Resistance",
+				"",
+				"You leave a trail of fire, which",
+				"ignites players for #0.25#0.25 seconds."
+				});
+	}
+
+	@Override
+	public String GetEnergyString()
+	{
+		return "Energy: #15#-1 per Second";
+	}
+
+	@EventHandler
+	public void Toggle(PlayerDropItemEvent event)
+	{
+		Player player = event.getPlayer();
+
+		if (getLevel(player) == 0)				
+			return;
+
+		if (!UtilGear.isWeapon(event.getItemDrop().getItemStack()))
+			return;
+
+		event.setCancelled(true);
+
+		//Check Allowed
+		SkillTriggerEvent trigger = new SkillTriggerEvent(player, GetName(), GetClassType());
+		UtilServer.getServer().getPluginManager().callEvent(trigger);
+		if (trigger.IsCancelled())
+			return;
+
+		if (_active.contains(player))
+		{
+			Remove(player);	
+		}
+		else
+		{
+			if (!Factory.Energy().Use(player, "Enable " + GetName(), 10, true, true))
+				return;
+
+			Add(player);
+		}
+	}
+
+	public void Add(Player player)
+	{
+		_active.add(player);
+		Conditions();
+		UtilPlayer.message(player, F.main(GetClassType().name(), GetName() + ": " + F.oo("Enabled", true)));
+	}
+
+	public void Remove(Player player)
+	{
+		_active.remove(player);
+		UtilPlayer.message(player, F.main(GetClassType().name(), GetName() + ": " + F.oo("Disabled", false)));
+		
+		Factory.Condition().EndCondition(player, null, GetName());
+		Factory.Condition().Factory().FireResist(GetName(), player, player, 1.9, 0, false, true, true);
+	}
+
+	@EventHandler
+	public void Aura(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		for (Player cur : GetUsers())
+		{	
+			if (!_active.contains(cur))
+				continue;
+
+			//Level
+			int level = getLevel(cur);
+			if (level == 0)
+			{
+				Remove(cur);	
+				continue;
+			}
+
+			//Check Allowed
+			SkillTriggerEvent trigger = new SkillTriggerEvent(cur, GetName(), GetClassType());
+			UtilServer.getServer().getPluginManager().callEvent(trigger);
+			if (trigger.IsCancelled())
+			{
+				Remove(cur);
+				continue;
+			}
+			
+			if (cur.getLocation().getBlock().getType() == Material.WATER || cur.getLocation().getBlock().getType() == Material.STATIONARY_WATER)
+			{
+				Remove(cur);
+				continue;
+			}
+
+			//Energy
+			if (!Factory.Energy().Use(cur, GetName(), 0.65 - (level * 0.05), true, true))
+			{
+				Remove(cur);
+				continue;
+			}	
+
+			//Put out Fire
+			cur.setFireTicks(0);
+		}
+	}
+
+	@EventHandler
+	public void Combust(EntityCombustEvent event)
+	{
+		if (_active.contains(event.getEntity()))
+			event.setCancelled(true);
+	}
+
+	@EventHandler
+	public void Update(UpdateEvent event)
+	{
+		if (event.getType() == UpdateType.FAST)
+			Conditions();
+
+		if (event.getType() == UpdateType.TICK)
+			Flames();
+	}
+
+	public void Conditions()
+	{
+		for (Player cur : GetUsers())
+		{	
+			if (!_active.contains(cur))
+				continue;
+			
+			int level = getLevel(cur);
+
+			Factory.Condition().Factory().Speed(GetName(), cur, cur, 1.9, 0, false, true, true);
+			Factory.Condition().Factory().Strength(GetName(), cur, cur, 1.9, level, false, true, true);
+			Factory.Condition().Factory().FireResist(GetName(), cur, cur, 1.9, 0, false, true, true);
+			
+			for (Player other : UtilPlayer.getNearby(cur.getLocation(), 6))
+			{
+				if (cur.equals(other))
+				{
+					continue;
+				}
+				else if (Factory.Relation().canHurt(cur, other))
+				{
+					continue;
+				}
+				
+				Factory.Condition().Factory().FireResist("Allied Immolate", other, cur, 2, 0, true, true, false);
+			}
+		}
+	}
+
+	public void Flames()
+	{
+		for (Player cur : GetUsers())
+		{	
+			if (!_active.contains(cur))
+				continue;
+
+			int level = getLevel(cur);
+			
+			//Fire
+			ItemStack itemStack = ItemStackFactory.Instance.CreateStack(Material.BLAZE_POWDER, 1);
+			ItemMeta meta = itemStack.getItemMeta();
+			meta.setDisplayName(ChatColor.RESET + "" + UtilEnt.getNewEntityId(false));
+			itemStack.setItemMeta(meta);
+			
+			Item fire = cur.getWorld().dropItem(cur.getLocation().add(0, 0.5, 0), itemStack);
+			fire.setVelocity(new Vector((Math.random() - 0.5)/3,Math.random()/3,(Math.random() - 0.5)/3));
+			Factory.Fire().Add(fire, cur, 2, 0, 0.25 + (level * 0.25), 0, GetName(), false);
+
+			//Sound
+			cur.getWorld().playSound(cur.getLocation(), Sound.FIZZ, 0.2f, 1f);
+		}
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_active.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Mage/Inferno.java

@@ -0,0 +1,160 @@
+package mineplex.minecraft.game.classcombat.Skill.Mage;
+
+import java.util.HashSet;
+
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.Action;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.util.Vector;
+
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilMath;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.itemstack.ItemStackFactory;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.core.condition.Condition;
+import mineplex.minecraft.game.core.condition.Condition.ConditionType;
+import mineplex.minecraft.game.core.condition.events.ConditionApplyEvent;
+
+public class Inferno extends SkillActive
+{
+	private HashSet<Player> _active = new HashSet<Player>();
+	
+	public Inferno(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Hold Block to use Inferno;",
+				"You spray fire at #1.05#0.15 velocity,",
+				"igniting enemies for #0.3#0.1 ."
+				});
+	}
+	
+	@Override
+	public String GetEnergyString()
+	{
+		return "Energy: #34#-1 per Second";
+	}
+	
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " .in water."));
+			return false;
+		}
+
+		return true;
+	}
+	
+	@Override
+	public void Skill(Player player, int level)
+	{
+		_active.add(player);
+	}
+
+	@EventHandler
+	public void Update(UpdateEvent event)  
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		for (Player cur : GetUsers())
+		{
+			if (!_active.contains(cur))
+				continue;
+			
+			if (!UtilPlayer.isBlocking(cur))
+			{
+				_active.remove(cur);
+				continue;
+			}
+  
+			//Level
+			int level = getLevel(cur);
+			if (level == 0)		
+			{
+				_active.remove(cur);
+				continue;
+			}
+			
+			//Energy
+			if (!Factory.Energy().Use(cur, GetName(), 1.7 - (0.05 * level), true, false))
+			{
+				_active.remove(cur);
+				continue;
+			} 
+
+			//Fire
+			ItemStack itemStack = ItemStackFactory.Instance.CreateStack(Material.BLAZE_POWDER, 1);
+			ItemMeta meta = itemStack.getItemMeta();
+			meta.setDisplayName(ChatColor.RESET + "" + UtilEnt.getNewEntityId(false));
+			itemStack.setItemMeta(meta);
+			
+			Item fire = cur.getWorld().dropItem(cur.getEyeLocation().add(cur.getLocation().getDirection()), itemStack);
+			Factory.Fire().Add(fire, cur, 0.7, 0, 0.3 + (0.1 * level), .375, GetName(), false);
+
+			fire.teleport(cur.getEyeLocation());
+			double x = 0.07 - (UtilMath.r(14)/100d);
+			double y = 0.07 - (UtilMath.r(14)/100d);
+			double z = 0.07 - (UtilMath.r(14)/100d);
+			fire.setVelocity(cur.getLocation().getDirection().add(new Vector(x,y,z)).multiply(1.05 + (0.15 * level)));
+
+			//Effect
+			cur.getWorld().playSound(cur.getLocation(), Sound.GHAST_FIREBALL, 0.1f, 1f);
+		}
+	}
+
+	@EventHandler
+	public void ignite(ConditionApplyEvent event)
+	{
+		Condition condition = event.GetCondition();
+		LivingEntity entity = condition.GetEnt(), source = condition.GetSource();
+
+		if (condition.GetType() != ConditionType.BURNING || source == null)
+		{
+			return;
+		}
+
+		if (!(entity instanceof Player) || !(source instanceof Player))
+		{
+			return;
+		}
+
+		if (!Factory.Relation().canHurt((Player) source, (Player) entity))
+		{
+			event.setCancelled(true);
+		}
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_active.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Mage/LifeBonds.java

@@ -0,0 +1,348 @@
+package mineplex.minecraft.game.classcombat.Skill.Mage;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.event.inventory.InventoryPickupItemEvent;
+import org.bukkit.event.player.PlayerDropItemEvent;
+import org.bukkit.event.player.PlayerPickupItemEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.util.Vector;
+
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilAlg;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilGear;
+import mineplex.core.common.util.UtilMath;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.itemstack.ItemStackFactory;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.Skill.event.SkillTriggerEvent;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+
+public class LifeBonds extends Skill
+{
+
+	private final Set<Player> _active = new HashSet<>();
+	private final Set<Item> _items = new HashSet<>();
+	private final Set<LifeBondsData> _hearts = new HashSet<>();
+
+	public LifeBonds(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Drop Axe/Sword to Toggle.",
+				"",
+				"Transfers life from yourself to",
+				"nearby allies with less health.",
+				"",
+				"Transfers #0.5#0.5 health every second.",
+				"Maximum range of #3#3 Blocks from user."
+				});
+	}
+
+	@Override
+	public String GetEnergyString()
+	{
+		return "Energy: #9#-1 per Second";
+	}
+
+	@EventHandler
+	public void Toggle(PlayerDropItemEvent event)
+	{
+		Player player = event.getPlayer();
+
+		if (getLevel(player) == 0)				
+			return;
+
+		if (!UtilGear.isWeapon(event.getItemDrop().getItemStack()))
+			return;
+
+		event.setCancelled(true);
+
+		//Check Allowed
+		SkillTriggerEvent trigger = new SkillTriggerEvent(player, GetName(), GetClassType());
+		UtilServer.getServer().getPluginManager().callEvent(trigger);
+		if (trigger.IsCancelled())
+			return;
+
+		if (_active.contains(player))
+		{
+			Remove(player);	
+		}
+		else
+		{
+			if (!Factory.Energy().Use(player, "Enable " + GetName(), 10, true, true))
+				return;
+
+			Add(player);
+		}
+	}
+
+	public void Add(Player player)
+	{
+		_active.add(player);
+		UtilPlayer.message(player, F.main(GetClassType().name(), GetName() + ": " + F.oo("Enabled", true)));
+	}
+
+	public void Remove(Player player)
+	{
+		_active.remove(player);
+		UtilPlayer.message(player, F.main(GetClassType().name(), GetName() + ": " + F.oo("Disabled", false)));
+	}
+
+	@EventHandler
+	public void Energy(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		for (Player cur : GetUsers())
+		{	
+			if (!_active.contains(cur))
+				continue;
+
+			//Level
+			int level = getLevel(cur);
+			if (level == 0)
+			{
+				Remove(cur);	
+				continue;
+			}
+
+			//Check Allowed
+			SkillTriggerEvent trigger = new SkillTriggerEvent(cur, GetName(), GetClassType());
+			UtilServer.getServer().getPluginManager().callEvent(trigger);
+			if (trigger.IsCancelled())
+			{
+				Remove(cur);
+				continue;
+			}
+
+			//Energy
+			if (!Factory.Energy().Use(cur, GetName(), 0.45 - (level * 0.05), true, true))
+			{
+				_active.remove(cur);
+				UtilPlayer.message(cur, F.main(GetClassType().name(), GetName() + ": " + F.oo("Disabled", false)));
+			}
+		}
+	}
+
+	@EventHandler
+	public void Plants(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.FASTEST)
+			return;
+
+		for (Player cur : GetUsers())
+		{	
+			if (!_active.contains(cur))
+				continue;
+
+			for (Player other : UtilPlayer.getNearby(cur.getLocation(), 8))
+			{
+				if (Factory.Relation().canHurt(cur, other) && !other.equals(cur))
+					continue;
+
+				//Plants
+				ItemStack stack;
+
+				double r = Math.random();
+
+				if (r > 0.4)		stack = ItemStackFactory.Instance.CreateStack(31, (byte)1);
+				else if (r > 0.11)	stack = ItemStackFactory.Instance.CreateStack(31, (byte)2);
+				else if (r > 0.05)	stack = ItemStackFactory.Instance.CreateStack(37, (byte)0);
+				else				stack = ItemStackFactory.Instance.CreateStack(38, (byte)0);
+
+				Item item = other.getWorld().dropItem(other.getLocation().add(0, 0.4, 0), stack);
+				_items.add(item);
+
+				Vector vec = new Vector(Math.random() - 0.5, Math.random()/2 + 0.2, Math.random() - 0.5).normalize();
+				vec.multiply(0.1 + Math.random()/8);
+				item.setVelocity(vec);
+			}
+		}
+	}
+
+	@EventHandler
+	public void LifeTransfer(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.SEC)
+			return;
+
+		for (Player cur : GetUsers())
+		{	
+			if (!_active.contains(cur))
+				continue;
+			
+			int level = getLevel(cur);
+			
+			//Bonds
+			Player lowest = null;
+			double lowestHp = 20;
+
+			for (Player other : UtilPlayer.getNearby(cur.getLocation(), 6 + (2 * level)))
+			{
+				if (Factory.Relation().canHurt(cur, other) && !other.equals(cur))
+					continue;
+
+				if (lowest == null || other.getHealth() < lowestHp)
+				{
+					lowest = other;
+					lowestHp = other.getHealth();
+				}
+			}
+			
+			//Nothing to Transfer
+			if (cur.equals(lowest) || cur.getHealth() - lowestHp < 2)
+				continue;
+
+			double amount = 0.5 + (0.5 * level);
+			
+			amount = Math.min((cur.getHealth() - lowestHp) / 2d, amount);
+			
+			//Steal
+			UtilPlayer.health(cur, -amount * .25);
+
+			//Hearts
+			_hearts.add(new LifeBondsData(cur.getLocation().add(0, 0.8, 0), lowest, amount));
+		}
+	}
+	
+	@EventHandler
+	public void Hearts(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.FASTEST)
+			return;
+
+		_hearts.removeIf(LifeBondsData::update);
+	}
+
+	@EventHandler
+	public void ItemPickup(PlayerPickupItemEvent event)
+	{
+		if (_items.contains(event.getItem()))
+			event.setCancelled(true);
+	}
+
+	@EventHandler
+	public void HopperPickup(InventoryPickupItemEvent event)
+	{
+		if (_items.contains(event.getItem()))
+			event.setCancelled(true);
+	}
+
+	@EventHandler
+	public void ItemDestroy(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		_items.removeIf(cur ->
+		{
+			if (UtilEnt.isGrounded(cur) || cur.getTicksLived() > 40 || cur.isDead() || !cur.isValid())
+			{
+				Block block = cur.getLocation().getBlock();
+				if (block.getType() == Material.AIR)
+				{
+					int below = block.getRelative(BlockFace.DOWN).getTypeId();
+					if (below == 2 || below == 3)
+					{
+						byte data = 0;
+						if (cur.getItemStack().getData() != null)
+							data = cur.getItemStack().getData().getData();
+
+						Factory.BlockRestore().add(block, cur.getItemStack().getTypeId(), data, 2000);
+					}
+				}
+
+				cur.remove();
+				return true;
+			}
+
+			return false;
+		});
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void damage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled() || event.GetCause() != DamageCause.ENTITY_ATTACK)
+		{
+			return;
+		}
+
+		Player damagee = event.GetDamageePlayer(), damager = event.GetDamagerPlayer(false);
+
+		if (damagee == null || damager == null)
+		{
+			return;
+		}
+
+		int level = getLevel(damager);
+
+		if (level == 0 || !_active.contains(damager))
+		{
+			return;
+		}
+
+		UtilPlayer.health(damager, 0.25 + 0.25 * level);
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_active.remove(player);
+	}
+
+	private class LifeBondsData
+	{
+
+		Location _loc;
+		Player _target;
+		double _health;
+
+		LifeBondsData(org.bukkit.Location loc, Player target, double amount)
+		{
+			_loc = loc;
+			_target = target;
+			_health = amount;
+		}
+
+		boolean update()
+		{
+			if (!_target.isValid() || !_target.isOnline())
+				return true;
+
+			if (UtilMath.offsetSquared(_loc, _target.getLocation()) < 1)
+			{
+				UtilPlayer.health(_target, _health);
+				return true;
+			}
+
+			_loc.add(UtilAlg.getTrajectory(_loc, _target.getLocation().add(0, 0.8, 0)).multiply(2.5));
+			UtilParticle.PlayParticleToAll(ParticleType.HEART, _loc, 0, 0, 0, 0, 1, ViewDist.LONG);
+			return false;
+		}
+
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Mage/LightningOrb.java

@@ -0,0 +1,195 @@
+package mineplex.minecraft.game.classcombat.Skill.Mage;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.block.BlockIgniteEvent;
+import org.bukkit.event.block.BlockIgniteEvent.IgniteCause;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.event.player.PlayerEvent;
+
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilMath;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.itemstack.ItemBuilder;
+import mineplex.core.projectile.IThrown;
+import mineplex.core.projectile.ProjectileUser;
+import mineplex.core.updater.UpdateType;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class LightningOrb extends SkillActive implements IThrown
+{
+	public static class LightningOrbEvent extends PlayerEvent
+	{
+		private static final HandlerList handlers = new HandlerList();
+
+		public static HandlerList getHandlerList()
+		{
+			return handlers;
+		}
+
+		@Override
+		public HandlerList getHandlers()
+		{
+			return getHandlerList();
+		}
+
+		private final List<LivingEntity> _struck;
+
+		LightningOrbEvent(Player who, List<LivingEntity> struck)
+		{
+			super(who);
+
+			_struck = struck;
+		}
+
+		public List<LivingEntity> getStruck()
+		{
+			return _struck;
+		}
+	}
+
+	public LightningOrb(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Launch a lightning orb. Upon a direct",
+				"hit with player, or 1.7 seconds, it will",
+				"strike all enemies within #3#0.5 Blocks ",
+				"with lightning, dealing #4#1 damage and",
+				"giving Slow 2 for 4 seconds."
+				});
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		//Action
+		Item item = player.getWorld().dropItem(player.getEyeLocation().add(player.getLocation().getDirection()),new ItemBuilder(Material.DIAMOND_BLOCK).setTitle(UtilMath.random.nextDouble() + "").build());
+		item.setVelocity(player.getLocation().getDirection());
+		Factory.Projectile().AddThrow(item, player, this, 1700, true, true, false, false, 
+				Sound.FIZZ, 0.6f, 1.6f, ParticleType.FIREWORKS_SPARK, UpdateType.TICK, 0.4f);
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You used " + F.skill(GetName(level)) + "."));
+
+		//Effect 
+		item.getWorld().playSound(item.getLocation(), Sound.SILVERFISH_HIT, 2f, 1f);
+	}
+
+	@Override
+	public void Collide(LivingEntity target, Block block, ProjectileUser data) 
+	{
+		Strike(data);
+	}
+
+	@Override
+	public void Idle(ProjectileUser data) 
+	{
+		Strike(data);
+	}
+
+	@Override
+	public void Expire(ProjectileUser data) 
+	{
+		Strike(data);
+	}
+
+	@Override
+	public void ChunkUnload(ProjectileUser data)
+	{
+		data.getThrown().remove();
+	}
+
+	public void Strike(ProjectileUser data)
+	{
+		//Remove
+		data.getThrown().remove();
+
+		//Thrower
+		if (!(data.getThrower() instanceof Player))
+			return;
+
+		Player player = (Player)data.getThrower();
+
+		//Level
+		int level = getLevel(player);
+		if (level == 0)				return;
+
+		List<LivingEntity> struck = new ArrayList<>();
+
+		UtilEnt.getInRadius(data.getThrown().getLocation(), 3 + 0.5 * level).forEach((cur, scale) ->
+		{
+			if (cur.equals(player) || (cur instanceof Player && !Factory.Relation().canHurt(player, (Player) cur)))
+			{
+				return;
+			}
+
+			//Inform
+			UtilPlayer.message(cur, F.main(GetClassType().name(), F.name(player.getName()) + " hit you with " + F.skill(GetName(level)) + "."));
+
+			//Lightning
+			cur.getWorld().strikeLightningEffect(cur.getLocation());
+
+			//Damage Event
+			Factory.Damage().NewDamageEvent(cur, player, null, DamageCause.LIGHTNING, 4 + level, false, true, false, player.getName(), GetName());
+			Factory.Condition().Factory().Slow(GetName(), cur, player, 4, 1, false, true, true, true);
+			Factory.Condition().Factory().Shock(GetName(), cur, player, 1, false, true);
+
+			struck.add(cur);
+		});
+
+		Bukkit.getPluginManager().callEvent(new LightningOrbEvent(player, struck));
+	}
+	
+	@EventHandler
+	public void CancelFire(BlockIgniteEvent event)
+	{
+		if (event.getCause() == IgniteCause.LIGHTNING)
+			event.setCancelled(true);
+	}
+	
+	@Override
+	public void Reset(Player player) 
+	{
+
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Mage/Mage.java

@@ -0,0 +1,30 @@
+package mineplex.minecraft.game.classcombat.Skill.Mage;
+
+import org.bukkit.entity.Arrow;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.entity.EntityShootBowEvent;
+import org.bukkit.metadata.FixedMetadataValue;
+import org.bukkit.metadata.MetadataValue;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.Skill.Global.BowDeficiencySkill;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+
+public class Mage extends BowDeficiencySkill
+{
+	public Mage(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"25% reduction in Arrow Velocity."
+				});
+	}
+	
+	
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Mage/MagmaBlade.java

@@ -0,0 +1,71 @@
+package mineplex.minecraft.game.classcombat.Skill.Mage;
+
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+
+import mineplex.core.common.util.UtilGear;
+import mineplex.minecraft.game.core.condition.Condition.ConditionType;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class MagmaBlade extends Skill
+{
+	public MagmaBlade(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Your sword deals an additional,",
+				"#0#1 damage to burning opponents,",
+				"but also extinguishes them.",
+				});
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void Damage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+
+		if (event.GetCause() != DamageCause.ENTITY_ATTACK)
+			return;
+		
+		//Damagee
+		Player damagee = event.GetDamageePlayer();
+		if (damagee == null)	return;
+
+		if (damagee.getFireTicks() <= 0)
+			return;
+
+		//Damager
+		Player damager = event.GetDamagerPlayer(false);
+		if (damager == null)	return;
+
+		if (!UtilGear.isSword(damager.getItemInHand()))
+			return;
+
+		int level = getLevel(damager);
+		if (level == 0)			return;
+
+		//Damage
+		event.AddMod(damager.getName(), GetName(), level, true);
+
+		//Effect
+		damager.getWorld().playSound(damager.getLocation(), Sound.FIZZ, 0.8f, 0f);
+		
+		Factory.Condition().EndCondition(damagee, ConditionType.BURNING, null);
+		damagee.setFireTicks(0);
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Mage/Magnetize.java

@@ -0,0 +1,130 @@
+package mineplex.minecraft.game.classcombat.Skill.Mage;
+
+import java.util.HashSet;
+
+import org.bukkit.Effect;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.Action;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.core.common.util.F;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.common.util.UtilAction;
+import mineplex.core.common.util.UtilAlg;
+import mineplex.core.common.util.UtilMath;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class Magnetize extends SkillActive
+{
+	private HashSet<Player> _active = new HashSet<Player>();
+
+	public Magnetize(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"SKILL NEEDS REPLACING",
+				});
+	}
+
+	@Override
+	public String GetEnergyString()
+	{
+		return "Energy: 16 per Second";
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		UtilPlayer.message(player, F.main("Skill", "This skill is currently being re-worked."));
+		return false;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		_active.add(player);
+	}
+
+
+	@EventHandler
+	public void Energy(UpdateEvent event) 
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		for (Player cur : GetUsers())
+		{
+			if (!_active.contains(cur))
+				continue;
+
+			if (!UtilPlayer.isBlocking(cur))
+			{
+				_active.remove(cur);
+				continue;
+			}
+
+			//Level
+			int level = getLevel(cur);
+			if (level == 0)		
+			{
+				_active.remove(cur);
+				continue;
+			}
+
+			if (!Factory.Energy().Use(cur, GetName(), 2, true, true))
+			{
+				_active.remove(cur);
+				continue;
+			}
+
+			//Effect
+			cur.getWorld().playEffect(cur.getLocation(), Effect.STEP_SOUND, 42);
+
+			//Pull		
+			for (int i=0 ; i<=5+level ; i++)
+				Pull(cur, cur.getEyeLocation().add(cur.getLocation().getDirection().multiply(i)));
+		}
+	}
+	
+	public void Pull(Player player, Location loc)
+	{
+		for (Player other : UtilPlayer.getNearby(loc, 2))
+		{
+			if (player.equals(other))
+				continue;
+
+			if (!Factory.Relation().canHurt(player, other))		
+				continue;
+
+			if (UtilMath.offset(player, other) < 2)		
+				continue;
+
+			UtilAction.velocity(other, UtilAlg.getTrajectory2d(other, player), 
+					0.2, false, 0, 0, 1, false);
+		}
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_active.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Mage/NullBlade.java

@@ -0,0 +1,62 @@
+package mineplex.minecraft.game.classcombat.Skill.Mage;
+
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+
+public class NullBlade extends Skill
+{
+	public NullBlade(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Your attacks suck the life from",
+				"opponents, restoring #4#2 energy."
+				});
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void Drain(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+		
+		if (event.GetCause() != DamageCause.ENTITY_ATTACK)
+			return;
+
+		//Damager
+		Player damager = event.GetDamagerPlayer(false);
+		if (damager == null)	return;
+
+		int level = getLevel(damager);
+		if (level == 0)			return;
+
+		//Damagee
+		Player damagee = event.GetDamageePlayer();
+		if (damagee == null)	return;
+
+		//Energy
+		Factory.Energy().ModifyEnergy(damager, 4 + 2 * level);
+
+		//Damage
+		event.AddMod(damager.getName(), GetName(), 0, false);
+
+		//Effect
+		damager.getWorld().playSound(damager.getLocation(), Sound.BLAZE_BREATH, 0.6f, 0.6f);
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Mage/RootingAxe.java

@@ -0,0 +1,92 @@
+package mineplex.minecraft.game.classcombat.Skill.Mage;
+
+import org.bukkit.Effect;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.util.Vector;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.core.common.util.UtilAction;
+import mineplex.core.common.util.UtilBlock;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilGear;
+import mineplex.core.recharge.Recharge;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class RootingAxe extends Skill
+{
+	public RootingAxe(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Your axe rips players downward into",
+				"the earth, disrupting their movement."
+				});
+	}
+	
+	@Override
+	public String GetRechargeString() 
+	{
+		return "Recharge: #7#-1.5 seconds";
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void Root(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+		
+		if (event.GetCause() != DamageCause.ENTITY_ATTACK)
+			return;
+
+		//Damager
+		Player damager = event.GetDamagerPlayer(false);
+		if (damager == null)	return;
+
+		if (!UtilGear.isAxe(damager.getItemInHand()))
+			return;
+
+		int level = getLevel(damager);
+		if (level == 0)			return;
+		
+		//Damagee
+		Player damagee = event.GetDamageePlayer();
+		if (damagee == null)	return;
+		
+		event.SetKnockback(false);
+
+		//Root
+		if (Recharge.Instance.use(damager, GetName(), 7000 - (level * 1500), false, false))
+			if (UtilEnt.isGrounded(damagee))
+			{
+				//Double Down
+				if (UtilBlock.solid(damagee.getLocation().getBlock()))
+					return;
+				
+				//Fall Through
+				if (UtilBlock.airFoliage(damagee.getLocation().getBlock().getRelative(0, -2, 0)))
+					return;
+				
+				//Action
+				damagee.teleport(damagee.getLocation().add(0, -0.9, 0));
+				
+				//Effect
+				damagee.getWorld().playEffect(damagee.getLocation().add(0, 1, 0), Effect.STEP_SOUND, damagee.getLocation().getBlock().getTypeId());
+			}
+		
+		//Velocity Down
+		UtilAction.velocity(damagee, new Vector(0,-1,0), 0.5, false, 0, 0, 10, false);
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Mage/Rupture.java

@@ -0,0 +1,380 @@
+package mineplex.minecraft.game.classcombat.Skill.Mage;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.WeakHashMap;
+
+import org.bukkit.Effect;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.event.inventory.InventoryPickupItemEvent;
+import org.bukkit.event.player.PlayerPickupItemEvent;
+import org.bukkit.util.Vector;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.core.common.util.F;
+import mineplex.core.itemstack.ItemStackFactory;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.common.util.UtilAction;
+import mineplex.core.common.util.UtilAlg;
+import mineplex.core.common.util.UtilBlock;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilMath;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.minecraft.game.classcombat.Skill.SkillActiveCharge;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class Rupture extends SkillActiveCharge
+{
+	private HashSet<Item> _items = new HashSet<Item>();
+
+	private WeakHashMap<Player, Location> _target = new WeakHashMap<Player, Location>();
+
+	public Rupture(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray,
+				0.01f, 0.005f);
+
+		SetDesc(new String[] 
+				{
+				"Hold Block to create a rupture",
+				"at your feet. It will snake through",
+				"the ground with #1#0.1 velocity, moving",
+				"towards where you are looking,",
+				"giving Slow 2 to nearby opponents.",
+				"",
+				GetChargeString(),
+				"",
+				"Release Block to release the rupture,",
+				"causing earth and players to fly upward,",
+				"dealing up to #4#1 initial damage."
+				
+				});
+	}
+
+	@Override
+	public String GetEnergyString()
+	{
+		return "Energy: #20#-1 per Second";
+	}
+
+	@SuppressWarnings("deprecation")
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		if (!UtilEnt.isGrounded(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " while airborne."));
+			return false;
+		}
+
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		_target.put(player, player.getLocation().subtract(0, 1, 0));
+		_charge.put(player, 0f);
+	}
+	
+	public void Clean(Player player)
+	{
+		_target.remove(player);
+		_charge.remove(player);
+	}
+
+	@EventHandler
+	public void UpdateSlow(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.FAST)
+			return;
+
+		for (Player cur : _target.keySet())
+		{
+			Location loc = _target.get(cur);
+
+			for (Player other : cur.getWorld().getPlayers())
+				if (!other.equals(cur))
+					if (UtilMath.offset(loc, other.getLocation()) < 2)
+						if (Factory.Relation().canHurt(cur, other))
+							Factory.Condition().Factory().Slow(GetName(), other, cur, 1.9, 1, false, true, false, true);
+		}		
+	}
+
+	@EventHandler
+	public void UpdateMove(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		for (Player cur : UtilServer.getPlayers())
+		{
+			//Not Charging
+			if (!_target.containsKey(cur))
+				continue;
+
+			//Level
+			int level = getLevel(cur);
+			if (level == 0)			return;
+
+			//Add Charge
+			if (!UtilPlayer.isBlocking(cur))
+				DoRupture(cur);
+
+			else
+			{
+				//Energy
+				if (!Factory.Energy().Use(cur, GetName(), 1 - (0.05 * level), true, true))
+				{
+					DoRupture(cur);
+					continue;
+				}
+
+				Charge(cur);
+
+				MoveRupture(cur);
+			}
+		}
+	}
+
+	public void MoveRupture(Player cur) 
+	{
+		Block targetBlock = cur.getTargetBlock((HashSet<Byte>)null, 150);
+		if (targetBlock == null)	return;
+
+		//Aiming at sky
+		if (targetBlock.getY() == 0)
+		{
+			//Display
+			DisplayRupture(cur);
+
+			return;
+		}
+
+		Location target = targetBlock.getLocation().add(0.5, 0.5, 0.5);
+
+		Location loc = _target.get(cur);
+		if (loc == null)			return;
+
+		int level = getLevel(cur);
+		loc.add(UtilAlg.getTrajectory(loc, target).normalize().multiply(0.30 + (0.03 * level)));
+
+		//Relocate
+		RelocateRupture(cur, loc, target);
+
+		//Display
+		DisplayRupture(cur);
+	}
+
+	public void RelocateRupture(Player cur, Location loc, Location target)
+	{
+		if (CanTravel(loc.getBlock()))
+			return;
+
+		Location bestLoc = null;
+		double bestDist = 9999;
+
+		for (Block block : UtilBlock.getInRadius(loc, 1.5d).keySet())
+		{
+			if (!CanTravel(block))
+				continue;
+
+			if (UtilMath.offset(block.getLocation(), target) < bestDist)
+			{
+				bestLoc = block.getLocation();
+				bestDist = UtilMath.offset(block.getLocation(), target);
+			}
+		}
+
+		if (bestLoc == null)
+		{
+			UtilPlayer.message(cur, F.main("Skill", "Your " + F.skill(GetName()) + " has failed."));
+			Clean(cur);
+		}
+
+		else
+			_target.put(cur, bestLoc);
+	}
+
+	public boolean CanTravel(Block block) 
+	{
+		return !UtilBlock.liquid(block)
+		//return true
+		/*int id = block.getTypeId();
+
+		return (id == 1 || 
+				id == 2 || 
+				id == 3 || 
+				id == 12 || 
+				id == 13)*/;
+	}
+
+	public void DisplayRupture(Player cur)
+	{	
+		if (_target.get(cur) == null)
+			return;
+
+		for (Block block : UtilBlock.getInRadius(_target.get(cur), 1d).keySet())
+			if (block.getRelative(BlockFace.UP).getTypeId() == 0 ||
+				block.getRelative(BlockFace.DOWN).getTypeId() == 0 ||
+				block.getRelative(BlockFace.NORTH).getTypeId() == 0 ||
+				block.getRelative(BlockFace.SOUTH).getTypeId() == 0 ||
+				block.getRelative(BlockFace.EAST).getTypeId() == 0 ||
+				block.getRelative(BlockFace.WEST).getTypeId() == 0)
+			{
+				block.getWorld().playEffect(block.getLocation(), Effect.STEP_SOUND, block.getTypeId());
+			}
+
+	}
+
+	public void DoRupture(Player player)
+	{
+		Location loc = _target.get(player);
+		float charge = _charge.get(player);
+
+		Clean(player);
+
+		double range = 2 + 2 * charge;
+		double mult = 0.5 + 0.5 * charge;
+
+		int level = getLevel(player);
+
+		//Fling
+		HashMap<LivingEntity, Double> targets = UtilEnt.getInRadius(loc, range);
+		for (LivingEntity cur : targets.keySet())
+		{
+			//Velocity
+			UtilAction.velocity(cur, 
+					UtilAlg.getTrajectory2d(loc.toVector().add(new Vector(0.5,0,0.5)), cur.getLocation().toVector()), 
+					0.8 + 0.8 * targets.get(cur) * mult, true, 0, 0.4 + 1.0 * targets.get(cur) * mult, 0.4 + 1.0 * mult, true);
+
+			//Condition
+			Factory.Condition().Factory().Falling(GetName(), cur, player, 10, false, true);
+
+			//Inform
+			if (cur instanceof Player)
+				UtilPlayer.message((Player)cur, F.main(GetClassType().name(), F.name(player.getName()) +" hit you with " + F.skill(GetName(level)) + "."));
+			
+			//Damage Event
+			Factory.Damage().NewDamageEvent(cur, player, null, 
+					DamageCause.CUSTOM, 1 + (charge * (3 + level)), false, true, false,
+					player.getName(), GetName());
+		}
+
+		//Blocks
+		int attempts = 0;
+		int done = 0;
+
+		Block locBlock = loc.getBlock();
+
+		while (done < charge * 40 && attempts < charge * 200)
+		{
+			attempts++;
+
+			Vector vec = new Vector(Math.random() - 0.5, Math.random() - 0.5, Math.random() - 0.5).normalize();
+			Location side = new Location(loc.getWorld(), loc.getX() + vec.getX(), loc.getY() + vec.getY(), loc.getZ() + vec.getZ());
+
+			if (!UtilBlock.airFoliage(side.getBlock()))
+				continue;
+
+			//Add Directional
+			vec.add(UtilAlg.getTrajectory(loc.getBlock().getLocation(), side.getBlock().getLocation()));
+
+			//Add Up
+			vec.add(new Vector(0, 1.6, 0));
+
+			vec.normalize();
+
+			//Scale 
+			vec.multiply(0.1 + 0.3 * Math.random() + 0.6 * charge);
+
+			//Block!
+			Item item = loc.getWorld().dropItem(side, ItemStackFactory.Instance.CreateStack(locBlock.getTypeId(), locBlock.getData()));
+			item.setVelocity(vec);
+			item.setPickupDelay(50000);
+			_items.add(item);
+
+			//Effect
+			side.getWorld().playEffect(side, Effect.STEP_SOUND, locBlock.getTypeId());
+
+			done++;
+		}
+	}
+
+	@EventHandler
+	public void ItemPickup(PlayerPickupItemEvent event)
+	{
+		if (_items.contains(event.getItem()))
+			event.setCancelled(true);
+	}
+	
+	@EventHandler
+	public void HopperPickup(InventoryPickupItemEvent event)
+	{
+		if (_items.contains(event.getItem()))
+			event.setCancelled(true);
+	}
+
+	@EventHandler
+	public void ItemDestroy(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		if (_items.isEmpty())
+			return;
+		
+		Iterator<Item> itemIterator = _items.iterator();
+
+		while (itemIterator.hasNext())
+		{
+			Item item = itemIterator.next();
+			
+			if (item.isDead() || !item.isValid())
+			{
+				item.remove();
+				itemIterator.remove();
+			}
+			else if (UtilEnt.isGrounded(item) || item.getTicksLived() > 60)
+			{
+				item.getWorld().playEffect(item.getLocation(), Effect.STEP_SOUND, item.getItemStack().getTypeId());
+				item.remove();
+				itemIterator.remove();
+			}
+		}
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		Clean(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Mage/StaticLazer.java

@@ -0,0 +1,157 @@
+package mineplex.minecraft.game.classcombat.Skill.Mage;
+
+import java.util.HashMap;
+
+import org.bukkit.Color;
+import org.bukkit.FireworkEffect.Type;
+import org.bukkit.Location;
+import org.bukkit.Sound;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilBlock;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilFirework;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.SkillChargeSword;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+
+public class StaticLazer extends SkillChargeSword
+{
+	public StaticLazer(SkillFactory skills, String name, 
+			ClassType classType, SkillType skillType, 
+			int cost, int maxLevel)
+	{
+		super(skills, name, classType, skillType, cost, maxLevel, 
+				0.012f, 0.004f, 
+				9500, -500, true, true,
+				false, true);
+
+		SetDesc(new String[] 
+				{
+				"Hold Block to charge static electricity.",
+				"Release Block to fire static lazer.",
+				"",
+				GetChargeString(),
+				"Taking damage cancels charge.",
+				"",
+				"Deals #6#2 damage and travels up to",
+				"#20#10 blocks.",
+				});
+		
+		_fireOnFull = false;
+		_energyPerCharge = 1.2f;
+		setAchievementSkill(true);
+	}
+	
+	@Override
+	public String GetRechargeString() 
+	{
+		return "Recharge: " + "#9#-0.5 Seconds";
+	}
+	
+	@Override
+	public String GetEnergyString() 
+	{
+		return "Energy: " + "24 per Second";
+	}
+
+	@Override
+	public void DoSkillCustom(Player player, float charge)
+	{
+		int level = getLevel(player);
+		if (level <= 0)
+			return;
+		
+		//Action
+		double curRange = 0;
+		double maxRange = 20 + 10 * level;
+		while (curRange <= maxRange)
+		{
+			Location newTarget = player.getEyeLocation().add(player.getLocation().getDirection().multiply(curRange));
+
+			//Hit Player
+			HashMap<LivingEntity, Double> hits = UtilEnt.getInRadius(newTarget, 1);
+			hits.remove(player);
+			if (!hits.isEmpty())
+				break;
+			
+			//Hit Block
+			if (!UtilBlock.airFoliage(newTarget.getBlock()))
+				break;
+				
+			//Progress Forwards
+			curRange += 0.2;
+
+			//Smoke Trail
+			UtilParticle.PlayParticle(ParticleType.FIREWORKS_SPARK, newTarget, 0, 0, 0, 0, 1,
+					ViewDist.MAX, UtilServer.getPlayers());
+		}
+
+		//Destination
+		Location target = player.getLocation().add(player.getLocation().getDirection().multiply(curRange));
+		
+		UtilParticle.PlayParticle(ParticleType.EXPLODE, target, 0, 0, 0, 0, 1,
+				ViewDist.MAX, UtilServer.getPlayers());
+		
+		//Firework 
+		UtilFirework.playFirework(player.getLocation().add(player.getLocation().getDirection().multiply(Math.max(0, curRange - 0.6))), Type.BURST, Color.WHITE, false, false);
+		
+		HashMap<LivingEntity, Double> hit = UtilEnt.getInRadius(target.subtract(0, 1, 0), 4);
+		for (LivingEntity other : hit.keySet())
+		{
+			if (other.equals(player))
+				continue;
+
+			double damage = 6 + 2 * level;
+			//Damage Event
+			Factory.Damage().NewDamageEvent(other, player, null, 
+					DamageCause.CUSTOM, damage * charge, true, true, false,
+					player.getName(), GetName());	
+			
+		}
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You used " + F.skill(GetName(getLevel(player))) + "."));
+
+		//Effect
+		player.getWorld().playSound(player.getEyeLocation(), Sound.ZOMBIE_REMEDY, 0.5f + player.getExp(), 1.75f - charge);
+	}
+
+	@EventHandler(priority = EventPriority.NORMAL)
+	public void damageCancelCharge(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+
+		//Damagee
+		Player damagee = event.GetDamageePlayer();
+		if (damagee == null)	return;
+
+		if (_charge.remove(damagee) == null)
+			return;
+		
+		//Inform
+		UtilPlayer.message(damagee, F.main(GetClassType().name(), F.skill(GetName()) + " was interrupted."));
+
+		//Effect
+		damagee.getWorld().playSound(damagee.getLocation(), Sound.ZOMBIE_REMEDY, 0.5f, 3f);
+
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_charge.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Mage/Void.java

@@ -0,0 +1,220 @@
+package mineplex.minecraft.game.classcombat.Skill.Mage;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.player.PlayerDropItemEvent;
+
+import mineplex.core.common.util.UtilEnt;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.core.common.util.F;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.common.util.UtilGear;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.Skill.event.SkillTriggerEvent;
+
+public class Void extends Skill
+{
+
+	private final Set<Player> _active = new HashSet<>();
+
+	public Void(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Drop Axe/Sword to Toggle.",
+				"",
+				"While in void form, you receive",
+				"Slow 3, take no knockback and",
+				"use no energy to swing weapons.",
+				"",
+				"Reduces incoming damage by #1#1 , but",
+				"burns #8#-1 Energy per 1 damage reduced."
+				});
+	}
+
+	@Override
+	public String GetEnergyString()
+	{
+		return "Energy: 6 per Second";
+	}
+
+	@EventHandler
+	public void Toggle(PlayerDropItemEvent event)
+	{
+		Player player = event.getPlayer();
+
+		if (!UtilGear.isWeapon(event.getItemDrop().getItemStack()))
+			return;
+
+		if (getLevel(player) == 0)				
+			return;
+
+		event.setCancelled(true);  
+
+		//Check Allowed
+		SkillTriggerEvent trigger = new SkillTriggerEvent(player, GetName(), GetClassType());
+		UtilServer.getServer().getPluginManager().callEvent(trigger);
+		if (trigger.IsCancelled())
+			return;
+
+		if (_active.contains(player))
+		{
+			_active.remove(player);
+			UtilPlayer.message(player, F.main(GetClassType().name(), GetName() + ": " + F.oo("Disabled", false)));
+
+			//Remove Condition
+			Factory.Condition().EndCondition(event.getPlayer(), null, GetName());
+		}
+		else
+		{
+			if (!Factory.Energy().Use(player, "Enable " + GetName(), 10, true, true))
+				return;
+
+			_active.add(player);
+			UtilPlayer.message(player, F.main(GetClassType().name(), GetName() + ": " + F.oo("Enabled", true)));
+			
+			//Remove Condition
+			Factory.Condition().EndCondition(event.getPlayer(), null, GetName());
+		} 
+	}
+	
+	@EventHandler
+	public void Silence(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		for (Player cur : GetUsers())
+		{
+			if (!_active.contains(cur))
+				continue;
+			
+			//Check Allowed
+			SkillTriggerEvent trigger = new SkillTriggerEvent(cur, GetName(), GetClassType());
+			UtilServer.getServer().getPluginManager().callEvent(trigger);
+			if (trigger.IsCancelled())
+				_active.remove(cur);
+		}
+	}
+	
+	@EventHandler
+	public void inWater(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+		
+		for (Player cur : GetUsers())
+		{
+			if (!_active.contains(cur))
+				continue;
+			
+			if (isInWater(cur))
+			{
+				UtilPlayer.message(cur, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+				_active.remove(cur);
+				Factory.Condition().EndCondition(cur, null, GetName());
+			}
+		}
+	}
+
+	@EventHandler
+	public void Audio(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.FAST)
+			return;
+
+		for (Player cur : _active)
+			cur.getWorld().playSound(cur.getLocation(), Sound.BLAZE_BREATH, 0.5f, 0.5f);
+	}
+
+	@EventHandler
+	public void Aura(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		for (Player cur : _active)
+		{	
+			if (cur.isDead())
+				continue;
+			
+			//Energy
+			Factory.Energy().ModifyEnergy(cur, -0.3);
+		}
+	}
+	
+	@EventHandler
+	public void Conditions(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.FAST)
+			return;
+
+		for (Player cur : _active)
+		{	
+			if (cur.isDead())
+				continue;
+			
+			//Condition
+			Factory.Condition().Factory().Invisible(GetName(), cur, cur, 1.9, 1, false, true, true);
+			Factory.Condition().Factory().Slow(GetName(), cur, cur, 1.9, 2, false, true, false, true);
+		}
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void Shield(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+
+		Player damagee = event.GetDamageePlayer();
+		if (damagee == null)	return;
+
+		if (!_active.contains(damagee))
+			return;
+
+		int level = getLevel(damagee);
+		if (level == 0)			return;
+
+		double dmgToEnergy = 8 - level;
+		int dmgLower = 1 + level;
+		
+		int currentEnergy = (int)Factory.Energy().GetCurrent(damagee);
+		double requiredEnergy = Math.min(dmgLower, event.GetDamage()) * dmgToEnergy;
+
+		//Lower
+		if (currentEnergy < requiredEnergy)
+			dmgLower = (int)(currentEnergy/dmgToEnergy);
+
+		//Use Energy
+		Factory.Energy().ModifyEnergy(damagee, -requiredEnergy);
+
+		//Damage
+		event.AddMod(damagee.getName(), GetName(), -dmgLower, false);
+		event.SetKnockback(false);
+
+		//Effect
+		damagee.getWorld().playSound(damagee.getLocation(), Sound.BLAZE_BREATH, 2f, 1f);
+	} 
+
+
+	@Override
+	public void Reset(Player player) 
+	{ 
+		_active.remove(player);
+		
+		//Remove Condition
+		Factory.Condition().EndCondition(player, null, GetName());
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Mage/events/FissureModifyBlockEvent.java

@@ -0,0 +1,46 @@
+package mineplex.minecraft.game.classcombat.Skill.Mage.events;
+
+import org.bukkit.block.Block;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+public class FissureModifyBlockEvent extends Event implements Cancellable
+{
+	private static final HandlerList HANDLER_LIST = new HandlerList();
+
+	private final Block _targetBlock;
+
+	private boolean _cancelled;
+
+	public FissureModifyBlockEvent(Block targetBlock)
+	{
+		this._targetBlock = targetBlock;
+	}
+
+	public boolean isCancelled()
+	{
+		return this._cancelled;
+	}
+
+	public void setCancelled(boolean cancelled)
+	{
+		this._cancelled = cancelled;
+	}
+
+	public Block getTargetBlock()
+	{
+		return this._targetBlock;
+	}
+
+	@Override
+	public HandlerList getHandlers()
+	{
+		return HANDLER_LIST;
+	}
+
+	public static HandlerList getHandlerList()
+	{
+		return HANDLER_LIST;
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Ranger/Agility.java

@@ -0,0 +1,164 @@
+package mineplex.minecraft.game.classcombat.Skill.Ranger;
+
+import java.util.HashSet;
+
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.potion.PotionEffectType;
+
+import mineplex.core.common.util.UtilEnt;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilEvent;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilEvent.ActionType;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class Agility extends SkillActive
+{
+	private HashSet<Player>	_active = new HashSet<Player>();
+
+	public Agility(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Sprint with great agility, gaining",
+				"Speed 2 for #3#1 seconds. You take",
+				"#45#5 % less damage and take no knockback.",
+				"",
+				"Agility ends if you Left-Click."	
+				});
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		//Action
+		Factory.Condition().Factory().Speed(GetName(), player, player, 3 + level, 1, false, true, true);
+		_active.add(player);
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You used " + F.skill(GetName(level)) + "."));
+
+		//Effect
+		player.getWorld().playSound(player.getLocation(), Sound.NOTE_PLING, 0.5f, 0.5f);
+	}
+
+	@EventHandler(priority = EventPriority.LOWEST)
+	public void End(PlayerInteractEvent event)
+	{
+		Player player = event.getPlayer();
+
+		if (UtilEvent.isAction(event, ActionType.R))
+			return;
+		
+		if (event.getAction() == Action.PHYSICAL)
+			return;
+
+		if (!_active.contains(player))
+			return;
+		
+		//Remove
+		_active.remove(player);
+		player.removePotionEffect(PotionEffectType.SPEED);
+	}
+
+	@EventHandler(priority = EventPriority.LOW)
+	public void Damage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+
+		Player damagee = event.GetDamageePlayer();
+
+		if (damagee == null)
+			return;
+
+		if (!damagee.isSprinting())
+			return;
+
+		if (!_active.contains(damagee))
+			return;
+
+		//Cancel
+		event.AddMult(GetName(), GetName(), (0.55 - 0.05 * getLevel(damagee)), false);
+		
+		event.SetKnockback(false);
+		
+		//Effect
+		damagee.getWorld().playSound(damagee.getLocation(), Sound.BLAZE_BREATH, 0.5f, 2f);
+	}
+
+	@EventHandler
+	public void Update(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.FAST)
+			return;
+
+		HashSet<Player>	expired = new HashSet<Player>();
+		for (Player cur : _active)
+			if (!cur.hasPotionEffect(PotionEffectType.SPEED))
+				expired.add(cur);
+
+		for (Player cur : expired)
+			_active.remove(cur);
+	}
+	
+	@EventHandler
+	public void Particle(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		for (Player player : _active)
+		{
+			if (player.isSprinting())
+				UtilParticle.PlayParticle(ParticleType.SPELL, player.getLocation(), 
+					(float)(Math.random() - 0.5), 0.2f + (float)(Math.random() * 1), (float)(Math.random() - 0.5), 0, 4,
+					ViewDist.LONG, UtilServer.getPlayers());
+		}
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_active.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Ranger/BarbedArrows.java

@@ -0,0 +1,119 @@
+package mineplex.minecraft.game.classcombat.Skill.Ranger;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.entity.EntityShootBowEvent;
+
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.Skill;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+
+public class BarbedArrows extends Skill
+{
+
+	private final Set<Entity> _arrows = new HashSet<>();
+
+	public BarbedArrows(SkillFactory skills, String name, ClassType classType, SkillType skillType, int cost, int levels) 
+	{
+		super(skills, name, classType, skillType, cost, levels);
+
+		SetDesc(new String[] 
+				{
+				"Your arrows are barbed, and give", 
+				"opponents Slow 1 for #2#1 seconds.",
+				"Will cancel sprint on opponents.",
+				"",
+				"Duration scales with arrow velocity."
+				});
+	}
+
+	@EventHandler (priority = EventPriority.MONITOR)
+	public void bowShoot(EntityShootBowEvent event)
+	{
+		int level = getLevel(event.getEntity());
+
+		if (level == 0)
+		{
+			return;
+		}
+
+		_arrows.add(event.getProjectile());
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void damage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+		{
+			return;
+		}
+
+		Projectile projectile = event.GetProjectile();
+
+		if (projectile == null || !_arrows.remove(projectile))
+		{
+			return;
+		}
+
+		LivingEntity damagee = event.GetDamageeEntity();
+		Player damager = event.GetDamagerPlayer(true);
+
+		if (damagee == null || damager == null)
+		{
+			return;
+		}
+
+		//Level
+		int level = getLevel(damager);
+		if (level == 0)
+		{
+			return;
+		}
+
+		//Condition
+		int duration = 3 + level;
+
+		Factory.Condition().Factory().Slow(GetName(), damagee, damager, duration, 0, false, true, true, true);
+		Factory.Condition().Factory().Regen(GetName(), damagee, damager, duration, 0, false, false, false);
+		Factory.Condition().Factory().ArcadeHungerDisable(GetName(), damagee, damager, duration, false);
+
+		Player damageePlayer = event.GetDamageePlayer();
+
+		if (damageePlayer != null)
+		{
+			int food = damageePlayer.getFoodLevel();
+
+			damageePlayer.setFoodLevel(2);
+			damageePlayer.setSprinting(false);
+
+			Factory.runSyncLater(() -> damageePlayer.setFoodLevel(food), duration * 20);
+		}
+	}
+
+	@EventHandler
+	public void clean(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.SLOW)
+		{
+			return;
+		}
+
+		_arrows.removeIf(arrow -> !arrow.isValid());
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Ranger/Barrage.java

@@ -0,0 +1,126 @@
+package mineplex.minecraft.game.classcombat.Skill.Ranger;
+
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.WeakHashMap;
+
+import org.bukkit.Sound;
+import org.bukkit.entity.Arrow;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.entity.ProjectileHitEvent;
+import org.bukkit.util.Vector;
+
+import mineplex.core.common.util.UtilGear;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.classcombat.Skill.SkillChargeBow;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.classcombat.Skill.event.SkillTriggerEvent;
+
+public class Barrage extends SkillChargeBow
+{
+	private WeakHashMap<Player, Integer> _chargeArrows = new WeakHashMap<Player, Integer>();
+	private HashSet<Projectile> _arrows = new HashSet<Projectile>();
+
+	public Barrage(SkillFactory skills, String name, ClassType classType,
+			SkillType skillType, int cost, int maxLevel)
+	{
+		super(skills, name, classType, skillType, cost, maxLevel, 
+				0.016f, 0.008f, false, true);
+	
+		SetDesc(new String[] 
+				{
+				"Charge your bow fire bonus arrows.",
+				"",
+				GetChargeString(),
+				"",
+				"Fires up to #2#2 additional arrows."
+				});
+	}
+	
+	@Override
+	public void DoSkillCustom(Player player, float charge, Arrow arrow)
+	{
+		_chargeArrows.put(player, (int)(charge * (2 + 2* getLevel(player))));
+	}
+
+	@EventHandler
+	public void Skill(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+		
+		for (Player cur : GetUsers())
+		{
+			if (!_chargeArrows.containsKey(cur))
+				continue;
+
+			if (!UtilGear.isBow(cur.getItemInHand()))
+			{
+				_chargeArrows.remove(cur);
+				continue;
+			}
+
+			int arrows = _chargeArrows.get(cur);
+			if (arrows <= 0)
+			{
+				_chargeArrows.remove(cur);
+				continue;
+			}
+			
+			if (UtilServer.CallEvent(new SkillTriggerEvent(cur, GetName(), GetClassType())).IsCancelled())
+			{
+				_chargeArrows.remove(cur);
+				continue;
+			}
+			
+			_chargeArrows.put(cur, arrows-1);
+
+			//Fire Arrow
+			Vector random = new Vector((Math.random()-0.5)/10, (Math.random()-0.5)/10, (Math.random()-0.5)/10);
+			Projectile arrow = cur.launchProjectile(Arrow.class);
+			arrow.setVelocity(cur.getLocation().getDirection().add(random).multiply(3));
+			_arrows.add(arrow);
+			cur.getWorld().playSound(cur.getLocation(), Sound.SHOOT_ARROW, 1f, 1f);
+			
+			UtilParticle.PlayParticle(ParticleType.CRIT, arrow.getLocation(), 0, 0, 0, 0, 1,
+					ViewDist.MAX, UtilServer.getPlayers());
+		}
+	}
+
+	@EventHandler
+	public void ProjectileHit(ProjectileHitEvent event)
+	{
+		if (_arrows.remove(event.getEntity()))
+			event.getEntity().remove();
+	}
+
+	@EventHandler
+	public void Clean(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.SEC)
+			return;
+		
+		for (Iterator<Projectile> arrowIterator = _arrows.iterator(); arrowIterator.hasNext();) 
+		{
+			Projectile arrow = arrowIterator.next();
+			
+			if (arrow.isDead() || !arrow.isValid())
+				arrowIterator.remove();
+		}
+	}
+	
+	@Override
+	public void Reset(Player player) 
+	{
+		_charge.remove(player);
+		_chargeArrows.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Ranger/Disengage.java

@@ -0,0 +1,200 @@
+package mineplex.minecraft.game.classcombat.Skill.Ranger;
+
+import java.util.HashMap;
+
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+import mineplex.core.common.util.F;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.common.util.UtilAction;
+import mineplex.core.common.util.UtilAlg;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.common.util.UtilTime;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+
+public class Disengage extends SkillActive
+{
+	private HashMap<Player, Long> _prepare = new HashMap<Player, Long>();
+	private HashMap<Player, Long> _fall = new HashMap<Player, Long>();
+	
+	public Disengage(SkillFactory skills, String name, ClassType classType, SkillType skillType, 
+			int cost, int levels, 
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType,
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Push Block, then block an attack",
+				"within 1 second to disengage.",
+				"",
+				"If successful, you leap backwards",
+				"and your attacker receives Slow 4",
+				"for #2.5#0.5 seconds.",
+				});
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+		
+		if (player.getLocation().getBlock().getType() == Material.WEB)
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " while trapped in a cobweb!"));
+			return false;
+		}
+		
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		//Prepare
+		_prepare.put(player, System.currentTimeMillis() + 1000);
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You prepared to " + F.skill(GetName()) + "."));
+	}
+
+	@EventHandler(priority = EventPriority.NORMAL)
+	public void Damage(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+
+		if (event.GetCause() != DamageCause.ENTITY_ATTACK)
+			return;
+
+		//Damagee
+		Player damagee = event.GetDamageePlayer();
+		if (damagee == null)	return;
+
+		//Blocking
+		if (!damagee.isBlocking())
+			return;
+
+		if (!_prepare.containsKey(damagee))
+			return;
+
+		//Damager
+		LivingEntity damager = event.GetDamagerEntity(false);
+		if (damager == null)	return;
+
+		//Level
+		int level = getLevel(damagee);
+		if (level == 0)			return;
+
+		//Cancel
+		event.SetCancelled(GetName());
+
+		//Remove
+		_prepare.remove(damagee);
+
+		//Velocity
+		if (UtilEnt.isGrounded(damagee))
+			UtilAction.velocity(damagee, UtilAlg.getTrajectory2d(damager, damagee), 3, true, 0, 0.8, 1, true);
+		else
+			UtilAction.velocity(damagee, UtilAlg.getTrajectory2d(damager, damagee), 1.5, true, 0, 0.8, 1, true);
+
+		//Condition
+		Factory.Condition().Factory().Slow(GetName(), damager, damagee, 2.5 + (0.5 * level), 3, false, true, true, true);
+		Factory.Condition().Factory().Invulnerable(GetName(), damagee, damagee, 0.3, false, false);
+
+		_fall.put(damagee, System.currentTimeMillis());
+		
+		//Effect
+		damagee.getWorld().playSound(damager.getLocation(), Sound.ZOMBIE_METAL, 0.5f, 1.6f);
+		UtilParticle.PlayParticle(ParticleType.ANGRY_VILLAGER, damager.getEyeLocation(), 0, 0, 0, 0, 1,
+				ViewDist.LONG, UtilServer.getPlayers());
+
+		//Inform
+		UtilPlayer.message(damagee, F.main(GetClassType().name(), "You used " + F.skill(GetName(level)) + "."));
+		UtilPlayer.message(event.GetDamageePlayer(), F.main(GetClassType().name(), F.name(damagee.getName()) + " used " + F.skill(GetName(level)) + "."));
+
+	}
+
+	@EventHandler
+	public void Expire(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+		
+		for (Player cur : GetUsers())
+		{
+			if (_fall.containsKey(cur))
+			{
+				if (UtilTime.elapsed(_fall.get(cur), 2000))
+				{
+					if (UtilEnt.isGrounded(cur) || UtilTime.elapsed(_fall.get(cur), 20000))
+					{
+						_fall.remove(cur);
+					}
+				}
+			}
+			
+			if (_prepare.containsKey(cur))
+			{
+				if (System.currentTimeMillis() > _prepare.get(cur))
+				{
+					//Remove
+					_prepare.remove(cur);
+
+					//Inform
+					UtilPlayer.message(cur, F.main(GetClassType().name(), "You failed to " + F.skill(GetName()) + "."));
+				}
+			}
+		}
+	}
+	
+	@EventHandler(priority = EventPriority.LOW)
+	public void fallCancel(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+
+		if (event.GetCause() != DamageCause.FALL)
+			return;
+		
+		if (_fall.remove(event.GetDamageeEntity()) != null)
+		{
+			event.SetCancelled(GetName() + " Fall");
+		}
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_fall.remove(player);
+		_prepare.remove(player);
+	}
+}

Plugins[Modified]/Mineplex.Minecraft.Game.ClassCombat/src/mineplex/minecraft/game/classcombat/Skill/Ranger/ExplosiveShot.java

@@ -0,0 +1,262 @@
+package mineplex.minecraft.game.classcombat.Skill.Ranger;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.entity.Arrow;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityShootBowEvent;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.event.entity.ProjectileHitEvent;
+
+import mineplex.minecraft.game.classcombat.Class.IPvpClass.ClassType;
+import mineplex.core.common.util.F;
+import mineplex.core.common.util.UtilAction;
+import mineplex.core.common.util.UtilAlg;
+import mineplex.core.common.util.UtilEnt;
+import mineplex.core.common.util.UtilParticle;
+import mineplex.core.common.util.UtilServer;
+import mineplex.core.updater.event.UpdateEvent;
+import mineplex.core.updater.UpdateType;
+import mineplex.core.common.util.UtilPlayer;
+import mineplex.core.common.util.UtilParticle.ParticleType;
+import mineplex.core.common.util.UtilParticle.ViewDist;
+import mineplex.minecraft.game.classcombat.Skill.SkillActive;
+import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
+import mineplex.minecraft.game.core.damage.CustomDamageEvent;
+
+public class ExplosiveShot extends SkillActive
+{
+
+	private final Set<Arrow> _arrows = new HashSet<>();
+	private final Set<Player> _active = new HashSet<>();
+
+	public ExplosiveShot(SkillFactory skills, String name, ClassType classType, SkillType skillType,
+			int cost, int levels,
+			int energy, int energyMod, 
+			long recharge, long rechargeMod, boolean rechargeInform, 
+			Material[] itemArray, 
+			Action[] actionArray) 
+	{
+		super(skills, name, classType, skillType, 
+				cost, levels,
+				energy, energyMod, 
+				recharge, rechargeMod, rechargeInform, 
+				itemArray,
+				actionArray);
+
+		SetDesc(new String[] 
+				{
+				"Prepare an explosive shot;",
+				"Your next arrow will explode on",
+				"impact, dealing up to 10 damage",
+				"and knockback. ",
+				" ",
+				"Explosion radius of #4.5#0.5",
+				});
+		
+		setAchievementSkill(true);
+	}
+
+	@Override
+	public boolean CustomCheck(Player player, int level) 
+	{
+		if (isInWater(player))
+		{
+			UtilPlayer.message(player, F.main("Skill", "You cannot use " + F.skill(GetName()) + " in water."));
+			return false;
+		}
+
+		return true;
+	}
+
+	@Override
+	public void Skill(Player player, int level) 
+	{
+		//Action
+		_active.add(player);
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You prepared " + F.skill(GetName(level)) + "."));
+
+		//Effect
+		player.getWorld().playSound(player.getLocation(), Sound.BLAZE_BREATH, 2.5f, 2.0f);
+	}
+
+	@EventHandler
+	public void BowShoot(EntityShootBowEvent event)
+	{
+		if (!(event.getEntity() instanceof Player))
+			return;
+
+		if (!(event.getProjectile() instanceof Arrow))
+			return;
+
+		Player player = (Player)event.getEntity();
+
+		if (!_active.remove(player))
+			return;
+
+		//Inform
+		UtilPlayer.message(player, F.main(GetClassType().name(), "You fired " + F.skill(GetName(getLevel(player))) + "."));
+
+		_arrows.add((Arrow)event.getProjectile());
+	}
+
+	@EventHandler(priority = EventPriority.HIGH)
+	public void hitEntityTrigger(CustomDamageEvent event)
+	{
+		if (event.IsCancelled())
+			return;
+
+		if (event.GetCause() != DamageCause.PROJECTILE)
+			return;
+
+		Projectile projectile = event.GetProjectile();
+		if (projectile == null)	
+			return;
+
+		if (!_arrows.remove(event.GetProjectile()))
+			return;
+
+		event.SetCancelled(GetName());
+
+		Location loc = event.GetDamageeEntity().getLocation().subtract(event.GetProjectile().getVelocity().normalize().multiply(0.1));
+		
+		trigger((Arrow)event.GetProjectile(), loc);
+	}
+
+	@EventHandler
+	public void hitBlockTrigger(ProjectileHitEvent event)
+	{
+		Projectile proj = event.getEntity();
+
+		if (!_arrows.contains(proj))
+			return;
+
+		if (proj.getShooter() == null)
+			return;
+
+		if (!(proj.getShooter() instanceof Player))
+			return;
+
+		Player damager = (Player)proj.getShooter();
+		int level = getLevel(damager);
+		if (level == 0)		return;
+
+		final Arrow arrow = (Arrow)proj;
+
+		Factory.getPlugin().getServer().getScheduler().scheduleSyncDelayedTask(Factory.getPlugin(), new Runnable()
+		{
+			public void run()
+			{
+				try
+				{
+					//If it hasnt already triggered (via damage)
+					if (_arrows.remove(arrow))
+						trigger(arrow, arrow.getLocation());
+				}
+				catch (Exception e)
+				{
+					e.printStackTrace();
+				}
+			}
+		}, 0);
+
+		//Remove
+		proj.remove();
+	}
+
+	@EventHandler
+	public void cleanTrigger(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.SEC)
+			return;
+
+		for (Iterator<Arrow> arrowIterator = _arrows.iterator(); arrowIterator.hasNext();) 
+		{
+			Arrow arrow = arrowIterator.next();
+
+			if (arrow.isDead() || !arrow.isValid() || arrow.isOnGround() || arrow.getTicksLived() > 60)
+			{
+				arrowIterator.remove();
+				trigger(arrow, arrow.getLocation());
+			}
+		}
+	}
+
+	public void trigger(Arrow arrow, Location loc)
+	{
+		if (arrow == null)
+			return;
+
+		if (arrow.getShooter() == null || !(arrow.getShooter() instanceof Player))
+		{
+			arrow.remove();
+			return;
+		}
+
+		Player player = (Player)arrow.getShooter();
+
+		//Level
+		int level = getLevel(player);
+		if (level == 0)			
+			return;
+
+		//Velocity Players
+		HashMap<LivingEntity,Double> hitMap = UtilEnt.getInRadius(loc, 4.5 + (level * 0.5));
+		for (LivingEntity cur : hitMap.keySet())
+		{	
+			double range = hitMap.get(cur);
+
+			//Condition
+			Factory.Condition().Factory().Falling(GetName(), cur, player, 6, false, true);
+
+			//Damage Event
+			Factory.Damage().NewDamageEvent(cur, player, null, 
+					DamageCause.CUSTOM, 10 * range, false, true, false,
+					player.getName(), GetName());	
+
+			//Velocity
+			UtilAction.velocity(cur, UtilAlg.getTrajectory2d(loc, cur.getLocation().add(0, 1, 0)), 
+					0.4 + 1 * range, false, 0, 0.2 + 0.6 * range, 1.2, true);
+
+			//Inform
+			if (cur instanceof Player)
+				UtilPlayer.message((Player)cur, F.main(GetClassType().name(), F.name(player.getName()) +" hit you with " + F.skill(GetName(level)) + "."));
+		}
+		
+		UtilParticle.PlayParticle(ParticleType.HUGE_EXPLOSION, loc, 0, 0, 0, 0, 1,
+				ViewDist.MAX, UtilServer.getPlayers());
+		loc.getWorld().playSound(loc, Sound.EXPLODE, 2f, 0.75f);
+	}
+
+	@EventHandler
+	public void particle(UpdateEvent event)
+	{
+		if (event.getType() != UpdateType.TICK)
+			return;
+
+		for (Entity ent : _arrows)
+			UtilParticle.PlayParticle(ParticleType.LARGE_EXPLODE, ent.getLocation(), 0, 0, 0, 0, 1,
+					ViewDist.MAX, UtilServer.getPlayers());
+	}
+
+	@Override
+	public void Reset(Player player) 
+	{
+		_active.remove(player);
+	}
+}