private void tryKickPlayer(String message, Player player, PlayerLoginEvent event) {
    Optional<PlaceholderAPIHook> placeholderapi;
    try {
        placeholderapi = ServiceLocator.getOptional(PlaceholderAPIHook.class);
    } catch (InstantiationException | IllegalAccessException ex) {
        logger.error(ex.getMessage(), ex);
        placeholderapi = Optional.empty();
    }

    event.setResult(PlayerLoginEvent.Result.KICK_OTHER);

    if (placeholderapi.isPresent()) {
        event.setKickMessage(placeholderapi.get().withPlaceholders(player, message));
    } else {
        event.setKickMessage(message);
    }
}
 

@EventHandler(priority = EventPriority.LOWEST)
public void onPlayerLogin(UserLoginEvent event) {
    TeamManager teamManager = teamManagerProvider.get();

    Entrant participation = teamManager.getEntrant(event.getUser());
    if(participation == null) return;

    final int playerCount = (int) onlinePlayers.all()
                                               .stream()
                                               .filter(player -> !player.equals(event.getPlayer()) &&
                                                                 participation.members().contains(userStore.playerId(player)))
                                               .count();

    int maxPlayers = tournament.max_players_per_match();
    if(playerCount >= maxPlayers) {
        event.disallow(PlayerLoginEvent.Result.KICK_WHITELIST, new Component(new TranslatableComponent("tourney.kick.maxPlayers", String.valueOf(maxPlayers)), ChatColor.RED));
    } else {
        if(event.getResult().equals(PlayerLoginEvent.Result.KICK_WHITELIST)) {
            event.allow(); // explicitly allow players on teams but not whitelist
        }
    }
}
 

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

	// Player is not allowed to join so don't create UhcPlayer. (Server full, whitelist, ban, ...)
	if (event.getResult() != Result.ALLOWED){
		return;
	}
	
	try{
		boolean allowedToJoin = gm.getPlayersManager().isPlayerAllowedToJoin(event.getPlayer());

		if (allowedToJoin){
			// Create player if not existent.
			gm.getPlayersManager().getOrCreateUhcPlayer(event.getPlayer());
		}else{
			throw new UhcPlayerJoinException("An unexpected error as occured.");
		}
	}catch(final UhcPlayerJoinException e){
		event.setKickMessage(e.getMessage());
		event.setResult(Result.KICK_OTHER);
	}
}
 

@SuppressWarnings("null")
@Override
public boolean init(final Expression<?>[] vars, final int matchedPattern, final Kleenean isDelayed, final ParseResult parser) {
	if (isDelayed == Kleenean.TRUE) {
		Skript.error("Can't cancel an event anymore after it has already passed", ErrorQuality.SEMANTIC_ERROR);
		return false;
	}
	cancel = matchedPattern == 0;
	final Class<? extends Event>[] es = ScriptLoader.getCurrentEvents();
	if (es == null)
		return false;
	for (final Class<? extends Event> e : es) {
		if (Cancellable.class.isAssignableFrom(e) || BlockCanBuildEvent.class.isAssignableFrom(e))
			return true; // TODO warning if some event(s) cannot be cancelled even though some can (needs a way to be suppressed)
	}
	if (ScriptLoader.isCurrentEvent(PlayerLoginEvent.class))
		Skript.error("A connect event cannot be cancelled, but the player may be kicked ('kick player by reason of \"...\"')", ErrorQuality.SEMANTIC_ERROR);
	else
		Skript.error(Utils.A(ScriptLoader.getCurrentEventName()) + " event cannot be cancelled", ErrorQuality.SEMANTIC_ERROR);
	return false;
}
 

@EventHandler(priority = EventPriority.LOW)
//run this on the loginEvent to let skins plugins see the skin like in normal Minecraft behaviour
public void onPlayerLogin(PlayerLoginEvent loginEvent) {
    if (loginEvent.getResult() != Result.ALLOWED) {
        return;
    }

    Player player = loginEvent.getPlayer();

    if (plugin.getConfig().getBoolean("forwardSkin")) {
        //go through every session, because player.getAddress is null
        //loginEvent.getAddress is just a InetAddress not InetSocketAddress, so not unique enough
        for (BukkitLoginSession session : plugin.getLoginSessions().values()) {
            if (session.getUsername().equals(player.getName())) {
                session.getSkin().ifPresent(skin -> applySkin(player, skin.getValue(), skin.getSignature()));
                break;
            }
        }
    }
}
 

@EventHandler(priority = EventPriority.HIGHEST)
public void onPlayerLogin(PlayerLoginEvent loginEvent) {
    if (loginEvent.getResult() != PlayerLoginEvent.Result.ALLOWED) {
        //in this event isCancelled option in the annotation doesn't work
        return;
    }

    Player player = loginEvent.getPlayer();

    //updates to the chosen one
    UserPreference preferences = plugin.getLoginSession(player.getUniqueId());
    if (preferences != null) {
        preferences.getTargetSkin().ifPresent(skin -> plugin.getApi().applySkin(player, skin));
    }

    plugin.endSession(player.getUniqueId());
}
 

@EventHandler(priority = EventPriority.LOW)
public void onPlayerLogin(PlayerLoginEvent event) {
    final Player player = event.getPlayer();
    final String name = player.getName();

    try {
        onJoinVerifier.checkSingleSession(name);
    } catch (FailedVerificationException e) {
        event.setKickMessage(messages.retrieveSingle(name, e.getReason(), e.getArgs()));
        event.setResult(PlayerLoginEvent.Result.KICK_OTHER);
        return;
    }

    if (validationService.isUnrestricted(name)) {
        return;
    }

    onJoinVerifier.refusePlayerForFullServer(event);
}
 

@Test
public void shouldNotInterfereWithUnrestrictedUser() throws FailedVerificationException {
    // given
    String name = "Player01";
    Player player = mockPlayerWithName(name);
    PlayerLoginEvent event = spy(new PlayerLoginEvent(player, "", null));
    given(validationService.isUnrestricted(name)).willReturn(true);

    // when
    listener.onPlayerLogin(event);

    // then
    verify(validationService).isUnrestricted(name);
    verify(onJoinVerifier).checkSingleSession(name);
    verifyNoModifyingCalls(event);
    verifyNoMoreInteractions(onJoinVerifier);
}
 

@Test
public void shouldStopHandlingForFullServer() throws FailedVerificationException {
    // given
    String name = "someone";
    Player player = mockPlayerWithName(name);
    PlayerLoginEvent event = spy(new PlayerLoginEvent(player, "", null));
    given(validationService.isUnrestricted(name)).willReturn(false);
    given(onJoinVerifier.refusePlayerForFullServer(event)).willReturn(true);

    // when
    listener.onPlayerLogin(event);

    // then
    verify(validationService).isUnrestricted(name);
    verify(onJoinVerifier).checkSingleSession(name);
    verify(onJoinVerifier).refusePlayerForFullServer(event);
    verifyNoMoreInteractions(onJoinVerifier);
    verifyNoModifyingCalls(event);
}
 

@Test
public void shouldStopHandlingEventForBadResult() throws FailedVerificationException {
    // given
    String name = "someone";
    Player player = mockPlayerWithName(name);
    PlayerLoginEvent event = new PlayerLoginEvent(player, "", null);
    event.setResult(PlayerLoginEvent.Result.KICK_BANNED);
    event = spy(event);
    given(validationService.isUnrestricted(name)).willReturn(false);
    given(onJoinVerifier.refusePlayerForFullServer(event)).willReturn(false);

    // when
    listener.onPlayerLogin(event);

    // then
    verify(validationService).isUnrestricted(name);
    verify(onJoinVerifier).checkSingleSession(name);
    verify(onJoinVerifier).refusePlayerForFullServer(event);
    verifyNoModifyingCalls(event);
}
 

@Test
public void shouldPerformAllJoinVerificationsSuccessfullyLogin() {
    // given
    String name = "someone";
    Player player = mockPlayerWithName(name);
    String ip = "12.34.56.78";

    PlayerLoginEvent loginEvent = spy(new PlayerLoginEvent(player, "", mockAddrWithIp(ip)));
    given(validationService.isUnrestricted(name)).willReturn(false);
    given(onJoinVerifier.refusePlayerForFullServer(loginEvent)).willReturn(false);

    // when
    listener.onPlayerLogin(loginEvent);

    // then
    verify(validationService).isUnrestricted(name);
    verify(onJoinVerifier).refusePlayerForFullServer(loginEvent);
    verifyNoInteractions(dataSource);
    verifyNoModifyingCalls(loginEvent);
}
 

@Test
public void shouldRefuseNonVipPlayerForFullServer() {
    // given
    Player player = mock(Player.class);
    PlayerLoginEvent event = new PlayerLoginEvent(player, "hostname", null);
    event.setResult(PlayerLoginEvent.Result.KICK_FULL);
    given(permissionsManager.hasPermission(player, PlayerStatePermission.IS_VIP)).willReturn(false);
    String serverFullMessage = "server is full";
    given(messages.retrieveSingle(player, MessageKey.KICK_FULL_SERVER)).willReturn(serverFullMessage);

    // when
    boolean result = onJoinVerifier.refusePlayerForFullServer(event);

    // then
    assertThat(result, equalTo(true));
    assertThat(event.getResult(), equalTo(PlayerLoginEvent.Result.KICK_FULL));
    assertThat(event.getKickMessage(), equalTo(serverFullMessage));
    verifyNoInteractions(bukkitService, dataSource);
}
 

@Test
public void shouldKickNonVipForJoiningVipPlayer() {
    // given
    Player player = mock(Player.class);
    PlayerLoginEvent event = new PlayerLoginEvent(player, "hostname", null);
    event.setResult(PlayerLoginEvent.Result.KICK_FULL);
    given(permissionsManager.hasPermission(player, PlayerStatePermission.IS_VIP)).willReturn(true);
    List<Player> onlinePlayers = Arrays.asList(mock(Player.class), mock(Player.class));
    given(permissionsManager.hasPermission(onlinePlayers.get(0), PlayerStatePermission.IS_VIP)).willReturn(true);
    given(permissionsManager.hasPermission(onlinePlayers.get(1), PlayerStatePermission.IS_VIP)).willReturn(false);
    given(bukkitService.getOnlinePlayers()).willReturn(onlinePlayers);
    given(server.getMaxPlayers()).willReturn(onlinePlayers.size());
    given(messages.retrieveSingle(player, MessageKey.KICK_FOR_VIP)).willReturn("kick for vip");

    // when
    boolean result = onJoinVerifier.refusePlayerForFullServer(event);

    // then
    assertThat(result, equalTo(false));
    assertThat(event.getResult(), equalTo(PlayerLoginEvent.Result.ALLOWED));
    // First player is VIP, so expect no interactions there and second player to have been kicked
    verifyNoInteractions(onlinePlayers.get(0));
    verify(onlinePlayers.get(1)).kickPlayer("kick for vip");
}
 

@Test
public void shouldKickVipPlayerIfNoPlayerCanBeKicked() {
    // given
    Player player = mock(Player.class);
    PlayerLoginEvent event = new PlayerLoginEvent(player, "hostname", null);
    event.setResult(PlayerLoginEvent.Result.KICK_FULL);
    given(permissionsManager.hasPermission(player, PlayerStatePermission.IS_VIP)).willReturn(true);
    List<Player> onlinePlayers = Collections.singletonList(mock(Player.class));
    given(permissionsManager.hasPermission(onlinePlayers.get(0), PlayerStatePermission.IS_VIP)).willReturn(true);
    given(bukkitService.getOnlinePlayers()).willReturn(onlinePlayers);
    given(server.getMaxPlayers()).willReturn(onlinePlayers.size());
    given(messages.retrieveSingle(player, MessageKey.KICK_FULL_SERVER)).willReturn("kick full server");

    // when
    boolean result = onJoinVerifier.refusePlayerForFullServer(event);

    // then
    assertThat(result, equalTo(true));
    assertThat(event.getResult(), equalTo(PlayerLoginEvent.Result.KICK_FULL));
    assertThat(event.getKickMessage(), equalTo("kick full server"));
    verifyNoInteractions(onlinePlayers.get(0));
}
 

@EventHandler(priority = EventPriority.MONITOR)
public void onPreJoin(PlayerLoginEvent event) {
  Player player = event.getPlayer();
  loginSubdomains.invalidate(player.getUniqueId());
  if (player.hasPermission(Permissions.VANISH)
      && !isVanished(player.getUniqueId())
      && isVanishSubdomain(event.getHostname())) {
    loginSubdomains.put(player.getUniqueId(), event.getHostname());
  }
}
 

@EventHandler(priority = EventPriority.LOWEST)
public void onPreLogin(PlayerLoginEvent event) {
  // Format kick screen for banned players
  if (event.getResult().equals(Result.KICK_BANNED)) {
    String formatted =
        getPunishmentScreenFromName(event.getPlayer(), event.getPlayer().getName());
    if (formatted != null) {
      event.setKickMessage(formatted);
    }
  }
}
 

@EventHandler
public void onPlayerLogin(final PlayerLoginEvent event) {
  // allow premiums to join when the server is full
  if (event.getResult() == Result.KICK_FULL) {
    if (event.getPlayer().hasPermission(Permissions.JOIN_FULL)) {
      event.allow();
    } else {
      event.setKickMessage(TextTranslations.translate("misc.serverFull", event.getPlayer()));
    }
  }
}
 

public PlayerEvents(Plugin plugin) {
    events.add(
            BukkitEvents.subscribe(plugin, AsyncPlayerPreLoginEvent.class, EventPriority.HIGH)
                    .handler(this::cachePlayer)
    );

    events.add(
            BukkitEvents.subscribe(plugin, PlayerLoginEvent.class, EventPriority.LOWEST)
                    .handler(this::checkPlayer)
    );
}
 

@EventHandler
public void onJoin(PlayerLoginEvent e) {
    BanEntry entry = getBanInfo(e.getPlayer().getUniqueId());
    if (entry == null)
        return;
    if (entry.expireTime <= System.currentTimeMillis()) {
        pardon(e.getPlayer().getUniqueId());
        return;
    }
    e.disallow(PlayerLoginEvent.Result.KICK_BANNED, ChatColor.translateAlternateColorCodes('&', entry.reason));
}
 

@Override
public void setup(@Nonnull TerminableConsumer consumer) {
    try (Connection c = this.sql.getConnection()) {
        try (Statement s = c.createStatement()) {
            s.execute(replaceTableName(CREATE));
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }

    // preload data
    if (this.preloadAmount > 0) {
        Log.info("[helper-profiles] Preloading the most recent " + this.preloadAmount + " entries...");
        long start = System.currentTimeMillis();
        int found = preload(this.preloadAmount);
        long time = System.currentTimeMillis() - start;
        Log.info("[helper-profiles] Preloaded " + found + " profiles into the cache! - took " + time + "ms");
    }

    // observe logins
    Events.subscribe(PlayerLoginEvent.class, EventPriority.MONITOR)
            .filter(e -> e.getResult() == PlayerLoginEvent.Result.ALLOWED)
            .handler(e -> {
                ImmutableProfile profile = new ImmutableProfile(e.getPlayer().getUniqueId(), e.getPlayer().getName());
                updateCache(profile);
                Schedulers.async().run(() -> saveProfile(profile));
            })
            .bindWith(consumer);
}
 

@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerLogin(PlayerLoginEvent event) {
    try {
        PlayerLoginEvent.Result result = event.getResult();
        UUID playerUUID = event.getPlayer().getUniqueId();
        boolean operator = event.getPlayer().isOp();
        boolean banned = result == PlayerLoginEvent.Result.KICK_BANNED;
        dbSystem.getDatabase().executeTransaction(new BanStatusTransaction(playerUUID, () -> banned));
        dbSystem.getDatabase().executeTransaction(new OperatorStatusTransaction(playerUUID, operator));
    } catch (Exception e) {
        errorLogger.log(L.ERROR, e, ErrorContext.builder().related(event, event.getResult()).build());
    }
}
 

@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
protected void execute(final Event e) {
	final String r = reason != null ? reason.getSingle(e) : "";
	if (r == null)
		return;
	for (final Player p : players.getArray(e)) {
		if (e instanceof PlayerLoginEvent && p.equals(((PlayerLoginEvent) e).getPlayer()) && !Delay.isDelayed(e)) {
			((PlayerLoginEvent) e).disallow(Result.KICK_OTHER, r);
		} else if (e instanceof PlayerKickEvent && p.equals(((PlayerKickEvent) e).getPlayer()) && !Delay.isDelayed(e)) {
			((PlayerKickEvent) e).setLeaveMessage(r);
		} else {
			p.kickPlayer(r);
		}
	}
}
 

@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerLoginMonitor(PlayerLoginEvent e) {
    /* Listen to see if the event was cancelled after we initially handled the login
       If the connection was cancelled here, we need to do something to clean up the data that was loaded. */

    // Check to see if this connection was denied at LOW. Even if it was denied at LOW, their data will still be present.
    if (this.deniedLogin.remove(e.getPlayer().getUniqueId())) {
        // This is a problem, as they were denied at low priority, but are now being allowed.
        if (e.getResult() == PlayerLoginEvent.Result.ALLOWED) {
            this.plugin.getLogger().severe("Player connection was re-allowed for " + e.getPlayer().getUniqueId());
            e.disallow(PlayerLoginEvent.Result.KICK_OTHER, "");
        }
    }
}
 

@EventHandler(priority = EventPriority.LOW)
public void onLogin(PlayerLoginEvent event)
{
    if(isTagged(event.getPlayer().getUniqueId()))
    {
        Boolean b = taggedPlayers.get(event.getPlayer().getUniqueId()).wasKilled();
        if(b == null)
        {
            event.setResult(Result.KICK_OTHER);
            event.setKickMessage(Lang.NPCALIVE.toString());
        }
    }
}
 

@EventHandler
public void onPlayerLogin(PlayerLoginEvent event) {

    if (!event.getPlayer().hasPermission("elitemobs.versionnotification")) return;

    new BukkitRunnable() {
        @Override
        public void run() {
            event.getPlayer().sendMessage(ChatColorConverter.convert("&a[EliteMobs] &cYour version of EliteMobs is outdated." +
                    " &aYou can download the latest version from &3&n&ohttps://www.spigotmc.org/resources/%E2%9A%94elitemobs%E2%9A%94.40090/"));
        }
    }.runTaskLater(MetadataHandler.PLUGIN, 20*3);


}
 

@EventHandler
public void playerLogin(PlayerLoginEvent event) {
    new BukkitRunnable() {
        @Override
        public void run() {
            if (!PlayerData.playerMaxGuildRank.containsKey(event.getPlayer().getUniqueId())) return;
            if (PlayerData.playerMaxGuildRank.get(event.getPlayer().getUniqueId()) < 11) return;

            event.getPlayer().getAttribute(Attribute.GENERIC_MAX_HEALTH).setBaseValue((PlayerData.playerMaxGuildRank.get(event.getPlayer().getUniqueId()) - 10) * 2 + 20);

        }
    }.runTaskLater(MetadataHandler.PLUGIN, 5);
}
 

@EventHandler(priority = EventPriority.LOWEST)
public void onEventLowest(PlayerLoginEvent event) {
    if (!event.getResult().equals(PlayerLoginEvent.Result.ALLOWED)) {
        DiscordSRV.debug("PlayerLoginEvent event result for " + event.getPlayer().getName() + " = " + event.getResult() + ", skipping");
        return;
    }
    check(event.getClass().getSimpleName(), EventPriority.LOWEST, event.getPlayer().getName(), event.getPlayer().getUniqueId(), event.getAddress().getHostAddress(), (result, message) -> event.disallow(PlayerLoginEvent.Result.valueOf(result), message));
}
 

@EventHandler(priority = EventPriority.LOW)
public void onEventLow(PlayerLoginEvent event) {
    if (!event.getResult().equals(PlayerLoginEvent.Result.ALLOWED)) {
        DiscordSRV.debug("PlayerLoginEvent event result for " + event.getPlayer().getName() + " = " + event.getResult() + ", skipping");
        return;
    }
    check(event.getClass().getSimpleName(), EventPriority.LOW, event.getPlayer().getName(), event.getPlayer().getUniqueId(), event.getAddress().getHostAddress(), (result, message) -> event.disallow(PlayerLoginEvent.Result.valueOf(result), message));
}
 

@EventHandler(priority = EventPriority.NORMAL)
public void onEventNormal(PlayerLoginEvent event) {
    if (!event.getResult().equals(PlayerLoginEvent.Result.ALLOWED)) {
        DiscordSRV.debug("PlayerLoginEvent event result for " + event.getPlayer().getName() + " = " + event.getResult() + ", skipping");
        return;
    }
    check(event.getClass().getSimpleName(), EventPriority.NORMAL, event.getPlayer().getName(), event.getPlayer().getUniqueId(), event.getAddress().getHostAddress(), (result, message) -> event.disallow(PlayerLoginEvent.Result.valueOf(result), message));
}