Runtime work for continuous games

Author: RussellLVP

javascript/features/games/game_commands.js

@@ -5,6 +5,7 @@
 import { CommandBuilder } from 'components/command_manager/command_builder.js';
 import { GameActivity } from 'features/games/game_activity.js';
 import { GameRegistration } from 'features/games/game_registration.js';
+import { GameRuntime } from 'features/games/game_runtime.js';
 import { Menu } from 'components/menu/menu.js';
 import { Question } from 'components/dialogs/question.js';
 import { Setting } from 'entities/setting.js';
@@ -189,6 +190,32 @@ export class GameCommands {
             return;
         }
 
+        // If the |description| accepts continuous participation, players can join and leave as they
+        // please. We need to handle this case in the sign-up logic as well.
+        const activeRuntimes = this.manager_.getActiveGameRuntimes(description);
+
+        for (const activeRuntime of activeRuntimes) {
+            if (activeRuntime.state != GameRuntime.kStateRunning)
+                continue;
+            
+            // TODO: We might want to support settings and custom options for continuous games, in
+            // which case joining the first one is not the right thing to do. This requires a
+            // `mapEquals` and private/public check like the block above.
+
+            // Take the registration fee from the |player|.
+            this.finance_().takePlayerCash(player, description.price);
+
+            player.sendMessage(
+                Message.GAME_REGISTRATION_JOINED, activeRuntime.getActivityName());
+            
+            this.nuwani_().echo(
+                'notice-minigame', player.name, player.id, activeRuntime.getActivityName());
+            
+            // Actually have the |player| join the |activeRuntime|, and we're done here.
+            await activeRuntime.addPlayer(player, description.price);
+            return;
+        }
+
         // If a |registrationId| was given, and we reach this point, then it was invalid. Tell 'em.
         if (registrationId) {
             player.sendMessage(Message.GAME_REGISTRATION_INVALID_ID);

javascript/features/games/game_manager.js

@@ -49,6 +49,9 @@ export class GameManager {
         server.playerManager.addObserver(this);
     }
 
+    // Gets access to the active runtimes, for testing purposes only.
+    get activeRuntimesForTesting() { return this.runtimes_; }
+
     // ---------------------------------------------------------------------------------------------
 
     // Returns the activity the |player| is engaged in as a `GameActivity` instance, if any.
@@ -113,6 +116,18 @@ export class GameManager {
 
     // ---------------------------------------------------------------------------------------------
 
+    // Returns an array with the active game runtimes for the given |description|.
+    getActiveGameRuntimes(description) {
+        let runtimesForGame = [];
+
+        for (const runtime of this.runtimes_) {
+            if (runtime.description === description)
+                runtimesForGame.push(runtime);
+        }
+
+        return runtimesForGame;
+    }
+
     // Immediately stops all games that are either accepting sign-ups or in-progress because the
     // game described by |description| will no longer be available.
     stopAllActiveGames(description) {

javascript/features/games/game_runtime.js

@@ -12,7 +12,7 @@ import { showCountdownForPlayer } from 'features/games/game_countdown.js';
 export class GameRuntime extends GameActivity {
     // The states in lifetime progression the game runtime supports.
     static kStateUninitialized = 0;
-    static kStateInitialized= 1;
+    static kStateInitialized = 1;
     static kStateRunning = 2;
     static kStateFinished = 3;
     static kStateFinalized = 4;
@@ -44,7 +44,7 @@ export class GameRuntime extends GameActivity {
     get players() { return this.players_; }
 
     // Getst the state the game is in. Only exposed for testing purposes.
-    get stateForTesting() { return this.state_; }
+    get state() { return this.state_; }
 
     // Gets the virtual world that has bene allocated to this game.
     get virtualWorld() { return this.virtualWorld_; }

javascript/features/games/game_runtime.test.js

@@ -307,7 +307,7 @@ describe('GameRuntime', (it, beforeEach) => {
         assert.equal(
             manager.getPlayerActivity(russell).getActivityState(), GameActivity.kStateEngaged);
 
-        assert.equal(runtime.stateForTesting, GameRuntime.kStateRunning);
+        assert.equal(runtime.state, GameRuntime.kStateRunning);
 
         assert.isNotNull(vehicles[0]);
         assert.equal(vehicles[0].virtualWorld, runtime.virtualWorld);
@@ -329,7 +329,7 @@ describe('GameRuntime', (it, beforeEach) => {
         await runGameLoop();
 
         // Both players have been told to leave the game, so it should now have been finalized.
-        assert.equal(runtime.stateForTesting, GameRuntime.kStateFinalized);
+        assert.equal(runtime.state, GameRuntime.kStateFinalized);
         assert.equal(manager.runtimes_.size, 0);
 
         assert.equal(gunther.messages.length, 3);
@@ -392,6 +392,81 @@ describe('GameRuntime', (it, beforeEach) => {
         }
     });
 
+    it('should enable players to join continuous games at any time', async (assert) => {
+        const feature = server.featureManager.loadFeature('games');
+        const finance = server.featureManager.loadFeature('finance');
+
+        let activePlayers = 0;
+        let initialized = false;
+
+        feature.registerGame(class extends Game {
+            async onInitialized(settings) {
+                if (initialized)
+                    throw new Error('The game already has been initialized.');
+                
+                initialized = true;
+            }
+
+            async onPlayerAdded(player) { ++activePlayers; }
+            async onPlayerRemoved(player) { --activePlayers; }
+        }, {
+            name: 'Bubble',
+            goal: 'Have entities',
+
+            command: 'bubblegame',
+            price: 500,
+
+            continuous: true,
+            minimumPlayers: 1,
+            maximumPlayers: 4,
+        });
+
+        finance.givePlayerCash(gunther, 2500);
+        finance.givePlayerCash(russell, 2500);
+
+        assert.isNull(manager.getPlayerActivity(gunther));
+        assert.isNull(manager.getPlayerActivity(russell));
+
+        // (1) The game should start immediately for |gunther|, even though other players are
+        // available. This is because it's been marked as a continuous game.
+        assert.isTrue(await gunther.issueCommand('/bubblegame'));
+
+        assert.isNotNull(manager.getPlayerActivity(gunther));
+        assert.equal(
+            manager.getPlayerActivity(gunther).getActivityState(), GameActivity.kStateEngaged);
+        
+        assert.equal(activePlayers, 1);
+
+        // (2) Have Russell join the game as well. They should be added to the active game, rather
+        // than be routed through registration and in a new game instead.
+        assert.isTrue(await russell.issueCommand('/bubblegame'));
+
+        assert.isNotNull(manager.getPlayerActivity(russell));
+        assert.equal(
+            manager.getPlayerActivity(russell).getActivityState(), GameActivity.kStateEngaged);
+        
+        assert.strictEqual(manager.getPlayerActivity(gunther), manager.getPlayerActivity(russell));
+        assert.equal(activePlayers, 2);
+
+        // (3) Have Gunther leave the game. Russell should still be playing.
+        assert.isTrue(await gunther.issueCommand('/leave'));
+
+        assert.isNull(manager.getPlayerActivity(gunther));
+        assert.equal(activePlayers, 1);
+
+        assert.isNotNull(manager.getPlayerActivity(russell));
+        assert.equal(
+            manager.getPlayerActivity(russell).getActivityState(), GameActivity.kStateEngaged);
+
+        // (4) When Russell leaves the game as well, it should be stopped. Here we mimic that by
+        // Russell disconnecting, because we're already testing the `/leave` command above.
+        russell.disconnectForTesting();
+
+        // Wait until there are no more active runtimes, to verify state is cleaned up.
+        while (manager.activeRuntimesForTesting.size)
+            await server.clock.advance(50);
+    });
+
     it('should have a sensible description when casted to a string', assert => {
         const description = new GameDescription(Game, { name: 'Bubble', goal: '' });
         const runtime = new GameRuntime(manager, description, kDefaultSettings);