@SuppressWarnings("null")
@Override
public void change(Event e, @Nullable Object[] delta, ChangeMode mode) {
	ServerListPingEvent event = (ServerListPingEvent) e;
	switch (mode) {
		case SET:
			event.setMaxPlayers(((Number) delta[0]).intValue());
			break;
		case ADD:
			event.setMaxPlayers(event.getMaxPlayers() + ((Number) delta[0]).intValue());
			break;
		case REMOVE:
			event.setMaxPlayers(event.getMaxPlayers() - ((Number) delta[0]).intValue());
			break;
		case DELETE:
		case RESET:
			event.setMaxPlayers(Bukkit.getMaxPlayers());
	}
}
 

@EventHandler
public void onPing(final ServerListPingEvent serverListPingEvent) {
    if (SkyWarsReloaded.get().serverLoaded()) {
        if (GameMap.getMaps().size() > 0) {
            GameMap game = GameMap.getMaps().get(0);
            serverListPingEvent.setMotd(new Messaging.MessageFormatter().setVariable("matchstate", game.getMatchState().toString())
                    .setVariable("playercount","" + game.getPlayerCount()).setVariable("maxplayers", "" + game.getMaxPlayers())
                    .setVariable("displayname", game.getDisplayName()).format("bungee.motd"));
        } else {
            serverListPingEvent.setMotd(new Messaging.MessageFormatter().setVariable("matchstate", MatchState.ENDING.toString() )
                    .setVariable("playercount","0").setVariable("maxplayers", "0")
                    .setVariable("displayname", "null").format("bungee.motd"));
        }
    } else {
        serverListPingEvent.setMotd(new Messaging.MessageFormatter().setVariable("matchstate", MatchState.ENDING.toString() )
                .setVariable("playercount","0").setVariable("maxplayers", "0")
                .setVariable("displayname", "null").format("bungee.motd"));
    }
}
 

@EventHandler(priority = EventPriority.LOWEST)
public void onServerListPing(ServerListPingEvent event) {
    String name = match.getLoadedMap().getName();
    ChatColor color = ChatColor.GRAY;
    switch (match.getState()) {
        case ENDED:
            color = ChatColor.AQUA;
            break;
        case PLAYING:
            color = ChatColor.GOLD;
            break;
        case STARTING:
            color = ChatColor.GREEN;
            break;
    }
    event.setMotd(color + "\u00BB " + ChatColor.AQUA + name + color + " \u00AB" +
            (!Config.motdMessage.equals("") ? "\n" + ChatColor.translateAlternateColorCodes('`', Config.motdMessage) : ""));

}
 

@Override
public GeyserPingInfo getPingInformation() {
    try {
        ServerListPingEvent event = new GeyserPingEvent(InetAddress.getLocalHost(), Bukkit.getMotd(), Bukkit.getOnlinePlayers().size(), Bukkit.getMaxPlayers());
        Bukkit.getPluginManager().callEvent(event);
        GeyserPingInfo geyserPingInfo = new GeyserPingInfo(event.getMotd(), event.getNumPlayers(), event.getMaxPlayers());
        Bukkit.getOnlinePlayers().forEach(player -> {
            geyserPingInfo.addPlayer(player.getName());
        });
        return geyserPingInfo;
    } catch (Exception e) {
        logger.debug("Error while getting Bukkit ping passthrough: " + e.toString());
        return new GeyserPingInfo(null, 0, 0);
    }
}
 

@EventHandler(priority = EventPriority.HIGHEST)
public void onServerListPing(ServerListPingEvent event) {
  final String format = PGM.get().getConfiguration().getMotd();
  if (format == null || format.isEmpty()) return;

  event.setMotd(MessageFormat.format(format, event.getMotd(), mapName, phaseColor.toString()));
}
 

@EventHandler
public void onServerListPing(ServerListPingEvent event) {
  if (!ready.get() || legacySportPaper.get()) return;

  // Remove vanished players from player sample/ping count
  Iterator<Player> playerSample = event.iterator();
  while (playerSample.hasNext()) {
    Player player = playerSample.next();
    if (vanishManager.isVanished(player.getUniqueId())) {
      playerSample.remove();
    }
  }

  try {
    JsonObject root = event.getOrCreateExtra(PGM.get());
    this.matchManager
        .getMatches()
        .forEachRemaining(
            match -> {
              String matchId = match.getId();
              try {
                root.add(matchId, this.matchCache.get(match));
              } catch (ExecutionException e) {
                this.logger.log(
                    Level.SEVERE, "Could not load server ping data for match: " + matchId, e);
              }
            });
  } catch (NoSuchMethodError ex) {
    legacySportPaper.compareAndSet(false, true);
  }
}
 

@EventHandler(priority = EventPriority.HIGHEST)
public void onPing(ServerListPingEvent event){
	GameManager gm = GameManager.getGameManager();

	if (gm == null){
		return; // Still loading
	}

	if (gm.getConfiguration().getDisableMotd()){
		return; // No motd support
	}

	// Display motd
	switch(gm.getGameState()){
		case ENDED:
			event.setMotd(Lang.DISPLAY_MOTD_ENDED);
			break;
		case LOADING:
			event.setMotd(Lang.DISPLAY_MOTD_LOADING);
			break;
		case DEATHMATCH:
		case PLAYING:
			event.setMotd(Lang.DISPLAY_MOTD_PLAYING);
			break;
		case STARTING:
			event.setMotd(Lang.DISPLAY_MOTD_STARTING);
			break;
		case WAITING:
			event.setMotd(Lang.DISPLAY_MOTD_WAITING);
			break;
		default:
			event.setMotd(Lang.DISPLAY_MESSAGE_PREFIX);
			break;
	}
}
 

@SuppressWarnings({"unchecked", "null"})
@Override
public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
	boolean isServerPingEvent = ScriptLoader.isCurrentEvent(ServerListPingEvent.class) ||
			(PAPER_EVENT_EXISTS && ScriptLoader.isCurrentEvent(PaperServerListPingEvent.class));
	if (parseResult.mark == 2 && !isServerPingEvent) {
		Skript.error("The 'shown' MOTD expression can't be used outside of a server list ping event");
		return false;
	}
	isDefault = (parseResult.mark == 0 && !isServerPingEvent) || parseResult.mark == 1;
	return true;
}
 

@Override
@Nullable
public String[] get(Event e) {
	if (isDefault)
		return CollectionUtils.array(Bukkit.getMotd());
	else
		return CollectionUtils.array(((ServerListPingEvent) e).getMotd());
}
 

@SuppressWarnings("null")
@Override
public void change(Event e, @Nullable Object[] delta, ChangeMode mode) {
	ServerListPingEvent event = (ServerListPingEvent) e;
	switch (mode) {
		case SET:
			event.setMotd((String) delta[0]);
			break;
		case DELETE:
			event.setMotd("");
			break;
		case RESET:
			event.setMotd(Bukkit.getMotd());
	}
}
 

@SuppressWarnings({"null", "unchecked"})
@Override
public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
	isProperty = matchedPattern < 2;
	isConnectEvent = ScriptLoader.isCurrentEvent(PlayerLoginEvent.class);
	boolean isServerPingEvent = ScriptLoader.isCurrentEvent(ServerListPingEvent.class) ||
			(PAPER_EVENT_EXISTS && ScriptLoader.isCurrentEvent(PaperServerListPingEvent.class));
	if (isProperty) {
		players = (Expression<Player>) exprs[0];
	} else if (!isConnectEvent && !isServerPingEvent) {
		Skript.error("You must specify players whose IP addresses to get outside of server list ping and connect events.");
		return false;
	}
	return true;
}
 

@Override
public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
	if (ScriptLoader.isCurrentEvent(ServerListPingEvent.class)) {
		Skript.error("The version string expression requires Paper 1.12.2 or newer");
		return false;
	} else if (!(PAPER_EVENT_EXISTS && ScriptLoader.isCurrentEvent(PaperServerListPingEvent.class))) {
		Skript.error("The version string expression can't be used outside of a server list ping event");
		return false;
	}
	return true;
}
 

@Override
public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
	boolean isPaperEvent = PAPER_EVENT_EXISTS && ScriptLoader.isCurrentEvent(PaperServerListPingEvent.class);
	if (parseResult.mark == 2) {
		if (ScriptLoader.isCurrentEvent(ServerListPingEvent.class)) {
			Skript.error("The 'fake' online players count expression requires Paper 1.12.2 or newer");
			return false;
		} else if (!isPaperEvent) {
			Skript.error("The 'fake' online players count expression can't be used outside of a server list ping event");
			return false;
		}
	}
	isReal = (parseResult.mark == 0 && !isPaperEvent) || parseResult.mark == 1;
	return true;
}
 

@SuppressWarnings({"unchecked", "null"})
@Override
public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, SkriptParser.ParseResult parseResult) {
	boolean isServerPingEvent = ScriptLoader.isCurrentEvent(ServerListPingEvent.class) ||
			(PAPER_EVENT_EXISTS && ScriptLoader.isCurrentEvent(PaperServerListPingEvent.class));
	if (parseResult.mark == 2 && !isServerPingEvent) {
		Skript.error("The 'shown' max players count expression can't be used outside of a server list ping event");
		return false;
	}
	isReal = (parseResult.mark == 0 && !isServerPingEvent) || parseResult.mark == 1;
	return true;
}
 

@Override
@Nullable
public Number[] get(Event e) {
	if (isReal)
		return CollectionUtils.array(Bukkit.getMaxPlayers());
	else
		return CollectionUtils.array(((ServerListPingEvent) e).getMaxPlayers());
}
 

@SuppressWarnings({"unchecked", "null"})
@Override
public boolean init(Expression<?>[] exprs, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
	boolean isServerPingEvent = ScriptLoader.isCurrentEvent(ServerListPingEvent.class) ||
			(PAPER_EVENT_EXISTS && ScriptLoader.isCurrentEvent(PaperServerListPingEvent.class));
	if (!isServerPingEvent) {
		Skript.error("The hide player from server list effect can't be used outside of a server list ping event");
		return false;
	} else if (isDelayed == Kleenean.TRUE) {
		Skript.error("Can't hide players from the server list anymore after the server list ping event has already passed");
		return false;
	}
	players = (Expression<Player>) exprs[0];
	return true;
}
 

@EventHandler(priority=EventPriority.HIGHEST, ignoreCancelled=true)
public void pingServer(ServerListPingEvent event)
{
	if(GameVars.useMOTD())
	{
		if(Game.getGameMap() == null || Game.getGameMap().getCurrentPhase() < 1)
			event.setMotd("In Lobby");
		else event.setMotd("Phase "+Game.getGameMap().getCurrentPhase());
	}
}
 

@Override
@EventHandler
public void onServerListPing(ServerListPingEvent event) {
    if (event instanceof PaperServerListPingEvent) {
        handlePaperServerListPing((PaperServerListPingEvent) event);
    } else {
        // Still handle events that don't implement PaperServerListPingEvent
        super.onServerListPing(event);
    }
}
 

/**
 * Server methods
 */
public static ServerListPingEvent callServerListPingEvent(Server craftServer, InetAddress address, String motd, int numPlayers, int maxPlayers) {
    ServerListPingEvent event = new ServerListPingEvent(address, motd, numPlayers, maxPlayers);
    craftServer.getPluginManager().callEvent(event);
    return event;
}
 

private void enableTasks() {
    Bukkit.getScheduler().runTask(this, new Runnable() {
        @Override
        public void run() {
            if (CloudServer.getInstance().getGroupData() != null) {
                if (CloudAPI.getInstance()
                            .getServerGroupData(CloudAPI.getInstance().getGroup())
                            .getMode()
                            .equals(ServerGroupMode.LOBBY) || CloudAPI.getInstance()
                                                                      .getServerGroupData(CloudAPI.getInstance()
                                                                                                  .getGroup())
                                                                      .getMode()
                                                                      .equals(ServerGroupMode.STATIC_LOBBY)) {
                    CommandCloudServer server = new CommandCloudServer();

                    getCommand("cloudserver").setExecutor(server);
                    getCommand("cloudserver").setPermission("cloudnet.command.cloudserver");
                    getCommand("cloudserver").setTabCompleter(server);
                }

                Bukkit.getPluginManager().callEvent(new BukkitCloudServerInitEvent(CloudServer.getInstance()));
                CloudServer.getInstance().update();

                if (CloudAPI.getInstance()
                            .getServerGroupData(CloudAPI.getInstance().getGroup())
                            .getAdvancedServerConfig()
                            .isDisableAutoSavingForWorlds()) {
                    for (World world : Bukkit.getWorlds()) {
                        world.setAutoSave(false);
                    }
                }
            }

            if (CloudServer.getInstance().getGroupData() != null) {
                getServer().getScheduler().runTaskTimer(BukkitBootstrap.this, new Runnable() {
                    @Override
                    public void run() {
                        try {
                            ServerListPingEvent serverListPingEvent = new ServerListPingEvent(new InetSocketAddress("127.0.0.1",
                                                                                                                    53345).getAddress(),
                                                                                              CloudServer.getInstance().getMotd(),
                                                                                              Bukkit.getOnlinePlayers().size(),
                                                                                              CloudServer.getInstance()
                                                                                                         .getMaxPlayers());
                            Bukkit.getPluginManager().callEvent(serverListPingEvent);
                            if (!serverListPingEvent.getMotd().equalsIgnoreCase(CloudServer.getInstance()
                                                                                           .getMotd()) || serverListPingEvent.getMaxPlayers() != CloudServer
                                .getInstance()
                                .getMaxPlayers()) {
                                CloudServer.getInstance().setMotd(serverListPingEvent.getMotd());
                                CloudServer.getInstance().setMaxPlayers(serverListPingEvent.getMaxPlayers());
                                if (serverListPingEvent.getMotd().toLowerCase().contains("running") || serverListPingEvent.getMotd()
                                                                                                                          .toLowerCase()
                                                                                                                          .contains(
                                                                                                                              "ingame")) {
                                    CloudServer.getInstance().changeToIngame();
                                } else {
                                    CloudServer.getInstance().update();
                                }
                            }
                        } catch (Exception ex) {
                        }
                    }
                }, 0, 5);
            }

            if (CloudAPI.getInstance().getPermissionPool() != null && (getServer().getPluginManager()
                                                                                  .isPluginEnabled("VaultAPI") || getServer().getPluginManager()
                                                                                                                             .isPluginEnabled(
                                                                                                                                 "Vault"))) {
                try {
                    Class.forName("de.dytanic.cloudnet.bridge.vault.VaultInvoker").getMethod("invoke").invoke(null);
                } catch (IllegalAccessException | ClassNotFoundException | NoSuchMethodException | InvocationTargetException e) {
                    e.printStackTrace();
                }
            }
        }
    });
}
 

@EventHandler
private void onPing(ServerListPingEvent event) {
    event.getExtra().put("pgm", new Info());
}
 

@Override
protected void execute(Event e) {
	Iterator<Player> it = ((ServerListPingEvent) e).iterator();		
	Iterators.removeAll(it, Arrays.asList(players.getArray(e)));
}
 

/**
 * Server methods
 */
public static ServerListPingEvent callServerListPingEvent(Server craftServer, InetAddress address, String motd, int numPlayers, int maxPlayers) {
    ServerListPingEvent event = new ServerListPingEvent(address, motd, numPlayers, maxPlayers);
    craftServer.getPluginManager().callEvent(event);
    return event;
}
 

/**
 * Injects a DuplexHandler into each NetworkManager's pipeline when the server receives a ping packet
 * @param event The event
 */
@EventHandler
public void serverListPing(ServerListPingEvent event) {
	this.injectOpenConnections();
}
 

/**
 * Injects a DuplexHandler into each NetworkManager's pipeline when the server receives a ping packet
 * @param event The event
 */
@EventHandler
public void serverListPing(ServerListPingEvent event) {
	this.injectOpenConnections();
}
 

/**
 * Injects a DuplexHandler into each NetworkManager's pipeline when the server receives a ping packet
 * @param event The event
 */
@EventHandler
public void serverListPing(ServerListPingEvent event) {
	this.injectOpenConnections();
}
 

/**
 * Injects a DuplexHandler into each NetworkManager's pipeline when the server receives a ping packet
 * @param event The event
 */
@EventHandler
public void serverListPing(ServerListPingEvent event) {
	this.injectOpenConnections();
}
 

/**
 * Injects a DuplexHandler into each NetworkManager's pipeline when the server receives a ping packet
 * @param event The event
 */
@EventHandler
public void serverListPing(ServerListPingEvent event) {
	this.injectOpenConnections();
}
 

/**
 * Injects a DuplexHandler into each NetworkManager's pipeline when the server receives a ping packet
 * @param event The event
 */
@EventHandler
public void serverListPing(ServerListPingEvent event) {
	this.injectOpenConnections();
}
 

/**
 * Injects a DuplexHandler into each NetworkManager's pipeline when the server receives a ping packet
 * @param event The event
 */
@EventHandler
public void serverListPing(ServerListPingEvent event) {
	this.injectOpenConnections();
}