Public texture (#1093)

* Public texture

 - Front => Get texture when user connected on public method
 - Front => Anonymous login will be make every connexion to get map details
 - Pusher => `/anonymLogin` permit to get map details and public texture load in customize scene

* Improve texture local user

- Permit to keep previous texture get with 'register' link

* Texture public loading

 - Texture will be load with Room class
 - Fix issue on lazzy loading atttempt

* Remove async await useless

front/src/Connexion/ConnectionManager.ts

@@ -4,7 +4,7 @@ import {RoomConnection} from "./RoomConnection";
 import type {OnConnectInterface, PositionInterface, ViewportInterface} from "./ConnexionModels";
 import {GameConnexionTypes, urlManager} from "../Url/UrlManager";
 import {localUserStore} from "./LocalUserStore";
-import {LocalUser} from "./LocalUser";
+import {CharacterTexture, LocalUser} from "./LocalUser";
 import {Room} from "./Room";
 
 
@@ -46,8 +46,8 @@ class ConnectionManager {
             urlManager.pushRoomIdToUrl(room);
             return Promise.resolve(room);
         } else if (connexionType === GameConnexionTypes.organization || connexionType === GameConnexionTypes.anonymous || connexionType === GameConnexionTypes.empty) {
-            const localUser = localUserStore.getLocalUser();
 
+            let localUser = localUserStore.getLocalUser();
             if (localUser && localUser.jwtToken && localUser.uuid && localUser.textures) {
                 this.localUser = localUser;
                 try {
@@ -57,16 +57,42 @@ class ConnectionManager {
                     console.error('JWT token invalid. Did it expire? Login anonymously instead.');
                     await this.anonymousLogin();
                 }
-            } else {
+            }else{
                 await this.anonymousLogin();
             }
-            let roomId: string
+
+            localUser = localUserStore.getLocalUser();
+            if(!localUser){
+                throw "Error to store local user data";
+            }
+
+            let roomId: string;
             if (connexionType === GameConnexionTypes.empty) {
                 roomId = START_ROOM_URL;
             } else {
                 roomId = window.location.pathname + window.location.search + window.location.hash;
             }
-            return Promise.resolve(new Room(roomId));
+
+            //get detail map for anonymous login and set texture in local storage
+            const room = new Room(roomId);
+            const mapDetail = await room.getMapDetail();
+            if(mapDetail.textures != undefined && mapDetail.textures.length > 0) {
+                //check if texture was changed
+                if(localUser.textures.length === 0){
+                    localUser.textures = mapDetail.textures;
+                }else{
+                    mapDetail.textures.forEach((newTexture) => {
+                        const alreadyExistTexture = localUser?.textures.find((c) => newTexture.id === c.id);
+                        if(localUser?.textures.findIndex((c) => newTexture.id === c.id) !== -1){
+                            return;
+                        }
+                        localUser?.textures.push(newTexture)
+                    });
+                }
+                this.localUser = localUser;
+                localUserStore.saveUser(localUser);
+            }
+            return Promise.resolve(room);
         }
 
         return Promise.reject(new Error('Invalid URL'));

front/src/Connexion/LocalUser.ts

@@ -24,6 +24,6 @@ export function areCharacterLayersValid(value: string[] | null): boolean {
 }
 
 export class LocalUser {
-    constructor(public readonly uuid:string, public readonly jwtToken: string, public readonly textures: CharacterTexture[]) {
+    constructor(public readonly uuid:string, public readonly jwtToken: string, public textures: CharacterTexture[]) {
     }
 }

front/src/Connexion/Room.ts

@@ -1,10 +1,17 @@
 import Axios from "axios";
 import {PUSHER_URL} from "../Enum/EnvironmentVariable";
+import type {CharacterTexture} from "./LocalUser";
+
+export class MapDetail{
+    constructor(public readonly mapUrl: string, public readonly textures : CharacterTexture[]|undefined) {
+    }
+}
 
 export class Room {
     public readonly id: string;
     public readonly isPublic: boolean;
     private mapUrl: string|undefined;
+    private textures: CharacterTexture[]|undefined;
     private instance: string|undefined;
     private _search: URLSearchParams;
 
@@ -50,10 +57,10 @@ export class Room {
         return {roomId, hash}
     }
 
-    public async getMapUrl(): Promise<string> {
-        return new Promise<string>((resolve, reject) => {
-            if (this.mapUrl !== undefined) {
-                resolve(this.mapUrl);
+    public async getMapDetail(): Promise<MapDetail> {
+        return new Promise<MapDetail>((resolve, reject) => {
+            if (this.mapUrl !== undefined && this.textures != undefined) {
+                resolve(new MapDetail(this.mapUrl, this.textures));
                 return;
             }
 
@@ -61,7 +68,7 @@ export class Room {
                 const match = /_\/[^/]+\/(.+)/.exec(this.id);
                 if (!match) throw new Error('Could not extract url from "'+this.id+'"');
                 this.mapUrl = window.location.protocol+'//'+match[1];
-                resolve(this.mapUrl);
+                resolve(new MapDetail(this.mapUrl, this.textures));
                 return;
             } else {
                 // We have a private ID, we need to query the map URL from the server.
@@ -71,7 +78,7 @@ export class Room {
                     params: urlParts
                 }).then(({data}) => {
                     console.log('Map ', this.id, ' resolves to URL ', data.mapUrl);
-                    resolve(data.mapUrl);
+                    resolve(data);
                     return;
                 }).catch((reason) => {
                     reject(reason);

front/src/Phaser/Game/GameManager.ts

@@ -78,11 +78,11 @@ export class GameManager {
 
     public async loadMap(room: Room, scenePlugin: Phaser.Scenes.ScenePlugin): Promise<void> {
         const roomID = room.id;
-        const mapUrl = await room.getMapUrl();
+        const mapDetail = await room.getMapDetail();
 
         const gameIndex = scenePlugin.getIndex(roomID);
         if(gameIndex === -1){
-            const game : Phaser.Scene = new GameScene(room, mapUrl);
+            const game : Phaser.Scene = new GameScene(room, mapDetail.mapUrl);
             scenePlugin.add(roomID, game, false);
         }
     }

front/src/Phaser/Login/CustomizeScene.ts

@@ -29,6 +29,8 @@ export class CustomizeScene extends AbstractCharacterScene {
     public activeRow:number = 0;
     private layers: BodyResourceDescriptionInterface[][] = [];
 
+    protected lazyloadingAttempt = true; //permit to update texture loaded after renderer
+
     constructor() {
         super({
             key: CustomizeSceneName
@@ -38,7 +40,6 @@ export class CustomizeScene extends AbstractCharacterScene {
     preload() {
         this.load.html(customizeSceneKey, 'resources/html/CustomCharacterScene.html');
 
-        this.layers = loadAllLayers(this.load);
         this.loadCustomSceneSelectCharacters().then((bodyResourceDescriptions) => {
             bodyResourceDescriptions.forEach((bodyResourceDescription) => {
                 if(bodyResourceDescription.level == undefined || bodyResourceDescription.level < 0 || bodyResourceDescription.level > 5 ){
@@ -46,8 +47,13 @@ export class CustomizeScene extends AbstractCharacterScene {
                 }
                 this.layers[bodyResourceDescription.level].unshift(bodyResourceDescription);
             });
+            this.lazyloadingAttempt = true;
         });
 
+        this.layers = loadAllLayers(this.load);
+        this.lazyloadingAttempt = false;
+
+
         //this function must stay at the end of preload function
         addLoader(this);
     }
@@ -222,6 +228,14 @@ export class CustomizeScene extends AbstractCharacterScene {
         }
     }
 
+    update(time: number, delta: number): void {
+
+        if(this.lazyloadingAttempt){
+            this.moveLayers();
+            this.lazyloadingAttempt = false;
+        }
+    }
+
      public onResize(): void {
         this.moveLayers();
 

front/src/Phaser/Login/SelectCharacterScene.ts

@@ -33,6 +33,8 @@ export class SelectCharacterScene extends AbstractCharacterScene {
     protected currentSelectUser = 0;
     protected pointerClicked: boolean = false;
 
+    protected lazyloadingAttempt = true; //permit to update texture loaded after renderer
+
     constructor() {
         super({
             key: SelectCharacterSceneName,
@@ -46,8 +48,10 @@ export class SelectCharacterScene extends AbstractCharacterScene {
             bodyResourceDescriptions.forEach((bodyResourceDescription) => {
                 this.playerModels.push(bodyResourceDescription);
             });
-        })
+            this.lazyloadingAttempt = true;
+        });
         this.playerModels = loadAllDefaultModels(this.load);
+        this.lazyloadingAttempt = false;
 
         //this function must stay at the end of preload function
         addLoader(this);
@@ -238,6 +242,13 @@ export class SelectCharacterScene extends AbstractCharacterScene {
         localUserStore.setPlayerCharacterIndex(this.currentSelectUser);
     }
 
+    update(time: number, delta: number): void {
+        if(this.lazyloadingAttempt){
+            this.createCurrentPlayer();
+            this.lazyloadingAttempt = false;
+        }
+    }
+
     public onResize(): void {
         //move position of user
         this.moveUser();

pusher/src/Controller/AuthenticateController.ts

@@ -110,12 +110,10 @@ export class AuthenticateController extends BaseController {
     private anonymLogin(){
         this.App.options("/anonymLogin", (res: HttpResponse, req: HttpRequest) => {
             this.addCorsHeaders(res);
-
             res.end();
         });
 
-        this.App.post("/anonymLogin", (res: HttpResponse, req: HttpRequest) => {
-
+        this.App.post("/anonymLogin", (res: HttpResponse, req: HttpRequest) => {           
             res.onAborted(() => {
                 console.warn('Login request was aborted');
             })