@momo2555/koppeliajs 0.0.142 → 0.0.144

package/dist/scripts/koppelia.d.ts

@@ -3,11 +3,13 @@ import { type AnyState } from "./state.js";
 import { Device } from "./device.js";
 import { Play } from "./play.js";
 import { Resident } from "./resident.js";
+import { type OptionChangedCallback } from "./option.js";
 export declare class Koppelia {
     private _console;
     private _state;
     private _stage;
     private static _instance;
+    private _option;
     constructor();
     static get instance(): Koppelia;
     get state(): Writable<AnyState>;
@@ -67,13 +69,11 @@ export declare class Koppelia {
      */
     enableDifficultyCursor(callback: (difficulty: number) => void): Promise<void>;
     /**
-     *
      * @param id
      * @param onGrowChange
      */
     registerNewGrowableElement(id: string, onGrowChange: (grown: boolean) => void): Promise<void>;
     /**
-     *
      * @param id
      * @param grown
      */
@@ -83,9 +83,24 @@ export declare class Koppelia {
      * text update notification form koppelia application
      */
     registerNewResizableText(id: string, defaultSize: number, onTextResized: (newSize: number) => void): Promise<void>;
+    writeGameConfig(config_id: string, config_value: {
+        [key: string]: any;
+    }, current_play?: boolean): Promise<void>;
+    getGameConfig(config_id: string, current_play: boolean): Promise<{
+        [key: string]: any;
+    }>;
     /**
-    *
-    * @param sentence
-    */
+     * @param sentence
+     */
     say(sentence: string): void;
+    /**
+     * Set a new or edit a game option
+     * @param name Name fo the option
+     * @param value Value of the option
+     */
+    setOption(name: string, value: any): void;
+    createSliderOtption(name: string, label: string, value: number, min: number, max: number, step: number): void;
+    createSwitchOption(name: string, label: string, value: boolean): void;
+    createChoicesOption(name: string, label: string, value: string, choices: string[]): void;
+    onOptionChanged(name: string, callback: OptionChangedCallback): void;
 }

package/dist/scripts/koppelia.js

@@ -6,13 +6,15 @@ import { Message, PeerType } from "./message.js";
 import { Stage } from "./stage.js";
 import { Device } from "./device.js";
 import { Play } from "./play.js";
-import { PUBLIC_GAME_ID } from '$env/static/public';
+import { PUBLIC_GAME_ID } from "$env/static/public";
 import { Resident } from "./resident.js";
+import { Option } from "./option.js";
 export class Koppelia {
     _console;
     _state;
     _stage;
     static _instance;
+    _option;
     constructor() {
         this._console = new Console();
         this._console.onReady(() => {
@@ -25,13 +27,15 @@ export class Koppelia {
                 console.log("identify monitor");
                 this._console.identify(PeerType.MONITOR);
             }
-            else
+            else {
                 console.log("Cannot identifiy type ", type);
+            }
         });
         this._state = new State(this._console, {
-            hey: "coucou"
+            hey: "coucou",
         });
         this._stage = new Stage(this._console);
+        this._option = new Option(this._console);
     }
     static get instance() {
         if (!Koppelia._instance) {
@@ -153,7 +157,8 @@ export class Koppelia {
             getResidentsRequest.setRequest("getResidentsList");
             getResidentsRequest.setDestination(PeerType.MASTER, "");
             this._console.sendMessage(getResidentsRequest, (response) => {
-                let ResidentRawList = response.getParam("residents", {});
+                let ResidentRawList = response
+                    .getParam("residents", {});
                 let residents = [];
                 for (let residentId in ResidentRawList) {
                     let resident = new Resident();
@@ -188,7 +193,6 @@ export class Koppelia {
     async enableDifficultyCursor(callback) {
     }
     /**
-     *
      * @param id
      * @param onGrowChange
      */
@@ -218,7 +222,6 @@ export class Koppelia {
         });
     }
     /**
-     *
      * @param id
      * @param grown
      */
@@ -256,8 +259,9 @@ export class Koppelia {
                 if (req == "resizableTextNotification") {
                     if (params.id !== undefined && params.id == id) {
                         let fontSize = defaultSize;
-                        if (params.fontSize != undefined)
+                        if (params.fontSize != undefined) {
                             fontSize = params.fontSize;
+                        }
                         onTextResized(fontSize);
                     }
                 }
@@ -265,10 +269,31 @@ export class Koppelia {
             resolve();
         });
     }
+    async writeGameConfig(config_id, config_value, current_play = true) {
+        let setGameConfigRequest = new Message();
+        setGameConfigRequest.setRequest("setGameData");
+        setGameConfigRequest.addParam("playId", current_play ? "current" : null);
+        setGameConfigRequest.addParam("content", config_value);
+        setGameConfigRequest.addParam("dataId", config_id);
+        setGameConfigRequest.setDestination(PeerType.MASTER, "");
+        this._console.sendMessage(setGameConfigRequest);
+    }
+    async getGameConfig(config_id, current_play) {
+        return new Promise((resolve, reject) => {
+            let getGameConfigRequest = new Message();
+            getGameConfigRequest.setRequest("getGameData");
+            getGameConfigRequest.addParam("playId", current_play ? "current" : null);
+            getGameConfigRequest.addParam("dataId", config_id);
+            getGameConfigRequest.setDestination(PeerType.MASTER, "");
+            this._console.sendMessage(getGameConfigRequest, (response) => {
+                let gameConfigContent = response.getParam("content", {});
+                resolve(gameConfigContent);
+            });
+        });
+    }
     /**
-    *
-    * @param sentence
-    */
+     * @param sentence
+     */
     say(sentence) {
         // create the message to request the devices
         let sayRequest = new Message();
@@ -278,4 +303,34 @@ export class Koppelia {
         // send the message to the console
         this._console.sendMessage(sayRequest);
     }
+    /**
+     * Set a new or edit a game option
+     * @param name Name fo the option
+     * @param value Value of the option
+     */
+    setOption(name, value) {
+        this._option.setOption(name, value, null, {});
+    }
+    createSliderOtption(name, label, value, min, max, step) {
+        this._option.setOption(name, value, "slider", {
+            "min": min,
+            "max": max,
+            "step": step,
+            "label": label,
+        });
+    }
+    createSwitchOption(name, label, value) {
+        this._option.setOption(name, value, "switch", {
+            "label": label,
+        });
+    }
+    createChoicesOption(name, label, value, choices) {
+        this._option.setOption(name, value, "choices", {
+            "choices": choices,
+            "label": label,
+        });
+    }
+    onOptionChanged(name, callback) {
+        this._option.onOptionChanged(name, callback);
+    }
 }

package/dist/scripts/option.d.ts

@@ -0,0 +1,40 @@
+import { Console } from "./console.js";
+export type Options = {
+    [key: string]: any;
+};
+export type OptionChangedCallback = (value: any) => void;
+export declare class Option {
+    private _options;
+    private _console;
+    private _callbacks;
+    constructor(console: Console);
+    get options(): Options;
+    /**
+     * Update the game options from the server
+     */
+    updateFromServer(): Promise<void>;
+    /**
+     * Set a new or edit a game option
+     * @param name Name fo the option
+     * @param value Value of the option
+     */
+    setOption(name: string, value: any, type?: string | null, config?: {
+        [key: string]: any;
+    }): void;
+    /**
+     * Set a callback when an option has changed
+     * @param name
+     * @param callback
+     */
+    onOptionChanged(name: string, callback: OptionChangedCallback): void;
+    /**
+     * Init all events
+     * @param from
+     * @param any
+     */
+    private _initEvents;
+    /**
+     * callback when a new option is received
+     */
+    private _onReceiveState;
+}

package/dist/scripts/option.js

@@ -0,0 +1,95 @@
+import { Console } from "./console.js";
+import { Message, PeerType } from "./message.js";
+import { get, writable } from "svelte/store";
+export class Option {
+    _options;
+    _console;
+    _callbacks;
+    constructor(console) {
+        this._options = {};
+        this._console = console;
+        this._callbacks = {};
+        this._initEvents();
+    }
+    get options() {
+        return this._options;
+    }
+    /**
+     * Update the game options from the server
+     */
+    async updateFromServer() {
+        return new Promise((resolve, reject) => {
+            let req = new Message();
+            req.setRequest("getGameOptions");
+            this._console.sendMessage(req, (response) => {
+                let options = response.getParam("gameOptions", {});
+                for (const optionName in options) {
+                    this._onReceiveState(response.header.from, optionName, options[optionName]);
+                }
+                resolve();
+            });
+        });
+    }
+    /**
+     * Set a new or edit a game option
+     * @param name Name fo the option
+     * @param value Value of the option
+     */
+    setOption(name, value, type = null, config = {}) {
+        let setOptionRequest = new Message();
+        setOptionRequest.setRequest("setGameOption");
+        setOptionRequest.setDestination(PeerType.MASTER, "");
+        setOptionRequest.addParam("name", name);
+        setOptionRequest.addParam("value", value);
+        setOptionRequest.addParam("type", type);
+        setOptionRequest.addParam("config", config);
+        this._console.sendMessage(setOptionRequest);
+        // this._options[name] = value;
+    }
+    /**
+     * Set a callback when an option has changed
+     * @param name
+     * @param callback
+     */
+    onOptionChanged(name, callback) {
+        this._callbacks[name] = callback;
+    }
+    /**
+     * Init all events
+     * @param from
+     * @param any
+     */
+    _initEvents() {
+        // Get the state when the console is ready
+        this._console.onReady(() => {
+            this.updateFromServer();
+        });
+        // update the state when receive a change from console
+        this._console.onRequest((request, params, from) => {
+            if (request == "gameOptionNotification") {
+                let value = {};
+                let name = "";
+                if (Object.hasOwn(params, "value")) {
+                    value = params["value"];
+                }
+                if (Object.hasOwn(params, "name")) {
+                    name = params["name"];
+                }
+                this._onReceiveState(from, name, value, true);
+            }
+        });
+    }
+    /**
+     * callback when a new option is received
+     */
+    _onReceiveState(from, receivedOption, valueOption, runCallbacks = false) {
+        this._options[receivedOption] = valueOption["value"];
+        if (runCallbacks) {
+            for (const callKey in this._callbacks) {
+                if (callKey == receivedOption) {
+                    this._callbacks[callKey](valueOption);
+                }
+            }
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@momo2555/koppeliajs",
-	"version": "0.0.142",
+	"version": "0.0.144",
 	"scripts": {
 		"dev": "vite dev",
 		"build": "vite build && npm run package",