stuffy

server/models/session.js

@@ -1,129 +1,142 @@
 import WebSocket from "ws";
-import { Game } from "./game.js";
 import { Player } from "./player.js";
-import { StateInterface } from "../states/interface.js";
 import * as msg from "../utils/messages.js";
-import figlet from "figlet";
+import { mustBeString, mustBe } from "../utils/mustbe.js";
+import { Scene } from "../scenes/scene.js";
+import { gGame } from "./globals.js";
 
 export class Session {
-  /** @protected @type {StateInterface} */
-  _state;
-  get state() {
-    return this._state;
-  }
+    /** @type {WebSocket} */
+    _websocket;
 
-  /** @protected @type {Game} */
-  _game;
-  get game() {
-    return this._game;
-  }
+    /** @protected @type {Scene} */
+    _scene;
 
-  /** @type {Player} */
-  _player;
-  get player() {
-    return this._player;
-  }
-
-  /** @param {Player} player */
-  set player(player) {
-    if (player instanceof Player) {
-      this._player = player;
-      return;
+    /** @readonly @constant @type {Scene} */
+    get scene() {
+        return this._scene;
     }
 
-    if (player === null) {
-      this._player = null;
-      return;
+    /** @type {Player} */
+    _player;
+
+    get player() {
+        return this._player;
     }
 
-    throw Error(
-      `Can only set player to null or instance of Player, but received ${typeof player}`,
-    );
-  }
+    /** @param {Player} player */
+    set player(player) {
+        if (player instanceof Player) {
+            this._player = player;
+            return;
+        }
 
-  /** @type {WebSocket} */
-  _websocket;
+        if (player === null) {
+            this._player = null;
+            return;
+        }
 
-  /**
-   * @param {WebSocket} websocket
-   * @param {Game} game
-   */
-  constructor(websocket, game) {
-    this._websocket = websocket;
-    this._game = game;
-  }
-
-  /** Close the session and websocket */
-  close() {
-    this._websocket.close();
-    this._player = null;
-  }
-
-  /**
-   * Send a message via our websocket.
-   *
-   * @param {string|number} messageType
-   * @param {...any} args
-   */
-  send(messageType, ...args) {
-    this._websocket.send(JSON.stringify([messageType, ...args]));
-  }
-
-  sendFigletMessage(message) {
-    console.debug("sendFigletMessage('%s')", message);
-    this.sendMessage(figlet.textSync(message), { preformatted: true });
-  }
-
-  /** @param {string} message Message to display to player */
-  sendMessage(message, ...args) {
-    if (message.length === 0) {
-      console.debug("sending a zero-length message, weird");
+        throw Error(`Can only set player to null or instance of Player, but received ${typeof player}`);
     }
-    if (Array.isArray(message)) {
-      message = message.join("\n");
+
+    /**
+     * @param {WebSocket} websocket
+     */
+    constructor(websocket) {
+        this._websocket = websocket;
     }
-    this.send(msg.MESSAGE, message, ...args);
-  }
 
-  /**
-   * @param {string} type prompt type (username, password, character name, etc.)
-   * @param {string|string[]} message The prompting message (please enter your character's name)
-   * @param {string} tag helps with message routing and handling.
-   */
-  sendPrompt(type, message, tag = "", ...args) {
-    if (Array.isArray(message)) {
-      message = message.join("\n");
+    /**
+     * @param {Scene} scene
+     */
+    setScene(scene) {
+        console.debug("changing scene", scene.constructor.name);
+        if (!(scene instanceof Scene)) {
+            throw new Error(`Expected instance of Scene, got a ${typeof scene}: >>${scene}<<`);
+        }
+        this._scene = scene;
+        scene.execute(this);
     }
-    this.send(msg.PROMPT, type, message, tag, ...args);
-  }
 
-  /** @param {string} message The error message to display to player */
-  sendError(message, ...args) {
-    this.send(msg.ERROR, message, ...args);
-  }
-
-  /** @param {string} message The error message to display to player */
-  sendDebug(message, ...args) {
-    this.send(msg.DEBUG, message, ...args);
-  }
-
-  /** @param {string} message The calamitous error to display to player */
-  sendCalamity(message, ...args) {
-    this.send(msg.CALAMITY, message, ...args);
-  }
-
-  sendSystemMessage(arg0, ...rest) {
-    this.send(msg.SYSTEM, arg0, ...rest);
-  }
-
-  /**
-   * @param {StateInterface} state
-   */
-  setState(state) {
-    this._state = state;
-    console.debug("changing state", state.constructor.name);
-    if (typeof state.onAttach === "function") {
-      state.onAttach();
+    /** Close the session and websocket */
+    close() {
+        if (this._websocket) {
+            this._websocket.close();
+            this._websocket = null;
+        }
+        this._player = null;
+        this._scene = null;
+    }
+
+    /**
+     * Send a message via our websocket.
+     *
+     * @param {string|number} messageType
+     * @param {...any} args
+     */
+    send(messageType, ...args) {
+        if (!this._websocket) {
+            console.error("Trying to send a message without a valid websocket", messageType, args);
+            return;
+        }
+        this._websocket.send(JSON.stringify([messageType, ...args]));
+    }
+
+    /**
+     * @overload
+     * @param {string|string[]} text The prompt message (the request to get the user to enter some info).
+     * @param {string?} context
+     */ /**
+     * @overload
+     * @param {string|string[]} text The prompt message (the request to get the user to enter some info).
+     * @param {object?} options Any options for the text (client side text formatting, color-, font-, or style info, etc.).
+     */
+    sendPrompt(text, options) {
+        options = options || {};
+
+        if (typeof options === "string") {
+            // if options is just a string, assume we meant to apply a context to the prompt
+            options = { context: options };
+        }
+
+        this.send(
+            msg.PROMPT, // message type
+            text, // TODO: prompt text must be string or an array of strings
+            mustBe(options, "object"),
+        );
+    }
+
+    /**
+     * Send text to be displayed to the client
+     *
+     * @param {string|string[]} text Text to send. If array, each element will be displayed as its own line on the client side.
+     * @param {object?} options message options for the client.
+     */
+    sendText(text, options = {}) {
+        this.send(msg.TEXT, text, options);
+    }
+
+    /** @param {string|string[]} errorMessage */
+    sendError(errorMessage) {
+        this.send(msg.ERROR, mustBeString(errorMessage));
+    }
+
+    /**
+     * Send a calamity text and then close the connection.
+     * @param {string|string[]} errorMessage Text to send. If array, each element will be displayed as its own line on the client side.
+     */
+    calamity(errorMessage) {
+        //
+        // The client should know not to format calamaties anyway, but we add “preformatted” anyway
+        this.send(msg.CALAMITY, errorMessage, { preformatted: true });
+        this.close();
+    }
+
+    /**
+     * @param {string} systemMessageType
+     * @param {any?} value
+     */
+    sendSystemMessage(systemMessageType, value = undefined) {
+        this.send(msg.SYSTEM, mustBeString(systemMessageType), value);
     }
-  }
 }