1697 lines
43 KiB
Java
1697 lines
43 KiB
Java
package nautilus.game.arcade;
|
|
|
|
import java.io.File;
|
|
import java.util.ArrayList;
|
|
import java.util.HashSet;
|
|
|
|
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.util.C;
|
|
import mineplex.core.common.util.F;
|
|
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.cosmetic.CosmeticManager;
|
|
import mineplex.core.creature.Creature;
|
|
import mineplex.core.customdata.CustomDataManager;
|
|
import mineplex.core.disguise.DisguiseManager;
|
|
import mineplex.core.disguise.PlayerDisguiseManager;
|
|
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.facebook.FacebookManager;
|
|
import mineplex.core.gadget.types.Gadget;
|
|
import mineplex.core.gadget.types.GadgetType;
|
|
import mineplex.core.hologram.HologramManager;
|
|
import mineplex.core.incognito.IncognitoManager;
|
|
import mineplex.core.incognito.events.IncognitoStatusChangeEvent;
|
|
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.punish.Punish;
|
|
import mineplex.core.resourcepack.ResourcePackManager;
|
|
import mineplex.core.reward.RewardRarity;
|
|
import mineplex.core.reward.rewards.PetReward;
|
|
import mineplex.core.sponsorbranding.BrandingManager;
|
|
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.valentines.ValentinesGiftManager;
|
|
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.GameCmdModeCommand;
|
|
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.GameTeam.PlayerState;
|
|
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.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.IdleManager;
|
|
import nautilus.game.arcade.managers.MiscManager;
|
|
import nautilus.game.arcade.managers.chat.GameChatManager;
|
|
import nautilus.game.arcade.player.ArcadePlayer;
|
|
import nautilus.game.arcade.shop.ArcadeShop;
|
|
import net.minecraft.server.v1_8_R3.EntityLiving;
|
|
|
|
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_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.server.ServerListPingEvent;
|
|
import org.bukkit.potion.PotionEffect;
|
|
import org.bukkit.util.Vector;
|
|
|
|
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 GameChatManager _gameChatManager;
|
|
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 ResourcePackManager _resourcePackManager;
|
|
private CustomDataManager _customDataManager;
|
|
private Punish _punishmentManager;
|
|
private BrandingManager _brandingManager;
|
|
private BonusManager _bonusManager;
|
|
|
|
private IncognitoManager _incognitoManager;
|
|
|
|
private TaskManager _taskManager;
|
|
private PacketHandler _packetHandler;
|
|
|
|
// Observers
|
|
private HashSet<Player> _specList = new HashSet<Player>();
|
|
private HashSet<Player> _fakeObserve = 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;
|
|
|
|
//Game commands
|
|
public static final String GAME_CMD_MODE_FILE = "GAME_CMD_MODE.dat";
|
|
private boolean _gameCommandMode;
|
|
|
|
public ArcadeManager(Arcade plugin, ServerStatusManager serverStatusManager, GameServerConfig serverConfig,
|
|
CoreClientManager clientManager, DonationManager donationManager, DamageManager damageManager,
|
|
StatsManager statsManager, IncognitoManager incognitoManager, 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, CustomDataManager customDataManager, Punish punish, EloManager eloManager)
|
|
{
|
|
super("Game Manager", plugin);
|
|
|
|
_serverConfig = serverConfig;
|
|
|
|
// Modules
|
|
_blockRestore = new BlockRestore(plugin);
|
|
|
|
_incognitoManager = incognitoManager;
|
|
|
|
_blood = blood;
|
|
_preferencesManager = preferences;
|
|
|
|
_explosionManager = new Explosion(plugin, _blockRestore);
|
|
_explosionManager.SetDebris(false);
|
|
|
|
_conditionManager = new SkillConditionManager(plugin);
|
|
|
|
_brandingManager = new BrandingManager(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());
|
|
_resourcePackManager = new ResourcePackManager(plugin, portal);
|
|
|
|
_customDataManager = customDataManager;
|
|
|
|
// Shop
|
|
_arcadeShop = new ArcadeShop(this, clientManager, donationManager);
|
|
|
|
// Managers
|
|
_gameChatManager = 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);
|
|
FacebookManager facebookManager = new FacebookManager(plugin, clientManager, donationManager, inventoryManager);
|
|
_bonusManager = new BonusManager(plugin, clientManager, serverStatusManager, donationManager, pollManager , npcManager, hologramManager, statsManager, _inventoryManager, petManager, facebookManager, _cosmeticManager.getGadgetManager());
|
|
new GameLootManager(this, petManager, _bonusManager.getRewardManager());
|
|
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 ValentinesGiftManager(plugin, clientManager, _bonusManager.getRewardManager(), inventoryManager, _cosmeticManager.getGadgetManager(), statsManager);
|
|
new GameTestingManager(this);
|
|
new PlayerDisguiseManager(plugin, _clientManager);
|
|
|
|
// Game Addons
|
|
new CompassAddon(plugin, this);
|
|
new SoupAddon(plugin, this);
|
|
new TeamArmorAddon(plugin, this);
|
|
|
|
//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 = eloManager;
|
|
|
|
_punishmentManager = punish;
|
|
|
|
if (GetHost() != null && !GetHost().isEmpty())
|
|
{
|
|
Bukkit.getScheduler().runTaskLater(plugin, () -> Portal.transferPlayer(GetHost(), _serverStatusManager.getCurrentServerName()), 80L);
|
|
}
|
|
|
|
loadRequiredRank();
|
|
|
|
_gameCommandMode = checkGameCommandMode();
|
|
}
|
|
|
|
@Override
|
|
public void addCommands()
|
|
{
|
|
addCommand(new GameCommand(this));
|
|
addCommand(new WriteCommand(this));
|
|
addCommand(new KitUnlockCommand(this));
|
|
addCommand(new DisguiseCommand(this));
|
|
addCommand(new RequiredRankCommand(this));
|
|
addCommand(new GameCmdModeCommand(this));
|
|
}
|
|
|
|
public GameChatManager getGameChatManager()
|
|
{
|
|
return _gameChatManager;
|
|
}
|
|
|
|
public BonusManager getBonusManager()
|
|
{
|
|
return _bonusManager;
|
|
}
|
|
|
|
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 Fire GetFire()
|
|
{
|
|
return _fire;
|
|
}
|
|
|
|
public ProjectileManager GetProjectile()
|
|
{
|
|
return _projectileManager;
|
|
}
|
|
|
|
public Punish getPunishments()
|
|
{
|
|
return _punishmentManager;
|
|
}
|
|
|
|
public BrandingManager getBrandingManager()
|
|
{
|
|
return _brandingManager;
|
|
}
|
|
|
|
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));
|
|
}
|
|
|
|
@Override
|
|
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 StaffIncognito(IncognitoStatusChangeEvent event)
|
|
{
|
|
if(event.getNewState()) //Is going into incognito
|
|
{
|
|
UtilServer.broadcast(F.sys("Quit", event.getPlayer().getName()));
|
|
|
|
if(_game.GetCountdown() > 0) //Lobby is counting down
|
|
{
|
|
// 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());
|
|
}
|
|
}
|
|
}
|
|
else if(_game.GetState() != GameState.Recruit) //Game is NOT in lobby
|
|
{
|
|
addSpectator(event.getPlayer(), true);
|
|
_specList.add(event.getPlayer());
|
|
if(_game.GetTeam(event.getPlayer()) != null)
|
|
_game.GetTeam(event.getPlayer()).SetPlayerState(event.getPlayer(), PlayerState.OUT);
|
|
}
|
|
else //Game is in lobby
|
|
{
|
|
_specList.add(event.getPlayer());
|
|
}
|
|
}
|
|
else //Is coming out of incognito
|
|
{
|
|
UtilServer.broadcast(F.sys("Join", event.getPlayer().getName()));
|
|
|
|
if(!(_game.GetState() == GameState.Live || _game.GetState() == GameState.Prepare))
|
|
{
|
|
_specList.remove(event.getPlayer());
|
|
if(_game.GetTeam(event.getPlayer()) != null)
|
|
_game.GetTeam(event.getPlayer()).SetPlayerState(event.getPlayer(), PlayerState.IN);
|
|
}
|
|
|
|
if (_game != null && isSpectator(event.getPlayer()))
|
|
{
|
|
event.show(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
@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.TWITCH))
|
|
extrainformation += "|HostRank." + _gameHostManager.getHostRank().toString();
|
|
|
|
//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 (_incognitoManager.Get(event.getPlayer()).Status)
|
|
{
|
|
event.setJoinMessage(null);
|
|
return;
|
|
}
|
|
|
|
if (event.getJoinMessage() == null)
|
|
return;
|
|
|
|
if (_game != null && _game.AnnounceJoinQuit)
|
|
event.setJoinMessage(F.sys("Join", GetColor(event.getPlayer()) + name));
|
|
|
|
else
|
|
event.setJoinMessage(null);
|
|
}
|
|
|
|
@EventHandler
|
|
public void MessageQuit(PlayerQuitEvent event)
|
|
{
|
|
if (_incognitoManager.Get(event.getPlayer()).Status)
|
|
{
|
|
event.setQuitMessage(null);
|
|
return;
|
|
}
|
|
|
|
String name = event.getPlayer().getName();
|
|
|
|
if (event.getQuitMessage() == null)
|
|
return;
|
|
|
|
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");
|
|
Rank minimum = Rank.OWNER;
|
|
if (testServer)
|
|
{
|
|
minimum = Rank.JNR_DEV;
|
|
}
|
|
|
|
if (_clientManager.Get(event.getPlayer()).GetRank().has(minimum))
|
|
event.getPlayer().setOp(true);
|
|
else
|
|
event.getPlayer().setOp(false);
|
|
}
|
|
|
|
public boolean IsAlive(Player player)
|
|
{
|
|
if (_game == null)
|
|
return false;
|
|
|
|
return _game.IsAlive(player);
|
|
}
|
|
|
|
/**
|
|
* Checks if a player is participating in/has been participating in the current game
|
|
* @param player The player to check
|
|
* @return Whether they are/have been playing
|
|
*/
|
|
public boolean hasBeenPlaying(Player player)
|
|
{
|
|
if (_game == null)
|
|
return false;
|
|
|
|
if (_game.GetTeam(player) == null)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
public void Clear(Player player)
|
|
{
|
|
if (player.getGameMode() == GameMode.SPECTATOR)
|
|
player.setSpectatorTarget(null);
|
|
|
|
player.setGameMode(GameMode.SURVIVAL);
|
|
player.setAllowFlight(false);
|
|
player.setFlySpeed(0.1F);
|
|
|
|
UtilInv.Clear(player);
|
|
|
|
UtilPlayer.setAutoDeploy(player, false);
|
|
UtilPlayer.setGlidableWithoutWings(player, false);
|
|
UtilPlayer.setGliding(player, false);
|
|
UtilPlayer.setAutoDeployDistance(player, 1.15F);
|
|
|
|
((CraftEntity) player).getHandle().getDataWatcher().watch(0, Byte.valueOf((byte) 0), EntityLiving.META_ENTITYDATA, (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);
|
|
|
|
Gadget morph = getCosmeticManager().getGadgetManager().getActive(player, GadgetType.Morph);
|
|
if (morph != null && morph.IsActive(player))
|
|
morph.Disable(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()))
|
|
{
|
|
if (_game != null && !_game.SpectatorAllowed)
|
|
{
|
|
UtilPlayer.message(event.getPlayer(), F.main("Game", "You are not allowed to toggle Spectator in this game!"));
|
|
return;
|
|
}
|
|
_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 void toggleFakeObserver(Player player)
|
|
{
|
|
if (!_fakeObserve.remove(player))
|
|
_fakeObserve.add(player);
|
|
}
|
|
|
|
public boolean IsObserver(Player player)
|
|
{
|
|
if (_fakeObserve.contains(player))
|
|
return true;
|
|
|
|
if (_incognitoManager.Get(player).Status)
|
|
{
|
|
_specList.add(player);
|
|
}
|
|
return _specList.contains(player);
|
|
}
|
|
|
|
public boolean isVanished(Player player)
|
|
{
|
|
return _incognitoManager.Get(player).Status;
|
|
}
|
|
|
|
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
|
|
public void toggleSpec(GameStateChangeEvent event)
|
|
{
|
|
if (event.GetState() != GameState.Loading)
|
|
return;
|
|
if (_game != null)
|
|
{
|
|
if (_game.SpectatorAllowed)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
for (Player player : _specList)
|
|
{
|
|
_specList.remove(player);
|
|
|
|
// Clean
|
|
if (_game != null)
|
|
{
|
|
// Remove Data
|
|
_game.RemoveTeamPreference(player);
|
|
_game.GetPlayerKits().remove(player);
|
|
_game.GetPlayerGems().remove(player);
|
|
|
|
// Leave Team
|
|
GameTeam team = _game.GetTeam(player);
|
|
|
|
if (team != null)
|
|
{
|
|
team.RemovePlayer(player);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@EventHandler(priority = EventPriority.LOWEST)
|
|
public void cosmeticState(GameStateChangeEvent event)
|
|
{
|
|
//Disable
|
|
if (event.GetState() == GameState.Recruit)
|
|
{
|
|
getCosmeticManager().setActive(true);
|
|
getCosmeticManager().setHideParticles(false);
|
|
}
|
|
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();
|
|
}
|
|
}
|
|
|
|
if (!event.GetGame().AllowParticles)
|
|
getCosmeticManager().setHideParticles(true);
|
|
}
|
|
}
|
|
|
|
@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, 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);
|
|
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);
|
|
}
|
|
|
|
/**
|
|
* Returns whether this server has a file, stating that it allows game commands.
|
|
*
|
|
* @return Whether this server is in game command mode.
|
|
*/
|
|
private boolean checkGameCommandMode()
|
|
{
|
|
return new File(GAME_CMD_MODE_FILE).exists();
|
|
}
|
|
|
|
/**
|
|
* @return Whether this server is in game command mode.
|
|
*/
|
|
public boolean isGameCommandMode()
|
|
{
|
|
return _gameCommandMode;
|
|
}
|
|
|
|
/**
|
|
* Sets this server's game command mode state.
|
|
*
|
|
* @param state Whether to enable or disable game commands.
|
|
*/
|
|
public void setGameCommandMode(boolean state)
|
|
{
|
|
_gameCommandMode = state;
|
|
}
|
|
|
|
/**
|
|
* Finds whether or not a player can use a game command or not.
|
|
* <p>
|
|
* Sends a denial alert if they can't.
|
|
*
|
|
* @param player The player attempting to use the command.
|
|
* @return Whether or not the player can successfully use the command.
|
|
*/
|
|
public boolean canPlayerUseGameCmd(Player player)
|
|
{
|
|
if (_gameCommandMode)
|
|
{
|
|
// When enabled, anyone can use game commands.
|
|
return true;
|
|
}
|
|
|
|
// Check whether they are of high enough rank status.
|
|
if (!GetClients().hasRank(player, Rank.JNR_DEV))
|
|
{
|
|
player.sendMessage(F.main("Server", "You are not allowed to use game commands."));
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|