CursorManager.ts

export enum WiggleVariants {
    NORMAL,
}

export enum PointVariants {
    SHORT,
    NORMAL,
    LONG,
}

export type TweenConfig = {
    type: string;
    variant?: WiggleVariants | PointVariants;
    time?: number;
};

export class CursorManager {
    public static readonly CursorTweens = {
        WIGGLE: "wiggle",
        POINT: "point",
    };
    private static readonly WIGGLE = {
        KEY: CursorManager.CursorTweens.WIGGLE,
        X1: -4,
        Y1: 4,
        X2: -8,
        Y2: 0,
        DEFAULT_TIME: Phaser.Timer.QUARTER >> 1,
    };
    private static readonly POINT = {
        KEY: CursorManager.CursorTweens.POINT,
        0: {
            X: -2,
            Y: 2,
        },
        1: {
            X: -4,
            Y: 4,
        },
        2: {
            X: -6,
            Y: 6,
        },
        DEFAULT_TIME: Phaser.Timer.QUARTER >> 1,
    };

    private static readonly DEFAULT_MOVE_TIME = Phaser.Timer.QUARTER >> 1;
    private static readonly X_SHIFT = 8;

    private game: Phaser.Game;
    private group: Phaser.Group;
    private cursor: Phaser.Sprite;
    private position: {
        x: number;
        y: number;
    };

    private active_tween: Phaser.Tween;

    private cursor_default_pos: {x: number; y: number};
    public cursor_flipped: boolean;

    public constructor(game: Phaser.Game) {
        this.game = game;

        this.group = this.game.add.group();
        this.group.visible = false;
        this.group.transformCallback = () => {
            if (this.group.visible) {
                this.group.x += this.position.x - this.group.worldPosition.x;
                this.group.y += this.position.y - this.group.worldPosition.y;
            }
        };

        this.group.x = 0;
        this.group.y = 0;

        this.cursor = this.group.create(0, 0, "menu", "cursor");
        this.cursor.anchor.x = 0.5;

        this.active_tween = null;

        this.cursor_default_pos = {x: 0, y: 0};
        this.cursor_flipped = false;

        this.position = {
            x: 0,
            y: 0,
        };
    }

    public init_tween(config: TweenConfig, callback?: Function) {
        this.clear_tweens();
        if (!this.group.visible) this.show();

        switch (config.type) {
            case CursorManager.WIGGLE.KEY:
                let wiggle_x1 = CursorManager.WIGGLE.X1;
                let wiggle_x2 = CursorManager.WIGGLE.X2;
                let wiggle_y1 = CursorManager.WIGGLE.Y1;
                let wiggle_y2 = CursorManager.WIGGLE.Y2;
                let wiggle_time = config.time ? config.time : CursorManager.WIGGLE.DEFAULT_TIME;

                this.active_tween = this.game.add
                    .tween(this.position)
                    .to(
                        {x: this.position.x + wiggle_x1, y: this.position.y + wiggle_y1},
                        wiggle_time,
                        Phaser.Easing.Linear.None
                    )
                    .to(
                        {x: this.position.x + wiggle_x2, y: this.position.y + wiggle_y2},
                        wiggle_time,
                        Phaser.Easing.Linear.None
                    )
                    .to(
                        {x: this.position.x + wiggle_x1, y: this.position.y + wiggle_y1},
                        wiggle_time,
                        Phaser.Easing.Linear.None
                    )
                    .to({x: this.position.x, y: this.position.y}, wiggle_time, Phaser.Easing.Linear.None)
                    .loop();
                break;
            case CursorManager.POINT.KEY:
                if (config.variant === undefined) config.variant = PointVariants.NORMAL;
                let point_x = CursorManager.POINT[config.variant].X;
                let point_y = CursorManager.POINT[config.variant].Y;
                let point_time = config.time ? config.time : CursorManager.POINT.DEFAULT_TIME;

                if (this.cursor_flipped) point_x *= -1;

                this.active_tween = this.game.add
                    .tween(this.position)
                    .to(
                        {x: this.position.x + point_x, y: this.position.y + point_y},
                        point_time,
                        Phaser.Easing.Linear.None
                    )
                    .to({x: this.position.x, y: this.position.y}, point_time, Phaser.Easing.Linear.None)
                    .loop();
        }

        this.bring_to_top();
        if (this.active_tween) this.active_tween.start();
        if (callback) callback();
    }

    public move_to(
        pos: {x: number; y: number},
        params?: {animate?: boolean; flip?: boolean; move_time?: number; tween_config?: TweenConfig},
        on_complete?: Function
    ) {
        if (!this.group.visible) this.show();
        this.bring_to_top();

        const flip = params ? (params.flip !== undefined ? params.flip : false) : false;
        const animate = params ? (params.animate !== undefined ? params.animate : true) : true;
        const tween_config = params ? params.tween_config : undefined;
        const move_time = params
            ? params.move_time !== undefined
                ? params.move_time
                : CursorManager.DEFAULT_MOVE_TIME
            : CursorManager.DEFAULT_MOVE_TIME;

        if (flip !== this.cursor_flipped) this.flip_cursor();
        if (!tween_config) this.clear_tweens();

        pos.x += CursorManager.X_SHIFT;
        this.cursor_default_pos = {x: pos.x, y: pos.y};

        if (animate) {
            let tween = this.game.add
                .tween(this.position)
                .to({x: pos.x, y: pos.y}, move_time, Phaser.Easing.Linear.None, true);
            tween.onComplete.addOnce(() => {
                if (tween_config) this.init_tween(tween_config, on_complete);
                else {
                    if (on_complete) on_complete();
                }
            }, this);
        } else {
            this.position.x = pos.x;
            this.position.y = pos.y;

            if (tween_config) this.init_tween(tween_config, on_complete);
            else if (on_complete) on_complete();
        }
    }

    public clear_tweens() {
        if (this.active_tween) this.game.tweens.remove(this.active_tween);
        this.active_tween = null;

        this.position.x = this.cursor_default_pos.x;
        this.position.y = this.cursor_default_pos.y;
    }

    public flip_cursor() {
        this.clear_tweens();

        this.cursor.scale.x *= -1;
        this.cursor_flipped = this.cursor_flipped ? false : true;
    }

    public bring_to_top() {
        this.game.world.bringToTop(this.group);
    }

    public hide() {
        this.group.visible = false;
    }

    public show() {
        this.group.visible = true;
        this.group.updateTransform();
    }

    public destroy() {
        this.group.remove(this.cursor, true);
        this.group = null;
        this.cursor = null;
        this.active_tween = null;
    }
}