@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist/objects/avatar/structure/AvatarPartList.d.ts

@@ -0,0 +1,30 @@
+import { AvatarFigurePartType } from "../enum/AvatarFigurePartType";
+import { IAvatarAnimationData } from "../data/interfaces/IAvatarAnimationData";
+import { Bodypart } from "../data/interfaces/IAvatarGeometryData";
+import { IAvatarOffsetsData } from "../data/interfaces/IAvatarOffsetsData";
+import { IAvatarPartSetsData } from "../data/interfaces/IAvatarPartSetsData";
+import { IFigureData } from "../data/interfaces/IFigureData";
+import { IFigureMapData } from "../data/interfaces/IFigureMapData";
+import { ParsedLook } from "../util/parseLookString";
+import { AvatarPart } from "./AvatarPart";
+export declare const basePartSet: Set<AvatarFigurePartType>;
+export declare class AvatarPartList {
+    private _deps;
+    private _parts;
+    private _hiddenLayers;
+    private _partsByType;
+    constructor(look: ParsedLook, itemId: string | number | undefined, _deps: AvatarPartListOptions);
+    getPartsForBodyBart(bodyPart: Bodypart): AvatarPart[];
+    getPartsForType(type: AvatarFigurePartType): AvatarPart[];
+    get parts(): AvatarPart[];
+    private _addItem;
+    private _registerPart;
+}
+interface AvatarPartListOptions {
+    figureData: IFigureData;
+    figureMap: IFigureMapData;
+    animationData: IAvatarAnimationData;
+    offsetsData: IAvatarOffsetsData;
+    partSetsData: IAvatarPartSetsData;
+}
+export {};

package/dist/objects/avatar/structure/AvatarPartList.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvatarPartList = exports.basePartSet = void 0;
+const AvatarFigurePartType_1 = require("../enum/AvatarFigurePartType");
+const AvatarPart_1 = require("./AvatarPart");
+exports.basePartSet = new Set([
+    AvatarFigurePartType_1.AvatarFigurePartType.LeftHand,
+    AvatarFigurePartType_1.AvatarFigurePartType.RightHand,
+    AvatarFigurePartType_1.AvatarFigurePartType.Body,
+    AvatarFigurePartType_1.AvatarFigurePartType.Head,
+]);
+class AvatarPartList {
+    constructor(look, itemId, _deps) {
+        this._deps = _deps;
+        this._parts = [];
+        this._hiddenLayers = new Set();
+        this._partsByType = new Map();
+        const { figureData } = _deps;
+        look.forEach(({ setId, colorId }, setType) => {
+            const parts = figureData.getParts(setType, setId.toString());
+            const colorValue = figureData.getColor(setType, colorId.toString());
+            const hiddenLayers = figureData.getHiddenLayers(setType, setId.toString());
+            hiddenLayers.forEach((layer) => this._hiddenLayers.add(layer));
+            if (parts != null && parts.length > 0) {
+                parts.forEach((part) => {
+                    const avatarPart = new AvatarPart_1.AvatarPart(part, colorValue, _deps);
+                    this._registerPart(avatarPart);
+                });
+            }
+        });
+        if (itemId != null) {
+            this._addItem(itemId);
+        }
+        exports.basePartSet.forEach((partType) => {
+            const partsForType = this._partsByType.get(partType);
+            if (partsForType == null || partsForType.length === 0) {
+                this._registerPart(new AvatarPart_1.AvatarPart({
+                    id: "1",
+                    type: partType,
+                    colorable: false,
+                    index: 0,
+                }, undefined, _deps));
+            }
+        });
+    }
+    getPartsForBodyBart(bodyPart) {
+        return bodyPart.items
+            .flatMap((bodyPartItem) => {
+            var _a;
+            return ((_a = this._partsByType.get(bodyPartItem.id)) !== null && _a !== void 0 ? _a : []);
+        })
+            .filter((part) => !this._hiddenLayers.has(part.type));
+    }
+    getPartsForType(type) {
+        const parts = this._partsByType.get(type);
+        if (parts == null)
+            return [];
+        const sortedParts = [...parts].sort((a, b) => a.index - b.index);
+        return sortedParts;
+    }
+    get parts() {
+        return this._parts;
+    }
+    _addItem(itemId) {
+        this._registerPart(new AvatarPart_1.AvatarPart({
+            type: "ri",
+            colorable: false,
+            id: itemId.toString(),
+            index: 0,
+        }, undefined, this._deps));
+    }
+    _registerPart(avatarPart) {
+        var _a;
+        const type = avatarPart.type;
+        this._parts.push(avatarPart);
+        const current = (_a = this._partsByType.get(type)) !== null && _a !== void 0 ? _a : [];
+        this._partsByType.set(type, [...current, avatarPart]);
+    }
+}
+exports.AvatarPartList = AvatarPartList;

package/dist/objects/avatar/structure/BodyPartDrawOrder.d.ts

@@ -0,0 +1,3 @@
+export declare class BodyPartDrawOrder {
+    static getDrawOrder(direction: number, drawOrderType: "std" | "lh-up" | "rh-up"): string[] | undefined;
+}

package/dist/objects/avatar/structure/BodyPartDrawOrder.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BodyPartDrawOrder = void 0;
+class BodyPartDrawOrder {
+    static getDrawOrder(direction, drawOrderType) {
+        switch (drawOrderType) {
+            case "std":
+                return drawOrdersDefault[direction];
+            case "rh-up":
+                return drawOrdersRightHandActive[direction];
+            case "lh-up":
+                return drawOrdersLeftHandActive[direction];
+        }
+        throw new Error(`Invalid draw order type ${drawOrderType}`);
+    }
+}
+exports.BodyPartDrawOrder = BodyPartDrawOrder;
+// We hardcode the draw orders for each direction. The flash client uses some matrix system based on the
+// radius in the geometry for this, which is what we should aim for.
+const drawOrdersDefault = {
+    0: [
+        "behind",
+        "bottom",
+        "leftitem",
+        "leftarm",
+        "torso",
+        "rightitem",
+        "rightarm",
+        "head",
+        "top",
+    ],
+    1: [
+        "behind",
+        "bottom",
+        "leftitem",
+        "leftarm",
+        "torso",
+        "rightitem",
+        "rightarm",
+        "head",
+        "top",
+    ],
+    2: [
+        "behind",
+        "bottom",
+        "leftitem",
+        "leftarm",
+        "torso",
+        "rightitem",
+        "rightarm",
+        "head",
+        "top",
+    ],
+    3: [
+        "behind",
+        "bottom",
+        "torso",
+        "leftitem",
+        "leftarm",
+        "rightitem",
+        "rightarm",
+        "head",
+        "top",
+    ],
+    4: [
+        "behind",
+        "bottom",
+        "rightarm",
+        "rightitem",
+        "torso",
+        "leftitem",
+        "leftarm",
+        "head",
+        "top",
+    ],
+    5: [
+        "behind",
+        "bottom",
+        "rightarm",
+        "rightitem",
+        "torso",
+        "leftitem",
+        "leftarm",
+        "head",
+        "top",
+    ],
+    6: [
+        "bottom",
+        "rightarm",
+        "rightitem",
+        "torso",
+        "leftitem",
+        "leftarm",
+        "head",
+        "behind",
+        "top",
+    ],
+    7: [
+        "bottom",
+        "rightarm",
+        "rightitem",
+        "leftitem",
+        "leftarm",
+        "torso",
+        "head",
+        "behind",
+        "top",
+    ],
+};
+const drawOrdersRightHandActive = {
+    ...drawOrdersDefault,
+    2: [
+        "behind",
+        "bottom",
+        "leftitem",
+        "leftarm",
+        "torso",
+        "head",
+        "rightitem",
+        "rightarm",
+        "top",
+    ],
+    3: [
+        "behind",
+        "bottom",
+        "leftitem",
+        "leftarm",
+        "torso",
+        "head",
+        "rightitem",
+        "rightarm",
+        "top",
+    ],
+    4: [
+        "behind",
+        "bottom",
+        "rightarm",
+        "torso",
+        "leftitem",
+        "leftarm",
+        "head",
+        "rightitem",
+        "top",
+    ],
+};
+const drawOrdersLeftHandActive = {
+    ...drawOrdersDefault,
+    5: [
+        "behind",
+        "bottom",
+        "rightarm",
+        "rightitem",
+        "torso",
+        "head",
+        "leftitem",
+        "leftarm",
+        "top",
+    ],
+    6: [
+        "behind",
+        "bottom",
+        "rightarm",
+        "rightitem",
+        "torso",
+        "head",
+        "leftitem",
+        "leftarm",
+        "top",
+    ],
+};

package/dist/objects/avatar/structure/interface/IAvatarDrawablePart.d.ts

@@ -0,0 +1,4 @@
+import { AvatarDrawPart } from "../../types";
+export interface IAvatarDrawablePart {
+    getDrawDefinition(): AvatarDrawPart | undefined;
+}

package/dist/objects/avatar/structure/interface/IAvatarDrawablePart.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/objects/avatar/structure/interface/IAvatarEffectPart.d.ts

@@ -0,0 +1,7 @@
+import { IAvatarEffectData } from "../../data/interfaces/IAvatarEffectData";
+export interface IAvatarEffectPart {
+    setDirection(direction: number): void;
+    setDirectionOffset(offset: number): void;
+    setEffectFrame(effect: IAvatarEffectData, frame: number): void;
+    setEffectFrameDefaultIfNotSet(): void;
+}

package/dist/objects/avatar/structure/interface/IAvatarEffectPart.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/objects/avatar/types/index.d.ts

@@ -0,0 +1,43 @@
+import { IAvatarActionsData } from "../data/interfaces/IAvatarActionsData";
+import { IAvatarAnimationData } from "../data/interfaces/IAvatarAnimationData";
+import { IAvatarGeometryData } from "../data/interfaces/IAvatarGeometryData";
+import { IAvatarOffsetsData } from "../data/interfaces/IAvatarOffsetsData";
+import { IAvatarPartSetsData } from "../data/interfaces/IAvatarPartSetsData";
+import { IFigureData } from "../data/interfaces/IFigureData";
+import { IFigureMapData } from "../data/interfaces/IFigureMapData";
+export type AvatarAsset = {
+    fileId: string;
+    x: number;
+    y: number;
+    library: string;
+    mirror: boolean;
+    substractWidth?: boolean;
+};
+export type AvatarDrawPart = DefaultAvatarDrawPart | AvatarEffectDrawPart;
+export type DefaultAvatarDrawPart = {
+    kind: "AVATAR_DRAW_PART";
+    type: string;
+    index: number;
+    mode: "colored" | "just-image";
+    color: string | undefined;
+    assets: AvatarAsset[];
+    z: number;
+};
+export type AvatarEffectDrawPart = {
+    kind: "EFFECT_DRAW_PART";
+    assets: AvatarAsset[];
+    z: number;
+    ink?: number;
+    addition: boolean;
+};
+export interface AvatarDependencies extends AvatarExternalDependencies {
+    offsetsData: IAvatarOffsetsData;
+}
+export interface AvatarExternalDependencies {
+    figureData: IFigureData;
+    figureMap: IFigureMapData;
+    animationData: IAvatarAnimationData;
+    partSetsData: IAvatarPartSetsData;
+    geometry: IAvatarGeometryData;
+    actionsData: IAvatarActionsData;
+}

package/dist/objects/avatar/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/objects/avatar/util/createLookServer.d.ts

@@ -0,0 +1,18 @@
+import { AvatarAction } from "../enum/AvatarAction";
+import { IAvatarEffectData } from "../data/interfaces/IAvatarEffectData";
+import { AvatarDependencies } from "../types";
+import { AvatarDrawDefinition } from "../structure/AvatarDrawDefinition";
+export interface LookOptions {
+    look: string;
+    actions: Set<AvatarAction>;
+    direction: number;
+    headDirection?: number;
+    item?: string | number;
+    effect?: string;
+    initial?: boolean;
+    skipCaching?: boolean;
+}
+export interface LookServer {
+    (options: LookOptions, effect?: IAvatarEffectData): AvatarDrawDefinition | undefined;
+}
+export declare function createLookServer(dependencies: AvatarDependencies): Promise<LookServer>;

package/dist/objects/avatar/util/createLookServer.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLookServer = createLookServer;
+const getAvatarDrawDefinition_1 = require("./getAvatarDrawDefinition");
+const parseLookString_1 = require("./parseLookString");
+async function createLookServer(dependencies) {
+    return ({ look, actions, direction, headDirection, item }, effect) => {
+        return (0, getAvatarDrawDefinition_1.getAvatarDrawDefinition)({
+            parsedLook: (0, parseLookString_1.parseLookString)(look),
+            actions,
+            direction,
+            headDirection,
+            frame: 0,
+            item: item,
+            effect: effect,
+        }, dependencies);
+    };
+}

package/dist/objects/avatar/util/getAssetForFrame.d.ts

@@ -0,0 +1,21 @@
+import { AvatarAnimationFrame } from "../data/interfaces/IAvatarAnimationData";
+import { IAvatarOffsetsData } from "../data/interfaces/IAvatarOffsetsData";
+import { AvatarActionInfo } from "../data/interfaces/IAvatarActionsData";
+import { AvatarFigurePartType } from "../enum/AvatarFigurePartType";
+export declare function getAssetForFrame({ animationFrame, actionData, partTypeFlipped, direction, partType, partId, offsetsData, offsetX, offsetY, }: {
+    animationFrame?: AvatarAnimationFrame;
+    actionData: AvatarActionInfo;
+    partTypeFlipped?: AvatarFigurePartType;
+    partType: AvatarFigurePartType;
+    direction: number;
+    partId: string;
+    offsetsData: IAvatarOffsetsData;
+    offsetX?: number;
+    offsetY?: number;
+}): {
+    fileId: string;
+    library: string;
+    mirror: boolean;
+    x: number;
+    y: number;
+} | undefined;

package/dist/objects/avatar/util/getAssetForFrame.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAssetForFrame = getAssetForFrame;
+const getFlippedMetaData_1 = require("./getFlippedMetaData");
+const getAssetFromPartMeta_1 = require("./getAssetFromPartMeta");
+function getAssetForFrame({ animationFrame, actionData, partTypeFlipped, direction, partType, partId, offsetsData, offsetX = 0, offsetY = 0, }) {
+    const avatarFlipped = getFlippedMetaData_1.DIRECTION_IS_FLIPPED[direction];
+    let assetPartDefinition = actionData.assetpartdefinition;
+    let frameNumber = 0;
+    if (animationFrame != null) {
+        frameNumber = animationFrame.number;
+        if (animationFrame.assetpartdefinition &&
+            animationFrame.assetpartdefinition !== "") {
+            assetPartDefinition = animationFrame.assetpartdefinition;
+        }
+    }
+    const flippedMeta = (0, getFlippedMetaData_1.getFlippedMetaData)({
+        assetPartDefinition,
+        flippedPartType: partTypeFlipped,
+        direction: direction,
+        partType: partType,
+    });
+    let assetId = generateAssetName(assetPartDefinition, flippedMeta.partType, partId, flippedMeta.direction, frameNumber);
+    let offset = offsetsData.getOffsets(assetId);
+    if (offset == null) {
+        assetId = generateAssetName("std", flippedMeta.partType, partId, flippedMeta.direction, 0);
+        offset = offsetsData.getOffsets(assetId);
+    }
+    if (offset != null) {
+        let flipH = flippedMeta.flip;
+        if (avatarFlipped) {
+            flipH = !flipH;
+        }
+        const asset = (0, getAssetFromPartMeta_1.getAssetFromPartMeta)(assetPartDefinition, { flipped: flipH, swapped: false, asset: assetId }, offsetsData, { offsetX, offsetY });
+        if (asset != null) {
+            return asset;
+        }
+    }
+}
+function generateAssetName(assetPartDef, partType, partId, direction, frame) {
+    return `h_${assetPartDef}_${partType}_${partId}_${direction}_${frame}`;
+}

package/dist/objects/avatar/util/getAssetFromPartMeta.d.ts

@@ -0,0 +1,30 @@
+import { IAvatarOffsetsData } from "../data/interfaces/IAvatarOffsetsData";
+export declare function getAssetFromPartMeta(assetPartDefinition: string, assetInfoFrame: {
+    flipped: boolean;
+    swapped: boolean;
+    asset: string;
+}, offsetsData: IAvatarOffsetsData, { offsetX, offsetY }: {
+    offsetX: number;
+    offsetY: number;
+}): {
+    fileId: string;
+    library: string;
+    mirror: boolean;
+    x: number;
+    y: number;
+} | undefined;
+export declare function applyOffsets({ offsets, customOffsets: { offsetX, offsetY }, flipped, lay, }: {
+    flipped: boolean;
+    offsets: {
+        offsetX: number;
+        offsetY: number;
+    };
+    customOffsets: {
+        offsetX: number;
+        offsetY: number;
+    };
+    lay: boolean;
+}): {
+    x: number;
+    y: number;
+};

package/dist/objects/avatar/util/getAssetFromPartMeta.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAssetFromPartMeta = getAssetFromPartMeta;
+exports.applyOffsets = applyOffsets;
+function getAssetFromPartMeta(assetPartDefinition, assetInfoFrame, offsetsData, { offsetX, offsetY }) {
+    const offsets = offsetsData.getOffsets(assetInfoFrame.asset);
+    if (offsets == null)
+        return;
+    const { x: offsetsX, y: offsetsY } = applyOffsets({
+        offsets,
+        customOffsets: { offsetX, offsetY },
+        flipped: assetInfoFrame.flipped,
+        lay: assetPartDefinition === "lay",
+    });
+    if (isNaN(offsetsX))
+        throw new Error("Invalid x offset");
+    if (isNaN(offsetsY))
+        throw new Error("Invalid y offset");
+    return {
+        fileId: assetInfoFrame.asset,
+        library: "",
+        mirror: assetInfoFrame.flipped,
+        x: offsetsX,
+        y: offsetsY,
+    };
+}
+function applyOffsets({ offsets, customOffsets: { offsetX, offsetY }, flipped, lay, }) {
+    let offsetsX = 0;
+    let offsetsY = 0;
+    offsetsY = -offsets.offsetY + offsetY;
+    if (flipped) {
+        offsetsX = 64 + offsets.offsetX - offsetX;
+    }
+    else {
+        offsetsX = -offsets.offsetX - offsetX;
+    }
+    if (lay) {
+        if (flipped) {
+            offsetsX -= 52;
+        }
+        else {
+            offsetsX += 52;
+        }
+    }
+    offsetsY = offsetsY + 16;
+    return {
+        x: offsetsX,
+        y: offsetsY,
+    };
+}

package/dist/objects/avatar/util/getAvatarDirection.d.ts

@@ -0,0 +1 @@
+export declare function getAvatarDirection(direction: number): number;

package/dist/objects/avatar/util/getAvatarDirection.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvatarDirection = getAvatarDirection;
+function getAvatarDirection(direction) {
+    if (direction < -8) {
+        return 0;
+    }
+    if (direction > 15) {
+        return 0;
+    }
+    if (direction < 0) {
+        return direction + 8;
+    }
+    if (direction > 7) {
+        return direction - 8;
+    }
+    return direction;
+}

package/dist/objects/avatar/util/getAvatarDrawDefinition.d.ts

@@ -0,0 +1,22 @@
+import { ParsedLook } from "./parseLookString";
+import { IAvatarEffectData } from "../data/interfaces/IAvatarEffectData";
+import { AvatarFigurePartType } from "../enum/AvatarFigurePartType";
+import { AvatarDrawDefinition } from "../structure/AvatarDrawDefinition";
+import { AvatarDependencies } from "../types";
+export declare const basePartSet: Set<AvatarFigurePartType>;
+/**
+ * Returns a definition of how the avatar should be drawn.
+ * @param options Look options
+ * @param deps External figure data, draw order and offsets
+ */
+export declare function getAvatarDrawDefinition({ parsedLook, actions: initialActions, direction, headDirection, item: itemId, effect, }: Options, deps: AvatarDependencies): AvatarDrawDefinition | undefined;
+interface Options {
+    parsedLook: ParsedLook;
+    actions: Set<string>;
+    direction: number;
+    headDirection?: number;
+    frame: number;
+    item?: string | number;
+    effect?: IAvatarEffectData;
+}
+export {};

package/dist/objects/avatar/util/getAvatarDrawDefinition.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.basePartSet = void 0;
+exports.getAvatarDrawDefinition = getAvatarDrawDefinition;
+const AvatarAction_1 = require("../enum/AvatarAction");
+const AvatarFigurePartType_1 = require("../enum/AvatarFigurePartType");
+const AvatarDrawDefinition_1 = require("../structure/AvatarDrawDefinition");
+exports.basePartSet = new Set([
+    AvatarFigurePartType_1.AvatarFigurePartType.LeftHand,
+    AvatarFigurePartType_1.AvatarFigurePartType.RightHand,
+    AvatarFigurePartType_1.AvatarFigurePartType.Body,
+    AvatarFigurePartType_1.AvatarFigurePartType.Head,
+]);
+/**
+ * Returns a definition of how the avatar should be drawn.
+ * @param options Look options
+ * @param deps External figure data, draw order and offsets
+ */
+function getAvatarDrawDefinition({ parsedLook, actions: initialActions, direction, headDirection, item: itemId, effect, }, deps) {
+    const actions = new Set(initialActions).add(AvatarAction_1.AvatarAction.Default);
+    const def = new AvatarDrawDefinition_1.AvatarDrawDefinition({
+        actions,
+        direction,
+        frame: 0,
+        look: parsedLook,
+        item: itemId,
+        headDirection,
+        effect,
+    }, deps);
+    return def;
+}

package/dist/objects/avatar/util/getDrawOrderForActions.d.ts

@@ -0,0 +1,4 @@
+import { AvatarActionInfo } from "../data/interfaces/IAvatarActionsData";
+export declare function getDrawOrderForActions(activeActions: AvatarActionInfo[], options: {
+    hasItem: boolean;
+}): "lh-up" | "rh-up" | "std";

package/dist/objects/avatar/util/getDrawOrderForActions.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDrawOrderForActions = getDrawOrderForActions;
+function getDrawOrderForActions(activeActions, options) {
+    const activePartSets = new Set();
+    activeActions.forEach((info) => {
+        if (info.activepartset != null) {
+            activePartSets.add(info.activepartset);
+        }
+    });
+    if (options.hasItem) {
+        activePartSets.add("itemRight");
+    }
+    if (activePartSets.has("handLeft")) {
+        return "lh-up";
+    }
+    if (activePartSets.has("handRightAndHead") ||
+        activePartSets.has("handRight")) {
+        return "rh-up";
+    }
+    return "std";
+}

package/dist/objects/avatar/util/getEffectSprite.d.ts

@@ -0,0 +1,9 @@
+import { IAvatarOffsetsData } from "../data/interfaces/IAvatarOffsetsData";
+export declare function getEffectSprite(member: string, direction: number, frame: number, offsetsData: IAvatarOffsetsData, hasDirection: boolean, handleFlipped: boolean): {
+    id: string;
+    offsets: {
+        offsetX: number;
+        offsetY: number;
+    } | undefined;
+    flip: boolean;
+};