release: Version 2.1.0

closes #161

Co-authored-by: ens-gijs <ens.gijs@gmail.com>

common/src/main/java/xyz/jpenilla/minimotd/common/MiniMOTD.java

@@ -34,7 +34,7 @@ import org.checkerframework.checker.nullness.qual.Nullable;
 import org.checkerframework.framework.qual.DefaultQualifier;
 import org.slf4j.Logger;
 import xyz.jpenilla.minimotd.common.config.ConfigManager;
-import xyz.jpenilla.minimotd.common.config.MiniMOTDConfig;
+import xyz.jpenilla.minimotd.common.config.MOTDConfig;
 import xyz.jpenilla.minimotd.common.util.Components;
 
 import static net.kyori.adventure.text.Component.newline;
@@ -77,7 +77,7 @@ public final class MiniMOTD<I> {
     return this.configManager;
   }
 
-  public PingResponse<I> createMOTD(final MiniMOTDConfig config, final int onlinePlayers, final int maxPlayers) {
+  public PingResponse<I> createMOTD(final MOTDConfig config, final int onlinePlayers, final int maxPlayers) {
     final PingResponse.PlayerCount count = config.modifyPlayerCount(onlinePlayers, maxPlayers);
     final PingResponse.Builder<I> response = PingResponse.<I>builder()
       .playerCount(count)
@@ -90,7 +90,7 @@ public final class MiniMOTD<I> {
         throw new IllegalStateException("MOTD is enabled, but there are no MOTDs in the config file?");
       }
       final int index = config.motds().size() == 1 ? 0 : ThreadLocalRandom.current().nextInt(config.motds().size());
-      final MiniMOTDConfig.MOTD motdConfig = config.motds().get(index);
+      final MOTDConfig.MOTD motdConfig = config.motds().get(index);
       final Component motd = Components.ofChildren(
         parse(motdConfig.line1(), count),
         newline(),

common/src/main/java/xyz/jpenilla/minimotd/common/config/ConfigManager.java

@@ -46,18 +46,18 @@ public final class ConfigManager {
 
   private final MiniMOTD<?> miniMOTD;
 
-  private final ConfigLoader<MiniMOTDConfig> mainConfigLoader;
-  private MiniMOTDConfig mainConfig;
+  private final ConfigLoader<MOTDConfig> mainConfigLoader;
+  private MOTDConfig mainConfig;
 
   private final ConfigLoader<PluginSettings> pluginSettingsLoader;
   private PluginSettings pluginSettings;
 
-  private final Map<String, MiniMOTDConfig> extraConfigs = new HashMap<>();
+  private final Map<String, MOTDConfig> extraConfigs = new HashMap<>();
 
   public ConfigManager(final @NonNull MiniMOTD<?> miniMOTD) {
     this.miniMOTD = miniMOTD;
     this.mainConfigLoader = new ConfigLoader<>(
-      MiniMOTDConfig.class,
+      MOTDConfig.class,
       this.miniMOTD.dataDirectory().resolve("main.conf"),
       options -> options.header("MiniMOTD Main Configuration")
     );
@@ -94,12 +94,12 @@ public final class ConfigManager {
             continue;
           }
           final String name = path.getFileName().toString().replace(".conf", "");
-          final ConfigLoader<MiniMOTDConfig> loader = new ConfigLoader<>(
-            MiniMOTDConfig.class,
+          final ConfigLoader<MOTDConfig> loader = new ConfigLoader<>(
+            MOTDConfig.class,
             path,
             options -> options.header(String.format("Extra MiniMOTD config '%s'", name))
           );
-          final MiniMOTDConfig config = loader.load();
+          final MOTDConfig config = loader.load();
           loader.save(config);
           this.extraConfigs.put(name, config);
         }
@@ -110,20 +110,20 @@ public final class ConfigManager {
   }
 
   private void createDefaultExtraConfigs(final @NonNull Path extraConfigsDir) throws ConfigurateException {
-    final List<Pair<Path, MiniMOTDConfig.MOTD>> defaults = Collections.unmodifiableList(Arrays.asList(
-      pair(extraConfigsDir.resolve("skyblock.conf"), new MiniMOTDConfig.MOTD("<green><italic>Skyblock</green>", "<bold><rainbow>MiniMOTD Skyblock Server")),
-      pair(extraConfigsDir.resolve("survival.conf"), new MiniMOTDConfig.MOTD("<gradient:blue:red>Survival Mode Hardcore", "<green><bold>MiniMOTD Survival Server"))
+    final List<Pair<Path, MOTDConfig.MOTD>> defaults = Collections.unmodifiableList(Arrays.asList(
+      pair(extraConfigsDir.resolve("skyblock.conf"), new MOTDConfig.MOTD("<green><italic>Skyblock</green>", "<bold><rainbow>MiniMOTD Skyblock Server")),
+      pair(extraConfigsDir.resolve("survival.conf"), new MOTDConfig.MOTD("<gradient:blue:red>Survival Mode Hardcore", "<green><bold>MiniMOTD Survival Server"))
     ));
-    for (final Pair<Path, MiniMOTDConfig.MOTD> pair : defaults) {
-      final ConfigLoader<MiniMOTDConfig> loader = new ConfigLoader<>(
-        MiniMOTDConfig.class,
+    for (final Pair<Path, MOTDConfig.MOTD> pair : defaults) {
+      final ConfigLoader<MOTDConfig> loader = new ConfigLoader<>(
+        MOTDConfig.class,
         pair.left()
       );
-      loader.save(new MiniMOTDConfig(pair.right()));
+      loader.save(new MOTDConfig(pair.right()));
     }
   }
 
-  public @NonNull MiniMOTDConfig mainConfig() {
+  public @NonNull MOTDConfig mainConfig() {
     if (this.mainConfig == null) {
       throw new IllegalStateException("Config has not yet been loaded");
     }
@@ -137,15 +137,14 @@ public final class ConfigManager {
     return this.pluginSettings;
   }
 
-  public @NonNull MiniMOTDConfig resolveConfig(final @Nullable InetSocketAddress address) {
+  public @NonNull MOTDConfig resolveConfig(final @Nullable InetSocketAddress address) {
     if (address == null) {
       return this.mainConfig();
     }
-    final String hostString = address.getHostString() + ":" + address.getPort();
-    final String configString = this.pluginSettings().proxySettings().findConfigStringForHost(hostString);
+    final String configString = this.pluginSettings().proxySettings().findConfigStringForHost(address.getHostString(), address.getPort());
 
     if (this.pluginSettings().proxySettings().virtualHostTestMode()) {
-      this.miniMOTD.platform().logger().info("[virtual-host-debug] Virtual Host: '{}', Selected Config: '{}'", hostString, configString == null ? "default" : configString);
+      this.miniMOTD.platform().logger().info("[virtual-host-debug] Virtual Host: '{}:{}', Selected Config: '{}'", address.getHostString(), address.getPort(), configString == null ? "default" : configString);
     }
 
     if (configString == null) {
@@ -154,11 +153,11 @@ public final class ConfigManager {
     return this.resolveConfig(configString);
   }
 
-  public @NonNull MiniMOTDConfig resolveConfig(final @NonNull String name) {
+  public @NonNull MOTDConfig resolveConfig(final @NonNull String name) {
     if ("default".equals(name)) {
       return this.mainConfig();
     }
-    final MiniMOTDConfig cfg = this.extraConfigs.get(name);
+    final MOTDConfig cfg = this.extraConfigs.get(name);
     if (cfg != null) {
       return cfg;
     }

common/src/main/java/xyz/jpenilla/minimotd/common/config/MOTDConfig.java

@@ -34,16 +34,16 @@ import xyz.jpenilla.minimotd.common.PingResponse;
 import static xyz.jpenilla.minimotd.common.PingResponse.PlayerCount.playerCount;
 
 @ConfigSerializable
-public final class MiniMOTDConfig {
+public final class MOTDConfig {
 
-  public MiniMOTDConfig() {
+  public MOTDConfig() {
     this(
       new MOTD(),
       new MOTD("<blue>Another <bold><red>MOTD", "<italic><underlined><gradient:red:green>much wow")
     );
   }
 
-  public MiniMOTDConfig(final @NonNull MOTD @NonNull ... defaults) {
+  public MOTDConfig(final @NonNull MOTD @NonNull ... defaults) {
     this.motds.addAll(Arrays.asList(defaults));
   }
 
@@ -123,9 +123,9 @@ public final class MiniMOTDConfig {
       + "If false, the online player count will be capped at the maximum player count")
     private boolean allowExceedingMaximum = false;
 
-    @Comment("The list of server names that affect player counts.\n"
+    @Comment("The list of server names that affect player counts/listing.\n"
       + "Only applicable when running the plugin on a proxy (Velocity or Waterfall/Bungeecord).\n"
-      + "When set to an empty list, the default count determined by the proxy will be used.")
+      + "When set to an empty list, the default count & list as determined by the proxy will be used.")
     private final List<String> servers = new ArrayList<>();
 
     @ConfigSerializable

common/src/main/java/xyz/jpenilla/minimotd/common/config/PluginSettings.java

@@ -23,9 +23,10 @@
  */
 package xyz.jpenilla.minimotd.common.config;
 
-import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.Locale;
 import java.util.Map;
+import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
 import org.checkerframework.checker.nullness.qual.NonNull;
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.spongepowered.configurate.objectmapping.ConfigSerializable;
@@ -50,11 +51,19 @@ public final class PluginSettings {
       this.virtualHostConfigs.put("skyblock.example.com:25565", "skyblock");
     }
 
+    public ProxySettings(final Map<String, String> virtualHostConfigs) {
+      this.virtualHostConfigs.putAll(virtualHostConfigs);
+    }
+
     @Comment("Here you can assign configs in the 'extra-configs' folder to specific virtual hosts\n"
       + "Either use the name of the config in 'extra-configs', or use \"default\" to use the configuration in main.conf\n"
       + "\n"
-      + "Format is \"hostname:port\"=\"configName|default\"")
-    private final Map<String, String> virtualHostConfigs = new HashMap<>();
+      + "Format is \"hostname:port\"=\"configName|default\"\n"
+      + "Parts of domains can be substituted for wildcards, i.e. \"*.mydomain.com:25565\". Wildcard-containing configs are\n"
+      + "checked in the order they are declared if there are no exact matches.")
+    private final Map<String, String> virtualHostConfigs = new LinkedHashMap<>();
+
+    private transient @MonotonicNonNull Map<String[], String> splitVirtualHostConfigs;
 
     @Comment("Set whether to enable virtual host testing mode.\n"
       + "When enabled, MiniMOTD will print virtual host debug info to the console on each server ping.")
@@ -64,8 +73,61 @@ public final class PluginSettings {
       return this.virtualHostTestMode;
     }
 
-    public @Nullable String findConfigStringForHost(final @NonNull String host) {
-      return this.virtualHostConfigs.get(host.toLowerCase(Locale.ENGLISH));
+    public @Nullable String findConfigStringForHost(@NonNull String host, final int port) {
+      host = processTcpShieldHostname(host).toLowerCase(Locale.ENGLISH) + ':' + port;
+
+      final @Nullable String exactMatch = this.virtualHostConfigs.get(host);
+      if (exactMatch != null) {
+        return exactMatch;
+      }
+
+      if (this.splitVirtualHostConfigs.isEmpty()) {
+        return null;
+      }
+
+      final String[] splitHost = host.split("\\.");
+
+      configs:
+      for (final Map.Entry<String[], String> e : this.splitVirtualHostConfigs.entrySet()) {
+        final String[] splitKey = e.getKey();
+        if (splitKey.length != splitHost.length) {
+          continue;
+        }
+        for (int i = 0; i < splitHost.length; i++) {
+          final String keyPart = splitKey[i];
+          if (!keyPart.equals(splitHost[i]) && !keyPart.equals("*")) {
+            continue configs;
+          }
+        }
+        return e.getValue();
+      }
+
+      return null;
+    }
+
+    private static String processTcpShieldHostname(final String hostname) {
+      if (hostname.contains("///")) {
+        final String[] split = hostname.split("///");
+        if (split.length == 4) {
+          // <actual hostname>///<user-ip>:<user-port>///<unix timestamp>///<signature>
+          return split[0];
+        }
+      }
+      return hostname;
+    }
+
+    public void processVirtualHosts() {
+      final Map<String, String> virtualHosts = new LinkedHashMap<>(this.virtualHostConfigs);
+      this.virtualHostConfigs.clear();
+      virtualHosts.forEach((host, config) -> this.virtualHostConfigs.put(host.toLowerCase(Locale.ENGLISH), config));
+
+      this.splitVirtualHostConfigs = new LinkedHashMap<>();
+      this.virtualHostConfigs.forEach((host, config) -> {
+        if (!host.contains("*")) {
+          return;
+        }
+        this.splitVirtualHostConfigs.put(host.split("\\."), config);
+      });
     }
   }
 
@@ -78,9 +140,7 @@ public final class PluginSettings {
   }
 
   @PostProcessor
-  private void lowercaseVirtualHosts() {
-    final Map<String, String> virtualHosts = new HashMap<>(this.proxySettings.virtualHostConfigs);
-    this.proxySettings.virtualHostConfigs.clear();
-    virtualHosts.forEach((host, config) -> this.proxySettings.virtualHostConfigs.put(host.toLowerCase(Locale.ENGLISH), config));
+  private void processVirtualHosts() {
+    this.proxySettings.processVirtualHosts();
   }
 }

common/src/test/java/xyz/jpenilla/minimotd/common/VirtualHostMatchingTest.java

@@ -0,0 +1,56 @@
+/*
+ * This file is part of MiniMOTD, licensed under the MIT License.
+ *
+ * Copyright (c) 2020-2024 Jason Penilla
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package xyz.jpenilla.minimotd.common;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import org.junit.jupiter.api.Test;
+import xyz.jpenilla.minimotd.common.config.PluginSettings;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
+class VirtualHostMatchingTest {
+  @Test
+  void testMatching() {
+    final Map<String, String> map = new LinkedHashMap<>();
+    map.put("abc.xyz:25565", "1");
+    map.put("subdomain.abc.xyz:25565", "2");
+    map.put("*.abc.xyz:25565", "3");
+    map.put("abc.*.*.domain.com:25565", "4");
+    map.put("*.*.*.domain.com:25565", "5");
+    final PluginSettings.ProxySettings proxySettings = new PluginSettings.ProxySettings(map);
+    proxySettings.processVirtualHosts();
+
+    assertEquals("1", proxySettings.findConfigStringForHost("abc.xyz", 25565));
+    assertEquals("2", proxySettings.findConfigStringForHost("subdomain.abc.xyz", 25565));
+    assertEquals("3", proxySettings.findConfigStringForHost("other_subdomain.abc.xyz", 25565));
+    assertEquals("4", proxySettings.findConfigStringForHost("abc.2.3.domain.com", 25565));
+    assertEquals("5", proxySettings.findConfigStringForHost("1.2.3.domain.com", 25565));
+    // TCPShield-mangled hostname
+    assertEquals("5", proxySettings.findConfigStringForHost("1.2.3.domain.com///127.0.0.1:25565///1681016669///MGQCMAW5X13a9cF5ysnWdrBLovH4wfVu60l7eBUwWsCI8vw0cuZ9aj+UM7+y1wC//qGHngIwRsCke7eCpO99HTHOVdvZKjx9G0E51ALqRFGWH7kxMhVKYNF2IfMaT1FfbS0/D0du", 25565));
+    assertNull(proxySettings.findConfigStringForHost("subdomain.subdomain.abc.xyz", 25565));
+    assertNull(proxySettings.findConfigStringForHost("google.com", 25565));
+  }
+}

gradle.properties

@@ -1,5 +1,5 @@
 group=xyz.jpenilla
-version=2.0.15-SNAPSHOT
+version=2.1.0
 description=Use MiniMessage text formatting in the server list MOTD.
 
 org.gradle.caching=true

gradle/libs.versions.toml

@@ -22,7 +22,7 @@ bstats = "3.0.2"
 paperApi = "1.16.5-R0.1-SNAPSHOT"
 paperlib = "1.0.8"
 waterfallApi = "1.16-R0.4-SNAPSHOT"
-fabricApi = "0.92.1+1.20.4"
+fabricApi = "0.93.1+1.20.4"
 fabricLoader = "0.15.3"
 minecraft = "1.20.4"
 spongeApi7 = "7.2.0"

platform/bukkit/src/main/java/xyz/jpenilla/minimotd/bukkit/PaperPingListener.java

@@ -33,7 +33,7 @@ import org.checkerframework.checker.nullness.qual.NonNull;
 import xyz.jpenilla.minimotd.common.Constants;
 import xyz.jpenilla.minimotd.common.MiniMOTD;
 import xyz.jpenilla.minimotd.common.PingResponse;
-import xyz.jpenilla.minimotd.common.config.MiniMOTDConfig;
+import xyz.jpenilla.minimotd.common.config.MOTDConfig;
 
 public final class PaperPingListener implements Listener {
   private final LegacyComponentSerializer unusualHexSerializer = LegacyComponentSerializer.builder().hexColors().useUnusualXRepeatedCharacterHexFormat().build();
@@ -45,7 +45,7 @@ public final class PaperPingListener implements Listener {
 
   @EventHandler
   public void handlePing(final @NonNull PaperServerListPingEvent event) {
-    final MiniMOTDConfig cfg = this.miniMOTD.configManager().mainConfig();
+    final MOTDConfig cfg = this.miniMOTD.configManager().mainConfig();
 
     final PingResponse<CachedServerIcon> response = this.miniMOTD.createMOTD(cfg, event.getNumPlayers(), event.getMaxPlayers());
 

platform/bukkit/src/main/java/xyz/jpenilla/minimotd/bukkit/PingListener.java

@@ -32,7 +32,7 @@ import org.bukkit.util.CachedServerIcon;
 import org.checkerframework.checker.nullness.qual.NonNull;
 import xyz.jpenilla.minimotd.common.MiniMOTD;
 import xyz.jpenilla.minimotd.common.PingResponse;
-import xyz.jpenilla.minimotd.common.config.MiniMOTDConfig;
+import xyz.jpenilla.minimotd.common.config.MOTDConfig;
 
 public final class PingListener implements Listener {
   private final MiniMOTD<CachedServerIcon> miniMOTD;
@@ -44,7 +44,7 @@ public final class PingListener implements Listener {
 
   @EventHandler
   public void handlePing(final @NonNull ServerListPingEvent event) {
-    final MiniMOTDConfig cfg = this.miniMOTD.configManager().mainConfig();
+    final MOTDConfig cfg = this.miniMOTD.configManager().mainConfig();
 
     final PingResponse<CachedServerIcon> response = this.miniMOTD.createMOTD(cfg, event.getNumPlayers(), event.getMaxPlayers());
 

platform/bungeecord/src/main/java/xyz/jpenilla/minimotd/bungee/MiniMOTDPlugin.java

@@ -40,7 +40,7 @@ import org.slf4j.LoggerFactory;
 import xyz.jpenilla.minimotd.common.MiniMOTD;
 import xyz.jpenilla.minimotd.common.MiniMOTDPlatform;
 import xyz.jpenilla.minimotd.common.PingResponse;
-import xyz.jpenilla.minimotd.common.config.MiniMOTDConfig;
+import xyz.jpenilla.minimotd.common.config.MOTDConfig;
 import xyz.jpenilla.minimotd.common.util.UpdateChecker;
 
 public final class MiniMOTDPlugin extends Plugin implements MiniMOTDPlatform<Favicon> {
@@ -116,7 +116,7 @@ public final class MiniMOTDPlugin extends Plugin implements MiniMOTDPlatform<Fav
   }
 
   private void preload() {
-    final MiniMOTDConfig cfg = this.miniMOTD.configManager().mainConfig();
+    final MOTDConfig cfg = this.miniMOTD.configManager().mainConfig();
     final PingResponse<Favicon> mini = this.miniMOTD.createMOTD(cfg, 0, 0);
     mini.motd(motd -> BungeeComponentSerializer.get().serialize(motd));
   }

platform/bungeecord/src/main/java/xyz/jpenilla/minimotd/bungee/PingListener.java

@@ -35,7 +35,7 @@ import org.checkerframework.checker.nullness.qual.NonNull;
 import xyz.jpenilla.minimotd.common.Constants;
 import xyz.jpenilla.minimotd.common.MiniMOTD;
 import xyz.jpenilla.minimotd.common.PingResponse;
-import xyz.jpenilla.minimotd.common.config.MiniMOTDConfig;
+import xyz.jpenilla.minimotd.common.config.MOTDConfig;
 
 public final class PingListener implements Listener {
   private final MiniMOTD<Favicon> miniMOTD;
@@ -52,7 +52,7 @@ public final class PingListener implements Listener {
     }
 
     final ServerPing.Players players = response.getPlayers();
-    final MiniMOTDConfig cfg = this.miniMOTD.configManager().resolveConfig(e.getConnection().getVirtualHost());
+    final MOTDConfig cfg = this.miniMOTD.configManager().resolveConfig(e.getConnection().getVirtualHost());
     final PingResponse<Favicon> mini = this.miniMOTD.createMOTD(cfg, players.getOnline(), players.getMax());
 
     if (mini.hidePlayerCount()) {

platform/fabric/src/main/java/xyz/jpenilla/minimotd/fabric/mixin/ServerStatusPacketListenerImplMixin.java

@@ -38,7 +38,7 @@ import org.spongepowered.asm.mixin.injection.Redirect;
 import xyz.jpenilla.minimotd.common.Constants;
 import xyz.jpenilla.minimotd.common.MiniMOTD;
 import xyz.jpenilla.minimotd.common.PingResponse;
-import xyz.jpenilla.minimotd.common.config.MiniMOTDConfig;
+import xyz.jpenilla.minimotd.common.config.MOTDConfig;
 import xyz.jpenilla.minimotd.common.util.ComponentColorDownsampler;
 import xyz.jpenilla.minimotd.fabric.MiniMOTDFabric;
 import xyz.jpenilla.minimotd.fabric.access.ConnectionAccess;
@@ -58,7 +58,7 @@ abstract class ServerStatusPacketListenerImplMixin {
     final ServerStatus vanillaStatus = Objects.requireNonNull(minecraftServer.getStatus(), "vanillaStatus");
 
     final MiniMOTD<ServerStatus.Favicon> miniMOTD = miniMOTDFabric.miniMOTD();
-    final MiniMOTDConfig config = miniMOTD.configManager().mainConfig();
+    final MOTDConfig config = miniMOTD.configManager().mainConfig();
 
     final PingResponse<ServerStatus.Favicon> response = miniMOTD.createMOTD(
       config,

platform/sponge7/src/main/java/xyz/jpenilla/minimotd/sponge7/ClientPingServerEventListener.java

@@ -31,7 +31,7 @@ import org.spongepowered.api.event.server.ClientPingServerEvent;
 import org.spongepowered.api.network.status.Favicon;
 import xyz.jpenilla.minimotd.common.MiniMOTD;
 import xyz.jpenilla.minimotd.common.PingResponse;
-import xyz.jpenilla.minimotd.common.config.MiniMOTDConfig;
+import xyz.jpenilla.minimotd.common.config.MOTDConfig;
 
 final class ClientPingServerEventListener implements EventListener<ClientPingServerEvent> {
   private final MiniMOTD<Favicon> miniMOTD;
@@ -58,7 +58,7 @@ final class ClientPingServerEventListener implements EventListener<ClientPingSer
       }
     }
 
-    final MiniMOTDConfig config = this.miniMOTD.configManager().mainConfig();
+    final MOTDConfig config = this.miniMOTD.configManager().mainConfig();
 
     final PingResponse<Favicon> mini = this.miniMOTD.createMOTD(config, players.getOnline(), players.getMax());
     mini.playerCount().applyCount(players::setOnline, players::setMax);

platform/sponge8/src/main/java/xyz/jpenilla/minimotd/sponge8/ClientPingServerEventListener.java

@@ -33,7 +33,7 @@ import org.spongepowered.api.network.status.Favicon;
 import xyz.jpenilla.minimotd.common.Constants;
 import xyz.jpenilla.minimotd.common.MiniMOTD;
 import xyz.jpenilla.minimotd.common.PingResponse;
-import xyz.jpenilla.minimotd.common.config.MiniMOTDConfig;
+import xyz.jpenilla.minimotd.common.config.MOTDConfig;
 import xyz.jpenilla.minimotd.common.util.ComponentColorDownsampler;
 
 final class ClientPingServerEventListener implements EventListener<ClientPingServerEvent> {
@@ -72,7 +72,7 @@ final class ClientPingServerEventListener implements EventListener<ClientPingSer
       }
     }
 
-    final MiniMOTDConfig config = this.miniMOTD.configManager().mainConfig();
+    final MOTDConfig config = this.miniMOTD.configManager().mainConfig();
 
     final PingResponse<Favicon> mini = this.miniMOTD.createMOTD(config, players.online(), players.max());
     mini.playerCount().applyCount(players::setOnline, players::setMax);

platform/velocity/src/main/java/xyz/jpenilla/minimotd/velocity/PingListener.java

@@ -31,13 +31,16 @@ import com.velocitypowered.api.proxy.ProxyServer;
 import com.velocitypowered.api.proxy.server.RegisteredServer;
 import com.velocitypowered.api.proxy.server.ServerPing;
 import com.velocitypowered.api.util.Favicon;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
 import org.checkerframework.checker.nullness.qual.NonNull;
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.checkerframework.framework.qual.DefaultQualifier;
 import xyz.jpenilla.minimotd.common.MiniMOTD;
 import xyz.jpenilla.minimotd.common.PingResponse;
-import xyz.jpenilla.minimotd.common.config.MiniMOTDConfig;
+import xyz.jpenilla.minimotd.common.config.MOTDConfig;
 
 @DefaultQualifier(NonNull.class)
 public final class PingListener {
@@ -56,7 +59,7 @@ public final class PingListener {
   }
 
   private void handle(final ProxyPingEvent event) {
-    final MiniMOTDConfig config = this.miniMOTD.configManager().resolveConfig(event.getConnection().getVirtualHost().orElse(null));
+    final MOTDConfig config = this.miniMOTD.configManager().resolveConfig(event.getConnection().getVirtualHost().orElse(null));
     final ServerPing.Builder pong = event.getPing().asBuilder();
 
     final List<String> targetServers = config.targetServers();
@@ -64,12 +67,18 @@ public final class PingListener {
     if (targetServers.isEmpty()) {
       playersCount = pong.getOnlinePlayers();
     } else {
+      final Set<ServerPing.SamplePlayer> players = new HashSet<>();
       for (final String serverName : targetServers) {
         final @Nullable RegisteredServer server = this.proxy.getServer(serverName).orElse(null);
         if (server != null) {
           playersCount += server.getPlayersConnected().size();
+          players.addAll(server.getPlayersConnected().stream()
+            .map(p -> new ServerPing.SamplePlayer(p.getGameProfile().getName(), p.getUniqueId()))
+            .collect(Collectors.toList()));
         }
       }
+      pong.clearSamplePlayers();
+      pong.samplePlayers(players.toArray(new ServerPing.SamplePlayer[0]));
     }
 
     final PingResponse<Favicon> response = this.miniMOTD.createMOTD(config, playersCount, pong.getMaximumPlayers());