🆙 Init V3

src/api/catalog/BuilderFurniPlaceableStatus.ts

@@ -0,0 +1,10 @@
+export class BuilderFurniPlaceableStatus
+{
+    public static OKAY: number = 0;
+    public static MISSING_OFFER: number = 1;
+    public static FURNI_LIMIT_REACHED: number = 2;
+    public static NOT_IN_ROOM: number = 3;
+    public static NOT_ROOM_OWNER: number = 4;
+    public static GUILD_ROOM: number = 5;
+    public static VISITORS_IN_ROOM: number = 6;
+}

src/api/catalog/CatalogNode.ts

@@ -0,0 +1,124 @@
+import { NodeData } from '@nitrots/nitro-renderer';
+import { ICatalogNode } from './ICatalogNode';
+
+export class CatalogNode implements ICatalogNode
+{
+    private _depth: number = 0;
+    private _localization: string = '';
+    private _pageId: number = -1;
+    private _pageName: string = '';
+    private _iconId: number = 0;
+    private _children: ICatalogNode[];
+    private _offerIds: number[];
+    private _parent: ICatalogNode;
+    private _isVisible: boolean;
+    private _isActive: boolean;
+    private _isOpen: boolean;
+
+    constructor(node: NodeData, depth: number, parent: ICatalogNode)
+    {
+        this._depth = depth;
+        this._parent = parent;
+        this._localization = node.localization;
+        this._pageId = node.pageId;
+        this._pageName = node.pageName;
+        this._iconId = node.icon;
+        this._children = [];
+        this._offerIds = node.offerIds;
+        this._isVisible = node.visible;
+        this._isActive = false;
+        this._isOpen = false;
+    }
+
+    public activate(): void
+    {
+        this._isActive = true;
+    }
+
+    public deactivate(): void
+    {
+        this._isActive = false;
+    }
+
+    public open(): void
+    {
+        this._isOpen = true;
+    }
+
+    public close(): void
+    {
+        this._isOpen = false;
+    }
+
+    public addChild(child: ICatalogNode):void
+    {
+        if(!child) return;
+
+        this._children.push(child);
+    }
+
+    public get depth(): number
+    {
+        return this._depth;
+    }
+
+    public get isBranch(): boolean
+    {
+        return (this._children.length > 0);
+    }
+
+    public get isLeaf(): boolean
+    {
+        return (this._children.length === 0);
+    }
+
+    public get localization(): string
+    {
+        return this._localization;
+    }
+
+    public get pageId(): number
+    {
+        return this._pageId;
+    }
+
+    public get pageName(): string
+    {
+        return this._pageName;
+    }
+
+    public get iconId(): number
+    {
+        return this._iconId;
+    }
+
+    public get children(): ICatalogNode[]
+    {
+        return this._children;
+    }
+
+    public get offerIds(): number[]
+    {
+        return this._offerIds;
+    }
+
+    public get parent(): ICatalogNode
+    {
+        return this._parent;
+    }
+
+    public get isVisible(): boolean
+    {
+        return this._isVisible;
+    }
+
+    public get isActive(): boolean
+    {
+        return this._isActive;
+    }
+
+    public get isOpen(): boolean
+    {
+        return this._isOpen;
+    }
+}

src/api/catalog/CatalogPage.ts

@@ -0,0 +1,59 @@
+import { ICatalogPage } from './ICatalogPage';
+import { IPageLocalization } from './IPageLocalization';
+import { IPurchasableOffer } from './IPurchasableOffer';
+
+export class CatalogPage implements ICatalogPage
+{
+    public static MODE_NORMAL: number = 0;
+
+    private _pageId: number;
+    private _layoutCode: string;
+    private _localization: IPageLocalization;
+    private _offers: IPurchasableOffer[];
+    private _acceptSeasonCurrencyAsCredits: boolean;
+    private _mode: number;
+
+    constructor(pageId: number, layoutCode: string, localization: IPageLocalization, offers: IPurchasableOffer[], acceptSeasonCurrencyAsCredits: boolean, mode: number = -1)
+    {
+        this._pageId = pageId;
+        this._layoutCode = layoutCode;
+        this._localization = localization;
+        this._offers = offers;
+        this._acceptSeasonCurrencyAsCredits = acceptSeasonCurrencyAsCredits;
+
+        for(const offer of offers) (offer.page = this);
+
+        if(mode === -1) this._mode = CatalogPage.MODE_NORMAL;
+        else this._mode = mode;
+    }
+
+    public get pageId(): number
+    {
+        return this._pageId;
+    }
+
+    public get layoutCode(): string
+    {
+        return this._layoutCode;
+    }
+
+    public get localization(): IPageLocalization
+    {
+        return this._localization;
+    }
+
+    public get offers(): IPurchasableOffer[]
+    {
+        return this._offers;
+    }
+
+    public get acceptSeasonCurrencyAsCredits(): boolean
+    {
+        return this._acceptSeasonCurrencyAsCredits;
+    }
+
+    public get mode(): number
+    {
+        return this._mode;
+    }
+}

src/api/catalog/CatalogPageName.ts

@@ -0,0 +1,26 @@
+export class CatalogPageName
+{
+    public static DUCKET_INFO: string = 'ducket_info';
+    public static CREDITS: string = 'credits';
+    public static AVATAR_EFFECTS: string = 'avatar_effects';
+    public static HC_MEMBERSHIP: string = 'hc_membership';
+    public static CLUB_GIFTS: string = 'club_gifts';
+    public static LIMITED_SOLD: string = 'limited_sold';
+    public static PET_ACCESSORIES: string = 'pet_accessories';
+    public static TRAX_SONGS: string = 'trax_songs';
+    public static NEW_ADDITIONS: string = 'new_additions';
+    public static QUEST_SHELL: string = 'quest_shell';
+    public static QUEST_SNOWFLAKES: string = 'quest_snowflakes';
+    public static VAL_QUESTS: string = 'val_quests';
+    public static GUILD_CUSTOM_FURNI: string = 'guild_custom_furni';
+    public static GIFT_SHOP: string = 'gift_shop';
+    public static HORSE_STYLES: string = 'horse_styles';
+    public static HORSE_SHOE: string = 'horse_shoe';
+    public static SET_EASTER: string = 'set_easter';
+    public static ECOTRON_TRANSFORM: string = 'ecotron_transform';
+    public static LOYALTY_INFO: string = 'loyalty_info';
+    public static ROOM_BUNDLES: string = 'room_bundles';
+    public static ROOM_BUNDLES_MOBILE: string = 'room_bundles_mobile';
+    public static HABBO_CLUB_DESKTOP: string = 'habbo_club_desktop';
+    public static MOBILE_SUBSCRIPTIONS: string = 'mobile_subscriptions';
+}

src/api/catalog/CatalogPetPalette.ts

@@ -0,0 +1,10 @@
+import { SellablePetPaletteData } from '@nitrots/nitro-renderer';
+
+export class CatalogPetPalette
+{
+    constructor(
+        public readonly breed: string,
+        public readonly palettes: SellablePetPaletteData[]
+    )
+    {}
+}

src/api/catalog/CatalogPurchaseState.ts

@@ -0,0 +1,10 @@
+export class CatalogPurchaseState
+{
+    public static NONE = 0;
+    public static CONFIRM = 1;
+    public static PURCHASE = 2;
+    public static NO_CREDITS = 3;
+    public static NO_POINTS = 4;
+    public static SOLD_OUT = 5;
+    public static FAILED = 6;
+}

src/api/catalog/CatalogType.ts

@@ -0,0 +1,5 @@
+export class CatalogType
+{
+    public static NORMAL: string = 'NORMAL';
+    public static BUILDER: string = 'BUILDERS_CLUB';
+}

src/api/catalog/CatalogUtilities.ts

@@ -0,0 +1,124 @@
+import { GetRoomEngine, SellablePetPaletteData } from '@nitrots/nitro-renderer';
+import { ICatalogNode } from './ICatalogNode';
+
+export const GetPixelEffectIcon = (id: number) =>
+{
+    return '';
+};
+
+export const GetSubscriptionProductIcon = (id: number) =>
+{
+    return '';
+};
+
+export const GetOfferNodes = (offerNodes: Map<number, ICatalogNode[]>, offerId: number) =>
+{
+    const nodes = offerNodes.get(offerId);
+    const allowedNodes: ICatalogNode[] = [];
+
+    if(nodes && nodes.length)
+    {
+        for(const node of nodes)
+        {
+            if(!node.isVisible) continue;
+
+            allowedNodes.push(node);
+        }
+    }
+
+    return allowedNodes;
+};
+
+export const FilterCatalogNode = (search: string, furniLines: string[], node: ICatalogNode, nodes: ICatalogNode[]) =>
+{
+    if(node.isVisible && (node.pageId > 0))
+    {
+        let nodeAdded = false;
+
+        const hayStack = [ node.pageName, node.localization ].join(' ').toLowerCase().replace(/ /gi, '');
+
+        if(hayStack.indexOf(search) > -1)
+        {
+            nodes.push(node);
+
+            nodeAdded = true;
+        }
+
+        if(!nodeAdded)
+        {
+            for(const furniLine of furniLines)
+            {
+                if(hayStack.indexOf(furniLine) >= 0)
+                {
+                    nodes.push(node);
+
+                    break;
+                }
+            }
+        }
+    }
+
+    for(const child of node.children) FilterCatalogNode(search, furniLines, child, nodes);
+};
+
+export function GetPetIndexFromLocalization(localization: string)
+{
+    if(!localization.length) return 0;
+
+    let index = (localization.length - 1);
+
+    while(index >= 0)
+    {
+        if(isNaN(parseInt(localization.charAt(index)))) break;
+
+        index--;
+    }
+
+    if(index > 0) return parseInt(localization.substring(index + 1));
+
+    return -1;
+}
+
+export function GetPetAvailableColors(petIndex: number, palettes: SellablePetPaletteData[]): number[][]
+{
+    switch(petIndex)
+    {
+        case 0:
+            return [ [ 16743226 ], [ 16750435 ], [ 16764339 ], [ 0xF59500 ], [ 16498012 ], [ 16704690 ], [ 0xEDD400 ], [ 16115545 ], [ 16513201 ], [ 8694111 ], [ 11585939 ], [ 14413767 ], [ 6664599 ], [ 9553845 ], [ 12971486 ], [ 8358322 ], [ 10002885 ], [ 13292268 ], [ 10780600 ], [ 12623573 ], [ 14403561 ], [ 12418717 ], [ 14327229 ], [ 15517403 ], [ 14515069 ], [ 15764368 ], [ 16366271 ], [ 0xABABAB ], [ 0xD4D4D4 ], [ 0xFFFFFF ], [ 14256481 ], [ 14656129 ], [ 15848130 ], [ 14005087 ], [ 14337152 ], [ 15918540 ], [ 15118118 ], [ 15531929 ], [ 9764857 ], [ 11258085 ] ];
+        case 1:
+            return [ [ 16743226 ], [ 16750435 ], [ 16764339 ], [ 0xF59500 ], [ 16498012 ], [ 16704690 ], [ 0xEDD400 ], [ 16115545 ], [ 16513201 ], [ 8694111 ], [ 11585939 ], [ 14413767 ], [ 6664599 ], [ 9553845 ], [ 12971486 ], [ 8358322 ], [ 10002885 ], [ 13292268 ], [ 10780600 ], [ 12623573 ], [ 14403561 ], [ 12418717 ], [ 14327229 ], [ 15517403 ], [ 14515069 ], [ 15764368 ], [ 16366271 ], [ 0xABABAB ], [ 0xD4D4D4 ], [ 0xFFFFFF ], [ 14256481 ], [ 14656129 ], [ 15848130 ], [ 14005087 ], [ 14337152 ], [ 15918540 ], [ 15118118 ], [ 15531929 ], [ 9764857 ], [ 11258085 ] ];
+        case 2:
+            return [ [ 16579283 ], [ 15378351 ], [ 8830016 ], [ 15257125 ], [ 9340985 ], [ 8949607 ], [ 6198292 ], [ 8703620 ], [ 9889626 ], [ 8972045 ], [ 12161285 ], [ 13162269 ], [ 8620113 ], [ 12616503 ], [ 8628101 ], [ 0xD2FF00 ], [ 9764857 ] ];
+        case 3:
+            return [ [ 0xFFFFFF ], [ 0xEEEEEE ], [ 0xDDDDDD ] ];
+        case 4:
+            return [ [ 0xFFFFFF ], [ 16053490 ], [ 15464440 ], [ 16248792 ], [ 15396319 ], [ 15007487 ] ];
+        case 5:
+            return [ [ 0xFFFFFF ], [ 0xEEEEEE ], [ 0xDDDDDD ] ];
+        case 6:
+            return [ [ 0xFFFFFF ], [ 0xEEEEEE ], [ 0xDDDDDD ], [ 16767177 ], [ 16770205 ], [ 16751331 ] ];
+        case 7:
+            return [ [ 0xCCCCCC ], [ 0xAEAEAE ], [ 16751331 ], [ 10149119 ], [ 16763290 ], [ 16743786 ] ];
+        default: {
+            const colors: number[][] = [];
+
+            for(const palette of palettes)
+            {
+                const petColorResult = GetRoomEngine().getPetColorResult(petIndex, palette.paletteId);
+
+                if(!petColorResult) continue;
+
+                if(petColorResult.primaryColor === petColorResult.secondaryColor)
+                {
+                    colors.push([ petColorResult.primaryColor ]);
+                }
+                else
+                {
+                    colors.push([ petColorResult.primaryColor, petColorResult.secondaryColor ]);
+                }
+            }
+
+            return colors;
+        }
+    }
+}

src/api/catalog/FurnitureOffer.ts

@@ -0,0 +1,120 @@
+import { GetProductOfferComposer, IFurnitureData } from '@nitrots/nitro-renderer';
+import { GetProductDataForLocalization, SendMessageComposer } from '../nitro';
+import { ICatalogPage } from './ICatalogPage';
+import { IProduct } from './IProduct';
+import { IPurchasableOffer } from './IPurchasableOffer';
+import { Offer } from './Offer';
+import { Product } from './Product';
+
+export class FurnitureOffer implements IPurchasableOffer
+{
+    private _furniData:IFurnitureData;
+    private _page: ICatalogPage;
+    private _product: IProduct;
+
+    constructor(furniData: IFurnitureData)
+    {
+        this._furniData = furniData;
+        this._product = (new Product(this._furniData.type, this._furniData.id, this._furniData.customParams, 1, GetProductDataForLocalization(this._furniData.className), this._furniData) as IProduct);
+    }
+
+    public activate(): void
+    {
+        SendMessageComposer(new GetProductOfferComposer((this._furniData.rentOfferId > -1) ? this._furniData.rentOfferId : this._furniData.purchaseOfferId));
+    }
+
+    public get offerId(): number
+    {
+        return (this.isRentOffer) ? this._furniData.rentOfferId : this._furniData.purchaseOfferId;
+    }
+
+    public get priceInActivityPoints(): number
+    {
+        return 0;
+    }
+
+    public get activityPointType(): number
+    {
+        return 0;
+    }
+
+    public get priceInCredits(): number
+    {
+        return 0;
+    }
+
+    public get page(): ICatalogPage
+    {
+        return this._page;
+    }
+
+    public set page(page: ICatalogPage)
+    {
+        this._page = page;
+    }
+
+    public get priceType(): string
+    {
+        return '';
+    }
+
+    public get product(): IProduct
+    {
+        return this._product;
+    }
+
+    public get products(): IProduct[]
+    {
+        return [ this._product ];
+    }
+
+    public get localizationId(): string
+    {
+        return 'roomItem.name.' + this._furniData.id;
+    }
+
+    public get bundlePurchaseAllowed(): boolean
+    {
+        return false;
+    }
+
+    public get isRentOffer(): boolean
+    {
+        return (this._furniData.rentOfferId > -1);
+    }
+
+    public get giftable(): boolean
+    {
+        return false;
+    }
+
+    public get pricingModel(): string
+    {
+        return Offer.PRICING_MODEL_FURNITURE;
+    }
+
+    public get clubLevel(): number
+    {
+        return 0;
+    }
+
+    public get badgeCode(): string
+    {
+        return '';
+    }
+
+    public get localizationName(): string
+    {
+        return this._furniData.name;
+    }
+
+    public get localizationDescription(): string
+    {
+        return this._furniData.description;
+    }
+
+    public get isLazy(): boolean
+    {
+        return true;
+    }
+}

src/api/catalog/GetImageIconUrlForProduct.ts

@@ -0,0 +1,19 @@
+import { GetRoomEngine } from '@nitrots/nitro-renderer';
+import { ProductTypeEnum } from './ProductTypeEnum';
+
+export const GetImageIconUrlForProduct = (productType: string, productClassId: number, extraData: string = null) =>
+{
+    let imageUrl: string = null;
+
+    switch(productType.toLocaleLowerCase())
+    {
+        case ProductTypeEnum.FLOOR:
+            imageUrl = GetRoomEngine().getFurnitureFloorIconUrl(productClassId);
+            break;
+        case ProductTypeEnum.WALL:
+            imageUrl = GetRoomEngine().getFurnitureWallIconUrl(productClassId, extraData);
+            break;
+    }
+
+    return imageUrl;
+};

src/api/catalog/GiftWrappingConfiguration.ts

@@ -0,0 +1,51 @@
+import { GiftWrappingConfigurationParser } from '@nitrots/nitro-renderer';
+
+export class GiftWrappingConfiguration
+{
+    private _isEnabled: boolean = false;
+    private _price: number = null;
+    private _stuffTypes: number[] = null;
+    private _boxTypes: number[] = null;
+    private _ribbonTypes: number[] = null;
+    private _defaultStuffTypes: number[] = null;
+
+    constructor(parser: GiftWrappingConfigurationParser)
+    {
+        this._isEnabled = parser.isEnabled;
+        this._price = parser.price;
+        this._boxTypes = parser.boxTypes;
+        this._ribbonTypes = parser.ribbonTypes;
+        this._stuffTypes = parser.giftWrappers;
+        this._defaultStuffTypes = parser.giftFurnis;
+    }
+
+    public get isEnabled(): boolean
+    {
+        return this._isEnabled;
+    }
+
+    public get price(): number
+    {
+        return this._price;
+    }
+
+    public get stuffTypes(): number[]
+    {
+        return this._stuffTypes;
+    }
+
+    public get boxTypes(): number[]
+    {
+        return this._boxTypes;
+    }
+
+    public get ribbonTypes(): number[]
+    {
+        return this._ribbonTypes;
+    }
+
+    public get defaultStuffTypes(): number[]
+    {
+        return this._defaultStuffTypes;
+    }
+}

src/api/catalog/ICatalogNode.ts

@@ -0,0 +1,21 @@
+export interface ICatalogNode
+{
+    activate(): void;
+    deactivate(): void;
+    open(): void;
+    close(): void;
+    addChild(node: ICatalogNode): void;
+    readonly depth: number;
+    readonly isBranch: boolean;
+    readonly isLeaf: boolean;
+    readonly localization: string;
+    readonly pageId: number;
+    readonly pageName: string;
+    readonly iconId: number;
+    readonly children: ICatalogNode[];
+    readonly offerIds: number[];
+    readonly parent: ICatalogNode;
+    readonly isVisible: boolean;
+    readonly isActive: boolean;
+    readonly isOpen: boolean;
+}

src/api/catalog/ICatalogOptions.ts

@@ -0,0 +1,13 @@
+import { ClubGiftInfoParser, ClubOfferData, HabboGroupEntryData, MarketplaceConfigurationMessageParser } from '@nitrots/nitro-renderer';
+import { CatalogPetPalette } from './CatalogPetPalette';
+import { GiftWrappingConfiguration } from './GiftWrappingConfiguration';
+
+export interface ICatalogOptions
+{
+    groups?: HabboGroupEntryData[];
+    petPalettes?: CatalogPetPalette[];
+    clubOffers?: ClubOfferData[];
+    clubGifts?: ClubGiftInfoParser;
+    giftConfiguration?: GiftWrappingConfiguration;
+    marketplaceConfiguration?: MarketplaceConfigurationMessageParser;
+}

src/api/catalog/ICatalogPage.ts

@@ -0,0 +1,12 @@
+import { IPageLocalization } from './IPageLocalization';
+import { IPurchasableOffer } from './IPurchasableOffer';
+
+export interface ICatalogPage
+{
+    readonly pageId: number;
+    readonly layoutCode: string;
+    readonly localization: IPageLocalization;
+    readonly offers: IPurchasableOffer[];
+    readonly acceptSeasonCurrencyAsCredits: boolean;
+    readonly mode: number;
+}

src/api/catalog/IMarketplaceSearchOptions.ts

@@ -0,0 +1,7 @@
+export interface IMarketplaceSearchOptions
+{
+    query: string;
+    type: number;
+    minPrice: number;
+    maxPrice: number;
+}

src/api/catalog/IPageLocalization.ts

@@ -0,0 +1,5 @@
+export interface IPageLocalization
+{
+    getText(index: number): string
+    getImage(index: number): string
+}

src/api/catalog/IProduct.ts

@@ -0,0 +1,16 @@
+import { IFurnitureData, IProductData } from '@nitrots/nitro-renderer';
+import { IPurchasableOffer } from './IPurchasableOffer';
+
+export interface IProduct
+{
+    getIconUrl(offer?: IPurchasableOffer): string;
+    productType: string;
+    productClassId: number;
+    extraParam: string;
+    productCount: number;
+    productData: IProductData;
+    furnitureData: IFurnitureData;
+    isUniqueLimitedItem: boolean;
+    uniqueLimitedItemSeriesSize: number;
+    uniqueLimitedItemsLeft: number;
+}

src/api/catalog/IPurchasableOffer.ts

@@ -0,0 +1,25 @@
+import { ICatalogPage } from './ICatalogPage';
+import { IProduct } from './IProduct';
+
+export interface IPurchasableOffer
+{
+    activate(): void;
+    clubLevel: number;
+    page: ICatalogPage;
+    offerId: number;
+    localizationId: string;
+    priceInCredits: number;
+    priceInActivityPoints: number;
+    activityPointType: number;
+    giftable: boolean;
+    product: IProduct;
+    pricingModel: string;
+    priceType: string;
+    bundlePurchaseAllowed: boolean;
+    isRentOffer: boolean;
+    badgeCode: string;
+    localizationName: string;
+    localizationDescription: string;
+    isLazy: boolean;
+    products: IProduct[];
+}

src/api/catalog/IPurchaseOptions.ts

@@ -0,0 +1,9 @@
+import { IObjectData } from '@nitrots/nitro-renderer';
+
+export interface IPurchaseOptions
+{
+    quantity?: number;
+    extraData?: string;
+    extraParamRequired?: boolean;
+    previewStuffData?: IObjectData;
+}

src/api/catalog/MarketplaceOfferData.ts

@@ -0,0 +1,128 @@
+import { IObjectData } from '@nitrots/nitro-renderer';
+
+export class MarketplaceOfferData
+{
+    public static readonly TYPE_FLOOR: number = 1;
+    public static readonly TYPE_WALL: number = 2;
+
+    private _offerId: number;
+    private _furniId: number;
+    private _furniType: number;
+    private _extraData: string;
+    private _stuffData: IObjectData;
+    private _price: number;
+    private _averagePrice: number;
+    private _imageCallback: number;
+    private _status: number;
+    private _timeLeftMinutes: number = -1;
+    private _offerCount: number;
+    private _image: string;
+
+    constructor(offerId: number, furniId: number, furniType: number, extraData: string, stuffData: IObjectData, price: number, status: number, averagePrice: number, offerCount: number = -1)
+    {
+        this._offerId = offerId;
+        this._furniId = furniId;
+        this._furniType = furniType;
+        this._extraData = extraData;
+        this._stuffData = stuffData;
+        this._price = price;
+        this._status = status;
+        this._averagePrice = averagePrice;
+        this._offerCount = offerCount;
+    }
+
+    public get offerId(): number
+    {
+        return this._offerId;
+    }
+
+    public set offerId(offerId: number)
+    {
+        this._offerId = offerId;
+    }
+
+    public get furniId(): number
+    {
+        return this._furniId;
+    }
+
+    public get furniType(): number
+    {
+        return this._furniType;
+    }
+
+    public get extraData(): string
+    {
+        return this._extraData;
+    }
+
+    public get stuffData(): IObjectData
+    {
+        return this._stuffData;
+    }
+
+    public get price(): number
+    {
+        return this._price;
+    }
+
+    public set price(price: number)
+    {
+        this._price = price;
+    }
+
+    public get averagePrice(): number
+    {
+        return this._averagePrice;
+    }
+
+    public get image(): string
+    {
+        return this._image;
+    }
+
+    public set image(image: string)
+    {
+        this._image = image;
+    }
+
+    public get imageCallback(): number
+    {
+        return this._imageCallback;
+    }
+
+    public set imageCallback(callback: number)
+    {
+        this._imageCallback = callback;
+    }
+
+    public get status(): number
+    {
+        return this._status;
+    }
+
+    public get timeLeftMinutes(): number
+    {
+        return this._timeLeftMinutes;
+    }
+
+    public set timeLeftMinutes(minutes: number)
+    {
+        this._timeLeftMinutes = minutes;
+    }
+
+    public get offerCount(): number
+    {
+        return this._offerCount;
+    }
+
+    public set offerCount(count: number)
+    {
+        this._offerCount = count;
+    }
+
+    public get isUniqueLimitedItem(): boolean
+    {
+        return (this.stuffData && (this.stuffData.uniqueSeries > 0));
+    }
+}

src/api/catalog/MarketplaceOfferState.ts

@@ -0,0 +1,7 @@
+export class MarketPlaceOfferState
+{
+    public static readonly ONGOING = 1;
+    public static readonly ONGOING_OWN = 1;
+    public static readonly SOLD = 2;
+    public static readonly EXPIRED = 3;
+}

src/api/catalog/MarketplaceSearchType.ts

@@ -0,0 +1,6 @@
+export class MarketplaceSearchType
+{
+    public static readonly BY_ACTIVITY = 1;
+    public static readonly BY_VALUE = 2;
+    public static readonly ADVANCED = 3;
+}

src/api/catalog/Offer.ts

@@ -0,0 +1,245 @@
+import { GetFurnitureData, GetProductDataForLocalization, LocalizeText, ProductTypeEnum } from '..';
+import { ICatalogPage } from './ICatalogPage';
+import { IProduct } from './IProduct';
+import { IPurchasableOffer } from './IPurchasableOffer';
+import { Product } from './Product';
+
+export class Offer implements IPurchasableOffer
+{
+    public static PRICING_MODEL_UNKNOWN: string = 'pricing_model_unknown';
+    public static PRICING_MODEL_SINGLE: string = 'pricing_model_single';
+    public static PRICING_MODEL_MULTI: string = 'pricing_model_multi';
+    public static PRICING_MODEL_BUNDLE: string = 'pricing_model_bundle';
+    public static PRICING_MODEL_FURNITURE: string = 'pricing_model_furniture';
+    public static PRICE_TYPE_NONE: string = 'price_type_none';
+    public static PRICE_TYPE_CREDITS: string = 'price_type_credits';
+    public static PRICE_TYPE_ACTIVITYPOINTS: string = 'price_type_activitypoints';
+    public static PRICE_TYPE_CREDITS_ACTIVITYPOINTS: string = 'price_type_credits_and_activitypoints';
+
+    private _pricingModel: string;
+    private _priceType: string;
+    private _offerId: number;
+    private _localizationId: string;
+    private _priceInCredits: number;
+    private _priceInActivityPoints: number;
+    private _activityPointType: number;
+    private _giftable: boolean;
+    private _isRentOffer: boolean;
+    private _page: ICatalogPage;
+    private _clubLevel: number = 0;
+    private _products: IProduct[];
+    private _badgeCode: string;
+    private _bundlePurchaseAllowed: boolean = false;
+
+    constructor(offerId: number, localizationId: string, isRentOffer: boolean, priceInCredits: number, priceInActivityPoints: number, activityPointType: number, giftable: boolean, clubLevel: number, products: IProduct[], bundlePurchaseAllowed: boolean)
+    {
+        this._offerId = offerId;
+        this._localizationId = localizationId;
+        this._isRentOffer = isRentOffer;
+        this._priceInCredits = priceInCredits;
+        this._priceInActivityPoints = priceInActivityPoints;
+        this._activityPointType = activityPointType;
+        this._giftable = giftable;
+        this._clubLevel = clubLevel;
+        this._products = products;
+        this._bundlePurchaseAllowed = bundlePurchaseAllowed;
+
+        this.setPricingModelForProducts();
+        this.setPricingType();
+
+        for(const product of products)
+        {
+            if(product.productType === ProductTypeEnum.BADGE)
+            {
+                this._badgeCode = product.extraParam;
+
+                break;
+            }
+        }
+    }
+
+    public activate(): void
+    {
+
+    }
+
+    public get clubLevel(): number
+    {
+        return this._clubLevel;
+    }
+
+    public get page(): ICatalogPage
+    {
+        return this._page;
+    }
+
+    public set page(k: ICatalogPage)
+    {
+        this._page = k;
+    }
+
+    public get offerId(): number
+    {
+        return this._offerId;
+    }
+
+    public get localizationId(): string
+    {
+        return this._localizationId;
+    }
+
+    public get priceInCredits(): number
+    {
+        return this._priceInCredits;
+    }
+
+    public get priceInActivityPoints(): number
+    {
+        return this._priceInActivityPoints;
+    }
+
+    public get activityPointType(): number
+    {
+        return this._activityPointType;
+    }
+
+    public get giftable(): boolean
+    {
+        return this._giftable;
+    }
+
+    public get product(): IProduct
+    {
+        if(!this._products || !this._products.length) return null;
+
+        if(this._products.length === 1) return this._products[0];
+
+        const products = Product.stripAddonProducts(this._products);
+
+        if(products.length) return products[0];
+
+        return null;
+    }
+
+    public get pricingModel(): string
+    {
+        return this._pricingModel;
+    }
+
+    public get priceType(): string
+    {
+        return this._priceType;
+    }
+
+    public get bundlePurchaseAllowed(): boolean
+    {
+        return this._bundlePurchaseAllowed;
+    }
+
+    public get isRentOffer(): boolean
+    {
+        return this._isRentOffer;
+    }
+
+    public get badgeCode(): string
+    {
+        return this._badgeCode;
+    }
+
+    public get localizationName(): string
+    {
+        const productData = GetProductDataForLocalization(this._localizationId);
+
+        if(productData) return productData.name;
+
+        return LocalizeText(this._localizationId);
+    }
+
+    public get localizationDescription(): string
+    {
+        const productData = GetProductDataForLocalization(this._localizationId);
+
+        if(productData) return productData.description;
+
+        return LocalizeText(this._localizationId);
+    }
+
+    public get isLazy(): boolean
+    {
+        return false;
+    }
+
+    public get products(): IProduct[]
+    {
+        return this._products;
+    }
+
+    private setPricingModelForProducts(): void
+    {
+        const products = Product.stripAddonProducts(this._products);
+
+        if(products.length === 1)
+        {
+            if(products[0].productCount === 1)
+            {
+                this._pricingModel = Offer.PRICING_MODEL_SINGLE;
+            }
+            else
+            {
+                this._pricingModel = Offer.PRICING_MODEL_MULTI;
+            }
+        }
+
+        else if(products.length > 1)
+        {
+            this._pricingModel = Offer.PRICING_MODEL_BUNDLE;
+        }
+
+        else
+        {
+            this._pricingModel = Offer.PRICING_MODEL_UNKNOWN;
+        }
+    }
+
+    private setPricingType(): void
+    {
+        if((this._priceInCredits > 0) && (this._priceInActivityPoints > 0))
+        {
+            this._priceType = Offer.PRICE_TYPE_CREDITS_ACTIVITYPOINTS;
+        }
+
+        else if(this._priceInCredits > 0)
+        {
+            this._priceType = Offer.PRICE_TYPE_CREDITS;
+        }
+
+        else if(this._priceInActivityPoints > 0)
+        {
+            this._priceType = Offer.PRICE_TYPE_ACTIVITYPOINTS;
+        }
+
+        else
+        {
+            this._priceType = Offer.PRICE_TYPE_NONE;
+        }
+    }
+
+    public clone(): IPurchasableOffer
+    {
+        const products: IProduct[] = [];
+        const productData = GetProductDataForLocalization(this.localizationId);
+
+        for(const product of this._products)
+        {
+            const furnitureData = GetFurnitureData(product.productClassId, product.productType);
+
+            products.push(new Product(product.productType, product.productClassId, product.extraParam, product.productCount, productData, furnitureData));
+        }
+
+        const offer = new Offer(this.offerId, this.localizationId, this.isRentOffer, this.priceInCredits, this.priceInActivityPoints, this.activityPointType, this.giftable, this.clubLevel, products, this.bundlePurchaseAllowed);
+
+        offer.page = this.page;
+
+        return offer;
+    }
+}

src/api/catalog/PageLocalization.ts

@@ -0,0 +1,36 @@
+import { GetConfigurationValue } from '../nitro';
+import { IPageLocalization } from './IPageLocalization';
+
+export class PageLocalization implements IPageLocalization
+{
+    private _images: string[];
+    private _texts: string[];
+
+    constructor(images: string[], texts: string[])
+    {
+        this._images = images;
+        this._texts = texts;
+    }
+
+    public getText(index: number): string
+    {
+        let message = (this._texts[index] || '');
+
+        if(message && message.length) message = message.replace(/\r\n|\r|\n/g, '<br />');
+
+        return message;
+    }
+
+    public getImage(index: number): string
+    {
+        const imageName = (this._images[index] || '');
+
+        if(!imageName || !imageName.length) return null;
+
+        let assetUrl = GetConfigurationValue<string>('catalog.asset.image.url');
+
+        assetUrl = assetUrl.replace('%name%', imageName);
+
+        return assetUrl;
+    }
+}

src/api/catalog/PlacedObjectPurchaseData.ts

@@ -0,0 +1,41 @@
+import { IFurnitureData, IProductData } from '@nitrots/nitro-renderer';
+import { IPurchasableOffer } from './IPurchasableOffer';
+
+export class PlacedObjectPurchaseData
+{
+    constructor(
+        public readonly roomId: number,
+        public readonly objectId: number,
+        public readonly category: number,
+        public readonly wallLocation: string,
+        public readonly x: number,
+        public readonly y: number,
+        public readonly direction: number,
+        public readonly offer: IPurchasableOffer)
+    {}
+
+    public get offerId(): number
+    {
+        return this.offer.offerId;
+    }
+
+    public get productClassId(): number
+    {
+        return this.offer.product.productClassId;
+    }
+
+    public get productData(): IProductData
+    {
+        return this.offer.product.productData;
+    }
+
+    public get furniData(): IFurnitureData
+    {
+        return this.offer.product.furnitureData;
+    }
+
+    public get extraParam(): string
+    {
+        return this.offer.product.extraParam;
+    }
+}

src/api/catalog/Product.ts

@@ -0,0 +1,143 @@
+import { GetRoomEngine, GetSessionDataManager, IFurnitureData, IObjectData, IProductData } from '@nitrots/nitro-renderer';
+import { GetConfigurationValue } from '../nitro';
+import { GetPixelEffectIcon, GetSubscriptionProductIcon } from './CatalogUtilities';
+import { IProduct } from './IProduct';
+import { IPurchasableOffer } from './IPurchasableOffer';
+import { ProductTypeEnum } from './ProductTypeEnum';
+
+export class Product implements IProduct
+{
+    public static EFFECT_CLASSID_NINJA_DISAPPEAR: number = 108;
+
+    private _productType: string;
+    private _productClassId: number;
+    private _extraParam: string;
+    private _productCount: number;
+    private _productData: IProductData;
+    private _furnitureData: IFurnitureData;
+    private _isUniqueLimitedItem: boolean;
+    private _uniqueLimitedItemSeriesSize: number;
+    private _uniqueLimitedItemsLeft: number;
+
+    constructor(productType: string, productClassId: number, extraParam: string, productCount: number, productData: IProductData, furnitureData: IFurnitureData, isUniqueLimitedItem: boolean = false, uniqueLimitedItemSeriesSize: number = 0, uniqueLimitedItemsLeft: number = 0)
+    {
+        this._productType = productType.toLowerCase();
+        this._productClassId = productClassId;
+        this._extraParam = extraParam;
+        this._productCount = productCount;
+        this._productData = productData;
+        this._furnitureData = furnitureData;
+        this._isUniqueLimitedItem = isUniqueLimitedItem;
+        this._uniqueLimitedItemSeriesSize = uniqueLimitedItemSeriesSize;
+        this._uniqueLimitedItemsLeft = uniqueLimitedItemsLeft;
+    }
+
+    public static stripAddonProducts(products: IProduct[]): IProduct[]
+    {
+        if(products.length === 1) return products;
+
+        return products.filter(product => ((product.productType !== ProductTypeEnum.BADGE) && (product.productType !== ProductTypeEnum.EFFECT) && (product.productClassId !== Product.EFFECT_CLASSID_NINJA_DISAPPEAR)));
+    }
+
+    public getIconUrl(offer: IPurchasableOffer = null, stuffData: IObjectData = null): string
+    {
+        switch(this._productType)
+        {
+            case ProductTypeEnum.FLOOR:
+                return GetRoomEngine().getFurnitureFloorIconUrl(this.productClassId);
+            case ProductTypeEnum.WALL: {
+                if(offer && this._furnitureData)
+                {
+                    let iconName = '';
+
+                    switch(this._furnitureData.className)
+                    {
+                        case 'floor':
+                            iconName = [ 'th', this._furnitureData.className, offer.product.extraParam ].join('_');
+                            break;
+                        case 'wallpaper':
+                            iconName = [ 'th', 'wall', offer.product.extraParam ].join('_');
+                            break;
+                        case 'landscape':
+                            iconName = [ 'th', this._furnitureData.className, (offer.product.extraParam || '').replace('.', '_'), '001' ].join('_');
+                            break;
+                    }
+
+                    if(iconName !== '')
+                    {
+                        const assetUrl = GetConfigurationValue<string>('catalog.asset.url');
+
+                        return `${ assetUrl }/${ iconName }.png`;
+                    }
+                }
+
+                return GetRoomEngine().getFurnitureWallIconUrl(this.productClassId, this._extraParam);
+            }
+            case ProductTypeEnum.EFFECT:
+                return GetPixelEffectIcon(this.productClassId);
+            case ProductTypeEnum.HABBO_CLUB:
+                return GetSubscriptionProductIcon(this.productClassId);
+            case ProductTypeEnum.BADGE:
+                return GetSessionDataManager().getBadgeUrl(this._extraParam);
+            case ProductTypeEnum.ROBOT:
+                return null;
+        }
+
+        return null;
+    }
+
+    public get productType(): string
+    {
+        return this._productType;
+    }
+
+    public get productClassId(): number
+    {
+        return this._productClassId;
+    }
+
+    public get extraParam(): string
+    {
+        return this._extraParam;
+    }
+
+    public set extraParam(extraParam: string)
+    {
+        this._extraParam = extraParam;
+    }
+
+    public get productCount(): number
+    {
+        return this._productCount;
+    }
+
+    public get productData(): IProductData
+    {
+        return this._productData;
+    }
+
+    public get furnitureData(): IFurnitureData
+    {
+        return this._furnitureData;
+    }
+
+    public get isUniqueLimitedItem(): boolean
+    {
+        return this._isUniqueLimitedItem;
+    }
+
+    public get uniqueLimitedItemSeriesSize(): number
+    {
+        return this._uniqueLimitedItemSeriesSize;
+    }
+
+    public get uniqueLimitedItemsLeft(): number
+    {
+        return this._uniqueLimitedItemsLeft;
+    }
+
+    public set uniqueLimitedItemsLeft(uniqueLimitedItemsLeft: number)
+    {
+        this._uniqueLimitedItemsLeft = uniqueLimitedItemsLeft;
+    }
+}

src/api/catalog/ProductTypeEnum.ts

@@ -0,0 +1,11 @@
+export class ProductTypeEnum
+{
+    public static WALL: string = 'i';
+    public static FLOOR: string = 's';
+    public static EFFECT: string = 'e';
+    public static HABBO_CLUB: string = 'h';
+    public static BADGE: string = 'b';
+    public static GAME_TOKEN: string = 'GAME_TOKEN';
+    public static PET: string = 'p';
+    public static ROBOT: string = 'r';
+}

src/api/catalog/RequestedPage.ts

@@ -0,0 +1,63 @@
+export class RequestedPage
+{
+    public static REQUEST_TYPE_NONE: number = 0;
+    public static REQUEST_TYPE_ID: number = 1;
+    public static REQUEST_TYPE_OFFER: number = 2;
+    public static REQUEST_TYPE_NAME: number = 3;
+
+    private _requestType: number;
+    private _requestById: number;
+    private _requestedByOfferId: number;
+    private _requestByName: string;
+
+    constructor()
+    {
+        this._requestType = RequestedPage.REQUEST_TYPE_NONE;
+    }
+
+    public resetRequest():void
+    {
+        this._requestType = RequestedPage.REQUEST_TYPE_NONE;
+        this._requestById = -1;
+        this._requestedByOfferId = -1;
+        this._requestByName = null;
+    }
+
+    public get requestType(): number
+    {
+        return this._requestType;
+    }
+
+    public get requestById(): number
+    {
+        return this._requestById;
+    }
+
+    public set requestById(id: number)
+    {
+        this._requestType = RequestedPage.REQUEST_TYPE_ID;
+        this._requestById = id;
+    }
+
+    public get requestedByOfferId(): number
+    {
+        return this._requestedByOfferId;
+    }
+
+    public set requestedByOfferId(offerId: number)
+    {
+        this._requestType = RequestedPage.REQUEST_TYPE_OFFER;
+        this._requestedByOfferId = offerId;
+    }
+
+    public get requestByName(): string
+    {
+        return this._requestByName;
+    }
+
+    public set requestByName(name: string)
+    {
+        this._requestType = RequestedPage.REQUEST_TYPE_NAME;
+        this._requestByName = name;
+    }
+}

src/api/catalog/SearchResult.ts

@@ -0,0 +1,11 @@
+import { ICatalogNode } from './ICatalogNode';
+import { IPurchasableOffer } from './IPurchasableOffer';
+
+export class SearchResult
+{
+    constructor(
+        public readonly searchValue: string,
+        public readonly offers: IPurchasableOffer[],
+        public readonly filteredNodes: ICatalogNode[])
+    {}
+}

src/api/catalog/index.ts

@@ -0,0 +1,29 @@
+export * from './BuilderFurniPlaceableStatus';
+export * from './CatalogNode';
+export * from './CatalogPage';
+export * from './CatalogPageName';
+export * from './CatalogPetPalette';
+export * from './CatalogPurchaseState';
+export * from './CatalogType';
+export * from './CatalogUtilities';
+export * from './FurnitureOffer';
+export * from './GetImageIconUrlForProduct';
+export * from './GiftWrappingConfiguration';
+export * from './ICatalogNode';
+export * from './ICatalogOptions';
+export * from './ICatalogPage';
+export * from './IMarketplaceSearchOptions';
+export * from './IPageLocalization';
+export * from './IProduct';
+export * from './IPurchasableOffer';
+export * from './IPurchaseOptions';
+export * from './MarketplaceOfferData';
+export * from './MarketplaceOfferState';
+export * from './MarketplaceSearchType';
+export * from './Offer';
+export * from './PageLocalization';
+export * from './PlacedObjectPurchaseData';
+export * from './Product';
+export * from './ProductTypeEnum';
+export * from './RequestedPage';
+export * from './SearchResult';