Merge branch 'gamestate-api-read' of github.com:jonnytest1/workadventure into metadataScriptingApi

front/src/Api/Events/DataLayerEvent.ts

@@ -0,0 +1,16 @@
+import * as tg from "generic-type-guard";
+
+
+
+export const isHasDataLayerChangedEvent =
+    new tg.IsInterface().withProperties({
+        data: tg.isObject
+    }).get();
+
+/**
+ * A message sent from the game to the iFrame when the data of the layers change after the iFrame send a message to the game that it want to listen to the data of the layers
+ */
+export type DataLayerEvent = tg.GuardedType<typeof isHasDataLayerChangedEvent>;
+
+
+export type HasDataLayerChangedEventCallback = (event: DataLayerEvent) => void

front/src/Api/Events/GameStateEvent.ts

@@ -0,0 +1,27 @@
+import * as tg from "generic-type-guard";
+
+/*export const isPositionState = new tg.IsInterface().withProperties({
+    x: tg.isNumber,
+    y: tg.isNumber
+}).get()
+export const isPlayerState = new tg.IsInterface()
+    .withStringIndexSignature(
+        new tg.IsInterface().withProperties({
+            position: isPositionState,
+            pusherId: tg.isUnion(tg.isNumber, tg.isUndefined)
+        }).get()
+    ).get()
+
+export type PlayerStateObject = tg.GuardedType<typeof isPlayerState>;*/
+
+export const isGameStateEvent =
+    new tg.IsInterface().withProperties({
+        roomId: tg.isString,
+        mapUrl: tg.isString,
+        uuid: tg.isUnion(tg.isString, tg.isUndefined),
+        startLayerName: tg.isUnion(tg.isString, tg.isNull)
+    }).get();
+/**
+ * A message sent from the game to the iFrame when the gameState is got by the script
+ */
+export type GameStateEvent = tg.GuardedType<typeof isGameStateEvent>;

front/src/Api/Events/HasPlayerMovedEvent.ts

@@ -0,0 +1,19 @@
+import * as tg from "generic-type-guard";
+
+
+
+export const isHasPlayerMovedEvent =
+    new tg.IsInterface().withProperties({
+        direction: tg.isString,
+        moving: tg.isBoolean,
+        x: tg.isNumber,
+        y: tg.isNumber
+    }).get();
+
+/**
+ * A message sent from the game to the iFrame when the player move after the iFrame send a message to the game that it want to listen to the position of the player
+ */
+export type HasPlayerMovedEvent = tg.GuardedType<typeof isHasPlayerMovedEvent>;
+
+
+export type HasPlayerMovedEventCallback = (event: HasPlayerMovedEvent) => void

front/src/Api/Events/IframeEvent.ts

@@ -1,24 +1,25 @@
 
-
+import type { GameStateEvent } from './GameStateEvent';
 import type { ButtonClickedEvent } from './ButtonClickedEvent';
 import type { ChatEvent } from './ChatEvent';
 import type { ClosePopupEvent } from './ClosePopupEvent';
 import type { EnterLeaveEvent } from './EnterLeaveEvent';
 import type { GoToPageEvent } from './GoToPageEvent';
+import type { HasPlayerMovedEvent } from './HasPlayerMovedEvent';
 import type { OpenCoWebSiteEvent } from './OpenCoWebSiteEvent';
 import type { OpenPopupEvent } from './OpenPopupEvent';
 import type { OpenTabEvent } from './OpenTabEvent';
 import type { UserInputChatEvent } from './UserInputChatEvent';
+import type { HasDataLayerChangedEvent } from "./HasDataLayerChangedEvent";
 import type { LayerEvent } from './LayerEvent';
 import type { SetPropertyEvent } from "./setPropertyEvent";
 
-
 export interface TypedMessageEvent<T> extends MessageEvent {
     data: T
 }
 
 export type IframeEventMap = {
-    //getState: GameStateEvent,
+    getState: GameStateEvent,
     // updateTile: UpdateTileEvent
     chat: ChatEvent,
     openPopup: OpenPopupEvent
@@ -31,6 +32,8 @@ export type IframeEventMap = {
     restorePlayerControls: null
     displayBubble: null
     removeBubble: null
+    onPlayerMove: undefined
+    onDataLayerChange: undefined
     showLayer: LayerEvent
     hideLayer: LayerEvent
     setProperty: SetPropertyEvent
@@ -49,7 +52,9 @@ export interface IframeResponseEventMap {
     enterEvent: EnterLeaveEvent
     leaveEvent: EnterLeaveEvent
     buttonClickedEvent: ButtonClickedEvent
-    // gameState: GameStateEvent
+    gameState: GameStateEvent
+    hasPlayerMoved: HasPlayerMovedEvent
+    hasDataLayerChanged: HasDataLayerChangedEvent
 }
 export interface IframeResponseEvent<T extends keyof IframeResponseEventMap> {
     type: T;

front/src/Api/IframeListener.ts

@@ -13,6 +13,12 @@ import { IframeEventMap, IframeEvent, IframeResponseEvent, IframeResponseEventMa
 import type { UserInputChatEvent } from "./Events/UserInputChatEvent";
 import { isLayerEvent, LayerEvent } from "./Events/LayerEvent";
 import { isSetPropertyEvent, SetPropertyEvent} from "./Events/setPropertyEvent";
+import { GameStateEvent } from './Events/GameStateEvent';
+import { deepFreezeClone as deepFreezeClone } from '../utility';
+import { HasPlayerMovedEvent } from './Events/HasPlayerMovedEvent';
+import { Math } from 'phaser';
+import { HasDataLayerChangedEvent } from "./Events/HasDataLayerChangedEvent";
+
 
 
 /**
@@ -20,6 +26,7 @@ import { isSetPropertyEvent, SetPropertyEvent} from "./Events/setPropertyEvent";
  * Also allows to send messages to those iframes.
  */
 class IframeListener {
+
     private readonly _chatStream: Subject<ChatEvent> = new Subject();
     public readonly chatStream = this._chatStream.asObservable();
 
@@ -62,8 +69,14 @@ class IframeListener {
     private readonly _setPropertyStream: Subject<SetPropertyEvent> = new Subject();
     public readonly setPropertyStream = this._setPropertyStream.asObservable();
 
+    private readonly _gameStateStream: Subject<void> = new Subject();
+    public readonly gameStateStream = this._gameStateStream.asObservable();
+
+
     private readonly iframes = new Set<HTMLIFrameElement>();
     private readonly scripts = new Map<string, HTMLIFrameElement>();
+    private sendPlayerMove: boolean = false;
+    private sendDataLayerChange: boolean = false;
 
     init() {
         window.addEventListener("message", (message: TypedMessageEvent<IframeEvent<keyof IframeEventMap>>) => {
@@ -117,12 +130,16 @@ class IframeListener {
                 }
                 else if (payload.type === 'restorePlayerControls') {
                     this._enablePlayerControlStream.next();
-                }
-                else if (payload.type === 'displayBubble') {
+                } else if (payload.type === 'displayBubble') {
                     this._displayBubbleStream.next();
-                }
-                else if (payload.type === 'removeBubble') {
+                } else if (payload.type === 'removeBubble') {
                     this._removeBubbleStream.next();
+                } else if (payload.type == "getState") {
+                    this._gameStateStream.next();
+                } else if (payload.type == "onPlayerMove") {
+                    this.sendPlayerMove = true
+                } else if (payload.type == "onDataLayerChange") {
+                    this.sendDataLayerChange = true
                 }
             }
 
@@ -131,6 +148,14 @@ class IframeListener {
 
     }
 
+
+    sendFrozenGameStateEvent(gameStateEvent: GameStateEvent) {
+        this.postMessage({
+            'type': 'gameState',
+            'data': gameStateEvent //deepFreezeClone(gameStateEvent)
+        });
+    }
+
     /**
      * Allows the passed iFrame to send/receive messages via the API.
      */
@@ -234,6 +259,24 @@ class IframeListener {
         });
     }
 
+    hasPlayerMoved(event: HasPlayerMovedEvent) {
+        if (this.sendPlayerMove) {
+            this.postMessage({
+                'type': 'hasPlayerMoved',
+                'data': event
+            });
+        }
+    }
+
+    hasDataLayerChanged(event: HasDataLayerChangedEvent) {
+        if (this.sendDataLayerChange) {
+            this.postMessage({
+                'type' : 'hasDataLayerChanged',
+                'data' : event
+            });
+        }
+    }
+
     sendButtonClickedEvent(popupId: number, buttonId: number): void {
         this.postMessage({
             'type': 'buttonClickedEvent',