content-type???

Fixing "Query string parameters prevent WA from loading"

.env.template

@@ -5,11 +5,13 @@ JITSI_PRIVATE_MODE=false
 JITSI_ISS=
 SECRET_JITSI_KEY=
 ADMIN_API_TOKEN=123
-START_ROOM_URL=/_/global/maps.workadventure.localhost/Floor0/floor0.json
+START_ROOM_URL=/_/global/maps.workadventure.localhost/starter/map.json
 # If your Turn server is configured to use the Turn REST API, you should put the shared auth secret here.
 # If you are using Coturn, this is the value of the "static-auth-secret" parameter in your coturn config file.
 # Keep empty if you are sharing hard coded / clear text credentials.
 TURN_STATIC_AUTH_SECRET=
+DISABLE_NOTIFICATIONS=true
+SKIP_RENDER_OPTIMIZATIONS=false
 
 # The email address used by Let's encrypt to send renewal warnings (compulsory)
 ACME_EMAIL=
@@ -17,3 +19,13 @@ ACME_EMAIL=
 MAX_PER_GROUP=4
 MAX_USERNAME_LENGTH=8
 
+OPID_CLIENT_ID=
+OPID_CLIENT_SECRET=
+OPID_CLIENT_ISSUER=
+OPID_CLIENT_REDIRECT_URL=
+OPID_LOGIN_SCREEN_PROVIDER=http://pusher.workadventure.localhost/login-screen
+OPID_PROFILE_SCREEN_PROVIDER=
+DISABLE_ANONYMOUS=
+
+# If you want to have a contact page in your menu, you MUST set CONTACT_URL to the URL of the page that you want
+CONTACT_URL=

.github/workflows/build-and-deploy.yml

@@ -1,7 +1,13 @@
 name: Build, push and deploy Docker image
 
 on:
-  - push
+  push:
+    branches: [master, develop]
+  release:
+    types: [created]
+  pull_request:
+    types: [ labeled, synchronize ]
+
 
 # Enables BuildKit
 env:
@@ -10,7 +16,7 @@ env:
 jobs:
 
   build-front:
-
+    if: ${{ github.event_name == 'push' || github.event_name == 'release' || github.event_name == 'pull_request' && contains(github.event.pull_request.labels.*.name, 'deploy') }}
     runs-on: ubuntu-latest
 
     steps:
@@ -30,11 +36,11 @@ jobs:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
           repository: thecodingmachine/workadventure-front
-          tags: ${{ env.GITHUB_REF_SLUG }}
+          tags: ${{ github.event_name == 'pull_request' && env.GITHUB_HEAD_REF_SLUG || env.GITHUB_REF_SLUG }}
           add_git_labels: true
 
   build-back:
-
+    if: ${{ github.event_name == 'push' || github.event_name == 'release' || github.event_name == 'pull_request' && contains(github.event.pull_request.labels.*.name, 'deploy') }}
     runs-on: ubuntu-latest
 
     steps:
@@ -53,11 +59,11 @@ jobs:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
           repository: thecodingmachine/workadventure-back
-          tags: ${{ env.GITHUB_REF_SLUG }}
+          tags: ${{ github.event_name == 'pull_request' && env.GITHUB_HEAD_REF_SLUG || env.GITHUB_REF_SLUG }}
           add_git_labels: true
 
   build-pusher:
-
+    if: ${{ github.event_name == 'push' || github.event_name == 'release' || github.event_name == 'pull_request' && contains(github.event.pull_request.labels.*.name, 'deploy') }}
     runs-on: ubuntu-latest
 
     steps:
@@ -76,11 +82,11 @@ jobs:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
           repository: thecodingmachine/workadventure-pusher
-          tags: ${{ env.GITHUB_REF_SLUG }}
+          tags: ${{ github.event_name == 'pull_request' && env.GITHUB_HEAD_REF_SLUG || env.GITHUB_REF_SLUG }}
           add_git_labels: true
 
   build-uploader:
-
+    if: ${{ github.event_name == 'push' || github.event_name == 'release' || github.event_name == 'pull_request' && contains(github.event.pull_request.labels.*.name, 'deploy') }}
     runs-on: ubuntu-latest
 
     steps:
@@ -99,11 +105,11 @@ jobs:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
           repository: thecodingmachine/workadventure-uploader
-          tags: ${{ env.GITHUB_REF_SLUG }}
+          tags: ${{ github.event_name == 'pull_request' && env.GITHUB_HEAD_REF_SLUG || env.GITHUB_REF_SLUG }}
           add_git_labels: true
 
   build-maps:
-
+    if: ${{ github.event_name == 'push' || github.event_name == 'release' || github.event_name == 'pull_request' && contains(github.event.pull_request.labels.*.name, 'deploy') }}
     runs-on: ubuntu-latest
 
     steps:
@@ -123,7 +129,7 @@ jobs:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
           repository: thecodingmachine/workadventure-maps
-          tags: ${{ env.GITHUB_REF_SLUG }}
+          tags: ${{ github.event_name == 'pull_request' && env.GITHUB_HEAD_REF_SLUG || env.GITHUB_REF_SLUG }}
           add_git_labels: true
 
   deeploy:
@@ -134,6 +140,7 @@ jobs:
       - build-maps
       - build-uploader
     runs-on: ubuntu-latest
+    if: ${{ github.event_name == 'push' || github.event_name == 'pull_request' && contains(github.event.pull_request.labels.*.name, 'deploy') }}
 
     steps:
       - name: Checkout
@@ -142,6 +149,37 @@ jobs:
       # Create a slugified value of the branch
       - uses: rlespinasse/github-slug-action@3.1.0
 
+      - name: Write certificate
+        run: echo "${CERTS_PRIVATE_KEY}" > secret.key && chmod 0600 secret.key
+        env:
+          CERTS_PRIVATE_KEY: ${{ secrets.CERTS_PRIVATE_KEY }}
+
+      - name: Download certificate
+        run: mkdir secrets && scp -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -i secret.key ubuntu@cert.workadventu.re:./config/live/workadventu.re/* secrets/
+
+      - name: Create namespace
+        uses: steebchen/kubectl@v1.0.0
+        env:
+          KUBE_CONFIG_DATA: ${{ secrets.KUBE_CONFIG_FILE_BASE64 }}
+        with:
+          args: create namespace workadventure-${{ github.event_name == 'pull_request' && env.GITHUB_HEAD_REF_SLUG || env.GITHUB_REF_SLUG }}
+        continue-on-error: true
+
+      - name: Delete old certificates in namespace
+        uses: steebchen/kubectl@v1.0.0
+        env:
+          KUBE_CONFIG_DATA: ${{ secrets.KUBE_CONFIG_FILE_BASE64 }}
+        with:
+          args: -n workadventure-${{ github.event_name == 'pull_request' && env.GITHUB_HEAD_REF_SLUG || env.GITHUB_REF_SLUG }} delete secret certificate-tls
+        continue-on-error: true
+
+      - name: Install certificates in namespace
+        uses: steebchen/kubectl@v1.0.0
+        env:
+          KUBE_CONFIG_DATA: ${{ secrets.KUBE_CONFIG_FILE_BASE64 }}
+        with:
+          args: -n workadventure-${{ github.event_name == 'pull_request' && env.GITHUB_HEAD_REF_SLUG || env.GITHUB_REF_SLUG }} create secret tls certificate-tls --key="secrets/privkey.pem" --cert="secrets/fullchain.pem"
+
       - name: Deploy
         uses: thecodingmachine/deeployer-action@master
         env:
@@ -151,14 +189,16 @@ jobs:
           JITSI_URL: ${{ secrets.JITSI_URL }}
           SECRET_JITSI_KEY: ${{ secrets.SECRET_JITSI_KEY }}
           TURN_STATIC_AUTH_SECRET: ${{ secrets.TURN_STATIC_AUTH_SECRET }}
+          DEPLOY_REF: ${{ github.event_name == 'pull_request' && env.GITHUB_HEAD_REF_SLUG || env.GITHUB_REF_SLUG }}
+          POSTHOG_API_KEY: ${{ secrets.POSTHOG_API_KEY }}
+          POSTHOG_URL: ${{ secrets.POSTHOG_URL }}
         with:
-          namespace: workadventure-${{ env.GITHUB_REF_SLUG }}
+          namespace: workadventure-${{ github.event_name == 'pull_request' && env.GITHUB_HEAD_REF_SLUG || env.GITHUB_REF_SLUG }}
 
       - name: Add a comment in PR
         uses: unsplash/comment-on-pr@v1.2.0
-        if: ${{ env.GITHUB_REF_SLUG != 'master' }}
+        if: ${{ github.event_name == 'pull_request' }}
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
-          msg: Environment deployed at https://play.${{ env.GITHUB_REF_SLUG }}.workadventure.test.thecodingmachine.com
-          check_for_duplicate_msg: true
+          msg: "Environment deployed at https://play-${{ env.GITHUB_HEAD_REF_SLUG }}.test.workadventu.re \nTests available at https://maps-${{ env.GITHUB_HEAD_REF_SLUG }}.test.workadventu.re/tests"

.github/workflows/cleanup.yml

@@ -1,7 +1,8 @@
 name: Cleanup images and environments
 
 on:
-  - delete
+  pull_request:
+    types: [ closed ]
 
 # Enables BuildKit
 env:
@@ -14,13 +15,12 @@ jobs:
 
     steps:
       # Create a slugified value of the branch
-      - uses: rlespinasse/github-slug-action@1.1.0
+      - uses: rlespinasse/github-slug-action@3.1.0
 
       - name: Cleanup
+        continue-on-error: true
         uses: thecodingmachine/deeployer-cleanup-action@master
         env:
           KUBE_CONFIG_FILE: ${{ secrets.KUBE_CONFIG_FILE }}
         with:
-# FIXME: we are not using ${{ env.GITHUB_REF_SLUG }} that resolves to master BUT! we are not using a slugified namespace
-# so complex namespace names will not be treated correctly
-          namespace: workadventure-${{ github.event.ref }}
+          namespace: workadventure-${{ env.GITHUB_HEAD_REF_SLUG }}

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,71 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ develop ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ develop ]
+  schedule:
+    - cron: '24 17 * * 0'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'javascript' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
+        # Learn more:
+        # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v1
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v1
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v1

.github/workflows/continuous_integration.yml

@@ -3,8 +3,11 @@
 name: "Continuous Integration"
 
 on:
-  - "pull_request"
-  - "push"
+  push:
+    branches:
+      - master
+      - develop
+  pull_request:
 
 jobs:
 
@@ -46,13 +49,22 @@ jobs:
       - name: "Build"
         run: yarn run build
         env:
-          API_URL: "localhost:8080"
+          PUSHER_URL: "//localhost:8080"
+          ADMIN_URL: "//localhost:80"
+        working-directory: "front"
+
+      - name: "Svelte check"
+        run: yarn run svelte-check
         working-directory: "front"
 
       - name: "Lint"
         run: yarn run lint
         working-directory: "front"
 
+      - name: "Pretty"
+        run: yarn run pretty-check
+        working-directory: "front"
+
       - name: "Jasmine"
         run: yarn test
         working-directory: "front"
@@ -69,7 +81,7 @@ jobs:
       - name: "Setup NodeJS"
         uses: actions/setup-node@v1
         with:
-          node-version: '12.x'
+          node-version: '14.x'
 
       - name: Install Protoc
         uses: arduino/setup-protoc@v1
@@ -100,6 +112,10 @@ jobs:
         run: yarn test
         working-directory: "pusher"
 
+      - name: "Prettier"
+        run: yarn run pretty-check
+        working-directory: "pusher"
+
   continuous-integration-back:
     name: "Continuous Integration Back"
 
@@ -143,3 +159,7 @@ jobs:
         run: yarn test
         working-directory: "back"
 
+      - name: "Prettier"
+        run: yarn run pretty-check
+        working-directory: "back"
+

.github/workflows/end_to_end_tests.yml

@@ -0,0 +1,60 @@
+# https://help.github.com/en/categories/automating-your-workflow-with-github-actions
+
+name: "End to end tests"
+
+on:
+  push:
+    branches:
+      - master
+      - develop
+  pull_request:
+
+jobs:
+
+  end-to-end-tests:
+    name: "End-to-end testcafe tests"
+
+    runs-on: "ubuntu-latest"
+
+    steps:
+      - name: "Checkout"
+        uses: "actions/checkout@v2.0.0"
+
+      - name: "Setup .env file"
+        run: cp .env.template .env
+
+      - name: "Edit ownership of file for test cases"
+        run: sudo chown 1000:1000 -R .
+
+      - name: "Start environment"
+        run: docker-compose up -d
+
+      - name: "Wait for environment to build (and downloading testcafe image)"
+        run: (docker-compose -f docker-compose.testcafe.yml pull &) && docker-compose logs -f --tail=0 front | grep -q "Compiled successfully"
+
+#      - name: "temp debug: display logs"
+#        run: docker-compose logs
+#
+#      - name: "Wait for back start"
+#        run: docker-compose logs -f back | grep -q "WorkAdventure HTTP API starting on port"
+#
+#      - name: "Wait for pusher start"
+#        run: docker-compose logs -f pusher | grep -q "WorkAdventure starting on port"
+
+      - name: "Run tests"
+        run: docker-compose -f docker-compose.testcafe.yml up --exit-code-from testcafe
+
+      - name: Upload failed tests
+        if: ${{ failure() }}
+        uses: actions/upload-artifact@v2
+        with:
+          name: my-artifact
+          path: './tests/screenshots/'
+
+      - name: Display state
+        if: ${{ failure() }}
+        run: docker-compose ps
+
+      - name: Display logs
+        if: ${{ failure() }}
+        run: docker-compose logs

.github/workflows/push-to-npm.yml

@@ -2,6 +2,7 @@ name: Push @workadventure/iframe-api-typings to NPM
 on:
   release:
     types: [created]
+  push:
 jobs:
   build:
     runs-on: ubuntu-latest
@@ -13,10 +14,6 @@ jobs:
           node-version: '14.x'
           registry-url: 'https://registry.npmjs.org'
 
-      - name: Edit tsconfig.json to add declarations
-        run: "sed -i 's/\"declaration\": false/\"declaration\": true/g' tsconfig.json"
-        working-directory: "front"
-
       - name: Replace version number
         run: 'sed -i "s#VERSION_PLACEHOLDER#${GITHUB_REF/refs\/tags\//}#g" package.json'
         working-directory: "front/packages/iframe-api-typings"
@@ -47,15 +44,19 @@ jobs:
         working-directory: "front"
 
       - name: "Build"
-        run: yarn run build
+        run: yarn run build-typings
         env:
-          API_URL: "localhost:8080"
+          PUSHER_URL: "//localhost:8080"
+          ADMIN_URL: "//localhost:80"
         working-directory: "front"
 
       # We build the front to generate the typings of iframe_api, then we copy those typings in a separate package.
       - name: Copy typings to package dir
         run: cp front/dist/src/iframe_api.d.ts front/packages/iframe-api-typings/iframe_api.d.ts
 
+      - name: Copy typings to package dir (2)
+        run: cp -R front/dist/src/Api front/packages/iframe-api-typings/Api
+
       - name: Install dependencies in package
         run: yarn install
         working-directory: "front/packages/iframe-api-typings"
@@ -65,3 +66,4 @@ jobs:
         working-directory: "front/packages/iframe-api-typings"
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+        if: ${{ github.event_name == 'release' }}

.gitignore

@@ -6,4 +6,6 @@ docker-compose.override.yaml
 *.DS_Store
 maps/yarn.lock
 maps/dist/computer.js
-maps/dist/computer.js.map
+maps/dist/computer.js.map
+node_modules
+_

.husky/.gitignore

@@ -0,0 +1 @@
+_

.husky/pre-commit

@@ -0,0 +1,15 @@
+#!/bin/sh
+. "$(dirname "$0")/_/husky.sh"
+
+(
+cd front || exit
+yarn run precommit
+)
+(
+cd pusher || exit
+yarn run precommit
+)
+(
+cd back || exit
+yarn run precommit
+)

CHANGELOG.md

@@ -0,0 +1,166 @@
+## Version develop
+
+### Updates
+- Added multi Co-Website management
+
+### Bugfix
+- Moving a discussion over a user will now add this user to the discussion
+- Being in a silent zone new forces mediaConstraints to false (#1508)
+- Fixes for the emote menu (#1501)
+- Fixing chat message attributed to wrong user (#1507 #1528)
+
+## Version 1.5.0
+### Updates
+- Added support for login with OpenID Connect
+- New scripting library available to extend WorkAdventure: see [Scripting API Extra](https://github.com/workadventure/scripting-api-extra/)  
+- New menu design!
+- New `openTab` property (#1419)
+- Possible integration with Posthog (#1458)
+
+### Bugfix
+- Fixing layers flattened several times (#1427 @Lurkars)
+- Fixing CSS of video elements
+- Chat now scrolls to bottom when opened (#1450)
+- Fixing silent zone not respected when exiting from Jitsi (#1456)
+- Fixing "yarn install" failing because of missing rights on some Docker installs (#1457)
+- Fixing audio not shut down when exiting a room (#1459)
+
+### Misc
+- Finished migrating "Build your map" documentation into the "/docs" directory of this repository (#1417 #1385)
+- Refactoring documentation (dedicated page for variables) (#1414)
+- Front container code is now completely linted (#1413)
+
+## Version 1.4.15
+
+### Updates 
+- New scripting API features : 
+  - Use `WA.ui.registerMenuCommand(commandDescriptor: string, options: MenuOptions): Menu` to add a custom menu or an iframe to the menu.
+- New `jitsiWidth` parameter to set the width of Jitsi and Cowebsite (#1398 @tabascoeye)
+- Refactored the way videos are displayed to better cope for vertical videos (on mobile)
+- Fixing reconnection issues after 5 minutes of an inactive tab on Google Chrome
+- Changes performed in `WA.room.setPropertyLayer` now have a real-time impact (#1395)
+
+### Bugfixes
+- Fixing streams in bubbles sometimes improperly muted when there are more than 2 people in the bubble (#1400 #1402)
+- Properly displaying carriage returns in popups (#1388)
+- `WA.state` now answers correctly to "in" keyword (#1393)
+- Variables can now be nested in group layers (#1406)
+
+## Version 1.4.14
+
+### Updates
+- New scripting API features : 
+  - Use `WA.room.loadTileset(url: string) : Promise<number>` to load a tileset from a JSON file.
+- Rewrote the way authentification works: the auth jwt token can now contains an email instead of an uuid
+- Added an OpenId login flow than can be plugged to any OIDC provider.
+- You can send a message to all rooms of your world from the console global message (user with tag admin only).
+
+## Version 1.4.11
+
+### Updates
+
+- Added the ability to have animated tiles in maps #1216 #1217
+- Enabled outlines on actionable item again (they were disabled when migrating to Phaser 3.50) #1218
+- Enabled outlines on player names (when the mouse hovers on a player you can interact with) #1219
+- Migrated the admin console to Svelte, and redesigned the console #1211
+- Layer properties (like `exitUrl`, `silent`, etc...) can now also used in tile properties #1210 (@jonnytest1)
+- New scripting API features :
+  - Use `WA.onInit(): Promise<void>` to wait for scripting API initialization
+  - Use `WA.room.showLayer(): void` to show a layer
+  - Use `WA.room.hideLayer(): void` to hide a layer
+  - Use `WA.room.setProperty() : void` to add, delete or change existing property of a layer
+  - Use `WA.player.onPlayerMove(): void` to track the movement of the current player
+  - Use `WA.player.id: string|undefined` to get the ID of the current player
+  - Use `WA.player.name: string` to get the name of the current player
+  - Use `WA.player.tags: string[]` to get the tags of the current player
+  - Use `WA.room.id: string` to get the ID of the room
+  - Use `WA.room.mapURL: string` to get the URL of the map
+  - Use `WA.room.mapURL: string` to get the URL of the map
+  - Use `WA.room.getMap(): Promise<ITiledMap>` to get the JSON map file
+  - Use `WA.room.setTiles(): void` to add, delete or change an array of tiles
+  - Use `WA.ui.registerMenuCommand(): void` to add a custom menu
+  - Use `WA.state.loadVariable(key: string): unknown` to retrieve a variable
+  - Use `WA.state.saveVariable(key: string, value: unknown): Promise<void>` to set a variable (across the room, for all users)
+  - Use `WA.state.onVariableChange(key: string): Observable<unknown>` to track a variable
+  - Use `WA.state.[any variable]: unknown` to access directly any variable (this is a shortcut to using `WA.state.loadVariable` and `WA.state.saveVariable`)
+- Users blocking now relies on UUID rather than ID. A blocked user that leaves a room and comes back will stay blocked.
+- The text chat was redesigned to be prettier and to use more features :
+  - The chat is now persistent between discussions and always accessible
+  - The chat now tracks incoming and outcoming users in your conversation
+  - The chat allows your to see the visit card of users
+  - You can close the chat window with the escape key
+- Added a 'Enable notifications' button in the menu.
+- The exchange format between Pusher and Admin servers has changed. If you have your own implementation of an admin server, these endpoints signatures have changed:
+  - `/api/map`: now accepts a complete room URL instead of organization/world/room slugs
+  - `/api/ban`: new endpoint to report users
+  - as a side effect, the "routing" is now completely stored on the admin side, so by implementing your own admin server, you can develop completely custom routing
+
+## Version 1.4.3 - 1.4.4 - 1.4.5
+
+## Bugfixes
+
+- Fixing the generation of @workadventure/iframe-api-typings
+
+## Version 1.4.2
+
+## Updates
+
+- A script in an iframe opened by another script can use the IFrame API.
+
+## Version 1.4.1
+
+### Bugfixes
+
+- Loading errors after the preload stage should not crash the game anymore
+
+## Version 1.4.0
+
+### BREAKING CHANGES
+
+- Scripting API:
+  - Changed function names: `restorePlayerControl` => `restorePlayerControls`, `disablePlayerControl` => `disablePlayerControls`.
+    Please keep in mind that the scripting API is still experimental. Some breaking changes can occur in it until we mark it as stable.
+
+### Updates
+
+- Added the emote feature to WorkAdventure. (@Kharhamel, @Tabascoeye)
+  - The emote menu can be opened by clicking on your character. 
+  -  Clicking on one of its element will close the menu and play an emote above your character. 
+  -  This emote can be seen by other players.
+- Player names were improved. (@Kharhamel)
+  - We now create a GameObject.Text instead of GameObject.BitmapText
+  - now use the 'Press Start 2P' font family and added an outline
+  - As a result, we can now allow non-standard letters like french accents or chinese characters!
+  
+- Added the contact card feature. (@Kharhamel)
+  - Click on another player to see its contact info.
+  - Premium-only feature unfortunately. I need to find a way to make it available for all.
+  - If no contact data is found (either because the user is anonymous or because no admin backend), display an error card.
+
+- Mobile support has been improved
+  - WorkAdventure automatically sets the zoom level based on the viewport size to ensure a sensible size of the map is visible, whatever the viewport used
+  - Mouse wheel support to zoom in / out
+  - Pinch support on mobile to zoom in / out
+  - Improved virtual joystick size (adapts to the zoom level)
+- Redesigned intermediate scenes
+  - Redesigned Select Companion scene
+  - Redesigned Enter Your Name scene
+    - Added a new `DISPLAY_TERMS_OF_USE` environment variable to trigger the display of terms of use  
+- New scripting API features:
+  - Use `WA.loadSound(): Sound` to load / play / stop a sound
+
+
+### Bug Fixes
+
+- Pinch gesture does no longer move the character
+
+## Version 1.3.0
+
+### New Features
+
+* Maps can now contain "group" layers (layers that contain other layers) - #899 #779 (@Lurkars @moufmouf)
+
+### Updates
+
+
+### Bug Fixes

CONTRIBUTING.md

@@ -0,0 +1,67 @@
+# Contributing to WorkAdventure
+
+Are you looking to help on WorkAdventure? Awesome, feel welcome and read the following sections in order to know how to 
+ask questions and how to work on something.
+
+## Contributions we are seeking
+
+We love to receive contributions from our community — you!
+
+There are many ways to contribute, from writing tutorials or blog posts, improving the documentation, 
+submitting bug reports and feature requests or writing code which can be incorporated into WorkAdventure itself.
+
+## Using the issue tracker
+
+First things first: **Do NOT report security vulnerabilities in public issues!**.
+Please read the [security guide](SECURITY.md) to learn who to do a security disclosure to the WorkAdventure core team.
+
+You can use [GitHub issue tracker](https://github.com/thecodingmachine/workadventure/issues) to:
+
+- File bug reports
+- Ask for feature requests
+
+If you have more general questions, a good place to ask is [our Discord server](https://discord.gg/YGtngdh9gt).
+
+Finally, you can come and talk to the WorkAdventure core team... on WorkAdventure, of course! [Our offices are here](https://play.staging.workadventu.re/@/tcm/workadventure/wa-village).
+
+## Pull requests
+
+Good pull requests - patches, improvements, new features - are a fantastic help. They should remain focused in scope 
+and avoid containing unrelated commits.
+
+Please ask first before embarking on any significant pull request (e.g. implementing features, refactoring code), 
+otherwise you risk spending a lot of time working on something that the project's developers might not want to merge 
+into the project.
+
+You can ask us on [Discord](https://discord.gg/YGtngdh9gt) or in the [GitHub issues](https://github.com/thecodingmachine/workadventure/issues).
+
+### Linting your code
+
+Before committing, be sure to install the "Prettier" precommit hook that will reformat your code to our coding style.
+
+In order to enable the "Prettier" precommit hook, at the root of the project, run:
+
+```console
+$ yarn install
+$ yarn run prepare
+```
+
+If you don't have the precommit hook installed (or if you committed code before installing the precommit hook), you will need 
+to run code linting manually:
+
+```console
+$ docker-compose exec front yarn run pretty
+$ docker-compose exec pusher yarn run pretty
+$ docker-compose exec back yarn run pretty
+```
+
+### Providing tests
+
+WorkAdventure is based on a video game engine (Phaser), and video games are not the easiest programs to unit test.
+
+Nevertheless, if your code can be unit tested, please provide a unit test (we use Jasmine).
+
+If you are providing a new feature, you should setup a test map in the `maps/tests` directory. The test map should contain
+some description text describing how to test the feature. Finally, you should modify the `maps/tests/index.html` file
+to add a reference to your newly created test map.
+

README.md

@@ -1,17 +1,18 @@
 ![](https://github.com/thecodingmachine/workadventure/workflows/Continuous%20Integration/badge.svg) [![Discord](https://img.shields.io/discord/821338762134290432?label=Discord)](https://discord.gg/YGtngdh9gt)
 
-![WorkAdventure landscape image](README-INTRO.jpg)
+![WorkAdventure logo](README-LOGO.svg)
+![WorkAdventure office image](README-MAP.png)
 
-Demo here : [https://workadventu.re/](https://workadventu.re/).
+Live demo [here](https://play.workadventu.re/@/tcm/workadventure/wa-village).
 
-# Work Adventure
+# WorkAdventure
 
-Work Adventure is a web-based collaborative workspace for small to medium teams (2-100 people) presented in the form of a
+WorkAdventure is a web-based collaborative workspace presented in the form of a
 16-bit video game.
 
-In Work Adventure, you can move around your office and talk to your colleagues (using a video-chat feature that is
-triggered when you move next to a colleague).
+In WorkAdventure you can move around your office and talk to your colleagues (using a video-chat system, triggered when you approach someone).
 
+See more features for your virtual office: https://workadventu.re/virtual-office
 
 ## Setting up a development environment
 
@@ -20,7 +21,8 @@ Install Docker.
 Run:
 
 ```
-docker-compose up
+cp .env.template .env
+docker-compose up -d
 ```
 
 The environment will start.
@@ -35,6 +37,9 @@ Note: on some OSes, you will need to add this line to your `/etc/hosts` file:
 127.0.0.1 workadventure.localhost
 ```
 
+Note: If on the first run you get a page with "network error". Try to ``docker-compose stop`` , then ``docker-compose start``.
+Note 2: If you are still getting "network error". Make sure you are authorizing the self-signed certificate by entering https://pusher.workadventure.localhost and accepting them.
+
 ### MacOS developers, your environment with Vagrant
 
 If you are using MacOS, you can increase Docker performance using Vagrant. If you want more explanations, you can read [this medium article](https://medium.com/better-programming/vagrant-to-increase-docker-performance-with-macos-25b354b0c65c).

SECURITY.md

@@ -0,0 +1,20 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+First things first: **Do NOT report security vulnerabilities in public issues!**
+
+Please disclose responsibly by sending
+a mail at security@workadventu.re (you can also ping us in the GitHub issues, but please, no details in the issues!)
+
+We will assess the issue as soon as possible on a best-effort basis and will give you an estimate for when we have a fix 
+and release available for an eventual public disclosure.
+
+We do not have a bug bounty program.
+
+## Supported Versions
+
+We only apply security patches on the latest tagged release and on the `master` and `develop` branches
+
+Unless specified otherwise, do not expect us to fix security issues on past releases. We are only maintaining one release:
+the latest one, which is online at https://play.workadventu.re.

back/.prettierignore

@@ -0,0 +1 @@
+src/Messages/generated

back/.prettierrc.json

@@ -0,0 +1,4 @@
+{
+  "printWidth": 120,
+  "tabWidth": 4
+}

back/package.json

@@ -10,8 +10,11 @@
     "runprod": "node --max-old-space-size=4096 ./dist/server.js",
     "profile": "tsc && node --prof ./dist/server.js",
     "test": "ts-node node_modules/jasmine/bin/jasmine --config=jasmine.json",
-    "lint": "node_modules/.bin/eslint src/ . --ext .ts",
-    "fix": "node_modules/.bin/eslint --fix src/ . --ext .ts"
+    "lint": "DEBUG= node_modules/.bin/eslint src/ . --ext .ts",
+    "fix": "DEBUG= node_modules/.bin/eslint --fix src/ . --ext .ts",
+    "precommit": "lint-staged",
+    "pretty": "yarn prettier --write 'src/**/*.{ts,tsx}'",
+    "pretty-check": "yarn prettier --check 'src/**/*.{ts,tsx}'"
   },
   "repository": {
     "type": "git",
@@ -37,24 +40,20 @@
   },
   "homepage": "https://github.com/thecodingmachine/workadventure#readme",
   "dependencies": {
-    "axios": "^0.21.1",
-    "body-parser": "^1.19.0",
+    "@workadventure/tiled-map-type-guard": "^1.0.3",
+    "axios": "^0.21.2",
     "busboy": "^0.3.1",
     "circular-json": "^0.5.9",
     "debug": "^4.3.1",
     "generic-type-guard": "^3.2.0",
     "google-protobuf": "^3.13.0",
     "grpc": "^1.24.4",
-    "http-status-codes": "^1.4.0",
-    "iterall": "^1.3.0",
+    "ipaddr.js": "^2.0.1",
     "jsonwebtoken": "^8.5.1",
     "mkdirp": "^1.0.4",
-    "multer": "^1.4.2",
     "prom-client": "^12.0.0",
     "query-string": "^6.13.3",
-    "systeminformation": "^4.31.1",
-    "ts-node-dev": "^1.0.0-pre.44",
-    "typescript": "^3.8.3",
+    "redis": "^3.1.2",
     "uWebSockets.js": "uNetworking/uWebSockets.js#v18.5.0",
     "uuidv4": "^6.0.7"
   },
@@ -67,10 +66,20 @@
     "@types/jasmine": "^3.5.10",
     "@types/jsonwebtoken": "^8.3.8",
     "@types/mkdirp": "^1.0.1",
+    "@types/redis": "^2.8.31",
     "@types/uuidv4": "^5.0.0",
     "@typescript-eslint/eslint-plugin": "^2.26.0",
     "@typescript-eslint/parser": "^2.26.0",
     "eslint": "^6.8.0",
-    "jasmine": "^3.5.0"
+    "jasmine": "^3.5.0",
+    "lint-staged": "^11.0.0",
+    "prettier": "^2.3.1",
+    "ts-node-dev": "^1.0.0-pre.44",
+    "typescript": "^3.8.3"
+  },
+  "lint-staged": {
+    "*.ts": [
+      "prettier --write"
+    ]
   }
 }

back/src/App.ts

@@ -1,7 +1,7 @@
 // lib/app.ts
-import {PrometheusController} from "./Controller/PrometheusController";
-import {DebugController} from "./Controller/DebugController";
-import {App as uwsApp} from "./Server/sifrr.server";
+import { PrometheusController } from "./Controller/PrometheusController";
+import { DebugController } from "./Controller/DebugController";
+import { App as uwsApp } from "./Server/sifrr.server";
 
 class App {
     public app: uwsApp;

back/src/Controller/BaseController.ts

@@ -1,10 +1,9 @@
-import {HttpResponse} from "uWebSockets.js";
-
+import { HttpResponse } from "uWebSockets.js";
 
 export class BaseController {
     protected addCorsHeaders(res: HttpResponse): void {
-        res.writeHeader('access-control-allow-headers', 'Origin, X-Requested-With, Content-Type, Accept');
-        res.writeHeader('access-control-allow-methods', 'GET, POST, OPTIONS, PUT, PATCH, DELETE');
-        res.writeHeader('access-control-allow-origin', '*');
+        res.writeHeader("access-control-allow-headers", "Origin, X-Requested-With, Content-Type, Accept");
+        res.writeHeader("access-control-allow-methods", "GET, POST, OPTIONS, PUT, PATCH, DELETE");
+        res.writeHeader("access-control-allow-origin", "*");
     }
 }

back/src/Controller/DebugController.ts

@@ -1,53 +1,54 @@
-import {ADMIN_API_TOKEN} from "../Enum/EnvironmentVariable";
-import {stringify} from "circular-json";
-import {HttpRequest, HttpResponse} from "uWebSockets.js";
-import { parse } from 'query-string';
-import {App} from "../Server/sifrr.server";
-import {socketManager} from "../Services/SocketManager";
+import { ADMIN_API_TOKEN } from "../Enum/EnvironmentVariable";
+import { stringify } from "circular-json";
+import { HttpRequest, HttpResponse } from "uWebSockets.js";
+import { parse } from "query-string";
+import { App } from "../Server/sifrr.server";
+import { socketManager } from "../Services/SocketManager";
 
 export class DebugController {
-    constructor(private App : App) {
+    constructor(private App: App) {
         this.getDump();
     }
 
-
-    getDump(){
+    getDump() {
         this.App.get("/dump", (res: HttpResponse, req: HttpRequest) => {
             const query = parse(req.getQuery());
 
             if (query.token !== ADMIN_API_TOKEN) {
-                return res.status(401).send('Invalid token sent!');
+                return res.writeStatus("401 Unauthorized").end("Invalid token sent!");
             }
 
-            return res.writeStatus('200 OK').writeHeader('Content-Type', 'application/json').end(stringify(
-                socketManager.getWorlds(),
-                (key: unknown, value: unknown) => {
-                    if (key === 'listeners') {
-                        return 'Listeners';
-                    }
-                    if (key === 'socket') {
-                        return 'Socket';
-                    }
-                    if (key === 'batchedMessages') {
-                        return 'BatchedMessages';
-                    }
-                    if(value instanceof Map) {
-                        const obj: any = {}; // eslint-disable-line @typescript-eslint/no-explicit-any
-                        for (const [mapKey, mapValue] of value.entries()) {
-                            obj[mapKey] = mapValue;
+            return res
+                .writeStatus("200 OK")
+                .writeHeader("Content-Type", "application/json")
+                .end(
+                    stringify(socketManager.getWorlds(), (key: unknown, value: unknown) => {
+                        if (key === "listeners") {
+                            return "Listeners";
                         }
-                        return obj;
-                    } else if(value instanceof Set) {
+                        if (key === "socket") {
+                            return "Socket";
+                        }
+                        if (key === "batchedMessages") {
+                            return "BatchedMessages";
+                        }
+                        if (value instanceof Map) {
+                            const obj: any = {}; // eslint-disable-line @typescript-eslint/no-explicit-any
+                            for (const [mapKey, mapValue] of value.entries()) {
+                                obj[mapKey] = mapValue;
+                            }
+                            return obj;
+                        } else if (value instanceof Set) {
                             const obj: Array<unknown> = [];
                             for (const [setKey, setValue] of value.entries()) {
                                 obj.push(setValue);
                             }
                             return obj;
-                    } else {
-                        return value;
-                    }
-                }
-            ));
+                        } else {
+                            return value;
+                        }
+                    })
+                );
         });
     }
 }

back/src/Controller/PrometheusController.ts

@@ -1,7 +1,7 @@
-import {App} from "../Server/sifrr.server";
-import {HttpRequest, HttpResponse} from "uWebSockets.js";
-const register = require('prom-client').register;
-const collectDefaultMetrics = require('prom-client').collectDefaultMetrics;
+import { App } from "../Server/sifrr.server";
+import { HttpRequest, HttpResponse } from "uWebSockets.js";
+const register = require("prom-client").register;
+const collectDefaultMetrics = require("prom-client").collectDefaultMetrics;
 
 export class PrometheusController {
     constructor(private App: App) {
@@ -14,7 +14,7 @@ export class PrometheusController {
     }
 
     private metrics(res: HttpResponse, req: HttpRequest): void {
-        res.writeHeader('Content-Type', register.contentType);
+        res.writeHeader("Content-Type", register.contentType);
         res.end(register.metrics());
     }
 }

back/src/Enum/EnvironmentVariable.ts

@@ -1,17 +1,20 @@
 const MINIMUM_DISTANCE = process.env.MINIMUM_DISTANCE ? Number(process.env.MINIMUM_DISTANCE) : 64;
 const GROUP_RADIUS = process.env.GROUP_RADIUS ? Number(process.env.GROUP_RADIUS) : 48;
-const ALLOW_ARTILLERY = process.env.ALLOW_ARTILLERY ? process.env.ALLOW_ARTILLERY == 'true' : false;
-const ADMIN_API_URL = process.env.ADMIN_API_URL || '';
-const ADMIN_API_TOKEN = process.env.ADMIN_API_TOKEN || 'myapitoken';
+const ALLOW_ARTILLERY = process.env.ALLOW_ARTILLERY ? process.env.ALLOW_ARTILLERY == "true" : false;
+const ADMIN_API_URL = process.env.ADMIN_API_URL || "";
+const ADMIN_API_TOKEN = process.env.ADMIN_API_TOKEN || "myapitoken";
 const CPU_OVERHEAT_THRESHOLD = Number(process.env.CPU_OVERHEAT_THRESHOLD) || 80;
-const JITSI_URL : string|undefined = (process.env.JITSI_URL === '') ? undefined : process.env.JITSI_URL;
-const JITSI_ISS = process.env.JITSI_ISS || '';
-const SECRET_JITSI_KEY = process.env.SECRET_JITSI_KEY || '';
-const HTTP_PORT = parseInt(process.env.HTTP_PORT || '8080') || 8080;
-const GRPC_PORT = parseInt(process.env.GRPC_PORT || '50051') || 50051;
-export const SOCKET_IDLE_TIMER = parseInt(process.env.SOCKET_IDLE_TIMER as string) || 30; // maximum time (in second) without activity before a socket is closed
-export const TURN_STATIC_AUTH_SECRET = process.env.TURN_STATIC_AUTH_SECRET || '';
-export const MAX_PER_GROUP = parseInt(process.env.MAX_PER_GROUP || '4');
+const JITSI_URL: string | undefined = process.env.JITSI_URL === "" ? undefined : process.env.JITSI_URL;
+const JITSI_ISS = process.env.JITSI_ISS || "";
+const SECRET_JITSI_KEY = process.env.SECRET_JITSI_KEY || "";
+const HTTP_PORT = parseInt(process.env.HTTP_PORT || "8080") || 8080;
+const GRPC_PORT = parseInt(process.env.GRPC_PORT || "50051") || 50051;
+export const TURN_STATIC_AUTH_SECRET = process.env.TURN_STATIC_AUTH_SECRET || "";
+export const MAX_PER_GROUP = parseInt(process.env.MAX_PER_GROUP || "4");
+export const REDIS_HOST = process.env.REDIS_HOST || undefined;
+export const REDIS_PORT = parseInt(process.env.REDIS_PORT || "6379") || 6379;
+export const REDIS_PASSWORD = process.env.REDIS_PASSWORD || undefined;
+export const STORE_VARIABLES_FOR_LOCAL_MAPS = process.env.STORE_VARIABLES_FOR_LOCAL_MAPS === "true";
 
 export {
     MINIMUM_DISTANCE,
@@ -24,5 +27,5 @@ export {
     CPU_OVERHEAT_THRESHOLD,
     JITSI_URL,
     JITSI_ISS,
-    SECRET_JITSI_KEY
-}
+    SECRET_JITSI_KEY,
+};

back/src/Model/Admin.ts

@@ -1,18 +1,12 @@
 import {
-    BatchMessage,
-    PusherToBackMessage,
     ServerToAdminClientMessage,
-    ServerToClientMessage,
-    SubMessage, UserJoinedRoomMessage, UserLeftRoomMessage
+    UserJoinedRoomMessage,
+    UserLeftRoomMessage,
 } from "../Messages/generated/messages_pb";
-import {AdminSocket} from "../RoomManager";
-
+import { AdminSocket } from "../RoomManager";
 
 export class Admin {
-    public constructor(
-        private readonly socket: AdminSocket
-    ) {
-    }
+    public constructor(private readonly socket: AdminSocket) {}
 
     public sendUserJoin(uuid: string, name: string, ip: string): void {
         const serverToAdminClientMessage = new ServerToAdminClientMessage();
@@ -27,7 +21,7 @@ export class Admin {
         this.socket.write(serverToAdminClientMessage);
     }
 
-    public sendUserLeft(uuid: string/*, name: string, ip: string*/): void {
+    public sendUserLeft(uuid: string /*, name: string, ip: string*/): void {
         const serverToAdminClientMessage = new ServerToAdminClientMessage();
 
         const userLeftRoomMessage = new UserLeftRoomMessage();

back/src/Model/GameRoom.ts

@@ -1,80 +1,94 @@
-import {PointInterface} from "./Websocket/PointInterface";
-import {Group} from "./Group";
-import {User, UserSocket} from "./User";
-import {PositionInterface} from "_Model/PositionInterface";
-import {EntersCallback, LeavesCallback, MovesCallback} from "_Model/Zone";
-import {PositionNotifier} from "./PositionNotifier";
-import {Movable} from "_Model/Movable";
-import {extractDataFromPrivateRoomId, extractRoomSlugPublicRoomId, isRoomAnonymous} from "./RoomIdentifier";
-import {arrayIntersect} from "../Services/ArrayHelper";
-import {JoinRoomMessage} from "../Messages/generated/messages_pb";
-import {ProtobufUtils} from "../Model/Websocket/ProtobufUtils";
-import {ZoneSocket} from "src/RoomManager";
-import {Admin} from "../Model/Admin";
+import { PointInterface } from "./Websocket/PointInterface";
+import { Group } from "./Group";
+import { User, UserSocket } from "./User";
+import { PositionInterface } from "_Model/PositionInterface";
+import { EmoteCallback, EntersCallback, LeavesCallback, MovesCallback } from "_Model/Zone";
+import { PositionNotifier } from "./PositionNotifier";
+import { Movable } from "_Model/Movable";
+import {
+    BatchToPusherMessage,
+    BatchToPusherRoomMessage,
+    EmoteEventMessage,
+    ErrorMessage,
+    JoinRoomMessage,
+    SubToPusherRoomMessage,
+    VariableMessage,
+    VariableWithTagMessage,
+} from "../Messages/generated/messages_pb";
+import { ProtobufUtils } from "../Model/Websocket/ProtobufUtils";
+import { RoomSocket, ZoneSocket } from "src/RoomManager";
+import { Admin } from "../Model/Admin";
+import { adminApi } from "../Services/AdminApi";
+import { isMapDetailsData, MapDetailsData } from "../Services/AdminApi/MapDetailsData";
+import { ITiledMap } from "@workadventure/tiled-map-type-guard/dist";
+import { mapFetcher } from "../Services/MapFetcher";
+import { VariablesManager } from "../Services/VariablesManager";
+import { ADMIN_API_URL } from "../Enum/EnvironmentVariable";
+import { LocalUrlError } from "../Services/LocalUrlError";
+import { emitErrorOnRoomSocket } from "../Services/MessageHelpers";
+import { VariableError } from "../Services/VariableError";
 
 export type ConnectCallback = (user: User, group: Group) => void;
 export type DisconnectCallback = (user: User, group: Group) => void;
 
-export enum GameRoomPolicyTypes {
-    ANONYMOUS_POLICY = 1,
-    MEMBERS_ONLY_POLICY,
-    USE_TAGS_POLICY,
-}
-
 export class GameRoom {
-    private readonly minDistance: number;
-    private readonly groupRadius: number;
-
     // Users, sorted by ID
-    private readonly users: Map<number, User>;
-    private readonly usersByUuid: Map<string, User>;
-    private readonly groups: Set<Group>;
-    private readonly admins: Set<Admin>;
+    private readonly users = new Map<number, User>();
+    private readonly usersByUuid = new Map<string, User>();
+    private readonly groups = new Set<Group>();
+    private readonly admins = new Set<Admin>();
 
-    private readonly connectCallback: ConnectCallback;
-    private readonly disconnectCallback: DisconnectCallback;
-
-    private itemsState: Map<number, unknown> = new Map<number, unknown>();
+    private itemsState = new Map<number, unknown>();
 
     private readonly positionNotifier: PositionNotifier;
-    public readonly roomId: string;
-    public readonly roomSlug: string;
-    public readonly worldSlug: string = '';
-    public readonly organizationSlug: string = '';
-    private versionNumber:number = 1;
+    private versionNumber: number = 1;
     private nextUserId: number = 1;
 
-    constructor(roomId: string,
-                connectCallback: ConnectCallback,
-                disconnectCallback: DisconnectCallback,
-                minDistance: number,
-                groupRadius: number,
-                onEnters: EntersCallback,
-                onMoves: MovesCallback,
-                onLeaves: LeavesCallback)
-    {
-        this.roomId = roomId;
+    private roomListeners: Set<RoomSocket> = new Set<RoomSocket>();
 
-        if (isRoomAnonymous(roomId)) {
-            this.roomSlug = extractRoomSlugPublicRoomId(this.roomId);
-        } else {
-            const {organizationSlug, worldSlug, roomSlug} = extractDataFromPrivateRoomId(this.roomId);
-            this.roomSlug = roomSlug;
-            this.organizationSlug = organizationSlug;
-            this.worldSlug = worldSlug;
-        }
-
-
-        this.users = new Map<number, User>();
-        this.usersByUuid = new Map<string, User>();
-        this.admins = new Set<Admin>();
-        this.groups = new Set<Group>();
-        this.connectCallback = connectCallback;
-        this.disconnectCallback = disconnectCallback;
-        this.minDistance = minDistance;
-        this.groupRadius = groupRadius;
+    private constructor(
+        public readonly roomUrl: string,
+        private mapUrl: string,
+        private readonly connectCallback: ConnectCallback,
+        private readonly disconnectCallback: DisconnectCallback,
+        private readonly minDistance: number,
+        private readonly groupRadius: number,
+        onEnters: EntersCallback,
+        onMoves: MovesCallback,
+        onLeaves: LeavesCallback,
+        onEmote: EmoteCallback
+    ) {
         // A zone is 10 sprites wide.
-        this.positionNotifier = new PositionNotifier(320, 320, onEnters, onMoves, onLeaves);
+        this.positionNotifier = new PositionNotifier(320, 320, onEnters, onMoves, onLeaves, onEmote);
+    }
+
+    public static async create(
+        roomUrl: string,
+        connectCallback: ConnectCallback,
+        disconnectCallback: DisconnectCallback,
+        minDistance: number,
+        groupRadius: number,
+        onEnters: EntersCallback,
+        onMoves: MovesCallback,
+        onLeaves: LeavesCallback,
+        onEmote: EmoteCallback
+    ): Promise<GameRoom> {
+        const mapDetails = await GameRoom.getMapDetails(roomUrl);
+
+        const gameRoom = new GameRoom(
+            roomUrl,
+            mapDetails.mapUrl,
+            connectCallback,
+            disconnectCallback,
+            minDistance,
+            groupRadius,
+            onEnters,
+            onMoves,
+            onLeaves,
+            onEmote
+        );
+
+        return gameRoom;
     }
 
     public getGroups(): Group[] {
@@ -85,18 +99,31 @@ export class GameRoom {
         return this.users;
     }
 
-    public getUserByUuid(uuid: string): User|undefined {
+    public getUserByUuid(uuid: string): User | undefined {
         return this.usersByUuid.get(uuid);
     }
+    public getUserById(id: number): User | undefined {
+        return this.users.get(id);
+    }
+    public getUsersByUuid(uuid: string): User[] {
+        const userList: User[] = [];
+        for (const user of this.users.values()) {
+            if (user.uuid === uuid) {
+                userList.push(user);
+            }
+        }
+        return userList;
+    }
 
-    public join(socket : UserSocket, joinRoomMessage: JoinRoomMessage): User {
+    public join(socket: UserSocket, joinRoomMessage: JoinRoomMessage): User {
         const positionMessage = joinRoomMessage.getPositionmessage();
         if (positionMessage === undefined) {
-            throw new Error('Missing position message');
+            throw new Error("Missing position message");
         }
         const position = ProtobufUtils.toPointInterface(positionMessage);
 
-        const user = new User(this.nextUserId,
+        const user = new User(
+            this.nextUserId,
             joinRoomMessage.getUseruuid(),
             joinRoomMessage.getIpaddress(),
             position,
@@ -104,6 +131,7 @@ export class GameRoom {
             this.positionNotifier,
             socket,
             joinRoomMessage.getTagList(),
+            joinRoomMessage.getVisitcardurl(),
             joinRoomMessage.getName(),
             ProtobufUtils.toCharacterLayerObjects(joinRoomMessage.getCharacterlayerList()),
             joinRoomMessage.getCompanion()
@@ -121,12 +149,12 @@ export class GameRoom {
         return user;
     }
 
-    public leave(user : User){
+    public leave(user: User) {
         const userObj = this.users.get(user.id);
         if (userObj === undefined) {
-            console.warn('User ', user.id, 'does not belong to this game room! It should!');
+            console.warn("User ", user.id, "does not belong to this game room! It should!");
         }
-        if (userObj !== undefined && typeof userObj.group !== 'undefined') {
+        if (userObj !== undefined && typeof userObj.group !== "undefined") {
             this.leaveGroup(userObj);
         }
         this.users.delete(user.id);
@@ -138,7 +166,7 @@ export class GameRoom {
 
         // Notify admins
         for (const admin of this.admins) {
-            admin.sendUserLeft(user.uuid/*, user.name, user.IPAddress*/);
+            admin.sendUserLeft(user.uuid /*, user.name, user.IPAddress*/);
         }
     }
 
@@ -146,7 +174,7 @@ export class GameRoom {
         return this.users.size === 0 && this.admins.size === 0;
     }
 
-    public updatePosition(user : User, userPosition: PointInterface): void {
+    public updatePosition(user: User, userPosition: PointInterface): void {
         user.setPosition(userPosition);
 
         this.updateUserGroup(user);
@@ -154,6 +182,7 @@ export class GameRoom {
 
     private updateUserGroup(user: User): void {
         user.group?.updatePosition();
+        user.group?.searchForNearbyUsers();
 
         if (user.silent) {
             return;
@@ -168,22 +197,25 @@ export class GameRoom {
                 return;
             }
 
-            const closestItem: User|Group|null = this.searchClosestAvailableUserOrGroup(user);
+            const closestItem: User | Group | null = this.searchClosestAvailableUserOrGroup(user);
 
             if (closestItem !== null) {
                 if (closestItem instanceof Group) {
                     // Let's join the group!
                     closestItem.join(user);
                 } else {
-                    const closestUser : User = closestItem;
-                    const group: Group = new Group(this.roomId,[
-                        user,
-                        closestUser
-                    ], this.connectCallback, this.disconnectCallback, this.positionNotifier);
+                    const closestUser: User = closestItem;
+                    const group: Group = new Group(
+                        this.roomUrl,
+                        [user, closestUser],
+                        this.groupRadius,
+                        this.connectCallback,
+                        this.disconnectCallback,
+                        this.positionNotifier
+                    );
                     this.groups.add(group);
                 }
             }
-
         } else {
             // If the user is part of a group:
             //  should he leave the group?
@@ -224,7 +256,9 @@ export class GameRoom {
             this.positionNotifier.leave(group);
             group.destroy();
             if (!this.groups.has(group)) {
-                throw new Error("Could not find group "+group.getId()+" referenced by user "+user.id+" in World.");
+                throw new Error(
+                    "Could not find group " + group.getId() + " referenced by user " + user.id + " in World."
+                );
             }
             this.groups.delete(group);
             //todo: is the group garbage collected?
@@ -242,16 +276,15 @@ export class GameRoom {
      * OR
      * - close enough to a group (distance <= groupRadius)
      */
-    private searchClosestAvailableUserOrGroup(user: User): User|Group|null
-    {
+    private searchClosestAvailableUserOrGroup(user: User): User | Group | null {
         let minimumDistanceFound: number = Math.max(this.minDistance, this.groupRadius);
         let matchingItem: User | Group | null = null;
         this.users.forEach((currentUser, userId) => {
             // Let's only check users that are not part of a group
-            if (typeof currentUser.group !== 'undefined') {
+            if (typeof currentUser.group !== "undefined") {
                 return;
             }
-            if(currentUser === user) {
+            if (currentUser === user) {
                 return;
             }
             if (currentUser.silent) {
@@ -260,7 +293,7 @@ export class GameRoom {
 
             const distance = GameRoom.computeDistance(user, currentUser); // compute distance between peers.
 
-            if(distance <= minimumDistanceFound && distance <= this.minDistance) {
+            if (distance <= minimumDistanceFound && distance <= this.minDistance) {
                 minimumDistanceFound = distance;
                 matchingItem = currentUser;
             }
@@ -271,7 +304,7 @@ export class GameRoom {
                 return;
             }
             const distance = GameRoom.computeDistanceBetweenPositions(user.getPosition(), group.getPosition());
-            if(distance <= minimumDistanceFound && distance <= this.groupRadius) {
+            if (distance <= minimumDistanceFound && distance <= this.groupRadius) {
                 minimumDistanceFound = distance;
                 matchingItem = group;
             }
@@ -280,15 +313,15 @@ export class GameRoom {
         return matchingItem;
     }
 
-    public static computeDistance(user1: User, user2: User): number
-    {
+    public static computeDistance(user1: User, user2: User): number {
         const user1Position = user1.getPosition();
         const user2Position = user2.getPosition();
-        return Math.sqrt(Math.pow(user2Position.x - user1Position.x, 2) + Math.pow(user2Position.y - user1Position.y, 2));
+        return Math.sqrt(
+            Math.pow(user2Position.x - user1Position.x, 2) + Math.pow(user2Position.y - user1Position.y, 2)
+        );
     }
 
-    public static computeDistanceBetweenPositions(position1: PositionInterface, position2: PositionInterface): number
-    {
+    public static computeDistanceBetweenPositions(position1: PositionInterface, position2: PositionInterface): number {
         return Math.sqrt(Math.pow(position2.x - position1.x, 2) + Math.pow(position2.y - position1.y, 2));
     }
 
@@ -300,6 +333,69 @@ export class GameRoom {
         return this.itemsState;
     }
 
+    public async setVariable(name: string, value: string, user: User): Promise<void> {
+        // First, let's check if "user" is allowed to modify the variable.
+        const variableManager = await this.getVariableManager();
+
+        try {
+            const readableBy = variableManager.setVariable(name, value, user);
+
+            // If the variable was not changed, let's not dispatch anything.
+            if (readableBy === false) {
+                return;
+            }
+
+            // TODO: should we batch those every 100ms?
+            const variableMessage = new VariableWithTagMessage();
+            variableMessage.setName(name);
+            variableMessage.setValue(value);
+            if (readableBy) {
+                variableMessage.setReadableby(readableBy);
+            }
+
+            const subMessage = new SubToPusherRoomMessage();
+            subMessage.setVariablemessage(variableMessage);
+
+            const batchMessage = new BatchToPusherRoomMessage();
+            batchMessage.addPayload(subMessage);
+
+            // Dispatch the message on the room listeners
+            for (const socket of this.roomListeners) {
+                socket.write(batchMessage);
+            }
+        } catch (e) {
+            if (e instanceof VariableError) {
+                // Ok, we have an error setting a variable. Either the user is trying to hack the map... or the map
+                // is not up to date. So let's try to reload the map from scratch.
+                if (this.variableManagerLastLoad === undefined) {
+                    throw e;
+                }
+                const lastLoaded = new Date().getTime() - this.variableManagerLastLoad.getTime();
+                if (lastLoaded < 10000) {
+                    console.log(
+                        'An error occurred while setting the "' +
+                            name +
+                            "\" variable. But we tried to reload the map less than 10 seconds ago, so let's fail."
+                    );
+                    // Do not try to reload if we tried to reload less than 10 seconds ago.
+                    throw e;
+                }
+
+                // Reset the variable manager
+                this.variableManagerPromise = undefined;
+                this.mapPromise = undefined;
+
+                console.log(
+                    'An error occurred while setting the "' + name + "\" variable. Let's reload the map and try again"
+                );
+                // Try to set the variable again!
+                await this.setVariable(name, value, user);
+            } else {
+                throw e;
+            }
+        }
+    }
+
     public addZoneListener(call: ZoneSocket, x: number, y: number): Set<Movable> {
         return this.positionNotifier.addZoneListener(call, x, y);
     }
@@ -320,9 +416,124 @@ export class GameRoom {
     public adminLeave(admin: Admin): void {
         this.admins.delete(admin);
     }
-    
+
     public incrementVersion(): number {
-        this.versionNumber++
+        this.versionNumber++;
         return this.versionNumber;
     }
+
+    public emitEmoteEvent(user: User, emoteEventMessage: EmoteEventMessage) {
+        this.positionNotifier.emitEmoteEvent(user, emoteEventMessage);
+    }
+
+    public addRoomListener(socket: RoomSocket) {
+        this.roomListeners.add(socket);
+    }
+
+    public removeRoomListener(socket: RoomSocket) {
+        this.roomListeners.delete(socket);
+    }
+
+    /**
+     * Connects to the admin server to fetch map details.
+     * If there is no admin server, the map details are generated by analysing the map URL (that must be in the form: /_/instance/map_url)
+     */
+    private static async getMapDetails(roomUrl: string): Promise<MapDetailsData> {
+        if (!ADMIN_API_URL) {
+            const roomUrlObj = new URL(roomUrl);
+
+            const match = /\/_\/[^/]+\/(.+)/.exec(roomUrlObj.pathname);
+            if (!match) {
+                console.error("Unexpected room URL", roomUrl);
+                throw new Error('Unexpected room URL "' + roomUrl + '"');
+            }
+
+            const mapUrl = roomUrlObj.protocol + "//" + match[1];
+
+            return {
+                mapUrl,
+                policy_type: 1,
+                textures: [],
+                tags: [],
+            };
+        }
+
+        const result = await adminApi.fetchMapDetails(roomUrl);
+        if (!isMapDetailsData(result)) {
+            console.error("Unexpected room details received from server", result);
+            throw new Error("Unexpected room details received from server");
+        }
+        return result;
+    }
+
+    private mapPromise: Promise<ITiledMap> | undefined;
+
+    /**
+     * Returns a promise to the map file.
+     * @throws LocalUrlError if the map we are trying to load is hosted on a local network
+     * @throws Error
+     */
+    private getMap(): Promise<ITiledMap> {
+        if (!this.mapPromise) {
+            this.mapPromise = mapFetcher.fetchMap(this.mapUrl);
+        }
+
+        return this.mapPromise;
+    }
+
+    private variableManagerPromise: Promise<VariablesManager> | undefined;
+    private variableManagerLastLoad: Date | undefined;
+
+    private getVariableManager(): Promise<VariablesManager> {
+        if (!this.variableManagerPromise) {
+            this.variableManagerLastLoad = new Date();
+            this.variableManagerPromise = this.getMap()
+                .then((map) => {
+                    const variablesManager = new VariablesManager(this.roomUrl, map);
+                    return variablesManager.init();
+                })
+                .catch((e) => {
+                    if (e instanceof LocalUrlError) {
+                        // If we are trying to load a local URL, we are probably in test mode.
+                        // In this case, let's bypass the server-side checks completely.
+
+                        // Note: we run this message inside a setTimeout so that the room listeners can have time to connect.
+                        setTimeout(() => {
+                            for (const roomListener of this.roomListeners) {
+                                emitErrorOnRoomSocket(
+                                    roomListener,
+                                    "You are loading a local map. If you use the scripting API in this map, please be aware that server-side checks and variable persistence is disabled."
+                                );
+                            }
+                        }, 1000);
+
+                        const variablesManager = new VariablesManager(this.roomUrl, null);
+                        return variablesManager.init();
+                    } else {
+                        // An error occurred while loading the map
+                        // Right now, let's bypass the error. In the future, we should make sure the user is aware of that
+                        // and that he/she will act on it to fix the problem.
+
+                        // Note: we run this message inside a setTimeout so that the room listeners can have time to connect.
+                        setTimeout(() => {
+                            for (const roomListener of this.roomListeners) {
+                                emitErrorOnRoomSocket(
+                                    roomListener,
+                                    "Your map does not seem accessible from the WorkAdventure servers. Is it behind a firewall or a proxy? Your map should be accessible from the WorkAdventure servers. If you use the scripting API in this map, please be aware that server-side checks and variable persistence is disabled."
+                                );
+                            }
+                        }, 1000);
+
+                        const variablesManager = new VariablesManager(this.roomUrl, null);
+                        return variablesManager.init();
+                    }
+                });
+        }
+        return this.variableManagerPromise;
+    }
+
+    public async getVariablesForTags(tags: string[]): Promise<Map<string, string>> {
+        const variablesManager = await this.getVariableManager();
+        return variablesManager.getVariablesForTags(tags);
+    }
 }

back/src/Model/Group.ts

@@ -1,36 +1,34 @@
-import { ConnectCallback, DisconnectCallback } from "./GameRoom";
+import { ConnectCallback, DisconnectCallback, GameRoom } from "./GameRoom";
 import { User } from "./User";
-import {PositionInterface} from "_Model/PositionInterface";
-import {Movable} from "_Model/Movable";
-import {PositionNotifier} from "_Model/PositionNotifier";
-import {gaugeManager} from "../Services/GaugeManager";
-import {MAX_PER_GROUP} from "../Enum/EnvironmentVariable";
+import { PositionInterface } from "_Model/PositionInterface";
+import { Movable } from "_Model/Movable";
+import { PositionNotifier } from "_Model/PositionNotifier";
+import { MAX_PER_GROUP } from "../Enum/EnvironmentVariable";
+import type { Zone } from "../Model/Zone";
 
 export class Group implements Movable {
-
     private static nextId: number = 1;
 
     private id: number;
     private users: Set<User>;
     private x!: number;
     private y!: number;
-    private hasEditedGauge: boolean = false;
     private wasDestroyed: boolean = false;
     private roomId: string;
+    private currentZone: Zone | null = null;
 
-
-    constructor(roomId: string, users: User[], private connectCallback: ConnectCallback, private disconnectCallback: DisconnectCallback, private positionNotifier: PositionNotifier) {
+    constructor(
+        roomId: string,
+        users: User[],
+        private groupRadius: number,
+        private connectCallback: ConnectCallback,
+        private disconnectCallback: DisconnectCallback,
+        private positionNotifier: PositionNotifier
+    ) {
         this.roomId = roomId;
         this.users = new Set<User>();
         this.id = Group.nextId;
         Group.nextId++;
-        //we only send a event for prometheus metrics if the group lives more than 5 seconds
-        setTimeout(() => {
-            if (!this.wasDestroyed) {
-                this.hasEditedGauge = true;
-                gaugeManager.incNbGroupsPerRoomGauge(roomId);
-            }
-        }, 5000);
 
         users.forEach((user: User) => {
             this.join(user);
@@ -43,7 +41,7 @@ export class Group implements Movable {
         return Array.from(this.users.values());
     }
 
-    getId() : number {
+    getId(): number {
         return this.id;
     }
 
@@ -53,7 +51,7 @@ export class Group implements Movable {
     getPosition(): PositionInterface {
         return {
             x: this.x,
-            y: this.y
+            y: this.y,
         };
     }
 
@@ -81,9 +79,22 @@ export class Group implements Movable {
         this.y = y;
 
         if (oldX === undefined) {
-            this.positionNotifier.enter(this);
+            this.currentZone = this.positionNotifier.enter(this);
         } else {
-            this.positionNotifier.updatePosition(this, {x, y}, {x: oldX, y: oldY});
+            this.currentZone = this.positionNotifier.updatePosition(this, { x, y }, { x: oldX, y: oldY });
+        }
+    }
+
+    searchForNearbyUsers(): void {
+        if (!this.currentZone) return;
+
+        for (const user of this.positionNotifier.getAllUsersInSquareAroundZone(this.currentZone)) {
+            if (user.group || this.isFull()) return; //we ignore users that are already in a group.
+            const distance = GameRoom.computeDistanceBetweenPositions(user.getPosition(), this.getPosition());
+            if (distance < this.groupRadius) {
+                this.join(user);
+                this.updatePosition();
+            }
         }
     }
 
@@ -95,19 +106,17 @@ export class Group implements Movable {
         return this.users.size <= 1;
     }
 
-    join(user: User): void
-    {
+    join(user: User): void {
         // Broadcast on the right event
         this.connectCallback(user, this);
         this.users.add(user);
         user.group = this;
     }
 
-    leave(user: User): void
-    {
+    leave(user: User): void {
         const success = this.users.delete(user);
         if (success === false) {
-            throw new Error("Could not find user "+user.id+" in the group "+this.id);
+            throw new Error("Could not find user " + user.id + " in the group " + this.id);
         }
         user.group = undefined;
 
@@ -123,16 +132,14 @@ export class Group implements Movable {
      * Let's kick everybody out.
      * Usually used when there is only one user left.
      */
-    destroy(): void
-    {
-        if (this.hasEditedGauge) gaugeManager.decNbGroupsPerRoomGauge(this.roomId);
+    destroy(): void {
         for (const user of this.users) {
             this.leave(user);
         }
         this.wasDestroyed = true;
     }
 
-    get getSize(){
+    get getSize() {
         return this.users.size;
     }
 }

back/src/Model/Movable.ts

@@ -1,8 +1,8 @@
-import {PositionInterface} from "_Model/PositionInterface";
+import { PositionInterface } from "_Model/PositionInterface";
 
 /**
  * A physical object that can be placed into a Zone
  */
 export interface Movable {
-    getPosition(): PositionInterface
+    getPosition(): PositionInterface;
 }

back/src/Model/PositionInterface.ts

@@ -1,4 +1,4 @@
 export interface PositionInterface {
-    x: number,
-    y: number
+    x: number;
+    y: number;
 }

back/src/Model/PositionNotifier.ts

@@ -8,40 +8,59 @@
  * The PositionNotifier is important for performance. It allows us to send the position of players only to a restricted
  * number of players around the current player.
  */
-import {EntersCallback, LeavesCallback, MovesCallback, Zone} from "./Zone";
-import {Movable} from "_Model/Movable";
-import {PositionInterface} from "_Model/PositionInterface";
-import {ZoneSocket} from "../RoomManager";
+import { EmoteCallback, EntersCallback, LeavesCallback, MovesCallback, Zone } from "./Zone";
+import { Movable } from "_Model/Movable";
+import { PositionInterface } from "_Model/PositionInterface";
+import { ZoneSocket } from "../RoomManager";
+import { User } from "../Model/User";
+import { EmoteEventMessage } from "../Messages/generated/messages_pb";
 
 interface ZoneDescriptor {
     i: number;
     j: number;
 }
 
-export class PositionNotifier {
+export function* getNearbyDescriptorsMatrix(middleZoneDescriptor: ZoneDescriptor): Generator<ZoneDescriptor> {
+    for (let n = 0; n < 9; n++) {
+        const i = middleZoneDescriptor.i + ((n % 3) - 1);
+        const j = middleZoneDescriptor.j + (Math.floor(n / 3) - 1);
 
-    // TODO: we need a way to clean the zones if noone is in the zone and noone listening (to free memory!)
+        if (i >= 0 && j >= 0) {
+            yield { i, j };
+        }
+    }
+}
+
+export class PositionNotifier {
+    // TODO: we need a way to clean the zones if no one is in the zone and no one listening (to free memory!)
 
     private zones: Zone[][] = [];
 
-    constructor(private zoneWidth: number, private zoneHeight: number, private onUserEnters: EntersCallback, private onUserMoves: MovesCallback, private onUserLeaves: LeavesCallback) {
-    }
+    constructor(
+        private zoneWidth: number,
+        private zoneHeight: number,
+        private onUserEnters: EntersCallback,
+        private onUserMoves: MovesCallback,
+        private onUserLeaves: LeavesCallback,
+        private onEmote: EmoteCallback
+    ) {}
 
     private getZoneDescriptorFromCoordinates(x: number, y: number): ZoneDescriptor {
         return {
             i: Math.floor(x / this.zoneWidth),
             j: Math.floor(y / this.zoneHeight),
-        }
+        };
     }
 
-    public enter(thing: Movable): void {
+    public enter(thing: Movable): Zone {
         const position = thing.getPosition();
         const zoneDesc = this.getZoneDescriptorFromCoordinates(position.x, position.y);
         const zone = this.getZone(zoneDesc.i, zoneDesc.j);
         zone.enter(thing, null, position);
+        return zone;
     }
 
-    public updatePosition(thing: Movable, newPosition: PositionInterface, oldPosition: PositionInterface): void {
+    public updatePosition(thing: Movable, newPosition: PositionInterface, oldPosition: PositionInterface): Zone {
         // Did we change zone?
         const oldZoneDesc = this.getZoneDescriptorFromCoordinates(oldPosition.x, oldPosition.y);
         const newZoneDesc = this.getZoneDescriptorFromCoordinates(newPosition.x, newPosition.y);
@@ -55,9 +74,11 @@ export class PositionNotifier {
 
             // Enter new zone
             newZone.enter(thing, oldZone, newPosition);
+            return newZone;
         } else {
             const zone = this.getZone(oldZoneDesc.i, oldZoneDesc.j);
             zone.move(thing, newPosition);
+            return zone;
         }
     }
 
@@ -77,7 +98,7 @@ export class PositionNotifier {
 
         let zone = this.zones[j][i];
         if (zone === undefined) {
-            zone = new Zone(this.onUserEnters, this.onUserMoves, this.onUserLeaves, i, j);
+            zone = new Zone(this.onUserEnters, this.onUserMoves, this.onUserLeaves, this.onEmote, i, j);
             this.zones[j][i] = zone;
         }
         return zone;
@@ -93,4 +114,22 @@ export class PositionNotifier {
         const zone = this.getZone(x, y);
         zone.removeListener(call);
     }
+
+    public emitEmoteEvent(user: User, emoteEventMessage: EmoteEventMessage) {
+        const zoneDesc = this.getZoneDescriptorFromCoordinates(user.getPosition().x, user.getPosition().y);
+        const zone = this.getZone(zoneDesc.i, zoneDesc.j);
+        zone.emitEmoteEvent(emoteEventMessage);
+    }
+
+    public *getAllUsersInSquareAroundZone(zone: Zone): Generator<User> {
+        const zoneDescriptor = this.getZoneDescriptorFromCoordinates(zone.x, zone.y);
+        for (const d of getNearbyDescriptorsMatrix(zoneDescriptor)) {
+            const zone = this.getZone(d.i, d.j);
+            for (const thing of zone.getThings()) {
+                if (thing instanceof User) {
+                    yield thing;
+                }
+            }
+        }
+    }
 }

back/src/Model/RoomIdentifier.ts

@@ -1,30 +0,0 @@
-//helper functions to parse room IDs
-
-export const isRoomAnonymous = (roomID: string): boolean => {
-    if (roomID.startsWith('_/')) {
-        return true;
-    } else if(roomID.startsWith('@/')) {
-        return false;
-    } else {
-        throw new Error('Incorrect room ID: '+roomID);
-    }
-}
-
-export const extractRoomSlugPublicRoomId = (roomId: string): string => {
-    const idParts = roomId.split('/');
-    if (idParts.length < 3) throw new Error('Incorrect roomId: '+roomId);
-    return idParts.slice(2).join('/');
-}
-export interface extractDataFromPrivateRoomIdResponse {
-    organizationSlug: string;
-    worldSlug: string;
-    roomSlug: string;
-}
-export const extractDataFromPrivateRoomId = (roomId: string): extractDataFromPrivateRoomIdResponse => {
-    const idParts = roomId.split('/');
-    if (idParts.length < 4) throw new Error('Incorrect roomId: '+roomId);
-    const organizationSlug = idParts[1];
-    const worldSlug = idParts[2];
-    const roomSlug = idParts[3];
-    return {organizationSlug, worldSlug, roomSlug}
-}

back/src/Model/User.ts

@@ -1,11 +1,17 @@
 import { Group } from "./Group";
 import { PointInterface } from "./Websocket/PointInterface";
-import {Zone} from "_Model/Zone";
-import {Movable} from "_Model/Movable";
-import {PositionNotifier} from "_Model/PositionNotifier";
-import {ServerDuplexStream} from "grpc";
-import {BatchMessage, CompanionMessage, PusherToBackMessage, ServerToClientMessage, SubMessage} from "../Messages/generated/messages_pb";
-import {CharacterLayer} from "_Model/Websocket/CharacterLayer";
+import { Zone } from "_Model/Zone";
+import { Movable } from "_Model/Movable";
+import { PositionNotifier } from "_Model/PositionNotifier";
+import { ServerDuplexStream } from "grpc";
+import {
+    BatchMessage,
+    CompanionMessage,
+    PusherToBackMessage,
+    ServerToClientMessage,
+    SubMessage,
+} from "../Messages/generated/messages_pb";
+import { CharacterLayer } from "_Model/Websocket/CharacterLayer";
 
 export type UserSocket = ServerDuplexStream<PusherToBackMessage, ServerToClientMessage>;
 
@@ -22,6 +28,7 @@ export class User implements Movable {
         private positionNotifier: PositionNotifier,
         public readonly socket: UserSocket,
         public readonly tags: string[],
+        public readonly visitCardUrl: string | null,
         public readonly name: string,
         public readonly characterLayers: CharacterLayer[],
         public readonly companion?: CompanionMessage
@@ -41,9 +48,8 @@ export class User implements Movable {
         this.positionNotifier.updatePosition(this, position, oldPosition);
     }
 
-
     private batchedMessages: BatchMessage = new BatchMessage();
-    private batchTimeout: NodeJS.Timeout|null = null;
+    private batchTimeout: NodeJS.Timeout | null = null;
 
     public emitInBatch(payload: SubMessage): void {
         this.batchedMessages.addPayload(payload);

back/src/Model/Websocket/CharacterLayer.ts

@@ -1,4 +1,4 @@
 export interface CharacterLayer {
-    name: string,
-    url: string|undefined
+    name: string;
+    url: string | undefined;
 }

back/src/Model/Websocket/ItemEventMessage.ts

@@ -1,10 +1,11 @@
 import * as tg from "generic-type-guard";
 
-export const isItemEventMessageInterface =
-    new tg.IsInterface().withProperties({
+export const isItemEventMessageInterface = new tg.IsInterface()
+    .withProperties({
         itemId: tg.isNumber,
         event: tg.isString,
         state: tg.isUnknown,
         parameters: tg.isUnknown,
-    }).get();
+    })
+    .get();
 export type ItemEventMessageInterface = tg.GuardedType<typeof isItemEventMessageInterface>;

back/src/Model/Websocket/MessageUserPosition.ts

@@ -1,7 +1,10 @@
-import {PointInterface} from "./PointInterface";
+import { PointInterface } from "./PointInterface";
 
-export class Point implements PointInterface{
-    constructor(public x : number, public y : number, public direction : string = "none", public moving : boolean = false) {
-    }
+export class Point implements PointInterface {
+    constructor(
+        public x: number,
+        public y: number,
+        public direction: string = "none",
+        public moving: boolean = false
+    ) {}
 }
-

back/src/Model/Websocket/PointInterface.ts

@@ -7,11 +7,12 @@ import * as tg from "generic-type-guard";
     readonly moving: boolean;
 }*/
 
-export const isPointInterface =
-    new tg.IsInterface().withProperties({
+export const isPointInterface = new tg.IsInterface()
+    .withProperties({
         x: tg.isNumber,
         y: tg.isNumber,
         direction: tg.isString,
-        moving: tg.isBoolean
-    }).get();
+        moving: tg.isBoolean,
+    })
+    .get();
 export type PointInterface = tg.GuardedType<typeof isPointInterface>;

back/src/Model/Websocket/ProtobufUtils.ts

@@ -1,34 +1,33 @@
-import {PointInterface} from "./PointInterface";
+import { PointInterface } from "./PointInterface";
 import {
     CharacterLayerMessage,
     ItemEventMessage,
     PointMessage,
-    PositionMessage
+    PositionMessage,
 } from "../../Messages/generated/messages_pb";
-import {CharacterLayer} from "_Model/Websocket/CharacterLayer";
+import { CharacterLayer } from "_Model/Websocket/CharacterLayer";
 import Direction = PositionMessage.Direction;
-import {ItemEventMessageInterface} from "_Model/Websocket/ItemEventMessage";
-import {PositionInterface} from "_Model/PositionInterface";
+import { ItemEventMessageInterface } from "_Model/Websocket/ItemEventMessage";
+import { PositionInterface } from "_Model/PositionInterface";
 
 export class ProtobufUtils {
-
     public static toPositionMessage(point: PointInterface): PositionMessage {
         let direction: Direction;
         switch (point.direction) {
-            case 'up':
+            case "up":
                 direction = Direction.UP;
                 break;
-            case 'down':
+            case "down":
                 direction = Direction.DOWN;
                 break;
-            case 'left':
+            case "left":
                 direction = Direction.LEFT;
                 break;
-            case 'right':
+            case "right":
                 direction = Direction.RIGHT;
                 break;
             default:
-                throw new Error('unexpected direction');
+                throw new Error("unexpected direction");
         }
 
         const position = new PositionMessage();
@@ -44,16 +43,16 @@ export class ProtobufUtils {
         let direction: string;
         switch (position.getDirection()) {
             case Direction.UP:
-                direction = 'up';
+                direction = "up";
                 break;
             case Direction.DOWN:
-                direction = 'down';
+                direction = "down";
                 break;
             case Direction.LEFT:
-                direction = 'left';
+                direction = "left";
                 break;
             case Direction.RIGHT:
-                direction = 'right';
+                direction = "right";
                 break;
             default:
                 throw new Error("Unexpected direction");
@@ -82,7 +81,7 @@ export class ProtobufUtils {
             event: itemEventMessage.getEvent(),
             parameters: JSON.parse(itemEventMessage.getParametersjson()),
             state: JSON.parse(itemEventMessage.getStatejson()),
-        }
+        };
     }
 
     public static toItemEventProtobuf(itemEvent: ItemEventMessageInterface): ItemEventMessage {
@@ -96,7 +95,7 @@ export class ProtobufUtils {
     }
 
     public static toCharacterLayerMessages(characterLayers: CharacterLayer[]): CharacterLayerMessage[] {
-        return characterLayers.map(function(characterLayer): CharacterLayerMessage {
+        return characterLayers.map(function (characterLayer): CharacterLayerMessage {
             const message = new CharacterLayerMessage();
             message.setName(characterLayer.name);
             if (characterLayer.url) {
@@ -107,7 +106,7 @@ export class ProtobufUtils {
     }
 
     public static toCharacterLayerObjects(characterLayers: CharacterLayerMessage[]): CharacterLayer[] {
-        return characterLayers.map(function(characterLayer): CharacterLayer {
+        return characterLayers.map(function (characterLayer): CharacterLayer {
             const url = characterLayer.getUrl();
             return {
                 name: characterLayer.getName(),

back/src/Model/Zone.ts

@@ -1,37 +1,52 @@
-import {User} from "./User";
-import {PositionInterface} from "_Model/PositionInterface";
-import {Movable} from "./Movable";
-import {Group} from "./Group";
-import {ZoneSocket} from "../RoomManager";
+import { User } from "./User";
+import { PositionInterface } from "_Model/PositionInterface";
+import { Movable } from "./Movable";
+import { Group } from "./Group";
+import { ZoneSocket } from "../RoomManager";
+import { EmoteEventMessage } from "../Messages/generated/messages_pb";
 
-export type EntersCallback = (thing: Movable, fromZone: Zone|null, listener: ZoneSocket) => void;
+export type EntersCallback = (thing: Movable, fromZone: Zone | null, listener: ZoneSocket) => void;
 export type MovesCallback = (thing: Movable, position: PositionInterface, listener: ZoneSocket) => void;
-export type LeavesCallback = (thing: Movable, newZone: Zone|null, listener: ZoneSocket) => void;
+export type LeavesCallback = (thing: Movable, newZone: Zone | null, listener: ZoneSocket) => void;
+export type EmoteCallback = (emoteEventMessage: EmoteEventMessage, listener: ZoneSocket) => void;
 
 export class Zone {
     private things: Set<Movable> = new Set<Movable>();
     private listeners: Set<ZoneSocket> = new Set<ZoneSocket>();
 
-    /**
-     * @param x For debugging purpose only
-     * @param y For debugging purpose only
-     */
-    constructor(private onEnters: EntersCallback, private onMoves: MovesCallback, private onLeaves: LeavesCallback, public readonly x: number, public readonly y: number) {
-    }
+    constructor(
+        private onEnters: EntersCallback,
+        private onMoves: MovesCallback,
+        private onLeaves: LeavesCallback,
+        private onEmote: EmoteCallback,
+        public readonly x: number,
+        public readonly y: number
+    ) {}
 
     /**
      * A user/thing leaves the zone
      */
-    public leave(thing: Movable, newZone: Zone|null) {
+    public leave(thing: Movable, newZone: Zone | null) {
         const result = this.things.delete(thing);
         if (!result) {
             if (thing instanceof User) {
-                throw new Error('Could not find user in zone '+thing.id);
+                throw new Error("Could not find user in zone " + thing.id);
             }
             if (thing instanceof Group) {
-                throw new Error('Could not find group '+thing.getId()+' in zone ('+this.x+','+this.y+'). Position of group: ('+thing.getPosition().x+','+thing.getPosition().y+')');
+                throw new Error(
+                    "Could not find group " +
+                        thing.getId() +
+                        " in zone (" +
+                        this.x +
+                        "," +
+                        this.y +
+                        "). Position of group: (" +
+                        thing.getPosition().x +
+                        "," +
+                        thing.getPosition().y +
+                        ")"
+                );
             }
-
         }
         this.notifyLeft(thing, newZone);
     }
@@ -39,15 +54,13 @@ export class Zone {
     /**
      * Notify listeners of this zone that this user/thing left
      */
-    private notifyLeft(thing: Movable, newZone: Zone|null) {
+    private notifyLeft(thing: Movable, newZone: Zone | null) {
         for (const listener of this.listeners) {
-            //if (listener !== thing && (newZone === null || !listener.listenedZones.has(newZone))) {
-                this.onLeaves(thing, newZone, listener);
-            //}
+            this.onLeaves(thing, newZone, listener);
         }
     }
 
-    public enter(thing: Movable, oldZone: Zone|null, position: PositionInterface) {
+    public enter(thing: Movable, oldZone: Zone | null, position: PositionInterface) {
         this.things.add(thing);
         this.notifyEnter(thing, oldZone, position);
     }
@@ -55,22 +68,12 @@ export class Zone {
     /**
      * Notify listeners of this zone that this user entered
      */
-    private notifyEnter(thing: Movable, oldZone: Zone|null, position: PositionInterface) {
+    private notifyEnter(thing: Movable, oldZone: Zone | null, position: PositionInterface) {
         for (const listener of this.listeners) {
-
-            /*if (listener === thing) {
-                continue;
-            }
-            if (oldZone === null || !listener.listenedZones.has(oldZone)) {
-                this.onEnters(thing, listener);
-            } else {
-                this.onMoves(thing, position, listener);
-            }*/
             this.onEnters(thing, oldZone, listener);
         }
     }
 
-
     public move(thing: Movable, position: PositionInterface) {
         if (!this.things.has(thing)) {
             this.things.add(thing);
@@ -80,33 +83,11 @@ export class Zone {
 
         for (const listener of this.listeners) {
             //if (listener !== thing) {
-                this.onMoves(thing,position, listener);
+            this.onMoves(thing, position, listener);
             //}
         }
     }
 
-    /*public startListening(listener: User): void {
-        for (const thing of this.things) {
-            if (thing !== listener) {
-                this.onEnters(thing, listener);
-            }
-        }
-
-        this.listeners.add(listener);
-        listener.listenedZones.add(this);
-    }
-
-    public stopListening(listener: User): void {
-        for (const thing of this.things) {
-            if (thing !== listener) {
-                this.onLeaves(thing, listener);
-            }
-        }
-
-        this.listeners.delete(listener);
-        listener.listenedZones.delete(this);
-    }*/
-
     public getThings(): Set<Movable> {
         return this.things;
     }
@@ -119,4 +100,10 @@ export class Zone {
     public removeListener(socket: ZoneSocket): void {
         this.listeners.delete(socket);
     }
+
+    public emitEmoteEvent(emoteEventMessage: EmoteEventMessage) {
+        for (const listener of this.listeners) {
+            this.onEmote(emoteEventMessage, listener);
+        }
+    }
 }

back/src/RoomManager.ts

@@ -1,99 +1,145 @@
-import {IRoomManagerServer} from "./Messages/generated/messages_grpc_pb";
+import { IRoomManagerServer } from "./Messages/generated/messages_grpc_pb";
 import {
     AdminGlobalMessage,
     AdminMessage,
     AdminPusherToBackMessage,
     AdminRoomMessage,
     BanMessage,
+    BatchToPusherMessage,
+    BatchToPusherRoomMessage,
+    EmotePromptMessage,
     EmptyMessage,
     ItemEventMessage,
     JoinRoomMessage,
     PlayGlobalMessage,
     PusherToBackMessage,
-    QueryJitsiJwtMessage, RefreshRoomPromptMessage,
+    QueryJitsiJwtMessage,
+    RefreshRoomPromptMessage,
+    RoomMessage,
     ServerToAdminClientMessage,
-    ServerToClientMessage,
     SilentMessage,
     UserMovesMessage,
-    WebRtcSignalToServerMessage, WorldFullWarningToRoomMessage,
-    ZoneMessage
+    VariableMessage,
+    WebRtcSignalToServerMessage,
+    WorldFullWarningToRoomMessage,
+    ZoneMessage,
 } from "./Messages/generated/messages_pb";
-import {sendUnaryData, ServerDuplexStream, ServerUnaryCall, ServerWritableStream} from "grpc";
-import {socketManager} from "./Services/SocketManager";
-import {emitError} from "./Services/MessageHelpers";
-import {User, UserSocket} from "./Model/User";
-import {GameRoom} from "./Model/GameRoom";
+import { sendUnaryData, ServerDuplexStream, ServerUnaryCall, ServerWritableStream } from "grpc";
+import { socketManager } from "./Services/SocketManager";
+import { emitError, emitErrorOnRoomSocket, emitErrorOnZoneSocket } from "./Services/MessageHelpers";
+import { User, UserSocket } from "./Model/User";
+import { GameRoom } from "./Model/GameRoom";
 import Debug from "debug";
-import {Admin} from "./Model/Admin";
+import { Admin } from "./Model/Admin";
 
-const debug = Debug('roommanager');
+const debug = Debug("roommanager");
 
 export type AdminSocket = ServerDuplexStream<AdminPusherToBackMessage, ServerToAdminClientMessage>;
-export type ZoneSocket = ServerWritableStream<ZoneMessage, ServerToClientMessage>;
+export type ZoneSocket = ServerWritableStream<ZoneMessage, BatchToPusherMessage>;
+export type RoomSocket = ServerWritableStream<RoomMessage, BatchToPusherRoomMessage>;
 
 const roomManager: IRoomManagerServer = {
     joinRoom: (call: UserSocket): void => {
-        console.log('joinRoom called');
+        console.log("joinRoom called");
 
-        let room: GameRoom|null = null;
-        let user: User|null = null;
+        let room: GameRoom | null = null;
+        let user: User | null = null;
 
-        call.on('data', (message: PusherToBackMessage) => {
-            try {
-                if (room === null || user === null) {
-                    if (message.hasJoinroommessage()) {
-                        socketManager.handleJoinRoom(call, message.getJoinroommessage() as JoinRoomMessage).then(({room: gameRoom, user: myUser}) => {
-                            if (call.writable) {
-                                room = gameRoom;
-                                user = myUser;
-                            } else {
-                                //Connexion may have been closed before the init was finished, so we have to manually disconnect the user.
-                                socketManager.leaveRoom(gameRoom, myUser);
+        call.on("data", (message: PusherToBackMessage) => {
+            (async () => {
+                try {
+                    if (room === null || user === null) {
+                        if (message.hasJoinroommessage()) {
+                            socketManager
+                                .handleJoinRoom(call, message.getJoinroommessage() as JoinRoomMessage)
+                                .then(({ room: gameRoom, user: myUser }) => {
+                                    if (call.writable) {
+                                        room = gameRoom;
+                                        user = myUser;
+                                    } else {
+                                        //Connection may have been closed before the init was finished, so we have to manually disconnect the user.
+                                        socketManager.leaveRoom(gameRoom, myUser);
+                                    }
+                                })
+                                .catch((e) => emitError(call, e));
+                        } else {
+                            throw new Error("The first message sent MUST be of type JoinRoomMessage");
+                        }
+                    } else {
+                        if (message.hasJoinroommessage()) {
+                            throw new Error("Cannot call JoinRoomMessage twice!");
+                        } else if (message.hasUsermovesmessage()) {
+                            socketManager.handleUserMovesMessage(
+                                room,
+                                user,
+                                message.getUsermovesmessage() as UserMovesMessage
+                            );
+                        } else if (message.hasSilentmessage()) {
+                            socketManager.handleSilentMessage(room, user, message.getSilentmessage() as SilentMessage);
+                        } else if (message.hasItemeventmessage()) {
+                            socketManager.handleItemEvent(
+                                room,
+                                user,
+                                message.getItemeventmessage() as ItemEventMessage
+                            );
+                        } else if (message.hasVariablemessage()) {
+                            await socketManager.handleVariableEvent(
+                                room,
+                                user,
+                                message.getVariablemessage() as VariableMessage
+                            );
+                        } else if (message.hasWebrtcsignaltoservermessage()) {
+                            socketManager.emitVideo(
+                                room,
+                                user,
+                                message.getWebrtcsignaltoservermessage() as WebRtcSignalToServerMessage
+                            );
+                        } else if (message.hasWebrtcscreensharingsignaltoservermessage()) {
+                            socketManager.emitScreenSharing(
+                                room,
+                                user,
+                                message.getWebrtcscreensharingsignaltoservermessage() as WebRtcSignalToServerMessage
+                            );
+                        } else if (message.hasPlayglobalmessage()) {
+                            socketManager.emitPlayGlobalMessage(
+                                room,
+                                message.getPlayglobalmessage() as PlayGlobalMessage
+                            );
+                        } else if (message.hasQueryjitsijwtmessage()) {
+                            socketManager.handleQueryJitsiJwtMessage(
+                                user,
+                                message.getQueryjitsijwtmessage() as QueryJitsiJwtMessage
+                            );
+                        } else if (message.hasEmotepromptmessage()) {
+                            socketManager.handleEmoteEventMessage(
+                                room,
+                                user,
+                                message.getEmotepromptmessage() as EmotePromptMessage
+                            );
+                        } else if (message.hasSendusermessage()) {
+                            const sendUserMessage = message.getSendusermessage();
+                            if (sendUserMessage !== undefined) {
+                                socketManager.handlerSendUserMessage(user, sendUserMessage);
                             }
-                        });
-                    } else {
-                        throw new Error('The first message sent MUST be of type JoinRoomMessage');
-                    }
-                } else {
-                    if (message.hasJoinroommessage()) {
-                        throw new Error('Cannot call JoinRoomMessage twice!');
-                    } else if (message.hasUsermovesmessage()) {
-                        socketManager.handleUserMovesMessage(room, user, message.getUsermovesmessage() as UserMovesMessage);
-                    } else if (message.hasSilentmessage()) {
-                        socketManager.handleSilentMessage(room, user, message.getSilentmessage() as SilentMessage);
-                    } else if (message.hasItemeventmessage()) {
-                        socketManager.handleItemEvent(room, user, message.getItemeventmessage() as ItemEventMessage);
-                    } else if (message.hasWebrtcsignaltoservermessage()) {
-                        socketManager.emitVideo(room, user, message.getWebrtcsignaltoservermessage() as WebRtcSignalToServerMessage);
-                    } else if (message.hasWebrtcscreensharingsignaltoservermessage()) {
-                        socketManager.emitScreenSharing(room, user, message.getWebrtcscreensharingsignaltoservermessage() as WebRtcSignalToServerMessage);
-                    } else if (message.hasPlayglobalmessage()) {
-                        socketManager.emitPlayGlobalMessage(room, message.getPlayglobalmessage() as PlayGlobalMessage);
-                    } else if (message.hasQueryjitsijwtmessage()){
-                        socketManager.handleQueryJitsiJwtMessage(user, message.getQueryjitsijwtmessage() as QueryJitsiJwtMessage);
-                    }else if (message.hasSendusermessage()) {
-                        const sendUserMessage = message.getSendusermessage();
-                        if(sendUserMessage !== undefined) {
-                            socketManager.handlerSendUserMessage(user, sendUserMessage);
+                        } else if (message.hasBanusermessage()) {
+                            const banUserMessage = message.getBanusermessage();
+                            if (banUserMessage !== undefined) {
+                                socketManager.handlerBanUserMessage(room, user, banUserMessage);
+                            }
+                        } else {
+                            throw new Error("Unhandled message type");
                         }
-                    }else if (message.hasBanusermessage()) {
-                        const banUserMessage = message.getBanusermessage();
-                        if(banUserMessage !== undefined) {
-                            socketManager.handlerBanUserMessage(room, user, banUserMessage);
-                        }
-                    } else {
-                        throw new Error('Unhandled message type');
                     }
+                } catch (e) {
+                    console.error(e);
+                    emitError(call, e);
+                    call.end();
                 }
-            } catch (e) {
-                emitError(call, e);
-                call.end();
-            }
-
+            })().catch((e) => console.error(e));
         });
 
-        call.on('end', () => {
-            debug('joinRoom ended');
+        call.on("end", () => {
+            debug("joinRoom ended");
             if (user !== null && room !== null) {
                 socketManager.leaveRoom(room, user);
             }
@@ -102,61 +148,96 @@ const roomManager: IRoomManagerServer = {
             user = null;
         });
 
-        call.on('error', (err: Error) => {
-            console.error('An error occurred in joinRoom stream:', err);
+        call.on("error", (err: Error) => {
+            console.error("An error occurred in joinRoom stream:", err);
         });
-
     },
 
     listenZone(call: ZoneSocket): void {
-        debug('listenZone called');
+        debug("listenZone called");
         const zoneMessage = call.request;
 
-        socketManager.addZoneListener(call, zoneMessage.getRoomid(), zoneMessage.getX(), zoneMessage.getY());
+        socketManager
+            .addZoneListener(call, zoneMessage.getRoomid(), zoneMessage.getX(), zoneMessage.getY())
+            .catch((e) => {
+                emitErrorOnZoneSocket(call, e.toString());
+            });
 
-        call.on('cancelled', () => {
-            debug('listenZone cancelled');
-            socketManager.removeZoneListener(call, zoneMessage.getRoomid(), zoneMessage.getX(), zoneMessage.getY());
+        call.on("cancelled", () => {
+            debug("listenZone cancelled");
+            socketManager
+                .removeZoneListener(call, zoneMessage.getRoomid(), zoneMessage.getX(), zoneMessage.getY())
+                .catch((e) => console.error(e));
             call.end();
-        })
-        
-        call.on('close', () => {
-            debug('listenZone connection closed');
-            socketManager.removeZoneListener(call, zoneMessage.getRoomid(), zoneMessage.getX(), zoneMessage.getY());
-        }).on('error', (e) => {
-            console.error('An error occurred in listenZone stream:', e);
-            socketManager.removeZoneListener(call, zoneMessage.getRoomid(), zoneMessage.getX(), zoneMessage.getY());
+        });
+
+        call.on("close", () => {
+            debug("listenZone connection closed");
+            socketManager
+                .removeZoneListener(call, zoneMessage.getRoomid(), zoneMessage.getX(), zoneMessage.getY())
+                .catch((e) => console.error(e));
+        }).on("error", (e) => {
+            console.error("An error occurred in listenZone stream:", e);
+            socketManager
+                .removeZoneListener(call, zoneMessage.getRoomid(), zoneMessage.getX(), zoneMessage.getY())
+                .catch((e) => console.error(e));
+            call.end();
+        });
+    },
+
+    listenRoom(call: RoomSocket): void {
+        debug("listenRoom called");
+        const roomMessage = call.request;
+
+        socketManager.addRoomListener(call, roomMessage.getRoomid()).catch((e) => {
+            emitErrorOnRoomSocket(call, e.toString());
+        });
+
+        call.on("cancelled", () => {
+            debug("listenRoom cancelled");
+            socketManager.removeRoomListener(call, roomMessage.getRoomid()).catch((e) => console.error(e));
+            call.end();
+        });
+
+        call.on("close", () => {
+            debug("listenRoom connection closed");
+            socketManager.removeRoomListener(call, roomMessage.getRoomid()).catch((e) => console.error(e));
+        }).on("error", (e) => {
+            console.error("An error occurred in listenRoom stream:", e);
+            socketManager.removeRoomListener(call, roomMessage.getRoomid()).catch((e) => console.error(e));
             call.end();
         });
     },
 
     adminRoom(call: AdminSocket): void {
-        console.log('adminRoom called');
+        console.log("adminRoom called");
 
         const admin = new Admin(call);
-        let room: GameRoom|null = null;
+        let room: GameRoom | null = null;
 
-        call.on('data', (message: AdminPusherToBackMessage) => {
+        call.on("data", (message: AdminPusherToBackMessage) => {
             try {
                 if (room === null) {
                     if (message.hasSubscribetoroom()) {
                         const roomId = message.getSubscribetoroom();
-                        socketManager.handleJoinAdminRoom(admin, roomId).then((gameRoom: GameRoom) => {
-                            room = gameRoom;
-                        });
+                        socketManager
+                            .handleJoinAdminRoom(admin, roomId)
+                            .then((gameRoom: GameRoom) => {
+                                room = gameRoom;
+                            })
+                            .catch((e) => console.error(e));
                     } else {
-                        throw new Error('The first message sent MUST be of type JoinRoomMessage');
+                        throw new Error("The first message sent MUST be of type JoinRoomMessage");
                     }
                 }
             } catch (e) {
                 emitError(call, e);
                 call.end();
             }
-
         });
 
-        call.on('end', () => {
-            debug('joinRoom ended');
+        call.on("end", () => {
+            debug("joinRoom ended");
             if (room !== null) {
                 socketManager.leaveAdminRoom(room, admin);
             }
@@ -164,39 +245,53 @@ const roomManager: IRoomManagerServer = {
             room = null;
         });
 
-        call.on('error', (err: Error) => {
-            console.error('An error occurred in joinAdminRoom stream:', err);
+        call.on("error", (err: Error) => {
+            console.error("An error occurred in joinAdminRoom stream:", err);
         });
     },
     sendAdminMessage(call: ServerUnaryCall<AdminMessage>, callback: sendUnaryData<EmptyMessage>): void {
-
-        socketManager.sendAdminMessage(call.request.getRoomid(), call.request.getRecipientuuid(), call.request.getMessage());
+        socketManager
+            .sendAdminMessage(call.request.getRoomid(), call.request.getRecipientuuid(), call.request.getMessage())
+            .catch((e) => console.error(e));
 
         callback(null, new EmptyMessage());
     },
     sendGlobalAdminMessage(call: ServerUnaryCall<AdminGlobalMessage>, callback: sendUnaryData<EmptyMessage>): void {
-        throw new Error('Not implemented yet');
+        throw new Error("Not implemented yet");
         // TODO
         callback(null, new EmptyMessage());
     },
     ban(call: ServerUnaryCall<BanMessage>, callback: sendUnaryData<EmptyMessage>): void {
         // FIXME Work in progress
-        socketManager.banUser(call.request.getRoomid(), call.request.getRecipientuuid(), call.request.getMessage());
+        socketManager
+            .banUser(call.request.getRoomid(), call.request.getRecipientuuid(), call.request.getMessage())
+            .catch((e) => console.error(e));
 
         callback(null, new EmptyMessage());
     },
     sendAdminMessageToRoom(call: ServerUnaryCall<AdminRoomMessage>, callback: sendUnaryData<EmptyMessage>): void {
-        socketManager.sendAdminRoomMessage(call.request.getRoomid(), call.request.getMessage());
+        // FIXME: we could improve return message by returning a Success|ErrorMessage message
+        socketManager
+            .sendAdminRoomMessage(call.request.getRoomid(), call.request.getMessage(), call.request.getType())
+            .catch((e) => console.error(e));
         callback(null, new EmptyMessage());
     },
-    sendWorldFullWarningToRoom(call: ServerUnaryCall<WorldFullWarningToRoomMessage>, callback: sendUnaryData<EmptyMessage>): void {
-        socketManager.dispatchWorlFullWarning(call.request.getRoomid());
+    sendWorldFullWarningToRoom(
+        call: ServerUnaryCall<WorldFullWarningToRoomMessage>,
+        callback: sendUnaryData<EmptyMessage>
+    ): void {
+        // FIXME: we could improve return message by returning a Success|ErrorMessage message
+        socketManager.dispatchWorldFullWarning(call.request.getRoomid()).catch((e) => console.error(e));
         callback(null, new EmptyMessage());
     },
-    sendRefreshRoomPrompt(call: ServerUnaryCall<RefreshRoomPromptMessage>, callback: sendUnaryData<EmptyMessage>): void {
-        socketManager.dispatchRoomRefresh(call.request.getRoomid());
+    sendRefreshRoomPrompt(
+        call: ServerUnaryCall<RefreshRoomPromptMessage>,
+        callback: sendUnaryData<EmptyMessage>
+    ): void {
+        // FIXME: we could improve return message by returning a Success|ErrorMessage message
+        socketManager.dispatchRoomRefresh(call.request.getRoomid()).catch((e) => console.error(e));
         callback(null, new EmptyMessage());
     },
 };
 
-export {roomManager};
+export { roomManager };

back/src/Server/server/app.ts

@@ -1,13 +1,13 @@
-import { App as _App, AppOptions } from 'uWebSockets.js';
-import BaseApp from './baseapp';
-import { extend } from './utils';
-import { UwsApp } from './types';
+import { App as _App, AppOptions } from "uWebSockets.js";
+import BaseApp from "./baseapp";
+import { extend } from "./utils";
+import { UwsApp } from "./types";
 
 class App extends (<UwsApp>_App) {
-  constructor(options: AppOptions = {}) {
-    super(options); // eslint-disable-line constructor-super
-    extend(this, new BaseApp());
-  }
+    constructor(options: AppOptions = {}) {
+        super(options); // eslint-disable-line constructor-super
+        extend(this, new BaseApp());
+    }
 }
 
 export default App;

back/src/Server/server/baseapp.ts

@@ -1,116 +1,109 @@
-import { Readable } from 'stream';
-import { us_listen_socket_close, TemplatedApp, HttpResponse, HttpRequest } from 'uWebSockets.js';
+import { Readable } from "stream";
+import { us_listen_socket_close, TemplatedApp, HttpResponse, HttpRequest } from "uWebSockets.js";
 
-import formData from './formdata';
-import { stob } from './utils';
-import { Handler } from './types';
-import {join} from "path";
+import formData from "./formdata";
+import { stob } from "./utils";
+import { Handler } from "./types";
+import { join } from "path";
 
-const contTypes = ['application/x-www-form-urlencoded', 'multipart/form-data'];
+const contTypes = ["application/x-www-form-urlencoded", "multipart/form-data"];
 const noOp = () => true;
 
 const handleBody = (res: HttpResponse, req: HttpRequest) => {
-  const contType = req.getHeader('content-type');
+    const contType = req.getHeader("content-type");
 
-  res.bodyStream = function() {
-    const stream = new Readable();
-    stream._read = noOp; // eslint-disable-line @typescript-eslint/unbound-method
+    res.bodyStream = function () {
+        const stream = new Readable();
+        stream._read = noOp; // eslint-disable-line @typescript-eslint/unbound-method
 
-    this.onData((ab: ArrayBuffer, isLast: boolean) => {
-      // uint and then slicing is bit faster than slice and then uint
-      stream.push(new Uint8Array(ab.slice((ab as any).byteOffset, ab.byteLength))); // eslint-disable-line @typescript-eslint/no-explicit-any
-      if (isLast) {
-        stream.push(null);
-      }
-    });
+        this.onData((ab: ArrayBuffer, isLast: boolean) => {
+            // uint and then slicing is bit faster than slice and then uint
+            stream.push(new Uint8Array(ab.slice((ab as any).byteOffset, ab.byteLength))); // eslint-disable-line @typescript-eslint/no-explicit-any
+            if (isLast) {
+                stream.push(null);
+            }
+        });
 
-    return stream;
-  };
+        return stream;
+    };
 
-  res.body = () => stob(res.bodyStream());
+    res.body = () => stob(res.bodyStream());
 
-  if (contType.includes('application/json'))
-    res.json = async () => JSON.parse(await res.body());
-  if (contTypes.map(t => contType.includes(t)).includes(true))
-    res.formData = formData.bind(res, contType);
+    if (contType.includes("application/json")) res.json = async () => JSON.parse(await res.body());
+    if (contTypes.map((t) => contType.includes(t)).includes(true)) res.formData = formData.bind(res, contType);
 };
 
 class BaseApp {
-  _sockets = new Map();
-  ws!: TemplatedApp['ws'];
-  get!: TemplatedApp['get'];
-  _post!: TemplatedApp['post'];
-  _put!: TemplatedApp['put'];
-  _patch!: TemplatedApp['patch'];
-  _listen!: TemplatedApp['listen'];
+    _sockets = new Map();
+    ws!: TemplatedApp["ws"];
+    get!: TemplatedApp["get"];
+    _post!: TemplatedApp["post"];
+    _put!: TemplatedApp["put"];
+    _patch!: TemplatedApp["patch"];
+    _listen!: TemplatedApp["listen"];
 
-  post(pattern: string, handler: Handler) {
-    if (typeof handler !== 'function')
-      throw Error(`handler should be a function, given ${typeof handler}.`);
-    this._post(pattern, (res, req) => {
-      handleBody(res, req);
-      handler(res, req);
-    });
-    return this;
-  }
+    post(pattern: string, handler: Handler) {
+        if (typeof handler !== "function") throw Error(`handler should be a function, given ${typeof handler}.`);
+        this._post(pattern, (res, req) => {
+            handleBody(res, req);
+            handler(res, req);
+        });
+        return this;
+    }
 
-  put(pattern: string, handler: Handler) {
-    if (typeof handler !== 'function')
-      throw Error(`handler should be a function, given ${typeof handler}.`);
-    this._put(pattern, (res, req) => {
-      handleBody(res, req);
+    put(pattern: string, handler: Handler) {
+        if (typeof handler !== "function") throw Error(`handler should be a function, given ${typeof handler}.`);
+        this._put(pattern, (res, req) => {
+            handleBody(res, req);
 
-      handler(res, req);
-    });
-    return this;
-  }
+            handler(res, req);
+        });
+        return this;
+    }
 
-  patch(pattern: string, handler: Handler) {
-    if (typeof handler !== 'function')
-      throw Error(`handler should be a function, given ${typeof handler}.`);
-    this._patch(pattern, (res, req) => {
-      handleBody(res, req);
+    patch(pattern: string, handler: Handler) {
+        if (typeof handler !== "function") throw Error(`handler should be a function, given ${typeof handler}.`);
+        this._patch(pattern, (res, req) => {
+            handleBody(res, req);
 
-      handler(res, req);
-    });
-    return this;
-  }
+            handler(res, req);
+        });
+        return this;
+    }
 
-  listen(h: string | number, p: Function | number = noOp, cb?: Function) {
-    if (typeof p === 'number' && typeof h === 'string') {
-      this._listen(h, p, socket => {
-        this._sockets.set(p, socket);
-        if (cb === undefined) {
-          throw new Error('cb undefined');
+    listen(h: string | number, p: Function | number = noOp, cb?: Function) {
+        if (typeof p === "number" && typeof h === "string") {
+            this._listen(h, p, (socket) => {
+                this._sockets.set(p, socket);
+                if (cb === undefined) {
+                    throw new Error("cb undefined");
+                }
+                cb(socket);
+            });
+        } else if (typeof h === "number" && typeof p === "function") {
+            this._listen(h, (socket) => {
+                this._sockets.set(h, socket);
+                p(socket);
+            });
+        } else {
+            throw Error("Argument types: (host: string, port: number, cb?: Function) | (port: number, cb?: Function)");
         }
-        cb(socket);
-      });
-    } else if (typeof h === 'number' && typeof p === 'function') {
-      this._listen(h, socket => {
-        this._sockets.set(h, socket);
-        p(socket);
-      });
-    } else {
-      throw Error(
-        'Argument types: (host: string, port: number, cb?: Function) | (port: number, cb?: Function)'
-      );
+
+        return this;
     }
 
-    return this;
-  }
-
-  close(port: null | number = null) {
-    if (port) {
-      this._sockets.has(port) && us_listen_socket_close(this._sockets.get(port));
-      this._sockets.delete(port);
-    } else {
-      this._sockets.forEach(app => {
-        us_listen_socket_close(app);
-      });
-      this._sockets.clear();
+    close(port: null | number = null) {
+        if (port) {
+            this._sockets.has(port) && us_listen_socket_close(this._sockets.get(port));
+            this._sockets.delete(port);
+        } else {
+            this._sockets.forEach((app) => {
+                us_listen_socket_close(app);
+            });
+            this._sockets.clear();
+        }
+        return this;
     }
-    return this;
-  }
 }
 
 export default BaseApp;

back/src/Server/server/formdata.ts

@@ -1,100 +1,99 @@
-import { createWriteStream } from 'fs';
-import { join, dirname } from 'path';
-import Busboy from 'busboy';
-import mkdirp from 'mkdirp';
+import { createWriteStream } from "fs";
+import { join, dirname } from "path";
+import Busboy from "busboy";
+import mkdirp from "mkdirp";
 
 function formData(
-  contType: string,
-  options: busboy.BusboyConfig & {
-    abortOnLimit?: boolean;
-    tmpDir?: string;
-    onFile?: (
-      fieldname: string,
-      file: NodeJS.ReadableStream,
-      filename: string,
-      encoding: string,
-      mimetype: string
-    ) => string;
-    onField?: (fieldname: string, value: any) => void; // eslint-disable-line @typescript-eslint/no-explicit-any
-    filename?: (oldName: string) => string;
-  } = {}
+    contType: string,
+    options: busboy.BusboyConfig & {
+        abortOnLimit?: boolean;
+        tmpDir?: string;
+        onFile?: (
+            fieldname: string,
+            file: NodeJS.ReadableStream,
+            filename: string,
+            encoding: string,
+            mimetype: string
+        ) => string;
+        onField?: (fieldname: string, value: any) => void; // eslint-disable-line @typescript-eslint/no-explicit-any
+        filename?: (oldName: string) => string;
+    } = {}
 ) {
-  console.log('Enter form data');
-  options.headers = {
-    'content-type': contType
-  };
+    console.log("Enter form data");
+    options.headers = {
+        "content-type": contType,
+    };
 
-  return new Promise((resolve, reject) => {
-    const busb = new Busboy(options);
-    const ret = {};
+    return new Promise((resolve, reject) => {
+        const busb = new Busboy(options);
+        const ret = {};
 
-    this.bodyStream().pipe(busb);
+        this.bodyStream().pipe(busb);
 
-    busb.on('limit', () => {
-      if (options.abortOnLimit) {
-        reject(Error('limit'));
-      }
+        busb.on("limit", () => {
+            if (options.abortOnLimit) {
+                reject(Error("limit"));
+            }
+        });
+
+        busb.on("file", function (fieldname, file, filename, encoding, mimetype) {
+            const value: { filePath: string | undefined; filename: string; encoding: string; mimetype: string } = {
+                filename,
+                encoding,
+                mimetype,
+                filePath: undefined,
+            };
+
+            if (typeof options.tmpDir === "string") {
+                if (typeof options.filename === "function") filename = options.filename(filename);
+                const fileToSave = join(options.tmpDir, filename);
+                mkdirp(dirname(fileToSave));
+
+                file.pipe(createWriteStream(fileToSave));
+                value.filePath = fileToSave;
+            }
+            if (typeof options.onFile === "function") {
+                value.filePath = options.onFile(fieldname, file, filename, encoding, mimetype) || value.filePath;
+            }
+
+            setRetValue(ret, fieldname, value);
+        });
+
+        busb.on("field", function (fieldname, value) {
+            if (typeof options.onField === "function") options.onField(fieldname, value);
+
+            setRetValue(ret, fieldname, value);
+        });
+
+        busb.on("finish", function () {
+            resolve(ret);
+        });
+
+        busb.on("error", reject);
     });
-
-    busb.on('file', function(fieldname, file, filename, encoding, mimetype) {
-      const value: { filePath: string|undefined, filename: string, encoding:string, mimetype: string } = {
-        filename,
-        encoding,
-        mimetype,
-        filePath: undefined
-      };
-
-      if (typeof options.tmpDir === 'string') {
-        if (typeof options.filename === 'function') filename = options.filename(filename);
-        const fileToSave = join(options.tmpDir, filename);
-        mkdirp(dirname(fileToSave));
-
-        file.pipe(createWriteStream(fileToSave));
-        value.filePath = fileToSave;
-      }
-      if (typeof options.onFile === 'function') {
-        value.filePath =
-          options.onFile(fieldname, file, filename, encoding, mimetype) || value.filePath;
-      }
-
-      setRetValue(ret, fieldname, value);
-    });
-
-    busb.on('field', function(fieldname, value) {
-      if (typeof options.onField === 'function') options.onField(fieldname, value);
-
-      setRetValue(ret, fieldname, value);
-    });
-
-    busb.on('finish', function() {
-      resolve(ret);
-    });
-
-    busb.on('error', reject);
-  });
 }
 
 function setRetValue(
-  ret: { [x: string]: any }, // eslint-disable-line @typescript-eslint/no-explicit-any
-  fieldname: string,
-  value: { filename: string; encoding: string; mimetype: string; filePath?: string } | any // eslint-disable-line @typescript-eslint/no-explicit-any
+    ret: { [x: string]: any }, // eslint-disable-line @typescript-eslint/no-explicit-any
+    fieldname: string,
+    value: { filename: string; encoding: string; mimetype: string; filePath?: string } | any // eslint-disable-line @typescript-eslint/no-explicit-any
 ) {
-  if (fieldname.endsWith('[]')) {
-    fieldname = fieldname.slice(0, fieldname.length - 2);
-    if (Array.isArray(ret[fieldname])) {
-      ret[fieldname].push(value);
+    if (fieldname.endsWith("[]")) {
+        fieldname = fieldname.slice(0, fieldname.length - 2);
+        if (Array.isArray(ret[fieldname])) {
+            ret[fieldname].push(value);
+        } else {
+            ret[fieldname] = [value];
+        }
     } else {
-      ret[fieldname] = [value];
+        if (Array.isArray(ret[fieldname])) {
+            ret[fieldname].push(value);
+        } else if (ret[fieldname]) {
+            ret[fieldname] = [ret[fieldname], value];
+        } else {
+            ret[fieldname] = value;
+        }
     }
-  } else {
-    if (Array.isArray(ret[fieldname])) {
-      ret[fieldname].push(value);
-    } else if (ret[fieldname]) {
-      ret[fieldname] = [ret[fieldname], value];
-    } else {
-      ret[fieldname] = value;
-    }
-  }
 }
 
 export default formData;

back/src/Server/server/sslapp.ts

@@ -1,13 +1,13 @@
-import { SSLApp as _SSLApp, AppOptions } from 'uWebSockets.js';
-import BaseApp from './baseapp';
-import { extend } from './utils';
-import { UwsApp } from './types';
+import { SSLApp as _SSLApp, AppOptions } from "uWebSockets.js";
+import BaseApp from "./baseapp";
+import { extend } from "./utils";
+import { UwsApp } from "./types";
 
 class SSLApp extends (<UwsApp>_SSLApp) {
-  constructor(options: AppOptions) {
-    super(options); // eslint-disable-line constructor-super
-    extend(this, new BaseApp());
-  }
+    constructor(options: AppOptions) {
+        super(options); // eslint-disable-line constructor-super
+        extend(this, new BaseApp());
+    }
 }
 
 export default SSLApp;

back/src/Server/server/types.ts

@@ -1,9 +1,9 @@
-import { AppOptions, TemplatedApp, HttpResponse, HttpRequest } from 'uWebSockets.js';
+import { AppOptions, TemplatedApp, HttpResponse, HttpRequest } from "uWebSockets.js";
 
 export type UwsApp = {
-  (options: AppOptions): TemplatedApp;
-  new (options: AppOptions): TemplatedApp;
-  prototype: TemplatedApp;
+    (options: AppOptions): TemplatedApp;
+    new (options: AppOptions): TemplatedApp;
+    prototype: TemplatedApp;
 };
 
 export type Handler = (res: HttpResponse, req: HttpRequest) => void;

back/src/Server/server/utils.ts

@@ -1,37 +1,36 @@
-import { ReadStream } from 'fs';
+import { ReadStream } from "fs";
 
-function extend(who: any, from: any, overwrite = true) { // eslint-disable-line @typescript-eslint/no-explicit-any
-  const ownProps = Object.getOwnPropertyNames(Object.getPrototypeOf(from)).concat(
-    Object.keys(from)
-  );
-  ownProps.forEach(prop => {
-    if (prop === 'constructor' || from[prop] === undefined) return;
-    if (who[prop] && overwrite) {
-      who[`_${prop}`] = who[prop];
-    }
-    if (typeof from[prop] === 'function') who[prop] = from[prop].bind(who);
-    else who[prop] = from[prop];
-  });
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function extend(who: any, from: any, overwrite = true) {
+    const ownProps = Object.getOwnPropertyNames(Object.getPrototypeOf(from)).concat(Object.keys(from));
+    ownProps.forEach((prop) => {
+        if (prop === "constructor" || from[prop] === undefined) return;
+        if (who[prop] && overwrite) {
+            who[`_${prop}`] = who[prop];
+        }
+        if (typeof from[prop] === "function") who[prop] = from[prop].bind(who);
+        else who[prop] = from[prop];
+    });
 }
 
 function stob(stream: ReadStream): Promise<Buffer> {
-  return new Promise(resolve => {
-    const buffers: Buffer[] = [];
-    stream.on('data', buffers.push.bind(buffers));
+    return new Promise((resolve) => {
+        const buffers: Buffer[] = [];
+        stream.on("data", buffers.push.bind(buffers));
 
-    stream.on('end', () => {
-      switch (buffers.length) {
-        case 0:
-          resolve(Buffer.allocUnsafe(0));
-          break;
-        case 1:
-          resolve(buffers[0]);
-          break;
-        default:
-          resolve(Buffer.concat(buffers));
-      }
+        stream.on("end", () => {
+            switch (buffers.length) {
+                case 0:
+                    resolve(Buffer.allocUnsafe(0));
+                    break;
+                case 1:
+                    resolve(buffers[0]);
+                    break;
+                default:
+                    resolve(Buffer.concat(buffers));
+            }
+        });
     });
-  });
 }
 
 export { extend, stob };

back/src/Server/sifrr.server.ts

@@ -1,19 +1,19 @@
-import { parse } from 'query-string';
-import { HttpRequest } from 'uWebSockets.js';
-import App from './server/app';
-import SSLApp from './server/sslapp';
-import * as types from './server/types';
+import { parse } from "query-string";
+import { HttpRequest } from "uWebSockets.js";
+import App from "./server/app";
+import SSLApp from "./server/sslapp";
+import * as types from "./server/types";
 
 const getQuery = (req: HttpRequest) => {
-  return parse(req.getQuery());
+    return parse(req.getQuery());
 };
 
 export { App, SSLApp, getQuery };
-export * from './server/types';
+export * from "./server/types";
 
 export default {
-  App,
-  SSLApp,
-  getQuery,
-  ...types
+    App,
+    SSLApp,
+    getQuery,
+    ...types,
 };

back/src/Services/AdminApi.ts

@@ -0,0 +1,24 @@
+import { ADMIN_API_TOKEN, ADMIN_API_URL } from "../Enum/EnvironmentVariable";
+import Axios from "axios";
+import { MapDetailsData } from "./AdminApi/MapDetailsData";
+import { RoomRedirect } from "./AdminApi/RoomRedirect";
+
+class AdminApi {
+    async fetchMapDetails(playUri: string): Promise<MapDetailsData | RoomRedirect> {
+        if (!ADMIN_API_URL) {
+            return Promise.reject(new Error("No admin backoffice set!"));
+        }
+
+        const params: { playUri: string } = {
+            playUri,
+        };
+
+        const res = await Axios.get(ADMIN_API_URL + "/api/map", {
+            headers: { Authorization: `${ADMIN_API_TOKEN}` },
+            params,
+        });
+        return res.data;
+    }
+}
+
+export const adminApi = new AdminApi();

back/src/Services/AdminApi/CharacterTexture.ts

@@ -0,0 +1,11 @@
+import * as tg from "generic-type-guard";
+
+export const isCharacterTexture = new tg.IsInterface()
+    .withProperties({
+        id: tg.isNumber,
+        level: tg.isNumber,
+        url: tg.isString,
+        rights: tg.isString,
+    })
+    .get();
+export type CharacterTexture = tg.GuardedType<typeof isCharacterTexture>;

back/src/Services/AdminApi/MapDetailsData.ts

@@ -0,0 +1,21 @@
+import * as tg from "generic-type-guard";
+import { isCharacterTexture } from "./CharacterTexture";
+import { isAny, isNumber } from "generic-type-guard";
+
+/*const isNumericEnum =
+    <T extends { [n: number]: string }>(vs: T) =>
+    (v: any): v is T =>
+        typeof v === "number" && v in vs;*/
+
+export const isMapDetailsData = new tg.IsInterface()
+    .withProperties({
+        mapUrl: tg.isString,
+        policy_type: isNumber, //isNumericEnum(GameRoomPolicyTypes),
+        tags: tg.isArray(tg.isString),
+        textures: tg.isArray(isCharacterTexture),
+    })
+    .withOptionalProperties({
+        roomSlug: tg.isUnion(tg.isString, tg.isNull), // deprecated
+    })
+    .get();
+export type MapDetailsData = tg.GuardedType<typeof isMapDetailsData>;

back/src/Services/AdminApi/RoomRedirect.ts

@@ -0,0 +1,8 @@
+import * as tg from "generic-type-guard";
+
+export const isRoomRedirect = new tg.IsInterface()
+    .withProperties({
+        redirectUrl: tg.isString,
+    })
+    .get();
+export type RoomRedirect = tg.GuardedType<typeof isRoomRedirect>;

back/src/Services/ArrayHelper.ts

@@ -1,3 +1,3 @@
-export const arrayIntersect = (array1: string[], array2: string[]) : boolean => {
-    return array1.filter(value => array2.includes(value)).length > 0;
-}
+export const arrayIntersect = (array1: string[], array2: string[]): boolean => {
+    return array1.filter((value) => array2.includes(value)).length > 0;
+};

back/src/Services/ClientEventsEmitter.ts

@@ -1,7 +1,7 @@
-const EventEmitter = require('events');
+const EventEmitter = require("events");
 
-const clientJoinEvent = 'clientJoin';
-const clientLeaveEvent = 'clientLeave';
+const clientJoinEvent = "clientJoin";
+const clientLeaveEvent = "clientLeave";
 
 class ClientEventsEmitter extends EventEmitter {
     emitClientJoin(clientUUid: string, roomId: string): void {

back/src/Services/CpuTracker.ts

@@ -1,6 +1,6 @@
-import {CPU_OVERHEAT_THRESHOLD} from "../Enum/EnvironmentVariable";
+import { CPU_OVERHEAT_THRESHOLD } from "../Enum/EnvironmentVariable";
 
-function secNSec2ms(secNSec: Array<number>|number) {
+function secNSec2ms(secNSec: Array<number> | number) {
     if (Array.isArray(secNSec)) {
         return secNSec[0] * 1000 + secNSec[1] / 1000000;
     }
@@ -12,17 +12,17 @@ class CpuTracker {
     private overHeating: boolean = false;
 
     constructor() {
-        let time  = process.hrtime.bigint()
-        let usage = process.cpuUsage()
+        let time = process.hrtime.bigint();
+        let usage = process.cpuUsage();
         setInterval(() => {
             const elapTime = process.hrtime.bigint();
-            const elapUsage = process.cpuUsage(usage)
-            usage = process.cpuUsage()
+            const elapUsage = process.cpuUsage(usage);
+            usage = process.cpuUsage();
 
             const elapTimeMS = elapTime - time;
-            const elapUserMS = secNSec2ms(elapUsage.user)
-            const elapSystMS = secNSec2ms(elapUsage.system)
-            this.cpuPercent = Math.round(100 * (elapUserMS + elapSystMS) / Number(elapTimeMS) * 1000000)
+            const elapUserMS = secNSec2ms(elapUsage.user);
+            const elapSystMS = secNSec2ms(elapUsage.system);
+            this.cpuPercent = Math.round(((100 * (elapUserMS + elapSystMS)) / Number(elapTimeMS)) * 1000000);
 
             time = elapTime;
 

back/src/Services/GaugeManager.ts

@@ -1,4 +1,4 @@
-import {Counter, Gauge} from "prom-client";
+import { Counter, Gauge } from "prom-client";
 
 //this class should manage all the custom metrics used by prometheus
 class GaugeManager {
@@ -10,29 +10,29 @@ class GaugeManager {
 
     constructor() {
         this.nbRoomsGauge = new Gauge({
-            name: 'workadventure_nb_rooms',
-            help: 'Number of active rooms'
+            name: "workadventure_nb_rooms",
+            help: "Number of active rooms",
         });
         this.nbClientsGauge = new Gauge({
-            name: 'workadventure_nb_sockets',
-            help: 'Number of connected sockets',
-            labelNames: [ ]
+            name: "workadventure_nb_sockets",
+            help: "Number of connected sockets",
+            labelNames: [],
         });
         this.nbClientsPerRoomGauge = new Gauge({
-            name: 'workadventure_nb_clients_per_room',
-            help: 'Number of clients per room',
-            labelNames: [ 'room' ]
+            name: "workadventure_nb_clients_per_room",
+            help: "Number of clients per room",
+            labelNames: ["room"],
         });
 
         this.nbGroupsPerRoomCounter = new Counter({
-            name: 'workadventure_counter_groups_per_room',
-            help: 'Counter of groups per room',
-            labelNames: [ 'room' ]
+            name: "workadventure_counter_groups_per_room",
+            help: "Counter of groups per room",
+            labelNames: ["room"],
         });
         this.nbGroupsPerRoomGauge = new Gauge({
-            name: 'workadventure_nb_groups_per_room',
-            help: 'Number of groups per room',
-            labelNames: [ 'room' ]
+            name: "workadventure_nb_groups_per_room",
+            help: "Number of groups per room",
+            labelNames: ["room"],
         });
     }
 
@@ -52,15 +52,6 @@ class GaugeManager {
         this.nbClientsGauge.dec();
         this.nbClientsPerRoomGauge.dec({ room: roomId });
     }
-
-    incNbGroupsPerRoomGauge(roomId: string): void {
-        this.nbGroupsPerRoomCounter.inc({ room: roomId })
-        this.nbGroupsPerRoomGauge.inc({ room: roomId })
-    }
-    
-    decNbGroupsPerRoomGauge(roomId: string): void {
-        this.nbGroupsPerRoomGauge.dec({ room: roomId })
-    }
 }
 
-export const gaugeManager = new GaugeManager();
+export const gaugeManager = new GaugeManager();

back/src/Services/LocalUrlError.ts

@@ -0,0 +1 @@
+export class LocalUrlError extends Error {}

back/src/Services/MapFetcher.ts

@@ -0,0 +1,70 @@
+import Axios from "axios";
+import ipaddr from "ipaddr.js";
+import { Resolver } from "dns";
+import { promisify } from "util";
+import { LocalUrlError } from "./LocalUrlError";
+import { ITiledMap } from "@workadventure/tiled-map-type-guard";
+import { isTiledMap } from "@workadventure/tiled-map-type-guard/dist";
+import { STORE_VARIABLES_FOR_LOCAL_MAPS } from "../Enum/EnvironmentVariable";
+
+class MapFetcher {
+    async fetchMap(mapUrl: string): Promise<ITiledMap> {
+        // Before trying to make the query, let's verify the map is actually on the open internet (and not a local test map)
+
+        if ((await this.isLocalUrl(mapUrl)) && !STORE_VARIABLES_FOR_LOCAL_MAPS) {
+            throw new LocalUrlError('URL for map "' + mapUrl + '" targets a local map');
+        }
+
+        // Note: mapUrl is provided by the client. A possible attack vector would be to use a rogue DNS server that
+        // returns local URLs. Alas, Axios cannot pin a URL to a given IP. So "isLocalUrl" and Axios.get could potentially
+        // target to different servers (and one could trick Axios.get into loading resources on the internal network
+        // despite isLocalUrl checking that.
+        // We can deem this problem not that important because:
+        // - We make sure we are only passing "GET" requests
+        // - The result of the query is never displayed to the end user
+        const res = await Axios.get(mapUrl, {
+            maxContentLength: 50 * 1024 * 1024, // Max content length: 50MB. Maps should not be bigger
+            timeout: 10000, // Timeout after 10 seconds
+        });
+
+        if (!isTiledMap(res.data)) {
+            //TODO fixme
+            //throw new Error("Invalid map format for map " + mapUrl);
+            console.error("Invalid map format for map " + mapUrl);
+        }
+
+        return res.data;
+    }
+
+    /**
+     * Returns true if the domain name is localhost of *.localhost
+     * Returns true if the domain name resolves to an IP address that is "private" (like 10.x.x.x or 192.168.x.x)
+     *
+     * @private
+     */
+    async isLocalUrl(url: string): Promise<boolean> {
+        const urlObj = new URL(url);
+        if (urlObj.hostname === "localhost" || urlObj.hostname.endsWith(".localhost")) {
+            return true;
+        }
+
+        let addresses = [];
+        if (!ipaddr.isValid(urlObj.hostname)) {
+            const resolver = new Resolver();
+            addresses = await promisify(resolver.resolve).bind(resolver)(urlObj.hostname);
+        } else {
+            addresses = [urlObj.hostname];
+        }
+
+        for (const address of addresses) {
+            const addr = ipaddr.parse(address);
+            if (addr.range() !== "unicast") {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
+
+export const mapFetcher = new MapFetcher();

back/src/Services/MessageHelpers.ts

@@ -1,5 +1,14 @@
-import {ErrorMessage, ServerToClientMessage} from "../Messages/generated/messages_pb";
-import {UserSocket} from "_Model/User";
+import {
+    BatchMessage,
+    BatchToPusherMessage,
+    BatchToPusherRoomMessage,
+    ErrorMessage,
+    ServerToClientMessage,
+    SubToPusherMessage,
+    SubToPusherRoomMessage,
+} from "../Messages/generated/messages_pb";
+import { UserSocket } from "_Model/User";
+import { RoomSocket, ZoneSocket } from "../RoomManager";
 
 export function emitError(Client: UserSocket, message: string): void {
     const errorMessage = new ErrorMessage();
@@ -9,7 +18,43 @@ export function emitError(Client: UserSocket, message: string): void {
     serverToClientMessage.setErrormessage(errorMessage);
 
     //if (!Client.disconnecting) {
-        Client.write(serverToClientMessage);
+    Client.write(serverToClientMessage);
+    //}
+    console.warn(message);
+}
+
+export function emitErrorOnRoomSocket(Client: RoomSocket, message: string): void {
+    console.error(message);
+
+    const errorMessage = new ErrorMessage();
+    errorMessage.setMessage(message);
+
+    const subToPusherRoomMessage = new SubToPusherRoomMessage();
+    subToPusherRoomMessage.setErrormessage(errorMessage);
+
+    const batchToPusherMessage = new BatchToPusherRoomMessage();
+    batchToPusherMessage.addPayload(subToPusherRoomMessage);
+
+    //if (!Client.disconnecting) {
+    Client.write(batchToPusherMessage);
+    //}
+    console.warn(message);
+}
+
+export function emitErrorOnZoneSocket(Client: ZoneSocket, message: string): void {
+    console.error(message);
+
+    const errorMessage = new ErrorMessage();
+    errorMessage.setMessage(message);
+
+    const subToPusherMessage = new SubToPusherMessage();
+    subToPusherMessage.setErrormessage(errorMessage);
+
+    const batchToPusherMessage = new BatchToPusherMessage();
+    batchToPusherMessage.addPayload(subToPusherMessage);
+
+    //if (!Client.disconnecting) {
+    Client.write(batchToPusherMessage);
     //}
     console.warn(message);
 }

back/src/Services/RedisClient.ts

@@ -0,0 +1,23 @@
+import { ClientOpts, createClient, RedisClient } from "redis";
+import { REDIS_HOST, REDIS_PASSWORD, REDIS_PORT } from "../Enum/EnvironmentVariable";
+
+let redisClient: RedisClient | null = null;
+
+if (REDIS_HOST !== undefined) {
+    const config: ClientOpts = {
+        host: REDIS_HOST,
+        port: REDIS_PORT,
+    };
+
+    if (REDIS_PASSWORD) {
+        config.password = REDIS_PASSWORD;
+    }
+
+    redisClient = createClient(config);
+
+    redisClient.on("error", (err) => {
+        console.error("Error connecting to Redis:", err);
+    });
+}
+
+export { redisClient };

back/src/Services/Repository/RedisVariablesRepository.ts

@@ -0,0 +1,43 @@
+import { promisify } from "util";
+import { RedisClient } from "redis";
+import { VariablesRepositoryInterface } from "./VariablesRepositoryInterface";
+
+/**
+ * Class in charge of saving/loading variables from the data store
+ */
+export class RedisVariablesRepository implements VariablesRepositoryInterface {
+    private readonly hgetall: OmitThisParameter<(arg1: string) => Promise<{ [p: string]: string }>>;
+    private readonly hset: OmitThisParameter<(arg1: [string, ...string[]]) => Promise<number>>;
+    private readonly hdel: OmitThisParameter<(arg1: string, arg2: string) => Promise<number>>;
+
+    constructor(private redisClient: RedisClient) {
+        /* eslint-disable @typescript-eslint/unbound-method */
+        this.hgetall = promisify(redisClient.hgetall).bind(redisClient);
+        this.hset = promisify(redisClient.hset).bind(redisClient);
+        this.hdel = promisify(redisClient.hdel).bind(redisClient);
+        /* eslint-enable @typescript-eslint/unbound-method */
+    }
+
+    /**
+     * Load all variables for a room.
+     *
+     * Note: in Redis, variables are stored in a hashmap and the key is the roomUrl
+     */
+    async loadVariables(roomUrl: string): Promise<{ [key: string]: string }> {
+        return this.hgetall(roomUrl);
+    }
+
+    async saveVariable(roomUrl: string, key: string, value: string): Promise<number> {
+        // The value is passed to JSON.stringify client side. If value is "undefined", JSON.stringify returns "undefined"
+        // which is translated to empty string when fetching the value in the pusher.
+        // Therefore, empty string server side == undefined client side.
+        if (value === "") {
+            return this.hdel(roomUrl, key);
+        }
+
+        // TODO: SLOW WRITING EVERY 2 SECONDS WITH A TIMEOUT
+
+        // @ts-ignore See https://stackoverflow.com/questions/63539317/how-do-i-use-hmset-with-node-promisify
+        return this.hset(roomUrl, key, value);
+    }
+}

back/src/Services/Repository/VariablesRepository.ts

@@ -0,0 +1,14 @@
+import { RedisVariablesRepository } from "./RedisVariablesRepository";
+import { redisClient } from "../RedisClient";
+import { VoidVariablesRepository } from "./VoidVariablesRepository";
+import { VariablesRepositoryInterface } from "./VariablesRepositoryInterface";
+
+let variablesRepository: VariablesRepositoryInterface;
+if (!redisClient) {
+    console.warn("WARNING: Redis isnot configured. No variables will be persisted.");
+    variablesRepository = new VoidVariablesRepository();
+} else {
+    variablesRepository = new RedisVariablesRepository(redisClient);
+}
+
+export { variablesRepository };

back/src/Services/Repository/VariablesRepositoryInterface.ts

@@ -0,0 +1,10 @@
+export interface VariablesRepositoryInterface {
+    /**
+     * Load all variables for a room.
+     *
+     * Note: in Redis, variables are stored in a hashmap and the key is the roomUrl
+     */
+    loadVariables(roomUrl: string): Promise<{ [key: string]: string }>;
+
+    saveVariable(roomUrl: string, key: string, value: string): Promise<number>;
+}

back/src/Services/Repository/VoidVariablesRepository.ts

@@ -0,0 +1,14 @@
+import { VariablesRepositoryInterface } from "./VariablesRepositoryInterface";
+
+/**
+ * Mock class in charge of NOT saving/loading variables from the data store
+ */
+export class VoidVariablesRepository implements VariablesRepositoryInterface {
+    loadVariables(roomUrl: string): Promise<{ [key: string]: string }> {
+        return Promise.resolve({});
+    }
+
+    saveVariable(roomUrl: string, key: string, value: string): Promise<number> {
+        return Promise.resolve(0);
+    }
+}

back/src/Services/SocketManager.ts

@@ -1,4 +1,4 @@
-import {GameRoom} from "../Model/GameRoom";
+import { GameRoom } from "../Model/GameRoom";
 import {
     ItemEventMessage,
     ItemStateMessage,
@@ -26,45 +26,51 @@ import {
     GroupLeftZoneMessage,
     WorldFullWarningMessage,
     UserLeftZoneMessage,
-    BanUserMessage, RefreshRoomMessage,
+    EmoteEventMessage,
+    BanUserMessage,
+    RefreshRoomMessage,
+    EmotePromptMessage,
+    VariableMessage,
+    BatchToPusherRoomMessage,
+    SubToPusherRoomMessage,
 } from "../Messages/generated/messages_pb";
-import {User, UserSocket} from "../Model/User";
-import {ProtobufUtils} from "../Model/Websocket/ProtobufUtils";
-import {Group} from "../Model/Group";
-import {cpuTracker} from "./CpuTracker";
+import { User, UserSocket } from "../Model/User";
+import { ProtobufUtils } from "../Model/Websocket/ProtobufUtils";
+import { Group } from "../Model/Group";
+import { cpuTracker } from "./CpuTracker";
 import {
     GROUP_RADIUS,
     JITSI_ISS,
     MINIMUM_DISTANCE,
     SECRET_JITSI_KEY,
-    TURN_STATIC_AUTH_SECRET
+    TURN_STATIC_AUTH_SECRET,
 } from "../Enum/EnvironmentVariable";
-import {Movable} from "../Model/Movable";
-import {PositionInterface} from "../Model/PositionInterface";
+import { Movable } from "../Model/Movable";
+import { PositionInterface } from "../Model/PositionInterface";
 import Jwt from "jsonwebtoken";
-import {JITSI_URL} from "../Enum/EnvironmentVariable";
-import {clientEventsEmitter} from "./ClientEventsEmitter";
-import {gaugeManager} from "./GaugeManager";
-import {ZoneSocket} from "../RoomManager";
-import {Zone} from "_Model/Zone";
+import { JITSI_URL } from "../Enum/EnvironmentVariable";
+import { clientEventsEmitter } from "./ClientEventsEmitter";
+import { gaugeManager } from "./GaugeManager";
+import { RoomSocket, ZoneSocket } from "../RoomManager";
+import { Zone } from "_Model/Zone";
 import Debug from "debug";
-import {Admin} from "_Model/Admin";
+import { Admin } from "_Model/Admin";
 import crypto from "crypto";
 
-
-const debug = Debug('sockermanager');
+const debug = Debug("sockermanager");
 
 function emitZoneMessage(subMessage: SubToPusherMessage, socket: ZoneSocket): void {
     // TODO: should we batch those every 100ms?
     const batchMessage = new BatchToPusherMessage();
     batchMessage.addPayload(subMessage);
-    
 
     socket.write(batchMessage);
 }
 
 export class SocketManager {
-    private rooms: Map<string, GameRoom> = new Map<string, GameRoom>();
+    //private rooms = new Map<string, GameRoom>();
+    // List of rooms in process of loading.
+    private roomsPromises = new Map<string, PromiseLike<GameRoom>>();
 
     constructor() {
         clientEventsEmitter.registerToClientJoin((clientUUid: string, roomId: string) => {
@@ -75,16 +81,18 @@ export class SocketManager {
         });
     }
 
-    public async handleJoinRoom(socket: UserSocket, joinRoomMessage: JoinRoomMessage): Promise<{ room: GameRoom; user: User }> {
-        
+    public async handleJoinRoom(
+        socket: UserSocket,
+        joinRoomMessage: JoinRoomMessage
+    ): Promise<{ room: GameRoom; user: User }> {
         //join new previous room
-        const {room, user} = await this.joinRoom(socket, joinRoomMessage);
-        
+        const { room, user } = await this.joinRoom(socket, joinRoomMessage);
+
         if (!socket.writable) {
-            console.warn('Socket was aborted');
+            console.warn("Socket was aborted");
             return {
                 room,
-                user
+                user,
             };
         }
         const roomJoinedMessage = new RoomJoinedMessage();
@@ -98,6 +106,16 @@ export class SocketManager {
             roomJoinedMessage.addItem(itemStateMessage);
         }
 
+        const variables = await room.getVariablesForTags(user.tags);
+
+        for (const [name, value] of variables.entries()) {
+            const variableMessage = new VariableMessage();
+            variableMessage.setName(name);
+            variableMessage.setValue(value);
+
+            roomJoinedMessage.addVariable(variableMessage);
+        }
+
         roomJoinedMessage.setCurrentuserid(user.id);
 
         const serverToClientMessage = new ServerToClientMessage();
@@ -106,37 +124,30 @@ export class SocketManager {
 
         return {
             room,
-            user
+            user,
         };
-
     }
 
     handleUserMovesMessage(room: GameRoom, user: User, userMovesMessage: UserMovesMessage) {
-        try {
-            const userMoves = userMovesMessage.toObject();
-            const position = userMovesMessage.getPosition();
+        const userMoves = userMovesMessage.toObject();
+        const position = userMovesMessage.getPosition();
 
-            // If CPU is high, let's drop messages of users moving (we will only dispatch the final position)
-            if (cpuTracker.isOverHeating() && userMoves.position?.moving === true) {
-                return;
-            }
-
-            if (position === undefined) {
-                throw new Error('Position not found in message');
-            }
-            const viewport = userMoves.viewport;
-            if (viewport === undefined) {
-                throw new Error('Viewport not found in message');
-            }
-            
-
-            // update position in the world
-            room.updatePosition(user, ProtobufUtils.toPointInterface(position));
-            //room.setViewport(client, client.viewport);
-        } catch (e) {
-            console.error('An error occurred on "user_position" event');
-            console.error(e);
+        // If CPU is high, let's drop messages of users moving (we will only dispatch the final position)
+        if (cpuTracker.isOverHeating() && userMoves.position?.moving === true) {
+            return;
         }
+
+        if (position === undefined) {
+            throw new Error("Position not found in message");
+        }
+        const viewport = userMoves.viewport;
+        if (viewport === undefined) {
+            throw new Error("Viewport not found in message");
+        }
+
+        // update position in the world
+        room.updatePosition(user, ProtobufUtils.toPointInterface(position));
+        //room.setViewport(client, client.viewport);
     }
 
     // Useless now, will be useful again if we allow editing details in game
@@ -155,39 +166,37 @@ export class SocketManager {
     }*/
 
     handleSilentMessage(room: GameRoom, user: User, silentMessage: SilentMessage) {
-        try {
-            room.setSilent(user, silentMessage.getSilent());
-        } catch (e) {
-            console.error('An error occurred on "handleSilentMessage"');
-            console.error(e);
-        }
+        room.setSilent(user, silentMessage.getSilent());
     }
 
     handleItemEvent(room: GameRoom, user: User, itemEventMessage: ItemEventMessage) {
         const itemEvent = ProtobufUtils.toItemEvent(itemEventMessage);
 
-        try {
-            const subMessage = new SubMessage();
-            subMessage.setItemeventmessage(itemEventMessage);
+        const subMessage = new SubMessage();
+        subMessage.setItemeventmessage(itemEventMessage);
 
-            // Let's send the event without using the SocketIO room.
-            // TODO: move this in the GameRoom class.
-            for (const user of room.getUsers().values()) {
-                user.emitInBatch(subMessage);
-            }
-
-            room.setItemState(itemEvent.itemId, itemEvent.state);
-        } catch (e) {
-            console.error('An error occurred on "item_event"');
-            console.error(e);
+        // Let's send the event without using the SocketIO room.
+        // TODO: move this in the GameRoom class.
+        for (const user of room.getUsers().values()) {
+            user.emitInBatch(subMessage);
         }
+
+        room.setItemState(itemEvent.itemId, itemEvent.state);
+    }
+
+    handleVariableEvent(room: GameRoom, user: User, variableMessage: VariableMessage): Promise<void> {
+        return room.setVariable(variableMessage.getName(), variableMessage.getValue(), user);
     }
 
     emitVideo(room: GameRoom, user: User, data: WebRtcSignalToServerMessage): void {
         //send only at user
         const remoteUser = room.getUsers().get(data.getReceiverid());
         if (remoteUser === undefined) {
-            console.warn("While exchanging a WebRTC signal: client with id ", data.getReceiverid(), " does not exist. This might be a race condition.");
+            console.warn(
+                "While exchanging a WebRTC signal: client with id ",
+                data.getReceiverid(),
+                " does not exist. This might be a race condition."
+            );
             return;
         }
 
@@ -195,8 +204,8 @@ export class SocketManager {
         webrtcSignalToClient.setUserid(user.id);
         webrtcSignalToClient.setSignal(data.getSignal());
         // TODO: only compute credentials if data.signal.type === "offer"
-        if (TURN_STATIC_AUTH_SECRET !== '') {
-            const {username, password} = this.getTURNCredentials(''+user.id, TURN_STATIC_AUTH_SECRET);
+        if (TURN_STATIC_AUTH_SECRET !== "") {
+            const { username, password } = this.getTURNCredentials("" + user.id, TURN_STATIC_AUTH_SECRET);
             webrtcSignalToClient.setWebrtcusername(username);
             webrtcSignalToClient.setWebrtcpassword(password);
         }
@@ -205,7 +214,7 @@ export class SocketManager {
         serverToClientMessage.setWebrtcsignaltoclientmessage(webrtcSignalToClient);
 
         //if (!client.disconnecting) {
-            remoteUser.socket.write(serverToClientMessage);
+        remoteUser.socket.write(serverToClientMessage);
         //}
     }
 
@@ -213,7 +222,11 @@ export class SocketManager {
         //send only at user
         const remoteUser = room.getUsers().get(data.getReceiverid());
         if (remoteUser === undefined) {
-            console.warn("While exchanging a WEBRTC_SCREEN_SHARING signal: client with id ", data.getReceiverid(), " does not exist. This might be a race condition.");
+            console.warn(
+                "While exchanging a WEBRTC_SCREEN_SHARING signal: client with id ",
+                data.getReceiverid(),
+                " does not exist. This might be a race condition."
+            );
             return;
         }
 
@@ -221,8 +234,8 @@ export class SocketManager {
         webrtcSignalToClient.setUserid(user.id);
         webrtcSignalToClient.setSignal(data.getSignal());
         // TODO: only compute credentials if data.signal.type === "offer"
-        if (TURN_STATIC_AUTH_SECRET !== '') {
-            const {username, password} = this.getTURNCredentials(''+user.id, TURN_STATIC_AUTH_SECRET);
+        if (TURN_STATIC_AUTH_SECRET !== "") {
+            const { username, password } = this.getTURNCredentials("" + user.id, TURN_STATIC_AUTH_SECRET);
             webrtcSignalToClient.setWebrtcusername(username);
             webrtcSignalToClient.setWebrtcpassword(password);
         }
@@ -231,48 +244,62 @@ export class SocketManager {
         serverToClientMessage.setWebrtcscreensharingsignaltoclientmessage(webrtcSignalToClient);
 
         //if (!client.disconnecting) {
-            remoteUser.socket.write(serverToClientMessage);
+        remoteUser.socket.write(serverToClientMessage);
         //}
     }
 
-    leaveRoom(room: GameRoom, user: User){
+    leaveRoom(room: GameRoom, user: User) {
         // leave previous room and world
         try {
             //user leave previous world
             room.leave(user);
             if (room.isEmpty()) {
-                this.rooms.delete(room.roomId);
+                this.roomsPromises.delete(room.roomUrl);
                 gaugeManager.decNbRoomGauge();
-                debug('Room is empty. Deleting room "%s"', room.roomId);
+                debug('Room is empty. Deleting room "%s"', room.roomUrl);
             }
         } finally {
-            clientEventsEmitter.emitClientLeave(user.uuid, room.roomId);
-            console.log('A user left');
+            clientEventsEmitter.emitClientLeave(user.uuid, room.roomUrl);
+            console.log("A user left");
         }
     }
 
     async getOrCreateRoom(roomId: string): Promise<GameRoom> {
-        //check and create new world for a room
-        let world = this.rooms.get(roomId)
-        if(world === undefined){
-            world = new GameRoom(
+        //check and create new room
+        let roomPromise = this.roomsPromises.get(roomId);
+        if (roomPromise === undefined) {
+            roomPromise = GameRoom.create(
                 roomId,
                 (user: User, group: Group) => this.joinWebRtcRoom(user, group),
                 (user: User, group: Group) => this.disConnectedUser(user, group),
                 MINIMUM_DISTANCE,
                 GROUP_RADIUS,
-                (thing: Movable, fromZone: Zone|null, listener: ZoneSocket) => this.onZoneEnter(thing, fromZone, listener),
-                (thing: Movable, position:PositionInterface, listener: ZoneSocket) => this.onClientMove(thing, position, listener),
-                (thing: Movable, newZone: Zone|null, listener: ZoneSocket) => this.onClientLeave(thing, newZone, listener)
-            );
-            gaugeManager.incNbRoomGauge();
-            this.rooms.set(roomId, world);
+                (thing: Movable, fromZone: Zone | null, listener: ZoneSocket) =>
+                    this.onZoneEnter(thing, fromZone, listener),
+                (thing: Movable, position: PositionInterface, listener: ZoneSocket) =>
+                    this.onClientMove(thing, position, listener),
+                (thing: Movable, newZone: Zone | null, listener: ZoneSocket) =>
+                    this.onClientLeave(thing, newZone, listener),
+                (emoteEventMessage: EmoteEventMessage, listener: ZoneSocket) =>
+                    this.onEmote(emoteEventMessage, listener)
+            )
+                .then((gameRoom) => {
+                    gaugeManager.incNbRoomGauge();
+                    return gameRoom;
+                })
+                .catch((e) => {
+                    this.roomsPromises.delete(roomId);
+                    throw e;
+                });
+            this.roomsPromises.set(roomId, roomPromise);
         }
-        return Promise.resolve(world)
+        return roomPromise;
     }
 
-    private async joinRoom(socket: UserSocket, joinRoomMessage: JoinRoomMessage): Promise<{ room: GameRoom; user: User }> {
-
+    private async joinRoom(
+        socket: UserSocket,
+        joinRoomMessage: JoinRoomMessage
+    ): Promise<{ room: GameRoom; user: User }> {
         const roomId = joinRoomMessage.getRoomid();
 
         const room = await socketManager.getOrCreateRoom(roomId);
@@ -281,21 +308,25 @@ export class SocketManager {
         const user = room.join(socket, joinRoomMessage);
 
         clientEventsEmitter.emitClientJoin(user.uuid, roomId);
-        console.log(new Date().toISOString() + ' A user joined');
-        return {room, user};
+        console.log(new Date().toISOString() + " A user joined");
+        return { room, user };
     }
 
-    private onZoneEnter(thing: Movable, fromZone: Zone|null, listener: ZoneSocket) {
+    private onZoneEnter(thing: Movable, fromZone: Zone | null, listener: ZoneSocket) {
         if (thing instanceof User) {
             const userJoinedZoneMessage = new UserJoinedZoneMessage();
             if (!Number.isInteger(thing.id)) {
-                throw new Error('clientUser.userId is not an integer '+thing.id);
+                throw new Error("clientUser.userId is not an integer " + thing.id);
             }
             userJoinedZoneMessage.setUserid(thing.id);
+            userJoinedZoneMessage.setUseruuid(thing.uuid);
             userJoinedZoneMessage.setName(thing.name);
             userJoinedZoneMessage.setCharacterlayersList(ProtobufUtils.toCharacterLayerMessages(thing.characterLayers));
             userJoinedZoneMessage.setPosition(ProtobufUtils.toPositionMessage(thing.getPosition()));
             userJoinedZoneMessage.setFromzone(this.toProtoZone(fromZone));
+            if (thing.visitCardUrl) {
+                userJoinedZoneMessage.setVisitcardurl(thing.visitCardUrl);
+            }
             userJoinedZoneMessage.setCompanion(thing.companion);
 
             const subMessage = new SubToPusherMessage();
@@ -306,11 +337,11 @@ export class SocketManager {
         } else if (thing instanceof Group) {
             this.emitCreateUpdateGroupEvent(listener, fromZone, thing);
         } else {
-            console.error('Unexpected type for Movable.');
+            console.error("Unexpected type for Movable.");
         }
     }
 
-    private onClientMove(thing: Movable, position:PositionInterface, listener: ZoneSocket): void {
+    private onClientMove(thing: Movable, position: PositionInterface, listener: ZoneSocket): void {
         if (thing instanceof User) {
             const userMovedMessage = new UserMovedMessage();
             userMovedMessage.setUserid(thing.id);
@@ -325,21 +356,28 @@ export class SocketManager {
         } else if (thing instanceof Group) {
             this.emitCreateUpdateGroupEvent(listener, null, thing);
         } else {
-            console.error('Unexpected type for Movable.');
+            console.error("Unexpected type for Movable.");
         }
     }
 
-    private onClientLeave(thing: Movable, newZone: Zone|null, listener: ZoneSocket) {
+    private onClientLeave(thing: Movable, newZone: Zone | null, listener: ZoneSocket) {
         if (thing instanceof User) {
             this.emitUserLeftEvent(listener, thing.id, newZone);
         } else if (thing instanceof Group) {
             this.emitDeleteGroupEvent(listener, thing.getId(), newZone);
         } else {
-            console.error('Unexpected type for Movable.');
+            console.error("Unexpected type for Movable.");
         }
     }
 
-    private emitCreateUpdateGroupEvent(client: ZoneSocket, fromZone: Zone|null, group: Group): void {
+    private onEmote(emoteEventMessage: EmoteEventMessage, client: ZoneSocket) {
+        const subMessage = new SubToPusherMessage();
+        subMessage.setEmoteeventmessage(emoteEventMessage);
+
+        emitZoneMessage(subMessage, client);
+    }
+
+    private emitCreateUpdateGroupEvent(client: ZoneSocket, fromZone: Zone | null, group: Group): void {
         const position = group.getPosition();
         const pointMessage = new PointMessage();
         pointMessage.setX(Math.floor(position.x));
@@ -357,7 +395,7 @@ export class SocketManager {
         //client.emitInBatch(subMessage);
     }
 
-    private emitDeleteGroupEvent(client: ZoneSocket, groupId: number, newZone: Zone|null): void {
+    private emitDeleteGroupEvent(client: ZoneSocket, groupId: number, newZone: Zone | null): void {
         const groupDeleteMessage = new GroupLeftZoneMessage();
         groupDeleteMessage.setGroupid(groupId);
         groupDeleteMessage.setTozone(this.toProtoZone(newZone));
@@ -369,7 +407,7 @@ export class SocketManager {
         //user.emitInBatch(subMessage);
     }
 
-    private emitUserLeftEvent(client: ZoneSocket, userId: number, newZone: Zone|null): void {
+    private emitUserLeftEvent(client: ZoneSocket, userId: number, newZone: Zone | null): void {
         const userLeftMessage = new UserLeftZoneMessage();
         userLeftMessage.setUserid(userId);
         userLeftMessage.setTozone(this.toProtoZone(newZone));
@@ -380,7 +418,7 @@ export class SocketManager {
         emitZoneMessage(subMessage, client);
     }
 
-    private toProtoZone(zone: Zone|null): ProtoZone|undefined {
+    private toProtoZone(zone: Zone | null): ProtoZone | undefined {
         if (zone !== null) {
             const zoneMessage = new ProtoZone();
             zoneMessage.setX(zone.x);
@@ -391,7 +429,6 @@ export class SocketManager {
     }
 
     private joinWebRtcRoom(user: User, group: Group) {
-
         for (const otherUser of group.getUsers()) {
             if (user === otherUser) {
                 continue;
@@ -400,10 +437,9 @@ export class SocketManager {
             // Let's send 2 messages: one to the user joining the group and one to the other user
             const webrtcStartMessage1 = new WebRtcStartMessage();
             webrtcStartMessage1.setUserid(otherUser.id);
-            webrtcStartMessage1.setName(otherUser.name);
             webrtcStartMessage1.setInitiator(true);
-            if (TURN_STATIC_AUTH_SECRET !== '') {
-                const {username, password} = this.getTURNCredentials(''+otherUser.id, TURN_STATIC_AUTH_SECRET);
+            if (TURN_STATIC_AUTH_SECRET !== "") {
+                const { username, password } = this.getTURNCredentials("" + otherUser.id, TURN_STATIC_AUTH_SECRET);
                 webrtcStartMessage1.setWebrtcusername(username);
                 webrtcStartMessage1.setWebrtcpassword(password);
             }
@@ -411,17 +447,13 @@ export class SocketManager {
             const serverToClientMessage1 = new ServerToClientMessage();
             serverToClientMessage1.setWebrtcstartmessage(webrtcStartMessage1);
 
-            //if (!user.socket.disconnecting) {
-                user.socket.write(serverToClientMessage1);
-                //console.log('Sending webrtcstart initiator to '+user.socket.userId)
-            //}
+            user.socket.write(serverToClientMessage1);
 
             const webrtcStartMessage2 = new WebRtcStartMessage();
             webrtcStartMessage2.setUserid(user.id);
-            webrtcStartMessage2.setName(user.name);
             webrtcStartMessage2.setInitiator(false);
-            if (TURN_STATIC_AUTH_SECRET !== '') {
-                const {username, password} = this.getTURNCredentials(''+user.id, TURN_STATIC_AUTH_SECRET);
+            if (TURN_STATIC_AUTH_SECRET !== "") {
+                const { username, password } = this.getTURNCredentials("" + user.id, TURN_STATIC_AUTH_SECRET);
                 webrtcStartMessage2.setWebrtcusername(username);
                 webrtcStartMessage2.setWebrtcpassword(password);
             }
@@ -429,11 +461,7 @@ export class SocketManager {
             const serverToClientMessage2 = new ServerToClientMessage();
             serverToClientMessage2.setWebrtcstartmessage(webrtcStartMessage2);
 
-            //if (!otherUser.socket.disconnecting) {
-                otherUser.socket.write(serverToClientMessage2);
-                //console.log('Sending webrtcstart to '+otherUser.socket.userId)
-            //}
-
+            otherUser.socket.write(serverToClientMessage2);
         }
     }
 
@@ -442,17 +470,17 @@ export class SocketManager {
      * and the Coturn server.
      * The Coturn server should be initialized with parameters: `--use-auth-secret --static-auth-secret=MySecretKey`
      */
-    private getTURNCredentials(name: string, secret: string): {username: string, password: string} {
-        const unixTimeStamp = Math.floor(Date.now()/1000) + 4*3600;   // this credential would be valid for the next 4 hours
-        const username = [unixTimeStamp, name].join(':');
-        const hmac = crypto.createHmac('sha1', secret);
-        hmac.setEncoding('base64');
+    private getTURNCredentials(name: string, secret: string): { username: string; password: string } {
+        const unixTimeStamp = Math.floor(Date.now() / 1000) + 4 * 3600; // this credential would be valid for the next 4 hours
+        const username = [unixTimeStamp, name].join(":");
+        const hmac = crypto.createHmac("sha1", secret);
+        hmac.setEncoding("base64");
         hmac.write(username);
         hmac.end();
         const password = hmac.read();
         return {
             username: username,
-            password: password
+            password: password,
         };
     }
 
@@ -475,10 +503,9 @@ export class SocketManager {
             serverToClientMessage1.setWebrtcdisconnectmessage(webrtcDisconnectMessage1);
 
             //if (!otherUser.socket.disconnecting) {
-                otherUser.socket.write(serverToClientMessage1);
+            otherUser.socket.write(serverToClientMessage1);
             //}
 
-
             const webrtcDisconnectMessage2 = new WebRtcDisconnectMessage();
             webrtcDisconnectMessage2.setUserid(otherUser.id);
 
@@ -486,57 +513,53 @@ export class SocketManager {
             serverToClientMessage2.setWebrtcdisconnectmessage(webrtcDisconnectMessage2);
 
             //if (!user.socket.disconnecting) {
-                user.socket.write(serverToClientMessage2);
+            user.socket.write(serverToClientMessage2);
             //}
         }
     }
 
     emitPlayGlobalMessage(room: GameRoom, playGlobalMessage: PlayGlobalMessage) {
-        try {
-            const serverToClientMessage = new ServerToClientMessage();
-            serverToClientMessage.setPlayglobalmessage(playGlobalMessage);
+        const serverToClientMessage = new ServerToClientMessage();
+        serverToClientMessage.setPlayglobalmessage(playGlobalMessage);
 
-            for (const [id, user] of room.getUsers().entries()) {
-                user.socket.write(serverToClientMessage);
-            }
-        } catch (e) {
-            console.error('An error occurred on "emitPlayGlobalMessage" event');
-            console.error(e);
+        for (const [id, user] of room.getUsers().entries()) {
+            user.socket.write(serverToClientMessage);
         }
-
     }
 
-    public getWorlds(): Map<string, GameRoom> {
-        return this.rooms;
+    public getWorlds(): Map<string, PromiseLike<GameRoom>> {
+        return this.roomsPromises;
     }
 
-
     public handleQueryJitsiJwtMessage(user: User, queryJitsiJwtMessage: QueryJitsiJwtMessage) {
         const room = queryJitsiJwtMessage.getJitsiroom();
         const tag = queryJitsiJwtMessage.getTag(); // FIXME: this is not secure. We should load the JSON for the current room and check rights associated to room instead.
 
-        if (SECRET_JITSI_KEY === '') {
-            throw new Error('You must set the SECRET_JITSI_KEY key to the secret to generate JWT tokens for Jitsi.');
+        if (SECRET_JITSI_KEY === "") {
+            throw new Error("You must set the SECRET_JITSI_KEY key to the secret to generate JWT tokens for Jitsi.");
         }
 
         // Let's see if the current client has
         const isAdmin = user.tags.includes(tag);
 
-        const jwt = Jwt.sign({
-            "aud": "jitsi",
-            "iss": JITSI_ISS,
-            "sub": JITSI_URL,
-            "room": room,
-            "moderator": isAdmin
-        }, SECRET_JITSI_KEY, {
-            expiresIn: '1d',
-            algorithm: "HS256",
-            header:
-                {
-                    "alg": "HS256",
-                    "typ": "JWT"
-                }
-        });
+        const jwt = Jwt.sign(
+            {
+                aud: "jitsi",
+                iss: JITSI_ISS,
+                sub: JITSI_URL,
+                room: room,
+                moderator: isAdmin,
+            },
+            SECRET_JITSI_KEY,
+            {
+                expiresIn: "1d",
+                algorithm: "HS256",
+                header: {
+                    alg: "HS256",
+                    typ: "JWT",
+                },
+            }
+        );
 
         const sendJitsiJwtMessage = new SendJitsiJwtMessage();
         sendJitsiJwtMessage.setJitsiroom(room);
@@ -548,7 +571,7 @@ export class SocketManager {
         user.socket.write(serverToClientMessage);
     }
 
-    public handlerSendUserMessage(user: User, sendUserMessageToSend: SendUserMessage){
+    public handlerSendUserMessage(user: User, sendUserMessageToSend: SendUserMessage) {
         const sendUserMessage = new SendUserMessage();
         sendUserMessage.setMessage(sendUserMessageToSend.getMessage());
         sendUserMessage.setType(sendUserMessageToSend.getType());
@@ -558,7 +581,7 @@ export class SocketManager {
         user.socket.write(serverToClientMessage);
     }
 
-    public handlerBanUserMessage(room: GameRoom, user: User, banUserMessageToSend: BanUserMessage){
+    public handlerBanUserMessage(room: GameRoom, user: User, banUserMessageToSend: BanUserMessage) {
         const banUserMessage = new BanUserMessage();
         banUserMessage.setMessage(banUserMessageToSend.getMessage());
         banUserMessage.setType(banUserMessageToSend.getType());
@@ -575,11 +598,10 @@ export class SocketManager {
         }, 10000);
     }
 
-    public addZoneListener(call: ZoneSocket, roomId: string, x: number, y: number): void {
-        const room = this.rooms.get(roomId);
+    public async addZoneListener(call: ZoneSocket, roomId: string, x: number, y: number): Promise<void> {
+        const room = await this.roomsPromises.get(roomId);
         if (!room) {
-            console.error("In addZoneListener, could not find room with id '" +  roomId + "'");
-            return;
+            throw new Error("In addZoneListener, could not find room with id '" + roomId + "'");
         }
 
         const things = room.addZoneListener(call, x, y);
@@ -590,9 +612,13 @@ export class SocketManager {
             if (thing instanceof User) {
                 const userJoinedMessage = new UserJoinedZoneMessage();
                 userJoinedMessage.setUserid(thing.id);
+                userJoinedMessage.setUseruuid(thing.uuid);
                 userJoinedMessage.setName(thing.name);
                 userJoinedMessage.setCharacterlayersList(ProtobufUtils.toCharacterLayerMessages(thing.characterLayers));
                 userJoinedMessage.setPosition(ProtobufUtils.toPositionMessage(thing.getPosition()));
+                if (thing.visitCardUrl) {
+                    userJoinedMessage.setVisitcardurl(thing.visitCardUrl);
+                }
                 userJoinedMessage.setCompanion(thing.companion);
 
                 const subMessage = new SubToPusherMessage();
@@ -616,16 +642,37 @@ export class SocketManager {
         call.write(batchMessage);
     }
 
-    removeZoneListener(call: ZoneSocket, roomId: string, x: number, y: number) {
-        const room = this.rooms.get(roomId);
+    async removeZoneListener(call: ZoneSocket, roomId: string, x: number, y: number): Promise<void> {
+        const room = await this.roomsPromises.get(roomId);
         if (!room) {
-            console.error("In removeZoneListener, could not find room with id '" +  roomId + "'");
-            return;
+            throw new Error("In removeZoneListener, could not find room with id '" + roomId + "'");
         }
 
         room.removeZoneListener(call, x, y);
     }
 
+    async addRoomListener(call: RoomSocket, roomId: string) {
+        const room = await this.getOrCreateRoom(roomId);
+        if (!room) {
+            throw new Error("In addRoomListener, could not find room with id '" + roomId + "'");
+        }
+
+        room.addRoomListener(call);
+
+        const batchMessage = new BatchToPusherRoomMessage();
+
+        call.write(batchMessage);
+    }
+
+    async removeRoomListener(call: RoomSocket, roomId: string) {
+        const room = await this.roomsPromises.get(roomId);
+        if (!room) {
+            throw new Error("In removeRoomListener, could not find room with id '" + roomId + "'");
+        }
+
+        room.removeRoomListener(call);
+    }
+
     public async handleJoinAdminRoom(admin: Admin, roomId: string): Promise<GameRoom> {
         const room = await socketManager.getOrCreateRoom(roomId);
 
@@ -634,79 +681,102 @@ export class SocketManager {
         return room;
     }
 
-    public leaveAdminRoom(room: GameRoom, admin: Admin){
+    public leaveAdminRoom(room: GameRoom, admin: Admin) {
         room.adminLeave(admin);
         if (room.isEmpty()) {
-            this.rooms.delete(room.roomId);
+            this.roomsPromises.delete(room.roomUrl);
             gaugeManager.decNbRoomGauge();
-            debug('Room is empty. Deleting room "%s"', room.roomId);
+            debug('Room is empty. Deleting room "%s"', room.roomUrl);
         }
     }
 
-    public sendAdminMessage(roomId: string, recipientUuid: string, message: string): void {
-        const room = this.rooms.get(roomId);
+    public async sendAdminMessage(roomId: string, recipientUuid: string, message: string): Promise<void> {
+        const room = await this.roomsPromises.get(roomId);
         if (!room) {
-            console.error("In sendAdminMessage, could not find room with id '" + roomId + "'. Maybe the room was closed a few milliseconds ago and there was a race condition?");
+            console.error(
+                "In sendAdminMessage, could not find room with id '" +
+                    roomId +
+                    "'. Maybe the room was closed a few milliseconds ago and there was a race condition?"
+            );
             return;
         }
 
-        const recipient = room.getUserByUuid(recipientUuid);
-        if (recipient === undefined) {
-            console.error("In sendAdminMessage, could not find user with id '" + recipientUuid + "'. Maybe the user left the room a few milliseconds ago and there was a race condition?");
+        const recipients = room.getUsersByUuid(recipientUuid);
+        if (recipients.length === 0) {
+            console.error(
+                "In sendAdminMessage, could not find user with id '" +
+                    recipientUuid +
+                    "'. Maybe the user left the room a few milliseconds ago and there was a race condition?"
+            );
             return;
         }
 
-        const sendUserMessage = new SendUserMessage();
-        sendUserMessage.setMessage(message);
-        sendUserMessage.setType('ban'); //todo: is the type correct?
+        for (const recipient of recipients) {
+            const sendUserMessage = new SendUserMessage();
+            sendUserMessage.setMessage(message);
+            sendUserMessage.setType("ban"); //todo: is the type correct?
 
-        const serverToClientMessage = new ServerToClientMessage();
-        serverToClientMessage.setSendusermessage(sendUserMessage);
+            const serverToClientMessage = new ServerToClientMessage();
+            serverToClientMessage.setSendusermessage(sendUserMessage);
 
-        recipient.socket.write(serverToClientMessage);
+            recipient.socket.write(serverToClientMessage);
+        }
     }
 
-    public banUser(roomId: string, recipientUuid: string, message: string): void {
-        const room = this.rooms.get(roomId);
+    public async banUser(roomId: string, recipientUuid: string, message: string): Promise<void> {
+        const room = await this.roomsPromises.get(roomId);
         if (!room) {
-            console.error("In banUser, could not find room with id '" +  roomId + "'. Maybe the room was closed a few milliseconds ago and there was a race condition?");
+            console.error(
+                "In banUser, could not find room with id '" +
+                    roomId +
+                    "'. Maybe the room was closed a few milliseconds ago and there was a race condition?"
+            );
             return;
         }
 
-        const recipient = room.getUserByUuid(recipientUuid);
-        if (recipient === undefined) {
-            console.error("In banUser, could not find user with id '" + recipientUuid + "'. Maybe the user left the room a few milliseconds ago and there was a race condition?");
+        const recipients = room.getUsersByUuid(recipientUuid);
+        if (recipients.length === 0) {
+            console.error(
+                "In banUser, could not find user with id '" +
+                    recipientUuid +
+                    "'. Maybe the user left the room a few milliseconds ago and there was a race condition?"
+            );
             return;
         }
 
-        // Let's leave the room now.
-        room.leave(recipient);
+        for (const recipient of recipients) {
+            // Let's leave the room now.
+            room.leave(recipient);
 
-        const banUserMessage = new BanUserMessage();
-        banUserMessage.setMessage(message);
-        banUserMessage.setType('banned');
+            const banUserMessage = new BanUserMessage();
+            banUserMessage.setMessage(message);
+            banUserMessage.setType("banned");
 
-        const serverToClientMessage = new ServerToClientMessage();
-        serverToClientMessage.setBanusermessage(banUserMessage);
+            const serverToClientMessage = new ServerToClientMessage();
+            serverToClientMessage.setBanusermessage(banUserMessage);
 
-        // Let's close the connection when the user is banned.
-        recipient.socket.write(serverToClientMessage);
-        recipient.socket.end();
+            // Let's close the connection when the user is banned.
+            recipient.socket.write(serverToClientMessage);
+            recipient.socket.end();
+        }
     }
 
-
-    sendAdminRoomMessage(roomId: string, message: string) {
-        const room = this.rooms.get(roomId);
+    async sendAdminRoomMessage(roomId: string, message: string, type: string) {
+        const room = await this.roomsPromises.get(roomId);
         if (!room) {
             //todo: this should cause the http call to return a 500
-            console.error("In sendAdminRoomMessage, could not find room with id '" +  roomId + "'. Maybe the room was closed a few milliseconds ago and there was a race condition?");
+            console.error(
+                "In sendAdminRoomMessage, could not find room with id '" +
+                    roomId +
+                    "'. Maybe the room was closed a few milliseconds ago and there was a race condition?"
+            );
             return;
         }
 
         room.getUsers().forEach((recipient) => {
             const sendUserMessage = new SendUserMessage();
             sendUserMessage.setMessage(message);
-            sendUserMessage.setType('message');
+            sendUserMessage.setType(type);
 
             const clientMessage = new ServerToClientMessage();
             clientMessage.setSendusermessage(sendUserMessage);
@@ -715,14 +785,18 @@ export class SocketManager {
         });
     }
 
-    dispatchWorlFullWarning(roomId: string,): void {
-        const room = this.rooms.get(roomId);
+    async dispatchWorldFullWarning(roomId: string): Promise<void> {
+        const room = await this.roomsPromises.get(roomId);
         if (!room) {
             //todo: this should cause the http call to return a 500
-            console.error("In sendAdminRoomMessage, could not find room with id '" +  roomId + "'. Maybe the room was closed a few milliseconds ago and there was a race condition?");
+            console.error(
+                "In dispatchWorldFullWarning, could not find room with id '" +
+                    roomId +
+                    "'. Maybe the room was closed a few milliseconds ago and there was a race condition?"
+            );
             return;
         }
-        
+
         room.getUsers().forEach((recipient) => {
             const worldFullMessage = new WorldFullWarningMessage();
 
@@ -733,17 +807,17 @@ export class SocketManager {
         });
     }
 
-    dispatchRoomRefresh(roomId: string,): void {
-        const room = this.rooms.get(roomId);
+    async dispatchRoomRefresh(roomId: string): Promise<void> {
+        const room = await this.roomsPromises.get(roomId);
         if (!room) {
             return;
         }
-        
+
         const versionNumber = room.incrementVersion();
         room.getUsers().forEach((recipient) => {
             const worldFullMessage = new RefreshRoomMessage();
-            worldFullMessage.setRoomid(roomId)
-            worldFullMessage.setVersionnumber(versionNumber)
+            worldFullMessage.setRoomid(roomId);
+            worldFullMessage.setVersionnumber(versionNumber);
 
             const clientMessage = new ServerToClientMessage();
             clientMessage.setRefreshroommessage(worldFullMessage);
@@ -751,6 +825,13 @@ export class SocketManager {
             recipient.socket.write(clientMessage);
         });
     }
+
+    handleEmoteEventMessage(room: GameRoom, user: User, emotePromptMessage: EmotePromptMessage) {
+        const emoteEventMessage = new EmoteEventMessage();
+        emoteEventMessage.setEmote(emotePromptMessage.getEmote());
+        emoteEventMessage.setActoruserid(user.id);
+        room.emitEmoteEvent(user, emoteEventMessage);
+    }
 }
 
 export const socketManager = new SocketManager();

back/src/Services/VariableError.ts

@@ -0,0 +1,9 @@
+/**
+ * Errors related to variable handling.
+ */
+export class VariableError extends Error {
+    constructor(message: string) {
+        super(message);
+        Object.setPrototypeOf(this, VariableError.prototype);
+    }
+}

back/src/Services/VariablesManager.ts

@@ -0,0 +1,234 @@
+/**
+ * Handles variables shared between the scripting API and the server.
+ */
+import {
+    ITiledMap,
+    ITiledMapLayer,
+    ITiledMapObject,
+    ITiledMapObjectLayer,
+} from "@workadventure/tiled-map-type-guard/dist";
+import { User } from "_Model/User";
+import { variablesRepository } from "./Repository/VariablesRepository";
+import { redisClient } from "./RedisClient";
+import { VariableError } from "./VariableError";
+
+interface Variable {
+    defaultValue?: string;
+    persist?: boolean;
+    readableBy?: string;
+    writableBy?: string;
+}
+
+export class VariablesManager {
+    /**
+     * The actual values of the variables for the current room
+     */
+    private _variables = new Map<string, string>();
+
+    /**
+     * The list of variables that are allowed
+     */
+    private variableObjects: Map<string, Variable> | undefined;
+
+    /**
+     * @param map The map can be "null" if it is hosted on a private network. In this case, we assume this is a test setup and bypass any server-side checks.
+     */
+    constructor(private roomUrl: string, private map: ITiledMap | null) {
+        // 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)
+        if (map) {
+            this.variableObjects = VariablesManager.findVariablesInMap(map);
+
+            // Let's initialize default values
+            for (const [name, variableObject] of this.variableObjects.entries()) {
+                if (variableObject.defaultValue !== undefined) {
+                    this._variables.set(name, variableObject.defaultValue);
+                }
+            }
+        }
+    }
+
+    /**
+     * Let's load data from the Redis backend.
+     */
+    public async init(): Promise<VariablesManager> {
+        if (!this.shouldPersist()) {
+            return this;
+        }
+        const variables = await variablesRepository.loadVariables(this.roomUrl);
+        for (const key in variables) {
+            // Let's only set variables if they are in the map (if the map has changed, maybe stored variables do not exist anymore)
+            if (this.variableObjects) {
+                const variableObject = this.variableObjects.get(key);
+                if (variableObject === undefined) {
+                    continue;
+                }
+                if (!variableObject.persist) {
+                    continue;
+                }
+            }
+
+            this._variables.set(key, variables[key]);
+        }
+        return this;
+    }
+
+    /**
+     * Returns true if saving should be enabled, and false otherwise.
+     *
+     * Saving is enabled if REDIS_HOST is set
+     *   unless we are editing a local map
+     *     unless we are in dev mode in which case it is ok to save
+     *
+     * @private
+     */
+    private shouldPersist(): boolean {
+        return redisClient !== null && (this.map !== null || process.env.NODE_ENV === "development");
+    }
+
+    private static findVariablesInMap(map: ITiledMap): Map<string, Variable> {
+        const objects = new Map<string, Variable>();
+        for (const layer of map.layers) {
+            this.recursiveFindVariablesInLayer(layer, objects);
+        }
+        return objects;
+    }
+
+    private static recursiveFindVariablesInLayer(layer: ITiledMapLayer, objects: Map<string, Variable>): void {
+        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.'
+                        );
+                        continue;
+                    }
+
+                    // We store a copy of the object (to make it immutable)
+                    objects.set(object.name, this.iTiledObjectToVariable(object));
+                }
+            }
+        } else if (layer.type === "group") {
+            for (const innerLayer of layer.layers) {
+                this.recursiveFindVariablesInLayer(innerLayer, objects);
+            }
+        }
+    }
+
+    private static iTiledObjectToVariable(object: ITiledMapObject): Variable {
+        const variable: Variable = {};
+
+        if (object.properties) {
+            for (const property of object.properties) {
+                const value = property.value;
+                switch (property.name) {
+                    case "default":
+                        variable.defaultValue = JSON.stringify(value);
+                        break;
+                    case "persist":
+                        if (typeof value !== "boolean") {
+                            throw new Error('The persist property of variable "' + object.name + '" must be a boolean');
+                        }
+                        variable.persist = 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;
+    }
+
+    /**
+     * Sets the variable.
+     *
+     * Returns who is allowed to read the variable (the readableby property) or "undefined" if anyone can read it.
+     * Also, returns "false" if the variable was not modified (because we set it to the value it already has)
+     *
+     * @param name
+     * @param value
+     * @param user
+     */
+    setVariable(name: string, value: string, user: User): string | undefined | false {
+        let readableBy: string | undefined;
+        let variableObject: Variable | undefined;
+        if (this.variableObjects) {
+            variableObject = this.variableObjects.get(name);
+            if (variableObject === undefined) {
+                throw new VariableError(
+                    'Trying to set a variable "' + name + '" that is not defined as an object in the map.'
+                );
+            }
+
+            if (variableObject.writableBy && !user.tags.includes(variableObject.writableBy)) {
+                throw new VariableError(
+                    'Trying to set a variable "' +
+                        name +
+                        '". User "' +
+                        user.name +
+                        '" does not have sufficient permission. Required tag: "' +
+                        variableObject.writableBy +
+                        '". User tags: ' +
+                        user.tags.join(", ") +
+                        "."
+                );
+            }
+
+            readableBy = variableObject.readableBy;
+        }
+
+        // If the value is not modified, return false
+        if (this._variables.get(name) === value) {
+            return false;
+        }
+
+        this._variables.set(name, value);
+
+        if (variableObject !== undefined && variableObject.persist) {
+            variablesRepository
+                .saveVariable(this.roomUrl, name, value)
+                .catch((e) => console.error("Error while saving variable in Redis:", e));
+        }
+
+        return readableBy;
+    }
+
+    public getVariablesForTags(tags: string[]): Map<string, string> {
+        if (this.variableObjects === undefined) {
+            return this._variables;
+        }
+
+        const readableVariables = new Map<string, string>();
+
+        for (const [key, value] of this._variables.entries()) {
+            const variableObject = this.variableObjects.get(key);
+            if (variableObject === undefined) {
+                throw new Error('Unexpected variable "' + key + '" found has no associated variableObject.');
+            }
+            if (!variableObject.readableBy || tags.includes(variableObject.readableBy)) {
+                readableVariables.set(key, value);
+            }
+        }
+        return readableVariables;
+    }
+}

back/tests/GameRoomTest.ts

@@ -1,55 +1,62 @@
 import "jasmine";
-import {ConnectCallback, DisconnectCallback, GameRoom} from "../src/Model/GameRoom";
-import {Point} from "../src/Model/Websocket/MessageUserPosition";
-import {Group} from "../src/Model/Group";
-import {User, UserSocket} from "_Model/User";
-import {JoinRoomMessage, PositionMessage} from "../src/Messages/generated/messages_pb";
+import { ConnectCallback, DisconnectCallback, GameRoom } from "../src/Model/GameRoom";
+import { Point } from "../src/Model/Websocket/MessageUserPosition";
+import { Group } from "../src/Model/Group";
+import { User, UserSocket } from "_Model/User";
+import { JoinRoomMessage, PositionMessage } from "../src/Messages/generated/messages_pb";
 import Direction = PositionMessage.Direction;
+import { EmoteCallback } from "_Model/Zone";
 
 function createMockUser(userId: number): User {
     return {
-        userId
+        userId,
     } as unknown as User;
 }
 
 function createMockUserSocket(): UserSocket {
-    return {
-    } as unknown as UserSocket;
+    return {} as unknown as UserSocket;
 }
 
-function createJoinRoomMessage(uuid: string, x: number, y: number): JoinRoomMessage
-{
+function createJoinRoomMessage(uuid: string, x: number, y: number): JoinRoomMessage {
     const positionMessage = new PositionMessage();
     positionMessage.setX(x);
     positionMessage.setY(y);
     positionMessage.setDirection(Direction.DOWN);
     positionMessage.setMoving(false);
     const joinRoomMessage = new JoinRoomMessage();
-    joinRoomMessage.setUseruuid('1');
-    joinRoomMessage.setIpaddress('10.0.0.2');
-    joinRoomMessage.setName('foo');
-    joinRoomMessage.setRoomid('_/global/test.json');
+    joinRoomMessage.setUseruuid("1");
+    joinRoomMessage.setIpaddress("10.0.0.2");
+    joinRoomMessage.setName("foo");
+    joinRoomMessage.setRoomid("_/global/test.json");
     joinRoomMessage.setPositionmessage(positionMessage);
     return joinRoomMessage;
 }
 
+const emote: EmoteCallback = (emoteEventMessage, listener): void => {};
+
 describe("GameRoom", () => {
-    it("should connect user1 and user2", () => {
+    it("should connect user1 and user2", async () => {
         let connectCalledNumber: number = 0;
         const connect: ConnectCallback = (user: User, group: Group): void => {
             connectCalledNumber++;
-        }
-        const disconnect: DisconnectCallback = (user: User, group: Group): void => {
+        };
+        const disconnect: DisconnectCallback = (user: User, group: Group): void => {};
 
-        }
+        const world = await GameRoom.create(
+            "https://play.workadventu.re/_/global/localhost/test.json",
+            connect,
+            disconnect,
+            160,
+            160,
+            () => {},
+            () => {},
+            () => {},
+            emote
+        );
 
-        const world = new GameRoom('_/global/test.json', connect, disconnect, 160, 160, () => {}, () => {}, () => {});
+        const user1 = world.join(createMockUserSocket(), createJoinRoomMessage("1", 100, 100));
 
-
-
-        const user1 = world.join(createMockUserSocket(), createJoinRoomMessage('1', 100, 100));
-
-        const user2 = world.join(createMockUserSocket(), createJoinRoomMessage('2', 500, 100));
+        const user2 = world.join(createMockUserSocket(), createJoinRoomMessage("2", 500, 100));
 
         world.updatePosition(user2, new Point(261, 100));
 
@@ -63,26 +70,34 @@ describe("GameRoom", () => {
         expect(connectCalledNumber).toBe(2);
     });
 
-    it("should connect 3 users", () => {
+    it("should connect 3 users", async () => {
         let connectCalled: boolean = false;
         const connect: ConnectCallback = (user: User, group: Group): void => {
             connectCalled = true;
-        }
-        const disconnect: DisconnectCallback = (user: User, group: Group): void => {
+        };
+        const disconnect: DisconnectCallback = (user: User, group: Group): void => {};
 
-        }
+        const world = await GameRoom.create(
+            "https://play.workadventu.re/_/global/localhost/test.json",
+            connect,
+            disconnect,
+            160,
+            160,
+            () => {},
+            () => {},
+            () => {},
+            emote
+        );
 
-        const world = new GameRoom('_/global/test.json', connect, disconnect, 160, 160, () => {}, () => {}, () => {});
+        const user1 = world.join(createMockUserSocket(), createJoinRoomMessage("1", 100, 100));
 
-        const user1 = world.join(createMockUserSocket(), createJoinRoomMessage('1', 100, 100));
-
-        const user2 = world.join(createMockUserSocket(), createJoinRoomMessage('2', 200, 100));
+        const user2 = world.join(createMockUserSocket(), createJoinRoomMessage("2", 200, 100));
 
         expect(connectCalled).toBe(true);
         connectCalled = false;
 
         // baz joins at the outer limit of the group
-        const user3 = world.join(createMockUserSocket(), createJoinRoomMessage('2', 311, 100));
+        const user3 = world.join(createMockUserSocket(), createJoinRoomMessage("2", 311, 100));
 
         expect(connectCalled).toBe(false);
 
@@ -91,31 +106,40 @@ describe("GameRoom", () => {
         expect(connectCalled).toBe(true);
     });
 
-    it("should disconnect user1 and user2", () => {
+    it("should disconnect user1 and user2", async () => {
         let connectCalled: boolean = false;
         let disconnectCallNumber: number = 0;
         const connect: ConnectCallback = (user: User, group: Group): void => {
             connectCalled = true;
-        }
+        };
         const disconnect: DisconnectCallback = (user: User, group: Group): void => {
             disconnectCallNumber++;
-        }
+        };
 
-        const world = new GameRoom('_/global/test.json', connect, disconnect, 160, 160, () => {}, () => {}, () => {});
+        const world = await GameRoom.create(
+            "https://play.workadventu.re/_/global/localhost/test.json",
+            connect,
+            disconnect,
+            160,
+            160,
+            () => {},
+            () => {},
+            () => {},
+            emote
+        );
 
-        const user1 = world.join(createMockUserSocket(), createJoinRoomMessage('1', 100, 100));
+        const user1 = world.join(createMockUserSocket(), createJoinRoomMessage("1", 100, 100));
 
-        const user2 = world.join(createMockUserSocket(), createJoinRoomMessage('2', 259, 100));
+        const user2 = world.join(createMockUserSocket(), createJoinRoomMessage("2", 259, 100));
 
         expect(connectCalled).toBe(true);
         expect(disconnectCallNumber).toBe(0);
 
-        world.updatePosition(user2, new Point(100+160+160+1, 100));
+        world.updatePosition(user2, new Point(100 + 160 + 160 + 1, 100));
 
         expect(disconnectCallNumber).toBe(2);
 
         world.updatePosition(user2, new Point(262, 100));
         expect(disconnectCallNumber).toBe(2);
     });
-
-})
+});

back/tests/MapFetcherTest.ts

@@ -0,0 +1,32 @@
+import { arrayIntersect } from "../src/Services/ArrayHelper";
+import { mapFetcher } from "../src/Services/MapFetcher";
+
+describe("MapFetcher", () => {
+    it("should return true on localhost ending URLs", async () => {
+        expect(await mapFetcher.isLocalUrl("https://localhost")).toBeTrue();
+        expect(await mapFetcher.isLocalUrl("https://foo.localhost")).toBeTrue();
+    });
+
+    it("should return true on DNS resolving to a local domain", async () => {
+        expect(await mapFetcher.isLocalUrl("https://127.0.0.1.nip.io")).toBeTrue();
+    });
+
+    it("should return true on an IP resolving to a local domain", async () => {
+        expect(await mapFetcher.isLocalUrl("https://127.0.0.1")).toBeTrue();
+        expect(await mapFetcher.isLocalUrl("https://192.168.0.1")).toBeTrue();
+    });
+
+    it("should return false on an IP resolving to a global domain", async () => {
+        expect(await mapFetcher.isLocalUrl("https://51.12.42.42")).toBeFalse();
+    });
+
+    it("should return false on an DNS resolving to a global domain", async () => {
+        expect(await mapFetcher.isLocalUrl("https://maps.workadventu.re")).toBeFalse();
+    });
+
+    it("should throw error on invalid domain", async () => {
+        await expectAsync(
+            mapFetcher.isLocalUrl("https://this.domain.name.doesnotexistfoobgjkgfdjkgldf.com")
+        ).toBeRejected();
+    });
+});

back/tests/PositionNotifierTest.ts

@@ -1,10 +1,6 @@
 import "jasmine";
-import {GameRoom, ConnectCallback, DisconnectCallback } from "_Model/GameRoom";
-import {Point} from "../src/Model/Websocket/MessageUserPosition";
-import { Group } from "../src/Model/Group";
 import {PositionNotifier} from "../src/Model/PositionNotifier";
 import {User, UserSocket} from "../src/Model/User";
-import {PointInterface} from "../src/Model/Websocket/PointInterface";
 import {Zone} from "_Model/Zone";
 import {Movable} from "_Model/Movable";
 import {PositionInterface} from "_Model/PositionInterface";
@@ -23,21 +19,21 @@ describe("PositionNotifier", () => {
             moveTriggered = true;
         }, (thing: Movable) => {
             leaveTriggered = true;
-        });
+        }, () => {});
 
         const user1 = new User(1, 'test', '10.0.0.2', {
             x: 500,
             y: 500,
             moving: false,
             direction: 'down'
-        }, false, positionNotifier, {} as UserSocket, [], 'foo', []);
+        }, false, positionNotifier, {} as UserSocket, [], null, 'foo', []);
 
         const user2 = new User(2, 'test', '10.0.0.2', {
             x: -9999,
             y: -9999,
             moving: false,
             direction: 'down'
-        }, false, positionNotifier, {} as UserSocket, [], 'foo', []);
+        }, false, positionNotifier, {} as UserSocket, [], null, 'foo', []);
 
         positionNotifier.addZoneListener({} as ZoneSocket, 0, 0);
         positionNotifier.addZoneListener({} as ZoneSocket, 0, 1);
@@ -98,21 +94,21 @@ describe("PositionNotifier", () => {
             moveTriggered = true;
         }, (thing: Movable) => {
             leaveTriggered = true;
-        });
+        }, () => {});
 
         const user1 = new User(1, 'test', '10.0.0.2', {
             x: 500,
             y: 500,
             moving: false,
             direction: 'down'
-        }, false, positionNotifier, {} as UserSocket, [], 'foo', []);
+        }, false, positionNotifier, {} as UserSocket, [], null, 'foo', []);
 
         const user2 = new User(2, 'test', '10.0.0.2', {
             x: 0,
             y: 0,
             moving: false,
             direction: 'down'
-        }, false, positionNotifier, {} as UserSocket, [], 'foo', []);
+        }, false, positionNotifier, {} as UserSocket, [], null, 'foo', []);
 
         const listener = {} as ZoneSocket;
         positionNotifier.addZoneListener(listener, 0, 0);

back/tests/RoomIdentifierTest.ts

@@ -1,19 +0,0 @@
-import {extractDataFromPrivateRoomId, extractRoomSlugPublicRoomId, isRoomAnonymous} from "../src/Model/RoomIdentifier";
-
-describe("RoomIdentifier", () => {
-    it("should flag public id as anonymous", () => {
-        expect(isRoomAnonymous('_/global/test')).toBe(true);
-    });
-    it("should flag public id as not anonymous", () => {
-        expect(isRoomAnonymous('@/afup/afup2020/1floor')).toBe(false);
-    });
-    it("should extract roomSlug from public ID", () => {
-        expect(extractRoomSlugPublicRoomId('_/global/npeguin/test.json')).toBe('npeguin/test.json');
-    });
-    it("should extract correct from private ID", () => {
-        const {organizationSlug, worldSlug, roomSlug} = extractDataFromPrivateRoomId('@/afup/afup2020/1floor');
-        expect(organizationSlug).toBe('afup');
-        expect(worldSlug).toBe('afup2020');
-        expect(roomSlug).toBe('1floor');
-    });
-})

back/tests/getNearbyDescriptorsMatrixTest.ts

@@ -0,0 +1,67 @@
+import "jasmine";
+import { getNearbyDescriptorsMatrix } from "../src/Model/PositionNotifier";
+
+describe("getNearbyDescriptorsMatrix", () => {
+    it("should create a matrix of coordinates in a square around the parameter", () => {
+        const matrix = [];
+        for (const d of getNearbyDescriptorsMatrix({ i: 1, j: 1 })) {
+            matrix.push(d);
+        }
+
+        expect(matrix).toEqual([
+            { i: 0, j: 0 },
+            { i: 1, j: 0 },
+            { i: 2, j: 0 },
+            { i: 0, j: 1 },
+            { i: 1, j: 1 },
+            { i: 2, j: 1 },
+            { i: 0, j: 2 },
+            { i: 1, j: 2 },
+            { i: 2, j: 2 },
+        ]);
+    });
+
+    it("should create a matrix of coordinates in a square around the parameter bis", () => {
+        const matrix = [];
+        for (const d of getNearbyDescriptorsMatrix({ i: 8, j: 3 })) {
+            matrix.push(d);
+        }
+
+        expect(matrix).toEqual([
+            { i: 7, j: 2 },
+            { i: 8, j: 2 },
+            { i: 9, j: 2 },
+            { i: 7, j: 3 },
+            { i: 8, j: 3 },
+            { i: 9, j: 3 },
+            { i: 7, j: 4 },
+            { i: 8, j: 4 },
+            { i: 9, j: 4 },
+        ]);
+    });
+
+    it("should not create a matrix with negative coordinates", () => {
+        const matrix = [];
+        for (const d of getNearbyDescriptorsMatrix({ i: 0, j: 0 })) {
+            matrix.push(d);
+        }
+
+        expect(matrix).toEqual([
+            { i: 0, j: 0 },
+            { i: 1, j: 0 },
+            { i: 0, j: 1 },
+            { i: 1, j: 1 },
+        ]);
+    });
+
+    /*it("should not create a matrix with coordinates bigger than its dimmensions", () => {
+        const matrix = getNearbyDescriptorsMatrix({i: 4, j: 4}, 5, 5);
+
+        expect(matrix).toEqual([
+            {i: 3,j: 3},
+            {i: 4,j: 3},
+            {i: 3,j: 4},
+            {i: 4,j: 4},
+        ])
+    });*/
+});

back/tsconfig.json

@@ -3,7 +3,7 @@
     "experimentalDecorators": true,
     /* Basic Options */
     // "incremental": true,                   /* Enable incremental compilation */
-    "target": "es5",                          /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
+    "target": "ES2019",                       /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'. */
     "downlevelIteration": true,
     "module": "commonjs",                     /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */
     // "lib": [],                             /* Specify library files to be included in the compilation. */

benchmark/index.ts

@@ -13,7 +13,6 @@ RoomConnection.setWebsocketFactory((url: string) => {
 });
 
 async function startOneUser(): Promise<void> {
-    await connectionManager.anonymousLogin(true);
     const onConnect = await connectionManager.connectToRoomSocket(process.env.ROOM_ID ? process.env.ROOM_ID : '_/global/maps.workadventure.localhost/Floor0/floor0.json', 'TEST', ['male3'],
         {
             x: 783,
@@ -23,7 +22,7 @@ async function startOneUser(): Promise<void> {
             bottom: 200,
             left: 500,
             right: 800
-        });
+        }, null);
 
     const connection = onConnect.connection;
 

benchmark/package-lock.json

@@ -209,9 +209,9 @@
       }
     },
     "glob-parent": {
-      "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.1.tgz",
-      "integrity": "sha512-FnI+VGOpnlGHWZxthPGR+QhR78fuiK0sNLkHQv+bL9fQi57lNNdquIbna/WrfROrolq8GK5Ek6BiMwqL/voRYQ==",
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
       "requires": {
         "is-glob": "^4.0.1"
       }
@@ -230,9 +230,9 @@
       }
     },
     "hosted-git-info": {
-      "version": "2.8.8",
-      "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.8.tgz",
-      "integrity": "sha512-f/wzC2QaWBs7t9IYqB4T3sR1xviIViXJRJTWBlx2Gf3g0Xi5vI7Yy4koXQ1c9OYDGHN9sBy1DQ2AB8fqZBWhUg=="
+      "version": "2.8.9",
+      "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.8.9.tgz",
+      "integrity": "sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw=="
     },
     "indent-string": {
       "version": "2.1.0",
@@ -429,9 +429,9 @@
       "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18="
     },
     "path-parse": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz",
-      "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw=="
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw=="
     },
     "path-type": {
       "version": "1.1.0",
@@ -688,9 +688,9 @@
       "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8="
     },
     "ws": {
-      "version": "7.3.1",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-7.3.1.tgz",
-      "integrity": "sha512-D3RuNkynyHmEJIpD2qrgVkc9DQ23OrN/moAwZX4L8DfvszsJxpjQuUq3LMx6HoYji9fbIOBY18XWBsAux1ZZUA=="
+      "version": "7.4.6",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-7.4.6.tgz",
+      "integrity": "sha512-YmhHDO4MzaDLB+M9ym/mDA5z0naX8j7SIlT8f8z+I0VtzsRbekxEutHSme7NPS2qE8StCYQNUnfWdXta/Yu85A=="
     },
     "xtend": {
       "version": "4.0.2",

benchmark/package.json

@@ -24,7 +24,7 @@
     "@types/ws": "^7.2.6",
     "ts-node-dev": "^1.0.0-pre.62",
     "typescript": "^4.0.2",
-    "ws": "^7.3.1"
+    "ws": "^7.4.6"
   },
   "devDependencies": {}
 }

benchmark/yarn.lock

@@ -148,8 +148,8 @@ get-stdin@^4.0.1:
   resolved "https://registry.yarnpkg.com/get-stdin/-/get-stdin-4.0.1.tgz#b968c6b0a04384324902e8bf1a5df32579a450fe"
 
 glob-parent@~5.1.0:
-  version "5.1.1"
-  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.1.tgz#b6c1ef417c4e5663ea498f1c45afac6916bbc229"
+  version "5.1.2"
+  resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-5.1.2.tgz#869832c58034fe68a4093c17dc15e8340d8401c4"
   dependencies:
     is-glob "^4.0.1"
 
@@ -169,8 +169,8 @@ graceful-fs@^4.1.2:
   resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.4.tgz#2256bde14d3632958c465ebc96dc467ca07a29fb"
 
 hosted-git-info@^2.1.4:
-  version "2.8.8"
-  resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-2.8.8.tgz#7539bd4bc1e0e0a895815a2e0262420b12858488"
+  version "2.8.9"
+  resolved "https://registry.yarnpkg.com/hosted-git-info/-/hosted-git-info-2.8.9.tgz#dffc0bf9a21c02209090f2aa69429e1414daf3f9"
 
 indent-string@^2.1.0:
   version "2.1.0"
@@ -315,8 +315,8 @@ path-is-absolute@^1.0.0:
   resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
 
 path-parse@^1.0.6:
-  version "1.0.6"
-  resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.6.tgz#d62dbb5679405d72c4737ec58600e9ddcf06d24c"
+  version "1.0.7"
+  resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.7.tgz#fbc114b60ca42b30d9daf5858e4bd68bbedb6735"
 
 path-type@^1.0.0:
   version "1.1.0"
@@ -515,9 +515,9 @@ wrappy@1:
   version "1.0.2"
   resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
 
-ws@^7.3.1:
-  version "7.3.1"
-  resolved "https://registry.yarnpkg.com/ws/-/ws-7.3.1.tgz#d0547bf67f7ce4f12a72dfe31262c68d7dc551c8"
+ws@^7.4.6:
+  version "7.4.6"
+  resolved "https://registry.yarnpkg.com/ws/-/ws-7.4.6.tgz#5654ca8ecdeee47c33a9a4bf6d28e2be2980377c"
 
 xtend@^4.0.0:
   version "4.0.2"

contrib/docker/docker-compose.prod.yaml

@@ -38,6 +38,7 @@ services:
       JITSI_URL: $JITSI_URL
       JITSI_PRIVATE_MODE: "$JITSI_PRIVATE_MODE"
       PUSHER_URL: //pusher.${DOMAIN}
+      ICON_URL: //icon.${DOMAIN}
       TURN_SERVER: "${TURN_SERVER}"
       TURN_USER: "${TURN_USER}"
       TURN_PASSWORD: "${TURN_PASSWORD}"
@@ -65,6 +66,7 @@ services:
       API_URL: back:50051
       JITSI_URL: $JITSI_URL
       JITSI_ISS: $JITSI_ISS
+      FRONT_URL: https://play.${DOMAIN}
     labels:
       - "traefik.http.routers.pusher.rule=Host(`pusher.${DOMAIN}`)"
       - "traefik.http.routers.pusher.entryPoints=web,traefik"
@@ -98,3 +100,15 @@ services:
       - "traefik.http.routers.back-ssl.service=back"
       - "traefik.http.routers.back-ssl.tls.certresolver=myresolver"
     restart: unless-stopped
+
+  icon:
+    image: matthiasluedtke/iconserver:v3.13.0
+    labels:
+      - "traefik.http.routers.icon.rule=Host(`icon.${DOMAIN}`)"
+      - "traefik.http.routers.icon.entryPoints=web,traefik"
+      - "traefik.http.services.icon.loadbalancer.server.port=8080"
+      - "traefik.http.routers.icon-ssl.rule=Host(`icon.${DOMAIN}`)"
+      - "traefik.http.routers.icon-ssl.entryPoints=websecure"
+      - "traefik.http.routers.icon-ssl.tls=true"
+      - "traefik.http.routers.icon-ssl.service=icon"
+      - "traefik.http.routers.icon-ssl.tls.certresolver=myresolver"

debian/.gitignore

@@ -0,0 +1,2 @@
+*~
+\#*\#

debian/README.Debian

@@ -0,0 +1,10 @@
+workadventure for Debian
+-----------------------
+
+To install:
+ - Install workadventure-back workadventure-front workadventure-pusher
+ - Go to "/var/lib/workadvenure/{back,pusher}" and run "yarn install --production"
+ - Serve "/usr/src/workadventure/front" as web page
+ - Provide configuration for the UI in "/usr/src/workadventure/front/config.js"
+
+ -- unknown <felix@localhost>  Sat, 17 Apr 2021 14:06:51 +0200

debian/changelog

@@ -0,0 +1,24 @@
+workadventure (1.6.3-1) unstable; urgency=medium
+
+  * Update to 1.6.3
+
+ -- unknown <felix@localhost>  Mon, 29 Nov 2021 20:10:29 +0200
+
+workadventure (1.4.12-1) unstable; urgency=medium
+
+  * Update to 1.4.12
+
+ -- unknown <felix@localhost>  Fri, 06 Aug 2021 15:00:35 +0200
+
+workadventure (1.2.4-2) unstable; urgency=medium
+
+  * Fix chat dialog spacing
+  * Improve systemd unit for backend
+
+ -- unknown <felix@localhost>  Wed, 21 Apr 2021 21:55:41 +0200
+
+workadventure (1.2.4-1) unstable; urgency=medium
+
+  * Initial release
+
+ -- unknown <felix@localhost>  Sat, 17 Apr 2021 14:06:51 +0200

debian/control

@@ -0,0 +1,32 @@
+Source: workadventure
+Section: unknown
+Priority: optional
+Maintainer: unknown <felix@localhost>
+Build-Depends: debhelper-compat (= 12), yarnpkg
+Standards-Version: 4.5.1
+Homepage: <insert the upstream URL, if relevant>
+Rules-Requires-Root: no
+
+Package: workadventure-back
+Architecture: all
+Depends: ${misc:Depends}, yarnpkg
+Description: <insert up to 60 chars description>
+ <insert long description, indented with spaces>
+
+Package: workadventure-pusher
+Architecture: all
+Depends: ${misc:Depends}, yarnpkg
+Description: <insert up to 60 chars description>
+ <insert long description, indented with spaces>
+
+Package: workadventure-front
+Architecture: all
+Depends: ${misc:Depends}
+Description: <insert up to 60 chars description>
+ <insert long description, indented with spaces>
+
+Package: workadventure-front-map
+Architecture: all
+Depends: ${misc:Depends}, workadventure-front
+Description: <insert up to 60 chars description>
+ <insert long description, indented with spaces>

debian/copyright

@@ -0,0 +1,32 @@
+Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: workadventure
+Upstream-Contact: <preferred name and address to reach the upstream project>
+Source: <url://example.com>
+
+Files: *
+Copyright: 2021 TheCodingMachine
+License: AGPL-3 with Commons Clause
+ <Put the license of the package here indented by 1 space>
+ <This follows the format of Description: lines in control file>
+ .
+ <Including paragraphs>
+
+Files: debian/*
+Copyright: 2021 unknown <felix@localhost>
+License: GPL-2+
+ This package is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+ .
+ This package is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ .
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <https://www.gnu.org/licenses/>
+ .
+ On Debian systems, the complete text of the GNU General
+ Public License version 2 can be found in "/usr/share/common-licenses/GPL-2".
+

debian/rules

@@ -0,0 +1,49 @@
+#!/usr/bin/make -f
+%:
+	dh $@
+
+override_dh_install:
+	install -Dt debian/workadventure-front/usr/src/workadventure/front front/dist/index.html
+	install -d debian/workadventure-front/usr/src/workadventure/front/js
+	cp -r front/dist/static front/dist/fonts front/dist/resources front/dist/*.js front/dist/*.png front/dist/*.css debian/workadventure-front/usr/src/workadventure/front
+	cp -r front/dist/js/*.js debian/workadventure-front/usr/src/workadventure/front/js
+
+
+	install -d debian/workadventure-front-map/usr/src/workadventure/front/js
+	cp -r front/dist/*.js.map front/dist/*.css.map debian/workadventure-front-map/usr/src/workadventure/front
+	cp -r front/dist/js/*.js.map debian/workadventure-front-map/usr/src/workadventure/front/js
+
+	install -d debian/workadventure-back/usr/src/workadventure/back
+	cp -r back/dist/server.js back/dist/src debian/workadventure-back/usr/src/workadventure/back
+	cp back/yarn.lock back/package.json debian/workadventure-back/usr/src/workadventure/back
+	install -d debian/workadventure-back/var/lib/workadventure/back
+	ln -s /usr/src/workadventure/back/package.json /usr/src/workadventure/back/yarn.lock /usr/src/workadventure/back/src /usr/src/workadventure/back/server.js debian/workadventure-back/var/lib/workadventure/back/
+
+	install -d debian/workadventure-pusher/usr/src/workadventure/pusher
+	cp -r pusher/dist/server.js pusher/dist/src debian/workadventure-pusher/usr/src/workadventure/pusher
+	cp pusher/yarn.lock pusher/package.json debian/workadventure-pusher/usr/src/workadventure/pusher
+	install -d debian/workadventure-back/var/lib/workadventure/pusher
+	ln -s /usr/src/workadventure/pusher/package.json /usr/src/workadventure/pusher/yarn.lock /usr/src/workadventure/pusher/src /usr/src/workadventure/pusher/server.js debian/workadventure-back/var/lib/workadventure/pusher/
+
+
+front/src/Messages/generated:
+	ln -s ../../../messages/generated front/src/Messages
+
+back/src/Messages/generated:
+	ln -s ../../../messages/generated back/src/Messages
+
+pusher/src/Messages/generated:
+	ln -s ../../../messages/generated pusher/src/Messages
+
+override_dh_auto_build: front/src/Messages/generated back/src/Messages/generated pusher/src/Messages/generated
+	cd messages && yarnpkg install && yarnpkg run proto
+	rm -Rf front/dist/js
+	cd front && ./templater.sh && yarnpkg install && yarnpkg run build
+	cd back && yarnpkg install && yarnpkg run tsc
+	cd pusher && yarnpkg install && yarnpkg run tsc
+
+# dh_make generated override targets
+# This is example for Cmake (See https://bugs.debian.org/641051 )
+#override_dh_auto_configure:
+#	dh_auto_configure -- \
+#	-DCMAKE_LIBRARY_PATH=$(DEB_HOST_MULTIARCH)

debian/source/format

@@ -0,0 +1 @@
+3.0 (quilt)

debian/workadventure-back.service

@@ -0,0 +1,13 @@
+[Unit]
+Description="Workadventure Backend"
+
+[Service]
+User=webspace-user
+WorkingDirectory=/var/lib/workadventure/back
+Environment=NODE_PATH=node_modules
+ExecStart=node --max-old-space-size=4096 server.js
+ProtectSystem=Full
+ProtectHome=true
+
+[Install]
+WantedBy=multi-user.target

debian/workadventure-docs.docs

@@ -0,0 +1,2 @@
+README.source
+README.Debian

debian/workadventure-pusher.service

@@ -0,0 +1,15 @@
+[Unit]
+Description="Workadventure Pusher"
+
+[Service]
+User=webspace-user
+WorkingDirectory=/var/lib/workadventure/pusher
+Environment=NODE_PATH=node_modules
+Environment=PUSHER_HTTP_PORT=8081
+Environment=API_URL=localhost:50051
+ExecStart=node --max-old-space-size=4096 server.js
+ProtectSystem=Full
+ProtectHome=true
+
+[Install]
+WantedBy=multi-user.target

deeployer.libsonnet

@@ -1,103 +1,95 @@
 {
   local env = std.extVar("env"),
-  local namespace = env.GITHUB_REF_SLUG,
+  local namespace = env.DEPLOY_REF,
   local tag = namespace,
-  local url = if namespace == "master" then "workadventu.re" else namespace+".workadventure.test.thecodingmachine.com",
+  local url = namespace+".test.workadventu.re",
   // develop branch does not use admin because of issue with SSL certificate of admin as of now.
-  local adminUrl = if namespace == "master" || namespace == "develop" || std.startsWith(namespace, "admin") then "https://"+url else null,
+  local adminUrl = if std.startsWith(namespace, "admin") then "https://"+url else null,
   "$schema": "https://raw.githubusercontent.com/thecodingmachine/deeployer/master/deeployer.schema.json",
   "version": "1.0",
   "containers": {
      "back1": {
        "image": "thecodingmachine/workadventure-back:"+tag,
        "host": {
-         "url": "api1."+url,
-         "https": "enable",
+         "url": "api1-"+url,
          "containerPort": 8080
        },
        "ports": [8080, 50051],
        "env": {
          "SECRET_KEY": "tempSecretKeyNeedsToChange",
-         "ADMIN_API_TOKEN": env.ADMIN_API_TOKEN,
          "JITSI_ISS": env.JITSI_ISS,
          "JITSI_URL": env.JITSI_URL,
          "SECRET_JITSI_KEY": env.SECRET_JITSI_KEY,
          "TURN_STATIC_AUTH_SECRET": env.TURN_STATIC_AUTH_SECRET,
+         "REDIS_HOST": "redis",
        } + (if adminUrl != null then {
          "ADMIN_API_URL": adminUrl,
-       } else {}) + if namespace != "master" then {
-         // Absolutely ugly WorkAround to circumvent broken certificates on the K8S test cluster. Don't do this in production kids!
-         "NODE_TLS_REJECT_UNAUTHORIZED": "0"
-       }
+         "ADMIN_API_TOKEN": env.ADMIN_API_TOKEN,
+       } else {})
      },
      "back2": {
             "image": "thecodingmachine/workadventure-back:"+tag,
             "host": {
-              "url": "api2."+url,
-              "https": "enable",
+              "url": "api2-"+url,
               "containerPort": 8080
             },
             "ports": [8080, 50051],
             "env": {
               "SECRET_KEY": "tempSecretKeyNeedsToChange",
-              "ADMIN_API_TOKEN": env.ADMIN_API_TOKEN,
               "JITSI_ISS": env.JITSI_ISS,
               "JITSI_URL": env.JITSI_URL,
               "SECRET_JITSI_KEY": env.SECRET_JITSI_KEY,
               "TURN_STATIC_AUTH_SECRET": env.TURN_STATIC_AUTH_SECRET,
+              "REDIS_HOST": "redis",
             } + (if adminUrl != null then {
               "ADMIN_API_URL": adminUrl,
-            } else {}) + if namespace != "master" then {
-              // Absolutely ugly WorkAround to circumvent broken certificates on the K8S test cluster. Don't do this in production kids!
-              "NODE_TLS_REJECT_UNAUTHORIZED": "0"
-            }
+              "ADMIN_API_TOKEN": env.ADMIN_API_TOKEN,
+            } else {})
           },
      "pusher": {
             "replicas": 2,
             "image": "thecodingmachine/workadventure-pusher:"+tag,
             "host": {
-              "url": "pusher."+url,
-              "https": "enable"
+              "url": "pusher-"+url,
             },
             "ports": [8080],
             "env": {
               "SECRET_KEY": "tempSecretKeyNeedsToChange",
-              "ADMIN_API_TOKEN": env.ADMIN_API_TOKEN,
               "JITSI_ISS": env.JITSI_ISS,
               "JITSI_URL": env.JITSI_URL,
               "API_URL": "back1:50051,back2:50051",
               "SECRET_JITSI_KEY": env.SECRET_JITSI_KEY,
+              "FRONT_URL": "https://play-"+url
             } + (if adminUrl != null then {
               "ADMIN_API_URL": adminUrl,
-            } else {}) + if namespace != "master" then {
-              // Absolutely ugly WorkAround to circumvent broken certificates on the K8S test cluster. Don't do this in production kids!
-              "NODE_TLS_REJECT_UNAUTHORIZED": "0"
-            }
+              "ADMIN_API_TOKEN": env.ADMIN_API_TOKEN,
+              "ADMIN_SOCKETS_TOKEN": env.ADMIN_SOCKETS_TOKEN,
+            } else {})
           },
     "front": {
       "image": "thecodingmachine/workadventure-front:"+tag,
       "host": {
-        "url": "play."+url,
-        "https": "enable"
+        "url": "play-"+url,
       },
       "ports": [80],
       "env": {
-        "PUSHER_URL": "//pusher."+url,
-        "UPLOADER_URL": "//uploader."+url,
+        "PUSHER_URL": "//pusher-"+url,
+        "UPLOADER_URL": "//uploader-"+url,
         "ADMIN_URL": "//"+url,
         "JITSI_URL": env.JITSI_URL,
+        #POSTHOG
+        "POSTHOG_API_KEY": if namespace == "master" then env.POSTHOG_API_KEY else "",
+        "POSTHOG_URL": if namespace == "master" then env.POSTHOG_URL else "",
         "SECRET_JITSI_KEY": env.SECRET_JITSI_KEY,
         "TURN_SERVER": "turn:coturn.workadventu.re:443,turns:coturn.workadventu.re:443",
         "JITSI_PRIVATE_MODE": if env.SECRET_JITSI_KEY != '' then "true" else "false",
-        "START_ROOM_URL": "/_/global/maps."+url+"/Floor0/floor0.json"
-        //"GA_TRACKING_ID": "UA-10196481-11"
+        "START_ROOM_URL": "/_/global/maps-"+url+"/starter/map.json"
       }
     },
     "uploader": {
            "image": "thecodingmachine/workadventure-uploader:"+tag,
            "host": {
-             "url": "uploader."+url,
-             "https": "enable",
+             "url": "uploader-"+url,
              "containerPort": 8080
            },
            "ports": [8080],
@@ -107,16 +99,16 @@
     "maps": {
       "image": "thecodingmachine/workadventure-maps:"+tag,
       "host": {
-        "url": "maps."+url,
-        "https": "enable"
+        "url": "maps-"+url
       },
       "ports": [80]
     },
+    "redis": {
+      "image": "redis:6",
+      "ports": [6379]
+    }
   },
   "config": {
-    "https": {
-      "mail": "d.negrier@thecodingmachine.com"
-    },
     k8sextension(k8sConf)::
         k8sConf + {
           back1+: {
@@ -131,6 +123,14 @@
                   }
                 }
               }
+            },
+            ingress+: {
+              spec+: {
+                tls+: [{
+                  hosts: ["api1-"+url],
+                  secretName: "certificate-tls"
+                }]
+              }
             }
           },
           back2+: {
@@ -145,6 +145,14 @@
                   }
                 }
               }
+            },
+            ingress+: {
+              spec+: {
+                tls+: [{
+                  hosts: ["api2-"+url],
+                  secretName: "certificate-tls"
+                }]
+              }
             }
           },
           pusher+: {
@@ -159,8 +167,46 @@
                   }
                 }
               }
-            }
-          }
+            },
+            ingress+: {
+              spec+: {
+                tls+: [{
+                  hosts: ["pusher-"+url],
+                  secretName: "certificate-tls"
+                }]
+              }
+             }
+          },
+          front+: {
+            ingress+: {
+              spec+: {
+                tls+: [{
+                  hosts: ["play-"+url],
+                  secretName: "certificate-tls"
+                }]
+              }
+             }
+          },
+          uploader+: {
+            ingress+: {
+              spec+: {
+                tls+: [{
+                  hosts: ["uploader-"+url],
+                  secretName: "certificate-tls"
+                }]
+              }
+             }
+          },
+          maps+: {
+            ingress+: {
+              spec+: {
+                tls+: [{
+                  hosts: ["maps-"+url],
+                  secretName: "certificate-tls"
+                }]
+              }
+             }
+          },
         }
   }
 }

docker-compose.single-domain.yaml

@@ -28,15 +28,20 @@ services:
       NODE_ENV: development
       PUSHER_URL: /pusher
       UPLOADER_URL: /uploader
-      ADMIN_URL: /admin
+      #ADMIN_URL: /admin
       MAPS_URL: /maps
-      STARTUP_COMMAND_1: yarn install
+      ICON_URL: /icon
+      STARTUP_COMMAND_1: ./templater.sh
+      STARTUP_COMMAND_2: yarn install
       TURN_SERVER: "turn:localhost:3478,turns:localhost:5349"
+      DISABLE_NOTIFICATIONS: "$DISABLE_NOTIFICATIONS"
+      SKIP_RENDER_OPTIMIZATIONS: "$SKIP_RENDER_OPTIMIZATIONS"
       # Use TURN_USER/TURN_PASSWORD if your Coturn server is secured via hard coded credentials.
       # Advice: you should instead use Coturn REST API along the TURN_STATIC_AUTH_SECRET in the Back container
       TURN_USER: ""
       TURN_PASSWORD: ""
       START_ROOM_URL: "$START_ROOM_URL"
+      DISABLE_ANONYMOUS: "$DISABLE_ANONYMOUS"
     command: yarn run start
     volumes:
       - ./front:/usr/src/app
@@ -50,19 +55,28 @@ services:
       - "traefik.http.routers.front-ssl.service=front"
 
   pusher:
-    image: thecodingmachine/nodejs:12
+    image: thecodingmachine/nodejs:14
     command: yarn dev
     #command: yarn run prod
     #command: yarn run profile
     environment:
       DEBUG: "*"
       STARTUP_COMMAND_1: yarn install
+      # wait for files generated by "messages" container to exists
+      STARTUP_COMMAND_2: while [ ! -f /usr/src/app/src/Messages/generated/messages_pb.js ]; do sleep 1; done
       SECRET_JITSI_KEY: "$SECRET_JITSI_KEY"
       SECRET_KEY: yourSecretKey
       ADMIN_API_TOKEN: "$ADMIN_API_TOKEN"
       API_URL: back:50051
       JITSI_URL: $JITSI_URL
       JITSI_ISS: $JITSI_ISS
+      FRONT_URL: http://localhost
+      OPID_CLIENT_ID: $OPID_CLIENT_ID
+      OPID_CLIENT_SECRET: $OPID_CLIENT_SECRET
+      OPID_CLIENT_ISSUER: $OPID_CLIENT_ISSUER
+      OPID_CLIENT_REDIRECT_URL: $OPID_CLIENT_REDIRECT_URL
+      OPID_PROFILE_SCREEN_PROVIDER: $OPID_PROFILE_SCREEN_PROVIDER
+      DISABLE_ANONYMOUS: $DISABLE_ANONYMOUS
     volumes:
       - ./pusher:/usr/src/app
     labels:
@@ -110,6 +124,8 @@ services:
     environment:
       DEBUG: "*"
       STARTUP_COMMAND_1: yarn install
+      # wait for files generated by "messages" container to exists
+      STARTUP_COMMAND_2: while [ ! -f /usr/src/app/src/Messages/generated/messages_pb.js ]; do sleep 1; done
       SECRET_KEY: yourSecretKey
       SECRET_JITSI_KEY: "$SECRET_JITSI_KEY"
       ALLOW_ARTILLERY: "true"
@@ -117,6 +133,8 @@ services:
       JITSI_URL: $JITSI_URL
       JITSI_ISS: $JITSI_ISS
       MAX_PER_GROUP: "$MAX_PER_GROUP"
+      REDIS_HOST: redis
+      NODE_ENV: development
     volumes:
       - ./back:/usr/src/app
     labels:
@@ -152,23 +170,6 @@ services:
       - "traefik.http.routers.uploader-ssl.tls=true"
       - "traefik.http.routers.uploader-ssl.service=uploader"
 
-  website:
-    image: thecodingmachine/nodejs:12-apache
-    environment:
-      STARTUP_COMMAND_1: npm install
-      STARTUP_COMMAND_2: npm run watch &
-      APACHE_DOCUMENT_ROOT: dist/
-    volumes:
-      - ./website:/var/www/html
-    labels:
-      - "traefik.http.routers.website.rule=Host(`workadventure.localhost`)"
-      - "traefik.http.routers.website.entryPoints=web"
-      - "traefik.http.services.website.loadbalancer.server.port=80"
-      - "traefik.http.routers.website-ssl.rule=Host(`workadventure.localhost`)"
-      - "traefik.http.routers.website-ssl.entryPoints=websecure"
-      - "traefik.http.routers.website-ssl.tls=true"
-      - "traefik.http.routers.website-ssl.service=website"
-
   messages:
     #image: thecodingmachine/nodejs:14
     image: thecodingmachine/workadventure-back-base:latest
@@ -182,6 +183,23 @@ services:
       - ./front:/usr/src/front
       - ./pusher:/usr/src/pusher
 
+  redis:
+    image: redis:6
+
+  icon:
+    image: matthiasluedtke/iconserver:v3.13.0
+    labels:
+      - "traefik.http.middlewares.strip-icon-prefix.stripprefix.prefixes=/icon"
+      - "traefik.http.routers.icon.rule=PathPrefix(`/icon`)"
+      - "traefik.http.routers.icon.middlewares=strip-icon-prefix@docker"
+      - "traefik.http.routers.icon.entryPoints=web"
+      - "traefik.http.services.icon.loadbalancer.server.port=8080"
+      - "traefik.http.routers.icon-ssl.rule=PathPrefix(`/icon`)"
+      - "traefik.http.routers.icon-ssl.middlewares=strip-icon-prefix@docker"
+      - "traefik.http.routers.icon-ssl.entryPoints=websecure"
+      - "traefik.http.routers.icon-ssl.tls=true"
+      - "traefik.http.routers.icon-ssl.service=icon"
+
 #  coturn:
 #    image: coturn/coturn:4.5.2
 #    command:

docker-compose.testcafe.yml

@@ -0,0 +1,12 @@
+version: "3"
+services:
+  testcafe:
+    image: testcafe/testcafe:1.17.1
+    working_dir: /tests
+    environment:
+      BROWSER: "chromium --use-fake-device-for-media-stream"
+    volumes:
+      - ./tests:/tests
+      - ./maps:/maps
+  #  security_opt:
+  #    - seccomp:unconfined

docker-compose.yaml

@@ -17,6 +17,12 @@ services:
       - front
     volumes:
       - /var/run/docker.sock:/var/run/docker.sock
+    networks:
+      default:
+        aliases:
+          - 'play.workadventure.localhost'
+          - 'pusher.workadventure.localhost'
+          - 'maps.workadventure.localhost'
 
   front:
     image: thecodingmachine/nodejs:14
@@ -28,11 +34,14 @@ services:
       NODE_ENV: development
       PUSHER_URL: //pusher.workadventure.localhost
       UPLOADER_URL: //uploader.workadventure.localhost
-      ADMIN_URL: //workadventure.localhost
+      #ADMIN_URL: //workadventure.localhost
+      ICON_URL: //icon.workadventure.localhost
       STARTUP_COMMAND_1: ./templater.sh
       STARTUP_COMMAND_2: yarn install
       STUN_SERVER: "stun:stun.l.google.com:19302"
       TURN_SERVER: "turn:coturn.workadventure.localhost:3478,turns:coturn.workadventure.localhost:5349"
+      DISABLE_NOTIFICATIONS: "$DISABLE_NOTIFICATIONS"
+      SKIP_RENDER_OPTIMIZATIONS: "$SKIP_RENDER_OPTIMIZATIONS"
       # Use TURN_USER/TURN_PASSWORD if your Coturn server is secured via hard coded credentials.
       # Advice: you should instead use Coturn REST API along the TURN_STATIC_AUTH_SECRET in the Back container
       TURN_USER: ""
@@ -40,6 +49,8 @@ services:
       START_ROOM_URL: "$START_ROOM_URL"
       MAX_PER_GROUP: "$MAX_PER_GROUP"
       MAX_USERNAME_LENGTH: "$MAX_USERNAME_LENGTH"
+      DISABLE_ANONYMOUS: "$DISABLE_ANONYMOUS"
+      OPID_LOGIN_SCREEN_PROVIDER: "$OPID_LOGIN_SCREEN_PROVIDER"
     command: yarn run start
     volumes:
       - ./front:/usr/src/app
@@ -53,17 +64,26 @@ services:
       - "traefik.http.routers.front-ssl.service=front"
 
   pusher:
-    image: thecodingmachine/nodejs:12
+    image: thecodingmachine/nodejs:14
     command: yarn dev
     environment:
       DEBUG: "socket:*"
       STARTUP_COMMAND_1: yarn install
+      # wait for files generated by "messages" container to exists
+      STARTUP_COMMAND_2: while [ ! -f /usr/src/app/src/Messages/generated/messages_pb.js ]; do sleep 1; done
       SECRET_JITSI_KEY: "$SECRET_JITSI_KEY"
       SECRET_KEY: yourSecretKey
       ADMIN_API_TOKEN: "$ADMIN_API_TOKEN"
       API_URL: back:50051
       JITSI_URL: $JITSI_URL
       JITSI_ISS: $JITSI_ISS
+      FRONT_URL: http://play.workadventure.localhost
+      OPID_CLIENT_ID: $OPID_CLIENT_ID
+      OPID_CLIENT_SECRET: $OPID_CLIENT_SECRET
+      OPID_CLIENT_ISSUER: $OPID_CLIENT_ISSUER
+      OPID_CLIENT_REDIRECT_URL: $OPID_CLIENT_REDIRECT_URL
+      OPID_PROFILE_SCREEN_PROVIDER: $OPID_PROFILE_SCREEN_PROVIDER
+      DISABLE_ANONYMOUS: $DISABLE_ANONYMOUS
     volumes:
       - ./pusher:/usr/src/app
     labels:
@@ -105,6 +125,8 @@ services:
     environment:
       DEBUG: "*"
       STARTUP_COMMAND_1: yarn install
+      # wait for files generated by "messages" container to exists
+      STARTUP_COMMAND_2: while [ ! -f /usr/src/app/src/Messages/generated/messages_pb.js ]; do sleep 1; done
       SECRET_KEY: yourSecretKey
       SECRET_JITSI_KEY: "$SECRET_JITSI_KEY"
       ALLOW_ARTILLERY: "true"
@@ -113,6 +135,9 @@ services:
       JITSI_ISS: $JITSI_ISS
       TURN_STATIC_AUTH_SECRET: SomeStaticAuthSecret
       MAX_PER_GROUP: "MAX_PER_GROUP"
+      REDIS_HOST: redis
+      NODE_ENV: development
+      STORE_VARIABLES_FOR_LOCAL_MAPS: "true"
     volumes:
       - ./back:/usr/src/app
     labels:
@@ -155,6 +180,31 @@ services:
       - ./front:/usr/src/front
       - ./pusher:/usr/src/pusher
 
+  redis:
+    image: redis:6
+
+  redisinsight:
+    image: redislabs/redisinsight:latest
+    labels:
+      - "traefik.http.routers.redisinsight.rule=Host(`redis.workadventure.localhost`)"
+      - "traefik.http.routers.redisinsight.entryPoints=web"
+      - "traefik.http.services.redisinsight.loadbalancer.server.port=8001"
+      - "traefik.http.routers.redisinsight-ssl.rule=Host(`redis.workadventure.localhost`)"
+      - "traefik.http.routers.redisinsight-ssl.entryPoints=websecure"
+      - "traefik.http.routers.redisinsight-ssl.tls=true"
+      - "traefik.http.routers.redisinsight-ssl.service=redisinsight"
+
+  icon:
+    image: matthiasluedtke/iconserver:v3.13.0
+    labels:
+      - "traefik.http.routers.icon.rule=Host(`icon.workadventure.localhost`)"
+      - "traefik.http.routers.icon.entryPoints=web"
+      - "traefik.http.services.icon.loadbalancer.server.port=8080"
+      - "traefik.http.routers.icon-ssl.rule=Host(`icon.workadventure.localhost`)"
+      - "traefik.http.routers.icon-ssl.entryPoints=websecure"
+      - "traefik.http.routers.icon-ssl.tls=true"
+      - "traefik.http.routers.icon-ssl.service=icon"
+
 #  coturn:
 #    image: coturn/coturn:4.5.2
 #    command:

docs/maps/animations.md

@@ -0,0 +1,33 @@
+{.section-title.accent.text-primary}
+# Animating WorkAdventure maps
+
+A tile can run an animation in loops, for example to render water or blinking lights. Each animation frame is a single 
+32x32 tile. To create an animation, edit the tileset in Tiled and click on the tile to animate (or pick a free tile to 
+not overwrite existing ones) and click on the animation editor:
+
+
+<div class="px-5 card rounded d-inline-block">
+    <img class="document-img" src="images/anims/camera.png" alt="" />
+</div>
+
+You can now add all tiles that should be part of the animation via drag and drop to the "playlist" and adjust the frame duration:
+
+<div>
+    <figure class="figure">
+        <img class="figure-img img-fluid rounded" src="images/anims/animation_editor.png" alt="" />
+        <figcaption class="figure-caption">The tile animation editor</figcaption>
+    </figure>
+</div>
+
+You can preview animations directly in Tiled, using the "Show tile animations" option:
+
+
+<div>
+    <figure class="figure">
+        <img class="figure-img img-fluid rounded" src="images/anims/settings_show_animations.png" alt="" />
+        <figcaption class="figure-caption">The Show Tile Animations option</figcaption>
+    </figure>
+</div>
+
+{.alert.alert-info}
+**Tip:** The engine does tile-updates every 100ms, animations with a shorter frame duration will most likely not look that good or may even do not work.

docs/maps/api-chat.md

@@ -0,0 +1,37 @@
+{.section-title.accent.text-primary}
+# API Chat functions reference
+
+### Sending a message in the chat
+
+```
+WA.chat.sendChatMessage(message: string, author: string): void
+```
+
+Sends a message in the chat. The message is only visible in the browser of the current user.
+
+*   **message**: the message to be displayed in the chat
+*   **author**: the name displayed for the author of the message. It does not have to be a real user.
+
+Example:
+
+```javascript
+WA.chat.sendChatMessage('Hello world', 'Mr Robot');
+```
+
+### Listening to messages from the chat
+
+```javascript
+WA.chat.onChatMessage(callback: (message: string) => void): void
+```
+
+Listens to messages typed by the current user and calls the callback. Messages from other users in the chat cannot be listened to.
+
+*   **callback**: the function that will be called when a message is received. It contains the message typed by the user.
+
+Example:
+
+```javascript
+WA.chat.onChatMessage((message => {
+    console.log('The user typed a message', message);
+}));
+```

docs/maps/api-controls.md

@@ -0,0 +1,29 @@
+{.section-title.accent.text-primary}
+# API Controls functions Reference
+
+### Disabling / restoring controls
+
+```
+WA.controls.disablePlayerControls(): void
+WA.controls.restorePlayerControls(): void
+```
+
+These 2 methods can be used to completely disable player controls and to enable them again.
+
+When controls are disabled, the user cannot move anymore using keyboard input. This can be useful in a "First Time User Experience" part, to display an important message to a user before letting him/her move again.
+
+Example:
+
+```javascript
+WA.room.onEnterLayer('myZone').subscribe(() => {
+    WA.controls.disablePlayerControls();
+    WA.ui.openPopup("popupRectangle", 'This is an imporant message!', [{
+        label: "Got it!",
+        className: "primary",
+        callback: (popup) => {
+            WA.controls.restorePlayerControls();
+            popup.close();
+        }
+    }]);
+})
+```

docs/maps/api-deprecated.md

@@ -0,0 +1,23 @@
+{.section-title.accent.text-primary}
+# API Reference - Deprecated functions
+
+The list of functions below is **deprecated**. You should not use those but. use the replacement functions.
+
+- Method `WA.sendChatMessage` is deprecated. It has been renamed to [`WA.chat.sendChatMessage`](api-chat.md#sending-a-message-in-the-chat).
+- Method `WA.disablePlayerControls` is deprecated. It has been renamed to [`WA.controls.disablePlayerControls`](api-controls.md#disabling--restoring-controls).
+- Method `WA.restorePlayerControls` is deprecated. It has been renamed to [`WA.controls.restorePlayerControls`](api-controls.md#disabling--restoring-controls).
+- Method `WA.displayBubble` is deprecated. It has been renamed to `WA.ui.displayBubble`.
+- Method `WA.removeBubble` is deprecated. It has been renamed to `WA.ui.removeBubble`.
+- Method `WA.openTab` is deprecated. It has been renamed to [`WA.nav.openTab`](api-nav.md#opening-a-web-page-in-a-new-tab).
+- Method `WA.loadSound` is deprecated. It has been renamed to [`WA.sound.loadSound`](api-sound.md#load-a-sound-from-an-url).
+- Method `WA.goToPage` is deprecated. It has been renamed to [`WA.nav.goToPage`](api-nav.md#opening-a-web-page-in-the-current-tab).
+- Method `WA.goToRoom` is deprecated. It has been renamed to [`WA.nav.goToRoom`](api-nav.md#going-to-a-different-map-from-the-script).
+- Method `WA.openCoWebSite` is deprecated. It has been renamed to [`WA.nav.openCoWebSite`](api-nav.md#openingclosing-web-page-in-co-websites).
+- Method `WA.closeCoWebSite` is deprecated. It has been remove and [replace by a function close](api-nav.md#openingclosing-web-page-in-co-websites).
+- Method `WA.openPopup` is deprecated. It has been renamed to [`WA.ui.openPopup`](api-ui.md#opening-a-popup).
+- Method `WA.onChatMessage` is deprecated. It has been renamed to [`WA.chat.onChatMessage`](api-chat.md#listening-to-messages-from-the-chat).
+- Method `WA.onEnterZone` is deprecated. It has been renamed to [`WA.room.onEnterZone`](api-room.md#detecting-when-the-user-entersleaves-a-layer).
+- Method `WA.onLeaveZone` is deprecated. It has been renamed to [`WA.room.onLeaveZone`](api-room.md#detecting-when-the-user-entersleaves-a-layer).
+- Method `WA.ui.registerMenuCommand` parameter `callback` is deprecated. Use [`WA.ui.registerMenuCommand(commandDescriptor: string, options: MenuOptions)`](api-ui.md#add-custom-menu).
+- Method `WA.room.onEnterZone` is deprecated. Use instead [`WA.room.onEnterLayer`](api-room.md#detecting-when-the-user-entersleaves-a-layer).
+- Method `WA.room.onLeaveZone` is deprecated. Use instead [`WA.room.onLeaveLayer`](api-room.md#detecting-when-the-user-entersleaves-a-layer).

docs/maps/api-nav.md

@@ -0,0 +1,82 @@
+{.section-title.accent.text-primary}
+# API Navigation functions reference
+
+### Opening a web page in a new tab
+
+```
+WA.nav.openTab(url: string): void
+```
+
+Opens the webpage at "url" in your browser, in a new tab.
+
+Example:
+
+```javascript
+WA.nav.openTab('https://www.wikipedia.org/');
+```
+
+### Opening a web page in the current tab
+
+```
+WA.nav.goToPage(url: string): void
+```
+
+Opens the webpage at "url" in your browser in place of WorkAdventure. WorkAdventure will be completely unloaded.
+
+Example:
+
+```javascript
+WA.nav.goToPage('https://www.wikipedia.org/');
+```
+
+### Going to a different map from the script
+
+```
+
+WA.nav.goToRoom(url: string): void
+```
+
+Load the map at url without unloading workadventure
+
+relative urls: "../subFolder/map.json[#start-layer-name]"
+global urls: "/_/global/domain/path/map.json[#start-layer-name]"
+
+Example:
+
+```javascript
+WA.nav.goToRoom("/@/tcm/workadventure/floor0")  // workadventure urls
+WA.nav.goToRoom('../otherMap/map.json');
+WA.nav.goToRoom("/_/global/<path to global map>.json#start-layer-2")
+```
+
+### Opening/closing web page in Co-Websites
+
+```
+WA.nav.openCoWebSite(url: string, allowApi: boolean = false, allowPolicy: string = "", position: number = 0): Promise<CoWebsite>
+```
+
+Opens the webpage at "url" in an iFrame (on the right side of the screen) or close that iFrame. `allowApi` allows the webpage to use the "IFrame API" and execute script (it is equivalent to putting the `openWebsiteAllowApi` property in the map). `allowPolicy` grants additional access rights to the iFrame. The `allowPolicy` parameter is turned into an [`allow` feature policy in the iFrame](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#attr-allow), position in whitch slot the web page will be open.
+You can have only 5 co-wbesites open simultaneously.
+
+Example:
+
+```javascript
+const coWebsite = await WA.nav.openCoWebSite('https://www.wikipedia.org/');
+const coWebsiteWorkAdventure = await WA.nav.openCoWebSite('https://workadventu.re/', true, "", 1);
+// ...
+coWebsite.close();
+```
+
+### Get all Co-Websites
+
+```
+WA.nav.getCoWebSites(): Promise<CoWebsite[]>
+```
+
+Get all opened co-websites with their ids and positions.
+
+Example:
+
+```javascript
+const coWebsites = await WA.nav.getCowebSites();
+```

docs/maps/api-player.md

@@ -0,0 +1,80 @@
+{.section-title.accent.text-primary}
+# API Player functions Reference
+
+### Get the player name
+
+```
+WA.player.name: string;
+```
+
+The player name is available from the `WA.player.name` property.
+
+{.alert.alert-info}
+You need to wait for the end of the initialization before accessing `WA.player.name`
+
+```typescript
+WA.onInit().then(() => {
+    console.log('Player name: ', WA.player.name);
+})
+```
+
+### Get the player ID
+
+```
+WA.player.id: string|undefined;
+```
+
+The player ID is available from the `WA.player.id` property.
+This is a unique identifier for a given player. Anonymous player might not have an id.
+
+{.alert.alert-info}
+You need to wait for the end of the initialization before accessing `WA.player.id`
+
+```typescript
+WA.onInit().then(() => {
+    console.log('Player ID: ', WA.player.id);
+})
+```
+
+### Get the tags of the player
+
+```
+WA.player.tags: string[];
+```
+
+The player tags are available from the `WA.player.tags` property.
+They represent a set of rights the player acquires after login in.
+
+{.alert.alert-warn}
+Tags attributed to a user depend on the authentication system you are using. For the hosted version
+of WorkAdventure, you can define tags related to the user in the [administration panel](https://workadventu.re/admin-guide/manage-members).
+
+{.alert.alert-info}
+You need to wait for the end of the initialization before accessing `WA.player.tags`
+
+```typescript
+WA.onInit().then(() => {
+    console.log('Tags: ', WA.player.tags);
+})
+```
+
+### Listen to player movement
+```
+WA.player.onPlayerMove(callback: HasPlayerMovedEventCallback): void;
+```
+Listens to the movement of the current user and calls the callback. Sends an event when the user stops moving, changes direction and every 200ms when moving in the same direction.
+
+The event has the following attributes :
+*   **moving (boolean):**  **true** when the current player is moving, **false** otherwise.
+*   **direction (string):** **"right"** | **"left"** | **"down"** | **"top"** the direction where the current player is moving.
+*   **x (number):** coordinate X of the current player.
+*   **y (number):** coordinate Y of the current player.
+*   **oldX (number):** old coordinate X of the current player.
+*   **oldY (number):** old coordinate Y of the current player.
+
+**callback:** the function that will be called when the current player is moving. It contains the event.
+
+Example :
+```javascript
+WA.player.onPlayerMove(console.log);
+```

docs/maps/api-reference.md

@@ -0,0 +1,14 @@
+{.section-title.accent.text-primary}
+# API Reference
+
+- [Start / Init functions](api-start.md)
+- [Navigation functions](api-nav.md)
+- [Chat functions](api-chat.md)
+- [Room functions](api-room.md)
+- [State related functions](api-state.md)
+- [Player functions](api-player.md)
+- [UI functions](api-ui.md)
+- [Sound functions](api-sound.md)
+- [Controls functions](api-controls.md)
+
+- [List of deprecated functions](api-deprecated.md)