🆙 Init V3

src/api/nitro/GetConfigurationValue.ts

@@ -0,0 +1,6 @@
+import { GetConfiguration } from '@nitrots/nitro-renderer';
+
+export function GetConfigurationValue<T = string>(key: string, value: T = null): T
+{
+    return GetConfiguration().getValue(key, value);
+}

src/api/nitro/OpenUrl.ts

@@ -0,0 +1,15 @@
+import { CreateLinkEvent, HabboWebTools } from '@nitrots/nitro-renderer';
+
+export const OpenUrl = (url: string) =>
+{
+    if(!url || !url.length) return;
+
+    if(url.startsWith('http'))
+    {
+        HabboWebTools.openWebPage(url);
+    }
+    else
+    {
+        CreateLinkEvent(url);
+    }
+};

src/api/nitro/SendMessageComposer.ts

@@ -0,0 +1,3 @@
+import { GetCommunication, IMessageComposer } from '@nitrots/nitro-renderer';
+
+export const SendMessageComposer = (event: IMessageComposer<unknown[]>) => GetCommunication().connection.send(event);

src/api/nitro/index.ts

@@ -0,0 +1,5 @@
+export * from './GetConfigurationValue';
+export * from './OpenUrl';
+export * from './SendMessageComposer';
+export * from './room';
+export * from './session';

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';

src/api/nitro/session/CanManipulateFurniture.ts

@@ -0,0 +1,9 @@
+import { GetRoomEngine, GetSessionDataManager, IRoomSession, RoomControllerLevel } from '@nitrots/nitro-renderer';
+import { IsOwnerOfFurniture } from './IsOwnerOfFurniture';
+
+export function CanManipulateFurniture(roomSession: IRoomSession, objectId: number, category: number): boolean
+{
+    if(!roomSession) return false;
+
+    return (roomSession.isRoomOwner || (roomSession.controllerLevel >= RoomControllerLevel.GUEST) || GetSessionDataManager().isModerator || IsOwnerOfFurniture(GetRoomEngine().getRoomObject(roomSession.roomId, objectId, category)));
+}

src/api/nitro/session/CreateRoomSession.ts

@@ -0,0 +1,6 @@
+import { GetRoomSessionManager } from '@nitrots/nitro-renderer';
+
+export function CreateRoomSession(roomId: number, password: string = null): void
+{
+    GetRoomSessionManager().createSession(roomId, password);
+}

src/api/nitro/session/GetCanStandUp.ts

@@ -0,0 +1,13 @@
+import { AvatarAction, RoomObjectVariable } from '@nitrots/nitro-renderer';
+import { GetOwnRoomObject } from '../room';
+
+export function GetCanStandUp(): string
+{
+    const roomObject = GetOwnRoomObject();
+
+    if(!roomObject) return AvatarAction.POSTURE_STAND;
+
+    const model = roomObject.model;
+
+    return model.getValue<string>(RoomObjectVariable.FIGURE_CAN_STAND_UP);
+}

src/api/nitro/session/GetCanUseExpression.ts

@@ -0,0 +1,14 @@
+import { RoomObjectVariable } from '@nitrots/nitro-renderer';
+import { GetOwnRoomObject } from '../room';
+
+export function GetCanUseExpression(): boolean
+{
+    const roomObject = GetOwnRoomObject();
+
+    if(!roomObject) return false;
+
+    const model = roomObject.model;
+    const effectId = model.getValue<number>(RoomObjectVariable.FIGURE_EFFECT);
+
+    return !((effectId === 29) || (effectId === 30) || (effectId === 185));
+}

src/api/nitro/session/GetClubMemberLevel.ts

@@ -0,0 +1,9 @@
+import { GetSessionDataManager, HabboClubLevelEnum } from '@nitrots/nitro-renderer';
+import { GetConfigurationValue } from '../GetConfigurationValue';
+
+export function GetClubMemberLevel(): number
+{
+    if(GetConfigurationValue<boolean>('hc.disabled', false)) return HabboClubLevelEnum.VIP;
+
+    return GetSessionDataManager().clubLevel;
+}

src/api/nitro/session/GetFurnitureData.ts

@@ -0,0 +1,19 @@
+import { GetSessionDataManager, IFurnitureData } from '@nitrots/nitro-renderer';
+import { ProductTypeEnum } from '../../catalog';
+
+export function GetFurnitureData(furniClassId: number, productType: string): IFurnitureData
+{
+    let furniData: IFurnitureData = null;
+
+    switch(productType.toLowerCase())
+    {
+        case ProductTypeEnum.FLOOR:
+            furniData = GetSessionDataManager().getFloorItemData(furniClassId);
+            break;
+        case ProductTypeEnum.WALL:
+            furniData = GetSessionDataManager().getWallItemData(furniClassId);
+            break;
+    }
+
+    return furniData;
+}

src/api/nitro/session/GetFurnitureDataForProductOffer.ts

@@ -0,0 +1,20 @@
+import { CatalogPageMessageProductData, FurnitureType, GetSessionDataManager, IFurnitureData } from '@nitrots/nitro-renderer';
+
+export function GetFurnitureDataForProductOffer(offer: CatalogPageMessageProductData): IFurnitureData
+{
+    if (!offer) return null;
+
+    let furniData: IFurnitureData = null;
+
+    switch ((offer.productType) as FurnitureType)
+    {
+        case FurnitureType.FLOOR:
+            furniData = GetSessionDataManager().getFloorItemData(offer.furniClassId);
+            break;
+        case FurnitureType.WALL:
+            furniData = GetSessionDataManager().getWallItemData(offer.furniClassId);
+            break;
+    }
+
+    return furniData;
+}

src/api/nitro/session/GetFurnitureDataForRoomObject.ts

@@ -0,0 +1,20 @@
+import { GetRoomEngine, GetSessionDataManager, IFurnitureData, RoomObjectCategory, RoomObjectVariable } from '@nitrots/nitro-renderer';
+
+export function GetFurnitureDataForRoomObject(roomId: number, objectId: number, category: number): IFurnitureData
+{
+    const roomObject = GetRoomEngine().getRoomObject(roomId, objectId, category);
+
+    if(!roomObject) return;
+
+    const typeId = roomObject.model.getValue<number>(RoomObjectVariable.FURNITURE_TYPE_ID);
+
+    switch(category)
+    {
+        case RoomObjectCategory.FLOOR:
+            return GetSessionDataManager().getFloorItemData(typeId);
+        case RoomObjectCategory.WALL:
+            return GetSessionDataManager().getWallItemData(typeId);
+    }
+
+    return null;
+}

src/api/nitro/session/GetOwnPosture.ts

@@ -0,0 +1,13 @@
+import { AvatarAction, RoomObjectVariable } from '@nitrots/nitro-renderer';
+import { GetOwnRoomObject } from '../room';
+
+export function GetOwnPosture(): string
+{
+    const roomObject = GetOwnRoomObject();
+
+    if(!roomObject) return AvatarAction.POSTURE_STAND;
+
+    const model = roomObject.model;
+
+    return model.getValue<string>(RoomObjectVariable.FIGURE_POSTURE);
+}

src/api/nitro/session/GetProductDataForLocalization.ts

@@ -0,0 +1,8 @@
+import { GetSessionDataManager, IProductData } from '@nitrots/nitro-renderer';
+
+export function GetProductDataForLocalization(localizationId: string): IProductData
+{
+    if(!localizationId) return null;
+
+    return GetSessionDataManager().getProductData(localizationId);
+}

src/api/nitro/session/GetRoomSession.ts

@@ -0,0 +1,3 @@
+import { GetRoomSessionManager } from '@nitrots/nitro-renderer';
+
+export const GetRoomSession = () => GetRoomSessionManager().getSession(-1);

src/api/nitro/session/GoToDesktop.ts

@@ -0,0 +1,7 @@
+import { DesktopViewComposer } from '@nitrots/nitro-renderer';
+import { SendMessageComposer } from '../SendMessageComposer';
+
+export function GoToDesktop(): void
+{
+    SendMessageComposer(new DesktopViewComposer());
+}

src/api/nitro/session/HasHabboClub.ts

@@ -0,0 +1,6 @@
+import { GetSessionDataManager, HabboClubLevelEnum } from '@nitrots/nitro-renderer';
+
+export function HasHabboClub(): boolean
+{
+    return (GetSessionDataManager().clubLevel >= HabboClubLevelEnum.CLUB);
+}

src/api/nitro/session/HasHabboVip.ts

@@ -0,0 +1,6 @@
+import { GetSessionDataManager, HabboClubLevelEnum } from '@nitrots/nitro-renderer';
+
+export function HasHabboVip(): boolean
+{
+    return (GetSessionDataManager().clubLevel >= HabboClubLevelEnum.VIP);
+}

src/api/nitro/session/IsOwnerOfFloorFurniture.ts

@@ -0,0 +1,14 @@
+import { GetRoomEngine, GetSessionDataManager, RoomObjectCategory, RoomObjectVariable } from '@nitrots/nitro-renderer';
+import { GetRoomSession } from './GetRoomSession';
+
+export function IsOwnerOfFloorFurniture(id: number): boolean
+{
+    const roomObject = GetRoomEngine().getRoomObject(GetRoomSession().roomId, id, RoomObjectCategory.FLOOR);
+
+    if(!roomObject || !roomObject.model) return false;
+
+    const userId = GetSessionDataManager().userId;
+    const objectOwnerId = roomObject.model.getValue<number>(RoomObjectVariable.FURNITURE_OWNER_ID);
+
+    return (userId === objectOwnerId);
+}

src/api/nitro/session/IsOwnerOfFurniture.ts

@@ -0,0 +1,11 @@
+import { GetSessionDataManager, IRoomObject, RoomObjectVariable } from '@nitrots/nitro-renderer';
+
+export function IsOwnerOfFurniture(roomObject: IRoomObject): boolean
+{
+    if(!roomObject || !roomObject.model) return false;
+
+    const userId = GetSessionDataManager().userId;
+    const objectOwnerId = roomObject.model.getValue<number>(RoomObjectVariable.FURNITURE_OWNER_ID);
+
+    return (userId === objectOwnerId);
+}

src/api/nitro/session/IsRidingHorse.ts

@@ -0,0 +1,14 @@
+import { RoomObjectVariable } from '@nitrots/nitro-renderer';
+import { GetOwnRoomObject } from '../room';
+
+export function IsRidingHorse(): boolean
+{
+    const roomObject = GetOwnRoomObject();
+
+    if(!roomObject) return false;
+
+    const model = roomObject.model;
+    const effectId = model.getValue<number>(RoomObjectVariable.FIGURE_EFFECT);
+
+    return (effectId === 77);
+}

src/api/nitro/session/StartRoomSession.ts

@@ -0,0 +1,6 @@
+import { GetRoomSessionManager, IRoomSession } from '@nitrots/nitro-renderer';
+
+export function StartRoomSession(session: IRoomSession): void
+{
+    GetRoomSessionManager().startSession(session);
+}

src/api/nitro/session/VisitDesktop.ts

@@ -0,0 +1,11 @@
+import { GetRoomSessionManager } from '@nitrots/nitro-renderer';
+import { GetRoomSession } from './GetRoomSession';
+import { GoToDesktop } from './GoToDesktop';
+
+export const VisitDesktop = () =>
+{
+    if(!GetRoomSession()) return;
+
+    GoToDesktop();
+    GetRoomSessionManager().removeSession(-1);
+};

src/api/nitro/session/index.ts

@@ -0,0 +1,19 @@
+export * from './CanManipulateFurniture';
+export * from './CreateRoomSession';
+export * from './GetCanStandUp';
+export * from './GetCanUseExpression';
+export * from './GetClubMemberLevel';
+export * from './GetFurnitureData';
+export * from './GetFurnitureDataForProductOffer';
+export * from './GetFurnitureDataForRoomObject';
+export * from './GetOwnPosture';
+export * from './GetProductDataForLocalization';
+export * from './GetRoomSession';
+export * from './GoToDesktop';
+export * from './HasHabboClub';
+export * from './HasHabboVip';
+export * from './IsOwnerOfFloorFurniture';
+export * from './IsOwnerOfFurniture';
+export * from './IsRidingHorse';
+export * from './StartRoomSession';
+export * from './VisitDesktop';