@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

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

@@ -0,0 +1,36 @@
+import { AvatarActionInfo, IAvatarActionsData } from "../data/interfaces/IAvatarActionsData";
+import { AvatarEffectFrameFXPart, IAvatarEffectData } from "../data/interfaces/IAvatarEffectData";
+import { IAvatarGeometryData } from "../data/interfaces/IAvatarGeometryData";
+import { IAvatarOffsetsData } from "../data/interfaces/IAvatarOffsetsData";
+import { IAvatarPartSetsData } from "../data/interfaces/IAvatarPartSetsData";
+import { AvatarBodyPart } from "./AvatarBodyPart";
+import { AvatarPartList } from "./AvatarPartList";
+export declare class AvatarBodyPartList {
+    private _bodyParts;
+    private _bodyPartsById;
+    private _additions;
+    private _actionsData;
+    private _offsetsData;
+    private _partSetsData;
+    private _additionsArr;
+    constructor(_bodyParts: AvatarBodyPart[], { actionsData, offsetsData, partSetsData, }: {
+        actionsData: IAvatarActionsData;
+        offsetsData: IAvatarOffsetsData;
+        partSetsData: IAvatarPartSetsData;
+    });
+    static create(partList: AvatarPartList, hasItem: boolean, { geometry, partSetsData, actionsData, offsetsData, }: {
+        geometry: IAvatarGeometryData;
+        partSetsData: IAvatarPartSetsData;
+        actionsData: IAvatarActionsData;
+        offsetsData: IAvatarOffsetsData;
+    }): AvatarBodyPartList;
+    applyActions(actions: AvatarActionInfo[]): void;
+    applyEffectAdditions(effect: IAvatarEffectData): void;
+    setEffectFrame(effect: IAvatarEffectData, frame: number): void;
+    setAvatarOffsets(avatarFrameData: AvatarEffectFrameFXPart, frame: number): void;
+    setAdditionsDirection(direction: number): void;
+    setDirectionOffset(offset: number): void;
+    setBodyPartDirection(direction: number, headDirection?: number): void;
+    getBodyPartById(id: string): AvatarBodyPart | undefined;
+    private _getBodyPartById;
+}

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

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvatarBodyPartList = void 0;
+const associateBy_1 = require("../../../util/associateBy");
+const notNullOrUndefined_1 = require("../../../util/notNullOrUndefined");
+const AvatarAdditionPart_1 = require("./AvatarAdditionPart");
+const AvatarBodyPart_1 = require("./AvatarBodyPart");
+class AvatarBodyPartList {
+    constructor(_bodyParts, { actionsData, offsetsData, partSetsData, }) {
+        this._bodyParts = _bodyParts;
+        this._bodyPartsById = new Map();
+        this._additions = new Map();
+        this._additionsArr = [];
+        this._bodyPartsById = (0, associateBy_1.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_1.notNullOrUndefined)
+            .map((bodyPart) => new AvatarBodyPart_1.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_1.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);
+    }
+}
+exports.AvatarBodyPartList = AvatarBodyPartList;

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

@@ -0,0 +1,39 @@
+import { IAvatarEffectData } from "../data/interfaces/IAvatarEffectData";
+import { ParsedLook } from "../util/parseLookString";
+import { IAvatarEffectPart } from "./interface/IAvatarEffectPart";
+import { AvatarDependencies, AvatarDrawPart } from "../types";
+export declare class AvatarDrawDefinition implements IAvatarEffectPart {
+    private _options;
+    private _figureData;
+    private _actionsData;
+    private _geometry;
+    private _partSetsData;
+    private _animationData;
+    private _offsetsData;
+    private _figureMap;
+    private _direction;
+    private _directionOffset;
+    private _partList;
+    private _activeActions;
+    private _effectParts;
+    private _bodyParts;
+    private _drawParts;
+    constructor(_options: Options, { figureData, actionsData, geometry, partSetsData, animationData, offsetsData, figureMap, }: AvatarDependencies);
+    setDirection(direction: number): void;
+    setDirectionOffset(offset: number): void;
+    setEffectFrame(effect: IAvatarEffectData, frame: number): void;
+    setEffectFrameDefaultIfNotSet(): void;
+    getDrawDefinition(): AvatarDrawPart[];
+    private _getPartsForLook;
+    private _getActiveActions;
+}
+interface Options {
+    look: ParsedLook;
+    actions: Set<string>;
+    direction: number;
+    headDirection?: number;
+    frame: number;
+    item?: string | number;
+    effect?: IAvatarEffectData;
+}
+export {};

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

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvatarDrawDefinition = void 0;
+const notNullOrUndefined_1 = require("../../../util/notNullOrUndefined");
+const AvatarAction_1 = require("../enum/AvatarAction");
+const getAvatarDirection_1 = require("../util/getAvatarDirection");
+const getDrawOrderForActions_1 = require("../util/getDrawOrderForActions");
+const AvatarBodyPartList_1 = require("./AvatarBodyPartList");
+const AvatarEffectPart_1 = require("./AvatarEffectPart");
+const AvatarPartList_1 = require("./AvatarPartList");
+const BodyPartDrawOrder_1 = require("./BodyPartDrawOrder");
+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_1.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_1.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 = (0, getDrawOrderForActions_1.getDrawOrderForActions)(this._activeActions, {
+            hasItem: this._options.item != null,
+        });
+        const drawOrderDirection = (0, getAvatarDirection_1.getAvatarDirection)(this._direction + this._directionOffset);
+        const drawOrderBodyParts = BodyPartDrawOrder_1.BodyPartDrawOrder.getDrawOrder(drawOrderDirection, drawOrderId);
+        if (drawOrderBodyParts == null)
+            return [];
+        const sortedParts = drawOrderBodyParts
+            .map((id) => this._bodyParts.getBodyPartById(id))
+            .filter(notNullOrUndefined_1.notNullOrUndefined)
+            .flatMap((bodyPart) => {
+            return bodyPart.getSortedParts("vertical");
+        });
+        const drawParts = sortedParts
+            .map((part) => part.getDrawDefinition())
+            .filter(notNullOrUndefined_1.notNullOrUndefined);
+        const effectDrawParts = this._effectParts
+            .map((part) => part.getDrawDefinition())
+            .filter(notNullOrUndefined_1.notNullOrUndefined);
+        const sortedDrawParts = [...drawParts, ...effectDrawParts].sort((a, b) => a.z - b.z);
+        this._drawParts = sortedDrawParts;
+        return sortedDrawParts;
+    }
+    _getPartsForLook(look) {
+        const avatarList = new AvatarPartList_1.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_1.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;
+        });
+    }
+}
+exports.AvatarDrawDefinition = AvatarDrawDefinition;

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

@@ -0,0 +1,25 @@
+import { IAvatarActionsData } from "../data/interfaces/IAvatarActionsData";
+import { AvatarEffectFrameFXPart, AvatarEffectSprite, IAvatarEffectData } from "../data/interfaces/IAvatarEffectData";
+import { IAvatarOffsetsData } from "../data/interfaces/IAvatarOffsetsData";
+import { IAvatarEffectPart } from "./interface/IAvatarEffectPart";
+import { AvatarEffectDrawPart } from "../types";
+export declare class AvatarEffectPart implements IAvatarEffectPart {
+    private _sprite;
+    private _actionsData;
+    private _offsetsData;
+    private _effectData;
+    private _direction;
+    private _directionOffset;
+    private _offsets;
+    private _customFrames;
+    constructor(_sprite: AvatarEffectSprite, _actionsData: IAvatarActionsData, _offsetsData: IAvatarOffsetsData, _effectData: IAvatarEffectData);
+    setDirection(direction: number): void;
+    setDirectionOffset(offset: number): void;
+    getDirection(offset?: number): number | undefined;
+    setEffectFrame(effect: IAvatarEffectData, frame: number): void;
+    setAvatarOffsets(avatarFrame: AvatarEffectFrameFXPart, frame: number): void;
+    setEffectFrameDefaultIfNotSet(): void;
+    getDrawDefinition(): AvatarEffectDrawPart | undefined;
+    private _getAvatarAsset;
+}
+export declare const getSpriteId: (member: string, direction: number, frame: number) => string;

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

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSpriteId = exports.AvatarEffectPart = void 0;
+const AvatarAction_1 = require("../enum/AvatarAction");
+const getAssetFromPartMeta_1 = require("../util/getAssetFromPartMeta");
+const getAvatarDirection_1 = require("../util/getAvatarDirection");
+const getEffectSprite_1 = require("../util/getEffectSprite");
+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 (0, getAvatarDirection_1.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_1.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_1.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 } = (0, getEffectSprite_1.getEffectSprite)(this._sprite.member, direction, frame, this._offsetsData, this._sprite.directions, false);
+            if (offsets == null) {
+                return;
+            }
+            const { x, y } = (0, getAssetFromPartMeta_1.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,
+            };
+        }
+    }
+}
+exports.AvatarEffectPart = AvatarEffectPart;
+const getSpriteId = (member, direction, frame) => `h_${member}_${direction}_${frame}`;
+exports.getSpriteId = getSpriteId;

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

@@ -0,0 +1,54 @@
+import { AvatarActionInfo } from "../data/interfaces/IAvatarActionsData";
+import { IAvatarAnimationData } from "../data/interfaces/IAvatarAnimationData";
+import { AvatarEffectFrameFXPart } from "../data/interfaces/IAvatarEffectData";
+import { IAvatarOffsetsData } from "../data/interfaces/IAvatarOffsetsData";
+import { IAvatarPartSetsData } from "../data/interfaces/IAvatarPartSetsData";
+import { FigureDataPart, IFigureData } from "../data/interfaces/IFigureData";
+import { IFigureMapData } from "../data/interfaces/IFigureMapData";
+import { DefaultAvatarDrawPart } from "../types";
+export declare class AvatarPart {
+    private _figureDataPart;
+    private _color;
+    private _action;
+    private _direction;
+    private _directionOffset;
+    private _animationData;
+    private _figureData;
+    private _figureMap;
+    private _offsetsData;
+    private _partSetsData;
+    private _assets;
+    private _customFrames;
+    private _frameRepeat;
+    private _offsets;
+    constructor(_figureDataPart: FigureDataPart, _color: string | undefined, { animationData, figureData, figureMap, offsetsData, partSetsData, }: {
+        animationData: IAvatarAnimationData;
+        figureData: IFigureData;
+        figureMap: IFigureMapData;
+        offsetsData: IAvatarOffsetsData;
+        partSetsData: IAvatarPartSetsData;
+    });
+    get type(): string;
+    get index(): number;
+    setFrameRepeat(value: number): void;
+    setActiveAction(action: AvatarActionInfo): void;
+    setDirection(direction: number): void;
+    addCustomFrame(customFrame: CustomPartFrame): void;
+    setDirectionOffset(offset: number): void;
+    setAvatarOffsets(avatarFrame: AvatarEffectFrameFXPart, frame: number): void;
+    getDirection(offset?: number): number | undefined;
+    /**
+     * Gets the draw definition for this specific part.
+     * This is a description how this part is drawn on the screen.
+     */
+    getDrawDefinition(): DefaultAvatarDrawPart | undefined;
+    private _getOffsetForFrame;
+    private _update;
+}
+export interface CustomPartFrame {
+    action: AvatarActionInfo;
+    frame: number;
+    dx?: number;
+    dy?: number;
+    dd?: number;
+}

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

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvatarPart = void 0;
+const getAvatarDirection_1 = require("../util/getAvatarDirection");
+const getAssetForFrame_1 = require("../util/getAssetForFrame");
+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 = (0, getAvatarDirection_1.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 (0, getAvatarDirection_1.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 = (0, getAssetForFrame_1.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 = (0, getAssetForFrame_1.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 = (0, getAssetForFrame_1.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);
+                }
+            }
+        }
+    }
+}
+exports.AvatarPart = AvatarPart;