TypeScript：实现队列思路与写法

import Conf, {Guide_combinationCfg, Guide_stepCfg, GuideCfg} from "../config/Conf";
import {UIMgr} from "./UIMgr";
import {LayerMgr} from "./LayerMgr";
import {LogicDispatcher} from "../../core/event/LogicDispatcher";
import GameEvent from "../main/events/GameEvent";
import GuideEffectView from "../main/view/guide/GuideEffectView";
import GuideTouchView from "../main/view/guide/GuideTouchView";
import GuideDialogueView from "../main/view/guide/GuideDialogueView";
import GLocalStorage from "../main/global/GLocalStorage";
import Global from "../main/global/Global";

/**
 * 新手引导管理类。检测、播放、停止都在此类进行
 * @author DuckKing
 * @Date: 2019-12-18 19:53:11
 * @Last Modified by: DuckKing
 * @Last Modified time: 2019-12-30 20:45:11
 * */
export default class GuideMgr
{
    private static _instance: GuideMgr;
    public static get instance(): GuideMgr
    {
        if(!this._instance)
            this._instance = new GuideMgr();
        return this._instance;
    }

    /** 新手引导队列*/
    public list: number[] = [];
    /** 新手引导步骤队列。*/
    public steps: number[] = [];
    /** 当前要执行的新手指引id*/
    public curGuideId: number = 0;
    /** 当前执行的新手指引步骤id*/
    public curStepId: number = 0;
    /** 当前是否正在执行新手指引*/
    public curRunGuide: boolean;
    /** 当前是否正在执行某个步骤*/
    public curRunStep: boolean;

    /** 当前已打开的组件面板*/
    private _panels: {[id:  number]: GuideTouchView | GuideDialogueView | GuideEffectView } = [];

    /**
     * 检测新手引导
     * @param id
     */
    public checkGuide(id: number): void
    {
        let key: string = `${Global.heroVo.name}${GLocalStorage.GUIDE_SAVE}${id}`;
        if(!GLocalStorage.getItem(key))
        {
            let cfg: GuideCfg = Conf.guide[id];
            if(cfg) this.createGuide(id);
        }
    }

    /**
     * 创建一个新手引导
     * @param id
     */
    public createGuide(id: number): void
    {
        this.list.push(id);
        this.checkIsRunGuide();
    }

    /**
     * 检测当前是否正在执行引导
     */
    public checkIsRunGuide(): void
    {
        if(this.curRunGuide) return;

        if(this.list.length > 0)
        {
            this.curGuideId = this.list.shift();
            this.playGuide(this.curGuideId);
        }
        else
        {
            let key: string = `${Global.heroVo.name}${GLocalStorage.GUIDE_SAVE}${this.curGuideId}`;
            GLocalStorage.setItem(key, "true");
            LogicDispatcher.event(GameEvent.GUIDE_OVER);
        }
    }

    /**
     * 播放一个新手引导
     * @param guideId
     */
    public playGuide(guideId: number): void
    {
        this.curRunGuide = true;
        this.curGuideId = guideId;

        let cfg: GuideCfg = Conf.guide[guideId];
        for(let temp of cfg.steps)
        {
            this.steps.push(temp);
        }

        this.checkIsRunStep();

        LogicDispatcher.on(GameEvent.GUIDE_OVER, this, this.onGuideComplete);
    }

    /**
     * 检测当前是否正在执行步骤
     */
    public checkIsRunStep(): void
    {
        if(this.curRunStep) return;

        //检测当前是否还有步骤未执行。。若没有继续检测上一级
        if(this.steps.length > 0)
        {
            this.curStepId = this.steps.shift();
            this.playStep(this.curStepId);
        }
        else
        {
            this.curRunGuide = false;
            this.checkIsRunGuide();
        }
    }

    /**
     * 播放一个步骤
     * @param stepId 步骤id
     */
    public playStep(stepId: number): void
    {
        this.curStepId = stepId;
        this.curRunStep = true;

        let cfg: Guide_stepCfg = Conf.guide_step[stepId];
        for(let i: number = 0; i < cfg.group.length; i++)
        {
            let groupId: number = cfg.group[i];
            let std: Guide_combinationCfg = Conf.guide_combination[groupId];

            let value: any = std.value;
            let node: Laya.Node;
            if(value)
            {
                if(value.btn)
                {
                    node = UIMgr.instance.getElementHandle(LayerMgr.rootLayer, value.btn);
                }
                else if(value.list)
                {
                    node = (UIMgr.instance.getElementHandle(LayerMgr.rootLayer, value.list) as Laya.List).cells[value.index];
                }
            }

            let panel: GuideTouchView | GuideEffectView | GuideDialogueView;
            switch (std.type)
            {
                //点击面板
                case 1:
                    panel = new GuideTouchView(std, node);
                    break;
                //特效面板
                case 2:
                    panel = new GuideEffectView(std, node);
                    break;
                //战斗面板
                case 3:
                    break;
                //对白面板
                case 4:
                    panel = new GuideDialogueView(std, node);
                    break;
            }
            this._panels[std.type] = panel;
            LayerMgr.rootLayer.addChild(panel);
        }

        if(cfg.lastDelay)
        {
            Laya.timer.once(cfg.lastDelay, this, this.closePanel)
        }

        LogicDispatcher.on(GameEvent.GUIDE_STEP_OVER, this, this.onStepComplete);
    }

    /**
     * 步骤配置里面如果配置了n秒后自动关闭面板
     */
    private closePanel(): void
    {
        for(let i in this._panels)
        {
            let temp = this._panels[i];
            LayerMgr.rootLayer.removeChild(temp);
        }
        LogicDispatcher.event(GameEvent.GUIDE_STEP_OVER);
    }

    /**
     * 某个新手指引结束后的回调函数
     */
    private onGuideComplete(): void
    {
        this.curRunGuide = false;

        let that = this;
        let std: GuideCfg = Conf.guide[this.curGuideId];
        Laya.timer.once(std.startDelay ? std.startDelay : 500, this, function() {
            that.checkIsRunGuide();
        })
    }

    /**
     * 某个步骤结束后的回调函数
     */
    private onStepComplete():void
    {
        this.curRunStep = false;

        for(let i in this._panels)
        {
            let temp: GuideTouchView | GuideDialogueView | GuideEffectView = this._panels[i];
            switch (i)
            {
                case "1":
                    (temp as GuideTouchView).clear();
                    break;
                case "2":
                    break;
            }

            LayerMgr.rootLayer.removeChild(temp);
        }

        let that = this;
        let std: Guide_stepCfg = Conf.guide_step[this.curStepId];
        Laya.timer.once(std.startDelay ? std.startDelay : 500, this, function () {
            that.checkIsRunStep();
        })
    }
}