2017-07-11 16:03:22 qq_17758883 阅读数 4616

下面即为一个简单的定时器代码,可以实现每隔几秒就重复执行一段代码的功能,比较实用的代码段:

  function Start () {

  StartCoroutine("DoSomething");

  }

  function DoSomething () {

  while (true) {

  //需要重复执行的代码就放于在此处

  print("DoSomething Loop");

  //设置间隔时间为10秒

  yield WaitForSeconds (10);

  }

  }

2015-03-08 15:07:59 Fredomyan 阅读数 1584
Unity3D提供的武器Coroutine,如果您因为一些所谓的”坑“,禁止自己或者他人使用,你将会失去一把锋利的武器,同时你也会”后悔“。
PS:当然并没有这么可怕..下面我们通篇介绍下Unity强大的“走走停停,分解压力”功能Coroutine.

最简单的解释:
你想在程序中每隔“多长时间”或者“下一帧”过后才继续执行一个程序块的剩余部分内容。
举几个使用场景:
[1]我们有一个复杂计算量非常大的处理逻辑,如果在同一帧执行,一定会导致游戏的卡顿,需要将这些大的逻辑处理“分割”到“每隔一帧”或者“2s过后”执行的小块中。
[2].网络传输的时候,需要等待文件下载完毕过后才能执行其他的任务,使用Coroutine可以帮助我们实现“xx事件完成过后,继续执行该程序块后续的内容”
[3].UI方面我们会遇到一次性加载过多的Item导致手机卡顿的问题,使用Coroutine可以帮助我们将加载过程进行“分割”,缓解卡顿的问题,给加载过程一个“一帧,或者1s的歇息”
[4].定时器
[5].执行一个带着时间点的函数队列
按照”走走停停“思想我们可以想出来很多的适用场景

为什么用?不需要复杂的多线程,不需要你去专门做一个效果定时器,自己去累加时间管理时间,最简单的方式就是使用Unity3D提供的Coroutine机制。(它并不是多线程,它和咱们的其他Script一样在同一个主线程执行)

总结:Coroutine就是提供给我们:方便暂停一个函数的执行(我们可以多次的暂停如果需要),直到我们设定的”条件“满足过后,继续执行该函数剩余的操作。在一个函数中你可以任意”暂停“和”继续执行“,只需要将你的代码块填到对应的位置即可。
既然Coroutine可以帮助我们完成这么多内容为何要抛弃它而不去了解它呢?

--------------------------------------------------------------步入正题ing---------------------------------------------------------------------------
Coroutine如果要满足我们的需求:”等“-”执行“-”等“-”执行“......需要什么特性呢?
1.对于我们一般的函数,当我们的函数执行完毕过后(return或者执行结束),所有的函数局部变量和”状态“都会被释放,但是对于Coroutine需要让一个函数多次的return,直到所有的return结束过后才会将函数的状态清空。

Coroutine In Detail?
如果对Coroutine内部的实现感兴趣,能够更好地掌握Coroutine,可以通过Google搜索”Unity3d coroutine in detail“可以搜索到很多有关介绍Coroutine使用的教程
这是其中一篇牛人的猜测(不需要翻墙也能看到,只不过有点慢...)写了有关Coroutine的内部实现猜测,牛人的猜测一般都是”真相“.

借助牛人的猜测,我在这里简单的总结下Coroutine的实现原理:内部其实是一个维护的迭代器(当你的协同报出错误的时候你可以看到提示的内容,会有一个MoveNext样子的错误提示,也可以验证)

IEnumerator e = TellMeASecret();
while(e.MoveNext())
{
     // If they press 'Escape', skip the cutscene
     if(Input.GetKeyDown(KeyCode.Escape)) { break; }
}
IEnumerator TellMeASecret()
{
  PlayAnimation("LeanInConspiratorially");
  while(playingAnimation)
    yield return null;

  Say("I stole the cookie from the cookie jar!");
  while(speaking)
    yield return null;

  PlayAnimation("LeanOutRelieved");
  while(playingAnimation)
    yield return null;
}

上代码应该看的很清楚,这个是文中进行的假设,将我们执行的Block代码块组织成一个迭代器,当执行完一个程序块过后,迭代器会自动执行MoveNext操作,我们也可以手动暂停终止。

怎么定?(YieldInstruction)
给我们提供的一些”Instructions“

我们也可以定义自己的YieldInstruction,确定如何进行”等待“
怎么启动:(StartCoroutine)

怎么暂停:(StopCoroutine?+yield break;)
只有使用string类型作为StartCoroutine启动的协同才能够被StopCoroutine进行暂停,如果你想暂停该GameObject启用的所有Coroutine直接用StopAllCoroutines();
当然也可以使用yield break;根据逻辑条件内部终止一个coroutine;
int waitCount = 5;
    private IEnumerator ExcuteSomething()
    {
        while(true)
        {
            yield return new WaitForSeconds(1f);
            waitCount --;
            //TODO
            if (waitCount >= 0)
            {
                //TODO
                Debug.Log("Wait count is " + waitCount);
            }
            else
                yield break;

        }
    }

下面我们举一些简单的例子说明Coroutine的使用方法和一些注意事项:
[1]最基本使用
using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    void Start() {
        print("Starting " + Time.time);
        StartCoroutine(WaitAndPrint(2.0F));
        print("Before WaitAndPrint Finishes " + Time.time);
    }
    IEnumerator WaitAndPrint(float waitTime) {
        yield return new WaitForSeconds(waitTime);
        print("WaitAndPrint " + Time.time);
    }
}
[2]定时器
    private IEnumerator CountDown(float fTime)
    {
        Debug.Log("Make a timer ftime is " + fTime);
        for(float timer = fTime;timer >= 0;timer -= Time.deltaTime)
            yield return 0;
        Debug.Log("After " + fTime + " log this message.");
        //TODO do something you want
    }
[3]指定一个时间执行函数序列,要知道其中的一个”坑“如果使用WaitForSeconds();你的TimeScale被设置成了0,那么你的Coroutine将不会返回除非你的TimeScale重新设置成了非0值,例子中展示了如何让启动的Coroutine不受到TimeScale的影响
public class CallEvents : MonoBehaviour
{
      
    public class CellEventFuntion
    {
        public float fTime;
        public CallBack callBack;
    }
    public delegate void CallBack();
    public delegate void CallBack<T>(T t);
    public delegate void CallBack<T, K>(T t1, K t2);

    public List<CellEventFuntion> eventList = new List<CellEventFuntion>();

    //设定一个根据时间调用的队列(每隔一定的时间调用不同的回调函数)
    public void CallFunctionListByTimes()
    {
        eventList.Clear();

        //添加新的Event到我们的list中
        CellEventFuntion newFunction = new CellEventFuntion();
        newFunction.fTime = 2.0f;
        newFunction.callBack = Function01;

        CellEventFuntion newFunction02 = new CellEventFuntion();
        newFunction02.fTime = 2.0f;
        newFunction02.callBack = Function02;

        CellEventFuntion newFunction03 = new CellEventFuntion();
        newFunction03.fTime = 2.0f;
        newFunction03.callBack = Funciton03;

        CellEventFuntion newFunction04 = new CellEventFuntion();
        newFunction04.fTime = 5.0f;
        newFunction04.callBack = Function04;

        eventList.Add(newFunction);
        eventList.Add(newFunction02);
        eventList.Add(newFunction03);
        eventList.Add(newFunction04);

        //进行执行List中所有的Event

        //将会受到TimeScale的影响
        //StartCoroutine(_CallFuctionListByTimes());
        //不会受到TimeScale的影响
        StartCoroutine(_CallFunctionListByTimeIgnoreTimeScale());
    }

    private IEnumerator _CallFuctionListByTimes()
    {
        foreach (CellEventFuntion fuction in eventList)
        {
            float fTime = fuction.fTime;
            yield return new WaitForSeconds(fTime);
            if (fuction.callBack != null)
                fuction.callBack();
        }
    }

    private IEnumerator _CallFunctionListByTimeIgnoreTimeScale()
    {
        foreach (CellEventFuntion function in eventList)
        {
            float fTime = function.fTime;
            yield return StartCoroutine(_WaitTimeEnd(fTime));
            if (function.callBack != null)
                function.callBack();
            //can be replaced by function.(这段是和使用_WaitTimeEnd一样的效果)
            //float start = Time.realtimeSinceStartup;
            //while (Time.realtimeSinceStartup < start + fTime)
            //{
            //    yield return null;
            //}
        }
    }

    private IEnumerator _WaitTimeEnd(float fTime)
    {
        float start = Time.realtimeSinceStartup;
        while (Time.realtimeSinceStartup < start + fTime)
        {
            yield return null;
        }
    }


    private void Function01()
    {
        //Debug.Log("--Call Function01**" + Time.time);
        Debug.Log("--Call Function01**" + Time.realtimeSinceStartup);
    }

    private void Function02()
    {
        //Debug.Log("--Call Function02**" + Time.time);
        Debug.Log("--Call Function02**" + Time.realtimeSinceStartup);
    }

    private void Funciton03()
    {
        //Debug.Log("--Call Function03**" + Time.time);
        Debug.Log("--Call Function03**" + Time.realtimeSinceStartup);
    }

    private void Function04()
    {
        //Debug.Log("--Call Function04**" + Time.time);
        Debug.Log("--Call Function04**" + Time.realtimeSinceStartup);
    }

    public void PauseGame()
    {
        Time.timeScale = 0.0f;
    }

    public void Resume()
    {
        Time.timeScale = 1.0f;
    }

    void OnDestroy()
    {
        StopAllCoroutines();
    }
}
你可以自己写一个测试用例,点击按钮把TimeScale设置不同的值,然后调用不同的启动函数,看看自己的Coroutine是否受到TimeScale的影响.


一些要注意的Notes或者说使用的”坑“:
多看文档

1.TimeScale的问题:使用了WaitForSeconds()如果将TimeScale设置0,则不会返回;.
2.Coroutine不是多线程,它和我们其他的脚本一样在主线程中顺序执行,它只是将我们的工作放置到”时间段“中执行而已.在Unity脚本执行流程中的具体位置可以参考文档
3.当你的GameObjet被删除的时候,对应的Coroutines也会被终止(如果你还担心,那就在脚本OnDestroy的时候StopAllCoroutines就行了).
4.没写一个Coroutine的时候都要看看终止的条件是什么,让Coroutine自己”自生自灭“是最好的写法,所以写的时候注意退出条件,否则除非给你的工程带来一些奇怪的问题(因为工程中的某个Coroutine一直在执行!).
5.disable的GameObject没办法启动协同.
6.多找资料,多实践,如果你害怕Coroutine,听别人说”坑“多,那他真的是在”坑“You.


网上找了很多Coroutine相关的资料,一些不错的献上
[1]一些使用注意事项http://answers.unity3d.com/questions/751178/when-using-coroutines-what-should-i-be-wary-of.html
[2]深入Coroutine的文章http://www.massimpressionsprojects.com/dev/altdevblog/2011/07/07/unity3d-coroutines-in-detail/

学习和使用Coroutine一定会给你带来开发效率,因为它是个很犀利的武器,装入武器库吧,别害怕,别逃避,如果发现真的是”坑“,那就写封信给Unity开发公司投诉吧.[哈哈哈]

希望看到这篇文章的人,能够对Coroutine进一步的了解,把Coroutine放入自己的武器库.
有什么想法,建议,错误,希望指出和交流.

.CodeForFreedom.


2019-03-04 09:18:32 qq_36228216 阅读数 199

首先展示一下几种Monobehavior的执行顺序。

几种Update的区别

Update: 每隔一段时间执行依次,但是隔的时间是不固定的。可能因为更新过程中执行的内容执行时间长度不同等各种原因产生差异

Fixedupdate: 每次调用的时间间隔相同。不会因为上一帧用时多久而改变下一帧调不调用。

 

 

2015-03-10 14:35:52 suifcd 阅读数 5144

使用unity编写代码的大多数使用的都是c#,c#中可以使用特定的语句来对代码的执行效率进行检测。

检测代码如下:

using UnityEngine;
using System.Collections;

public class Test: MonoBehaviour 
{
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.G))
        {
            TestExeTime();
        }
    }

    void TestExeTime()
    {
        System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();

        stopwatch.Start(); //  开始监视代码运行时间
        TestFunc();
        stopwatch.Stop(); //  停止监视

        //  获取当前实例测量得出的总时间
        System.TimeSpan timespan = stopwatch.Elapsed;
        //   double hours = timespan.TotalHours; // 总小时
        //    double minutes = timespan.TotalMinutes;  // 总分钟
        //    double seconds = timespan.TotalSeconds;  //  总秒数
        double milliseconds = timespan.TotalMilliseconds;  //  总毫秒数

        //打印代码执行时间
        Debug.Log(milliseconds);
    }

    void TestFunc()
    {
        int m = 124;
        int n = 256;
        int mn = m + n;
       Debug.Log(mn);
    }
}

运行,可得到如下结果:
这里写图片描述

将TestFunc()中的Debug.Log(mn);注释掉,再测试可得

    void TestFunc()
    {
        int m = 124;
        int n = 256;
        int mn = m + n;
       // Debug.Log(mn);
    }

这里写图片描述

2016-02-17 15:01:50 u014261855 阅读数 313

定时器:
Public float Max =10.0f;//
定义一个最大的时间

Void Update()//
在每一帧检测
{
if(max > 0.0f)
{
Max -= Time.deltaTime;
}
Else
{
Max=10.0f

…………
}
}//
每隔max时间执行else中代码;

Unity3D 代码优化

阅读数 681

没有更多推荐了,返回首页