@wiredsnippets/wsproom 0.0.0-stage → 2.0.0

package/dist/objects/furniture/util/visualization/parseAnimations.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAnimations = parseAnimations;
+function parseAnimations(visualization, set) {
+    const animations = visualization.animations
+        ? visualization.animations[0].animation
+        : undefined;
+    if (animations != null) {
+        animations.forEach((animation) => {
+            const animationId = animation["$"].id;
+            const animationLayers = animation.animationLayer;
+            const layerToFrames = new Map();
+            let frameCount = 1;
+            animationLayers.forEach((layer) => {
+                const layerId = layer["$"].id;
+                if (layer.frameSequence != null) {
+                    const frameSequenceFrames = layer.frameSequence[0].frame;
+                    const frames = frameSequenceFrames.map((frame) => frame["$"].id);
+                    const frameRepeatString = layer["$"].frameRepeat;
+                    layerToFrames.set(layerId, {
+                        frames,
+                        frameRepeat: frameRepeatString != null ? Number(frameRepeatString) : undefined,
+                    });
+                    if (frames.length > frameCount) {
+                        frameCount = frames.length;
+                    }
+                }
+            });
+            set(animationId, {
+                frameCount: frameCount,
+                layerToFrames,
+            });
+        });
+    }
+}

package/dist/objects/furniture/util/visualization/parseColors.d.ts

@@ -0,0 +1,2 @@
+import { VisualizationXmlVisualization } from "./VisualizationXml";
+export declare function parseColors(visualization: VisualizationXmlVisualization, set: (id: string, colorLayersMap: Map<string, string>) => void): void;

package/dist/objects/furniture/util/visualization/parseColors.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseColors = parseColors;
+function parseColors(visualization, set) {
+    const colors = visualization.colors && visualization.colors[0].color;
+    if (colors != null) {
+        colors.forEach(color => {
+            const id = color["$"].id;
+            const colorLayersMap = new Map();
+            const colorLayers = color.colorLayer;
+            colorLayers.forEach(layer => {
+                const layerId = layer["$"].id;
+                const color = layer["$"].color;
+                colorLayersMap.set(layerId, color);
+            });
+            set(id, colorLayersMap);
+        });
+    }
+}

package/dist/objects/furniture/util/visualization/parseDirections.d.ts

@@ -0,0 +1,5 @@
+import { Layer } from "./parseLayers";
+import { VisualizationXmlVisualization } from "./VisualizationXml";
+export declare function parseDirections(visualization: VisualizationXmlVisualization, set: (direction: number, layerMap: Map<string, Layer>) => void): {
+    validDirections: number[];
+};

package/dist/objects/furniture/util/visualization/parseDirections.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDirections = parseDirections;
+function parseDirections(visualization, set) {
+    const directions = visualization.directions[0].direction;
+    const validDirections = [];
+    for (let i = 0; i < directions.length; i++) {
+        const layerMap = new Map();
+        const directionNumber = Number(directions[i]["$"].id);
+        const directionLayers = directions[i].layer || [];
+        validDirections.push(directionNumber);
+        for (let j = 0; j < directionLayers.length; j++) {
+            const layer = directionLayers[j]["$"];
+            layerMap.set(layer.id, {
+                zIndex: layer != null && layer.z != null ? Number(layer.z) : undefined,
+                tag: undefined,
+                ink: undefined,
+                alpha: undefined,
+                ignoreMouse: undefined,
+            });
+        }
+        set(directionNumber, layerMap);
+    }
+    return {
+        validDirections,
+    };
+}

package/dist/objects/furniture/util/visualization/parseLayers.d.ts

@@ -0,0 +1,9 @@
+import { VisualizationXmlVisualization } from "./VisualizationXml";
+export type Layer = {
+    zIndex: number | undefined;
+    tag: string | undefined;
+    ink: string | undefined;
+    alpha: number | undefined;
+    ignoreMouse: string | undefined;
+};
+export declare function parseLayers(visualization: VisualizationXmlVisualization, set: (id: string, layer: Layer) => void): void;

package/dist/objects/furniture/util/visualization/parseLayers.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLayers = parseLayers;
+function parseLayers(visualization, set) {
+    if (visualization.layers != null) {
+        const layers = visualization.layers[0].layer;
+        const layersLength = layers == null ? 0 : layers.length;
+        for (let i = 0; i < layersLength; i++) {
+            const layer = layers[i]["$"];
+            set(layer.id, {
+                zIndex: layer != null && layer.z != null ? Number(layer.z) : 0,
+                tag: layer.tag,
+                ink: layer.ink,
+                alpha: layer.alpha != null ? Number(layer.alpha) : undefined,
+                ignoreMouse: layer.ignoreMouse,
+            });
+        }
+    }
+}

package/dist/objects/furniture/util/visualization/parseVisualization.d.ts

@@ -0,0 +1,17 @@
+import { AnimationData, FramesData } from "./parseAnimations";
+import { Layer } from "./parseLayers";
+import { VisualizationXml } from "./VisualizationXml";
+export type Visualization = {
+    directions: number[];
+    layerCount: number;
+    getColor: (colorId: string, layer: string) => string | undefined;
+    getLayer: (layerId: string) => Layer | undefined;
+    getAnimation: (animationId: string, layerId: string) => FramesData | undefined;
+    getFrameCount: (animationId: string) => number | undefined;
+    getDirectionLayerOverride: (direction: number, layerId: string) => Layer | undefined;
+    getAnimationDatas(): {
+        id: string;
+        data: AnimationData;
+    }[];
+};
+export declare function parseVisualization(xml: VisualizationXml): Visualization;

package/dist/objects/furniture/util/visualization/parseVisualization.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVisualization = parseVisualization;
+const parseAnimations_1 = require("./parseAnimations");
+const parseColors_1 = require("./parseColors");
+const parseDirections_1 = require("./parseDirections");
+const parseLayers_1 = require("./parseLayers");
+function parseVisualization(xml) {
+    const visualizations = xml["visualizationData"]["graphics"][0]["visualization"];
+    let parsedValidDirections = [];
+    for (let i = 0; i < visualizations.length; i++) {
+        const visualization = visualizations[i];
+        if (visualization["$"]["size"] == "64") {
+            const layerMap = new Map();
+            const colorMap = new Map();
+            const animationMap = new Map();
+            const directionMap = new Map();
+            const { validDirections } = (0, parseDirections_1.parseDirections)(visualization, (direction, layerMap) => directionMap.set(direction, layerMap));
+            parsedValidDirections = validDirections;
+            (0, parseAnimations_1.parseAnimations)(visualization, (id, data) => animationMap.set(id, data));
+            (0, parseColors_1.parseColors)(visualization, (id, colorLayersMap) => colorMap.set(id, colorLayersMap));
+            (0, parseLayers_1.parseLayers)(visualization, (id, layer) => layerMap.set(id, layer));
+            return {
+                layerCount: Number(visualization["$"]["layerCount"]),
+                getColor: (colorId, layer) => { var _a; return (_a = colorMap === null || colorMap === void 0 ? void 0 : colorMap.get(colorId)) === null || _a === void 0 ? void 0 : _a.get(layer); },
+                getAnimation: (animationId, layerId) => {
+                    var _a, _b;
+                    const frameInfo = (_b = (_a = animationMap
+                        .get(animationId)) === null || _a === void 0 ? void 0 : _a.layerToFrames) === null || _b === void 0 ? void 0 : _b.get(layerId);
+                    return frameInfo;
+                },
+                getFrameCount: (animationId) => { var _a; return (_a = animationMap.get(animationId)) === null || _a === void 0 ? void 0 : _a.frameCount; },
+                getLayer: (layerId) => layerMap.get(layerId),
+                getDirectionLayerOverride: (direction, layerId) => { var _a; return (_a = directionMap.get(direction)) === null || _a === void 0 ? void 0 : _a.get(layerId); },
+                getAnimationDatas: () => Array.from(animationMap).map(([animationId, data]) => ({
+                    id: animationId,
+                    data,
+                })),
+                directions: parsedValidDirections,
+            };
+        }
+    }
+    throw new Error("No visualization found");
+}

package/dist/objects/furniture/visualization/AnimatedFurnitureVisualization.d.ts

@@ -0,0 +1,40 @@
+import { IFurnitureVisualizationLayer, IFurnitureVisualizationView } from "../IFurnitureVisualizationView";
+import { FurnitureVisualization } from "./FurnitureVisualization";
+export declare class AnimatedFurnitureVisualization extends FurnitureVisualization {
+    private _animationQueue;
+    private _animationQueueStartFrame;
+    private _animationFrameCount;
+    private _currentAnimationId;
+    private _furnitureDrawDefintion;
+    private _sprites;
+    private _disableTransitions;
+    private _frame;
+    private _overrideAnimation;
+    private _modifier;
+    private _currentDirection;
+    private _currentTargetAnimationId;
+    private _changeAnimationCount;
+    private _lastFramePlayedMap;
+    private _refreshFurniture;
+    constructor();
+    get animationId(): number | undefined;
+    set animationId(value: number | undefined);
+    get modifier(): ((part: IFurnitureVisualizationLayer) => IFurnitureVisualizationLayer) | undefined;
+    set modifier(value: ((part: IFurnitureVisualizationLayer) => IFurnitureVisualizationLayer) | undefined);
+    setView(view: IFurnitureVisualizationView): void;
+    setCurrentAnimation(newAnimation: number): void;
+    updateAnimation(animation: string): void;
+    updateDirection(direction: number): void;
+    isLastFramePlayedForLayer(layerIndex: number): boolean;
+    destroy(): void;
+    update(): void;
+    updateFrame(frame: number): void;
+    isAnimated(animation?: string): boolean;
+    private _getCurrentProgress;
+    private _setAnimation;
+    private _updateLayers;
+    private _updateFurniture;
+    private _update;
+    private _getAnimationList;
+    private _updateAnimation;
+}

package/dist/objects/furniture/visualization/AnimatedFurnitureVisualization.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnimatedFurnitureVisualization = void 0;
+const FurnitureVisualization_1 = require("./FurnitureVisualization");
+class AnimatedFurnitureVisualization extends FurnitureVisualization_1.FurnitureVisualization {
+    constructor() {
+        super();
+        this._animationQueue = [];
+        this._sprites = new Set();
+        this._disableTransitions = false;
+        this._frame = 0;
+        this._changeAnimationCount = 0;
+        this._lastFramePlayedMap = new Map();
+        this._refreshFurniture = false;
+        this._refreshFurniture = true;
+    }
+    get animationId() {
+        if (this._overrideAnimation != null) {
+            return this._overrideAnimation;
+        }
+        return this._currentAnimationId;
+    }
+    set animationId(value) {
+        this._overrideAnimation = value;
+        this._refreshFurniture = true;
+    }
+    get modifier() {
+        return this._modifier;
+    }
+    set modifier(value) {
+        this._modifier = value;
+        this._updateFurniture();
+    }
+    setView(view) {
+        super.setView(view);
+        this._currentTargetAnimationId = undefined;
+        this._currentDirection = undefined;
+        this._currentAnimationId = undefined;
+    }
+    setCurrentAnimation(newAnimation) {
+        this._animationQueueStartFrame = undefined;
+        // Skip the transitions of the initial animation change.
+        this._animationQueue = this._getAnimationList(this.view.getVisualizationData(), newAnimation);
+        this._disableTransitions = this._changeAnimationCount === 0;
+        this._changeAnimationCount++;
+        this._update();
+    }
+    updateAnimation(animation) {
+        this._updateAnimation(this._currentTargetAnimationId, animation);
+    }
+    updateDirection(direction) {
+        if (this._currentDirection === direction)
+            return;
+        this._currentDirection = direction;
+        this._updateFurniture();
+    }
+    isLastFramePlayedForLayer(layerIndex) {
+        var _a;
+        return (_a = this._lastFramePlayedMap.get(layerIndex)) !== null && _a !== void 0 ? _a : false;
+    }
+    destroy() {
+        // Do nothing
+    }
+    update() {
+        if (this._currentDirection == null)
+            return;
+        this.view.setDisplayDirection(this._currentDirection);
+        this.view.updateDisplay();
+        this._update();
+    }
+    updateFrame(frame) {
+        if (this._refreshFurniture) {
+            this._refreshFurniture = false;
+            this._updateFurniture();
+        }
+        if (this._animationQueueStartFrame == null) {
+            this._animationQueueStartFrame = frame;
+        }
+        if (this._animationQueue.length > 0) {
+            const progress = this._getCurrentProgress(frame);
+            let frameCounter = 0;
+            let animationId;
+            let animationFrameCount;
+            for (let i = 0; i < this._animationQueue.length; i++) {
+                const animation = this._animationQueue[i];
+                frameCounter += animation.frameCount;
+                if (progress < frameCounter) {
+                    animationId = animation.id;
+                    animationFrameCount = animation.frameCount;
+                    break;
+                }
+            }
+            if (animationId == null ||
+                animationFrameCount == null ||
+                this._disableTransitions) {
+                const animation = this._animationQueue[this._animationQueue.length - 1];
+                animationId = animation.id;
+                animationFrameCount = animation.frameCount;
+            }
+            this._setAnimation(animationId);
+            this._animationFrameCount = animationFrameCount;
+            this._frame = progress;
+        }
+        this._update(true);
+    }
+    isAnimated(animation = "0") {
+        var _a;
+        if (!this.mounted)
+            return true;
+        const data = this.view.getVisualizationData();
+        const animationId = Number(animation);
+        if (Number.isNaN(animationId))
+            return true;
+        if (data.getTransitionForAnimation(64, animationId) != null)
+            return true;
+        const frameCount = (_a = data.getFrameCount(64, animationId)) !== null && _a !== void 0 ? _a : 1;
+        return frameCount > 1;
+    }
+    _getCurrentProgress(frame) {
+        if (this._animationQueueStartFrame == null) {
+            return 0;
+        }
+        return frame - this._animationQueueStartFrame;
+    }
+    _setAnimation(animation) {
+        if (this._currentAnimationId === animation)
+            return;
+        this._currentAnimationId = animation;
+        this._updateFurniture();
+    }
+    _updateLayers() {
+        if (this.modifier != null) {
+            const modifier = this.modifier;
+            this.view.getLayers().forEach((layer) => modifier(layer));
+        }
+    }
+    _updateFurniture() {
+        var _a;
+        var _b;
+        if (!this.mounted)
+            return;
+        this.view.setDisplayDirection((_b = this._currentDirection) !== null && _b !== void 0 ? _b : 0);
+        this.view.setDisplayAnimation((_a = this.animationId) === null || _a === void 0 ? void 0 : _a.toString());
+        this.view.updateDisplay();
+        this._updateLayers();
+        this._update();
+    }
+    _update(skipLayerUpdate = false) {
+        var _a;
+        const frameCount = (_a = this._animationFrameCount) !== null && _a !== void 0 ? _a : 1;
+        this.view.getLayers().forEach((part) => {
+            if (this.modifier != null) {
+                part = this.modifier(part);
+            }
+            const frameProgress = this._frame % frameCount;
+            // Each layer cycles through its own frame sequence independently, like
+            // the official client. The global frame count only bounds the animation
+            // as a whole — layers with a shorter sequence (or a different
+            // frameRepeat) wrap around instead of freezing on their last frame.
+            let frameIndex = Math.floor(frameProgress / part.frameRepeat);
+            if (part.assetCount > 0) {
+                frameIndex = frameIndex % part.assetCount;
+            }
+            else {
+                frameIndex = 0;
+            }
+            if (frameProgress === frameCount - 1) {
+                this._lastFramePlayedMap.set(part.layerIndex, true);
+            }
+            else {
+                this._lastFramePlayedMap.set(part.layerIndex, false);
+            }
+            part.setCurrentFrameIndex(frameIndex);
+        });
+    }
+    _getAnimationList(data, target) {
+        const animations = [];
+        const handleAnimation = (id) => {
+            var _a;
+            const transition = data.getTransitionForAnimation(64, id);
+            if (transition != null) {
+                handleAnimation(transition.id);
+            }
+            const animation = data.getAnimation(64, id);
+            const frameCount = (_a = data.getFrameCount(64, id)) !== null && _a !== void 0 ? _a : 1;
+            if (animation != null) {
+                animations.push({ id: animation.id, frameCount });
+            }
+        };
+        handleAnimation(target);
+        if (animations.length === 0) {
+            return [{ id: 0, frameCount: 1 }];
+        }
+        return animations;
+    }
+    _updateAnimation(oldAnimation, newAnimation) {
+        this._currentTargetAnimationId = newAnimation;
+        if (newAnimation == null) {
+            this.setCurrentAnimation(0);
+        }
+        else if (oldAnimation == newAnimation) {
+            // Do nothing
+        }
+        else if (oldAnimation != newAnimation) {
+            this.setCurrentAnimation(Number(newAnimation));
+        }
+    }
+}
+exports.AnimatedFurnitureVisualization = AnimatedFurnitureVisualization;
+const getAssetsCount = (part) => {
+    if (part.assets == null)
+        return 1;
+    return part.assets.length;
+};

package/dist/objects/furniture/visualization/BasicFurnitureVisualization.d.ts

@@ -0,0 +1,19 @@
+import { IFurnitureVisualizationView } from "../IFurnitureVisualizationView";
+import { FurnitureVisualization } from "./FurnitureVisualization";
+export declare class StaticFurnitureVisualization extends FurnitureVisualization {
+    private _sprites;
+    private _refreshFurniture;
+    private _currentDirection;
+    private _animationId;
+    setView(view: IFurnitureVisualizationView): void;
+    updateDirection(direction: number): void;
+    updateAnimation(animation: string): void;
+    updateFrame(): void;
+    update(): void;
+    destroy(): void;
+    private _update;
+}
+/**
+ * @deprecated Use `StaticFurnitureVisualization`
+ */
+export declare const BasicFurnitureVisualization: typeof StaticFurnitureVisualization;

package/dist/objects/furniture/visualization/BasicFurnitureVisualization.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BasicFurnitureVisualization = exports.StaticFurnitureVisualization = void 0;
+const FurnitureVisualization_1 = require("./FurnitureVisualization");
+class StaticFurnitureVisualization extends FurnitureVisualization_1.FurnitureVisualization {
+    constructor() {
+        super(...arguments);
+        this._sprites = [];
+        this._refreshFurniture = false;
+    }
+    setView(view) {
+        super.setView(view);
+        this._update();
+    }
+    updateDirection(direction) {
+        if (this._currentDirection === direction)
+            return;
+        this._currentDirection = direction;
+        this._update();
+    }
+    updateAnimation(animation) {
+        if (this._animationId === animation)
+            return;
+        this._animationId = animation;
+        this._update();
+    }
+    updateFrame() {
+        if (!this.mounted)
+            return;
+        if (this._refreshFurniture) {
+            this._refreshFurniture = false;
+            this._update();
+        }
+    }
+    update() {
+        this._update();
+    }
+    destroy() {
+        // Do nothing
+    }
+    _update() {
+        if (this._currentDirection == null)
+            return;
+        this.view.setDisplayAnimation(this._animationId);
+        this.view.setDisplayDirection(this._currentDirection);
+        this.view.updateDisplay();
+        this.view.getLayers().forEach((layer) => layer.setCurrentFrameIndex(0));
+    }
+}
+exports.StaticFurnitureVisualization = StaticFurnitureVisualization;
+/**
+ * @deprecated Use `StaticFurnitureVisualization`
+ */
+exports.BasicFurnitureVisualization = StaticFurnitureVisualization;

package/dist/objects/furniture/visualization/FurnitureBottleVisualization.d.ts

@@ -0,0 +1,17 @@
+import { IFurnitureVisualizationView } from "../IFurnitureVisualizationView";
+import { FurnitureVisualization } from "./FurnitureVisualization";
+export declare class FurnitureBottleVisualization extends FurnitureVisualization {
+    private static readonly ANIMATION_ID_OFFSET_SLOW1;
+    private static readonly ANIMATION_ID_OFFSET_SLOW2;
+    private static readonly ANIMATION_ID_ROLL;
+    private _base;
+    private _stateQueue;
+    private _running;
+    isAnimated(): boolean;
+    destroy(): void;
+    update(): void;
+    setView(view: IFurnitureVisualizationView): void;
+    updateFrame(frame: number): void;
+    updateDirection(direction: number): void;
+    updateAnimation(animation: string): void;
+}

package/dist/objects/furniture/visualization/FurnitureBottleVisualization.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FurnitureBottleVisualization = void 0;
+const AnimatedFurnitureVisualization_1 = require("./AnimatedFurnitureVisualization");
+const FurnitureVisualization_1 = require("./FurnitureVisualization");
+class FurnitureBottleVisualization extends FurnitureVisualization_1.FurnitureVisualization {
+    constructor() {
+        super(...arguments);
+        this._base = new AnimatedFurnitureVisualization_1.AnimatedFurnitureVisualization();
+        this._stateQueue = [];
+        this._running = false;
+    }
+    isAnimated() {
+        return true;
+    }
+    destroy() {
+        this._base.destroy();
+    }
+    update() {
+        this._base.update();
+    }
+    setView(view) {
+        super.setView(view);
+        this._base.setView(view);
+    }
+    updateFrame(frame) {
+        if (this._stateQueue.length > 0 &&
+            this._base.isLastFramePlayedForLayer(0)) {
+            const nextAnimation = this._stateQueue.shift();
+            if (nextAnimation != null) {
+                this._base.setCurrentAnimation(nextAnimation);
+            }
+        }
+        this._base.updateFrame(frame);
+    }
+    updateDirection(direction) {
+        this._base.updateDirection(direction);
+    }
+    updateAnimation(animation) {
+        if (animation === FurnitureBottleVisualization.ANIMATION_ID_ROLL.toString()) {
+            if (!this._running) {
+                this._running = true;
+                this._stateQueue.push(FurnitureBottleVisualization.ANIMATION_ID_ROLL);
+                return;
+            }
+        }
+        const animationNumber = Number(animation);
+        // Animation between 0 and 7 is the final value of the bottle. This directly translates to its direction.
+        if (animationNumber >= 0 && animationNumber <= 7) {
+            if (this._running) {
+                this._running = false;
+                this._stateQueue.push(FurnitureBottleVisualization.ANIMATION_ID_OFFSET_SLOW1);
+                this._stateQueue.push(FurnitureBottleVisualization.ANIMATION_ID_OFFSET_SLOW2 +
+                    animationNumber);
+                this._stateQueue.push(animationNumber);
+                return;
+            }
+            this._base.updateAnimation(animation);
+        }
+    }
+}
+exports.FurnitureBottleVisualization = FurnitureBottleVisualization;
+FurnitureBottleVisualization.ANIMATION_ID_OFFSET_SLOW1 = 20;
+FurnitureBottleVisualization.ANIMATION_ID_OFFSET_SLOW2 = 9;
+FurnitureBottleVisualization.ANIMATION_ID_ROLL = -1;

package/dist/objects/furniture/visualization/FurnitureGuildCustomizedVisualization.d.ts

@@ -0,0 +1,28 @@
+import { IFurnitureVisualizationView } from "../IFurnitureVisualizationView";
+import { FurnitureVisualization } from "./FurnitureVisualization";
+export declare class FurnitureGuildCustomizedVisualization extends FurnitureVisualization {
+    private static readonly PRIMARY_COLOR_TAG;
+    private static readonly SECONDARY_COLOR_TAG;
+    private _base;
+    private _primaryColor;
+    private _secondaryColor;
+    private _refreshModifier;
+    constructor(options?: {
+        primaryColor?: string;
+        secondaryColor?: string;
+    });
+    get primaryColor(): string | undefined;
+    set primaryColor(value: string | undefined);
+    get secondaryColor(): string | undefined;
+    set secondaryColor(value: string | undefined);
+    isAnimated(): boolean;
+    update(): void;
+    setView(view: IFurnitureVisualizationView): void;
+    destroy(): void;
+    updateFrame(frame: number): void;
+    updateDirection(direction: number): void;
+    updateAnimation(animation: string): void;
+    private _updateModifier;
+    private _normalizeColor;
+    private _modifyPart;
+}