Merge branch 'main' into main

build.gradle

@@ -2,10 +2,12 @@ plugins {
     id 'java'
     id 'eclipse'
     id "org.jetbrains.gradle.plugin.idea-ext" version "1.1.7"
+    id "xyz.jpenilla.run-velocity" version "2.1.0"
+    id "io.freefair.lombok" version "8.1.0"
 }
 
 group = 'voruti'
-version = '1.0.2'
+version = '1.1.1'
 
 repositories {
     mavenCentral()
@@ -15,9 +17,11 @@ repositories {
     }
 }
 
+def velocityApiVersion = '3.2.0-SNAPSHOT'
+
 dependencies {
-    compileOnly 'com.velocitypowered:velocity-api:3.1.2-SNAPSHOT'
-    annotationProcessor 'com.velocitypowered:velocity-api:3.1.2-SNAPSHOT'
+    compileOnly "com.velocitypowered:velocity-api:$velocityApiVersion"
+    annotationProcessor "com.velocitypowered:velocity-api:$velocityApiVersion"
 }
 
 def targetJavaVersion = 11
@@ -53,3 +57,12 @@ sourceSets.main.java.srcDir(generateTemplates.map { it.outputs })
 
 rootProject.idea.project.settings.taskTriggers.afterSync generateTemplates
 project.eclipse.synchronizationTasks(generateTemplates)
+
+tasks {
+    runVelocity {
+        // Configure the Velocity version for our task.
+        // This is the only required configuration besides applying the plugin.
+        // Your plugin's jar (or shadowJar if present) will be used automatically.
+        velocityVersion(velocityApiVersion)
+    }
+}

gradle.properties

@@ -0,0 +1 @@
+javaVersion=11

src/main/java/voruti/velocityplayerlistquery/VelocityPlayerListQuery.java

@@ -6,13 +6,20 @@
 import com.velocitypowered.api.event.proxy.ProxyInitializeEvent;
 import com.velocitypowered.api.event.proxy.ProxyPingEvent;
 import com.velocitypowered.api.plugin.Plugin;
+import com.velocitypowered.api.plugin.annotation.DataDirectory;
 import com.velocitypowered.api.proxy.Player;
 import com.velocitypowered.api.proxy.ProxyServer;
 import com.velocitypowered.api.proxy.ServerConnection;
 import com.velocitypowered.api.proxy.server.ServerInfo;
 import com.velocitypowered.api.proxy.server.ServerPing;
+import lombok.AccessLevel;
+import lombok.experimental.FieldDefaults;
 import org.slf4j.Logger;
+import voruti.velocityplayerlistquery.model.Config;
+import voruti.velocityplayerlistquery.service.PersistenceService;
+import voruti.velocityplayerlistquery.util.ServerListEntryBuilder;
 
+import java.nio.file.Path;
 import java.util.Collection;
 
 @Plugin(
@@ -23,40 +30,46 @@
         url = "https://github.com/voruti/VelocityPlayerListQuery",
         authors = {"voruti"}
 )
+@FieldDefaults(level = AccessLevel.PRIVATE)
 public class VelocityPlayerListQuery {
 
     @Inject
-    private Logger logger;
+    Logger logger;
 
     @Inject
-    private ProxyServer server;
+    ProxyServer server;
+
+    @Inject
+    @DataDirectory
+    Path dataDirectory;
+
+    ServerListEntryBuilder serverListEntryBuilder;
 
 
     @Subscribe
     public void onProxyInitialization(ProxyInitializeEvent event) {
-        logger.info("Enabled");
+        final Config config = new PersistenceService(logger, dataDirectory)
+                .loadConfig();
+        this.serverListEntryBuilder = new ServerListEntryBuilder(logger, config);
+
+        this.logger.info("Enabled");
     }
 
     @Subscribe
-    public EventTask onServerPing(ProxyPingEvent event) {
+    public EventTask onServerPing(final ProxyPingEvent event) {
+        this.logger.trace("Server ping event received, adding players to server list entry...");
+
         return EventTask.async(() -> {
-            Collection<Player> players = server.getAllPlayers();
+            Collection<Player> players = this.server.getAllPlayers();
 
             if (!players.isEmpty()) {
                 event.setPing(event.getPing().asBuilder()
                         .samplePlayers(
                                 players.stream()
-                                        .map(player -> {
-                                            final String serverName = player.getCurrentServer()
-                                                    .map(ServerConnection::getServerInfo)
-                                                    .map(ServerInfo::getName)
-                                                    .map(name -> "["+name+"] ")
-                                                    .orElse("");
-                                            return new ServerPing.SamplePlayer(
-                                                    serverName + player.getUsername(),
-                                                    player.getUniqueId()
-                                            );
-                                        })
+                                        .map(player -> new ServerPing.SamplePlayer(
+                                                this.serverListEntryBuilder.buildForPlayer(player),
+                                                player.getGameProfile().getId()
+                                        ))
                                         .toArray(ServerPing.SamplePlayer[]::new)
                         ).onlinePlayers(players.size())
                         .maximumPlayers(server.getConfiguration().getShowMaxPlayers())

src/main/java/voruti/velocityplayerlistquery/model/Config.java

@@ -0,0 +1,25 @@
+package voruti.velocityplayerlistquery.model;
+
+import lombok.Value;
+import lombok.experimental.Accessors;
+
+@Value
+@Accessors(fluent = true)
+public class Config {
+
+    public static final String FILE_NAME = "config.json";
+
+    public static final Config DEFAULT_CONFIG = new Config(
+            "%1$s"
+    );
+
+
+    /**
+     * Configure how players are shown in the server list.
+     * <ul>
+     *      <li>{@code %1$s}: placeholder for the player name</li>
+     *      <li>{@code %2$s}: placeholder for the server name, on which that player is currently playing on</li>
+     * </ul>
+     */
+    String serverListEntryFormat;
+}

src/main/java/voruti/velocityplayerlistquery/service/PersistenceService.java

@@ -0,0 +1,65 @@
+package voruti.velocityplayerlistquery.service;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import lombok.AccessLevel;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+import org.slf4j.Logger;
+import voruti.velocityplayerlistquery.model.Config;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+@RequiredArgsConstructor
+@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
+public class PersistenceService {
+
+    @NonNull
+    Logger logger;
+    @NonNull
+    Path dataDirectory;
+
+    @NonNull
+    final Gson gson = new GsonBuilder()
+            .setPrettyPrinting()
+            .create();
+
+
+    public Config loadConfig() {
+        logger.trace("Loading config...");
+
+        try {
+            // checks:
+            if (!Files.exists(dataDirectory)) {
+                Files.createDirectories(dataDirectory);
+            }
+
+            final Path configPath = dataDirectory.resolve(Config.FILE_NAME);
+            if (!Files.exists(configPath)) {
+                this.writeFile(configPath, Config.DEFAULT_CONFIG);
+                return Config.DEFAULT_CONFIG;
+            }
+            if (!Files.isRegularFile(configPath) || !Files.isReadable(configPath)) {
+                throw new IllegalStateException("Config file is invalid");
+            }
+
+            // load:
+            return gson.fromJson(
+                    Files.readString(configPath),
+                    Config.class
+            );
+        } catch (IOException | IllegalStateException e) {
+            logger.error("Error while loading config", e);
+            return Config.DEFAULT_CONFIG;
+        }
+    }
+
+    private <T> void writeFile(Path path, T content) throws IOException {
+        logger.trace("Writing file: {}", path);
+
+        Files.write(path, gson.toJson(content).getBytes());
+    }
+}

src/main/java/voruti/velocityplayerlistquery/util/ServerListEntryBuilder.java

@@ -0,0 +1,31 @@
+package voruti.velocityplayerlistquery.util;
+
+import com.velocitypowered.api.proxy.Player;
+import lombok.AccessLevel;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+import org.slf4j.Logger;
+import voruti.velocityplayerlistquery.model.Config;
+
+@RequiredArgsConstructor
+@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
+public class ServerListEntryBuilder {
+
+    @NonNull
+    Logger logger;
+    @NonNull
+    Config config;
+
+
+    public String buildForPlayer(Player player) {
+        logger.trace("Building server list entry for player {}...", player.getUsername());
+        return String.format(
+                this.config.serverListEntryFormat(),
+                player.getGameProfile().getName(),
+                player.getCurrentServer()
+                        .map(serverConnection -> serverConnection.getServerInfo().getName())
+                        .orElse("unknown")
+        );
+    }
+}