Added plugin API

proxy/src/main/java/com/glyart/authmevelocity/proxy/AuthMeVelocityPlugin.java

@@ -19,23 +19,25 @@ import java.util.List;
 import java.util.UUID;
 
 public class AuthMeVelocityPlugin {
-    private final ProxyServer server;
+    private static ProxyServer proxy;
     private final Logger logger;
     private static Yaml config = new Yaml("config", "plugins/AuthmeVelocity");
 
-    public final List<UUID> loggedPlayers = Collections.synchronizedList(new ArrayList<>());
+    protected static final List<UUID> loggedPlayers = Collections.synchronizedList(new ArrayList<>());
 
     @Inject
     public AuthMeVelocityPlugin(ProxyServer server, Logger logger) {
-        this.server = server;
+        proxy = server;
         this.logger = logger;
     }
 
     @Subscribe
     public void onProxyInitialize(ProxyInitializeEvent event) {
-        server.getChannelRegistrar().register(new LegacyChannelIdentifier("authmevelocity:main"), MinecraftChannelIdentifier.create("authmevelocity", "main"));
+        proxy.getChannelRegistrar().register(
-        server.getEventManager().register(this, new ProxyListener(this, server));
+            new LegacyChannelIdentifier("authmevelocity:main"),
-        server.getEventManager().register(this, new FastLoginListener(this, server));
+            MinecraftChannelIdentifier.create("authmevelocity", "main"));
+        proxy.getEventManager().register(this, new ProxyListener(proxy));
+        proxy.getEventManager().register(this, new FastLoginListener(proxy));
         AuthMeConfig.defaultConfig();
         logger.info("AuthMeVelocity enabled");
         logger.info("AuthServers: " + config.getList("authservers"));
@@ -44,4 +46,8 @@ public class AuthMeVelocityPlugin {
     public static Yaml getConfig(){
         return config;
     }
+
+    protected static ProxyServer getProxy(){
+        return proxy;
+    }
 }

proxy/src/main/java/com/glyart/authmevelocity/proxy/AuthmeVelocityAPI.java

@@ -0,0 +1,51 @@
+package com.glyart.authmevelocity.proxy;
+
+import java.util.UUID;
+import java.util.function.Predicate;
+
+import com.velocitypowered.api.proxy.Player;
+
+public class AuthmeVelocityAPI {
+    /**
+     * Check if the player is logged in or not
+     * @param player the player
+     * @return if the player is logged in or not
+     */
+    public static boolean isLogged(Player player){
+        final UUID playerUUID = player.getUniqueId();
+        return AuthMeVelocityPlugin.loggedPlayers.contains(playerUUID);
+    }
+
+    /**
+     * Adds a player to the list of logged in players
+     * @param player the new logged player
+     */
+    public static void addPlayer(Player player){
+        final UUID playerUUID = player.getUniqueId();
+        if(!AuthmeVelocityAPI.isLogged(player)){
+            AuthMeVelocityPlugin.loggedPlayers.add(playerUUID);
+        }
+    }
+
+    /**
+     * Removes a player from the list of logged-in players
+     * @param player the unlogged player
+     */
+    public static void removePlayer(Player player){
+        final UUID playerUUID = player.getUniqueId();
+        if(AuthmeVelocityAPI.isLogged(player)){
+            AuthMeVelocityPlugin.loggedPlayers.remove(playerUUID);
+        }
+    }
+
+    /**
+     * Removes players who meet the established condition
+     * @param predicate the condition
+     */
+    public static void removePlayerIf(Predicate<Player> predicate){
+        AuthMeVelocityPlugin.loggedPlayers.stream()
+            .map(uuid -> AuthMeVelocityPlugin.getProxy().getPlayer(uuid).orElse(null))
+            .filter(predicate)
+            .forEach(player -> AuthMeVelocityPlugin.loggedPlayers.remove(player.getUniqueId()));
+    }
+}

proxy/src/main/java/com/glyart/authmevelocity/proxy/event/ProxyLoginEvent.java

@@ -3,6 +3,9 @@ package com.glyart.authmevelocity.proxy.event;
 import com.velocitypowered.api.proxy.Player;
 import com.velocitypowered.api.proxy.server.RegisteredServer;
 
+/**
+ * Event executed in case the player is successfully logged in
+ */
 public class ProxyLoginEvent {
 
     private final Player player;

proxy/src/main/java/com/glyart/authmevelocity/proxy/listener/FastLoginListener.java

@@ -1,29 +1,23 @@
 package com.glyart.authmevelocity.proxy.listener;
 
 import java.util.Optional;
-import java.util.UUID;
 
 import com.github.games647.fastlogin.velocity.event.VelocityFastLoginAutoLoginEvent;
-import com.glyart.authmevelocity.proxy.AuthMeVelocityPlugin;
+import com.glyart.authmevelocity.proxy.AuthmeVelocityAPI;
 import com.velocitypowered.api.event.Subscribe;
 import com.velocitypowered.api.proxy.Player;
 import com.velocitypowered.api.proxy.ProxyServer;
 
 public class FastLoginListener {
-    private final AuthMeVelocityPlugin plugin;
     private final ProxyServer server;
-    public FastLoginListener(AuthMeVelocityPlugin plugin, ProxyServer server){
+    public FastLoginListener(ProxyServer server){
-        this.plugin = plugin;
         this.server = server;
     }
     @Subscribe
     public void onAutoLogin(VelocityFastLoginAutoLoginEvent event){
         Optional<Player> autoLoginPlayer = server.getPlayer(event.getProfile().getName());
         if(autoLoginPlayer.isPresent()){
-            UUID playerUUID = autoLoginPlayer.get().getUniqueId();
+            AuthmeVelocityAPI.addPlayer(autoLoginPlayer.get());
-            if(!plugin.loggedPlayers.contains(playerUUID)){
-                plugin.loggedPlayers.add(playerUUID);
-            }
         }
     }
 }

proxy/src/main/java/com/glyart/authmevelocity/proxy/listener/ProxyListener.java

@@ -1,6 +1,7 @@
 package com.glyart.authmevelocity.proxy.listener;
 
 import com.glyart.authmevelocity.proxy.AuthMeVelocityPlugin;
+import com.glyart.authmevelocity.proxy.AuthmeVelocityAPI;
 import com.glyart.authmevelocity.proxy.event.ProxyLoginEvent;
 import com.google.common.io.ByteArrayDataInput;
 import com.velocitypowered.api.event.Subscribe;
@@ -20,11 +21,9 @@ import java.util.Optional;
 import java.util.UUID;
 
 public class ProxyListener {
-    private final AuthMeVelocityPlugin plugin;
     private final ProxyServer server;
 
-    public ProxyListener(AuthMeVelocityPlugin plugin, ProxyServer server) {
+    public ProxyListener(ProxyServer server) {
-        this.plugin = plugin;
         this.server = server;
     }
 
@@ -39,29 +38,28 @@ public class ProxyListener {
         if (!sChannel.equals("LOGIN")) return;
 
         String user = input.readUTF();
-        Optional<Player> player = server.getPlayer(UUID.fromString(user));
+        Optional<Player> optionalPlayer = server.getPlayer(UUID.fromString(user));
-        if (!player.isPresent()) return;
+        if (!optionalPlayer.isPresent()) return;
 
-        Player loggedPlayer = player.get();
+        Player loggedPlayer = optionalPlayer.get();
-        UUID playerUUID = loggedPlayer.getUniqueId();
+        if (!AuthmeVelocityAPI.isLogged(loggedPlayer)){
-        if (!plugin.loggedPlayers.contains(playerUUID)){
+            AuthmeVelocityAPI.addPlayer(loggedPlayer);
-            plugin.loggedPlayers.add(playerUUID);
 
-            RegisteredServer loginServer = player.get().getCurrentServer().get().getServer();
+            RegisteredServer loginServer = loggedPlayer.getCurrentServer().get().getServer();
             server.getEventManager().fireAndForget(new ProxyLoginEvent(loggedPlayer, loginServer));
         }
     }
 
     @Subscribe
     public void onDisconnect(final DisconnectEvent event) {
-        plugin.loggedPlayers.remove(event.getPlayer().getUniqueId());
+        AuthmeVelocityAPI.removePlayer(event.getPlayer());
     }
 
     @Subscribe
     public void onCommandExecute(final CommandExecuteEvent event) {
         if (!(event.getCommandSource() instanceof Player player)) return;
 
-        if (plugin.loggedPlayers.contains(player.getUniqueId())) return;
+        if (AuthmeVelocityAPI.isLogged(player)) return;
 
         Optional<ServerConnection> server = player.getCurrentServer();
         boolean isAuthServer = server.isPresent() &&
@@ -77,7 +75,7 @@ public class ProxyListener {
     @Subscribe
     public void onPlayerChat(final PlayerChatEvent event) {
         final Player player = event.getPlayer();
-        if (plugin.loggedPlayers.contains(player.getUniqueId())) return;
+        if (AuthmeVelocityAPI.isLogged(player)) return;
 
         Optional<ServerConnection> server = player.getCurrentServer();
         if (server.isPresent() && AuthMeVelocityPlugin.getConfig().getList("authservers").contains(server.get().getServerInfo().getName())) {
@@ -89,8 +87,7 @@ public class ProxyListener {
 
     @Subscribe
     public void onServerPreConnect(ServerPreConnectEvent event) {
-        final Player player = event.getPlayer();
+        if (AuthmeVelocityAPI.isLogged(event.getPlayer())) return;
-        if (plugin.loggedPlayers.contains(player.getUniqueId())) return;
 
         Optional<RegisteredServer> server = event.getResult().getServer();
         if (server.isPresent() && AuthMeVelocityPlugin.getConfig().getList("authservers").contains(server.get().getServerInfo().getName())) {
@@ -115,8 +112,7 @@ public class ProxyListener {
 
     @Subscribe
     public void onTabComplete(PlayerAvailableCommandsEvent event){
-        Player player = event.getPlayer();
+        if (!AuthmeVelocityAPI.isLogged(event.getPlayer())) {
-        if (!plugin.loggedPlayers.contains(player.getUniqueId())) {
             event.getRootNode().getChildren().iterator().remove();
         }
     }