Adding a Pusher container as a middleware/dispatcher between front and back

pusher/src/Model/Websocket/ExSocketInterface.ts

@@ -0,0 +1,42 @@
+import {PointInterface} from "./PointInterface";
+import {Identificable} from "./Identificable";
+import {ViewportInterface} from "_Model/Websocket/ViewportMessage";
+import {
+    BatchMessage,
+    PusherToBackMessage,
+    ServerToClientMessage,
+    SubMessage
+} from "../../Messages/generated/messages_pb";
+import {WebSocket} from "uWebSockets.js"
+import {CharacterTexture} from "../../Services/AdminApi";
+import {ClientDuplexStream} from "grpc";
+import {Zone} from "_Model/Zone";
+
+export type BackConnection = ClientDuplexStream<PusherToBackMessage, ServerToClientMessage>;
+
+export interface CharacterLayer {
+    name: string,
+    url: string|undefined
+}
+
+export interface ExSocketInterface extends WebSocket, Identificable {
+    token: string;
+    roomId: string;
+    //userId: number;   // A temporary (autoincremented) identifier for this user
+    userUuid: string; // A unique identifier for this user
+    name: string;
+    characterLayers: CharacterLayer[];
+    position: PointInterface;
+    viewport: ViewportInterface;
+    /**
+     * Pushes an event that will be sent in the next batch of events
+     */
+    emitInBatch: (payload: SubMessage) => void;
+    batchedMessages: BatchMessage;
+    batchTimeout: NodeJS.Timeout|null;
+    disconnecting: boolean,
+    tags: string[],
+    textures: CharacterTexture[],
+    backConnection: BackConnection,
+    listenedZones: Set<Zone>;
+}

pusher/src/Model/Websocket/GroupUpdateInterface.ts

@@ -0,0 +1,6 @@
+import {PositionInterface} from "_Model/PositionInterface";
+
+export interface GroupUpdateInterface {
+    position: PositionInterface,
+    groupId: number,
+}

pusher/src/Model/Websocket/Identificable.ts

@@ -0,0 +1,3 @@
+export interface Identificable {
+    userId: number;
+}

pusher/src/Model/Websocket/ItemEventMessage.ts

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

pusher/src/Model/Websocket/JoinRoomMessage.ts

@@ -0,0 +1,11 @@
+import * as tg from "generic-type-guard";
+import {isPointInterface} from "./PointInterface";
+import {isViewport} from "./ViewportMessage";
+
+export const isJoinRoomMessageInterface =
+    new tg.IsInterface().withProperties({
+        roomId: tg.isString,
+        position: isPointInterface,
+        viewport: isViewport
+    }).get();
+export type JoinRoomMessageInterface = tg.GuardedType<typeof isJoinRoomMessageInterface>;

pusher/src/Model/Websocket/MessageUserJoined.ts

@@ -0,0 +1,6 @@
+import {PointInterface} from "_Model/Websocket/PointInterface";
+
+export class MessageUserJoined {
+    constructor(public userId: number, public name: string, public characterLayers: string[], public position: PointInterface) {
+    }
+}

pusher/src/Model/Websocket/MessageUserPosition.ts

@@ -0,0 +1,11 @@
+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 MessageUserPosition {
+    constructor(public userId: number, public name: string, public characterLayers: string[], public position: PointInterface) {
+    }
+}

pusher/src/Model/Websocket/PointInterface.ts

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

pusher/src/Model/Websocket/ProtobufUtils.ts

@@ -0,0 +1,108 @@
+import {PointInterface} from "./PointInterface";
+import {
+    CharacterLayerMessage,
+    ItemEventMessage,
+    PointMessage,
+    PositionMessage
+} from "../../Messages/generated/messages_pb";
+import {CharacterLayer, ExSocketInterface} from "_Model/Websocket/ExSocketInterface";
+import Direction = PositionMessage.Direction;
+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':
+                direction = Direction.UP;
+                break;
+            case 'down':
+                direction = Direction.DOWN;
+                break;
+            case 'left':
+                direction = Direction.LEFT;
+                break;
+            case 'right':
+                direction = Direction.RIGHT;
+                break;
+            default:
+                throw new Error('unexpected direction');
+        }
+
+        const position = new PositionMessage();
+        position.setX(point.x);
+        position.setY(point.y);
+        position.setMoving(point.moving);
+        position.setDirection(direction);
+
+        return position;
+    }
+
+    public static toPointInterface(position: PositionMessage): PointInterface {
+        let direction: string;
+        switch (position.getDirection()) {
+            case Direction.UP:
+                direction = 'up';
+                break;
+            case Direction.DOWN:
+                direction = 'down';
+                break;
+            case Direction.LEFT:
+                direction = 'left';
+                break;
+            case Direction.RIGHT:
+                direction = 'right';
+                break;
+            default:
+                throw new Error("Unexpected direction");
+        }
+
+        // sending to all clients in room except sender
+        return {
+            x: position.getX(),
+            y: position.getY(),
+            direction,
+            moving: position.getMoving(),
+        };
+    }
+
+    public static toPointMessage(point: PositionInterface): PointMessage {
+        const position = new PointMessage();
+        position.setX(Math.floor(point.x));
+        position.setY(Math.floor(point.y));
+
+        return position;
+    }
+
+    public static toItemEvent(itemEventMessage: ItemEventMessage): ItemEventMessageInterface {
+        return {
+            itemId: itemEventMessage.getItemid(),
+            event: itemEventMessage.getEvent(),
+            parameters: JSON.parse(itemEventMessage.getParametersjson()),
+            state: JSON.parse(itemEventMessage.getStatejson()),
+        }
+    }
+
+    public static toItemEventProtobuf(itemEvent: ItemEventMessageInterface): ItemEventMessage {
+        const itemEventMessage = new ItemEventMessage();
+        itemEventMessage.setItemid(itemEvent.itemId);
+        itemEventMessage.setEvent(itemEvent.event);
+        itemEventMessage.setParametersjson(JSON.stringify(itemEvent.parameters));
+        itemEventMessage.setStatejson(JSON.stringify(itemEvent.state));
+
+        return itemEventMessage;
+    }
+
+    public static toCharacterLayerMessages(characterLayers: CharacterLayer[]): CharacterLayerMessage[] {
+        return characterLayers.map(function(characterLayer): CharacterLayerMessage {
+            const message = new CharacterLayerMessage();
+            message.setName(characterLayer.name);
+            if (characterLayer.url) {
+                message.setUrl(characterLayer.url);
+            }
+            return message;
+        });
+    }
+}

pusher/src/Model/Websocket/SetPlayerDetailsMessage.ts

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

pusher/src/Model/Websocket/UserInGroupInterface.ts

@@ -0,0 +1,5 @@
+export interface UserInGroupInterface {
+    userId: number,
+    name: string,
+    initiator: boolean
+}

pusher/src/Model/Websocket/ViewportMessage.ts

@@ -0,0 +1,10 @@
+import * as tg from "generic-type-guard";
+
+export const isViewport =
+    new tg.IsInterface().withProperties({
+        left: tg.isNumber,
+        top: tg.isNumber,
+        right: tg.isNumber,
+        bottom: tg.isNumber,
+    }).get();
+export type ViewportInterface = tg.GuardedType<typeof isViewport>;

pusher/src/Model/Websocket/WebRtcSignalMessage.ts

@@ -0,0 +1,18 @@
+import * as tg from "generic-type-guard";
+
+export const isSignalData =
+    new tg.IsInterface().withProperties({
+        type: tg.isOptional(tg.isString)
+    }).get();
+
+export const isWebRtcSignalMessageInterface =
+    new tg.IsInterface().withProperties({
+        receiverId: tg.isNumber,
+        signal: isSignalData
+    }).get();
+export const isWebRtcScreenSharingStartMessageInterface =
+    new tg.IsInterface().withProperties({
+        userId: tg.isNumber,
+        roomId: tg.isString
+    }).get();
+export type WebRtcSignalMessageInterface = tg.GuardedType<typeof isWebRtcSignalMessageInterface>;