🆙 Init V3

src/api/nitro/room/DispatchMouseEvent.ts

@@ -0,0 +1,54 @@
+import { GetRoomEngine, MouseEventType } from '@nitrots/nitro-renderer';
+
+let didMouseMove = false;
+let lastClick = 0;
+let clickCount = 0;
+
+export const DispatchMouseEvent = (event: MouseEvent, canvasId: number = 1) =>
+{
+    const x = event.clientX;
+    const y = event.clientY;
+
+    let eventType = event.type;
+
+    if(eventType === MouseEventType.MOUSE_CLICK)
+    {
+        if(lastClick)
+        {
+            clickCount = 1;
+
+            if(lastClick >= Date.now() - 300) clickCount++;
+        }
+
+        lastClick = Date.now();
+
+        if(clickCount === 2)
+        {
+            if(!didMouseMove) eventType = MouseEventType.DOUBLE_CLICK;
+
+            clickCount = 0;
+            lastClick = null;
+        }
+    }
+
+    switch(eventType)
+    {
+        case MouseEventType.MOUSE_CLICK:
+            break;
+        case MouseEventType.DOUBLE_CLICK:
+            break;
+        case MouseEventType.MOUSE_MOVE:
+            didMouseMove = true;
+            break;
+        case MouseEventType.MOUSE_DOWN:
+            didMouseMove = false;
+            break;
+        case MouseEventType.MOUSE_UP:
+            break;
+        case MouseEventType.RIGHT_CLICK:
+            break;
+        default: return;
+    }
+
+    GetRoomEngine().dispatchMouseEvent(canvasId, x, y, eventType, event.altKey, (event.ctrlKey || event.metaKey), event.shiftKey, false);
+};

src/api/nitro/room/DispatchTouchEvent.ts

@@ -0,0 +1,81 @@
+import { GetRoomEngine, MouseEventType, TouchEventType } from '@nitrots/nitro-renderer';
+
+let didMouseMove = false;
+let lastClick = 0;
+let clickCount = 0;
+
+export const DispatchTouchEvent = (event: TouchEvent, canvasId: number = 1, longTouch: boolean = false, altKey: boolean = false, ctrlKey: boolean = false, shiftKey: boolean = false) =>
+{
+    let x = 0;
+    let y = 0;
+
+    if(event.touches[0])
+    {
+        x = event.touches[0].clientX;
+        y = event.touches[0].clientY;
+    }
+
+    else if(event.changedTouches[0])
+    {
+        x = event.changedTouches[0].clientX;
+        y = event.changedTouches[0].clientY;
+    }
+
+    let eventType = event.type;
+
+    if(longTouch) eventType = TouchEventType.TOUCH_LONG;
+
+    if(eventType === MouseEventType.MOUSE_CLICK || eventType === TouchEventType.TOUCH_END)
+    {
+        eventType = MouseEventType.MOUSE_CLICK;
+
+        if(lastClick)
+        {
+            clickCount = 1;
+
+            if(lastClick >= (Date.now() - 300)) clickCount++;
+        }
+
+        lastClick = Date.now();
+
+        if(clickCount === 2)
+        {
+            if(!didMouseMove) eventType = MouseEventType.DOUBLE_CLICK;
+
+            clickCount = 0;
+            lastClick = null;
+        }
+    }
+
+    switch(eventType)
+    {
+        case MouseEventType.MOUSE_CLICK:
+            break;
+        case MouseEventType.DOUBLE_CLICK:
+            break;
+        case TouchEventType.TOUCH_START:
+            eventType = MouseEventType.MOUSE_DOWN;
+
+            didMouseMove = false;
+            break;
+        case TouchEventType.TOUCH_MOVE:
+            eventType = MouseEventType.MOUSE_MOVE;
+
+            didMouseMove = true;
+            break;
+        case TouchEventType.TOUCH_END:
+            eventType = MouseEventType.MOUSE_UP;
+            break;
+        case TouchEventType.TOUCH_LONG:
+            eventType = MouseEventType.MOUSE_DOWN_LONG;
+            break;
+        default: return;
+    }
+
+    if(eventType === TouchEventType.TOUCH_START)
+    {
+        GetRoomEngine().dispatchMouseEvent(canvasId, x, y, eventType, altKey, ctrlKey, shiftKey, false);
+    }
+
+    GetRoomEngine().dispatchMouseEvent(canvasId, x, y, eventType, altKey, ctrlKey, shiftKey, false);
+};

src/api/nitro/room/GetOwnRoomObject.ts

@@ -0,0 +1,31 @@
+import { GetRoomEngine, GetSessionDataManager, IRoomObjectController, RoomObjectCategory } from '@nitrots/nitro-renderer';
+import { GetRoomSession } from '../session';
+
+export function GetOwnRoomObject(): IRoomObjectController
+{
+    const userId = GetSessionDataManager().userId;
+    const roomId = GetRoomEngine().activeRoomId;
+    const category = RoomObjectCategory.UNIT;
+    const totalObjects = GetRoomEngine().getTotalObjectsForManager(roomId, category);
+
+    let i = 0;
+
+    while(i < totalObjects)
+    {
+        const roomObject = GetRoomEngine().getRoomObjectByIndex(roomId, i, category);
+
+        if(roomObject)
+        {
+            const userData = GetRoomSession().userDataManager.getUserDataByIndex(roomObject.id);
+
+            if(userData)
+            {
+                if(userData.webID === userId) return roomObject;
+            }
+        }
+
+        i++;
+    }
+
+    return null;
+}

src/api/nitro/room/GetRoomObjectBounds.ts

@@ -0,0 +1,13 @@
+import { GetRoomEngine } from '@nitrots/nitro-renderer';
+
+export const GetRoomObjectBounds = (roomId: number, objectId: number, category: number, canvasId = 1) =>
+{
+    const rectangle = GetRoomEngine().getRoomObjectBoundingRectangle(roomId, objectId, category, canvasId);
+
+    if(!rectangle) return null;
+
+    rectangle.x = Math.round(rectangle.x);
+    rectangle.y = Math.round(rectangle.y);
+
+    return rectangle;
+};

src/api/nitro/room/GetRoomObjectScreenLocation.ts

@@ -0,0 +1,13 @@
+import { GetRoomEngine } from '@nitrots/nitro-renderer';
+
+export const GetRoomObjectScreenLocation = (roomId: number, objectId: number, category: number, canvasId = 1) =>
+{
+    const point = GetRoomEngine().getRoomObjectScreenLocation(roomId, objectId, category, canvasId);
+
+    if(!point) return null;
+
+    point.x = Math.round(point.x);
+    point.y = Math.round(point.y);
+
+    return point;
+};

src/api/nitro/room/InitializeRoomInstanceRenderingCanvas.ts

@@ -0,0 +1,9 @@
+import { GetRoomEngine } from '@nitrots/nitro-renderer';
+
+export const InitializeRoomInstanceRenderingCanvas = (width: number, height: number, canvasId: number = 1) =>
+{
+    const roomEngine = GetRoomEngine();
+    const roomId = roomEngine.activeRoomId;
+
+    roomEngine.initializeRoomInstanceRenderingCanvas(roomId, canvasId, width, height);
+};

src/api/nitro/room/IsFurnitureSelectionDisabled.ts

@@ -0,0 +1,22 @@
+import { GetRoomEngine, GetSessionDataManager, RoomEngineObjectEvent, RoomObjectVariable } from '@nitrots/nitro-renderer';
+
+export function IsFurnitureSelectionDisabled(event: RoomEngineObjectEvent): boolean
+{
+    let result = false;
+
+    const roomObject = GetRoomEngine().getRoomObject(event.roomId, event.objectId, event.category);
+
+    if(roomObject)
+    {
+        const selectionDisabled = (roomObject.model.getValue<number>(RoomObjectVariable.FURNITURE_SELECTION_DISABLED) === 1);
+
+        if(selectionDisabled)
+        {
+            result = true;
+
+            if(GetSessionDataManager().isModerator) result = false;
+        }
+    }
+
+    return result;
+}

src/api/nitro/room/ProcessRoomObjectOperation.ts

@@ -0,0 +1,6 @@
+import { GetRoomEngine } from '@nitrots/nitro-renderer';
+
+export function ProcessRoomObjectOperation(objectId: number, category: number, operation: string): void
+{
+    GetRoomEngine().processRoomObjectOperation(objectId, category, operation);
+}

src/api/nitro/room/SetActiveRoomId.ts

@@ -0,0 +1,6 @@
+import { GetRoomEngine } from '@nitrots/nitro-renderer';
+
+export function SetActiveRoomId(roomId: number): void
+{
+    GetRoomEngine().setActiveRoomId(roomId);
+}

src/api/nitro/room/index.ts

@@ -0,0 +1,9 @@
+export * from './DispatchMouseEvent';
+export * from './DispatchTouchEvent';
+export * from './GetOwnRoomObject';
+export * from './GetRoomObjectBounds';
+export * from './GetRoomObjectScreenLocation';
+export * from './InitializeRoomInstanceRenderingCanvas';
+export * from './IsFurnitureSelectionDisabled';
+export * from './ProcessRoomObjectOperation';
+export * from './SetActiveRoomId';