Merge pull request #21 from Mirasaki/feat/next-restart

Feat: next restart in ... functionality

Author: FlorianSW

docker-compose.yml

@@ -15,6 +15,7 @@ services:
       PLAYER_COUNT_PROVIDER: ${PLAYER_COUNT_PROVIDER}
       DISCORD_PUBLISHER_MESSAGE_FORMAT: ${DISCORD_PUBLISHER_MESSAGE_FORMAT}
       DISCORD_PUBLISHER_MESSAGE_QUEUED_FORMAT: ${DISCORD_PUBLISHER_MESSAGE_QUEUED_FORMAT}
+      DISCORD_PUBLISHER_MESSAGE_NEXT_RESTART_FORMAT: ${DISCORD_PUBLISHER_MESSAGE_NEXT_RESTART_FORMAT}
       STEAM_API_TOKEN: ${STEAM_API_TOKEN}
       GAME_ADDRESS: ${GAME_ADDRESS}
       BM_ACCESS_TOKEN: ${BM_ACCESS_TOKEN}

example.env

@@ -41,6 +41,12 @@ DISCORD_TOKEN=
 # count provider, the game and the used game server.
 DISCORD_MESSAGE_CHANNEL_ID=
 
+# Next Restart Configuration - Restart times in LOCAL hours (local = time of the machine this app will be hosted on)
+# PLEASE NOTE: "Next restart in..." is NOT powered by an API (nor does it restart your servers), it instead requires
+# an absolute restart schedule. If you change your restart schedule, you WILL
+# need to change this to prevent feeding misinformation to your players.
+# Format: Comma separated list (eg. "0,6,12,18" for every 6 hours)
+ABSOLUTE_RESTART_TIMES=0,4,8,12,16,20
 
 # Message formats
 # You can define your own message formats for the player count display in the user list in Discord.
@@ -49,6 +55,9 @@ DISCORD_MESSAGE_CHANNEL_ID=
 #  - maxPlayers: The maximum number of players that can be on the server
 #  - queuedPlayersMessage: The message as defined in DISCORD_PUBLISHER_MESSAGE_QUEUED_FORMAT (only makes sense when the server supports a player queue
 #  - queuedPlayers: The number of players currently in the queue
+#  - nextRestartMessage: The message as defined in DISCORD_PUBLISHER_MESSAGE_NEXT_RESTART_FORMAT (only used/parsed when ABSOLUTE_RESTART_TIMES is provided and valid)
+#  - nextRestartRelative: Relative time until next server restart
 # Example (uncomment if editing):
-# DISCORD_PUBLISHER_MESSAGE_FORMAT='${playerCount}/${maxPlayers} ${queuedPlayersMessage}'
+# DISCORD_PUBLISHER_MESSAGE_FORMAT='${playerCount}/${maxPlayers} ${queuedPlayersMessage} ${nextRestartMessage}'
 # DISCORD_PUBLISHER_MESSAGE_QUEUED_FORMAT='(+${queuedPlayers})'
+# DISCORD_PUBLISHER_MESSAGE_NEXT_RESTART_FORMAT='⌛ Restart: ${nextRestartRelative}'

src/adapter/discord/discord-publisher.ts

@@ -8,16 +8,69 @@ import {MapsRepository} from '../../domain/maps-repository.js';
 export interface MessageFormats {
     playerCount: string,
     queuedPlayers: string,
+    nextRestart: string,
 }
 
 export class DiscordPublisher implements GameStatusPublisher {
     private messageId: string | undefined;
     private channel: TextChannel | undefined;
+    private nextRestartTimes: number[] | undefined;
+
+    public msUntilNextRestart(): number | null {
+        if (!this.nextRestartTimes || this.nextRestartTimes.length === 0) {
+            return null;
+        }
+        const now = new Date();
+        const currentHour = now.getHours();
+        const nextRestartHour = this.nextRestartTimes.find((t) => t > currentHour);
+        if (nextRestartHour === undefined) {
+            return null;
+        }
+        const nextRestartDate = new Date(now.getFullYear(), now.getMonth(), now.getDate(), nextRestartHour, 0, 0);
+        if (nextRestartDate < now) {
+            nextRestartDate.setDate(nextRestartDate.getDate() + 1);
+        }
+        return nextRestartDate.getTime() - now.getTime();
+    }
+
+    public humanReadableMs(ms: number): string {
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+
+        const pluralize = (value: number, unit: string): string => {
+            return `${value} ${unit}${value !== 1 ? 's' : ''}`;
+        };
+
+        const parts: string[] = [];
+        if (hours > 0) {
+            parts.push(pluralize(hours, 'hour'));
+        }
+        if (minutes % 60 > 0) {
+            parts.push(pluralize(minutes % 60, 'minute'));
+        }
+        if (parts.length === 0 && seconds % 60 > 0) {
+            parts.push(pluralize(seconds % 60, 'second'));
+        }
+        if (parts.length === 0) {
+            return 'less than a second';
+        }
+
+        return parts.join(', ');
+    }
 
     constructor(private readonly client: Client, private readonly maps: MapsRepository, private readonly formats: MessageFormats) {
         if (!process.env.DISCORD_MESSAGE_CHANNEL_ID) {
             return
         }
+        if (process.env.ABSOLUTE_RESTART_TIMES?.length) {
+            const times = process.env.ABSOLUTE_RESTART_TIMES.split(',').map((t) => parseInt(t.trim(), 10));
+            if (times.some((t) => isNaN(t) || t < 0 || t > 23)) {
+                throw new Error('Invalid ABSOLUTE_RESTART_TIMES provided, must be a comma separated list of integers between (inclusive) 0 and 23.');
+            }
+            console.log('Using absolute restart times: ' + times.join(', '));
+            this.nextRestartTimes = times;
+        }
         this.updateCreateStatusMessage().then((c) => {
             console.log('Created or updates initial status message...');
             this.messageId = c.messageId;
@@ -103,6 +156,27 @@ export class DiscordPublisher implements GameStatusPublisher {
                   .replace('${queuedPlayersMessage}', '')
                   .replace('${queuedPlayers}', '');
             }
+            const hasNextRestartMessage = message.indexOf('${nextRestartMessage}') !== -1;
+            const hasNextRestartRelative = message.indexOf('${nextRestartRelative}') !== -1;
+            if (hasNextRestartMessage || hasNextRestartRelative) {
+                const nextRestart = this.msUntilNextRestart();
+                if (nextRestart !== null) {
+                  const humanReadableNextRestart = this.humanReadableMs(nextRestart);
+                    if (hasNextRestartMessage) {
+                        message = message.replace(
+                            '${nextRestartMessage}',
+                            this.formats.nextRestart.replace('${nextRestartRelative}', humanReadableNextRestart)
+                        );
+                    }
+                    if (hasNextRestartRelative) {
+                        message = message.replace('${nextRestartRelative}', humanReadableNextRestart);
+                    }
+                } else {
+                    message = message
+                      .replace('${nextRestartMessage}', '')
+                      .replace('${nextRestartRelative}', '');
+                }
+            }
             this.client.user?.setPresence({
                 status: 'online',
                 activities: [{

src/index.ts

@@ -22,8 +22,9 @@ class App {
         this.client = await this.createDiscordClient();
         try {
             const publisher = new DiscordPublisher(this.client, new FileBackedMapRepository(), {
-                playerCount: process.env.DISCORD_PUBLISHER_MESSAGE_FORMAT || '${playerCount}/${maxPlayers} $queuedPlayersMessage',
+                playerCount: process.env.DISCORD_PUBLISHER_MESSAGE_FORMAT || '${playerCount}/${maxPlayers} $queuedPlayersMessage ${nextRestartMessage}',
                 queuedPlayers: process.env.DISCORD_PUBLISHER_MESSAGE_QUEUED_FORMAT || '(+${queuedPlayers})',
+                nextRestart: process.env.DISCORD_PUBLISHER_MESSAGE_NEXT_RESTART_FORMAT || '⌛ Restart: ${nextRestartRelative}',
             });
             this.useCase = new ProvideGameStatus(providerFactory().build(), publisher);
         } catch (e) {