Bloodbending

src/com/projectkorra/ProjectKorra/BendingManager.java

@@ -20,6 +20,7 @@ import com.projectkorra.ProjectKorra.chiblocking.ChiPassive;
 import com.projectkorra.ProjectKorra.earthbending.EarthPassive;
 import com.projectkorra.ProjectKorra.firebending.FirePassive;
 import com.projectkorra.ProjectKorra.firebending.FireStream;
+import com.projectkorra.ProjectKorra.waterbending.Bloodbending;
 import com.projectkorra.ProjectKorra.waterbending.Plantbending;
 import com.projectkorra.ProjectKorra.waterbending.WaterPassive;
 
@@ -57,9 +58,12 @@ public class BendingManager implements Runnable {
 			WaterPassive.handlePassive();
 			FirePassive.handlePassive();
 			EarthPassive.revertSands();
+			TempPotionEffect.progressAll();
 			Plantbending.regrow();
 			AirBurst.progressAll();
 			handleDayNight();
+			Bloodbending.progressAll();
+			
 			for (int ID: Tornado.instances.keySet()) {
 				Tornado.progress(ID);
 			}

src/com/projectkorra/ProjectKorra/ConfigManager.java

@@ -3,6 +3,7 @@ package com.projectkorra.ProjectKorra;
 import java.util.ArrayList;
 
 import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.entity.Player;
 
 public class ConfigManager {
 
@@ -72,6 +73,14 @@ public class ConfigManager {
 		config.addDefault("Abilities.Air.AirBlast.Radius", 2);
 		config.addDefault("Abilities.Air.AirBlast.Push", 3.5);
 		
+		config.addDefault("Abilities.Air.AirBurst.Enabled", true);
+		config.addDefault("Abilities.Air.AirBurst.Description", "AirBurst is one of the most powerful abilities in the airbender's arsenal. "
+				+ "To use, press and hold sneak to charge your burst. "
+				+ "Once charged, you can either release sneak to launch a cone-shaped burst "
+				+ "of air in front of you, or click to release the burst in a sphere around you. "
+				+ "Additionally, having this ability selected when you land on the ground from a "
+				+ "large enough fall will create a burst of air around you.");
+		
 		plugin.getConfig().addDefault("Abilities.Air.Tornado.Enabled", true);
 		plugin.getConfig().addDefault("Abilities.Air.Tornado.Description", "To use, simply sneak (default: shift). "
 				+ "This will create a swirling vortex at the targeted location. "
@@ -90,6 +99,18 @@ public class ConfigManager {
 		config.addDefault("Abilities.Air.Tornado.PlayerPushFactor", 1);
 		
 		plugin.getConfig().addDefault("Abilities.Water.Passive.SwimSpeedFactor", 0.7);
+		
+		config.addDefault("Abilities.Water.Bloodbending.Enabled", true);
+		config.addDefault("Abilities.Water.Bloodbending.Description", "This ability was made illegal for a reason. With this ability selected, sneak while "
+				+ "targetting something and you will bloodbend that target. Bloodbent targets cannot move, "
+				+ "bend or attack. You are free to control their actions by looking elsewhere - they will "
+				+ "be forced to move in that direction. Additionally, clicking while bloodbending will "
+				+ "launch that target off in the direction you're looking. "
+				+ "People who are capable of bloodbending are immune to your technique, and you are immune to theirs.");
+		config.addDefault("Abilities.Water.Bloodbending.ThrowFactor", 2);
+		config.addDefault("Abilities.Water.Bloodbending.Range", 10);
+		
+		
 		plugin.getConfig().addDefault("Abilities.Water.Plantbending.RegrowTime", 180000);
 		
 		plugin.getConfig().addDefault("Abilities.Earth.Passive.Duration", 2500);

src/com/projectkorra/ProjectKorra/Methods.java

@@ -31,6 +31,7 @@ import org.bukkit.util.Vector;
 
 import com.projectkorra.ProjectKorra.Ability.AbilityModule;
 import com.projectkorra.ProjectKorra.Ability.AbilityModuleManager;
+import com.projectkorra.ProjectKorra.Ability.AvatarState;
 import com.projectkorra.ProjectKorra.earthbending.EarthPassive;
 import com.projectkorra.ProjectKorra.waterbending.FreezeMelt;
 import com.projectkorra.ProjectKorra.waterbending.WaterCore;
@@ -616,6 +617,16 @@ public class Methods {
 		block.breakNaturally(new ItemStack(Material.AIR));
 	}
 
+	public static boolean canBeBloodbent(Player player) {
+		if (AvatarState.isAvatarState(player))
+			return false;
+		if ((isChiBlocked(player.getName())))
+			return true;
+		if (canBend(player.getName(), "Bloodbending") && Methods.getBendingPlayer(player.getName()).isToggled)
+			return false;
+		return true;
+	}
+
 	public static void moveEarthBlock(Block source, Block target) {
 		byte full = 0x0;
 		Information info;

src/com/projectkorra/ProjectKorra/PKListener.java

@@ -4,6 +4,7 @@ import java.util.List;
 
 import org.bukkit.ChatColor;
 import org.bukkit.GameMode;
+import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.block.Block;
 import org.bukkit.entity.Entity;
@@ -16,15 +17,28 @@ import org.bukkit.event.block.BlockFadeEvent;
 import org.bukkit.event.block.BlockFormEvent;
 import org.bukkit.event.block.BlockFromToEvent;
 import org.bukkit.event.block.BlockPhysicsEvent;
+import org.bukkit.event.block.BlockPlaceEvent;
+import org.bukkit.event.entity.EntityChangeBlockEvent;
 import org.bukkit.event.entity.EntityCombustEvent;
 import org.bukkit.event.entity.EntityDamageByEntityEvent;
 import org.bukkit.event.entity.EntityDamageEvent;
 import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.event.entity.EntityExplodeEvent;
+import org.bukkit.event.entity.EntityInteractEvent;
+import org.bukkit.event.entity.EntityShootBowEvent;
+import org.bukkit.event.entity.EntityTargetEvent;
+import org.bukkit.event.entity.EntityTargetLivingEntityEvent;
+import org.bukkit.event.entity.EntityTeleportEvent;
+import org.bukkit.event.entity.ProjectileLaunchEvent;
+import org.bukkit.event.entity.SlimeSplitEvent;
 import org.bukkit.event.player.PlayerAnimationEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
 import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerMoveEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.event.player.PlayerToggleFlightEvent;
 import org.bukkit.event.player.PlayerToggleSneakEvent;
+import org.bukkit.util.Vector;
 import org.kitteh.tag.AsyncPlayerReceiveNameTagEvent;
 
 import com.projectkorra.ProjectKorra.Ability.AvatarState;
@@ -35,6 +49,7 @@ import com.projectkorra.ProjectKorra.chiblocking.ChiPassive;
 import com.projectkorra.ProjectKorra.earthbending.EarthPassive;
 import com.projectkorra.ProjectKorra.firebending.Enflamed;
 import com.projectkorra.ProjectKorra.firebending.FireStream;
+import com.projectkorra.ProjectKorra.waterbending.Bloodbending;
 import com.projectkorra.ProjectKorra.waterbending.WaterCore;
 import com.projectkorra.ProjectKorra.waterbending.WaterPassive;
 
@@ -46,6 +61,23 @@ public class PKListener implements Listener {
 		this.plugin = plugin;
 	}
 
+	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
+	public void onPlayerInteraction(PlayerInteractEvent event) {
+		Player player = event.getPlayer();
+		if (Paralyze.isParalyzed(player) || Bloodbending.isBloodbended(player)) {
+			event.setCancelled(true);
+		}
+	}
+
+	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
+	public void onBlockPlace(BlockPlaceEvent event) {
+		Player player = event.getPlayer();
+		if (Paralyze.isParalyzed(player) || Bloodbending.isBloodbended(player)) {
+			event.setCancelled(true);
+		}
+	}
+
+
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onBlockFlowTo(BlockFromToEvent event) {
 		Block toblock = event.getToBlock();
@@ -85,22 +117,22 @@ public class PKListener implements Listener {
 		Methods.saveBendingPlayer(e.getPlayer().getName());
 		BendingPlayer.players.remove(e.getPlayer().getName());
 	}
-	
+
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onPlayerSneak(PlayerToggleSneakEvent event) {
 		Player player = event.getPlayer();
-		
+
 		if (Paralyze.isParaylzed(player) || Bloodbending.isBloodbended(player)) {
 			event.setCancelled(true);
 		}
-		
+
 		AirScooter.check(player);
-		
+
 		String abil = Methods.getBoundAbility(player);
 		if (abil == null) {
 			return;
 		}
-		
+
 		if (!player.isSneaking() && Methods.canBend(player.getName(), abil)) {
 			if (Methods.isAirAbility(abil)) {
 				if (Methods.isWeapon(player.getItemInHand().getType()) && !plugin.getConfig().getBoolean("Properties.Air.CanBendWithWeapons")) {
@@ -116,16 +148,113 @@ public class PKListener implements Listener {
 					new AirBurst(player);
 				}
 			}
+
+			if (Methods.isWaterAbility(abil)) {
+				if (Methods.isWeapon(player.getItemInHand().getType()) && !plugin.getConfig().getBoolean("Properties.Water.CanBendWithWeapons")) {
+					return;
+				}
+				if (abil.equalsIgnoreCase("Bloodbending")) {
+					new Bloodbending(player);
+				}
+			}
 		}
 	}
+
+	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
+	public void onPlayerMove(PlayerMoveEvent event) {
+		Player player = event.getPlayer();
+		if (Paralyze.isParalyzed(player)) {
+			event.setCancelled(true);
+			return;
+		}
+
+		if (Bloodbending.isBloodbended(player)) {
+			double distance1, distance2;
+			Location loc = Bloodbending.getBloodbendingLocation(player);
+			distance1 = event.getFrom().distance(loc);
+			distance2 = event.getTo().distance(loc);
+			if (distance2 > distance1) {
+				player.setVelocity(new Vector(0, 0, 0));
+			}
+		}
+	}
+
+	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
+	public void onEntityTargetLiving(EntityTargetLivingEntityEvent event) {
+		Entity entity = event.getEntity();
+		if (Paralyze.isParalyzed(entity) || Bloodbending.isBloodbended(entity)) {
+			event.setCancelled(true);
+		}
+	}
+
+	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
+	public void onTarget(EntityTargetEvent event) {
+		Entity entity = event.getEntity();
+		if (Paralyze.isParalyzed(entity) || Bloodbending.isBloodbended(entity)) {
+			event.setCancelled(true);
+		}
+	}
+
+	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
+	public void onEntityChangeBlockEvent(EntityChangeBlockEvent event) {
+		Entity entity = event.getEntity();
+		if (Paralyze.isParalyzed(entity) || Bloodbending.isBloodbended(entity))
+			event.setCancelled(true);
+	}
+
+	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
+	public void onEntityExplodeEvent(EntityExplodeEvent event) {
+		Entity entity = event.getEntity();
+		if (entity != null)
+			if (Paralyze.isParalyzed(entity)
+					|| Bloodbending.isBloodbended(entity))
+				event.setCancelled(true);
+	}
+
+	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
+	public void onEntityInteractEvent(EntityInteractEvent event) {
+		Entity entity = event.getEntity();
+		if (Paralyze.isParalyzed(entity) || Bloodbending.isBloodbended(entity))
+			event.setCancelled(true);
+	}
+
+	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
+	public void onEntityShootBowEvent(EntityShootBowEvent event) {
+		Entity entity = event.getEntity();
+		if (Paralyze.isParalyzed(entity) || Bloodbending.isBloodbended(entity))
+			event.setCancelled(true);
+	}
+
+	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
+	public void onEntityTeleportEvent(EntityTeleportEvent event) {
+		Entity entity = event.getEntity();
+		if (Paralyze.isParalyzed(entity) || Bloodbending.isBloodbended(entity))
+			event.setCancelled(true);
+	}
+
+	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
+	public void onEntityProjectileLaunchEvent(ProjectileLaunchEvent event) {
+		Entity entity = event.getEntity();
+		if (Paralyze.isParalyzed(entity) || Bloodbending.isBloodbended(entity))
+			event.setCancelled(true);
+	}
+
+	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
+	public void onEntitySlimeSplitEvent(SlimeSplitEvent event) {
+		Entity entity = event.getEntity();
+		if (Paralyze.isParalyzed(entity) || Bloodbending.isBloodbended(entity))
+			event.setCancelled(true);
+	}
+
+
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) 
 	public void onPlayerSwing(PlayerAnimationEvent event) {
 		Player player = event.getPlayer();
-		
+
 		if (Bloodbending.isBloodbended(player) || Paralyze.isParalyzed(player)) {
 			event.setCancelled(true);
 		}
-		
+
 		String abil = Methods.getBoundAbility(player);
 		if (abil == null) return;
 		if (Methods.canBend(player.getName(), abil)) {
@@ -143,6 +272,14 @@ public class PKListener implements Listener {
 					AirBurst.coneBurst(player);
 				}
 			}
+			if (Methods.isWaterAbility(abil)) {
+				if (Methods.isWeapon(player.getItemInHand().getType()) && !plugin.getConfig().getBoolean("Properties.Water.CanBendWithWeapons")) {
+					return;
+				}
+				if (abil.equalsIgnoreCase("Bloodbending")) {
+					Bloodbending.launch(player);
+				}
+			}
 		}
 	}
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) 
@@ -215,11 +352,11 @@ public class PKListener implements Listener {
 	public void onPlayerDamage(EntityDamageEvent event) {
 		if (event.getEntity() instanceof Player) {
 			Player player = (Player) event.getEntity();
-			
+
 			if (Methods.isBender(player.getName(), Element.Earth) && event.getCause() == DamageCause.FALL) {
 				Shockwave.fallShockwave(player);
 			}
-			
+
 			if (Methods.isBender(player.getName(), Element.Air) && event.getCause() == DamageCause.FALL && Methods.canBendPassive(player.getName(), Element.Air)) {
 				new Flight(player);
 				player.setAllowFlight(true);
@@ -228,7 +365,7 @@ public class PKListener implements Listener {
 				event.setDamage(0);
 				event.setCancelled(true);
 			}
-			
+
 			if (!event.isCancelled() && Methods.isBender(player.getName(), Element.Water) && event.getCause() == DamageCause.FALL && Methods.canBendPassive(player.getName(), Element.Water)) {
 				if (WaterPassive.applyNoFall(player)) {
 					new Flight(player);
@@ -238,7 +375,7 @@ public class PKListener implements Listener {
 					event.setCancelled(true);
 				}
 			}
-			
+
 			if (!event.isCancelled()
 					&& Methods.isBender(player.getName(), Element.Earth)
 					&& event.getCause() == DamageCause.FALL
@@ -251,7 +388,7 @@ public class PKListener implements Listener {
 					event.setCancelled(true);
 				}
 			}
-			
+
 			if (!event.isCancelled()
 					&& Methods.isBender(player.getName(), Element.Chi)
 					&& event.getCause() == DamageCause.FALL
@@ -261,7 +398,7 @@ public class PKListener implements Listener {
 				double finaldamage = initdamage - newdamage;
 				event.setDamage(finaldamage);
 			}
-			
+
 			if (!event.isCancelled() && event.getCause() == DamageCause.FALL) {
 				Player source = Flight.getLaunchedBy(player);
 				if (source != null) {
@@ -269,18 +406,18 @@ public class PKListener implements Listener {
 					Methods.damageEntity(source, player, event.getDamage());
 				}
 			}
-			
+
 			if (Methods.canBendPassive(player.getName(), Element.Fire)
 					&& Methods.isBender(player.getName(),  Element.Fire)
 					&& (event.getCause() == DamageCause.FIRE || event.getCause() == DamageCause.FIRE_TICK)) {
 				event.setCancelled(!Extinguish.canBurn(player));
 			}
-			
+
 			if (Methods.isBender(player.getName(), Element.Earth)
 					&& event.getCause() == DamageCause.SUFFOCATION && TempBlock.isTempBlock(player.getEyeLocation().getBlock())) {
-						event.setDamage(0);
-						event.setCancelled(true);
-					}
+				event.setDamage(0);
+				event.setCancelled(true);
+			}
 		}
 	}
 

src/com/projectkorra/ProjectKorra/TempPotionEffect.java

@@ -0,0 +1,119 @@
+package com.projectkorra.ProjectKorra;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.potion.PotionEffect;
+
+public class TempPotionEffect {
+
+	private static ConcurrentHashMap<LivingEntity, TempPotionEffect> instances = new ConcurrentHashMap<LivingEntity, TempPotionEffect>();
+
+	private static final long tick = 21;
+
+	private int ID = Integer.MIN_VALUE;
+
+	// private ConcurrentHashMap<Long, PotionEffect> effects = new
+	// ConcurrentHashMap<Long, PotionEffect>();
+	private ConcurrentHashMap<Integer, PotionInfo> infos = new ConcurrentHashMap<Integer, PotionInfo>();
+	private LivingEntity entity;
+
+	private class PotionInfo {
+
+		private long starttime;
+		private PotionEffect effect;
+
+		public PotionInfo(long starttime, PotionEffect effect) {
+			this.starttime = starttime;
+			this.effect = effect;
+		}
+
+		public long getTime() {
+			return starttime;
+		}
+
+		public PotionEffect getEffect() {
+			return effect;
+		}
+
+	}
+
+	public TempPotionEffect(LivingEntity entity, PotionEffect effect,
+			long starttime) {
+		this.entity = entity;
+		if (instances.containsKey(entity)) {
+			TempPotionEffect instance = instances.get(entity);
+			instance.infos
+			.put(instance.ID++, new PotionInfo(starttime, effect));
+			// instance.effects.put(starttime, effect);
+			instances.replace(entity, instance);
+		} else {
+			// effects.put(starttime, effect);
+			infos.put(ID++, new PotionInfo(starttime, effect));
+			instances.put(entity, this);
+		}
+	}
+
+	public TempPotionEffect(LivingEntity entity, PotionEffect effect) {
+		this(entity, effect, System.currentTimeMillis());
+	}
+
+	private void addEffect(PotionEffect effect) {
+		for (PotionEffect peffect : entity.getActivePotionEffects()) {
+			if (peffect.getType().equals(effect.getType())) {
+				if (peffect.getAmplifier() > effect.getAmplifier()) {
+
+					if (peffect.getDuration() > effect.getDuration()) {
+						return;
+					} else {
+						int dt = effect.getDuration() - peffect.getDuration();
+						PotionEffect neweffect = new PotionEffect(
+								effect.getType(), dt, effect.getAmplifier());
+						new TempPotionEffect(entity, neweffect,
+								System.currentTimeMillis()
+								+ peffect.getDuration() * tick);
+						return;
+					}
+
+				} else {
+
+					if (peffect.getDuration() > effect.getDuration()) {
+						entity.removePotionEffect(peffect.getType());
+						entity.addPotionEffect(effect);
+						int dt = peffect.getDuration() - effect.getDuration();
+						PotionEffect neweffect = new PotionEffect(
+								peffect.getType(), dt, peffect.getAmplifier());
+						new TempPotionEffect(entity, neweffect,
+								System.currentTimeMillis()
+								+ effect.getDuration() * tick);
+						return;
+					} else {
+						entity.removePotionEffect(peffect.getType());
+						entity.addPotionEffect(effect);
+						return;
+					}
+
+				}
+			}
+		}
+		entity.addPotionEffect(effect);
+	}
+
+	private void progress() {
+		for (int id : infos.keySet()) {
+			PotionInfo info = infos.get(id);
+			if (info.getTime() < System.currentTimeMillis()) {
+				addEffect(info.getEffect());
+				infos.remove(id);
+			}
+		}
+		if (infos.isEmpty() && instances.containsKey(entity))
+			instances.remove(entity);
+	}
+
+	public static void progressAll() {
+		for (LivingEntity entity : instances.keySet())
+			instances.get(entity).progress();
+	}
+
+}

src/com/projectkorra/ProjectKorra/airbending/AirBurst.java

@@ -192,15 +192,6 @@ public class AirBurst {
 			instances.get(player).progress();
 	}
 
-	public static String getDescription() {
-		return "AirBurst is one of the most powerful abilities in the airbender's arsenal. "
-				+ "To use, press and hold sneak to charge your burst. "
-				+ "Once charged, you can either release sneak to launch a cone-shaped burst "
-				+ "of air in front of you, or click to release the burst in a sphere around you. "
-				+ "Additionally, having this ability selected when you land on the ground from a "
-				+ "large enough fall will create a burst of air around you.";
-	}
-
 	public static void removeAll() {
 		instances.clear();
 

src/com/projectkorra/ProjectKorra/waterbending/Bloodbending.java

@@ -0,0 +1,225 @@
+package com.projectkorra.ProjectKorra.waterbending;
+
+import java.util.ArrayList;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.bukkit.Location;
+import org.bukkit.entity.Creature;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+import org.bukkit.util.Vector;
+
+import com.projectkorra.ProjectKorra.Methods;
+import com.projectkorra.ProjectKorra.ProjectKorra;
+import com.projectkorra.ProjectKorra.TempPotionEffect;
+import com.projectkorra.ProjectKorra.Ability.AvatarState;
+
+public class Bloodbending {
+
+	public static ConcurrentHashMap<Player, Bloodbending> instances = new ConcurrentHashMap<Player, Bloodbending>();
+
+	ConcurrentHashMap<Entity, Location> targetentities = new ConcurrentHashMap<Entity, Location>();
+
+	private static final double factor = ProjectKorra.plugin.getConfig().getDouble("Abilities.Water.Bloodbending.ThrowFactor");
+
+	private Player player;
+	private int range = ProjectKorra.plugin.getConfig().getInt("Abilities.Water.Bloodbending.Range");
+
+	public Bloodbending(Player player) {
+		if (instances.containsKey(player)) {
+			remove(player);
+			return;
+		}
+		range = (int) Methods.waterbendingNightAugment(range, player.getWorld());
+		if (AvatarState.isAvatarState(player)) {
+			range = AvatarState.getValue(range);
+			for (Entity entity : Methods.getEntitiesAroundPoint(
+					player.getLocation(), range)) {
+				if (entity instanceof LivingEntity) {
+					if (entity instanceof Player) {
+//						if (Methods.isRegionProtectedFromBuild(player,
+//								Abilities.Bloodbending, entity.getLocation())
+								if (AvatarState.isAvatarState((Player) entity)
+								|| entity.getEntityId() == player.getEntityId()
+								|| Methods.canBend(((Player) entity).getName(),
+										"Bloodbending"))
+							continue;
+					}
+					Methods.damageEntity(player, entity, 0);
+					targetentities.put(entity, entity.getLocation().clone());
+				}
+			}
+		} else {
+			Entity target = Methods.getTargetedEntity(player, range, new ArrayList<Entity>());
+			if (target == null)
+				return;
+			if (!(target instanceof LivingEntity))
+//					|| Methods.isRegionProtectedFromBuild(player,
+//							Abilities.Bloodbending, target.getLocation()))
+				return;
+			if (target instanceof Player) {
+				if (Methods.canBend(((Player) target).getName(), "Bloodbending")
+						|| AvatarState.isAvatarState((Player) target))
+					return;
+			}
+			Methods.damageEntity(player, target, 0);
+			targetentities.put(target, target.getLocation().clone());
+		}
+		this.player = player;
+		instances.put(player, this);
+	}
+
+	public static void launch(Player player) {
+		if (instances.containsKey(player))
+			instances.get(player).launch();
+	}
+
+	private void launch() {
+		Location location = player.getLocation();
+		for (Entity entity : targetentities.keySet()) {
+			double dx, dy, dz;
+			Location target = entity.getLocation().clone();
+			dx = target.getX() - location.getX();
+			dy = target.getY() - location.getY();
+			dz = target.getZ() - location.getZ();
+			Vector vector = new Vector(dx, dy, dz);
+			vector.normalize();
+			entity.setVelocity(vector.multiply(factor));
+		}
+		remove(player);
+	}
+
+	private void progress() {
+		PotionEffect effect = new PotionEffect(PotionEffectType.SLOW, 60, 1);
+
+		if (!player.isSneaking()) {
+			remove(player);
+			return;
+		}
+		
+		if (!Methods.canBend(player.getName(), "Bloodbending")) {
+			remove(player);
+			return;
+		}
+		if (Methods.getBoundAbility(player) == null) {
+			remove(player);
+			return;
+		}
+		if (!Methods.getBoundAbility(player).equalsIgnoreCase("Bloodbending")) {
+			remove(player);
+			return;
+		}
+
+		if (AvatarState.isAvatarState(player)) {
+			ArrayList<Entity> entities = new ArrayList<Entity>();
+			for (Entity entity : Methods.getEntitiesAroundPoint(
+					player.getLocation(), range)) {
+//				if (Methods.isRegionProtectedFromBuild(player,
+//						Abilities.Bloodbending, entity.getLocation()))
+//					continue;
+				if (entity instanceof Player) {
+					if (!Methods.canBeBloodbent((Player) entity))
+						continue;
+				}
+				entities.add(entity);
+				if (!targetentities.containsKey(entity)
+						&& entity instanceof LivingEntity) {
+					Methods.damageEntity(player, entity, 0);
+					targetentities.put(entity, entity.getLocation().clone());
+				}
+				if (entity instanceof LivingEntity) {
+					Location newlocation = entity.getLocation().clone();
+					Location location = targetentities.get(entity);
+					double distance = location.distance(newlocation);
+					double dx, dy, dz;
+					dx = location.getX() - newlocation.getX();
+					dy = location.getY() - newlocation.getY();
+					dz = location.getZ() - newlocation.getZ();
+					Vector vector = new Vector(dx, dy, dz);
+					if (distance > .5) {
+						entity.setVelocity(vector.normalize().multiply(.5));
+					} else {
+						entity.setVelocity(new Vector(0, 0, 0));
+					}
+					new TempPotionEffect((LivingEntity) entity, effect);
+					entity.setFallDistance(0);
+					if (entity instanceof Creature) {
+						((Creature) entity).setTarget(null);
+					}
+				}
+			}
+			for (Entity entity : targetentities.keySet()) {
+				if (!entities.contains(entity))
+					targetentities.remove(entity);
+			}
+		} else {
+			for (Entity entity : targetentities.keySet()) {
+				if (entity instanceof Player) {
+					if (!Methods.canBeBloodbent((Player) entity)) {
+						targetentities.remove(entity);
+						continue;
+					}
+				}
+				Location newlocation = entity.getLocation();
+				Location location = Methods.getTargetedLocation(
+						player,
+						(int) targetentities.get(entity).distance(
+								player.getLocation()));
+				double distance = location.distance(newlocation);
+				double dx, dy, dz;
+				dx = location.getX() - newlocation.getX();
+				dy = location.getY() - newlocation.getY();
+				dz = location.getZ() - newlocation.getZ();
+				Vector vector = new Vector(dx, dy, dz);
+				if (distance > .5) {
+					entity.setVelocity(vector.normalize().multiply(.5));
+				} else {
+					entity.setVelocity(new Vector(0, 0, 0));
+				}
+				new TempPotionEffect((LivingEntity) entity, effect);
+				entity.setFallDistance(0);
+				if (entity instanceof Creature) {
+					((Creature) entity).setTarget(null);
+				}
+			}
+		}
+	}
+
+	public static void progressAll() {
+		for (Player player : instances.keySet()) {
+			instances.get(player).progress();
+		}
+	}
+
+	public static void remove(Player player) {
+		if (instances.containsKey(player)) {
+			instances.remove(player);
+		}
+	}
+
+	public static boolean isBloodbended(Entity entity) {
+		for (Player player : instances.keySet()) {
+			if (instances.get(player).targetentities.containsKey(entity)) {
+				// if (entity instanceof Player) {
+				// if (!Methods.canBeBloodbent((Player) entity))
+				// return false;
+				// }
+				return true;
+			}
+		}
+		return false;
+	}
+
+	public static Location getBloodbendingLocation(Entity entity) {
+		for (Player player : instances.keySet()) {
+			if (instances.get(player).targetentities.containsKey(entity)) {
+				return instances.get(player).targetentities.get(entity);
+			}
+		}
+		return null;
+	}
+
+}

src/config.yml

@@ -51,6 +51,9 @@ Abilities:
       Range: 20
       Radius: 2
       Push: 3.5
+    AirBurst:
+      Enabled: true
+      Description: "AirBurst is one of the most powerful abilities in an airbender's arsenal. To use, press and hold sneak to charge your burst. Once charged, you can either release sneak to launch a cone-shaped burst of air in front of you, or click to release theb urst in a sphere around you. Additionally, having this ability selected when you land on the ground from a large enough fall will create a burst of air around you."
     Tornado: 
       Enabled: true
       Description: "To use, simply sneak (default: shift). This will create a swirling vortex at the targeted lcoation. Any creature or object caught in the vortex will be launched up and out in some random direction. If another player gets caught in the vortex, the launching effect is minimal. Tornado can also be used to transport the user. If the user gets caught in his/her own tornado, his/her movements are much more manageable. Provided the user doesn't fall out of the vortex, it will take him to a maximum height and move him in the general direction he/she is looking. Skilled airbenders can scale anything with this ability."
@@ -62,6 +65,11 @@ Abilities:
   Water:
     Passive:
       SwimSpeedFactor: 0.7
+    Bloodbending:
+      Enabled: true
+      Description: "This ability was made illegal for a reason. With this ability selected, sneak while targeting something and you will bloodbend that target. Bloodbent targets cannot move, bend, or attack. You are free to control their actions by looking elsewhere - they will be forced to move in that direciton. Additionally, clicking while bloodbending will launch that target off in the direction you're looking. People who are capable of bloodbending are immune to technique, and you are immune to theirs.";
+      ThrowFactor: 2
+      Range: 10
     Plantbending:
       RegrowTime: 180000
   Earth: