Update Listener to use errorLog method

src/com/projectkorra/ProjectKorra/PKListener.java

@@ -2,6 +2,7 @@ package com.projectkorra.ProjectKorra;
 
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.IllegalFormatException;
 import java.util.List;
 
 import org.bukkit.Bukkit;
@@ -152,6 +153,7 @@ public class PKListener implements Listener {
 
 	@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
 	public void onEntityDamageByBlock(EntityDamageByBlockEvent event) {
+		try {
 			if (event.getCause().equals(DamageCause.BLOCK_EXPLOSION)) {
 				if (event.getDamager() == null) {
 					event.setCancelled(true);
@@ -163,29 +165,33 @@ public class PKListener implements Listener {
 					event.setCancelled(true);
 				}
 			}
-
+		} catch (Exception ex) {
+			GeneralMethods.logError(ex, false);
+		}
 	}
 
 	@EventHandler
-	public void onHorizontalCollision(HorizontalVelocityChangeEvent e)
+	public void onHorizontalCollision(HorizontalVelocityChangeEvent e) {
-	{
+		try {
 			if(!plugin.getConfig().getBoolean("Properties.HorizontalCollisionPhysics.Enabled"))
 				return;
 
-		if(e.getEntity() instanceof LivingEntity)
+			if(e.getEntity() instanceof LivingEntity) {
-		{
+				if(e.getEntity().getEntityId() != e.getInstigator().getEntityId()) {
-			if(e.getEntity().getEntityId() != e.getInstigator().getEntityId())
-			{
 					double minimumDistance = plugin.getConfig().getDouble("Properties.HorizontalCollisionPhysics.WallDamageMinimumDistance");
 					double damage = ((e.getDistanceTraveled() - minimumDistance) < 0 ? 0 : e.getDistanceTraveled() - minimumDistance) / (e.getDifference().length());
 					if(damage > 0)
 						GeneralMethods.damageEntity(e.getInstigator(), e.getEntity(), damage);
 				}
 			}
+		} catch (Exception ex) {
+			GeneralMethods.logError(ex, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onPlayerGrapple(PlayerGrappleEvent event) {
+		try {
 			if (event.isCancelled()) return;
 			if (!plugin.getConfig().getBoolean("Properties.CustomItems.GrapplingHook.Enable")) return;
 
@@ -227,10 +233,14 @@ public class PKListener implements Listener {
 				}
 				GrapplingHookAPI.addPlayerCooldown(player, 100);
 			}
+		} catch (Exception ex) {
+			GeneralMethods.logError(ex, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
 	public void onProjectileHit(ProjectileHitEvent event) {
+		try {
 			Integer id = event.getEntity().getEntityId();
 			if (Smokescreen.snowballs.contains(id)) {
 				Location loc = event.getEntity().getLocation();
@@ -249,10 +259,14 @@ public class PKListener implements Listener {
 			////				}
 			////			}
 			//		}
+		} catch (Exception ex) {
+			GeneralMethods.logError(ex, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.HIGHEST)
 	public void fishEvent(PlayerFishEvent event) {
+		try {
 			if (event.isCancelled()) return;
 			Player player = event.getPlayer();
 			if (GrapplingHookAPI.isGrapplingHook(player.getItemInHand())) {
@@ -270,9 +284,13 @@ public class PKListener implements Listener {
 					plugin.getServer().getPluginManager().callEvent(e);
 				}
 			}
+		} catch (Exception ex) {
+			GeneralMethods.logError(ex, false);
+		}
 	}
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onPlayerInteraction(PlayerInteractEvent event) {
+		try {
 			if (event.isCancelled()) return;
 			Player player = event.getPlayer();
 
@@ -286,21 +304,29 @@ public class PKListener implements Listener {
 			if (Paralyze.isParalyzed(player) || ChiComboManager.isParalyzed(player) || Bloodbending.isBloodbended(player) || Suffocate.isBreathbent(player)) {
 				event.setCancelled(true);
 			}
+		} catch (Exception ex) {
+			GeneralMethods.logError(ex, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onBlockPlace(BlockPlaceEvent event) {
+		try {
 			if (event.isCancelled()) return;
 			Player player = event.getPlayer();
 			GeneralMethods.cooldowns.put(player.getName(), System.currentTimeMillis());
 			if (Paralyze.isParalyzed(player) || ChiComboManager.isParalyzed(player) || Bloodbending.isBloodbended(player) || Suffocate.isBreathbent(player)) {
 				event.setCancelled(true);
 			}
+		} catch (Exception ex) {
+			GeneralMethods.logError(ex, false);
+		}
 	}
 
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onBlockFlowTo(BlockFromToEvent event) {
+		try {
 			if (event.isCancelled()) return;
 			Block toblock = event.getToBlock();
 			Block fromblock = event.getBlock();
@@ -318,15 +344,23 @@ public class PKListener implements Listener {
 						toblock.setType(Material.AIR);
 				}
 			}
+		} catch (Exception ex) {
+			GeneralMethods.logError(ex, false);
+		}
 	}
 
 	@EventHandler
 	public void onPlayerJoin(PlayerJoinEvent e) {
+		try {
 			Player player = e.getPlayer();
 			GeneralMethods.createBendingPlayer(e.getPlayer().getUniqueId(), player.getName());
+		} catch (Exception ex) {
+			GeneralMethods.logError(ex, false);
+		}
 	}
 	
 	public static void login(BendingPlayer pl) {
+        try {
         	ProjectKorra plugin = ProjectKorra.plugin;
             Player player = Bukkit.getPlayer(pl.getUUID());
             
@@ -376,11 +410,14 @@ public class PKListener implements Listener {
                     }
                 }
             }
+		} catch (Exception ex) {
+			GeneralMethods.logError(ex, false);
+		}
     }
 
 	@EventHandler
 	public void onPlayerQuit(PlayerQuitEvent event) {
-		
+		try {
 			Player player = event.getPlayer();
 			BendingPlayer bPlayer = GeneralMethods.getBendingPlayer(player.getName());
 			if (bPlayer != null) {
@@ -400,27 +437,33 @@ public class PKListener implements Listener {
 				event.getPlayer().removePotionEffect(PotionEffectType.DAMAGE_RESISTANCE);
 			}
 			
-		for(Player p : MetalClips.instances.keySet())
+			for (Player p : MetalClips.instances.keySet()) {
-		{
 				if (MetalClips.instances.get(p).getTarget() != null &&
-					MetalClips.instances.get(p).getTarget().getEntityId() == event.getPlayer().getEntityId())
+						MetalClips.instances.get(p).getTarget().getEntityId() == event.getPlayer().getEntityId()) {
-			{
 					MetalClips.instances.get(p).remove();
 				}
 			}
 			
-		com.projectkorra.ProjectKorra.airbending.FlightAbility.remove(event.getPlayer());
+			FlightAbility.remove(event.getPlayer());
+		} catch (Exception ex) {
+			GeneralMethods.logError(ex, false);
+		}
 	}
 	
 	@EventHandler
 	public void playerIsKicked(PlayerKickEvent event) {
+		try {
 			if(event.isCancelled()) return;
 			
-		com.projectkorra.ProjectKorra.airbending.FlightAbility.remove(event.getPlayer());
+			FlightAbility.remove(event.getPlayer());
+		} catch (Exception ex) {
+			GeneralMethods.logError(ex, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onPlayerSneak(PlayerToggleSneakEvent event) {
+		try {
 			Player player = event.getPlayer();
 
 			if (event.isCancelled()) return;
@@ -549,10 +592,8 @@ public class PKListener implements Listener {
 						new Extraction(player);
 					}
 					
-				if(abil.equalsIgnoreCase("MetalClips"))
+					if(abil.equalsIgnoreCase("MetalClips")) {
-				{
+						if(MetalClips.instances.containsKey(player)) {
-					if(MetalClips.instances.containsKey(player))
-					{
 							if(MetalClips.instances.get(player).getTarget() == null)
 								MetalClips.instances.get(player).magnet();
 							else
@@ -602,6 +643,9 @@ public class PKListener implements Listener {
 					}
 				}
 			}
+		} catch (Exception e) {
+			GeneralMethods.logError(e, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
@@ -611,6 +655,7 @@ public class PKListener implements Listener {
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onPlayerMove(PlayerMoveEvent event) {
+		try {
 			if (event.isCancelled()) return;
 
 			Player player = event.getPlayer();
@@ -619,8 +664,7 @@ public class PKListener implements Listener {
 				return;
 			}
 			
-		if(ChiComboManager.isParalyzed(player))
+			if(ChiComboManager.isParalyzed(player))	{
-		{
 				event.setTo(event.getFrom());
 				return;
 			}
@@ -675,30 +719,42 @@ public class PKListener implements Listener {
 					}
 				}
 			}
+		} catch (Exception ex) {
+			GeneralMethods.logError(ex, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onEntityTargetLiving(EntityTargetLivingEntityEvent event) {
+		try {
 			if (event.isCancelled()) return;
 
 			Entity entity = event.getEntity();
 			if (Paralyze.isParalyzed(entity) || ChiComboManager.isParalyzed(entity) || Bloodbending.isBloodbended(entity)) {
 				event.setCancelled(true);
 			}
+		} catch (Exception ex) {
+			GeneralMethods.logError(ex, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onTarget(EntityTargetEvent event) {
+		try {
 			if (event.isCancelled()) return;
 
 			Entity entity = event.getEntity();
 			if (Paralyze.isParalyzed(entity) || ChiComboManager.isParalyzed(entity) || Bloodbending.isBloodbended(entity)) {
 				event.setCancelled(true);
 			}
+		} catch (Exception ex) {
+			GeneralMethods.logError(ex, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onEntityChangeBlockEvent(EntityChangeBlockEvent event) {
+		try {
 			if (event.isCancelled()) return;
 
 			Entity entity = event.getEntity();
@@ -711,10 +767,14 @@ public class PKListener implements Listener {
 					event.setCancelled(true);
 				}
 			}
+		} catch (Exception ex) {
+			GeneralMethods.logError(ex, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
 	public void onEntityExplode(EntityExplodeEvent event) {
+		try {
 			if (event.isCancelled()) return;
 
 			for (Block block : event.blockList()) {
@@ -736,14 +796,14 @@ public class PKListener implements Listener {
 					EarthMethods.removeRevertIndex(block);
 				}
 			}
-
+		} catch (Exception ex) {
-
+			GeneralMethods.logError(ex, false);
-
+		}
 	}
-
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onEntityExplodeEvent(EntityExplodeEvent event) {
+		try {
 			if (event.isCancelled()) return;
 
 			Entity entity = event.getEntity();
@@ -751,56 +811,80 @@ public class PKListener implements Listener {
 				if (Paralyze.isParalyzed(entity) || ChiComboManager.isParalyzed(entity)
 						|| Bloodbending.isBloodbended(entity) || Suffocate.isBreathbent(entity))
 					event.setCancelled(true);
+		} catch (Exception ex) {
+			GeneralMethods.logError(ex, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onEntityInteractEvent(EntityInteractEvent event) {
+		try {
 			if (event.isCancelled()) return;
 
 			Entity entity = event.getEntity();
 			if (Paralyze.isParalyzed(entity) || ChiComboManager.isParalyzed(entity) || Bloodbending.isBloodbended(entity) || Suffocate.isBreathbent(entity))
 				event.setCancelled(true);
+		} catch (Exception ex) {
+			GeneralMethods.logError(ex, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onEntityShootBowEvent(EntityShootBowEvent event) {
+		try {
 			if (event.isCancelled()) return;
 
 			Entity entity = event.getEntity();
 			if (Paralyze.isParalyzed(entity) || ChiComboManager.isParalyzed(entity) || Bloodbending.isBloodbended(entity) || Suffocate.isBreathbent(entity))
 				event.setCancelled(true);
+		} catch (Exception ex) {
+			GeneralMethods.logError(ex, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onEntityTeleportEvent(EntityTeleportEvent event) {
+		try {
 			if (event.isCancelled()) return;
 
 			Entity entity = event.getEntity();
 			if (Paralyze.isParalyzed(entity) || ChiComboManager.isParalyzed(entity) || Bloodbending.isBloodbended(entity) || Suffocate.isBreathbent(entity))
 				event.setCancelled(true);
+		} catch (Exception e) {
+			GeneralMethods.logError(e, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onEntityProjectileLaunchEvent(ProjectileLaunchEvent event) {
+		try {
 			if (event.isCancelled()) return;
 
 			Entity entity = event.getEntity();
 			if (Paralyze.isParalyzed(entity) || ChiComboManager.isParalyzed(entity) || Bloodbending.isBloodbended(entity) || Suffocate.isBreathbent(entity))
 				event.setCancelled(true);
+		} catch (Exception e) {
+			GeneralMethods.logError(e, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onEntitySlimeSplitEvent(SlimeSplitEvent event) {
+		try {
 			if (event.isCancelled()) return;
 
 			Entity entity = event.getEntity();
 			if (Paralyze.isParalyzed(entity) || ChiComboManager.isParalyzed(entity) || Bloodbending.isBloodbended(entity) || Suffocate.isBreathbent(entity))
 				event.setCancelled(true);
+		} catch (Exception e) {
+			GeneralMethods.logError(e, false);
+		}
 	}
 
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) 
 	public void onPlayerSwing(PlayerAnimationEvent event) {
+		try {
 			if (event.isCancelled()) return;
 
 			Player player = event.getPlayer();
@@ -856,11 +940,11 @@ public class PKListener implements Listener {
 						if (!ProjectKorra.plugin.getConfig().getBoolean("Abilities.Air.Flight.HoverEnabled")
 								|| !AirMethods.canAirFlight(player)) return;
 						
-					if(com.projectkorra.ProjectKorra.airbending.FlightAbility.instances.containsKey(event.getPlayer().getName())) {
+						if (FlightAbility.instances.containsKey(event.getPlayer().getName())) {
-						if(com.projectkorra.ProjectKorra.airbending.FlightAbility.isHovering(event.getPlayer())) {
+							if (FlightAbility.isHovering(event.getPlayer())) {
-							com.projectkorra.ProjectKorra.airbending.FlightAbility.setHovering(event.getPlayer(), false);
+								FlightAbility.setHovering(event.getPlayer(), false);
 							} else {
-							com.projectkorra.ProjectKorra.airbending.FlightAbility.setHovering(event.getPlayer(), true);
+								FlightAbility.setHovering(event.getPlayer(), true);
 							}
 						}
 					}
@@ -1029,14 +1113,17 @@ public class PKListener implements Listener {
 					new AvatarState(player);
 				}
 			}
+		} catch (Exception e) {
+			GeneralMethods.logError(e, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onInventoryClick(InventoryClickEvent event) {
+		try {
 			if (event.isCancelled()) return;
 
-		for(Player p : MetalClips.instances.keySet())
+			for (Player p : MetalClips.instances.keySet()) {
-		{
 				if (MetalClips.instances.get(p).getTarget() != null)
 					if (MetalClips.instances.get(p).getTarget().getEntityId() == event.getWhoClicked().getEntityId())
 						event.setCancelled(true);
@@ -1045,10 +1132,14 @@ public class PKListener implements Listener {
 			if (event.getSlotType() == SlotType.ARMOR
 					&& !EarthArmor.canRemoveArmor((Player) event.getWhoClicked()))
 				event.setCancelled(true);
+		} catch (Exception e) {
+			GeneralMethods.logError(e, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onPlayerDeath(PlayerDeathEvent event) {
+		try {
 			if (EarthArmor.instances.containsKey(event.getEntity())) {
 				List<ItemStack> drops = event.getDrops();
 				List<ItemStack> newdrops = new ArrayList<ItemStack>();
@@ -1086,10 +1177,14 @@ public class PKListener implements Listener {
 				event.getDrops().addAll(newdrops);
 				
 			}
+		} catch (Exception e) {
+			GeneralMethods.logError(e, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) 
 	public void onPlayerToggleFlight(PlayerToggleFlightEvent event) {
+		try {
 			if (event.isCancelled()) return;
 
 			Player p = event.getPlayer();
@@ -1098,10 +1193,14 @@ public class PKListener implements Listener {
 					|| AvatarState.getPlayers().contains(p)) {
 				event.setCancelled(p.getGameMode() != GameMode.CREATIVE);
 			}
+		} catch (Exception e) {
+			GeneralMethods.logError(e, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onEntityCombust(EntityCombustEvent event) {
+		try {
 			if (event.isCancelled()) return;
 
 			Entity entity = event.getEntity();
@@ -1109,14 +1208,19 @@ public class PKListener implements Listener {
 			if (FireStream.ignitedblocks.containsKey(block) && entity instanceof LivingEntity) {
 				new Enflamed(entity, FireStream.ignitedblocks.get(block));
 			}
+		} catch (Exception e) {
+			GeneralMethods.logError(e, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onEntityDamageBlock(EntityDamageByBlockEvent event) {
 
 	}
+	
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onEntityDamageEvent(EntityDamageEvent event) {
+		try {
 			if (event.isCancelled()) return;
 
 			Entity entity = event.getEntity();
@@ -1139,10 +1243,14 @@ public class PKListener implements Listener {
 					}
 				}
 			}
+		} catch (Exception e) {
+			GeneralMethods.logError(e, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onBlockMeltEvent(BlockFadeEvent event) {
+		try {
 			if (event.isCancelled()) return;
 
 			Block block = event.getBlock();
@@ -1168,10 +1276,14 @@ public class PKListener implements Listener {
 			if (FireStream.ignitedblocks.containsKey(block)) {
 				FireStream.remove(block);
 			}
+		} catch (Exception e) {
+			GeneralMethods.logError(e, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onBlockBreak(BlockBreakEvent event) {
+		try {
 			if (event.isCancelled()) return;
 
 			Block block = event.getBlock();
@@ -1211,10 +1323,14 @@ public class PKListener implements Listener {
 			} else if (TempBlock.isTempBlock(block)) {
 				TempBlock.revertBlock(block, Material.AIR);
 			}
+		} catch (Exception e) {
+			GeneralMethods.logError(e, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onPlayerChat(AsyncPlayerChatEvent event) {
+		try {
 			if (event.isCancelled()) return;
 
 			if (!plugin.getConfig().getBoolean("Properties.Chat.Enable")) {
@@ -1242,11 +1358,14 @@ public class PKListener implements Listener {
 			format = format.replace("<message>", "%2$s");
 			format = format.replace("<name>", color + player.getDisplayName() + ChatColor.RESET);
 			event.setFormat(format);
-
+		} catch (IllegalFormatException | NullPointerException e) {
+			GeneralMethods.logError(e, false);
+		}
 	}
 	
 	@EventHandler
 	public void onEntitySuffocatedByTempBlocks(EntityDamageEvent event) {
+		try {
 			if(event.isCancelled()) return;
 			
 			if(event.getCause() == DamageCause.SUFFOCATION) {
@@ -1254,10 +1373,14 @@ public class PKListener implements Listener {
 					event.setCancelled(true);
 				}
 			}
+		} catch (Exception e) {
+			GeneralMethods.logError(e, false);
+		}
 	}
 
 	@EventHandler
 	public void onPlayerDamageByPlayer(EntityDamageByEntityEvent e) {
+		try {
 			if (e.isCancelled()) return;
 
 			Entity source = e.getDamager();
@@ -1328,10 +1451,14 @@ public class PKListener implements Listener {
 					}
 				}
 			}
+		} catch (Exception ex) {
+			GeneralMethods.logError(ex, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onPlayerDamage(EntityDamageEvent event) {
+		try {
 			if (event.isCancelled()) return;
 
 			if (event.getEntity() instanceof Player) {
@@ -1408,10 +1535,14 @@ public class PKListener implements Listener {
 					event.setCancelled(true);
 				}
 			}
+		} catch (Exception e) {
+			GeneralMethods.logError(e, false);
+		}
 	}
 
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onBlockPhysics(BlockPhysicsEvent event) {
+		try {
 			if (event.isCancelled()) return;
 
 			Block block = event.getBlock();
@@ -1421,9 +1552,14 @@ public class PKListener implements Listener {
 				event.setCancelled(Illumination.blocks.containsKey(block));
 			if (!event.isCancelled())
 				event.setCancelled(EarthMethods.tempnophysics.contains(block));
+		} catch (Exception e) {
+			GeneralMethods.logError(e, false);
 		}
+	}
+	
 	@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true)
 	public void onBlockForm(BlockFormEvent event) {
+		try {
 			if (event.isCancelled()) return;
 
 			if (TempBlock.isTempBlock(event.getBlock()))
@@ -1432,8 +1568,9 @@ public class PKListener implements Listener {
 				event.setCancelled(true);
 			if (!EarthPassive.canPhysicsChange(event.getBlock()))
 				event.setCancelled(true);
+		} catch (Exception e) {
+			GeneralMethods.logError(e, false);
+		}
 	}
 
-
-
 }