Merge branch 'develop' of github.com:thecodingmachine/workadventure into GlobalMessageToWorld

front/src/Phaser/Game/AddPlayerInterface.ts

@@ -1,5 +1,5 @@
-import type {PointInterface} from "../../Connexion/ConnexionModels";
-import type {PlayerInterface} from "./PlayerInterface";
+import type { PointInterface } from "../../Connexion/ConnexionModels";
+import type { PlayerInterface } from "./PlayerInterface";
 
 export interface AddPlayerInterface extends PlayerInterface {
     position: PointInterface;

front/src/Phaser/Game/GameMap.ts

@@ -1,4 +1,4 @@
-import type { ITiledMap, ITiledMapLayer, ITiledMapLayerProperty } from "../Map/ITiledMap";
+import type { ITiledMap, ITiledMapLayer, ITiledMapProperty } from "../Map/ITiledMap";
 import { flattenGroupLayersMap } from "../Map/LayersFlattener";
 import TilemapLayer = Phaser.Tilemaps.TilemapLayer;
 import { DEPTH_OVERLAY_INDEX } from "./DepthIndexes";
@@ -19,7 +19,7 @@ export class GameMap {
     private callbacks = new Map<string, Array<PropertyChangeCallback>>();
     private tileNameMap = new Map<string, number>();
 
-    private tileSetPropertyMap: { [tile_index: number]: Array<ITiledMapLayerProperty> } = {};
+    private tileSetPropertyMap: { [tile_index: number]: Array<ITiledMapProperty> } = {};
     public readonly flatLayers: ITiledMapLayer[];
     public readonly phaserLayers: TilemapLayer[] = [];
 
@@ -61,7 +61,7 @@ export class GameMap {
         }
     }
 
-    public getPropertiesForIndex(index: number): Array<ITiledMapLayerProperty> {
+    public getPropertiesForIndex(index: number): Array<ITiledMapProperty> {
         if (this.tileSetPropertyMap[index]) {
             return this.tileSetPropertyMap[index];
         }
@@ -151,7 +151,7 @@ export class GameMap {
         return this.map;
     }
 
-    private getTileProperty(index: number): Array<ITiledMapLayerProperty> {
+    private getTileProperty(index: number): Array<ITiledMapProperty> {
         if (this.tileSetPropertyMap[index]) {
             return this.tileSetPropertyMap[index];
         }

front/src/Phaser/Game/GameScene.ts

@@ -46,13 +46,7 @@ import { RemotePlayer } from "../Entity/RemotePlayer";
 import type { ActionableItem } from "../Items/ActionableItem";
 import type { ItemFactoryInterface } from "../Items/ItemFactoryInterface";
 import { SelectCharacterScene, SelectCharacterSceneName } from "../Login/SelectCharacterScene";
-import type {
-    ITiledMap,
-    ITiledMapLayer,
-    ITiledMapLayerProperty,
-    ITiledMapObject,
-    ITiledTileSet,
-} from "../Map/ITiledMap";
+import type { ITiledMap, ITiledMapLayer, ITiledMapProperty, ITiledMapObject, ITiledTileSet } from "../Map/ITiledMap";
 import { MenuScene, MenuSceneName } from "../Menu/MenuScene";
 import { PlayerAnimationDirections } from "../Player/Animation";
 import { hasMovedEventName, Player, requestEmoteEventName } from "../Player/Player";
@@ -90,6 +84,7 @@ import { soundManager } from "./SoundManager";
 import { peerStore, screenSharingPeerStore } from "../../Stores/PeerStore";
 import { videoFocusStore } from "../../Stores/VideoFocusStore";
 import { biggestAvailableAreaStore } from "../../Stores/BiggestAvailableAreaStore";
+import { SharedVariablesManager } from "./SharedVariablesManager";
 import { playersStore } from "../../Stores/PlayersStore";
 import { chatVisibilityStore } from "../../Stores/ChatStore";
 
@@ -200,7 +195,8 @@ export class GameScene extends DirtyScene {
     private mapTransitioning: boolean = false; //used to prevent transitions happenning at the same time.
     private emoteManager!: EmoteManager;
     private preloading: boolean = true;
-    startPositionCalculator!: StartPositionCalculator;
+    private startPositionCalculator!: StartPositionCalculator;
+    private sharedVariablesManager!: SharedVariablesManager;
 
     constructor(private room: Room, MapUrlFile: string, customKey?: string | undefined) {
         super({
@@ -715,6 +711,13 @@ export class GameScene extends DirtyScene {
                     this.gameMap.setPosition(event.x, event.y);
                 });
 
+                // Set up variables manager
+                this.sharedVariablesManager = new SharedVariablesManager(
+                    this.connection,
+                    this.gameMap,
+                    onConnect.room.variables
+                );
+
                 //this.initUsersPosition(roomJoinedMessage.users);
                 this.connectionAnswerPromiseResolve(onConnect.room);
                 // Analyze tags to find if we are admin. If yes, show console.
@@ -1050,20 +1053,24 @@ ${escapedMessage}
             })
         );
 
-        this.iframeSubscriptionList.push(
-            iframeListener.dataLayerChangeStream.subscribe(() => {
-                iframeListener.sendDataLayerEvent({ data: this.gameMap.getMap() });
-            })
-        );
+        iframeListener.registerAnswerer("getMapData", () => {
+            return {
+                data: this.gameMap.getMap(),
+            };
+        });
 
-        iframeListener.registerAnswerer("getState", () => {
+        iframeListener.registerAnswerer("getState", async () => {
+            // The sharedVariablesManager is not instantiated before the connection is established. So we need to wait
+            // for the connection to send back the answer.
+            await this.connectionAnswerPromise;
             return {
                 mapUrl: this.MapUrlFile,
                 startLayerName: this.startPositionCalculator.startLayerName,
                 uuid: localUserStore.getLocalUser()?.uuid,
-                nickname: localUserStore.getName(),
+                nickname: this.playerName,
                 roomId: this.roomUrl,
                 tags: this.connection ? this.connection.getAllTags() : [],
+                variables: this.sharedVariablesManager.variables,
             };
         });
         this.iframeSubscriptionList.push(
@@ -1194,6 +1201,7 @@ ${escapedMessage}
         this.chatVisibilityUnsubscribe();
         this.biggestAvailableAreaStoreUnsubscribe();
         iframeListener.unregisterAnswerer("getState");
+        this.sharedVariablesManager?.close();
 
         mediaManager.hideGameOverlay();
 
@@ -1233,12 +1241,12 @@ ${escapedMessage}
     }
 
     private getProperty(layer: ITiledMapLayer | ITiledMap, name: string): string | boolean | number | undefined {
-        const properties: ITiledMapLayerProperty[] | undefined = layer.properties;
+        const properties: ITiledMapProperty[] | undefined = layer.properties;
         if (!properties) {
             return undefined;
         }
         const obj = properties.find(
-            (property: ITiledMapLayerProperty) => property.name.toLowerCase() === name.toLowerCase()
+            (property: ITiledMapProperty) => property.name.toLowerCase() === name.toLowerCase()
         );
         if (obj === undefined) {
             return undefined;
@@ -1247,12 +1255,12 @@ ${escapedMessage}
     }
 
     private getProperties(layer: ITiledMapLayer | ITiledMap, name: string): (string | number | boolean | undefined)[] {
-        const properties: ITiledMapLayerProperty[] | undefined = layer.properties;
+        const properties: ITiledMapProperty[] | undefined = layer.properties;
         if (!properties) {
             return [];
         }
         return properties
-            .filter((property: ITiledMapLayerProperty) => property.name.toLowerCase() === name.toLowerCase())
+            .filter((property: ITiledMapProperty) => property.name.toLowerCase() === name.toLowerCase())
             .map((property) => property.value);
     }
 
@@ -1710,7 +1718,7 @@ ${escapedMessage}
         this.scene.start(ErrorSceneName, {
             title: "Banned",
             subTitle: "You were banned from WorkAdventure",
-            message: "If you want more information, you may contact us at: workadventure@thecodingmachine.com",
+            message: "If you want more information, you may contact us at: hello@workadventu.re",
         });
     }
 
@@ -1725,14 +1733,14 @@ ${escapedMessage}
             this.scene.start(ErrorSceneName, {
                 title: "Connection rejected",
                 subTitle: "The world you are trying to join is full. Try again later.",
-                message: "If you want more information, you may contact us at: workadventure@thecodingmachine.com",
+                message: "If you want more information, you may contact us at: hello@workadventu.re",
             });
         } else {
             this.scene.start(ErrorSceneName, {
                 title: "Connection rejected",
                 subTitle: "You cannot join the World. Try again later. \n\r \n\r Error: " + message + ".",
                 message:
-                    "If you want more information, you may contact administrator or contact us at: workadventure@thecodingmachine.com",
+                    "If you want more information, you may contact administrator or contact us at: hello@workadventu.re",
             });
         }
     }

front/src/Phaser/Game/SharedVariablesManager.ts

@@ -0,0 +1,159 @@
+import type { RoomConnection } from "../../Connexion/RoomConnection";
+import { iframeListener } from "../../Api/IframeListener";
+import type { Subscription } from "rxjs";
+import type { GameMap } from "./GameMap";
+import type { ITile, ITiledMapObject } from "../Map/ITiledMap";
+import type { Var } from "svelte/types/compiler/interfaces";
+import { init } from "svelte/internal";
+
+interface Variable {
+    defaultValue: unknown;
+    readableBy?: string;
+    writableBy?: string;
+}
+
+/**
+ * Stores variables and provides a bridge between scripts and the pusher server.
+ */
+export class SharedVariablesManager {
+    private _variables = new Map<string, unknown>();
+    private variableObjects: Map<string, Variable>;
+
+    constructor(
+        private roomConnection: RoomConnection,
+        private gameMap: GameMap,
+        serverVariables: Map<string, unknown>
+    ) {
+        // We initialize the list of variable object at room start. The objects cannot be edited later
+        // (otherwise, this would cause a security issue if the scripting API can edit this list of objects)
+        this.variableObjects = SharedVariablesManager.findVariablesInMap(gameMap);
+
+        // Let's initialize default values
+        for (const [name, variableObject] of this.variableObjects.entries()) {
+            if (variableObject.readableBy && !this.roomConnection.hasTag(variableObject.readableBy)) {
+                // Do not initialize default value for variables that are not readable
+                continue;
+            }
+
+            this._variables.set(name, variableObject.defaultValue);
+        }
+
+        // Override default values with the variables from the server:
+        for (const [name, value] of serverVariables) {
+            this._variables.set(name, value);
+        }
+
+        roomConnection.onSetVariable((name, value) => {
+            this._variables.set(name, value);
+
+            // On server change, let's notify the iframes
+            iframeListener.setVariable({
+                key: name,
+                value: value,
+            });
+        });
+
+        // When a variable is modified from an iFrame
+        iframeListener.registerAnswerer("setVariable", (event) => {
+            const key = event.key;
+
+            const object = this.variableObjects.get(key);
+
+            if (object === undefined) {
+                const errMsg =
+                    'A script is trying to modify variable "' +
+                    key +
+                    '" but this variable is not defined in the map.' +
+                    'There should be an object in the map whose name is "' +
+                    key +
+                    '" and whose type is "variable"';
+                console.error(errMsg);
+                throw new Error(errMsg);
+            }
+
+            if (object.writableBy && !this.roomConnection.hasTag(object.writableBy)) {
+                const errMsg =
+                    'A script is trying to modify variable "' +
+                    key +
+                    '" but this variable is only writable for users with tag "' +
+                    object.writableBy +
+                    '".';
+                console.error(errMsg);
+                throw new Error(errMsg);
+            }
+
+            this._variables.set(key, event.value);
+
+            // Dispatch to the room connection.
+            this.roomConnection.emitSetVariableEvent(key, event.value);
+        });
+    }
+
+    private static findVariablesInMap(gameMap: GameMap): Map<string, Variable> {
+        const objects = new Map<string, Variable>();
+        for (const layer of gameMap.getMap().layers) {
+            if (layer.type === "objectgroup") {
+                for (const object of layer.objects) {
+                    if (object.type === "variable") {
+                        if (object.template) {
+                            console.warn(
+                                'Warning, a variable object is using a Tiled "template". WorkAdventure does not support objects generated from Tiled templates.'
+                            );
+                        }
+
+                        // We store a copy of the object (to make it immutable)
+                        objects.set(object.name, this.iTiledObjectToVariable(object));
+                    }
+                }
+            }
+        }
+        return objects;
+    }
+
+    private static iTiledObjectToVariable(object: ITiledMapObject): Variable {
+        const variable: Variable = {
+            defaultValue: undefined,
+        };
+
+        if (object.properties) {
+            for (const property of object.properties) {
+                const value = property.value;
+                switch (property.name) {
+                    case "default":
+                        variable.defaultValue = value;
+                        break;
+                    case "writableBy":
+                        if (typeof value !== "string") {
+                            throw new Error(
+                                'The writableBy property of variable "' + object.name + '" must be a string'
+                            );
+                        }
+                        if (value) {
+                            variable.writableBy = value;
+                        }
+                        break;
+                    case "readableBy":
+                        if (typeof value !== "string") {
+                            throw new Error(
+                                'The readableBy property of variable "' + object.name + '" must be a string'
+                            );
+                        }
+                        if (value) {
+                            variable.readableBy = value;
+                        }
+                        break;
+                }
+            }
+        }
+
+        return variable;
+    }
+
+    public close(): void {
+        iframeListener.unregisterAnswerer("setVariable");
+    }
+
+    get variables(): Map<string, unknown> {
+        return this._variables;
+    }
+}

front/src/Phaser/Game/StartPositionCalculator.ts

@@ -1,5 +1,5 @@
 import type { PositionInterface } from "../../Connexion/ConnexionModels";
-import type { ITiledMap, ITiledMapLayer, ITiledMapLayerProperty, ITiledMapTileLayer } from "../Map/ITiledMap";
+import type { ITiledMap, ITiledMapLayer, ITiledMapProperty, ITiledMapTileLayer } from "../Map/ITiledMap";
 import type { GameMap } from "./GameMap";
 
 const defaultStartLayerName = "start";
@@ -112,12 +112,12 @@ export class StartPositionCalculator {
     }
 
     private getProperty(layer: ITiledMapLayer | ITiledMap, name: string): string | boolean | number | undefined {
-        const properties: ITiledMapLayerProperty[] | undefined = layer.properties;
+        const properties: ITiledMapProperty[] | undefined = layer.properties;
         if (!properties) {
             return undefined;
         }
         const obj = properties.find(
-            (property: ITiledMapLayerProperty) => property.name.toLowerCase() === name.toLowerCase()
+            (property: ITiledMapProperty) => property.name.toLowerCase() === name.toLowerCase()
         );
         if (obj === undefined) {
             return undefined;