@momo2555/koppeliajs 0.0.91

package/dist/scripts/device.d.ts

@@ -0,0 +1,49 @@
+import { Console } from './console.js';
+/**
+ * This class reprensts a device
+ */
+type Color = {
+    r: number;
+    g: number;
+    b: number;
+};
+export declare class Device {
+    private _address;
+    private _color;
+    private _name;
+    private _console;
+    private _attachedEvents;
+    constructor(console: Console, address?: string);
+    set color(color: Color);
+    get color(): Color;
+    ping(): void;
+    onEvent(eventName: string, callback: () => void): void;
+    onZPosition(callback: (z: number) => void): void;
+    onVerticalDetector(callback: (vertical: boolean) => void): void;
+    private _attachEvent;
+    private _enableModule;
+    setColor(color: Color): void;
+    /**
+     * Vibrate the device (use the motor vibrator)
+     * @param time
+     * @param blink
+     * @param blinkOff
+     * @param blinkCount
+     */
+    vibrate(time: number, blink?: boolean, blinkOff?: number, blinkCount?: number): void;
+    /**
+     * Convert this device object to a json object
+     * @returns
+     */
+    toObject(): {
+        [key: string]: any;
+    };
+    /**
+     * set the device object from a json object
+     * @param object
+     */
+    fromObject(object: {
+        [key: string]: any;
+    }): void;
+}
+export {};

package/dist/scripts/device.js

@@ -0,0 +1,123 @@
+import { Console } from './console.js';
+import { Message, MessageType, PeerType } from './message.js';
+export class Device {
+    _address;
+    _color;
+    _name;
+    _console;
+    _attachedEvents;
+    constructor(console, address = "") {
+        this._address = address;
+        this._color = { r: 0, g: 0, b: 0 };
+        this._name = "";
+        this._console = console;
+        this._attachedEvents = [];
+    }
+    set color(color) {
+        this._color = color;
+        // TODO : send a request to change the color
+    }
+    get color() {
+        return this._color;
+    }
+    ping() {
+    }
+    onEvent(eventName, callback) {
+        this._attachEvent(eventName);
+        this._console.onDeviceEvent(callback);
+    }
+    onZPosition(callback) {
+        this._enableModule("zPos");
+        this._attachEvent("zPosition");
+        this._console.onRequest((request, params, form, address) => {
+            if (request == "zPosition" && address == this._address) {
+                callback(params.value);
+            }
+        });
+    }
+    onVerticalDetector(callback) {
+        this._enableModule("vDetct");
+        this._attachEvent("verticalDetector");
+        this._console.onRequest((request, params, form, address) => {
+            if (request == "verticalDetector" && address == this._address) {
+                callback(params.value);
+            }
+        });
+    }
+    _attachEvent(event) {
+        if (!(event in this._attachedEvents)) {
+            let request = new Message();
+            request.addParam("event", event);
+            request.setDestination(PeerType.DEVICE, this._address);
+            request.setRequest("attachEvent");
+            this._console.sendMessage(request);
+            this._attachedEvents.push(event);
+        }
+    }
+    _enableModule(moduleNmae) {
+        let request = new Message();
+        request.addParam("module", moduleNmae);
+        request.setDestination(PeerType.DEVICE, this._address);
+        request.setRequest("enableModule");
+        this._console.sendMessage(request);
+    }
+    setColor(color) {
+        console.log("Set Color");
+        this._color = color;
+        let request = new Message();
+        request.addParam("color", color);
+        request.setDestination(PeerType.DEVICE, this._address);
+        request.setRequest("setColor");
+        console.log("Set Color request", request);
+        this._console.sendMessage(request);
+    }
+    /**
+     * Vibrate the device (use the motor vibrator)
+     * @param time
+     * @param blink
+     * @param blinkOff
+     * @param blinkCount
+     */
+    vibrate(time, blink = false, blinkOff = 0, blinkCount = 0) {
+        let vibration = {
+            v: time,
+            toff: 0,
+            c: 1
+        };
+        if (blink) {
+            vibration.toff = blinkOff;
+            vibration.c = blinkCount;
+        }
+        let request = new Message();
+        request.addParam("vibration", vibration);
+        request.setDestination(PeerType.DEVICE, this._address);
+        request.setRequest("vibrate");
+        this._console.sendMessage(request);
+    }
+    /**
+     * Convert this device object to a json object
+     * @returns
+     */
+    toObject() {
+        return {
+            "address": this._address,
+            "color": this._color,
+            "name": this._name
+        };
+    }
+    /**
+     * set the device object from a json object
+     * @param object
+     */
+    fromObject(object) {
+        if (object.address !== undefined) {
+            this._address = object.address;
+        }
+        if (object.color !== undefined) {
+            this._color = object.color;
+        }
+        if (object.name !== undefined) {
+            this._name = object.name;
+        }
+    }
+}

package/dist/scripts/game.d.ts

@@ -0,0 +1,5 @@
+export declare class Game {
+    constructor();
+    getGameId(): void;
+    getGameFile(): void;
+}

package/dist/scripts/game.js

@@ -0,0 +1,8 @@
+export class Game {
+    constructor() {
+    }
+    getGameId() {
+    }
+    getGameFile() {
+    }
+}

package/dist/scripts/koppelia.d.ts

@@ -0,0 +1,70 @@
+import { type Writable } from "svelte/store";
+import { type AnyState } from "./state.js";
+import { Device } from "./device.js";
+import { Play } from "./play.js";
+export declare class Koppelia {
+    private _console;
+    private _state;
+    private _stage;
+    private static _instance;
+    constructor();
+    static get instance(): Koppelia;
+    get state(): Writable<AnyState>;
+    updateState(stateUpdate: AnyState): void;
+    setState(newState: AnyState): void;
+    get ready(): boolean;
+    /**
+     * Add a callback that will be called when the connection to the console is entirely ready
+     *
+     * @param callback
+     */
+    onReady(callback: () => void): void;
+    /**
+     * Init the default state of the game and the list of all stages
+     *
+     * @param defaultState Default state that be initialized
+     * @param stages List of all stages
+     */
+    init(defaultState: AnyState, stages: string[]): void;
+    /**
+     * Go to a stage, the stage must be in the stage list
+     * If the stage list is empty the console will return an error
+     * @param stageName
+     */
+    goto(stageName: string): void;
+    /**
+     * Get the list of devices in a callback
+     * @param callback
+     */
+    getDevices(): Promise<Device[]>;
+    /**
+     * Get the game ID of the current game
+     * @returns the game id as a string
+     */
+    getGameId(): string;
+    /**
+     * Get the list of plays
+     * @param count limit of plays to get
+     * @param index index from which to start fetching the plays
+     * @param orderBy order by date or name
+     * @returns the List of plays an array of objects of type Play
+     */
+    getPlays(count?: number, index?: number, orderBy?: string): Promise<Play[]>;
+    /**
+     * This function enables the difficulty cursor, to change the difficulty in live when playing from Koppeli'App
+     * @param callback : callback to call when difficulty changes
+     */
+    enableDifficultyCursor(callback: (difficulty: number) => void): Promise<void>;
+    /**
+     *
+     * @param id
+     * @param onGrowChange
+     */
+    registerNewGrowableElement(id: string, onGrowChange: (grown: boolean) => void): Promise<void>;
+    /**
+     *
+     * @param id
+     * @param grown
+     */
+    updateGrowableElement(id: string, grown: boolean): Promise<void>;
+}

package/dist/scripts/koppelia.js

@@ -0,0 +1,196 @@
+import { get } from "svelte/store";
+import { routeType } from "../stores/routeStore.js";
+import { Console } from "./console.js";
+import { State } from "./state.js";
+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';
+export class Koppelia {
+    _console;
+    _state;
+    _stage;
+    static _instance;
+    constructor() {
+        this._console = new Console();
+        this._console.onReady(() => {
+            let type = get(routeType);
+            if (type == "controller") {
+                console.log("identify controller");
+                this._console.identify(PeerType.CONTROLLER);
+            }
+            else if (type == "monitor") {
+                console.log("identify monitor");
+                this._console.identify(PeerType.MONITOR);
+            }
+            else
+                console.log("Cannot identifiy type ", type);
+        });
+        this._state = new State(this._console, {
+            hey: "coucou"
+        });
+        this._stage = new Stage(this._console);
+    }
+    static get instance() {
+        if (!Koppelia._instance) {
+            Koppelia._instance = new Koppelia();
+        }
+        return Koppelia._instance;
+    }
+    get state() {
+        return this._state.state;
+    }
+    updateState(stateUpdate) {
+        this._state.updateState(stateUpdate);
+    }
+    setState(newState) {
+        this._state.setState(newState);
+    }
+    get ready() {
+        return this._console.ready;
+    }
+    /**
+     * Add a callback that will be called when the connection to the console is entirely ready
+     *
+     * @param callback
+     */
+    onReady(callback) {
+        this._console.onReady(callback);
+    }
+    /**
+     * Init the default state of the game and the list of all stages
+     *
+     * @param defaultState Default state that be initialized
+     * @param stages List of all stages
+     */
+    init(defaultState, stages) {
+        this._console.onReady(() => {
+            let type = get(routeType);
+            if (type == "controller") {
+                this._state.setState(defaultState); // set the state
+                this._stage.initStages(stages); // init the list of stages
+            }
+        });
+    }
+    /**
+     * Go to a stage, the stage must be in the stage list
+     * If the stage list is empty the console will return an error
+     * @param stageName
+     */
+    goto(stageName) {
+        this._stage.goto(stageName);
+    }
+    /**
+     * Get the list of devices in a callback
+     * @param callback
+     */
+    async getDevices() {
+        return new Promise((resolve, reject) => {
+            // create the message to request the devices
+            let getDevicesRequest = new Message();
+            getDevicesRequest.setRequest("getDevices");
+            getDevicesRequest.setDestination(PeerType.MASTER, "");
+            // send the message to the console
+            this._console.sendMessage(getDevicesRequest, (response) => {
+                // convert the response to al list of device objects
+                let devices_raw = response.getParam("devices", []);
+                let devices = [];
+                for (let device_raw of devices_raw) {
+                    let device = new Device(this._console);
+                    device.fromObject(device_raw);
+                    devices.push(device);
+                }
+                resolve(devices);
+            });
+        });
+    }
+    /**
+     * Get the game ID of the current game
+     * @returns the game id as a string
+     */
+    getGameId() {
+        return PUBLIC_GAME_ID;
+    }
+    /**
+     * Get the list of plays
+     * @param count limit of plays to get
+     * @param index index from which to start fetching the plays
+     * @param orderBy order by date or name
+     * @returns the List of plays an array of objects of type Play
+     */
+    async getPlays(count = 10, index = 0, orderBy = "date") {
+        return new Promise((resolve, reject) => {
+            let getPlaysRequest = new Message();
+            getPlaysRequest.setRequest("getPlaysList");
+            getPlaysRequest.addParam("gameId", this.getGameId());
+            getPlaysRequest.addParam("count", count);
+            getPlaysRequest.addParam("index", index);
+            getPlaysRequest.addParam("orderBy", orderBy);
+            getPlaysRequest.setDestination(PeerType.MASTER, "");
+            this._console.sendMessage(getPlaysRequest, (response) => {
+                let playsRawList = response.getParam("plays", {});
+                let plays = [];
+                for (let playId in playsRawList) {
+                    plays.push(new Play(this._console, playId, playsRawList[playId]));
+                }
+                resolve(plays);
+            });
+        });
+    }
+    /**
+     * This function enables the difficulty cursor, to change the difficulty in live when playing from Koppeli'App
+     * @param callback : callback to call when difficulty changes
+     */
+    async enableDifficultyCursor(callback) {
+    }
+    /**
+     *
+     * @param id
+     * @param onGrowChange
+     */
+    async registerNewGrowableElement(id, onGrowChange) {
+        return new Promise((resolve, reject) => {
+            // create the message to request the devices
+            if (get(routeType) == "controller") {
+                let addGrowableElRequest = new Message();
+                addGrowableElRequest.setRequest("addGrowableElement");
+                addGrowableElRequest.addParam("id", id);
+                addGrowableElRequest.setDestination(PeerType.MASTER, "");
+                // send the message to the console (only the controller sends the )
+                this._console.sendMessage(addGrowableElRequest, (response) => {
+                });
+            }
+            this._console.onRequest((req, params) => {
+                if (req == "gowableElementNotification") {
+                    if (params.id !== undefined && params.id == id) {
+                        let grown = false;
+                        if (params.grown != undefined)
+                            grown = params.grown;
+                        onGrowChange(grown);
+                    }
+                }
+            });
+            resolve();
+        });
+    }
+    /**
+     *
+     * @param id
+     * @param grown
+     */
+    async updateGrowableElement(id, grown) {
+        return new Promise((resolve, reject) => {
+            // create the message to request the devices
+            let addGrowableElRequest = new Message();
+            addGrowableElRequest.setRequest("updateGrowableElement");
+            addGrowableElRequest.addParam("id", id);
+            addGrowableElRequest.addParam("grown", grown);
+            addGrowableElRequest.setDestination(PeerType.MASTER, "");
+            // send the message to the console
+            this._console.sendMessage(addGrowableElRequest, (response) => {
+                resolve();
+            });
+        });
+    }
+}

package/dist/scripts/koppeliaWebsocket.d.ts

@@ -0,0 +1,77 @@
+import { Message } from "./message.js";
+export type Callback = (response: Message) => void;
+type OnGoingRequest = {
+    requestId: string;
+    callback?: Callback;
+};
+export declare class KoppeliaWebsocket {
+    socket?: WebSocket;
+    onGoingRequests: OnGoingRequest[];
+    timeout: number;
+    receiveCallbacks: Callback[];
+    openCallback?: () => void;
+    /**
+     * Constructor of the Koppelia websocket class
+     * @param websocketUrl
+     * @param timeout
+     */
+    constructor(websocketUrl: string, timeout?: number);
+    /**
+     * Send a new request: Add a request Id to the request and add it to the ongoing requests
+     * Add an interval to timeout when there is no response after a certain amount of time
+     * @param data
+     * @param callback
+     */
+    send(data: Message, callback?: Callback): void;
+    /**
+     * Add a receive callback
+     * @param callback
+     */
+    onReceive(callback: Callback): void;
+    /**
+     * Define a callback for the websocket open event
+     * @param callback
+     */
+    onOpen(callback: () => void): void;
+    /**
+     * Generate a new request Id
+     * @returns (string): a nex resuest id
+     */
+    private _generateRequestId;
+    /**
+     * Handle a websocket response
+     * - Execute a callback of a reception if a request was send before (by checking ongoing request)
+     * - Execute a callbacj for a genral reception response
+     * @param data
+     * @returns
+     */
+    private _handleWebsocketResponse;
+    /**
+     * Init all websocker events
+     */
+    private _setupEvents;
+    /**
+     * Timeout the request if there is no response
+     * To timout the response, the function simply delete the id from on going request list
+     * @param requestId Id of the request
+     */
+    private _getRequestIndex;
+    /**
+     * Delete the request from the list of onGoing Requests
+     * @param requestId
+     */
+    private _deleteRequest;
+    /**
+     * get the Ongoing the request and get theh callback
+     * @param requestId
+     * @returns
+     */
+    private _getOnGoingRequest;
+    /**
+     * Add a new request to ongoing requests
+     * @param requestId
+     * @param callback
+     */
+    private _addNewRequest;
+}
+export {};

package/dist/scripts/koppeliaWebsocket.js

@@ -0,0 +1,159 @@
+import { Message } from "./message.js";
+const DEFAULT_WS_TIMEOUT = 4000;
+export class KoppeliaWebsocket {
+    socket = undefined;
+    onGoingRequests;
+    timeout;
+    receiveCallbacks;
+    openCallback;
+    /* ------ PUBLIC ------ */
+    /**
+     * Constructor of the Koppelia websocket class
+     * @param websocketUrl
+     * @param timeout
+     */
+    constructor(websocketUrl, timeout = DEFAULT_WS_TIMEOUT) {
+        if (!import.meta.env.SSR) {
+            this.socket = new WebSocket(websocketUrl);
+            console.log("Open new Koppelia websocket connection successfully with url ", websocketUrl);
+            this._setupEvents();
+        }
+        else
+            console.log("Koppelia websocket not accessible during server rendering");
+        this.onGoingRequests = [];
+        this.timeout = timeout;
+        this.receiveCallbacks = [];
+    }
+    /**
+     * Send a new request: Add a request Id to the request and add it to the ongoing requests
+     * Add an interval to timeout when there is no response after a certain amount of time
+     * @param data
+     * @param callback
+     */
+    send(data, callback) {
+        if (this.socket === undefined) {
+            console.log("KoppeliaWebsocket::send(): Koppelia websocket client was not instancieated");
+            return;
+        }
+        // Create a request id
+        data.generateRequestId();
+        this._addNewRequest(data.getRequestId(), callback);
+        // Send the request
+        const serializedMessage = JSON.stringify(data.toObject());
+        console.log("sending message", serializedMessage);
+        console.log(this.socket);
+        this.socket.send(serializedMessage);
+        // set a timeout
+        window.setTimeout(() => this._deleteRequest(data.getRequestId()), this.timeout);
+        ;
+    }
+    /**
+     * Add a receive callback
+     * @param callback
+     */
+    onReceive(callback) {
+        this.receiveCallbacks.push(callback);
+    }
+    /**
+     * Define a callback for the websocket open event
+     * @param callback
+     */
+    onOpen(callback) {
+        this.openCallback = callback;
+    }
+    /* ------ PRIVATE ------ */
+    /**
+     * Generate a new request Id
+     * @returns (string): a nex resuest id
+     */
+    _generateRequestId() {
+        return crypto.randomUUID();
+    }
+    /**
+     * Handle a websocket response
+     * - Execute a callback of a reception if a request was send before (by checking ongoing request)
+     * - Execute a callbacj for a genral reception response
+     * @param data
+     * @returns
+     */
+    _handleWebsocketResponse(data) {
+        if (data === undefined) {
+            return;
+        }
+        let message = new Message();
+        message.parse(data);
+        if (message.getRequestId() !== undefined) {
+            // There is a request id, check if it's a response
+            let onGoing = this._getOnGoingRequest(message.getRequestId());
+            if (onGoing) {
+                // check if the callback exists
+                if (onGoing.callback)
+                    onGoing.callback(message);
+                // otherwise do not execute callback and delete the request from ongoing
+                this._deleteRequest(message.getRequestId());
+                return;
+            }
+        }
+        for (let callback of this.receiveCallbacks) {
+            callback(message);
+        }
+    }
+    /**
+     * Init all websocker events
+     */
+    _setupEvents() {
+        if (this.socket === undefined) {
+            console.log("KoppeliaWebsocket::_setupEvents(): Koppelia websocket client was not instancieated");
+            return;
+        }
+        // handle web socker opening
+        this.socket.addEventListener('open', (e) => {
+            if (this.openCallback)
+                this.openCallback();
+        });
+        // handle web socket reception
+        this.socket.addEventListener('message', (e) => {
+            let data = JSON.parse(e.data);
+            this._handleWebsocketResponse(data);
+        });
+    }
+    /**
+     * Timeout the request if there is no response
+     * To timout the response, the function simply delete the id from on going request list
+     * @param requestId Id of the request
+     */
+    _getRequestIndex(requestId) {
+        return this.onGoingRequests.findIndex((element) => {
+            if (!element) {
+                return false; // Skip empty slots
+            }
+            return element.requestId === requestId;
+        });
+    }
+    /**
+     * Delete the request from the list of onGoing Requests
+     * @param requestId
+     */
+    _deleteRequest(requestId) {
+        this.onGoingRequests = this.onGoingRequests.filter((element) => element.requestId !== requestId);
+    }
+    /**
+     * get the Ongoing the request and get theh callback
+     * @param requestId
+     * @returns
+     */
+    _getOnGoingRequest(requestId) {
+        let requestIndex = this._getRequestIndex(requestId);
+        if (requestIndex < 0)
+            return undefined;
+        return this.onGoingRequests[requestIndex];
+    }
+    /**
+     * Add a new request to ongoing requests
+     * @param requestId
+     * @param callback
+     */
+    _addNewRequest(requestId, callback) {
+        this.onGoingRequests.push({ requestId: requestId, callback: callback });
+    }
+}