Simplify how player commands work in JavaScript

Author: RussellLVP

data/messages.json

@@ -485,6 +485,7 @@
   "PLAYER_COMMANDS_SPAWN_WEAPONS_TELEPORT" : "@error Sorry, you can't get weapons now because you %s.",
   "PLAYER_COMMANDS_SPAWN_WEAPONS_TELEPORT_TARGET" : "@error Sorry, the player can't get weapons now because %s %s.",
   "PLAYER_COMMANDS_SPAWN_WEAPONS_WEAPON": "@success %s with ammo multiplier '%d' has been bought.",
+  "PLAYER_COMMANDS_REQUIRES_VIP": "@error Sorry, this command is only available for VIPs. Check out /vip!",
 
   "POSITIONING_CURRENT_POSITION": "Your current position is X: %d, Y: %d Z: %d, Rotation: %d",
   "POSITIONING_OTHER_USAGE_POS": "{FF9900}Other usage{FFFFFF}: /pos [x] [y] [z]",

javascript/features/player_commands/commands/spawn_weapons.js

@@ -9,44 +9,29 @@ import { WeaponData } from 'features/player_commands/weapon_data.js';
 // Using the spawnweapons command is a bit more expensive than using the ammunation.
 const ExtraPriceFactor = 1.5;
 
-// Command: spawnweapons [weaponId] [multipler]
-export default class SpawnWeapons extends PlayerCommand {
+// Implementation of the "/my spawnweapons" and "/p [player] spawnweapons" commands. Enables players
+// to purchase spawn weapons for the duration of their playing session.
+export class SpawnWeapons extends PlayerCommand {
     get name() { return 'spawnweapons'; }
-
-    setCommandParameters(commandBuilder) {
-        return commandBuilder
-            .parameters([
-                { name: 'weapon', type: CommandBuilder.NUMBER_PARAMETER },
-                { name: 'multiplier', type: CommandBuilder.NUMBER_PARAMETER }
-            ]);
-    }
-
-    build(commandBuilder) {
-        this.setCommandParameters(commandBuilder)
-            .build(SpawnWeapons.prototype.onSpawnWeaponsCommand.bind(this));
+    get parameters() {
+        return [
+            { name: 'weapon', type: CommandBuilder.NUMBER_PARAMETER },
+            { name: 'multiplier', type: CommandBuilder.NUMBER_PARAMETER, defaultValue: 1 }
+        ];
     }
 
-    buildAdmin(commandBuilder) {
-        this.setCommandParameters(commandBuilder)
-            .build(SpawnWeapons.prototype.giveSpawnWeapon.bind(this));
-    }
-
-    // Let the player buy spawn weapons
-    onSpawnWeaponsCommand(player, weapon, multiplier) {
-        this.giveSpawnWeapon(player, player, weapon, multiplier);
-    }
+    // Called when the command is executed by the |player| for the |target|, which may be another
+    // player. The |weapon| and |multiplier| are guaranteed to be given.
+    execute(player, target, weapon, multiplier) {
+        const teleportStatus = this.limits().canTeleport(target);
 
-    // Gve the |subject| their |weapon| with |multiplier| * ammunations (from config).
-    // If |player| is not |subject| an admin gives the weapon. Costs are not applied.
-    giveSpawnWeapon(player, subject, weapon, multiplier) {        
-        const teleportStatus = this.limits_().canTeleport(subject);
         // Bail out if the |player| might abuse it.
         if (!teleportStatus.isApproved()) {
-            if (player.id === subject.id) {
+            if (player.id === target.id) {
                 player.sendMessage(Message.PLAYER_COMMANDS_SPAWN_WEAPONS_TELEPORT, teleportStatus);
             } else {
                 player.sendMessage(
-                    Message.PLAYER_COMMANDS_SPAWN_WEAPONS_TELEPORT_TARGET, subject.name,
+                    Message.PLAYER_COMMANDS_SPAWN_WEAPONS_TELEPORT_TARGET, target.name,
                     teleportStatus);
             }
 
@@ -65,21 +50,21 @@ export default class SpawnWeapons extends PlayerCommand {
 
         const weaponData = WeaponData.getWeaponById(weapon);
 
-        if (player === subject) {
+        if (player === target) {
             const price = weaponData.basePrice * multiplier * ExtraPriceFactor;
-            if (this.finance_().getPlayerCash(player) < price) {
+            if (this.finance().getPlayerCash(player) < price) {
                 player.sendMessage(Message.PLAYER_COMMANDS_SPAWN_WEAPONS_NOT_ENOUGH_MONEY, price);
                 return;
             }
 
-            this.finance_().takePlayerCash(player, price);
+            this.finance().takePlayerCash(player, price);
         }
 
         if (weaponData.id === 1337 /* armour */) {
-            subject.giveSpawnArmour();
+            target.giveSpawnArmour();
             player.sendMessage(Message.PLAYER_COMMANDS_SPAWN_WEAPONS_ARMOUR);
         } else {
-            subject.giveSpawnWeapon(weaponData.id, multiplier);
+            target.giveSpawnWeapon(weaponData.id, multiplier);
             player.sendMessage(
                 Message.PLAYER_COMMANDS_SPAWN_WEAPONS_WEAPON, weaponData.name, multiplier);
         }

javascript/features/player_commands/commands/spawn_weapons.test.js

@@ -2,83 +2,75 @@
 // Use of this source code is governed by the MIT license, a copy of which can
 // be found in the LICENSE file.
 
-import SpawnWeapons from 'features/player_commands/commands/spawn_weapons.js';
-
-describe('SpawnWeapons', (it, beforeEach, afterEach) => {
-    let command = null;
+describe('SpawnWeapons', (it, beforeEach) => {
+    let finance = null;
     let gunther = null;
     let russell = null;
-    let finance = null;
 
     beforeEach(async () => {
-        const announce = server.featureManager.loadFeature('announce');
-        const limits = server.featureManager.loadFeature('limits');
+        const feature = server.featureManager.loadFeature('player_commands');
 
         finance = server.featureManager.loadFeature('finance');
+        gunther = server.playerManager.getById(/* Gunther= */ 0);
+        russell = server.playerManager.getById(/* Russell= */ 1);
+        russell.level = Player.LEVEL_ADMINISTRATOR;
 
-        command = new SpawnWeapons(() => announce, () => finance, () => limits);
-
-        gunther = server.playerManager.getById(0 /* Gunther */);
-        russell = server.playerManager.getById(1 /* Russell */);
-        await gunther.identify();
+        await feature.registry_.initialize();
         await russell.identify();
-        russell.level = Player.LEVEL_ADMINISTRATOR;
     });
 
-    it('should not allow buying weapons if it might be abuse.', assert => {
+    it('should not allow buying weapons if it might be abuse', async (assert) => {
         gunther.shoot({ target: russell });
 
-        command.onSpawnWeaponsCommand(gunther, 24, 1);
+        assert.isTrue(await gunther.issueCommand('/my spawnweapons 24 1'));
 
         assert.equal(gunther.messages.length, 1);
         assert.includes(gunther.messages[0], `Sorry, you can't get weapons now because you`);
     });
 
-    it('should not be able to give an invalid spawn weapon.', async assert => {
-        command.giveSpawnWeapon(gunther, gunther, 35, 1);
+    it('should not be able to give an invalid spawn weapon', async (assert) => {
+        assert.isTrue(await gunther.issueCommand('/my spawnweapons 35'));
 
         assert.equal(gunther.messages.length, 1);
         assert.includes(gunther.messages[0], 'Sorry, id 35 is not a valid spawn weapon.');
     });
 
-    it('should not be able to use zero as multiplier.', async assert => {
-        command.giveSpawnWeapon(gunther, gunther, 24, 0);
+    it('should not be able to use zero as multiplier', async (assert) => {
+        assert.isTrue(await gunther.issueCommand('/my spawnweapons 24 0'));
 
         assert.equal(gunther.messages.length, 1);
         assert.includes(gunther.messages[0], 'Sorry, you can only have a multiplier of 1-100.');
-    });
 
-    it('should not be able to use 101 as multiplier.', async assert => {
-        command.giveSpawnWeapon(gunther, gunther, 24, 101);
+        assert.isTrue(await gunther.issueCommand('/my spawnweapons 24 101'));
 
-        assert.equal(gunther.messages.length, 1);
-        assert.includes(gunther.messages[0], 'Sorry, you can only have a multiplier of 1-100.');
+        assert.equal(gunther.messages.length, 2);
+        assert.includes(gunther.messages[1], 'Sorry, you can only have a multiplier of 1-100.');
     });
 
-    it('should give error if player does not have enough cash.', async assert => {
-        command.giveSpawnWeapon(gunther, gunther, 24, 10);
+    it('should give error if player does not have enough cash', async (assert) => {
+        assert.isTrue(await gunther.issueCommand('/my spawnweapons 24'));
 
         assert.equal(gunther.messages.length, 1);
         assert.includes(gunther.messages[0], 'Sorry, you need');
     });
 
     it('should be able to give spawn armour to other player without money.', async assert => {
-        command.giveSpawnWeapon(russell, gunther, 1337, 1);
+        assert.isTrue(await russell.issueCommand('/p gunther spawnweapons 1337'));
 
         assert.equal(russell.messages.length, 1);
         assert.equal(
             russell.messages[0], Message.format(Message.PLAYER_COMMANDS_SPAWN_WEAPONS_ARMOUR));
+
         assert.equal(gunther.messages.length, 0);
     });
 
-    it('should give spawn weapon if everything aligns nicely', async assert => {
+    it('should give spawn weapon if everything aligns nicely', async (assert) => {
         finance.givePlayerCash(gunther, 1000000);
 
-        command.onSpawnWeaponsCommand(gunther, 24, 1);
+        assert.isTrue(await gunther.issueCommand('/my spawnweapons 24'));
 
         assert.equal(gunther.messages.length, 1);
         assert.includes(
             gunther.messages[0], `Desert Eagle with ammo multiplier '1' has been bought.`);
     });
-
 });

javascript/features/player_commands/player_command.js

@@ -2,26 +2,60 @@
 // Use of this source code is governed by the MIT license, a copy of which can
 // be found in the LICENSE file.
 
-// The playerCommand can be used by using /my [playerCommand] [params]
+// Represents a player-bound command. Accessible using either "/my [name]" or "/p [player] [name]"
+// when the player executing the command is an administrator. Has access to various dependencies.
 export class PlayerCommand {
+    #announce_ = null;
+    #finance_ = null;
+    #limits_ = null;
+
     constructor(announce, finance, limits) {
-        this.announce_ = announce;
-        this.finance_ = finance;
-        this.limits_ = limits;
+        this.#announce_ = announce;
+        this.#finance_ = finance;
+        this.#limits_ = limits;
     }
 
-    // Gets the name of the current command. Must be implemented by the command.
-    get name() {
-        throw new Error('Command::name getter must be implemented by the command.');
-    }
+    // Gets read-only access to the dependencies available to commands.
+    get announce() { return this.#announce_; }
+    get finance() { return this.#finance_; }
+    get limits() { return this.#limits_; }
 
-    // Builds the command based on |commandBuilder|. Must be implemented by the command.
-    build(commandBuilder) {
-        throw new Error('Command::build() must be implemented by the command: /' + this.name);
-    }
+    // ---------------------------------------------------------------------------------------------
+    // Required API to be implemented by individual commands.
+    // ---------------------------------------------------------------------------------------------
+
+    // Gets the name of the command ("/{name}").
+    get name() { throw new Error('PlayerCommand::name is expected to be implemented.'); }
+
+    // Executes the command, which has been invoked by the |player|, for the |target|. The |target|
+    // may either be the |player| (when /my is used), or another player through administrator use.
+    execute(player, target) {}
+
+    // ---------------------------------------------------------------------------------------------
+    // Optional API to be implemented by individual commands.
+    // ---------------------------------------------------------------------------------------------
+
+    // Gets the required level for this command to be available through the "/p [player]" command.
+    get administratorLevel() { return Player.LEVEL_ADMINISTRATOR; }
 
-    // Build the admin version o the command based on |commandBuilder|
-    buildAdmin(commandBuilder) { }
+    // Gets the parameters (& default values) available when players run this command.
+    get parameters() { return []; }
 
-    dispose() {}
+    // Gets the required level for this command to be available through the "/my" command.
+    get playerLevel() { return Player.LEVEL_PLAYER; }
+
+    // Gets whether players have to be VIP in order to be able to execute this command.
+    get playerVip() { return false; }
+
+    // ---------------------------------------------------------------------------------------------
+
+    toString() { return `[object PlayerCommand("/${this.name}")]`; }
+
+    // ---------------------------------------------------------------------------------------------
+
+    dispose() {
+        this.#announce_ = null;
+        this.#finance_ = null;
+        this.#limits_ = null;
+    }
 }

javascript/features/player_commands/player_command_registry.js

@@ -0,0 +1,119 @@
+// Copyright 2020 Las Venturas Playground. All rights reserved.
+// Use of this source code is governed by the MIT license, a copy of which can
+// be found in the LICENSE file.
+
+import { CommandBuilder } from 'components/command_manager/command_builder.js';
+import { PlayerCommand } from 'features/player_commands/player_command.js';
+
+// The directory in which the command definitions are located, and the include path through which
+// we can import them to JavaScript with dynamic import statements.
+const kCommandDirectory = 'javascript/features/player_commands/commands/';
+const kCommandIncludePath = 'features/player_commands/commands/';
+
+// Loads and keeps track of the sub-commands available to "/my" and "/p". Generates help messages
+// tailored to particular players with the functionality available to them.
+export class PlayerCommandRegistry {
+    #commands_ = null;
+    #params_ = null;
+
+    constructor(...params) {
+        this.#commands_ = new Set();
+        this.#params_ = params;
+    }
+
+    // Asynchronously loads all defined commands, and builds the "/my" and "/p" commands on the
+    // server. Has to be called explicitly when running tests.
+    async initialize() {
+        // (1) Build the set of player commands supported by Las Venturas Playground.
+        for (const filename of glob(kCommandDirectory, '^((?!test).)*\.js$')) {
+            const exports = await import(kCommandIncludePath + filename);
+            const constructor = Object.values(exports).pop();
+
+            const command = new constructor(...this.#params_);
+            if (!(command instanceof PlayerCommand))
+                throw new Error(`Source file "${filename}" does not export a player command.`);
+
+            this.#commands_.add(command);
+        }
+
+        // (2) Initialize the builders through which the individual commands will be registered.
+        const myBuilder = server.commandManager.buildCommand('my');
+        const playerBuilder = server.commandManager.buildCommand('p')
+            .sub(CommandBuilder.PLAYER_PARAMETER);
+        
+        // (3) Iterate over all the commands, and add them to both "/my" and "/p".
+        for (const command of this.#commands_) {
+            myBuilder.sub(command.name)
+                .restrict(command.playerLevel)
+                .parameters(command.parameters)
+                .build(PlayerCommandRegistry.prototype.onCommand.bind(
+                    this, command, /* subject= */ null));
+
+            playerBuilder.sub(command.name)
+                .restrict(command.administratorLevel)
+                .parameters(command.parameters)
+                .build(PlayerCommandRegistry.prototype.onCommand.bind(this, command));
+        }
+
+        // (4) Register the "/my" command with the server. We already closed the last sub-command.
+        myBuilder.build(PlayerCommandRegistry.prototype.onMyCommand.bind(this));
+
+        // (5) Register the "/p" command with the server. The sub-command requiring the player
+        // parameter is still open, so that has to be closed first.
+        playerBuilder
+            .build(PlayerCommandRegistry.prototype.onPlayerCommand.bind(this))
+            .build(PlayerCommandRegistry.prototype.onPlayerCommand.bind(this));
+    }
+
+    // ---------------------------------------------------------------------------------------------
+
+    // Called when the |player| has executed the |command|, optionally for |subject| when they are
+    // an administrator and have sufficient access. The |params| should be passed through.
+    async onCommand(command, subject, player, ...params) {
+        const self = subject ?? player;
+
+        // Bail out if the |player| is using the command on themselves, it requires VIP access and
+        // they don't have VIP access. Administrators cannot cheat this way either.
+        if (self === player && command.playerVip && !player.isVip()) {
+            player.sendMessage(Message.PLAYER_COMMANDS_REQUIRES_VIP);
+            return;
+        }
+
+        // Execute the |command| and wait for it to be complete.
+        return await command.execute(self, player, ...params);
+    }
+
+    // Called when the |player| has executed the "/my" command with parameters that could not be
+    // fully understood, and thus should be displayed a help message.
+    onMyCommand(player, params) {
+        // TODO: Migrate all the player commands to JavaScript, then display a help message here.
+        wait(0).then(() => pawnInvoke(
+            'OnPlayerCommand', 'is', player.id, '/my ' + params ?? ''));
+    }
+
+    // Called when the |player| has executed the "/p" command with parameters that could not be
+    // fully understood, and thus has to be displayed a help message.
+    onPlayerCommand(player, params) {
+        // TODO: Migrate all the player commands to JavaScript, then display a help message here.
+        wait(0).then(() => pawnInvoke(
+            'OnPlayerCommand', 'is', player.id, '/p ' + params ?? ''));
+    }
+
+    // ---------------------------------------------------------------------------------------------
+
+    dispose() {
+        for (const command of this.#commands_)
+            command.dispose();
+
+        this.#commands_.clear();
+        this.#commands_ = null;
+
+        this.#params_ = null;
+
+        if (!server.commandManager.hasCommand('my'))
+            return;  // the commands never were registered
+
+        server.commandManager.removeCommand('my');
+        server.commandManager.removeCommand('p');
+    }
+}