Mineplex2018-withcommit/Plugins/Nautilus.Game.Arcade/src/nautilus/game/arcade/ArcadeManager.java

package nautilus.game.arcade;

import java.io.File;
import java.util.ArrayList;
import java.util.HashSet;

import nautilus.game.arcade.addons.*;
import nautilus.game.arcade.command.*;
import nautilus.game.arcade.events.GameStateChangeEvent;
import nautilus.game.arcade.game.Game;
import nautilus.game.arcade.game.Game.GameState;
import nautilus.game.arcade.game.GameServerConfig;
import nautilus.game.arcade.game.GameTeam;
import nautilus.game.arcade.managers.*;
import nautilus.game.arcade.shop.ArcadeShop;
import nautilus.game.arcade.world.FireworkHandler;

import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.GameMode;
import org.bukkit.Material;
import org.bukkit.OfflinePlayer;
import org.bukkit.craftbukkit.v1_7_R3.entity.CraftEntity;
import org.bukkit.craftbukkit.v1_7_R3.entity.CraftPlayer;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.block.BlockBurnEvent;
import org.bukkit.event.block.BlockFadeEvent;
import org.bukkit.event.block.BlockSpreadEvent;
import org.bukkit.event.block.LeavesDecayEvent;
import org.bukkit.event.entity.CreatureSpawnEvent;
import org.bukkit.event.player.PlayerCommandPreprocessEvent;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerLoginEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.event.player.PlayerTeleportEvent;
import org.bukkit.event.server.ServerListPingEvent;

import mineplex.minecraft.game.classcombat.Class.ClassManager;
import mineplex.minecraft.game.classcombat.Condition.SkillConditionManager;
import mineplex.minecraft.game.classcombat.Skill.SkillFactory;
import mineplex.minecraft.game.classcombat.Skill.event.SkillTriggerEvent;
import mineplex.minecraft.game.classcombat.item.ItemFactory;
import mineplex.minecraft.game.classcombat.item.event.ItemTriggerEvent;
import mineplex.minecraft.game.classcombat.shop.ClassCombatShop;
import mineplex.minecraft.game.classcombat.shop.ClassShopManager;
import mineplex.minecraft.game.core.IRelation;
import mineplex.minecraft.game.core.condition.ConditionManager;
import mineplex.minecraft.game.core.condition.Condition.ConditionType;
import mineplex.minecraft.game.core.damage.DamageManager;
import mineplex.minecraft.game.core.fire.Fire;
import mineplex.core.MiniPlugin;
import mineplex.core.itemstack.ItemStackFactory;
import mineplex.core.account.CoreClientManager;
import mineplex.core.achievement.AchievementManager;
import mineplex.core.antihack.AntiHack;
import mineplex.core.antistack.AntiStack;
import mineplex.core.blockrestore.BlockRestore;
import mineplex.core.blood.Blood;
import mineplex.core.chat.Chat;
import mineplex.core.common.Rank;
import mineplex.core.common.util.*;
import mineplex.core.creature.Creature;
import mineplex.core.disguise.DisguiseManager;
import mineplex.core.donation.DonationManager;
import mineplex.core.movement.Movement;
import mineplex.core.packethandler.PacketHandler;
import mineplex.core.elo.EloManager;
import mineplex.core.energy.Energy;
import mineplex.core.explosion.Explosion;
import mineplex.core.portal.Portal;
import mineplex.core.preferences.PreferencesManager;
import mineplex.core.projectile.ProjectileManager;
import mineplex.core.stats.StatsManager;
import mineplex.core.status.ServerStatusManager;
import mineplex.core.teleport.Teleport;
import mineplex.core.timing.TimingManager;

public class ArcadeManager extends MiniPlugin implements IRelation
{
	// Modules
	private AntiStack _antistack;
	private BlockRestore _blockRestore;
	private Blood _blood;
	private Chat _chat;
	private CoreClientManager _clientManager;
	private DisguiseManager _disguiseManager;
	private DonationManager _donationManager;
	private ConditionManager _conditionManager;
	private Creature _creature;
	private DamageManager _damageManager;
	private Explosion _explosionManager;
	private Fire _fire;
	private FireworkHandler _firework;
	private ProjectileManager _projectileManager;

	private Portal _portal;
	private ArcadeShop _arcadeShop;

	// Managers
	private GameFactory _gameFactory;
	private GameCreationManager _gameCreationManager;
	private GameGemManager _gameGemManager;
	private GameManager _gameManager;
	private GameLobbyManager _gameLobbyManager;
	private GameWorldManager _gameWorldManager;
	private ServerStatusManager _serverStatusManager;

	private AchievementManager _achievementManager;
	private StatsManager _statsManager;
	private ClassManager _classManager;
	private SkillFactory _skillFactory;
	private ClassShopManager _classShopManager;
	private ClassCombatShop _classShop;

	private EloManager _eloManager;

	private MiscManager _miscManager;

	// Observers
	private HashSet<Player> _specList = new HashSet<Player>();

	// Server Games
	private GameServerConfig _serverConfig;

	// Games
	private Game _game;

	public ArcadeManager(Arcade plugin, ServerStatusManager serverStatusManager, GameServerConfig serverConfig,
			CoreClientManager clientManager, DonationManager donationManager, DamageManager damageManager,
			DisguiseManager disguiseManager, Creature creature, Teleport teleport, Blood blood, AntiStack antistack,
			Portal portal, PacketHandler packetHandler, PreferencesManager preferences, String webAddress)
	{
		super("Game Manager", plugin);

		_serverConfig = serverConfig;
		if (serverConfig.Tournament)
		{
			AntiHack.Instance.SetEnabled(false);
			Bukkit.getServer().setWhitelist(true);
		}

		// Modules
		_antistack = antistack;

		_blockRestore = new BlockRestore(plugin);

		_blood = blood;

		_explosionManager = new Explosion(plugin, _blockRestore);
		_explosionManager.SetDebris(false);

		if (serverConfig.GameList.contains(GameType.ChampionsDominate)
				|| serverConfig.GameList.contains(GameType.ChampionsTDM)
				|| serverConfig.GameList.contains(GameType.ChampionsMOBA))
		{
			_conditionManager = new SkillConditionManager(plugin);
		}
		else
		{
			_conditionManager = new ConditionManager(plugin);
		}

		_clientManager = clientManager;
		_serverStatusManager = serverStatusManager;
		_chat = new Chat(plugin, _clientManager, preferences, _serverStatusManager.getCurrentServerName());

		_creature = creature;

		_damageManager = damageManager;
		_damageManager.UseSimpleWeaponDamage = true;

		_disguiseManager = disguiseManager;

		_donationManager = donationManager;

		_firework = new FireworkHandler();
		_fire = new Fire(plugin, _conditionManager, damageManager);

		_projectileManager = new ProjectileManager(plugin);

		if (serverConfig.GameList.contains(GameType.ChampionsDominate)
				|| serverConfig.GameList.contains(GameType.ChampionsTDM)
				|| serverConfig.GameList.contains(GameType.ChampionsMOBA))
		{
			Energy energy = new Energy(plugin);
			ItemFactory itemFactory = new ItemFactory(_plugin, _blockRestore, _conditionManager, damageManager, energy,
					_fire, _projectileManager, webAddress);
			_skillFactory = new SkillFactory(plugin, damageManager, this, _damageManager.GetCombatManager(),
					_conditionManager, _projectileManager, _blockRestore, _fire, new Movement(plugin), teleport,
					energy, webAddress);
			_classManager = new ClassManager(plugin, clientManager, donationManager, _skillFactory, itemFactory,
					webAddress);

			_classShopManager = new ClassShopManager(_plugin, _classManager, _skillFactory, itemFactory);
			_classShop = new ClassCombatShop(_classShopManager, clientManager, donationManager, webAddress);

			_eloManager = new EloManager(_plugin);
		}

		_statsManager = new StatsManager(plugin);
		_achievementManager = new AchievementManager(_statsManager);

		_portal = portal;

		// Shop
		_arcadeShop = new ArcadeShop(this, clientManager, donationManager);

		// Game Factory
		_gameFactory = new GameFactory(this);

		// Managers
		new GameChatManager(this);
		_gameCreationManager = new GameCreationManager(this);
		_gameGemManager = new GameGemManager(this);
		_gameManager = new GameManager(this);
		_gameLobbyManager = new GameLobbyManager(this, packetHandler);
		new GameFlagManager(this);
		new GamePlayerManager(this);
		_gameWorldManager = new GameWorldManager(this);
		_miscManager = new MiscManager(this);
		new IdleManager(this);

		// Game Addons
		new CompassAddon(plugin, this);
		new SoupAddon(plugin, this);
		new TeamArmorAddon(plugin, this);
	}

	@Override
	public void AddCommands()
	{
		AddCommand(new GameCommand(this));
		AddCommand(new WriteCommand(this));
	}

	public GameServerConfig GetServerConfig()
	{
		return _serverConfig;
	}

	public ArrayList<GameType> GetGameList()
	{
		return GetServerConfig().GameList;
	}
	
	public AchievementManager GetAchievement()
	{
		return _achievementManager;
	}

	public AntiStack GetAntiStack()
	{
		return _antistack;
	}

	public Blood GetBlood()
	{
		return _blood;
	}

	public Chat GetChat()
	{
		return _chat;
	}

	public BlockRestore GetBlockRestore()
	{
		return _blockRestore;
	}

	public CoreClientManager GetClients()
	{
		return _clientManager;
	}

	public ConditionManager GetCondition()
	{
		return _conditionManager;
	}

	public Creature GetCreature()
	{
		return _creature;
	}

	public DisguiseManager GetDisguise()
	{
		return _disguiseManager;
	}

	public DamageManager GetDamage()
	{
		return _damageManager;
	}

	public DonationManager GetDonation()
	{
		return _donationManager;
	}

	public EloManager getEloManager()
	{
		return _eloManager;
	}

	public Explosion GetExplosion()
	{
		return _explosionManager;
	}

	public Fire GetFire()
	{
		return _fire;
	}

	public FireworkHandler GetFirework()
	{
		return _firework;
	}

	public ProjectileManager GetProjectile()
	{
		return _projectileManager;
	}

	public Portal GetPortal()
	{
		return _portal;
	}

	public GameLobbyManager GetLobby()
	{
		return _gameLobbyManager;
	}

	public ArcadeShop GetShop()
	{
		return _arcadeShop;
	}

	public GameCreationManager GetGameCreationManager()
	{
		return _gameCreationManager;
	}

	public GameFactory GetGameFactory()
	{
		return _gameFactory;
	}

	public GameManager GetGameManager()
	{
		return _gameManager;
	}

	public GameGemManager GetGameGemManager()
	{
		return _gameGemManager;
	}

	public GameWorldManager GetGameWorldManager()
	{
		return _gameWorldManager;
	}

	public StatsManager GetStatsManager()
	{
		return _statsManager;
	}
	
	public ServerStatusManager GetServerStatusManager()
	{
		return _serverStatusManager;
	}

	public ChatColor GetColor(Player player)
	{
		if (_game == null)
			return ChatColor.GRAY;

		GameTeam team = _game.GetTeam(player);
		if (team == null)
			return ChatColor.GRAY;

		return team.GetColor();
	}

	@Override
	public boolean CanHurt(String a, String b)
	{
		return CanHurt(UtilPlayer.searchExact(a), UtilPlayer.searchExact(b));
	}

	public boolean CanHurt(Player pA, Player pB)
	{
		if (pA == null || pB == null)
			return false;

		if (!_game.Damage)
			return false;

		if (!_game.DamagePvP)
			return false;

		// Self Damage
		if (pA.equals(pB))
			return _game.DamageSelf;

		GameTeam tA = _game.GetTeam(pA);
		if (tA == null)
			return false;

		GameTeam tB = _game.GetTeam(pB);
		if (tB == null)
			return false;

		if (tA.equals(tB) && !_game.DamageTeamSelf)
			return false;

		if (!tA.equals(tB) && !_game.DamageTeamOther)
			return false;

		return true;
	}

	@Override
	public boolean IsSafe(Player player)
	{
		if (_game == null)
			return true;

		if (_game.IsPlaying(player))
			return false;

		return true;
	}

	@EventHandler
	public void MessageMOTD(ServerListPingEvent event)
	{
		String extrainformation = "|" + _serverConfig.ServerType + "|" + (_game == null ? "Unknown" : _game.GetName())
				+ "|" + ((_game == null || _game.WorldData == null) ? "Unknown" : _game.WorldData.MapName);

		if (_game == null || _game.GetState() == GameState.Recruit)
		{
			if (_game != null && _game.GetCountdown() != -1)
			{
				event.setMotd(ChatColor.GREEN + "Starting in " + _game.GetCountdown() + " Seconds" + extrainformation);
			}
			else
			{
				event.setMotd(ChatColor.GREEN + "Recruiting" + extrainformation);
			}

		}
		else
		{
			event.setMotd(ChatColor.YELLOW + "In Progress" + extrainformation);
		}
	}

	@EventHandler
	public void MessageJoin(PlayerJoinEvent event)
	{
		if (_game == null || _game.AnnounceJoinQuit)
			event.setJoinMessage(F.sys("Join", event.getPlayer().getName()));
		else
			event.setJoinMessage(null);
	}

	@EventHandler
	public void MessageQuit(PlayerQuitEvent event)
	{
		if (_game == null || _game.AnnounceJoinQuit)
			event.setQuitMessage(F.sys("Quit", GetColor(event.getPlayer()) + event.getPlayer().getName()));
		else
			event.setQuitMessage(null);
	}

	public Game GetGame()
	{
		return _game;
	}

	public void SetGame(Game game)
	{
		_game = game;
	}

	public int GetPlayerMin()
	{
		return GetServerConfig().MinPlayers;
	}

	public int GetPlayerFull()
	{
		return GetServerConfig().MaxPlayers;
	}

	public void HubClock(Player player)
	{
		if (_game != null && !_game.GiveClock)
			return;

		player.getInventory().setItem(
				8,
				ItemStackFactory.Instance.CreateStack(Material.WATCH, (byte) 0, 1, (short) 0, C.cGreen
						+ "Return to Hub", new String[] { "", ChatColor.RESET + "Click while holding this",
						ChatColor.RESET + "to return to the Hub." }));
	}

	@EventHandler
	public void Login(PlayerLoginEvent event)
	{
		if (Bukkit.getServer().hasWhitelist())
		{
			if (_clientManager.Get(event.getPlayer().getName()).GetRank().Has(event.getPlayer(), Rank.MODERATOR, false))
			{
				event.allow();
				event.setResult(PlayerLoginEvent.Result.ALLOWED);

				if (_serverConfig.Tournament)
				{
					event.getPlayer().setOp(true);
				}
			}
			else
			{
				for (OfflinePlayer player : Bukkit.getWhitelistedPlayers())
				{
					if (player.getName().equalsIgnoreCase(event.getPlayer().getName()))
					{
						event.allow();
						event.setResult(PlayerLoginEvent.Result.ALLOWED);
						return;
					}
				}
				
				event.disallow(PlayerLoginEvent.Result.KICK_OTHER, "Server Whitelisted!");
			}

			return;
		}

		// Reserved Slot Check
		if (Bukkit.getOnlinePlayers().length >= Bukkit.getServer().getMaxPlayers())
		{
			if (_serverStatusManager.getCurrentServerName().contains("BETA"))
			{
				if (_clientManager.Get(event.getPlayer().getName()).GetRank()
						.Has(event.getPlayer(), Rank.HELPER, false))
				{
					event.allow();
					event.setResult(PlayerLoginEvent.Result.ALLOWED);
					return;
				}
			}
			else if (_clientManager.Get(event.getPlayer().getName()).GetRank()
					.Has(event.getPlayer(), Rank.ULTRA, false)
					|| _donationManager.Get(event.getPlayer().getName()).OwnsUnknownPackage(
							_serverConfig.ServerType + " ULTRA"))
			{
				event.allow();
				event.setResult(PlayerLoginEvent.Result.ALLOWED);

				return;
			}

			event.disallow(PlayerLoginEvent.Result.KICK_OTHER, "Server Full > Purchase Ultra at www.mineplex.com/shop");
		}
	}

	public boolean IsAlive(Player player)
	{
		if (_game == null)
			return false;

		return _game.IsAlive(player);
	}

	public void Clear(Player player)
	{
		player.setGameMode(GameMode.SURVIVAL);
		player.setAllowFlight(false);
		UtilInv.Clear(player);

		((CraftEntity) player).getHandle().getDataWatcher().watch(0, Byte.valueOf((byte) 0));

		player.setSprinting(false);

		player.setFoodLevel(20);
		player.setSaturation(3f);
		player.setExhaustion(0f);

		player.setMaxHealth(20);
		player.setHealth(player.getMaxHealth());

		player.setFireTicks(0);
		player.setFallDistance(0);

		player.setLevel(0);
		player.setExp(0f);

		((CraftPlayer) player).getHandle().spectating = false;
		((CraftPlayer) player).getHandle().k = true;

		// Arrows go bye bye.
		((CraftPlayer) player).getHandle().p(0);

		GetCondition().EndCondition(player, ConditionType.CLOAK, null);

		HubClock(player);

		GetDisguise().undisguise(player);
	}

	public ArrayList<String> LoadFiles(String gameName)
	{
		TimingManager.start("ArcadeManager LoadFiles");
		File folder = new File(".." + File.separatorChar + ".." + File.separatorChar + "update" + File.separatorChar
				+ "maps" + File.separatorChar + gameName);
		if (!folder.exists())
			folder.mkdirs();

		ArrayList<String> maps = new ArrayList<String>();

		System.out.println("Searching Maps in: " + folder);

		for (File file : folder.listFiles())
		{
			if (!file.isFile())
				continue;

			String name = file.getName();

			if (name.length() < 5)
				continue;

			name = name.substring(name.length() - 4, name.length());

			if (file.getName().equals(".zip"))
				continue;

			maps.add(file.getName().substring(0, file.getName().length() - 4));
		}

		for (String map : maps)
			System.out.println("Found Map: " + map);

		TimingManager.stop("ArcadeManager LoadFiles");

		return maps;
	}

	public ClassManager getClassManager()
	{
		return _classManager;
	}

	public ClassCombatShop getClassShop()
	{
		return _classShop;
	}

	public void openClassShop(Player player)
	{
		_classShop.attemptShopOpen(player);
	}

	@EventHandler
	public void BlockBurn(BlockBurnEvent event)
	{
		if (_game == null)
			event.setCancelled(true);
	}

	@EventHandler
	public void BlockSpread(BlockSpreadEvent event)
	{
		if (_game == null)
			event.setCancelled(true);
	}

	@EventHandler
	public void BlockFade(BlockFadeEvent event)
	{
		if (_game == null)
			event.setCancelled(true);
	}

	@EventHandler
	public void BlockDecay(LeavesDecayEvent event)
	{
		if (_game == null)
			event.setCancelled(true);
	}

	@EventHandler
	public void MobSpawn(CreatureSpawnEvent event)
	{
		if (_game == null)
			event.setCancelled(true);
	}

	@EventHandler
	public void SkillTrigger(SkillTriggerEvent event)
	{
		if (_game == null || !_game.IsLive())
		{
			event.SetCancelled(true);
		}
	}

	@EventHandler
	public void ItemTrigger(ItemTriggerEvent event)
	{
		if (_game == null || !_game.IsLive())
		{
			event.SetCancelled(true);
		}
	}

	@EventHandler
	public void Observer(PlayerCommandPreprocessEvent event)
	{
		if (event.getMessage().equalsIgnoreCase("/spec"))
		{
			event.setCancelled(true);

			if (_game != null && _game.InProgress())
			{
				UtilPlayer.message(event.getPlayer(), F.main("Game", "You cannot toggle Spectator during games."));
				return;
			}

			if (!_specList.remove(event.getPlayer()))
			{
				_specList.add(event.getPlayer());

				UtilPlayer.message(event.getPlayer(), F.main("Game", "You are now a Spectator!"));
			}
			else
			{
				UtilPlayer.message(event.getPlayer(), F.main("Game", "You are no longer a Spectator!"));
			}

			// Clean
			if (_game != null)
			{
				// Remove Data
				_game.RemoveTeamPreference(event.getPlayer());
				_game.GetPlayerKits().remove(event.getPlayer());
				_game.GetPlayerGems().remove(event.getPlayer());

				// Leave Team
				GameTeam team = _game.GetTeam(event.getPlayer());

				if (team != null)
				{
					team.RemovePlayer(event.getPlayer());
				}
			}
		}
	}

	@EventHandler
	public void ObserverQuit(PlayerQuitEvent event)
	{
		_specList.remove(event.getPlayer());
	}

	public boolean IsObserver(Player player)
	{
		return _specList.contains(player);
	}

	public boolean IsTournamentServer()
	{
		return _serverConfig.Tournament;
	}

	@EventHandler
	public void ObserverQuit(GameStateChangeEvent event)
	{
		if (_skillFactory != null)
		{
			_skillFactory.ResetAll();
		}
	}

	@EventHandler
	public void TeleportLog(PlayerTeleportEvent event)
	{
		System.out.println("Teleporting: " + event.getPlayer().getName() + " to "
				+ event.getTo().getWorld().getWorldFolder().getName());
	}
}