darkstarworks velocity patch 1.1

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

@@ -54,6 +54,8 @@ public final class ConfigManager {
 
   private final Map<String, MOTDConfig> extraConfigs = new HashMap<>();
 
+  private @Nullable MOTDConfig offlineConfig = null;
+
   public ConfigManager(final @NonNull MiniMOTD<?> miniMOTD) {
     this.miniMOTD = miniMOTD;
     this.mainConfigLoader = new ConfigLoader<>(
@@ -104,6 +106,9 @@ public void loadExtraConfigs() {
           this.extraConfigs.put(name, config);
         }
       }
+
+      this.loadOfflineConfig();
+
     } catch (final IOException e) {
       throw new IllegalStateException("Failed to load virtual host configs", e);
     }
@@ -165,4 +170,28 @@ private void createDefaultExtraConfigs(final @NonNull Path extraConfigsDir) thro
     return this.mainConfig();
   }
 
+  public @Nullable MOTDConfig getOfflineConfig() {
+    return this.offlineConfig;
+  }
+
+  private void loadOfflineConfig() {
+    final Path offlineConfigPath = this.miniMOTD.dataDirectory().resolve("offline-config.conf");
+    if (Files.exists(offlineConfigPath)) {
+      try {
+        final ConfigLoader<MOTDConfig> loader = new ConfigLoader<>(
+          MOTDConfig.class,
+          offlineConfigPath,
+          options -> options.header("MiniMOTD Offline Configuration")
+        );
+        this.offlineConfig = loader.load();
+        loader.save(this.offlineConfig);
+        this.miniMOTD.logger().info("Loaded offline MOTD configuration");
+      } catch (final ConfigurateException e) {
+        this.miniMOTD.logger().error("Failed to load offline config", e);
+        this.offlineConfig = null;
+      }
+    } else {
+      this.offlineConfig = null;
+    }
+  }
 }

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

@@ -59,6 +59,10 @@ public MOTDConfig(final @NonNull MOTD @NonNull ... defaults) {
   @Comment("Enable server list icon related features")
   private boolean iconEnabled = true;
 
+  @Comment("Enable offline MOTD when all servers are offline\n"
+  + "Requires offline-config.conf file to be present")
+  private boolean useOfflineMotd = false;
+
   private PlayerCountSettings playerCountSettings = new PlayerCountSettings();
 
   @ConfigSerializable
@@ -215,4 +219,8 @@ private int calculateMaxPlayers(final int onlinePlayers, final int maxPlayers) {
     }
     return playerCount(online, max);
   }
+
+  public boolean useOfflineMotd() {
+    return this.useOfflineMotd;
+  }
 }

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

@@ -60,27 +60,49 @@ public EventTask onProxyPingEvent(final ProxyPingEvent event) {
   private void handle(final ProxyPingEvent event) {
     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();
+
     int playersCount = 0;
+    boolean allServersOffline = false;
     if (targetServers.isEmpty()) {
       playersCount = pong.getOnlinePlayers();
+      // See if all servers offline when no targets are specified
+      allServersOffline = this.proxy.getAllServers().stream()
+        .allMatch(server -> server.getPlayersConnected().isEmpty());
     } else {
       final Set<ServerPing.SamplePlayer> players = new HashSet<>();
+      int onlineServerCount = 0;
       for (final String serverName : targetServers) {
         final @Nullable RegisteredServer server = this.proxy.getServer(serverName).orElse(null);
         if (server != null) {
-          playersCount += server.getPlayersConnected().size();
+          final int serverPlayers = server.getPlayersConnected().size();
+          if (serverPlayers > 0) {
+            onlineServerCount++;
+          }
+          playersCount += serverPlayers;
           players.addAll(server.getPlayersConnected().stream()
             .map(p -> new ServerPing.SamplePlayer(p.getGameProfile().getName(), p.getUniqueId()))
             .collect(Collectors.toList()));
         }
       }
+      // All servers offline if 0 players and 0 online servers
+      allServersOffline = (onlineServerCount == 0 && playersCount == 0);
       pong.clearSamplePlayers();
       pong.samplePlayers(players.toArray(new ServerPing.SamplePlayer[0]));
     }
 
-    final PingResponse<Favicon> response = this.miniMOTD.createMOTD(config, playersCount, pong.getMaximumPlayers());
+    // Use offline config if true and all servers are offline
+    final MOTDConfig activeConfig;
+
+    if (allServersOffline && config.useOfflineMotd()) {
+      // Try for offline-specific config
+      final @Nullable MOTDConfig offlineConfig = this.miniMOTD.configManager().getOfflineConfig();
+      activeConfig = offlineConfig != null ? offlineConfig : config;
+    } else {
+      activeConfig = config;
+    }
+
+    final PingResponse<Favicon> response = this.miniMOTD.createMOTD(activeConfig, playersCount, pong.getMaximumPlayers());
     response.icon(pong::favicon);
     response.motd(pong::description);
     response.playerCount().applyCount(pong::onlinePlayers, pong::maximumPlayers);
@@ -94,4 +116,4 @@ private void handle(final ProxyPingEvent event) {
 
     event.setPing(pong.build());
   }
-}
+}