package mineplex.hub;

import java.util.HashMap;
import java.util.HashSet;

import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.GameMode;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.Sound;
import org.bukkit.craftbukkit.v1_7_R3.CraftWorld;
import org.bukkit.entity.Egg;
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.block.Action;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.event.entity.ItemSpawnEvent;
import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.player.AsyncPlayerChatEvent;
import org.bukkit.event.player.PlayerCommandPreprocessEvent;
import org.bukkit.event.player.PlayerDropItemEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerLoginEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.event.player.PlayerRespawnEvent;
import org.bukkit.event.server.ServerListPingEvent;
import org.bukkit.event.world.ChunkLoadEvent;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scoreboard.DisplaySlot;
import org.bukkit.scoreboard.Objective;
import org.bukkit.scoreboard.Scoreboard;

import mineplex.core.MiniClientPlugin;
import mineplex.core.account.CoreClient;
import mineplex.core.account.CoreClientManager;
import mineplex.core.blockrestore.BlockRestore;
import mineplex.core.common.Rank;
import mineplex.core.common.util.C;
import mineplex.core.common.util.F;
import mineplex.core.common.util.UtilAction;
import mineplex.core.common.util.UtilAlg;
import mineplex.core.common.util.UtilInv;
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.UtilWorld;
import mineplex.core.common.util.UtilParticle.ParticleType;
import mineplex.core.disguise.DisguiseManager;
import mineplex.core.disguise.disguises.DisguisePlayer;
import mineplex.core.disguise.disguises.DisguiseSlime;
import mineplex.core.donation.DonationManager;
import mineplex.core.itemstack.ItemStackFactory;
import mineplex.core.logger.Logger;
import mineplex.core.portal.Portal;
import mineplex.core.recharge.Recharge;
import mineplex.core.stats.StatsManager;
import mineplex.core.task.TaskManager;
import mineplex.core.updater.UpdateType;
import mineplex.core.updater.event.UpdateEvent;
import mineplex.hub.commands.ForcefieldToggle;
import mineplex.hub.commands.GadgetToggle;
import mineplex.hub.gadget.GadgetManager;
import mineplex.hub.modules.*;
import mineplex.hub.mount.MountManager;
import mineplex.hub.party.Party;
import mineplex.hub.party.PartyManager;
import mineplex.hub.tutorial.TutorialManager;
import mineplex.minecraft.game.classcombat.Skill.event.SkillTriggerEvent;
import mineplex.minecraft.game.classcombat.item.event.ItemTriggerEvent;
import mineplex.minecraft.game.core.condition.ConditionManager;

public class HubManager extends MiniClientPlugin<HubClient>
{
	public String Mode = "Normal";
	
	private BlockRestore _blockRestore;
	private CoreClientManager _clientManager; 
	private ConditionManager _conditionManager;
	private DonationManager _donationManager;
	private DisguiseManager _disguiseManager;
	private PartyManager _partyManager;
	private Portal _portal;
	private StatsManager _statsManager;
	private GadgetManager _gadgetManager;
	private MountManager _mountManager;
	private VisibilityManager _visibilityManager;
	private TutorialManager _tutorialManager;
	private TextManager _textCreator;
	private ParkourManager _parkour;

	private Location _spawn;
	private int _scoreboardTick = 0;
	
	private HashMap<Player, Scoreboard> _scoreboards = new HashMap<Player, Scoreboard>();

	private String _pigStacker = "0 - Nobody";
	
	private boolean _shuttingDown;

	private HashMap<String, Long> _portalTime = new HashMap<String, Long>();
	
	private int _slot = 7;
	private HashSet<Player> _disabled = new HashSet<Player>();
	
	//Admin
	private boolean _gadgetsEnabled = true;
	private HashSet<Player> _forcefield = new HashSet<Player>();

	public HubManager(JavaPlugin plugin, BlockRestore blockRestore, CoreClientManager clientManager, DonationManager donationManager, ConditionManager conditionManager, DisguiseManager disguiseManager, TaskManager taskManager, Portal portal, PartyManager partyManager) 
	{
		super("Hub Manager", plugin);

		_blockRestore = blockRestore;
		_clientManager = clientManager;
		_conditionManager = conditionManager;
		_donationManager = donationManager; 
		_disguiseManager = disguiseManager;

		_portal = portal;

		_spawn = new Location(UtilWorld.getWorld("world"), 0.5, 74, 0.5);

		_textCreator = new TextManager(this);
		_parkour = new ParkourManager(this, donationManager, taskManager);

		new MapManager(this);
		new WorldManager(this);
		new JumpManager(this);
		new NewsManager(this);
		
		_mountManager = new MountManager(this);
		_gadgetManager = new GadgetManager(this, _mountManager);

		_partyManager = partyManager;
		_tutorialManager = new TutorialManager(this, donationManager, taskManager, _textCreator);
		_visibilityManager = new VisibilityManager(this);
		
		_statsManager = new StatsManager(plugin);

		((CraftWorld)Bukkit.getWorlds().get(0)).getHandle().pvpMode = true;
	}
	
	@Override
	public void AddCommands() 
	{
		AddCommand(new GadgetToggle(this));
		AddCommand(new ForcefieldToggle(this));
	}
	
	@EventHandler(priority = EventPriority.HIGHEST)
	public void reflectMotd(ServerListPingEvent event)
	{
		if (_shuttingDown)
		{
			event.setMotd("Restarting soon");
		}
	}

	@EventHandler
	public void BumpJoin(PlayerJoinEvent event)
	{
		event.getPlayer().getInventory().setItem(_slot, ItemStackFactory.Instance.CreateStack(Material.SLIME_BALL, (byte)0, 1, 
				C.cYellow + "Stacker" + C.cWhite + " - " + C.cGreen + "Enabled"));
	}
	
	@EventHandler
	public void BumpQuit(PlayerQuitEvent event)
	{
		_disabled.remove(event.getPlayer());
	}
	
	public boolean BumpDisabled(Entity ent)
	{
		if (ent == null)
			return false;
		
		return _disabled.contains(ent);
	}
	
	@EventHandler
	public void BumpToggle(PlayerInteractEvent event)
	{
		if (event.getAction() == Action.PHYSICAL)
			return;
		
		Player player = event.getPlayer();
		
		if (player.getInventory().getHeldItemSlot() != _slot)
			return;
		
		event.setCancelled(true);
		
		if (_disabled.remove(player))
		{
			UtilPlayer.message(player, F.main("Hub Games", "You are back in the Hub Games!"));
			
			player.getInventory().setItem(_slot, ItemStackFactory.Instance.CreateStack(Material.SLIME_BALL, (byte)0, 1, 
					C.cYellow + "Stacker" + C.cWhite + " - " + C.cGreen + "Enabled"));
		}
		else
		{
			_disabled.add(player);
			UtilPlayer.message(player, F.main("Hub Games", "You are no longer partaking in Hub Games."));
			
			player.getInventory().setItem(_slot, ItemStackFactory.Instance.CreateStack(Material.MAGMA_CREAM, (byte)0, 1, 
					C.cYellow + "Stacker" + C.cWhite + " - " + C.cRed + "Disabled"));
		}
	}
	
	@EventHandler
	public void orderThatItem(final PlayerDropItemEvent event)
	{
		if (event.getItemDrop().getItemStack().getType() == Material.REDSTONE_TORCH_OFF || event.getItemDrop().getItemStack().getType() == Material.REDSTONE_TORCH_ON)
		{
			Bukkit.getScheduler().scheduleSyncDelayedTask(GetPlugin(), new Runnable()
			{
				public void run()
				{
					if (event.getPlayer().isOnline())
					{
						event.getPlayer().getInventory().remove(event.getItemDrop().getItemStack().getType());
						event.getPlayer().getInventory().setItem(_slot, ItemStackFactory.Instance.CreateStack(event.getItemDrop().getItemStack().getType(), (byte)0, 1, ChatColor.RESET + C.cYellow + "Stacker" + C.cWhite + (_disabled.contains(event.getPlayer()) ? C.cWhite + " - " + C.cRed + "Disabled" : " - " + C.cGreen  + "Enabled")));
						event.getPlayer().updateInventory();
					}
				}
			});
		}
	}
	
	@EventHandler
	public void redirectStopCommand(PlayerCommandPreprocessEvent event)
	{
		if (event.getPlayer().isOp() && event.getMessage().equalsIgnoreCase("/stop"))
		{
			_shuttingDown = true;
			
			Bukkit.getServer().getScheduler().scheduleSyncDelayedTask(_plugin, new Runnable()
			{
				public void run()
				{
					_portal.SendAllPlayers("Lobby");
					
					Bukkit.getServer().getScheduler().scheduleSyncDelayedTask(_plugin, new Runnable()
					{
						public void run()
						{
							Bukkit.shutdown();
						}
					}, 40L);
				}
			}, 60L);
			
			event.setCancelled(true);
		}
	}
	
	@EventHandler
	public void preventEggSpawn(ItemSpawnEvent event)
	{
		if (event.getEntity() instanceof Egg)
		{
			event.setCancelled(true);
		}
	}

	@EventHandler
	public void PlayerRespawn(PlayerRespawnEvent event)
	{
		event.setRespawnLocation(GetSpawn());
	}

	@EventHandler(priority = EventPriority.MONITOR)
	public void OnChunkLoad(ChunkLoadEvent event)
	{
		for (Entity entity : event.getChunk().getEntities())
		{
			if (entity instanceof LivingEntity)
			{
				if (((LivingEntity)entity).isCustomNameVisible() && ((LivingEntity)entity).getCustomName() != null)
				{
					if (ChatColor.stripColor(((LivingEntity)entity).getCustomName()).equalsIgnoreCase("Minekart"))
					{
						_disguiseManager.disguise(new DisguisePlayer(entity, ChatColor.YELLOW + "MineKart"));
					}
					else if (ChatColor.stripColor(((LivingEntity)entity).getCustomName()).equalsIgnoreCase("Block Hunt"))
					{
						DisguiseSlime disguise = new DisguiseSlime(entity);
						disguise.SetCustomNameVisible(true);
						disguise.SetName(((LivingEntity)entity).getCustomName());
						disguise.SetSize(2);
						_disguiseManager.disguise(disguise);
					}
				}
			}
		}
	}
	
	@EventHandler(priority = EventPriority.LOW)
	public void login(final PlayerLoginEvent event)
	{
        CoreClient client = _clientManager.Get(event.getPlayer().getName());
		
        // Reserved Slot Check
		if (Bukkit.getOnlinePlayers().length >= Bukkit.getServer().getMaxPlayers())
		{
			if (!client.GetRank().Has(Rank.ULTRA))
			{
				Bukkit.getScheduler().scheduleSyncDelayedTask(GetPlugin(), new Runnable()
				{
					public void run()
					{
						_portal.SendPlayerToServer(event.getPlayer(), "Lobby");
					}
				});

				event.allow();
			}
		}
	}

	@EventHandler(priority = EventPriority.LOW)
	public void PlayerJoin(PlayerJoinEvent event)
	{
		try
		{
			final Player player = event.getPlayer();
	
			//Survival
			player.setGameMode(GameMode.SURVIVAL);
	
			//Public Message
			event.setJoinMessage(null);
	
			//Teleport
			player.teleport(GetSpawn());
	
			//Allow Double Jump
			player.setAllowFlight(true);
	
			UtilInv.Clear(player);
	
			//Scoreboard
			Scoreboard board = Bukkit.getScoreboardManager().getNewScoreboard();
			player.setScoreboard(board);
			_scoreboards.put(player, board);
	
			//Objective
			Objective obj = board.registerNewObjective(C.Bold + "Player Data", "dummy");
			obj.setDisplaySlot(DisplaySlot.SIDEBAR);
	
			
			for (Rank rank : Rank.values())
			{
				if (rank != Rank.ALL)
					board.registerNewTeam(rank.Name).setPrefix(rank.GetTag(true, true) + ChatColor.RESET + " ");
				else
					board.registerNewTeam(rank.Name).setPrefix("");
			}
	
			for (Player otherPlayer : Bukkit.getOnlinePlayers())
			{
				if (_clientManager.Get(otherPlayer) == null)
					continue;
				
				String rankName = _clientManager.Get(player).GetRank().Name;
				String otherRankName = _clientManager.Get(otherPlayer).GetRank().Name;
				
				if (!_clientManager.Get(player).GetRank().Has(Rank.ULTRA) && _donationManager.Get(player.getName()).OwnsUltraPackage())
				{
					rankName = Rank.ULTRA.Name;
				}
				
				if (!_clientManager.Get(otherPlayer).GetRank().Has(Rank.ULTRA) && _donationManager.Get(otherPlayer.getName()).OwnsUltraPackage())
				{
					otherRankName = Rank.ULTRA.Name;
				}
				
				//Add Other to Self
				board.getTeam(otherRankName).addPlayer(otherPlayer);
	
				//Add Self to Other
				otherPlayer.getScoreboard().getTeam(rankName).addPlayer(player);
			}
			
		}
		catch (Exception ex)
		{
			Logger.Instance.log(ex);
			System.out.println("[HubManager] Player Join exception");
			throw ex;
		}
	}
	
	/* XXX TOURNEY
	@EventHandler(priority = EventPriority.HIGHEST)
	public void TournamentWins(PlayerJoinEvent event)
	{
		for (Player player : Bukkit.getOnlinePlayers())
		{
			Scoreboard board = player.getScoreboard();
			if (board == null)
				continue;
			
			Objective obj = board.getObjective(DisplaySlot.BELOW_NAME);
			if (obj == null)
			{
				obj = board.registerNewObjective("SG Tourney Kills", "dummy");
				obj.setDisplaySlot(DisplaySlot.BELOW_NAME);
			}
			
			obj.getScore(event.getPlayer()).setScore(GetStats().getStat(event.getPlayer(), "Pvp", "Kills"));
		}		
		
		if (event.getPlayer().getScoreboard() != null)
		{
			Scoreboard board = event.getPlayer().getScoreboard();
			
			Objective obj = board.getObjective(DisplaySlot.BELOW_NAME);
			if (obj == null)
			{
				obj = board.registerNewObjective("SG Tournament Kills", "dummy");
				obj.setDisplaySlot(DisplaySlot.BELOW_NAME);
			}
			
			for (Player player : Bukkit.getOnlinePlayers())
			{
				if (player.equals(event.getPlayer()))
					continue;
				
				obj.getScore(player).setScore(GetStats().getStat(player, "Pvp", "Kills"));
			}
		}
	}
	*/

	@EventHandler
	public void PlayerQuit(PlayerQuitEvent event)
	{
		event.setQuitMessage(null);

		event.getPlayer().leaveVehicle();
		event.getPlayer().eject();

		for (Player player : UtilServer.getPlayers())
			player.getScoreboard().resetScores(event.getPlayer().getName());
		
		_scoreboards.remove(event.getPlayer());
		
		_portalTime.remove(event.getPlayer().getName());
	}

	@EventHandler
	public void PlayerChat(AsyncPlayerChatEvent event)
	{
		if (event.isCancelled())
			return;

		Player player = event.getPlayer();

		Rank rank = GetClients().Get(player).GetRank();

		boolean ownsUltra = _donationManager.Get(player.getName()).OwnsUltraPackage();

		//Rank Prefix
		String rankStr = "";
		if  (rank != Rank.ALL)
			rankStr = rank.GetTag(true, true) + " ";

		if (ownsUltra && !rank.Has(Rank.ULTRA))
			rankStr = Rank.ULTRA.GetTag(true, true) + " ";

		//Party Chat
		if (event.getMessage().charAt(0) == '@')
		{
			Party party = _partyManager.GetParty(player);
			if (party != null)
			{
				event.getRecipients().clear();

				event.setMessage(event.getMessage().substring(1, event.getMessage().length()));
				event.setFormat(C.cDPurple + C.Bold + "Party " + C.cWhite + C.Bold + "%1$s " + C.cPurple + "%2$s");
				
				for (String name : party.GetPlayers())
				{
					Player other = UtilPlayer.searchExact(name);
					
					if (other != null)
						event.getRecipients().add(other);						
				}
			}
			else
			{
				UtilPlayer.message(player, F.main("Party", "You are not in a Party."));
				event.setCancelled(true);
			}
			
			return;
		}
		else
		{
			for (Player other : UtilServer.getPlayers())
			{
				if (_tutorialManager.InTutorial(other))
				{
					event.getRecipients().remove(other);
					continue;
				}
	
				event.setMessage(event.getMessage());
				event.setFormat(rankStr + C.cYellow + "%1$s " + C.cWhite + "%2$s");
			}
		}
	}

	@EventHandler
	public void Damage(EntityDamageEvent event)
	{
		if (event.getCause() == DamageCause.VOID)
			if (event.getEntity() instanceof Player)
			{
				event.getEntity().eject();
				event.getEntity().leaveVehicle();
				event.getEntity().teleport(GetSpawn());
			}
				
			else
				event.getEntity().remove();

		event.setCancelled(true);
	}


	@EventHandler
	public void FoodHealthUpdate(UpdateEvent event)
	{
		if (event.getType() != UpdateType.SLOW)
			return;

		for (Player player : UtilServer.getPlayers())
		{
			player.setHealth(20);
			player.setFoodLevel(20);
		}
	}

	@EventHandler
	public void InventoryCancel(InventoryClickEvent event)
	{
		if (event.getWhoClicked() instanceof Player && ((Player)event.getWhoClicked()).getGameMode() != GameMode.CREATIVE)
			event.setCancelled(true);
	}

	@EventHandler
	public void UpdateScoreboard(UpdateEvent event)
	{
		if (event.getType() != UpdateType.TICK)
			return;

		_scoreboardTick = (_scoreboardTick + 1)%3;

		if (_scoreboardTick != 0)
			return;

		int bestPig = 0;
		for (Player player : UtilServer.getPlayers())
		{
			if (player.getVehicle() != null)
				continue;

			int count = 0;

			Entity ent = player;
			while (ent.getPassenger() != null)
			{
				ent = ent.getPassenger();
				count++;
			}

			if (count > bestPig)
			{
				_pigStacker = player.getName();
				bestPig = count;
			}
		}
		if (bestPig == 0)
		{
			_pigStacker = "0 - Nobody";
		}
		else
		{
			_pigStacker = bestPig + " - " + _pigStacker;

			if (_pigStacker.length() > 16)
				_pigStacker = _pigStacker.substring(0, 16);
		}

		for (Player player : UtilServer.getPlayers())
		{
			//Dont Waste Time
			if (_partyManager.GetParty(player) != null)
				continue;
			
			//Return to Main Scoreboard
			if (!player.getScoreboard().equals(_scoreboards.get(player)))
				player.setScoreboard(_scoreboards.get(player));
			
			//Objective
			Objective obj = player.getScoreboard().getObjective(DisplaySlot.SIDEBAR);

			//Title
			obj.setDisplayName(C.cWhite + C.Bold + Get(player).GetScoreboardText());

			int line = 15;

			obj.getScore(C.cGreen + C.Bold +  "Gems").setScore(line--);

			// Remove Old
			player.getScoreboard().resetScores(Get(player.getName()).GetLastGemCount() + "");
			// Add New			
			obj.getScore(GetDonation().Get(player.getName()).GetGems() + "").setScore(line--);

			Get(player.getName()).SetLastGemCount(GetDonation().Get(player.getName()).GetGems());

			//Space
			obj.getScore(" ").setScore(line--);

			/*
			//News
			obj.getScore(C.cGray + C.Bold + "Latest News")).setScore(line--);	
			player.getScoreboard().resetScores(Get(player).GetNewsText(false)));
			obj.getScore(Get(player).GetNewsText(true))).setScore(line--);
			 */

			//Stacker
			obj.getScore(C.cGray + C.Bold + "Stacker").setScore(line--);
			player.getScoreboard().resetScores(Get(player).BestPig);
			Get(player).BestPig = _pigStacker;
			obj.getScore(Get(player).BestPig).setScore(line--);

			//Space
			obj.getScore("  ").setScore(line--);

			//Display Rank
			if (GetClients().Get(player).GetRank().Has(Rank.HERO))
			{
				obj.getScore(C.cPurple + C.Bold + "Hero Rank").setScore(line--);

				player.getScoreboard().resetScores(Get(player).GetUltraText(false));
				obj.getScore(Get(player).GetUltraText(true)).setScore(line--);
			}
			else if (GetClients().Get(player).GetRank().Has(Rank.ULTRA))
			{
				obj.getScore(C.cAqua + C.Bold + "Ultra Rank").setScore(line--);

				player.getScoreboard().resetScores(Get(player).GetUltraText(false));
				obj.getScore(Get(player).GetUltraText(true)).setScore(line--);
			}
			else
			{
				obj.getScore(C.cRed + C.Bold + "No Rank").setScore(line--);

				player.getScoreboard().resetScores(Get(player).GetPurchaseText(false));
				obj.getScore(Get(player).GetPurchaseText(true)).setScore(line--);
			}

			//Space
			obj.getScore("   ").setScore(line--);

			//Display Staff
			obj.getScore(C.cGold + C.Bold + "Online Staff").setScore(line--);
			String staff = "";
			for (Player other : UtilServer.getPlayers())
			{
				Rank rank = GetClients().Get(other).GetRank();

				if (!rank.Has(Rank.HELPER))
					continue;

				staff += other.getName() + "   ";
			}
			if (staff.length() == 0)
				staff = "None";

			player.getScoreboard().resetScores(Get(player).GetStaffText(false));
			Get(player).StaffString = staff;
			obj.getScore(Get(player).GetStaffText(true)).setScore(line--);

			//Space
			obj.getScore("    ").setScore(line--);

			//Website
			obj.getScore(C.cYellow + C.Bold + "Website").setScore(line--);
			obj.getScore("www.mineplex.com").setScore(line--);
			obj.getScore("----------------").setScore(line--);

		}
	}

	@Override
	protected HubClient AddPlayer(String player) 
	{ 
		return new HubClient(player);
	}
	
	public BlockRestore GetBlockRestore()
	{
		return _blockRestore;
	}

	public CoreClientManager GetClients()
	{
		return _clientManager;
	}
	
	public ConditionManager GetCondition()
	{
		return _conditionManager;
	}

	public DonationManager GetDonation()
	{
		return _donationManager;
	}
	
	public DisguiseManager GetDisguise()
	{
		return _disguiseManager;
	}
	
	public GadgetManager GetGadget()
	{
		return _gadgetManager;
	}
	
	public MountManager GetMount()
	{
		return _mountManager;
	}
	
	public ParkourManager GetParkour()
	{
		return _parkour;
	}

	public Location GetSpawn()
	{
		return _spawn.clone();
	}

	public TutorialManager GetTutorial() 
	{
		return _tutorialManager;
	}
	
	public StatsManager GetStats()
	{
		return _statsManager;
	}

	public VisibilityManager GetVisibility() 
	{
		return _visibilityManager;
	}

	public void SetPortalDelay(Entity ent)
	{
		if (ent instanceof Player)
			_portalTime.put(((Player)ent).getName(), System.currentTimeMillis());
	}

	public boolean CanPortal(Player player)
	{
		//Riding
		if (player.getVehicle() != null || player.getPassenger() != null)
			return false;

		//Portal Delay
		if (!_portalTime.containsKey(player.getName()))
			return true;

		return UtilTime.elapsed(_portalTime.get(player.getName()), 5000);
	}
	
	public boolean CanBump(LivingEntity ent)
	{
		if (!(ent instanceof Player))
			return true;
		
		if (BumpDisabled(ent))
			return false;
		
		if (GetVisibility().IsHiding(ent))
			return false;
		
		return true;
	}
	
	@EventHandler
	public void HeartDisplay(UpdateEvent event)
	{
		if (event.getType() != UpdateType.FASTER)
			return;
		
		for (Player player : UtilServer.getPlayers())
		{
			if (!player.isOp())
				continue;
			
			for (Player other : UtilServer.getPlayers())
			{
				if (player.getName().equalsIgnoreCase("Chiss"))
					UtilParticle.PlayParticle(other, ParticleType.HEART, player.getLocation().add(0, 1, 0), 0.25f, 0.5f, 0.25f, 0, 1);
				
				else if (player.getName().equalsIgnoreCase("defek7"))
					UtilParticle.PlayParticle(other, ParticleType.FIREWORKS_SPARK, player.getLocation().add(0, 1, 0), 0.25f, 0.5f, 0.25f, 0, 2);
				
				else if (player.getName().equalsIgnoreCase("Spu_"))
					UtilParticle.PlayParticle(other, ParticleType.FLAME, player.getLocation().add(0, 1, 0), 0.25f, 0.5f, 0.25f, 0, 2);
				
				else if (player.getName().equalsIgnoreCase("sterling_"))
					UtilParticle.PlayParticle(other, ParticleType.WITCH_MAGIC, player.getLocation().add(0, 1, 0), 0.25f, 0.5f, 0.25f, 0, 2);
			}
		}
	}
	
	@EventHandler
	public void SkillTrigger(SkillTriggerEvent event)
	{
		event.SetCancelled(true);
	}
	
	@EventHandler
	public void ItemTrigger(ItemTriggerEvent event)
	{
		event.SetCancelled(true);
	}
	
	public boolean IsGadgetEnabled()
	{
		return _gadgetsEnabled;
	}

	public void SetGadgetEnabled(boolean _enabled)
	{
		this._gadgetsEnabled = _enabled;
	}

	public boolean ToggleForcefield(Player caller)
	{
		if (_forcefield.add(caller))
			return true;
		
		_forcefield.remove(caller);
		return false;
	}
	
	@EventHandler
	public void ForcefieldUpdate(UpdateEvent event)
	{
		if (event.getType() != UpdateType.FAST)
			return;
		
		for (Player player : _forcefield)
		{
			for (Player other : UtilServer.getPlayers())
			{
				if (player.equals(other))
					continue;
				
				if (UtilMath.offset(other, player) > 5)
					continue;
				
				if (GetClients().Get(other).GetRank().Has(Rank.ADMIN))
					continue;
				
				if (Recharge.Instance.use(other, "Forcefield Bump", 500, false, false))
				{
					UtilAction.velocity(other, UtilAlg.getTrajectory2d(player, other), 1.6, true, 0.8, 0, 10, true);
					other.getWorld().playSound(other.getLocation(), Sound.CHICKEN_EGG_POP, 2f, 0.5f);
				}
			}
		}
	}
}