WaterCore

Some more Waterbending Methods (This is proving to be a pain)

.classpath

@@ -5,9 +5,9 @@
 	<classpathentry kind="lib" path="C:/Users/Shawn/Documents/Bending Plugins/TagAPI.jar"/>
 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
 	<classpathentry kind="lib" path="C:/Users/Shawn/Documents/LocalServer/plugins/ProjectKorra/Abilities/RaiseEarth.jar"/>
-	<classpathentry kind="lib" path="C:/Users/Shawn/Documents/LocalServer/plugins/ProjectKorra/Abilities/WaterManipulation.jar"/>
 	<classpathentry kind="lib" path="C:/Users/Shawn/Documents/LocalServer/plugins/ProjectKorra/Abilities/OctopusForm.jar"/>
-	<classpathentry kind="lib" path="C:/Users/Shawn/Documents/LocalServer/plugins/ProjectKorra/Abilities/PhaseChange.jar"/>
+	<classpathentry kind="lib" path="C:/Users/Shawn/Documents/LocalServer/plugins/ProjectKorra/Abilities/WaterSpout.jar"/>
+	<classpathentry kind="lib" path="C:/Users/Shawn/Documents/LocalServer/plugins/ProjectKorra/Abilities/WaterManipulation.jar"/>
 	<classpathentry kind="lib" path="C:/Users/Shawn/Documents/LocalServer/plugins/ProjectKorra/Abilities/Surge.jar"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

src/com/projectkorra/ProjectKorra/Methods.java

@@ -32,7 +32,7 @@ import org.bukkit.util.Vector;
 import com.projectkorra.ProjectKorra.Ability.AbilityModule;
 import com.projectkorra.ProjectKorra.Ability.AbilityModuleManager;
 import com.projectkorra.ProjectKorra.earthbending.EarthPassive;
-import com.projectkorra.abilities.PhaseChange.FreezeMelt;
+import com.projectkorra.ProjectKorra.waterbending.WaterCore;
 import com.projectkorra.abilities.RaiseEarth.EarthColumn;
 
 public class Methods {
@@ -541,7 +541,7 @@ public class Methods {
 		boolean adjacent = false;
 		if (Methods.isAbilityInstalled("PhaseChange", "orion304")) {
 			for (BlockFace face : faces) {
-				if (FreezeMelt.frozenblocks.containsKey((block.getRelative(face))))
+				if (WaterCore.frozenblocks.containsKey((block.getRelative(face))))
 					adjacent = true;
 			}
 		}

src/com/projectkorra/ProjectKorra/PKListener.java

@@ -11,10 +11,15 @@ import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockBreakEvent;
 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.entity.EntityCombustEvent;
 import org.bukkit.event.entity.EntityDamageByEntityEvent;
 import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.EntityExplodeEvent;
 import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
 import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
@@ -24,7 +29,10 @@ 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.WaterCore;
 import com.projectkorra.ProjectKorra.waterbending.WaterPassive;
+import com.projectkorra.abilities.Surge.WaterWall;
+import com.projectkorra.abilities.Surge.WaveAbility;
 
 public class PKListener implements Listener {
 
@@ -34,6 +42,17 @@ public class PKListener implements Listener {
 		this.plugin = plugin;
 	}
 
+	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
+	public void onBlockFlowTo(BlockFromToEvent event) {
+		Block toblock = event.getToBlock();
+		Block fromblock = event.getBlock();
+		if (Methods.isWater(fromblock)) {
+			if (!event.isCancelled()) {
+				event.setCancelled(!WaterCore.canFlowFromTo(fromblock, toblock));
+			}
+		}
+	}
+
 	@EventHandler
 	public void onPlayerJoin(PlayerJoinEvent e) {
 		Methods.createBendingPlayer(e.getPlayer().getUniqueId(), e.getPlayer().getName());
@@ -69,20 +88,20 @@ public class PKListener implements Listener {
 			new Enflamed(entity, FireStream.ignitedblocks.get(block));
 		}
 	}
-	
+
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onEntityDamageEvent(EntityDamageEvent event) {
 		Entity entity = event.getEntity();
 		if (event.getCause() == DamageCause.FIRE && FireStream.ignitedblocks.containsKey(entity.getLocation().getBlock())) {
 			new Enflamed(entity, FireStream.ignitedblocks.get(entity.getLocation().getBlock()));
 		}
-		
+
 		if (Enflamed.isEnflamed(entity) && event.getCause() == DamageCause.FIRE_TICK) {
 			event.setCancelled(true);
 			Enflamed.dealFlameDamage(entity);
 		}
 	}
-	
+
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onBlockMeltEvent(BlockFadeEvent event) {
 		Block block = event.getBlock();
@@ -115,6 +134,41 @@ public class PKListener implements Listener {
 			}
 		}
 	}
+
+	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) 
+	public void onBlockBreak(BlockBreakEvent event) {
+		Block block = event.getBlock();
+		Player player = event.getPlayer();
+		if (Methods.isAbilityInstalled("Surge", "orion304")) {	
+			if (WaterWall.wasBrokenFor(player, block)) {
+				event.setCancelled(true);
+				return;
+			}
+			if (WaterCore.waterwallblocks.containsKey(block)) {
+				WaterWall.thaw(block);
+				event.setCancelled(true);
+			}
+			if (!WaveAbility.canThaw(block)) {
+				WaveAbility.thaw(block);
+				event.setCancelled(true);
+			}
+		}
+	}
+
+	@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
+	public void onEntityExplode(EntityExplodeEvent event) {
+		for (Block block: event.blockList()) {
+			if (Methods.isAbilityInstalled("Surge", "orion304")) {
+				if (WaterCore.waterwallblocks.containsKey(block)) {
+					block.setType(Material.AIR);
+				}
+				if (!WaveAbility.canThaw(block)) {
+					WaveAbility.thaw(block);
+				}
+			}
+		}
+	}
+
 	@EventHandler
 	public void onPlayerDamage(EntityDamageEvent e) {
 		Entity en = e.getEntity();
@@ -145,6 +199,18 @@ public class PKListener implements Listener {
 		}
 	}
 
+	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
+	public void onBlockPhysics(BlockPhysicsEvent event) {
+		Block block = event.getBlock();
+		event.setCancelled(!WaterCore.canPhysicsChange(block));
+	}
+
+	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
+	public void onBlockForm(BlockFormEvent event) {
+		if (!WaterCore.canPhysicsChange(event.getBlock()))
+			event.setCancelled(true);
+	}
+
 	public void onNameTag(AsyncPlayerReceiveNameTagEvent e) {
 		List<Element> elements = Methods.getBendingPlayer(e.getNamedPlayer().getName()).getElements();
 		if (elements.size() > 1)

src/com/projectkorra/ProjectKorra/ProjectKorra.java

@@ -20,7 +20,6 @@ public class ProjectKorra extends JavaPlugin {
 		plugin = this;
 
 		new Methods(this);
-		getServer().getPluginManager().registerEvents(new PKListener(this), this);
 
 		new Commands(this);
 		new AbilityModuleManager(this);
@@ -38,6 +37,7 @@ public class ProjectKorra extends JavaPlugin {
 		for (Player player: Bukkit.getOnlinePlayers()) {
 			Methods.createBendingPlayer(player.getUniqueId(), player.getName());
 		}
+		getServer().getPluginManager().registerEvents(new PKListener(this), this);
 	}
 
 	@Override

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

@@ -0,0 +1,118 @@
+package com.projectkorra.ProjectKorra.waterbending;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+
+import com.projectkorra.ProjectKorra.Methods;
+import com.projectkorra.ProjectKorra.TempBlock;
+import com.projectkorra.abilities.Surge.WaveAbility;
+import com.projectkorra.abilities.WaterSpout.WaterSpoutAbility;
+
+public class WaterCore {
+
+	public static ConcurrentHashMap<Block, Byte> frozenblocks = new ConcurrentHashMap<Block, Byte>();
+	public static ConcurrentHashMap<Block, Block> waterSpoutAffectedBlocks = new ConcurrentHashMap<Block, Block>();
+	public static ConcurrentHashMap<Block, Block> waterManipulationAffectedBlocks = new ConcurrentHashMap<Block, Block>();
+
+	public static ConcurrentHashMap<Block, Block> waterWallAffectedBlocks = new ConcurrentHashMap<Block, Block>();
+	public static ConcurrentHashMap<Block, Player> waterwallblocks = new ConcurrentHashMap<Block, Player>();
+
+
+
+	public static void freeze(Player player, Block block) {
+		//		if (Methods.isRegionProtectedFromBuild(player, Abilities.PhaseChange,
+		//				block.getLocation()))
+		//			return;
+		if (TempBlock.isTempBlock(block))
+			return;
+		byte data = block.getData();
+		block.setType(Material.ICE);
+		frozenblocks.put(block, data);
+	}
+
+	public static void removeSpouts(Location loc0, double radius,
+			Player sourceplayer) {
+		if (!Methods.isAbilityInstalled("WaterSpout", "orion304")) return;
+		for (Player player : WaterSpoutAbility.instances.keySet()) {
+			if (!player.equals(sourceplayer)) {
+				Location loc1 = player.getLocation().getBlock().getLocation();
+				loc0 = loc0.getBlock().getLocation();
+				double dx = loc1.getX() - loc0.getX();
+				double dy = loc1.getY() - loc0.getY();
+				double dz = loc1.getZ() - loc0.getZ();
+
+				double distance = Math.sqrt(dx * dx + dz * dz);
+
+				if (distance <= radius && dy > 0 && dy < WaterSpoutAbility.defaultheight)
+					WaterSpoutAbility.instances.get(player).remove();
+			}
+		}
+	}
+
+	public static void thaw(Block block) {
+		if (frozenblocks.containsKey(block)) {
+			byte data = frozenblocks.get(block);
+			frozenblocks.remove(block);
+			block.setType(Material.WATER);
+			block.setData(data);
+		}
+	}
+
+	public static boolean canFlowFromTo(Block from, Block to) {
+		if (WaterCore.waterManipulationAffectedBlocks.containsKey(to) || WaterCore.waterManipulationAffectedBlocks.containsKey(from)) {
+			return false;
+		}
+		if (WaterCore.waterSpoutAffectedBlocks.containsKey(to) || WaterCore.waterSpoutAffectedBlocks.containsKey(from)) {
+			return false;
+		}
+
+		if (waterWallAffectedBlocks.containsKey(to)
+				|| waterWallAffectedBlocks.containsKey(from)) {
+			return false;
+		}
+
+		if (waterwallblocks.containsKey(to)
+				|| waterwallblocks.containsKey(from)) {
+			return false;
+		}
+//		if (WaveAbility.isBlockWave(to) || WaveAbility.isBlockWave(from)) {
+//			return false;
+//		}
+
+		if (TempBlock.isTempBlock(to) || TempBlock.isTempBlock(from)) {
+			return false;
+		}
+		if (Methods.isAdjacentToFrozenBlock(to)
+				|| Methods.isAdjacentToFrozenBlock(from)) {
+			return false;
+		}
+
+		return true;
+	}
+
+	public static boolean canPhysicsChange(Block block) {
+		if (waterManipulationAffectedBlocks.containsKey(block))
+			return false;
+		if (Methods.isAbilityInstalled("WaterSpout", "orion304")) {
+			if (waterSpoutAffectedBlocks.containsKey(block))
+				return false;
+		}
+		if (Methods.isAbilityInstalled("Surge", "orion304")) {
+			if (waterWallAffectedBlocks.containsKey(block))
+				return false;
+			if (waterwallblocks.containsKey(block))
+				return false;
+//			if (WaveAbility.isBlockWave(block))
+//				return false;
+		}
+		if (TempBlock.isTempBlock(block))
+			return false;
+		if (TempBlock.isTouchingTempBlock(block))
+			return false;
+		return true;
+	}
+}

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

@@ -15,7 +15,7 @@ import com.projectkorra.ProjectKorra.Methods;
 import com.projectkorra.ProjectKorra.TempBlock;
 import com.projectkorra.abilities.OctopusForm.OctopusFormAbility;
 import com.projectkorra.abilities.Surge.WaterWall;
-import com.projectkorra.abilities.Surge.Wave;
+import com.projectkorra.abilities.Surge.WaveAbility;
 import com.projectkorra.abilities.WaterManipulation.WaterManipulationAbility;
 
 public class WaterReturn {
@@ -156,7 +156,7 @@ public class WaterReturn {
 
 	private static boolean isBending(Player player) {
 		if (Methods.isAbilityInstalled("WaterManipulation", "orion304")) {
-			for (int id : WaterManipulationAbility .instances.keySet()) {
+			for (int id : WaterManipulationAbility.instances.keySet()) {
 				WaterManipulationAbility.instances.get(id);
 				if (WaterManipulationAbility.player.equals(player))
 					return true;
@@ -167,11 +167,10 @@ public class WaterReturn {
 				return true;
 		}
 		if (Methods.isAbilityInstalled("Surge", "orion304")) {
-			for (int id : Wave.instances.keySet()) {
-				if (Wave.instances.get(id).player.equals(player))
+			for (int id : WaveAbility.instances.keySet()) {
+				if (WaveAbility.instances.get(id).player.equals(player))
 					return true;
 			}
-
 			for (int id : WaterWall.instances.keySet()) {
 				if (WaterWall.instances.get(id).player.equals(player))
 					return true;