@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

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

@@ -0,0 +1,166 @@
+export 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}`);
+    }
+}
+// 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-esm/objects/avatar/structure/interface/IAvatarDrawablePart.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,15 @@
+import { getAvatarDrawDefinition } from "./getAvatarDrawDefinition";
+import { parseLookString } from "./parseLookString";
+export async function createLookServer(dependencies) {
+    return ({ look, actions, direction, headDirection, item }, effect) => {
+        return getAvatarDrawDefinition({
+            parsedLook: parseLookString(look),
+            actions,
+            direction,
+            headDirection,
+            frame: 0,
+            item: item,
+            effect: effect,
+        }, dependencies);
+    };
+}

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

@@ -0,0 +1,39 @@
+import { DIRECTION_IS_FLIPPED, getFlippedMetaData } from "./getFlippedMetaData";
+import { getAssetFromPartMeta } from "./getAssetFromPartMeta";
+export function getAssetForFrame({ animationFrame, actionData, partTypeFlipped, direction, partType, partId, offsetsData, offsetX = 0, offsetY = 0, }) {
+    const avatarFlipped = 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 = 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 = 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-esm/objects/avatar/util/getAssetFromPartMeta.js

@@ -0,0 +1,46 @@
+export 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,
+    };
+}
+export 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-esm/objects/avatar/util/getAvatarDirection.js

@@ -0,0 +1,15 @@
+export 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-esm/objects/avatar/util/getAvatarDrawDefinition.js

@@ -0,0 +1,27 @@
+import { AvatarAction } from "../enum/AvatarAction";
+import { AvatarFigurePartType } from "../enum/AvatarFigurePartType";
+import { AvatarDrawDefinition } from "../structure/AvatarDrawDefinition";
+export const basePartSet = new Set([
+    AvatarFigurePartType.LeftHand,
+    AvatarFigurePartType.RightHand,
+    AvatarFigurePartType.Body,
+    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
+ */
+export function getAvatarDrawDefinition({ parsedLook, actions: initialActions, direction, headDirection, item: itemId, effect, }, deps) {
+    const actions = new Set(initialActions).add(AvatarAction.Default);
+    const def = new AvatarDrawDefinition({
+        actions,
+        direction,
+        frame: 0,
+        look: parsedLook,
+        item: itemId,
+        headDirection,
+        effect,
+    }, deps);
+    return def;
+}

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

@@ -0,0 +1,19 @@
+export 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-esm/objects/avatar/util/getEffectSprite.js

@@ -0,0 +1,24 @@
+import { getBasicFlippedMetaData } from "./getFlippedMetaData";
+import { getSpriteId } from "../structure/AvatarEffectPart";
+export function getEffectSprite(member, direction, frame, offsetsData, hasDirection, handleFlipped) {
+    let id = getSpriteId(member, direction, frame);
+    let offsets = offsetsData.getOffsets(id);
+    let flip = false;
+    if (handleFlipped && offsets == null) {
+        const flippedMeta = getBasicFlippedMetaData(direction);
+        id = getSpriteId(member, flippedMeta.direction, frame);
+        offsets = offsetsData.getOffsets(id);
+        flip = flippedMeta.flip;
+    }
+    if (!hasDirection) {
+        id = getSpriteId(member, 0, frame);
+        if (offsets == null) {
+            offsets = offsetsData.getOffsets(id);
+        }
+    }
+    return {
+        id,
+        offsets,
+        flip,
+    };
+}

package/dist-esm/objects/avatar/util/getFlippedMetaData.js

@@ -0,0 +1,89 @@
+import { AvatarFigurePartType } from "../enum/AvatarFigurePartType";
+export const DIRECTION_IS_FLIPPED = [
+    false,
+    false,
+    false,
+    false,
+    true,
+    true,
+    true,
+    false,
+];
+export function getFlippedMetaData({ assetPartDefinition, direction, partType, flippedPartType, }) {
+    const directionFlipped = DIRECTION_IS_FLIPPED[direction];
+    if (!directionFlipped) {
+        return { direction, flip: false, partType, swapped: false };
+    }
+    if (assetPartDefinition === "wav" &&
+        (partType == AvatarFigurePartType.LeftHand ||
+            partType == AvatarFigurePartType.LeftSleeve ||
+            partType == AvatarFigurePartType.LeftCoatSleeve)) {
+        return { direction, flip: true, partType, swapped: false };
+    }
+    if (assetPartDefinition == "drk" &&
+        (partType == AvatarFigurePartType.RightHand ||
+            partType == AvatarFigurePartType.RightSleeve ||
+            partType == AvatarFigurePartType.RightCoatSleeve)) {
+        return { direction, flip: true, partType, swapped: false };
+    }
+    if (assetPartDefinition == "blw" &&
+        partType == AvatarFigurePartType.RightHand) {
+        return { direction, flip: true, partType, swapped: false };
+    }
+    if (assetPartDefinition == "sig" &&
+        partType == AvatarFigurePartType.LeftHand) {
+        return { direction, flip: true, partType, swapped: false };
+    }
+    if (assetPartDefinition == "respect" &&
+        partType == AvatarFigurePartType.LeftHand) {
+        return { direction, flip: true, partType, swapped: false };
+    }
+    if (partType == AvatarFigurePartType.RightHandItem) {
+        return { direction, flip: true, partType, swapped: false };
+    }
+    if (partType == AvatarFigurePartType.LeftHandItem) {
+        return { direction, flip: true, partType, swapped: false };
+    }
+    if (partType == AvatarFigurePartType.ChestPrint) {
+        return { direction, flip: true, partType, swapped: false };
+    }
+    const overrideDirection = getBasicFlippedMetaData(direction);
+    if (flippedPartType != partType) {
+        return {
+            direction: overrideDirection.direction,
+            flip: false,
+            partType: flippedPartType !== null && flippedPartType !== void 0 ? flippedPartType : partType,
+            swapped: true,
+        };
+    }
+    return { direction: overrideDirection.direction, flip: false, partType };
+}
+export function getBasicFlippedMetaData(direction) {
+    let overrideDirection = direction;
+    let flipped = false;
+    if (direction === 4) {
+        overrideDirection = 2;
+        flipped = true;
+    }
+    if (direction === 5) {
+        overrideDirection = 1;
+        flipped = true;
+    }
+    if (direction === 6) {
+        overrideDirection = 0;
+        flipped = true;
+    }
+    return { direction: overrideDirection, flip: flipped };
+}
+export function getPartFlippedMetaData(direction, { partType, flippedPartType, }) {
+    const overrideDirection = getBasicFlippedMetaData(direction);
+    if (flippedPartType != partType) {
+        return {
+            direction: overrideDirection.direction,
+            flip: false,
+            partType: flippedPartType !== null && flippedPartType !== void 0 ? flippedPartType : partType,
+            swapped: true,
+        };
+    }
+    return { direction: overrideDirection.direction, flip: false, partType };
+}

package/dist-esm/objects/avatar/util/getLibrariesForLook.js

@@ -0,0 +1,29 @@
+export function getLibrariesForLook(look, { figureMap, figureData, }) {
+    var _a;
+    const libraries = new Set();
+    const figureParts = Array.from(look).flatMap(([setType, { setId }]) => {
+        var _a;
+        var _b;
+        return ((_b = (_a = figureData
+            .getParts(setType, setId.toString())) === null || _a === void 0 ? void 0 : _a.map((part) => ({ ...part, setId, setType }))) !== null && _b !== void 0 ? _b : []);
+    });
+    for (const part of figureParts) {
+        let libraryId = figureMap.getLibraryOfPart(part.id, part.type);
+        if (libraryId != null) {
+            const checkParts = (_a = figureData.getParts(part.setType, part.setId.toString())) !== null && _a !== void 0 ? _a : [];
+            for (const checkPart of checkParts) {
+                libraryId = figureMap.getLibraryOfPart(checkPart.id, checkPart.type);
+                if (libraryId != null)
+                    break;
+            }
+        }
+        if (libraryId != null) {
+            libraries.add(libraryId);
+        }
+    }
+    // Add base libraries
+    libraries.add("hh_human_face");
+    libraries.add("hh_human_item");
+    libraries.add("hh_human_body");
+    return libraries;
+}

package/dist-esm/objects/avatar/util/index.js

@@ -0,0 +1 @@
+export * from "./createLookServer";

package/dist-esm/objects/avatar/util/parseLookString.js

@@ -0,0 +1,12 @@
+export function parseLookString(look) {
+    return new Map(look.split(".").map((str) => {
+        const partData = str.split("-");
+        return [
+            partData[0],
+            {
+                setId: Number(partData[1]),
+                colorId: Number(partData[2]),
+            },
+        ];
+    }));
+}

package/dist-esm/objects/events/EventEmitter.js

@@ -0,0 +1,27 @@
+export class EventEmitter {
+    constructor() {
+        this._map = new Map();
+    }
+    addEventListener(name, callback) {
+        var _a;
+        const key = name.toString();
+        const currentEventCallbackSet = (_a = this._map.get(key)) !== null && _a !== void 0 ? _a : new Set();
+        currentEventCallbackSet.add(callback);
+        this._map.set(key, currentEventCallbackSet);
+    }
+    removeEventListener(name, callback) {
+        const key = name.toString();
+        const currentEventCallbackSet = this._map.get(key);
+        if (currentEventCallbackSet != null) {
+            currentEventCallbackSet.delete(callback);
+        }
+    }
+    trigger(name, value) {
+        const key = name.toString();
+        const currentEventCallbackSet = this._map.get(key);
+        currentEventCallbackSet === null || currentEventCallbackSet === void 0 ? void 0 : currentEventCallbackSet.forEach((callback) => callback(value));
+    }
+}
+if (typeof window !== 'undefined') {
+    window.addEventListener;
+}