@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

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

@@ -0,0 +1,87 @@
+import { associateBy } from "../../../util/associateBy";
+import { notNullOrUndefined } from "../../../util/notNullOrUndefined";
+import { AvatarAdditionPart } from "./AvatarAdditionPart";
+import { AvatarBodyPart } from "./AvatarBodyPart";
+export class AvatarBodyPartList {
+    constructor(_bodyParts, { actionsData, offsetsData, partSetsData, }) {
+        this._bodyParts = _bodyParts;
+        this._bodyPartsById = new Map();
+        this._additions = new Map();
+        this._additionsArr = [];
+        this._bodyPartsById = associateBy(this._bodyParts, (bodyPart) => bodyPart.id);
+        this._actionsData = actionsData;
+        this._offsetsData = offsetsData;
+        this._partSetsData = partSetsData;
+    }
+    static create(partList, hasItem, { geometry, partSetsData, actionsData, offsetsData, }) {
+        const bodyPartIds = [...geometry.getBodyParts("full")];
+        if (hasItem) {
+            bodyPartIds.push("rightitem");
+        }
+        const bodyParts = bodyPartIds
+            .map((id) => geometry.getBodyPart("vertical", id))
+            .filter(notNullOrUndefined)
+            .map((bodyPart) => new AvatarBodyPart(bodyPart, partList.getPartsForBodyBart(bodyPart), partSetsData, actionsData, geometry))
+            .sort((a, b) => a.z - b.z);
+        return new AvatarBodyPartList(bodyParts, {
+            actionsData,
+            offsetsData,
+            partSetsData,
+        });
+    }
+    applyActions(actions) {
+        actions.forEach((action) => {
+            this._bodyParts.forEach((bodyPart) => {
+                bodyPart.setActiveAction(action);
+            });
+        });
+    }
+    applyEffectAdditions(effect) {
+        effect.getAddtions().forEach((sprite) => {
+            var _a;
+            const bodyPart = sprite.align != null ? this._getBodyPartById(sprite.align) : undefined;
+            if (bodyPart != null) {
+                const current = (_a = this._additions.get(bodyPart)) !== null && _a !== void 0 ? _a : [];
+                const additionPart = new AvatarAdditionPart(sprite, this._actionsData, this._offsetsData, this._partSetsData);
+                this._additions.set(bodyPart, [...current, additionPart]);
+                this._additionsArr.push(additionPart);
+                bodyPart.addAddition(additionPart);
+            }
+        });
+    }
+    setEffectFrame(effect, frame) {
+        this._bodyParts.forEach((bodyPart) => {
+            bodyPart.setEffectFrame(effect, frame);
+            bodyPart.setFrameRepeat(2);
+        });
+        this._additionsArr.forEach((addition) => {
+            addition.setEffectFrame(effect, frame);
+        });
+    }
+    setAvatarOffsets(avatarFrameData, frame) {
+        this._bodyParts.forEach((bodyPart) => bodyPart.setAvatarOffsets(avatarFrameData, frame));
+    }
+    setAdditionsDirection(direction) {
+        this._additionsArr.forEach((addition) => addition.setDirection(direction));
+    }
+    setDirectionOffset(offset) {
+        this._additionsArr.forEach((addition) => addition.setDirectionOffset(offset));
+        this._bodyParts.forEach((bodyPart) => bodyPart.setDirectionOffset(offset));
+    }
+    setBodyPartDirection(direction, headDirection) {
+        this._bodyParts.forEach((bodyPart) => {
+            if (bodyPart.id === "head") {
+                bodyPart.setDirection(headDirection !== null && headDirection !== void 0 ? headDirection : direction);
+            }
+            else {
+                bodyPart.setDirection(direction);
+            }
+        });
+    }
+    getBodyPartById(id) {
+        return this._getBodyPartById(id);
+    }
+    _getBodyPartById(id) {
+        return this._bodyPartsById.get(id);
+    }
+}

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

@@ -0,0 +1,131 @@
+import { notNullOrUndefined } from "../../../util/notNullOrUndefined";
+import { AvatarAction } from "../enum/AvatarAction";
+import { getAvatarDirection } from "../util/getAvatarDirection";
+import { getDrawOrderForActions } from "../util/getDrawOrderForActions";
+import { AvatarBodyPartList } from "./AvatarBodyPartList";
+import { AvatarEffectPart } from "./AvatarEffectPart";
+import { AvatarPartList } from "./AvatarPartList";
+import { BodyPartDrawOrder } from "./BodyPartDrawOrder";
+export class AvatarDrawDefinition {
+    constructor(_options, { figureData, actionsData, geometry, partSetsData, animationData, offsetsData, figureMap, }) {
+        var _a;
+        var _b;
+        this._options = _options;
+        this._directionOffset = 0;
+        this._drawParts = undefined;
+        this._direction = _options.direction;
+        this._figureData = figureData;
+        this._actionsData = actionsData;
+        this._geometry = geometry;
+        this._partSetsData = partSetsData;
+        this._animationData = animationData;
+        this._offsetsData = offsetsData;
+        this._figureMap = figureMap;
+        const effect = _options.effect;
+        const partList = this._getPartsForLook(_options.look);
+        const bodyParts = AvatarBodyPartList.create(partList, this._options.item != null, { actionsData, geometry, partSetsData, offsetsData });
+        const activeActions = this._getActiveActions();
+        this._bodyParts = bodyParts;
+        bodyParts.applyActions(activeActions);
+        bodyParts.setBodyPartDirection(this._options.direction, this._options.headDirection);
+        const effectParts = new Map();
+        this._effectParts = [];
+        if (effect != null) {
+            bodyParts.applyEffectAdditions(effect);
+            effect.getSprites().forEach((sprite) => {
+                if (sprite.id === "avatar") {
+                    effectParts.set(sprite.id, this);
+                    return;
+                }
+                const effectPart = new AvatarEffectPart(sprite, this._actionsData, this._offsetsData, effect);
+                effectParts.set(sprite.id, effectPart);
+                this._effectParts.push(effectPart);
+            });
+            for (let i = 0; i < effect.getFrameCount(); i++) {
+                bodyParts.setEffectFrame(effect, i);
+                effectParts.forEach((effectPart) => effectPart.setEffectFrame(effect, i));
+            }
+            effectParts.forEach((effectPart) => {
+                effectPart.setEffectFrameDefaultIfNotSet();
+                effectPart.setDirection(_options.direction);
+            });
+            bodyParts.setAdditionsDirection(_options.direction);
+        }
+        const directionOffset = (_b = (_a = effect === null || effect === void 0 ? void 0 : effect.getDirection()) === null || _a === void 0 ? void 0 : _a.offset) !== null && _b !== void 0 ? _b : 0;
+        if (directionOffset != null) {
+            effectParts.forEach((part) => {
+                part.setDirectionOffset(directionOffset);
+            });
+            bodyParts.setDirectionOffset(directionOffset);
+        }
+        this._activeActions = activeActions;
+        this._partList = partList;
+    }
+    setDirection(direction) {
+        this._direction = direction;
+    }
+    setDirectionOffset(offset) {
+        this._directionOffset = offset;
+    }
+    setEffectFrame(effect, frame) {
+        const avatarFrameData = effect.getFrameEffectPart("avatar", frame);
+        if (avatarFrameData == null)
+            return;
+        this._bodyParts.setAvatarOffsets(avatarFrameData, frame);
+        this._effectParts.forEach((effectPart) => {
+            effectPart.setAvatarOffsets(avatarFrameData, frame);
+        });
+    }
+    setEffectFrameDefaultIfNotSet() {
+        // Do nothing
+    }
+    getDrawDefinition() {
+        if (this._drawParts != null)
+            return this._drawParts;
+        const drawOrderId = getDrawOrderForActions(this._activeActions, {
+            hasItem: this._options.item != null,
+        });
+        const drawOrderDirection = getAvatarDirection(this._direction + this._directionOffset);
+        const drawOrderBodyParts = BodyPartDrawOrder.getDrawOrder(drawOrderDirection, drawOrderId);
+        if (drawOrderBodyParts == null)
+            return [];
+        const sortedParts = drawOrderBodyParts
+            .map((id) => this._bodyParts.getBodyPartById(id))
+            .filter(notNullOrUndefined)
+            .flatMap((bodyPart) => {
+            return bodyPart.getSortedParts("vertical");
+        });
+        const drawParts = sortedParts
+            .map((part) => part.getDrawDefinition())
+            .filter(notNullOrUndefined);
+        const effectDrawParts = this._effectParts
+            .map((part) => part.getDrawDefinition())
+            .filter(notNullOrUndefined);
+        const sortedDrawParts = [...drawParts, ...effectDrawParts].sort((a, b) => a.z - b.z);
+        this._drawParts = sortedDrawParts;
+        return sortedDrawParts;
+    }
+    _getPartsForLook(look) {
+        const avatarList = new AvatarPartList(look, this._options.item, {
+            figureData: this._figureData,
+            animationData: this._animationData,
+            figureMap: this._figureMap,
+            offsetsData: this._offsetsData,
+            partSetsData: this._partSetsData,
+        });
+        return avatarList;
+    }
+    _getActiveActions() {
+        const actions = new Set(this._options.actions).add(AvatarAction.Default);
+        return this._actionsData
+            .getActions()
+            .filter((info) => actions.has(info.id))
+            .sort((a, b) => {
+            if (a.precedence < b.precedence)
+                return 1;
+            if (a.precedence > b.precedence)
+                return -1;
+            return 0;
+        });
+    }
+}

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

@@ -0,0 +1,113 @@
+import { AvatarAction } from "../enum/AvatarAction";
+import { applyOffsets } from "../util/getAssetFromPartMeta";
+import { getAvatarDirection } from "../util/getAvatarDirection";
+import { getEffectSprite } from "../util/getEffectSprite";
+export class AvatarEffectPart {
+    constructor(_sprite, _actionsData, _offsetsData, _effectData) {
+        this._sprite = _sprite;
+        this._actionsData = _actionsData;
+        this._offsetsData = _offsetsData;
+        this._effectData = _effectData;
+        this._directionOffset = 0;
+        this._offsets = new Map();
+        this._customFrames = [];
+    }
+    setDirection(direction) {
+        this._direction = direction;
+    }
+    setDirectionOffset(offset) {
+        this._directionOffset = offset;
+    }
+    getDirection(offset = 0) {
+        if (this._direction == null)
+            return;
+        if (!this._sprite.directions) {
+            return 0;
+        }
+        return getAvatarDirection(this._direction + this._directionOffset + offset);
+    }
+    setEffectFrame(effect, frame) {
+        const part = effect.getFrameEffectPart(this._sprite.id, frame);
+        if (part != null) {
+            let actionData = part.action != null
+                ? this._actionsData.getAction(part.action)
+                : undefined;
+            if (actionData == null) {
+                actionData = this._actionsData.getAction(AvatarAction.Default);
+            }
+            this._customFrames.push({
+                action: actionData,
+                frame: part.frame,
+                dd: part.dd,
+                dx: part.dx,
+                dy: part.dy,
+            });
+        }
+    }
+    setAvatarOffsets(avatarFrame, frame) {
+        this._offsets.set(frame, avatarFrame);
+    }
+    setEffectFrameDefaultIfNotSet() {
+        if (this._customFrames.length > 0)
+            return;
+        const action = this._actionsData.getAction(AvatarAction.Default);
+        this._customFrames.push({
+            action,
+        });
+    }
+    getDrawDefinition() {
+        var _a;
+        const assets = [];
+        const directionData = this._direction != null
+            ? this._effectData.getSpriteDirection(this._sprite.id, this._direction)
+            : undefined;
+        this._customFrames.forEach((customFrame) => {
+            var _a;
+            const action = customFrame.action;
+            if (action == null)
+                throw new Error("Invalid action");
+            const direction = this.getDirection(customFrame.dd);
+            if (direction == null)
+                return;
+            const asset = this._getAvatarAsset(direction, (_a = customFrame.frame) !== null && _a !== void 0 ? _a : 0, customFrame, directionData);
+            if (asset != null) {
+                assets.push(asset);
+            }
+        });
+        if (assets.length === 0)
+            return;
+        return {
+            assets: assets.flatMap((asset) => [asset, asset]),
+            addition: false,
+            kind: "EFFECT_DRAW_PART",
+            z: (_a = directionData === null || directionData === void 0 ? void 0 : directionData.dz) !== null && _a !== void 0 ? _a : 0,
+            ink: this._sprite.ink,
+        };
+    }
+    _getAvatarAsset(direction, frame, customFrame, directionData) {
+        var _a, _b, _c, _d;
+        if (this._sprite.member != null) {
+            const { id, offsets, flip } = getEffectSprite(this._sprite.member, direction, frame, this._offsetsData, this._sprite.directions, false);
+            if (offsets == null) {
+                return;
+            }
+            const { x, y } = applyOffsets({
+                offsets,
+                customOffsets: {
+                    offsetX: (_a = customFrame.dx) !== null && _a !== void 0 ? _a : 0 - ((_b = directionData === null || directionData === void 0 ? void 0 : directionData.dx) !== null && _b !== void 0 ? _b : 0),
+                    offsetY: (_c = customFrame.dy) !== null && _c !== void 0 ? _c : 0 + ((_d = directionData === null || directionData === void 0 ? void 0 : directionData.dy) !== null && _d !== void 0 ? _d : 0),
+                },
+                lay: false,
+                flipped: flip,
+            });
+            return {
+                fileId: id,
+                library: "",
+                mirror: flip,
+                x,
+                y,
+            };
+        }
+    }
+}
+export const getSpriteId = (member, direction, frame) => `h_${member}_${direction}_${frame}`;

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

@@ -0,0 +1,158 @@
+import { getAvatarDirection } from "../util/getAvatarDirection";
+import { getAssetForFrame } from "../util/getAssetForFrame";
+export class AvatarPart {
+    constructor(_figureDataPart, _color, { animationData, figureData, figureMap, offsetsData, partSetsData, }) {
+        this._figureDataPart = _figureDataPart;
+        this._color = _color;
+        this._directionOffset = 0;
+        this._assets = [];
+        this._customFrames = [];
+        this._frameRepeat = 1;
+        this._offsets = new Map();
+        this._animationData = animationData;
+        this._figureData = figureData;
+        this._figureMap = figureMap;
+        this._offsetsData = offsetsData;
+        this._partSetsData = partSetsData;
+    }
+    get type() {
+        return this._figureDataPart.type;
+    }
+    get index() {
+        return this._figureDataPart.index;
+    }
+    setFrameRepeat(value) {
+        this._frameRepeat = value;
+    }
+    setActiveAction(action) {
+        this._action = action;
+    }
+    setDirection(direction) {
+        this._direction = getAvatarDirection(direction);
+    }
+    addCustomFrame(customFrame) {
+        this._customFrames.push(customFrame);
+    }
+    setDirectionOffset(offset) {
+        this._directionOffset = offset;
+    }
+    setAvatarOffsets(avatarFrame, frame) {
+        this._offsets.set(frame, avatarFrame);
+    }
+    getDirection(offset = 0) {
+        if (this._direction == null)
+            return;
+        return getAvatarDirection(this._direction + this._directionOffset + offset);
+    }
+    /**
+     * Gets the draw definition for this specific part.
+     * This is a description how this part is drawn on the screen.
+     */
+    getDrawDefinition() {
+        this._update();
+        if (this._assets.length === 0) {
+            return;
+        }
+        return {
+            assets: this._assets.flatMap((asset) => new Array(this._frameRepeat).fill(0).map(() => asset)),
+            color: this._figureDataPart.colorable ? `#${this._color}` : undefined,
+            index: this._figureDataPart.index,
+            kind: "AVATAR_DRAW_PART",
+            mode: this._figureDataPart.type !== "ey" && this._figureDataPart.colorable
+                ? "colored"
+                : "just-image",
+            type: this._figureDataPart.type,
+            z: 0,
+        };
+    }
+    _getOffsetForFrame(frame) {
+        var _a, _b;
+        const data = this._offsets.get(frame);
+        if (data == null)
+            return { x: 0, y: 0 };
+        return {
+            x: (_a = data.dx) !== null && _a !== void 0 ? _a : 0,
+            y: (_b = data.dy) !== null && _b !== void 0 ? _b : 0,
+        };
+    }
+    _update() {
+        const partInfo = this._partSetsData.getPartInfo(this.type);
+        this._assets = [];
+        // If any custom frames are set, use them instead of the default animation behavior.
+        // This is usually used when effects override certain body parts and their actions/animations.
+        if (this._customFrames.length > 0) {
+            this._customFrames.forEach((customFrame, i) => {
+                var _a, _b;
+                const action = customFrame.action;
+                const direction = this.getDirection(customFrame.dd);
+                if (direction == null)
+                    throw new Error("Invalid direction");
+                const frame = this._animationData.getAnimationFrame(action.id, this.type, customFrame.frame);
+                const offset = this._getOffsetForFrame(i);
+                const asset = getAssetForFrame({
+                    animationFrame: frame,
+                    actionData: action,
+                    direction: direction,
+                    offsetsData: this._offsetsData,
+                    partId: this._figureDataPart.id,
+                    partType: this._figureDataPart.type,
+                    partTypeFlipped: partInfo === null || partInfo === void 0 ? void 0 : partInfo.flippedSetType,
+                    offsetX: ((_a = customFrame.dx) !== null && _a !== void 0 ? _a : 0) + offset.x,
+                    offsetY: ((_b = customFrame.dy) !== null && _b !== void 0 ? _b : 0) + offset.y,
+                });
+                if (asset != null) {
+                    this._assets.push(asset);
+                }
+            });
+            return;
+        }
+        const action = this._action;
+        const direction = this.getDirection();
+        if (action == null)
+            return;
+        if (direction == null)
+            return;
+        const frames = this._animationData.getAnimationFrames(action.id, this.type);
+        let framesIndexed = frames.flatMap((frame) => new Array(frame.repeats).fill(frame));
+        if (framesIndexed.length === 0) {
+            framesIndexed = [undefined];
+        }
+        if (this._offsets.size > 0) {
+            this._offsets.forEach((offset) => {
+                var _a;
+                const animationFrame = this._animationData.getAnimationFrame(action.id, this.type, (_a = offset.frame) !== null && _a !== void 0 ? _a : 0);
+                const asset = getAssetForFrame({
+                    animationFrame: animationFrame,
+                    actionData: action,
+                    direction: direction,
+                    offsetsData: this._offsetsData,
+                    partId: this._figureDataPart.id,
+                    partType: this._figureDataPart.type,
+                    partTypeFlipped: partInfo === null || partInfo === void 0 ? void 0 : partInfo.flippedSetType,
+                    offsetX: offset.dx,
+                    offsetY: offset.dy,
+                });
+                if (asset != null) {
+                    this._assets.push(asset);
+                }
+            });
+        }
+        else {
+            for (let i = 0; i < framesIndexed.length; i++) {
+                const frame = framesIndexed[i];
+                const asset = getAssetForFrame({
+                    animationFrame: frame,
+                    actionData: action,
+                    direction: direction,
+                    offsetsData: this._offsetsData,
+                    partId: this._figureDataPart.id,
+                    partType: this._figureDataPart.type,
+                    partTypeFlipped: partInfo === null || partInfo === void 0 ? void 0 : partInfo.flippedSetType,
+                });
+                if (asset != null) {
+                    this._assets.push(asset);
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,76 @@
+import { AvatarFigurePartType } from "../enum/AvatarFigurePartType";
+import { AvatarPart } from "./AvatarPart";
+export const basePartSet = new Set([
+    AvatarFigurePartType.LeftHand,
+    AvatarFigurePartType.RightHand,
+    AvatarFigurePartType.Body,
+    AvatarFigurePartType.Head,
+]);
+export 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(part, colorValue, _deps);
+                    this._registerPart(avatarPart);
+                });
+            }
+        });
+        if (itemId != null) {
+            this._addItem(itemId);
+        }
+        basePartSet.forEach((partType) => {
+            const partsForType = this._partsByType.get(partType);
+            if (partsForType == null || partsForType.length === 0) {
+                this._registerPart(new 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({
+            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]);
+    }
+}