Merge branch 'dev' into 'master'

2.1.0

See merge request ajg0702/ajqueue!31

api/src/main/java/us/ajg0702/queue/api/commands/ICommandSender.java

@@ -3,6 +3,7 @@ package us.ajg0702.queue.api.commands;
 import net.kyori.adventure.audience.Audience;
 import us.ajg0702.queue.api.util.Handle;
 
+@SuppressWarnings("BooleanMethodIsAlwaysInverted")
 public interface ICommandSender extends Handle, Audience {
     boolean hasPermission(String permission);
     boolean isPlayer();

api/src/main/java/us/ajg0702/queue/api/queues/Balancer.java

@@ -0,0 +1,8 @@
+package us.ajg0702.queue.api.queues;
+
+import us.ajg0702.queue.api.players.AdaptedPlayer;
+import us.ajg0702.queue.api.server.AdaptedServer;
+
+public interface Balancer {
+    AdaptedServer getIdealServer(AdaptedPlayer player);
+}

api/src/main/java/us/ajg0702/queue/api/queues/QueueServer.java

@@ -13,7 +13,7 @@ import java.util.UUID;
 /**
  * Represents a server or a group that can be queued for
  */
-@SuppressWarnings("unused")
+@SuppressWarnings({"unused", "BooleanMethodIsAlwaysInverted"})
 public interface QueueServer {
 
     /**
@@ -232,6 +232,19 @@ public interface QueueServer {
      */
     void setSupportedProtocols(List<Integer> list);
 
+    /**
+     * Gets the balancer this server is using
+     * @return The balancer this server is using
+     */
+    Balancer getBalancer();
+
+    /**
+     * Checks if the player can join this server even if its full
+     * @param player The player
+     * @return If the player can join this server if its full
+     */
+    boolean canJoinFull(AdaptedPlayer player);
+
 
     /**
      * elliot is bad

build.gradle.kts

@@ -12,7 +12,7 @@ repositories {
 }
 
 allprojects {
-    version = "2.0.10"
+    version = "2.1.0"
     group = "us.ajg0702"
 
     plugins.apply("java")

common/src/main/java/us/ajg0702/queue/commands/BaseCommand.java

@@ -54,6 +54,7 @@ public class BaseCommand implements IBaseCommand {
         sender.sendMessage(Component.text("Unimplemented command"));
     }
 
+    @SuppressWarnings("BooleanMethodIsAlwaysInverted")
     public boolean checkPermission(ICommandSender sender) {
         if(getPermission() != null && !sender.hasPermission(getPermission())) {
             sender.sendMessage(getMessages().getComponent("noperm"));

common/src/main/java/us/ajg0702/queue/common/EventHandlerImpl.java

@@ -33,6 +33,10 @@ public class EventHandlerImpl implements EventHandler {
         try {
             String subchannel = in.readUTF();
 
+            if(subchannel.equals("ack")) {
+                main.getPlatformMethods().sendPluginMessage(recievingPlayer, "ack", "yes, im here");
+            }
+
             if(subchannel.equals("queue")) {
                 String rawData = in.readUTF();
                 String[] args = new String[1];

common/src/main/java/us/ajg0702/queue/common/QueueManagerImpl.java

@@ -116,7 +116,9 @@ public class QueueManagerImpl implements QueueManager {
             return false;
         }
 
-        if(player.getServerName().equals(server.getName())) {
+        List<AdaptedServer> notInServers = new ArrayList<>(server.getServers());
+        notInServers.removeIf(adaptedServer -> !adaptedServer.getName().equals(player.getServerName()));
+        if(notInServers.size() > 0) {
             player.sendMessage(msgs.getComponent("errors.already-connected", "SERVER:"+server.getAlias()));
             return false;
         }
@@ -528,11 +530,7 @@ public class QueueManagerImpl implements QueueManager {
                     AdaptedPlayer player = p.getPlayer();
                     if(player == null) continue;
 
-                    boolean bypassFull =
+                    if(server.isFull() && !server.canJoinFull(p.getPlayer())) continue;
-                            p.getPlayer().hasPermission("ajqueue.joinfull") ||
-                            p.getPlayer().hasPermission("ajqueue.joinfullserver."+server.getName());
-
-                    if(server.isFull() && !bypassFull) continue;
 
                     AdaptedServer selected = server.getIdealServer(player);
                     if(selected == null) {
@@ -578,7 +576,7 @@ public class QueueManagerImpl implements QueueManager {
 
             if(!server.canAccess(nextPlayer)) continue;
 
-            if(server.isFull() && !nextPlayer.hasPermission("ajqueue.joinfull")) continue;
+            if(server.isFull() && !server.canJoinFull(nextPlayer)) continue;
 
             if(main.getConfig().getBoolean("enable-bypasspaused-permission")) {
                 if(server.isPaused() && !nextPlayer.hasPermission("ajqueue.bypasspaused")) continue;

common/src/main/java/us/ajg0702/queue/common/queues/QueueServerImpl.java

@@ -1,13 +1,18 @@
 package us.ajg0702.queue.common.queues;
 
 import com.google.common.collect.ImmutableList;
+import jdk.nashorn.internal.runtime.Debug;
 import us.ajg0702.queue.api.players.AdaptedPlayer;
 import us.ajg0702.queue.api.players.QueuePlayer;
+import us.ajg0702.queue.api.queues.Balancer;
 import us.ajg0702.queue.api.queues.QueueServer;
 import us.ajg0702.queue.api.server.AdaptedServer;
 import us.ajg0702.queue.api.server.AdaptedServerPing;
 import us.ajg0702.queue.common.QueueMain;
 import us.ajg0702.queue.common.players.QueuePlayerImpl;
+import us.ajg0702.queue.common.queues.balancers.DefaultBalancer;
+import us.ajg0702.queue.common.queues.balancers.MinigameBalancer;
+import us.ajg0702.queue.common.utils.Debugger;
 import us.ajg0702.utils.common.GenUtils;
 import us.ajg0702.utils.common.Messages;
 
@@ -30,6 +35,32 @@ public class QueueServerImpl implements QueueServer {
         this.servers = servers;
         this.main = main;
 
+        List<String> types = main.getConfig().getStringList("balancer-types");
+        for(String type : types) {
+            int colon = type.indexOf(":");
+            if(colon == -1) continue;
+            String groupName = type.substring(0, colon);
+            String balancerType = type.substring(colon+1);
+
+            if(groupName.equals(name)) {
+                boolean valid = true;
+                switch(balancerType.toLowerCase(Locale.ROOT)) {
+                    case "minigame":
+                        balancer = new MinigameBalancer(this, main);
+                        break;
+                    default:
+                        balancerType = "default";
+                        balancer = new DefaultBalancer(this, main);
+                }
+                Debugger.debug("Using "+balancerType.toLowerCase(Locale.ROOT)+" balancer for "+name);
+                break;
+            }
+        }
+        if(balancer == null) {
+            balancer = new DefaultBalancer(this, main);
+            Debugger.debug("Using default balancer for "+name);
+        }
+
         for(QueuePlayer queuePlayer : previousPlayers) {
             if(queuePlayer.getPlayer() == null) {
                 addPlayer(
@@ -64,6 +95,8 @@ public class QueueServerImpl implements QueueServer {
 
     private List<Integer> supportedProtocols = new ArrayList<>();
 
+    private Balancer balancer;
+
 
     private int playerCount;
     private int maxPlayers;
@@ -111,7 +144,7 @@ public class QueueServerImpl implements QueueServer {
             return msgs.getString("status.offline.whitelisted");
         }
 
-        if(isFull()) {
+        if(isFull() && !canJoinFull(p)) {
             return msgs.getString("status.offline.full");
         }
 
@@ -253,12 +286,16 @@ public class QueueServerImpl implements QueueServer {
 
     @Override
     public boolean isJoinable(AdaptedPlayer p) {
-        if(p != null && isWhitelisted() && !whitelistedUUIDs.contains(p.getUniqueId())) {
+        if(p != null) {
-            return false;
+            if (isWhitelisted() && !whitelistedUUIDs.contains(p.getUniqueId())) {
+                return false;
+            }
+            if (isFull() && !canJoinFull(p)) {
+                return false;
+            }
         }
         return isOnline() &&
                 canAccess(p) &&
-                !isFull() &&
                 !isPaused();
     }
 
@@ -290,6 +327,7 @@ public class QueueServerImpl implements QueueServer {
 
     @Override
     public boolean isFull() {
+        if(!isOnline()) return false;
         return playerCount >= maxPlayers;
     }
 
@@ -382,36 +420,8 @@ public class QueueServerImpl implements QueueServer {
 
     @Override
     public AdaptedServer getIdealServer(AdaptedPlayer player) {
-        HashMap<AdaptedServer, AdaptedServerPing> serverInfos = pings;
+        Debugger.debug(getBalancer().toString());
-        AdaptedServer selected = null;
+        return getBalancer().getIdealServer(player);
-        int selectednum = 0;
-        if(serverInfos.keySet().size() == 1) {
-            selected = serverInfos.keySet().iterator().next();
-        } else {
-            for(AdaptedServer si : serverInfos.keySet()) {
-                AdaptedServerPing sp = serverInfos.get(si);
-                if(sp == null) continue;
-                int online = sp.getPlayerCount();
-                if(selected == null) {
-                    selected = si;
-                    selectednum = online;
-                    continue;
-                }
-                if(selectednum > online && main.getQueueManager().findServer(si.getName()).isJoinable(player)) {
-                    selected = si;
-                    selectednum = online;
-                }
-            }
-        }
-        if(selected == null && serverInfos.size() > 0) {
-            selected = serverInfos.keySet().iterator().next();
-        }
-        if(selected == null) {
-            main.getLogger().warning("Unable to find ideal server, using random server from group.");
-            int r = GenUtils.randomInt(0, getServers().size()-1);
-            selected = getServers().get(r);
-        }
-        return selected;
     }
 
     @Override
@@ -428,4 +438,19 @@ public class QueueServerImpl implements QueueServer {
     public void setSupportedProtocols(List<Integer> list) {
         supportedProtocols = new ArrayList<>(list);
     }
+
+    @Override
+    public Balancer getBalancer() {
+        return balancer;
+    }
+
+    @Override
+    public boolean canJoinFull(AdaptedPlayer player) {
+        if(player == null) return true;
+        return
+                player.hasPermission("ajqueue.joinfull") ||
+                player.hasPermission("ajqueue.joinfullserver."+name) ||
+                player.hasPermission("ajqueue.joinfullandbypassserver."+name) ||
+                player.hasPermission("ajqueue.joinfullandbypass");
+    }
 }

common/src/main/java/us/ajg0702/queue/common/queues/balancers/DefaultBalancer.java

@@ -0,0 +1,55 @@
+package us.ajg0702.queue.common.queues.balancers;
+
+import us.ajg0702.queue.api.players.AdaptedPlayer;
+import us.ajg0702.queue.api.queues.Balancer;
+import us.ajg0702.queue.api.queues.QueueServer;
+import us.ajg0702.queue.api.server.AdaptedServer;
+import us.ajg0702.queue.api.server.AdaptedServerPing;
+import us.ajg0702.queue.common.QueueMain;
+import us.ajg0702.utils.common.GenUtils;
+
+import java.util.HashMap;
+
+public class DefaultBalancer implements Balancer {
+
+    private final QueueServer server;
+    private final QueueMain main;
+    public DefaultBalancer(QueueServer server, QueueMain main) {
+        this.server = server;
+        this.main = main;
+    }
+
+    @Override
+    public AdaptedServer getIdealServer(AdaptedPlayer player) {
+        HashMap<AdaptedServer, AdaptedServerPing> serverInfos = server.getLastPings();
+        AdaptedServer selected = null;
+        int selectednum = 0;
+        if(serverInfos.keySet().size() == 1) {
+            selected = serverInfos.keySet().iterator().next();
+        } else {
+            for(AdaptedServer si : serverInfos.keySet()) {
+                AdaptedServerPing sp = serverInfos.get(si);
+                if(sp == null) continue;
+                int online = sp.getPlayerCount();
+                if(selected == null) {
+                    selected = si;
+                    selectednum = online;
+                    continue;
+                }
+                if(selectednum > online && main.getQueueManager().findServer(si.getName()).isJoinable(player)) {
+                    selected = si;
+                    selectednum = online;
+                }
+            }
+        }
+        if(selected == null && serverInfos.size() > 0) {
+            selected = serverInfos.keySet().iterator().next();
+        }
+        if(selected == null) {
+            main.getLogger().warning("Unable to find ideal server, using random server from group.");
+            int r = GenUtils.randomInt(0, server.getServers().size()-1);
+            selected = server.getServers().get(r);
+        }
+        return selected;
+    }
+}

common/src/main/java/us/ajg0702/queue/common/queues/balancers/MinigameBalancer.java

@@ -0,0 +1,53 @@
+package us.ajg0702.queue.common.queues.balancers;
+
+import us.ajg0702.queue.api.players.AdaptedPlayer;
+import us.ajg0702.queue.api.queues.Balancer;
+import us.ajg0702.queue.api.queues.QueueServer;
+import us.ajg0702.queue.api.server.AdaptedServer;
+import us.ajg0702.queue.api.server.AdaptedServerPing;
+import us.ajg0702.queue.common.QueueMain;
+
+import java.util.*;
+
+public class MinigameBalancer implements Balancer {
+
+    private final QueueServer server;
+    private final QueueMain main;
+    public MinigameBalancer(QueueServer server, QueueMain main) {
+        this.server = server;
+        this.main = main;
+    }
+
+    @Override
+    public AdaptedServer getIdealServer(AdaptedPlayer player) {
+        HashMap<AdaptedServer, AdaptedServerPing> serverInfos = server.getLastPings();
+        if(serverInfos.keySet().size() == 1) {
+            return serverInfos.keySet().iterator().next();
+        } else {
+
+            List<Map.Entry<AdaptedServer, AdaptedServerPing>> servers = new ArrayList<>(serverInfos.entrySet());
+            servers.sort(Comparator.comparingInt(o -> {
+                @SuppressWarnings("unchecked")
+                Map.Entry<AdaptedServer, AdaptedServerPing> e = (Map.Entry<AdaptedServer, AdaptedServerPing>) o;
+                AdaptedServerPing value = e.getValue();
+                if(value == null) return -1;
+                return value.getPlayerCount();
+            }).reversed());
+            LinkedHashMap<AdaptedServer, AdaptedServerPing> sortedServers = new LinkedHashMap<>();
+            for(Map.Entry<AdaptedServer, AdaptedServerPing> entry : servers) {
+                sortedServers.put(entry.getKey(), entry.getValue());
+            }
+
+            for(AdaptedServer si : sortedServers.keySet()) {
+                AdaptedServerPing sp = sortedServers.get(si);
+                if(sp == null) continue;
+                int online = sp.getPlayerCount();
+                int max = sp.getMaxPlayers();
+                if(online < max) {
+                    return si;
+                }
+            }
+            return new ArrayList<AdaptedServer>(sortedServers.keySet().size()).get(sortedServers.keySet().size()-1);
+        }
+    }
+}

common/src/main/java/us/ajg0702/queue/common/utils/Debugger.java

@@ -0,0 +1,11 @@
+package us.ajg0702.queue.common.utils;
+
+import us.ajg0702.queue.api.AjQueueAPI;
+
+public class Debugger {
+    public static void debug(String message) {
+        AjQueueAPI api = AjQueueAPI.getInstance();
+        if(!api.getConfig().getBoolean("debug")) return;
+        api.getLogger().info("[debug] "+message);
+    }
+}

common/src/main/resources/config.yml

@@ -1,5 +1,5 @@
 # Dont touch this number please
-config-version: 29
+config-version: 30
 
 
 # This is the main config for ajQueue.
@@ -267,4 +267,17 @@ enable-updater: true
 # For example, if survival is in this list, then if a player executes /survival
 #  then they will be put in the queue for survival
 # This works for both servers and groups
-slash-servers: []
+slash-servers: []
+
+# What balancer should we use?
+# If a group is not specified here, then the default one is used
+# Example entry: - "bedwars:minigame"
+# Balancers:
+#  default - Will send the player to the server in the group with the least number of players
+#  minigame - Will send the player to the server with the most players, until that server is full, which it will then send to the next server
+balancer-types:
+  - "bedwars:minigame"
+
+
+# Should we print some extra stuff to the console that might help diagnose some issues?
+debug: false

premium/src/main/java/us/ajg0702/queue/logic/PremiumLogic.java

@@ -39,6 +39,8 @@ public class PremiumLogic implements Logic {
         if(
                 player.hasPermission("ajqueue.bypass") ||
                 player.hasPermission("ajqueue.serverbypass."+server.getName()) ||
+                player.hasPermission("ajqueue.joinfullandbypassserver."+server.getName()) ||
+                player.hasPermission("ajqueue.joinfullandbypass") ||
                 permissionGetter.hasContextBypass(player, server.getName())
         ) {
             if(debug) {

spigot/src/main/java/us/ajg0702/queue/spigot/Commands.java

@@ -17,6 +17,10 @@ public class Commands implements CommandExecutor {
 
 	@Override
 	public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label, String[] args) {
+		if(!pl.hasProxy()) {
+			sender.sendMessage(color("&cajQueue must also be installed on the proxy!&7 If it has been installed on the proxy, make sure it loaded correctly and try relogging."));
+			return true;
+		}
 		Player player = null;
 		if(sender instanceof Player) {
 			player = (Player) sender;

spigot/src/main/java/us/ajg0702/queue/spigot/SpigotMain.java

@@ -9,6 +9,7 @@ import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.event.server.ServerListPingEvent;
 import org.bukkit.plugin.java.JavaPlugin;
@@ -26,6 +27,8 @@ public class SpigotMain extends JavaPlugin implements PluginMessageListener,List
 	Placeholders placeholders;
 	
 	ConfigFile config;
+
+	boolean hasProxy = false;
 	
 	@SuppressWarnings("ConstantConditions")
 	public void onEnable() {
@@ -74,7 +77,11 @@ public class SpigotMain extends JavaPlugin implements PluginMessageListener,List
 
 		getLogger().info("Spigot side enabled! v"+getDescription().getVersion());
 	}
-	
+
+	public boolean hasProxy() {
+		return hasProxy;
+	}
+
 	final HashMap<Player, String> queuebatch = new HashMap<>();
 
 	@Override
@@ -85,6 +92,10 @@ public class SpigotMain extends JavaPlugin implements PluginMessageListener,List
 		
 	    String subchannel = in.readUTF();
 
+	    if(subchannel.equals("ack")) {
+	    	hasProxy = true;
+		}
+
 	    if(subchannel.equals("inqueueevent")) {
 	    	String playername = in.readUTF();
 	    	Player p = Bukkit.getPlayer(playername);
@@ -180,6 +191,14 @@ public class SpigotMain extends JavaPlugin implements PluginMessageListener,List
 		placeholders.cleanCache();
 	}
 
+	@EventHandler
+	public void onJoin(PlayerJoinEvent e) {
+		if(hasProxy) return;
+		Bukkit.getScheduler().runTask(this, () -> {
+			sendMessage(e.getPlayer(), "ack", "");
+		});
+	}
+
 	@EventHandler(priority = EventPriority.HIGH)
 	public void onServerPing(ServerListPingEvent e) {
 		if(!config.getBoolean("take-over-motd-for-whitelist")) return;