fix: remove 'replaced' game slot status

playwright.config.ts

@@ -24,19 +24,13 @@ export default defineConfig({
   },
 
   projects: [
-    {
-      name: 'setup database',
-      testMatch: /database\.setup\.ts/,
-    },
     {
       name: 'chromium',
       use: { ...devices['Desktop Chrome'] },
-      dependencies: ['setup database'],
     },
     {
       name: 'firefox',
       use: { ...devices['Desktop Firefox'] },
-      dependencies: ['setup database'],
     },
 
     // {

src/database/models/game-slot.model.ts

@@ -5,7 +5,6 @@ import type { SteamId64 } from '../../shared/types/steam-id-64'
 export enum SlotStatus {
   active = 'active',
   waitingForSubstitute = 'waiting for substitute',
-  replaced = 'replaced',
 }
 
 export enum PlayerConnectionStatus {

src/games/plugins/manage-in-game-players.ts

@@ -23,6 +23,10 @@ export default fp(
     events.on(
       'game:playerReplaced',
       safe(async ({ game, replacee, replacement }) => {
+        if (replacee === replacement) {
+          return
+        }
+
         const re = await collections.players.findOne({ steamId: replacee })
         if (!re) {
           throw new Error(`player not found: ${replacee}`)

src/games/rcon/blacklist-player.ts

@@ -4,11 +4,6 @@ import { delGamePlayer } from './commands'
 import { withRcon } from './with-rcon'
 
 export async function blacklistPlayer(game: GameModel, steamId: SteamId64) {
-  const slot = game.slots.find(slot => slot.player === steamId)
-  if (!slot) {
-    throw new Error(`player not found in game: ${steamId}`)
-  }
-
   return await withRcon(game, async ({ rcon }) => {
     await rcon.send(delGamePlayer(steamId))
   })

src/games/rcon/configure.ts

@@ -3,7 +3,6 @@ import { deburr } from 'lodash-es'
 import { configuration } from '../../configuration'
 import { collections } from '../../database/collections'
 import { GameEventType } from '../../database/models/game-event.model'
-import { SlotStatus } from '../../database/models/game-slot.model'
 import { type GameModel, GameState } from '../../database/models/game.model'
 import { environment } from '../../environment'
 import { logger } from '../../logger'
@@ -147,15 +146,13 @@ async function compileConfig(game: GameModel, password: string): Promise<string[
     .concat(setPassword(password))
     .concat(
       await Promise.all(
-        game.slots
-          .filter(slot => slot.status !== SlotStatus.replaced)
-          .map(async slot => {
-            const player = await collections.players.findOne({ steamId: slot.player })
-            if (player === null) {
-              throw new Error(`player ${slot.player} not found`)
-            }
-            return addGamePlayer(player.steamId, deburr(player.name), slot.team, slot.gameClass)
-          }),
+        game.slots.map(async slot => {
+          const player = await collections.players.findOne({ steamId: slot.player })
+          if (player === null) {
+            throw new Error(`player ${slot.player} not found`)
+          }
+          return addGamePlayer(player.steamId, deburr(player.name), slot.team, slot.gameClass)
+        }),
       ),
     )
     .concat(enablePlayerWhitelist())

src/games/replace-player.ts

@@ -37,32 +37,7 @@ export async function replacePlayer({
     }
 
     let newGame: GameModel
-
-    if (replacee === replacement) {
-      newGame = await update(
-        { number },
-        {
-          $set: {
-            'slots.$[slot].status': SlotStatus.active,
-          },
-          $push: {
-            events: {
-              event: GameEventType.playerReplaced,
-              at: new Date(),
-              replacee,
-              replacement,
-            },
-          },
-        },
-        {
-          arrayFilters: [
-            {
-              $and: [{ 'slot.player': { $eq: replacee } }],
-            },
-          ],
-        },
-      )
-    } else {
+    if (replacee !== replacement) {
       const rm = await collections.players.findOne({ steamId: replacement })
       if (!rm) {
         throw new Error(`replacement player not found: ${replacement}`)
@@ -71,51 +46,42 @@ export async function replacePlayer({
       if (rm.activeGame !== undefined) {
         throw new Error(`player denied: player has active game`)
       }
+    }
 
-      await update(
-        { number },
-        {
-          $push: {
-            slots: {
-              player: replacement,
-              team: slot.team,
-              gameClass: slot.gameClass,
-              status: SlotStatus.active,
-              connectionStatus: PlayerConnectionStatus.offline,
-            },
-            events: {
-              event: GameEventType.playerReplaced,
-              at: new Date(),
-              replacee,
-              replacement,
-            },
-          },
+    newGame = await update(
+      { number },
+      {
+        $set: {
+          'slots.$[slot].status': SlotStatus.active,
+          'slots.$[slot].player': replacement,
+          ...(replacee === replacement
+            ? {}
+            : { 'slots.$[slot].connectionStatus': PlayerConnectionStatus.offline }),
         },
-      )
-
-      newGame = await update(
-        { number },
-        {
-          $set: {
-            'slots.$[slot].status': SlotStatus.replaced,
+        $push: {
+          events: {
+            event: GameEventType.playerReplaced,
+            at: new Date(),
+            replacee,
+            replacement,
           },
         },
-        {
-          arrayFilters: [
-            {
-              $and: [
-                { 'slot.player': { $eq: replacee } },
-                {
-                  'slot.status': {
-                    $eq: SlotStatus.waitingForSubstitute,
-                  },
+      },
+      {
+        arrayFilters: [
+          {
+            $and: [
+              { 'slot.player': { $eq: replacee } },
+              {
+                'slot.status': {
+                  $eq: SlotStatus.waitingForSubstitute,
                 },
-              ],
-            },
-          ],
-        },
-      )
-    }
+              },
+            ],
+          },
+        ],
+      },
+    )
 
     events.emit('game:playerReplaced', { game: newGame, replacee, replacement })
     return game

src/games/request-substitute.ts

@@ -19,7 +19,7 @@ export async function requestSubstitute({
   actor: SteamId64 | Bot
   reason?: string
 }): Promise<GameModel> {
-  logger.trace({ number, replacee, actor, reason }, 'substitutePlayer()')
+  logger.trace({ number, replacee, actor, reason }, 'games.requestSubstitute()')
 
   const game = await collections.games.findOne({ number })
   if (game === null) {

src/games/views/html/game-slot.tsx

@@ -30,7 +30,6 @@ export async function GameSlot(props: {
         {
           [SlotStatus.active]: 'active',
           [SlotStatus.waitingForSubstitute]: 'waiting-for-substitute',
-          [SlotStatus.replaced]: 'replaced',
         }[props.slot.status],
       ]}
       data-player={player.steamId}

src/migrations/005-remove-replaced-game-slots.ts

@@ -0,0 +1,15 @@
+import { collections } from '../database/collections'
+import type { SlotStatus } from '../database/models/game-slot.model'
+
+export async function up() {
+  await collections.games.updateMany(
+    {},
+    {
+      $pull: {
+        slots: {
+          status: 'replaced' as SlotStatus,
+        },
+      },
+    },
+  )
+}

tests/20-game/08-player-substitutes.spec.ts

@@ -0,0 +1,70 @@
+import { secondsToMilliseconds } from 'date-fns'
+import { launchGame as test, expect } from '../fixtures/launch-game'
+
+test.use({ waitForStage: 'started' })
+test.describe('substitutes', () => {
+  test('substitute self', async ({ gameNumber, users, page, gameServer }) => {
+    const admin = users.getAdmin()
+    const adminsPage = await admin.gamePage(gameNumber)
+    const mayflowersPage = await users.byName('Mayflower').gamePage(gameNumber)
+
+    await expect(adminsPage.playerLink('Mayflower')).toBeVisible()
+    await adminsPage.requestSubstitute('Mayflower')
+    await expect(adminsPage.playerLink('Mayflower')).not.toBeVisible()
+    await expect(gameServer).toHaveCommand(`say Looking for replacement for Mayflower...`, {
+      timeout: secondsToMilliseconds(1),
+    })
+
+    await expect(adminsPage.gameEvent(`${admin.playerName} requested substitute`)).toBeVisible()
+    await expect(adminsPage.playerLink('Mayflower')).not.toBeVisible()
+    await expect(mayflowersPage.gameEvent(`${admin.playerName} requested substitute`)).toBeVisible()
+    await expect(mayflowersPage.playerLink('Mayflower')).not.toBeVisible()
+
+    await expect(
+      page.getByText(`Team BLU needs a substitute for scout in game #${mayflowersPage.gameNumber}`),
+    ).toBeVisible()
+
+    await mayflowersPage.replacePlayer('Mayflower')
+
+    await expect(adminsPage.playerLink('Mayflower')).toBeVisible()
+    await expect(adminsPage.gameEvent(`Mayflower replaced Mayflower`)).toBeVisible()
+    await expect(mayflowersPage.playerLink('Mayflower')).toBeVisible()
+    await expect(mayflowersPage.gameEvent(`Mayflower replaced Mayflower`)).toBeVisible()
+  })
+
+  test('substitute other', async ({ gameNumber, users, page, gameServer }) => {
+    const admin = users.getAdmin()
+    const adminsPage = await admin.gamePage(gameNumber)
+    const tommyGunsPage = await users.byName('TommyGun').gamePage(gameNumber)
+    await tommyGunsPage.goto()
+
+    await expect(adminsPage.playerLink('Mayflower')).toBeVisible()
+    await adminsPage.requestSubstitute('Mayflower')
+    await expect(adminsPage.playerLink('Mayflower')).not.toBeVisible()
+    await expect(gameServer).toHaveCommand(`say Looking for replacement for Mayflower...`, {
+      timeout: secondsToMilliseconds(1),
+    })
+
+    await expect(adminsPage.gameEvent(`${admin.playerName} requested substitute`)).toBeVisible()
+    await expect(adminsPage.playerLink('Mayflower')).not.toBeVisible()
+    await expect(tommyGunsPage.gameEvent(`${admin.playerName} requested substitute`)).toBeVisible()
+    await expect(tommyGunsPage.playerLink('Mayflower')).not.toBeVisible()
+
+    await expect(
+      page.getByText(`Team BLU needs a substitute for scout in game #${adminsPage.gameNumber}`),
+    ).toBeVisible()
+
+    await tommyGunsPage.replacePlayer('Mayflower')
+
+    await expect(adminsPage.playerLink('TommyGun')).toBeVisible()
+    await expect(adminsPage.gameEvent(`TommyGun replaced Mayflower`)).toBeVisible()
+    await expect(tommyGunsPage.playerLink('TommyGun')).toBeVisible()
+    await expect(tommyGunsPage.gameEvent(`TommyGun replaced Mayflower`)).toBeVisible()
+
+    await expect(gameServer).toHaveCommand(`sm_game_player_add ${users.byName('TommyGun').steamId}`)
+    await expect(gameServer).toHaveCommand(
+      `sm_game_player_del ${users.byName('Mayflower').steamId}`,
+    )
+    await expect(gameServer).toHaveCommand(`say Mayflower has been replaced by TommyGun`)
+  })
+})

tests/50-player-behavior/01-auto-requests-substitute.spec.ts → tests/20-game/09-auto-substitute-requests.spec.ts

@@ -2,7 +2,6 @@ import { secondsToMilliseconds } from 'date-fns'
 import { GamePage } from '../pages/game.page'
 import { expect, mergeTests } from '@playwright/test'
 import { accessMongoDb } from '../fixtures/access-mongo-db'
-import type { UserContext } from '../user-manager'
 import { launchGame } from '../fixtures/launch-game'
 
 const test = mergeTests(launchGame, accessMongoDb)