298ea1e5e6
* commit 'd561915fd32885036b55cc6a05899934a544e131': FORMATTING CHANG EI'M GOING TO CRY UGH DONEONDONFA;SDJF;LADSF;OCAJEFOJ;FJAD;FAJSMLDFAH D Changed dns api key to new key. Prevent server monitor redis calls to cause restarts. Added winter chests to customer support. Epic chnage that saved the day omg Die player cache Quick changes to improve things. Uncommented bouncy balls Final tweaks to random armorstand Quick thing before merge Worked on double. Switching branches Formatting Reformatted Fixed paintball to the max. :>> Class Switching branches c: Sniper work Work. Deemed unsuitable due to an issue with the paintballs flying wide. Added a sniper kit! :D
1455 lines
37 KiB
Java
1455 lines
37 KiB
Java
package nautilus.game.arcade;
|
|
|
|
import java.io.File;
|
|
import java.util.ArrayList;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.Map.Entry;
|
|
|
|
import org.bukkit.Bukkit;
|
|
import org.bukkit.ChatColor;
|
|
import org.bukkit.GameMode;
|
|
import org.bukkit.Material;
|
|
import org.bukkit.OfflinePlayer;
|
|
import org.bukkit.Sound;
|
|
import org.bukkit.craftbukkit.v1_8_R3.entity.CraftEntity;
|
|
import org.bukkit.craftbukkit.v1_8_R3.entity.CraftPlayer;
|
|
import org.bukkit.entity.Entity;
|
|
import org.bukkit.entity.EntityType;
|
|
import org.bukkit.entity.Player;
|
|
import org.bukkit.event.EventHandler;
|
|
import org.bukkit.event.EventPriority;
|
|
import org.bukkit.event.HandlerList;
|
|
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.entity.EntityExplodeEvent;
|
|
import org.bukkit.event.inventory.InventoryType;
|
|
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.PlayerResourcePackStatusEvent;
|
|
import org.bukkit.event.player.PlayerResourcePackStatusEvent.Status;
|
|
import org.bukkit.event.server.ServerListPingEvent;
|
|
import org.bukkit.potion.PotionEffect;
|
|
import org.bukkit.util.Vector;
|
|
|
|
import com.google.common.base.Objects;
|
|
|
|
import mineplex.core.MiniPlugin;
|
|
import mineplex.core.account.CoreClientManager;
|
|
import mineplex.core.achievement.AchievementManager;
|
|
import mineplex.core.blockrestore.BlockRestore;
|
|
import mineplex.core.blood.Blood;
|
|
import mineplex.core.bonuses.BonusManager;
|
|
import mineplex.core.chat.Chat;
|
|
import mineplex.core.common.Rank;
|
|
import mineplex.core.common.jsonchat.ClickEvent;
|
|
import mineplex.core.common.jsonchat.JsonMessage;
|
|
import mineplex.core.common.util.C;
|
|
import mineplex.core.common.util.Callback;
|
|
import mineplex.core.common.util.F;
|
|
import mineplex.core.common.util.NautHashMap;
|
|
import mineplex.core.common.util.UtilAction;
|
|
import mineplex.core.common.util.UtilGear;
|
|
import mineplex.core.common.util.UtilInv;
|
|
import mineplex.core.common.util.UtilPlayer;
|
|
import mineplex.core.common.util.UtilServer;
|
|
import mineplex.core.common.util.UtilTime;
|
|
import mineplex.core.cosmetic.CosmeticManager;
|
|
import mineplex.core.creature.Creature;
|
|
import mineplex.core.customdata.CustomDataManager;
|
|
import mineplex.core.disguise.DisguiseManager;
|
|
import mineplex.core.donation.DonationManager;
|
|
import mineplex.core.elo.EloManager;
|
|
import mineplex.core.energy.Energy;
|
|
import mineplex.core.explosion.Explosion;
|
|
import mineplex.core.explosion.ExplosionEvent;
|
|
import mineplex.core.giveaway.GiveawayManager;
|
|
import mineplex.core.hologram.HologramManager;
|
|
import mineplex.core.inventory.InventoryManager;
|
|
import mineplex.core.itemstack.ItemStackFactory;
|
|
import mineplex.core.movement.Movement;
|
|
import mineplex.core.npc.NpcManager;
|
|
import mineplex.core.packethandler.PacketHandler;
|
|
import mineplex.core.party.PartyManager;
|
|
import mineplex.core.pet.PetManager;
|
|
import mineplex.core.poll.PollManager;
|
|
import mineplex.core.portal.Portal;
|
|
import mineplex.core.preferences.PreferencesManager;
|
|
import mineplex.core.projectile.ProjectileManager;
|
|
import mineplex.core.resourcepack.ResourcePackManager;
|
|
import mineplex.core.reward.RewardData;
|
|
import mineplex.core.reward.RewardRarity;
|
|
import mineplex.core.reward.rewards.PetReward;
|
|
import mineplex.core.stats.StatsManager;
|
|
import mineplex.core.status.ServerStatusManager;
|
|
import mineplex.core.task.TaskManager;
|
|
import mineplex.core.teleport.Teleport;
|
|
import mineplex.core.timing.TimingManager;
|
|
import mineplex.core.titangiveaway.TitanGiveawayManager;
|
|
import mineplex.core.updater.event.UpdateEvent;
|
|
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.damage.DamageManager;
|
|
import mineplex.minecraft.game.core.fire.Fire;
|
|
import nautilus.game.arcade.addons.SoupAddon;
|
|
import nautilus.game.arcade.addons.TeamArmorAddon;
|
|
import nautilus.game.arcade.addons.compass.CompassAddon;
|
|
import nautilus.game.arcade.command.DisguiseCommand;
|
|
import nautilus.game.arcade.command.GameCommand;
|
|
import nautilus.game.arcade.command.KitUnlockCommand;
|
|
import nautilus.game.arcade.command.RequiredRankCommand;
|
|
import nautilus.game.arcade.command.WriteCommand;
|
|
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.game.games.event.EventModule;
|
|
import nautilus.game.arcade.game.games.uhc.UHC;
|
|
import nautilus.game.arcade.managers.GameAchievementManager;
|
|
import nautilus.game.arcade.managers.GameChatManager;
|
|
import nautilus.game.arcade.managers.GameCreationManager;
|
|
import nautilus.game.arcade.managers.GameFlagManager;
|
|
import nautilus.game.arcade.managers.GameGemManager;
|
|
import nautilus.game.arcade.managers.GameHostManager;
|
|
import nautilus.game.arcade.managers.GameLobbyManager;
|
|
import nautilus.game.arcade.managers.GameLootManager;
|
|
import nautilus.game.arcade.managers.GameManager;
|
|
import nautilus.game.arcade.managers.GamePlayerManager;
|
|
import nautilus.game.arcade.managers.GameSpectatorManager;
|
|
import nautilus.game.arcade.managers.GameStatManager;
|
|
import nautilus.game.arcade.managers.GameTestingManager;
|
|
import nautilus.game.arcade.managers.GameTournamentManager;
|
|
import nautilus.game.arcade.managers.GameWorldManager;
|
|
import nautilus.game.arcade.managers.HolidayManager;
|
|
import nautilus.game.arcade.managers.IdleManager;
|
|
import nautilus.game.arcade.managers.MiscManager;
|
|
import nautilus.game.arcade.player.ArcadePlayer;
|
|
import nautilus.game.arcade.shop.ArcadeShop;
|
|
|
|
public class ArcadeManager extends MiniPlugin implements IRelation
|
|
{
|
|
// Modules
|
|
private BlockRestore _blockRestore;
|
|
private Blood _blood;
|
|
private Chat _chat;
|
|
private CoreClientManager _clientManager;
|
|
private DisguiseManager _disguiseManager;
|
|
private DonationManager _donationManager;
|
|
private ConditionManager _conditionManager;
|
|
private PetManager _petManager;
|
|
private Creature _creature;
|
|
private DamageManager _damageManager;
|
|
private Explosion _explosionManager;
|
|
private EventModule _eventManager;
|
|
|
|
private Fire _fire;
|
|
private ProjectileManager _projectileManager;
|
|
|
|
private Portal _portal;
|
|
private ArcadeShop _arcadeShop;
|
|
|
|
//Champions Modules
|
|
private boolean _enabled = true;
|
|
private ClassManager _classManager;
|
|
private SkillFactory _skillFactory;
|
|
private ItemFactory _itemFactory;
|
|
private Energy _energy;
|
|
private ClassShopManager _classShopManager;
|
|
private ClassCombatShop _classShop;
|
|
private EloManager _eloManager;
|
|
|
|
// Managers
|
|
private GameCreationManager _gameCreationManager;
|
|
private GameGemManager _gameGemManager;
|
|
private GameManager _gameManager;
|
|
private GameLobbyManager _gameLobbyManager;
|
|
private GamePlayerManager _gamePlayerManager;
|
|
private GameTournamentManager _gameTournamentManager;
|
|
private GameWorldManager _gameWorldManager;
|
|
private GameHostManager _gameHostManager;
|
|
private ServerStatusManager _serverStatusManager;
|
|
private InventoryManager _inventoryManager;
|
|
private CosmeticManager _cosmeticManager;
|
|
private final IdleManager _idleManager;
|
|
private HologramManager _hologramManager;
|
|
private AchievementManager _achievementManager;
|
|
private StatsManager _statsManager;
|
|
private PartyManager _partyManager;
|
|
private PreferencesManager _preferencesManager;
|
|
private GiveawayManager _giveawayManager;
|
|
private ResourcePackManager _resourcePackManager;
|
|
private CustomDataManager _customDataManager;
|
|
|
|
private TaskManager _taskManager;
|
|
private PacketHandler _packetHandler;
|
|
|
|
// Observers
|
|
private HashSet<Player> _specList = new HashSet<Player>();
|
|
|
|
// Server Games
|
|
private GameServerConfig _serverConfig;
|
|
|
|
// Games
|
|
private Game _game;
|
|
|
|
//Youtuber Kits
|
|
private HashSet<Player> _youtube = new HashSet<Player>();
|
|
|
|
//Server Property
|
|
private Rank _requiredRank;
|
|
|
|
public ArcadeManager(Arcade plugin, ServerStatusManager serverStatusManager, GameServerConfig serverConfig,
|
|
CoreClientManager clientManager, DonationManager donationManager, DamageManager damageManager,
|
|
StatsManager statsManager, AchievementManager achievementManager, DisguiseManager disguiseManager, Creature creature, Teleport teleport, Blood blood, Chat chat,
|
|
Portal portal, PreferencesManager preferences, InventoryManager inventoryManager, PacketHandler packetHandler,
|
|
CosmeticManager cosmeticManager, ProjectileManager projectileManager, PetManager petManager, HologramManager hologramManager, String webAddress, PollManager pollManager,
|
|
NpcManager npcManager, GiveawayManager giveawayManager, CustomDataManager customDataManager)
|
|
{
|
|
super("Game Manager", plugin);
|
|
|
|
_serverConfig = serverConfig;
|
|
|
|
// Modules
|
|
_blockRestore = new BlockRestore(plugin);
|
|
|
|
_blood = blood;
|
|
_preferencesManager = preferences;
|
|
|
|
_explosionManager = new Explosion(plugin, _blockRestore);
|
|
_explosionManager.SetDebris(false);
|
|
|
|
_conditionManager = new SkillConditionManager(plugin);
|
|
|
|
//Dont see a reason to ever just use the normal one
|
|
// if (serverConfig.GameList.contains(GameType.ChampionsDominate)
|
|
// || serverConfig.GameList.contains(GameType.ChampionsTDM)
|
|
// || serverConfig.GameList.contains(GameType.ChampionsCTF))
|
|
// {
|
|
// _conditionManager = new SkillConditionManager(plugin);
|
|
// }
|
|
// else
|
|
// {
|
|
// _conditionManager = new ConditionManager(plugin);
|
|
// }
|
|
|
|
_clientManager = clientManager;
|
|
_serverStatusManager = serverStatusManager;
|
|
_chat = chat;
|
|
_creature = creature;
|
|
|
|
_damageManager = damageManager;
|
|
_damageManager.UseSimpleWeaponDamage = true;
|
|
_damageManager.setConditionManager(_conditionManager);
|
|
_conditionManager.setDamageManager(_damageManager);
|
|
|
|
_disguiseManager = disguiseManager;
|
|
|
|
_donationManager = donationManager;
|
|
|
|
_fire = new Fire(plugin, _conditionManager, damageManager);
|
|
|
|
_projectileManager = projectileManager;
|
|
|
|
_packetHandler = packetHandler;
|
|
|
|
_partyManager = new PartyManager(plugin, portal, _clientManager, preferences);
|
|
_statsManager = statsManager;
|
|
_taskManager = new TaskManager(plugin, clientManager, webAddress);
|
|
_achievementManager = achievementManager;
|
|
_inventoryManager = inventoryManager;
|
|
_cosmeticManager = cosmeticManager;
|
|
_portal = portal;
|
|
_petManager = petManager;
|
|
_eventManager = new EventModule(this, getPlugin());
|
|
_giveawayManager = giveawayManager;
|
|
_resourcePackManager = new ResourcePackManager(plugin, portal);
|
|
|
|
_customDataManager = customDataManager;
|
|
|
|
// Shop
|
|
_arcadeShop = new ArcadeShop(this, clientManager, donationManager);
|
|
|
|
// Managers
|
|
new GameChatManager(this);
|
|
_gameCreationManager = new GameCreationManager(this);
|
|
_gameGemManager = new GameGemManager(this);
|
|
_gameManager = new GameManager(this);
|
|
_gameLobbyManager = new GameLobbyManager(this, packetHandler);
|
|
_gameHostManager = new GameHostManager(this);
|
|
new GameFlagManager(this);
|
|
_gamePlayerManager = new GamePlayerManager(this);
|
|
new GameAchievementManager(this);
|
|
_gameTournamentManager = new GameTournamentManager(this);
|
|
new GameStatManager(this);
|
|
new GameLootManager(this, petManager);
|
|
new GameSpectatorManager(this);
|
|
_gameWorldManager = new GameWorldManager(this);
|
|
new MiscManager(this);
|
|
_hologramManager = hologramManager;
|
|
_idleManager = new IdleManager(this);
|
|
TitanGiveawayManager titanGiveaway = new TitanGiveawayManager(getPlugin(), clientManager, serverStatusManager);
|
|
new HolidayManager(this, titanGiveaway);
|
|
new GameTestingManager(this);
|
|
|
|
// Game Addons
|
|
new CompassAddon(plugin, this);
|
|
new SoupAddon(plugin, this);
|
|
new TeamArmorAddon(plugin, this);
|
|
|
|
new BonusManager(plugin, clientManager, serverStatusManager, donationManager, pollManager , npcManager, hologramManager, statsManager, _inventoryManager, petManager, giveawayManager);
|
|
|
|
//Champions Modules
|
|
_energy = new Energy(plugin);
|
|
|
|
_itemFactory = new ItemFactory(_plugin, _blockRestore, _conditionManager, damageManager, _energy,
|
|
_fire, _projectileManager, webAddress);
|
|
|
|
_skillFactory = new SkillFactory(plugin, damageManager, this, _damageManager.GetCombatManager(),
|
|
_conditionManager, _projectileManager, _disguiseManager, _blockRestore, _fire, new Movement(plugin), teleport,
|
|
_energy, webAddress);
|
|
|
|
_classManager = new ClassManager(plugin, clientManager, donationManager, _cosmeticManager.getGadgetManager(), _skillFactory, _itemFactory,
|
|
webAddress);
|
|
|
|
_classShopManager = new ClassShopManager(_plugin, _classManager, _skillFactory, _itemFactory, _achievementManager, clientManager);
|
|
|
|
_classShop = new ClassCombatShop(_classShopManager, clientManager, donationManager, false, "Class Shop");
|
|
|
|
_eloManager = new EloManager(_plugin, clientManager);
|
|
|
|
if (GetHost() != null && !GetHost().isEmpty())
|
|
{
|
|
Bukkit.getScheduler().runTaskLater(plugin, new Runnable()
|
|
{
|
|
public void run()
|
|
{
|
|
Portal.transferPlayer(GetHost(), _serverStatusManager.getCurrentServerName());
|
|
}
|
|
}, 80L);
|
|
}
|
|
|
|
loadRequiredRank();
|
|
}
|
|
|
|
@Override
|
|
public void addCommands()
|
|
{
|
|
addCommand(new GameCommand(this));
|
|
addCommand(new WriteCommand(this));
|
|
addCommand(new KitUnlockCommand(this));
|
|
addCommand(new DisguiseCommand(this));
|
|
addCommand(new RequiredRankCommand(this));
|
|
}
|
|
|
|
public GameServerConfig GetServerConfig()
|
|
{
|
|
return _serverConfig;
|
|
}
|
|
|
|
public ResourcePackManager getResourcePackManager()
|
|
{
|
|
return _resourcePackManager;
|
|
}
|
|
|
|
public ArrayList<GameType> GetGameList()
|
|
{
|
|
return GetServerConfig().GameList;
|
|
}
|
|
|
|
public AchievementManager GetAchievement()
|
|
{
|
|
return _achievementManager;
|
|
}
|
|
|
|
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 PacketHandler getPacketHandler()
|
|
{
|
|
return _packetHandler;
|
|
}
|
|
|
|
public CosmeticManager getCosmeticManager()
|
|
{
|
|
return _cosmeticManager;
|
|
}
|
|
|
|
public DisguiseManager GetDisguise()
|
|
{
|
|
return _disguiseManager;
|
|
}
|
|
|
|
public HologramManager getHologramManager()
|
|
{
|
|
return _hologramManager;
|
|
}
|
|
|
|
public DamageManager GetDamage()
|
|
{
|
|
return _damageManager;
|
|
}
|
|
|
|
public DonationManager GetDonation()
|
|
{
|
|
return _donationManager;
|
|
}
|
|
|
|
public EloManager getEloManager()
|
|
{
|
|
return _eloManager;
|
|
}
|
|
|
|
public Explosion GetExplosion()
|
|
{
|
|
return _explosionManager;
|
|
}
|
|
|
|
public GiveawayManager getGiveawayManager()
|
|
{
|
|
return _giveawayManager;
|
|
}
|
|
|
|
public Fire GetFire()
|
|
{
|
|
return _fire;
|
|
}
|
|
|
|
public ProjectileManager GetProjectile()
|
|
{
|
|
return _projectileManager;
|
|
}
|
|
|
|
public Portal GetPortal()
|
|
{
|
|
return _portal;
|
|
}
|
|
|
|
public GameLobbyManager GetLobby()
|
|
{
|
|
return _gameLobbyManager;
|
|
}
|
|
|
|
public TaskManager GetTaskManager()
|
|
{
|
|
return _taskManager;
|
|
}
|
|
|
|
public ArcadeShop GetShop()
|
|
{
|
|
return _arcadeShop;
|
|
}
|
|
|
|
public GameCreationManager GetGameCreationManager()
|
|
{
|
|
return _gameCreationManager;
|
|
}
|
|
|
|
public GameHostManager GetGameHostManager()
|
|
{
|
|
return _gameHostManager;
|
|
}
|
|
|
|
public GameManager GetGameManager()
|
|
{
|
|
return _gameManager;
|
|
}
|
|
|
|
public GameGemManager GetGameGemManager()
|
|
{
|
|
return _gameGemManager;
|
|
}
|
|
|
|
public GamePlayerManager GetGamePlayerManager()
|
|
{
|
|
return _gamePlayerManager;
|
|
}
|
|
|
|
public GameTournamentManager GetGameTournamentManager()
|
|
{
|
|
return _gameTournamentManager;
|
|
}
|
|
|
|
public GameWorldManager GetGameWorldManager()
|
|
{
|
|
return _gameWorldManager;
|
|
}
|
|
|
|
public EventModule GetEventModule()
|
|
{
|
|
return _eventManager;
|
|
}
|
|
|
|
public PreferencesManager getPreferences()
|
|
{
|
|
return _preferencesManager;
|
|
}
|
|
|
|
public StatsManager GetStatsManager()
|
|
{
|
|
return _statsManager;
|
|
}
|
|
|
|
public ServerStatusManager GetServerStatusManager()
|
|
{
|
|
return _serverStatusManager;
|
|
}
|
|
|
|
public CustomDataManager getCustomDataManager() { return _customDataManager; }
|
|
|
|
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)
|
|
{
|
|
event.setMaxPlayers(_serverConfig.MaxPlayers);
|
|
|
|
//MPS
|
|
if (_gameHostManager != null && _gameHostManager.isPrivateServer())
|
|
{
|
|
if (_gameHostManager.isHostExpired())
|
|
{
|
|
event.setMotd(ChatColor.RED + "Finished");
|
|
return;
|
|
}
|
|
|
|
if (!GetServerConfig().PublicServer || GetServerConfig().PlayerServerWhitelist)
|
|
{
|
|
event.setMotd(ChatColor.GRAY + "Private");
|
|
return;
|
|
}
|
|
}
|
|
|
|
String extrainformation = "|" + _serverConfig.ServerType + "|" + (_game == null ? "Unknown" : _game.GetName())
|
|
+ "|" + ((_game == null || _game.WorldData == null) ? "Unknown" : _game.WorldData.MapName);
|
|
|
|
if (_gameHostManager.isPrivateServer() && _gameHostManager.hasRank(Rank.MODERATOR))
|
|
extrainformation += "|StaffHosted";
|
|
|
|
//Always Joinable
|
|
// if (_game != null && _game.JoinInProgress)
|
|
// {
|
|
// event.setMotd(ChatColor.GREEN + "Recruiting" + extrainformation);
|
|
// }
|
|
//UHC Timed
|
|
if (_game != null && _game.GetType() == GameType.UHC)
|
|
{
|
|
event.setMotd(((UHC) _game).getMotdStatus() + extrainformation);
|
|
}
|
|
//Recruiting
|
|
else 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);
|
|
}
|
|
}
|
|
//In Progress
|
|
else
|
|
{
|
|
event.setMotd(ChatColor.YELLOW + "In Progress" + extrainformation);
|
|
}
|
|
|
|
if (this.getPlugin().getConfig().getString("serverstatus.group").equalsIgnoreCase("Testing"))
|
|
event.setMotd(ChatColor.GOLD + "Private Mineplex Test Server");
|
|
}
|
|
|
|
@EventHandler
|
|
public void MessageJoin(PlayerJoinEvent event)
|
|
{
|
|
String name = event.getPlayer().getName();
|
|
|
|
if (_game != null && _game.AnnounceJoinQuit)
|
|
event.setJoinMessage(F.sys("Join", GetColor(event.getPlayer()) + name));
|
|
|
|
else
|
|
event.setJoinMessage(null);
|
|
}
|
|
|
|
@EventHandler
|
|
public void MessageQuit(PlayerQuitEvent event)
|
|
{
|
|
String name = event.getPlayer().getName();
|
|
|
|
if (_game == null || _game.AnnounceJoinQuit)
|
|
event.setQuitMessage(F.sys("Quit", GetColor(event.getPlayer()) + name));
|
|
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 (!IsHotbarHubClock())
|
|
return;
|
|
|
|
if (_game != null && !_game.GiveClock)
|
|
return;
|
|
|
|
if (player.getOpenInventory().getType() != InventoryType.CRAFTING &&
|
|
player.getOpenInventory().getType() != InventoryType.CREATIVE)
|
|
return;
|
|
|
|
if (!UtilGear.isMat(player.getInventory().getItem(8), Material.WATCH) && !UtilGear.isMat(player.getInventory().getItem(8), Material.SPECKLED_MELON))
|
|
{
|
|
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."}));
|
|
|
|
UtilInv.Update(player);
|
|
}
|
|
}
|
|
|
|
@EventHandler
|
|
public void Login(PlayerLoginEvent event)
|
|
{
|
|
if (Bukkit.getServer().hasWhitelist())
|
|
{
|
|
if(_requiredRank != null)
|
|
{
|
|
if (_clientManager.Get(event.getPlayer().getName()).GetRank().has(event.getPlayer(), _requiredRank, false))
|
|
{
|
|
event.allow();
|
|
event.setResult(PlayerLoginEvent.Result.ALLOWED);
|
|
|
|
if (_serverConfig.Tournament && _clientManager.Get(event.getPlayer().getName()).GetRank().has(event.getPlayer(), Rank.MODERATOR, false))
|
|
{
|
|
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, "Required Rank for this server: " + _requiredRank.getColor() + _requiredRank.Name);
|
|
return;
|
|
}
|
|
}
|
|
if (_clientManager.Get(event.getPlayer().getName()).GetRank().has(event.getPlayer(), Rank.MODERATOR, false) ||
|
|
_clientManager.Get(event.getPlayer().getName()).GetRank() == Rank.MAPDEV ||
|
|
_clientManager.Get(event.getPlayer().getName()).GetRank() == Rank.MAPLEAD)
|
|
{
|
|
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().size() >= Bukkit.getServer().getMaxPlayers())
|
|
{
|
|
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"))
|
|
{
|
|
|
|
if (GetGame() != null && GetGame().DontAllowOverfill)
|
|
{
|
|
event.disallow(PlayerLoginEvent.Result.KICK_OTHER, C.Bold + "Server has reached max capacity for gameplay purposes.");
|
|
return;
|
|
}
|
|
else if (Bukkit.getServer().getOnlinePlayers().size() / Bukkit.getMaxPlayers() > 1.5)
|
|
{
|
|
event.disallow(PlayerLoginEvent.Result.KICK_OTHER, C.Bold + "Server has reached max capacity for gameplay purposes.");
|
|
return;
|
|
}
|
|
else if (_gameHostManager.isEventServer() && Bukkit.getServer().getOnlinePlayers().size() >= 128)
|
|
{
|
|
event.disallow(PlayerLoginEvent.Result.KICK_OTHER, C.Bold + "Server has reached max capacity for gameplay purposes.");
|
|
return;
|
|
}
|
|
|
|
event.allow();
|
|
event.setResult(PlayerLoginEvent.Result.ALLOWED);
|
|
|
|
return;
|
|
}
|
|
|
|
event.disallow(PlayerLoginEvent.Result.KICK_OTHER, "Server Full > Purchase Ultra at www.mineplex.com/shop");
|
|
}
|
|
}
|
|
|
|
@EventHandler(priority = EventPriority.LOW)
|
|
public void AdminOP(PlayerJoinEvent event)
|
|
{
|
|
// Give developers operator on their servers
|
|
boolean testServer = _plugin.getConfig().getString("serverstatus.group").equalsIgnoreCase("Testing");
|
|
boolean eventTestServer = _plugin.getConfig().getString("serverstatus.name").equalsIgnoreCase("SMTestServer-1");
|
|
|
|
if (_clientManager.Get(event.getPlayer()).GetRank().has(Rank.OWNER)
|
|
|| (testServer && (_clientManager.Get(event.getPlayer()).GetRank().has(Rank.DEVELOPER) || _clientManager.Get(event.getPlayer()).GetRank() == Rank.JNR_DEV))
|
|
|| eventTestServer && _clientManager.Get(event.getPlayer()).GetRank().has(Rank.JNR_DEV))
|
|
event.getPlayer().setOp(true);
|
|
else
|
|
event.getPlayer().setOp(false);
|
|
}
|
|
|
|
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);
|
|
player.setFlySpeed(0.1F);
|
|
|
|
UtilInv.Clear(player);
|
|
|
|
((CraftEntity) player).getHandle().getDataWatcher().watch(0, Byte.valueOf((byte) 0));
|
|
|
|
player.setCustomName("");
|
|
player.setCustomNameVisible(false);
|
|
|
|
player.setSprinting(false);
|
|
player.setSneaking(false);
|
|
|
|
player.setFoodLevel(20);
|
|
player.setSaturation(3f);
|
|
player.setExhaustion(0f);
|
|
|
|
player.setMaxHealth(20);
|
|
player.setHealth(player.getMaxHealth());
|
|
|
|
player.setFireTicks(0);
|
|
player.setFallDistance(0);
|
|
|
|
player.eject();
|
|
player.leaveVehicle();
|
|
|
|
player.setLevel(0);
|
|
player.setExp(0f);
|
|
|
|
player.resetPlayerTime();
|
|
player.resetPlayerWeather();
|
|
|
|
((CraftPlayer) player).getHandle().spectating = false;
|
|
((CraftPlayer) player).getHandle().setGhost(false);
|
|
((CraftPlayer) player).getHandle().k = true;
|
|
|
|
// Arrows go bye bye.
|
|
((CraftPlayer) player).getHandle().o(0);
|
|
|
|
//Remove all conditions
|
|
GetCondition().EndCondition(player, null, null);
|
|
for (PotionEffect potion : player.getActivePotionEffects())
|
|
player.removePotionEffect(potion.getType());
|
|
|
|
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);
|
|
System.out.println(folder.getAbsolutePath()+" -=-=-=-=-=" );
|
|
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;
|
|
}
|
|
|
|
public boolean IsTournamentPoints()
|
|
{
|
|
return _serverConfig.TournamentPoints;
|
|
}
|
|
|
|
public boolean IsTeamRejoin()
|
|
{
|
|
return _serverConfig.TeamRejoin;
|
|
}
|
|
|
|
public boolean IsTeamAutoJoin()
|
|
{
|
|
return _serverConfig.TeamAutoJoin;
|
|
}
|
|
|
|
public boolean IsGameAutoStart()
|
|
{
|
|
return _serverConfig.GameAutoStart;
|
|
}
|
|
|
|
public boolean IsGameTimeout()
|
|
{
|
|
return _serverConfig.GameTimeout;
|
|
}
|
|
|
|
public boolean IsTeamBalance()
|
|
{
|
|
return _serverConfig.TeamForceBalance;
|
|
}
|
|
|
|
public boolean IsRewardGems()
|
|
{
|
|
return _serverConfig.RewardGems;
|
|
}
|
|
|
|
public boolean IsRewardItems()
|
|
{
|
|
return _serverConfig.RewardItems;
|
|
}
|
|
|
|
public boolean IsRewardStats()
|
|
{
|
|
return _serverConfig.RewardStats;
|
|
}
|
|
|
|
public boolean IsRewardAchievements()
|
|
{
|
|
return _serverConfig.RewardAchievements;
|
|
}
|
|
|
|
public boolean IsHotbarInventory()
|
|
{
|
|
return _serverConfig.HotbarInventory;
|
|
}
|
|
|
|
public boolean IsHotbarHubClock()
|
|
{
|
|
return _serverConfig.HotbarHubClock;
|
|
}
|
|
|
|
public boolean IsPlayerKickIdle()
|
|
{
|
|
return _serverConfig.PlayerKickIdle;
|
|
}
|
|
|
|
public int GetDesiredPlayerAmount()
|
|
{
|
|
return _serverConfig.MaxPlayers;
|
|
}
|
|
|
|
public String GetHost()
|
|
{
|
|
return _serverConfig.HostName;
|
|
}
|
|
|
|
@EventHandler
|
|
public void ObserverQuit(GameStateChangeEvent event)
|
|
{
|
|
if (_skillFactory != null)
|
|
{
|
|
_skillFactory.ResetAll();
|
|
}
|
|
}
|
|
|
|
public InventoryManager getInventoryManager()
|
|
{
|
|
return _inventoryManager;
|
|
}
|
|
|
|
@EventHandler(priority = EventPriority.LOWEST)
|
|
public void cosmeticState(GameStateChangeEvent event)
|
|
{
|
|
//Disable
|
|
if (event.GetState() == GameState.Recruit)
|
|
{
|
|
getCosmeticManager().setActive(true);
|
|
}
|
|
else if (event.GetState() == GameState.Prepare || event.GetState() == GameState.Loading || event.GetState() == GameState.Dead)
|
|
{
|
|
if (event.GetGame().GadgetsDisabled)
|
|
{
|
|
if (getCosmeticManager().isShowingInterface())
|
|
{
|
|
getCosmeticManager().setActive(false);
|
|
getCosmeticManager().disableItemsForGame();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@EventHandler
|
|
public void disableGadget(PlayerJoinEvent event)
|
|
{
|
|
updateGadgetEnabled();
|
|
}
|
|
|
|
@EventHandler
|
|
public void disableGadget(PlayerQuitEvent event)
|
|
{
|
|
updateGadgetEnabled();
|
|
}
|
|
|
|
private void updateGadgetEnabled()
|
|
{
|
|
// Disables gadgets if player count is greater than 40
|
|
int playerCount = UtilServer.getPlayers().length;
|
|
getCosmeticManager().getGadgetManager().setGadgetEnabled(playerCount <= 40);
|
|
}
|
|
|
|
/*public void saveBasicStats(final Game game)
|
|
{
|
|
if (!IsTournamentServer())
|
|
return;
|
|
|
|
final Map<UUID, Boolean> data = new HashMap<>();
|
|
|
|
for (Player loser : game.getLosers())
|
|
data.put(loser.getUniqueId(), false);
|
|
|
|
for (Player winner : game.getWinners())
|
|
data.put(winner.getUniqueId(), true);
|
|
|
|
Bukkit.getScheduler().runTaskAsynchronously(getPlugin(), new Runnable()
|
|
{
|
|
@Override
|
|
public void run()
|
|
{
|
|
getArcadeRepository().saveBasicStats(game.GetType(), IsTournamentServer(), (int) (System.currentTimeMillis() - game.getGameLiveTime()), data);
|
|
}
|
|
});
|
|
}*/
|
|
|
|
/*public void saveLeaderboardStats(Game game)
|
|
{
|
|
final TournamentType type = TournamentType.getTournamentType(game.GetType());
|
|
|
|
if (type != null)
|
|
{
|
|
final Map<UUID, Boolean> data = new HashMap<>();
|
|
|
|
for (Player loser : game.getLosers())
|
|
data.put(loser.getUniqueId(), false);
|
|
|
|
for (Player winner : game.getWinners())
|
|
data.put(winner.getUniqueId(), true);
|
|
|
|
Bukkit.getScheduler().runTaskAsynchronously(getPlugin(), new Runnable()
|
|
{
|
|
@Override
|
|
public void run()
|
|
{
|
|
getArcadeRepository().saveLeaderboardStats(0, type.ordinal(), data);
|
|
}
|
|
});
|
|
}
|
|
}*/
|
|
|
|
public boolean isGameInProgress()
|
|
{
|
|
return _game != null && _game.InProgress();
|
|
}
|
|
|
|
public boolean hasKitsUnlocked(Player player)
|
|
{
|
|
return _youtube.contains(player);
|
|
}
|
|
|
|
public void toggleUnlockKits(Player caller)
|
|
{
|
|
if (_youtube.remove(caller))
|
|
{
|
|
UtilPlayer.message(caller, C.cRed + C.Bold + "Celebrity Mode Disabled: " + ChatColor.RESET + "Kits Locked");
|
|
}
|
|
else
|
|
{
|
|
_youtube.add(caller);
|
|
UtilPlayer.message(caller, C.cGreen + C.Bold + "Celebrity Mode Enabled: " + ChatColor.RESET + "All Kits Unlocked");
|
|
}
|
|
}
|
|
|
|
@EventHandler
|
|
public void quitYoutuber(PlayerQuitEvent event)
|
|
{
|
|
_youtube.remove(event.getPlayer());
|
|
}
|
|
|
|
public IdleManager getIdleManager()
|
|
{
|
|
return _idleManager;
|
|
}
|
|
|
|
public void rewardPet(Player player, String pet, EntityType type)
|
|
{
|
|
if (!player.isOnline())
|
|
return;
|
|
|
|
PetReward reward = new PetReward(_petManager, _inventoryManager, _donationManager, pet, pet, type, RewardRarity.OTHER, 0, 0);
|
|
|
|
if (reward.canGiveReward(player))
|
|
reward.giveReward(null, player, new Callback<RewardData>()
|
|
{
|
|
@Override
|
|
public void run(RewardData data)
|
|
{
|
|
|
|
}
|
|
});
|
|
}
|
|
|
|
public void toggleChampionsModules(GameType gameType)
|
|
{
|
|
boolean isChamps = gameType == GameType.ChampionsDominate || gameType == GameType.ChampionsTDM || gameType == GameType.ChampionsCTF || gameType == GameType.BossBattles;
|
|
|
|
if (_enabled == isChamps)
|
|
{
|
|
System.out.println("----------Champions Modules are still " + isChamps);
|
|
return;
|
|
}
|
|
|
|
System.out.println("----------Champions Modules set to " + isChamps);
|
|
_enabled = isChamps;
|
|
|
|
if (_enabled)
|
|
{
|
|
_classManager.setEnabled(true);
|
|
_classShopManager.registerSelf();
|
|
_skillFactory.registerSelf();
|
|
_itemFactory.registerSelf();
|
|
_energy.registerSelf();
|
|
_eloManager.registerSelf();
|
|
|
|
//Class Shop
|
|
_plugin.getServer().getPluginManager().registerEvents(_classShop, _plugin);
|
|
}
|
|
else
|
|
{
|
|
_classManager.setEnabled(false);
|
|
_classShopManager.deregisterSelf();
|
|
_skillFactory.deregisterSelf();
|
|
_itemFactory.deregisterSelf();
|
|
_energy.deregisterSelf();
|
|
_eloManager.deregisterSelf();
|
|
|
|
//Class Shop
|
|
HandlerList.unregisterAll(_classShop);
|
|
}
|
|
}
|
|
|
|
public PartyManager getPartyManager()
|
|
{
|
|
return _partyManager;
|
|
}
|
|
|
|
public void addSpectator(Player player, boolean teleport)
|
|
{
|
|
if (GetGame() == null)
|
|
return;
|
|
|
|
Clear(player);
|
|
|
|
if (teleport)
|
|
player.teleport(GetGame().GetSpectatorLocation());
|
|
|
|
//Set Spec State
|
|
UtilAction.velocity(player, new Vector(0,1,0));
|
|
player.setAllowFlight(true);
|
|
player.setFlying(true);
|
|
player.setFlySpeed(0.1f);
|
|
((CraftPlayer) player).getHandle().spectating = true;
|
|
((CraftPlayer) player).getHandle().setGhost(true);
|
|
((CraftPlayer) player).getHandle().k = false;
|
|
|
|
GetCondition().Factory().Cloak("Spectator", player, player, 7777, true, true);
|
|
|
|
//Game Team
|
|
GetGame().GetScoreboard().SetPlayerTeam(player, "SPEC");
|
|
}
|
|
|
|
public boolean isSpectator(Entity player)
|
|
{
|
|
if (player instanceof Player)
|
|
return UtilPlayer.isSpectator((Player)player);
|
|
return false;
|
|
}
|
|
|
|
public void loadRequiredRank()
|
|
{
|
|
_requiredRank = null;
|
|
|
|
for(File file : new File(".").listFiles())
|
|
{
|
|
if(!file.getName().startsWith("RequiredRank"))
|
|
continue;
|
|
|
|
try
|
|
{
|
|
_requiredRank = Rank.valueOf(file.getName().split("=")[1]);
|
|
System.out.println("set required rank to " + _requiredRank.Name);
|
|
}
|
|
catch (IllegalArgumentException e)
|
|
{
|
|
System.out.println("===============================");
|
|
System.out.println("Wrong required rank definition.");
|
|
System.out.println("[" + file.getName().split("=")[1] + "] Does not exist!");
|
|
System.out.println("===============================");
|
|
}
|
|
}
|
|
}
|
|
|
|
public Rank getRequiredRank()
|
|
{
|
|
return _requiredRank;
|
|
}
|
|
|
|
public void setRequiredRank(Rank rank)
|
|
{
|
|
_requiredRank = rank;
|
|
}
|
|
|
|
@EventHandler(priority=EventPriority.LOWEST)
|
|
public void explosionCancel(EntityExplodeEvent event)
|
|
{
|
|
if (GetGame() == null || !GetGame().InProgress())
|
|
{
|
|
event.blockList().clear();
|
|
event.setCancelled(true);
|
|
}
|
|
}
|
|
|
|
@EventHandler(priority = EventPriority.LOWEST)
|
|
public void explosionCancel(ExplosionEvent event)
|
|
{
|
|
if (GetGame() == null || !GetGame().InProgress())
|
|
{
|
|
event.GetBlocks().clear();
|
|
}
|
|
}
|
|
|
|
@EventHandler
|
|
public void spawnDebug(PlayerCommandPreprocessEvent event)
|
|
{
|
|
if (event.getPlayer().isOp() && event.getMessage().contains("setmax"))
|
|
{
|
|
try
|
|
{
|
|
int i = Integer.parseInt(event.getMessage().split(" ")[1]);
|
|
|
|
_serverConfig.MaxPlayers = i;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
|
|
}
|
|
|
|
event.setCancelled(true);
|
|
}
|
|
}
|
|
|
|
public ArcadePlayer getArcadePlayer(Player player)
|
|
{
|
|
return new ArcadePlayer(player, getCustomDataManager(), this);
|
|
}
|
|
}
|