Unity协程控制队列

最新推荐文章于 2024-09-12 17:53:15 发布
原创 最新推荐文章于 2024-09-12 17:53:15 发布 · 513 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#unity #游戏引擎

 

完整代码：

using System.Collections;
using System.Collections.Generic;
using System.Threading.Tasks;
using UnityEngine;

namespace GameLogic.CoroutinePipeline
{
    /// <summary>
    /// 运行协程的Mono
    /// </summary>
    public class CoroutineRunner : MonoBehaviour
    {
        public static CoroutineRunner Runner;

        private void Awake()
        {
            gameObject.hideFlags = HideFlags.HideAndDontSave;

            DontDestroyOnLoad(gameObject);
        }
    }

    /// <summary>
    /// 协程管线的管理类
    /// </summary>
    public static class PipelineManager
    {
        private static CoroutinePipeline mainPipeline;
        private static Dictionary<int, CoroutinePipeline> pipelinePool = new Dictionary<int, CoroutinePipeline>();

        /// <summary>
        /// 初始化方法
        /// </summary>
        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
        private static void Init()
        {
            CoroutineRunner.Runner = new GameObject("CoroutineRunner").AddComponent<CoroutineRunner>();
            mainPipeline = new CoroutinePipeline(0, true);
            pipelinePool.Add(0, mainPipeline);
            mainPipeline.Play();
        }

        /// <summary>
        /// 注销子管线
        /// </summary>
        /// <param name="index">管线索引</param>
        public static void DestroyPipeline(int index)
        {
            if (pipelinePool.ContainsKey(index) && index != 0)
            {
                pipelinePool.Remove(index);
            }
        }

        /// <summary>
        /// 获得索引对应的管线
        /// </summary>
        /// <param name="index">管线索引</param>
        /// <returns>索引对应的管线，若索引不存在返回主管线</returns>
        public static CoroutinePipeline GetPipeline(int index = 0)
        {
            if (pipelinePool.ContainsKey(index))
            {
                return pipelinePool[index];
            }
            else
            {
                return mainPipeline;
            }
        }

        /// <summary>
        /// 创建新的子管线
        /// </summary>
        /// <param name="isSustained">是否为持续管线</param>
        /// <returns></returns>
        public static int CreatePipeline(bool isSustained = false)
        {
            int index = 1;
            while (true)
            {
                if (!pipelinePool.ContainsKey(index))
                {
                    pipelinePool.Add(index, new CoroutinePipeline(index, isSustained));
                    return index;
                }
                index++;
            }
        }

        /// <summary>
        /// 将协程注册至协程管线
        /// </summary>
        /// <param name="enumerator">需要注册的协程</param>
        /// <param name="pipelineIndex">注册目标管线索引，默认为主管线</param>
        public static void EnPipeline(this IEnumerator enumerator, int pipelineIndex = 0)
        {
            GetPipeline(pipelineIndex).EnPipeline(enumerator);
        }


        /// <summary>
        /// 将协程注册至协程管线当前执行协程之后
        /// </summary>
        /// <param name="enumerator">需要注册的协程</param>
        /// <param name="pipelineIndex">注册目标管线索引，默认为主管线</param>
        public static void SyncInsertPipeline(this IEnumerator enumerator, int pipelineIndex = 0)
        {
            GetPipeline(pipelineIndex).SyncInsertPipeline(enumerator);
        }

        /// <summary>
        /// 将协程注册至协程管线中第一个等于插入目标的协程之后
        /// </summary>
        /// <param name="enumerator">需要注册的协程</param>
        /// <param name="target">插入目标</param>
        /// <param name="pipelineIndex">注册目标管线索引，默认为主管线</param>
        public static void AsyncInsertPipeline(this IEnumerator enumerator, IEnumerator target, int pipelineIndex = 0)
        {
            GetPipeline(pipelineIndex).AsyncInsertPipeline(enumerator, target);
        }

        /// <summary>
        /// 将协程注册至索引对应的协程管线中最新的并行监听中，若没有将新建立一个监听
        /// </summary>
        /// <param name="enumerator">需要注册的协程</param>
        /// <param name="pipelineIndex">注册目标管线索引，默认为主管线</param>
        public static void EnParallelListener(this IEnumerator enumerator, int pipelineIndex = 0)
        {
            ParallelPipeline pipeline = GetPipeline(pipelineIndex).GetLastParallelPipeline();
            if (pipeline != null)
            {
                enumerator.EnPipeline(pipeline.CreatePipeline());
            }
            else
            {
                pipeline = new ParallelPipeline(pipelineIndex);
                pipeline.EnPipeline();
                enumerator.EnPipeline(pipeline.CreatePipeline());
            }
        }
    }


    /// <summary>
    /// 管线的并行监听类
    /// </summary>
    public class ParallelPipeline
    {
        private List<CoroutinePipeline> coroutines;
        private CoroutinePipeline belongPipeline;

        public ParallelPipeline()
        {
            coroutines = new List<CoroutinePipeline>();
            this.belongPipeline = PipelineManager.GetPipeline();
        }

        public ParallelPipeline(List<CoroutinePipeline> coroutines)
        {
            coroutines = new List<CoroutinePipeline>(coroutines);
            this.belongPipeline = PipelineManager.GetPipeline();
        }

        public ParallelPipeline(CoroutinePipeline belongPipeline)
        {
            coroutines = new List<CoroutinePipeline>();
            this.belongPipeline = belongPipeline;
        }

        public ParallelPipeline(int belongPipelineIndex)
        {
            coroutines = new List<CoroutinePipeline>();
            this.belongPipeline = PipelineManager.GetPipeline(belongPipelineIndex);
        }

        public ParallelPipeline(CoroutinePipeline belongPipeline, List<CoroutinePipeline> coroutines)
        {
            coroutines = new List<CoroutinePipeline>(coroutines);
            this.belongPipeline = belongPipeline;
        }

        public ParallelPipeline(int belongPipelineIndex, List<CoroutinePipeline> coroutines)
        {
            coroutines = new List<CoroutinePipeline>(coroutines);
            this.belongPipeline = PipelineManager.GetPipeline(belongPipelineIndex);
        }

        /// <summary>
        /// 并行管线激活
        /// </summary>
        private void PipelineEnable()
        {

            foreach (var item in coroutines)
            {
                item.Play();
            }
        }

        /// <summary>
        /// 将并行管线注册至协程管线
        /// </summary>
        public void EnPipeline()
        {
            belongPipeline.EnParallelList(this);
            ParallelPipelineWaiter().EnPipeline(belongPipeline.index);
        }


        /// <summary>
        /// 将并行管线注册至协程管线当前执行协程之后
        /// </summary>
        public void SyncInsertPipeline()
        {
            belongPipeline.EnParallelList(this);
            ParallelPipelineWaiter().SyncInsertPipeline(belongPipeline.index);
        }

        /// <summary>
        /// 将并行管线注册至协程管线中第一个等于插入目标的协程之后
        /// </summary>
        /// <param name="target">插入目标</param>
        public void AsyncInsertPipeline(IEnumerator target)
        {
            belongPipeline.EnParallelList(this);
            ParallelPipelineWaiter().AsyncInsertPipeline(target, belongPipeline.index);
        }

        /// <summary>
        /// 添加管线至此监听
        /// </summary>
        /// <param name="coroutine"></param>
        public void AddPipeline(CoroutinePipeline coroutine)
        {
            coroutines.Add(coroutine);
        }

        /// <summary>
        /// 创建管线并添加至此监听
        /// </summary>
        /// <returns>创建的管线索引</returns>
        public int CreatePipeline()
        {
            int index = PipelineManager.CreatePipeline();
            coroutines.Add(PipelineManager.GetPipeline(index));
            return index;
        }

        /// <summary>
        /// 封装的监听协程
        /// </summary>
        private IEnumerator ParallelPipelineWaiter()
        {
            PipelineEnable();
            yield return ParallelHandle().AsIEnumerator();
        }

        private async Task ParallelHandle()
        {
            await Task.Run(() => Monitor());
        }

        public void Monitor()
        {
            try
            {
                while (true)
                {
                    if (coroutines.Count == 0)
                    {
                        continue;
                    }
                    int i = 0;
                    foreach (var item in coroutines)
                    {
                        if (!item.isEnd)
                        {
                            continue;
                        }
                        i++;
                    }
                    if (i == coroutines.Count)
                    {
                        belongPipeline.DeParallelList(this);
                        return;
                    }
                }
            }
            catch (System.Exception e)
            {
                Debug.LogError(e);
            }
        }

    }


    /// <summary>
    /// 协程管线实例
    /// </summary>
    public class CoroutinePipeline
    {
        public bool isEnd = false;
        private LinkedList<IEnumerator> coroutineLink = new LinkedList<IEnumerator>();
        private LinkedListNode<IEnumerator> isPlayNode;
        private List<ParallelPipeline> ParallelList = new List<ParallelPipeline>();
        private Coroutine coroutine;
        private bool isPause = true;
        private bool isSustained;
        public int index { private set; get; }

        public CoroutinePipeline(int index, bool isSustained = false)
        {
            this.index = index;
            this.isSustained = isSustained;
            coroutine = CoroutineRunner.Runner.StartCoroutine(Coroutine());
        }

        public void EnParallelList(ParallelPipeline pipeline)
        {
            ParallelList.Add(pipeline);
        }

        public void DeParallelList(ParallelPipeline pipeline)
        {
            ParallelList.Remove(pipeline);
        }

        public ParallelPipeline GetLastParallelPipeline()
        {
            if (ParallelList.Count == 0)
            {
                return null;
            }
            else
            {
                return ParallelList[ParallelList.Count - 1];
            }
        }

        /// <summary>
        /// 将协程注册至协程管线
        /// </summary>
        /// <param name="enumerator">需要注册的协程</param>
        public void EnPipeline(IEnumerator enumerator)
        {
            coroutineLink.AddLast(enumerator);
        }


        /// <summary>
        /// 将协程注册至协程管线当前执行协程之后
        /// </summary>
        /// <param name="enumerator">需要注册的协程</param>
        public void SyncInsertPipeline(IEnumerator enumerator)
        {
            if (isPlayNode == null)
            {
                coroutineLink.AddLast(enumerator);
            }
            else
            {
                coroutineLink.AddAfter(isPlayNode, enumerator);
            }
        }

        /// <summary>
        /// 将协程注册至协程管线中第一个等于插入目标的协程之后
        /// </summary>
        /// <param name="enumerator">需要注册的协程</param>
        /// <param name="target">插入目标</param>
        public void AsyncInsertPipeline(IEnumerator enumerator, IEnumerator target)
        {
            LinkedListNode<IEnumerator> node = coroutineLink.Find(target);
            if (node == null)
            {
                coroutineLink.AddLast(enumerator);
            }
            else
            {
                coroutineLink.AddAfter(node, enumerator);
            }
        }

        /// <summary>
        /// 管线暂停
        /// </summary>
        public void Pause()
        {
            isPause = true;
        }

        /// <summary>
        /// 管线播放
        /// </summary>
        public void Play()
        {
            isPause = false;
        }


        private IEnumerator Coroutine()
        {
            IEnumerator runingCoroutine = null;
            bool IsDone = true;

            while (!isEnd)
            {
                if (!isPause)
                {
                    if (runingCoroutine == null && coroutineLink.Count != 0)
                    {
                        isPlayNode = coroutineLink.First;
                        runingCoroutine = isPlayNode.Value;
                    }
                    else if (coroutineLink.Count == 0)
                    {
                        yield return null;
                    }

                    if (runingCoroutine != null)
                    {
                        IsDone = !runingCoroutine.MoveNext();

                        if (!IsDone)
                        {
                            yield return runingCoroutine.Current;
                        }
                        else
                        {
                            coroutineLink.RemoveFirst();
                            if (!isSustained && coroutineLink.Count == 0)
                            {
                                isEnd = true;
                            }
                            IsDone = true;
                            runingCoroutine = null;
                            isPlayNode = null;
                        }
                    }
                }
                yield return null;
            }
            PipelineManager.DestroyPipeline(index);
            CoroutineRunner.Runner.StopCoroutine(coroutine);
            yield break;
        }



    }

}

PlayerCreed
关注
一个Unity协程的队列方法-可方便排序执行顺序只能
大话程序员
10-30 769
记录一下，经常忘了 “协程”是什么，原理什么的就不多说了 也实现了清空和暂停的方法 /* 版本1.1 ========================= 已添加Stop和Destroy()时的自动退出协程 调用方法，如 ActionQueue.InitOneActionQueue(). AddAction(TryOne()) AddAction(CheckResources()). AddAction(Dow
Unity协程底层原理与实际应用：原理、实现、源码与工程实践
本博客聚焦游戏开发技巧、创业实战心得及大学热门课程干货。这里既有技术深度，也有思维广度，无论你是开发者、创业者还是高校学子，都能在这里找到适合自己的成长之路！
06-05 269
摘要：深入理解Unity协程的底层原理与最佳实践 Unity协程是游戏开发中常用的异步流程控制技术，本质上是基于C#迭代器机制与引擎主循环调度的"延续"机制。本文系统剖析了协程的核心原理，包括：C#迭代器与IEnumerator的状态机机制、yield返回对象的调度关系、Unity主循环与协程的交互过程。同时总结了协程在实际项目中的应用模式，如异步流程控制、时序动画、资源加载等场景，并提供了性能优化建议和工程实践案例。深入理解协程的底层原理有助于开发者避免内存泄漏、性能问题，构建更稳定高
Unity协程搭配队列开发Tips弹窗模块
無限進步的全棧遊戲開發的博客
09-07 1069
本文将探讨如何使用Unity的协程（Coroutine）配合队列（Queue）数据结构来构建一个高效且可扩展的Tips弹窗模块。
Unity3d 队列 方法 Queue
09-22
Unity3d 队列 方法 Queue
【Unity】运用协程设计任务执行队列
刘一码的博客
12-19 2602
在开发的时候，经常会遇到按照顺序执行一些任务的情况，但是其中一些任务必需满足一定条件后才能执行下一个任务，例如进入游戏后需要依次执行检查资源（等待与服务器对比完成）、下载资源（等待下载完成）、加载资源（等待加载完成）、初始化、进入游戏这几个方法，这个时候就容易逻辑混乱和写出一些臃肿的代码。于是我针对这个情况写了一个任务执行队列功能。 思路是将每个需要执行的方法都封装为一个IEnumerator，...
Unity协程队列，顺序分帧处理
蚂蚁蚂蚁
09-24 6910
游戏开发过程中经常会遇到要加载一片场景资源的情况，先不考虑如何加载的情况，对于一大片场景的加载和显示，如果在一帧内完成的话，对性能会有很大的小号，造成瞬间帧率下降，产生性能峰值。
unity协程搭配队列制作消息弹出模块
weixin_43948818的博客
06-03 810
制作unity消息弹出模块 需要的私有变量 private Queue<GameObject> m_TipsQueue = new Queue<GameObject>(); private bool isTipsShow = false; 协程模块代码 IEnumerator Timer(int sec,Action op) { yield return new WaitForSeconds(sec); op?.Invoke(); } 利用unity的Mono虚拟机的Upada
Unity协程(Coroutine)管理类——TaskManager工具分享
08-04
TaskManager是一个专门用于管理和调度Unity协程的类，旨在提高代码的可读性和可维护性，避免协程间的混乱和资源浪费。通过创建一个中央管理器，TaskManager可以帮助我们更好地组织和控制游戏中的各种任务。 首先，...
[Unity]控制大量角色队形想法
BuladeMian的博客，菜得抠脚，菜得真实
06-26 1575
队形的几种方式: 三角队形、长方形、正方形、圆形、椭圆 根据不同的方位 竖直、横向、 未完 参考资料： 1.unity3d：保持V字型队形，按路径点移动 2.【Unity闲谈】2D游戏的角色跟随，角色队列的实现 3. ...
Unity 动画（UITweener）、协程（Coroutine)和委托（Delegate）队列管理
茶向
12-06 1309
http://dsqiu.iteye.com/blog/2031778
unity3D Network Manager
05-29
unity3D Network Manager Unity 2018.4 文档地址 https://blog.youkuaiyun.com/nicepainkiller/article/details/117379600
编队飞行编队控制问题
02-07
很好的编队文件，大家尽情分享。 飞行编队 飞行协同
unity 用法 队列queue_Unity3d shader中Queue 使用渲染队列进行深度排序
weixin_42713608的博客
12-23 680
为了让我们真正明白透明度，我们需要了解一下深度排序，或者说，对象的绘制顺序。Unity允许我们控制一个特定对象绘制到屏幕上的顺序，因此我们可以更好地控制哪些对象应该覆盖在其他对象上。你可以把绘制顺序理解成Photoshop中的图层的概念。在处理透明度或者类似界面对象的元素时，绘制顺序尤其重要。本篇将会讲解如何使用Unity内置的标签(tags)来利用这个分层化的方法去渲染你的对象。这是非常重要的，...
Unity实现自己的协程系统
R3333355726856的博客
09-12 1192
Unity实现自己的协程系统
Unity 协程嵌套测试
蓝蓝的天涯
04-10 3600
通过return 嵌套，子协程执行完之后父进程才继续执行using System.Collections;using UnityEngine; public class test2 : MonoBehaviour { void Start () { Debug.Log("Start0"); StartCoroutine(test()); De
【Unity】Unity协程(Coroutine)的原理与应用
hafeiyangha的博客
06-20 7408
首先看一下Unity官方对协程的定义：Unity中的协程是一种返回值为的特殊函数，它可以主动的请求暂停自身并提交一个唤醒条件，Unity会在唤醒条件满足的时候去重新唤醒协程，所以协程还是运行在主线程上。
Unity 协程
热门推荐
明明明的博客
06-21 1万+
Unity 协程
Unity之简易任务队列TaskQueue
静风霁
07-09 5145
Unity之简易任务队列TaskQueue
unity协程详解
最新发布
03-23
当调用 `StartCoroutine()` 方法启动一个协程时，Unity 将会把对应的协程加入到调度队列中，在每一帧更新过程中逐步推进它的状态直到结束或者被手动停止。 #### 主要特点 - **分步执行**：通过多次调用 `MoveNext()...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值