【原创】Unity小练习--倒计时（常用的Time类实例方法）

da11

//TimeScriptWork.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;  //Text组件要调用这个命名空间

public class TimeScriptWork : MonoBehaviour
{

    //Time类小练习，制作一个倒计时，两分钟计时，最后十秒字体变成红色，0秒停止倒计时。
    //扩展练习， 需要放在Updata里面执行。

    private Text TextTxt;  //获取Text组件变量

    private int fixCS; //隐藏变量，FIxedUpdata方法特用。
    private float UpCS;
    private int DJSTime;
    //private int NeedDJSTime;
    public int NeedDJSTime=16;  //可以通过面板设置一开始的倒计时时间，所以设置为public修饰符
    private int NeedDJSTimeCache = 16;   //倒计时时间缓存变量
    private bool IsRestDJSTime=true;
    private int RestDJSTime;   
    private float Time2Cache=1;  //判断Time.time时间差的变量


    private void Start()
    {
        //提示：找固定的组件引用在游戏开始就可以找了，没必要放在Update()中每0.02秒找一次，费资源
        TextTxt = this.GetComponent<Text>();

        //InvokeRepeating方法，在Start()中重复调用多次某一个方法
        //语法解析：InvokeRepeating("【要调用的方法名，没有括号】",【第一次执行的时间（int）（单位：秒）】,【每次执行间隔时间（int）（单位：秒）】)
        InvokeRepeating("Time3", 1, 1);

        //Invoke方法，延迟执行某一个方法(常用)
        //语法解析：IInvoke("【要调用的方法名，没有括号】",【第一次执行的时间（int）（单位：秒）】)
        //Invoke("Time3", 3);
    }

    private void Update()
    {
        //Time2();
    }



    //第一种倒计时方法，每执行一次updata方法计算一次每帧经过时间并累加 （Time.deltaTime）
    //适用于放在Updata方法，修改时间波动灵活，只需要修改以下的  UpCS >= 【波动时间】;
    //适合按下鼠标左键，子弹发射的频率。先做后在判断
    private void Time1()
    {
        print(NeedDJSTime);
        //通过按钮设置可以设置倒计时秒数
        if (IsRestDJSTime == false)
        {
            NeedDJSTime = RestDJSTime;
        }

        //通过面板设置的倒计时秒数
        if (NeedDJSTimeCache != NeedDJSTime)
        {
            DJSTime = 0;  //重新开始计时
            NeedDJSTimeCache = NeedDJSTime;  //判定重置
            Time.timeScale = 1;              //时间缩放恢复
        }


        //不通过面板设置的固定死的倒计时秒数，已注释
        #region
        /*     
        if (IsRestDJSTime==true)
        {
            NeedDJSTime = 16;
        }
        else
        {
            NeedDJSTime = RestDJSTime;
        }
        */

        //NeedDJSTime++; //这里需要倒计时的时间加一是因为要在开始计时时显示NeedDJSTime第一个数，与“不通过面板设置的固定死的倒计时秒数”联动使用
        #endregion

        //print(UpCS); //显示1秒内累计的每帧经过时间

        //剩余时间大于10秒执行
        if ((NeedDJSTime - DJSTime) > 10)
        {
            //当计算的“每执行一次updata方法计算一次每帧经过时间”大于等于1秒，就代表经过了一秒
            if (UpCS >= 1)
            {
                //倒计时时间加一
                DJSTime++;
                //将需要倒计时的时间减去DJSTime，就是现在剩余的时间
                TextTxt.text = DJSZH((NeedDJSTime - DJSTime));
                //变换Text文本字体颜色为黑色
                TextTxt.color = Color.black;

                //重置每帧经过时间，进入下一个计算一秒的循环
                UpCS = 0;

            }
        }
        else if ((NeedDJSTime - DJSTime) == 0) //+2代表需要显示0在显示游戏结束
        {
            //剩余时间等于0秒执行，倒计时结束，游戏暂停
            TextTxt.text = "倒计时结束";
            //时间缩放调整至0，代表暂停游戏，除非使用按钮重置恢复为1，否则会一直将受Time.timeScale影响的代码暂停
            Time.timeScale = 0;
        }
        else  //剩余时间在0-9秒之间的，字体变红
        {
            //当计算的“每执行一次updata方法计算一次每帧经过时间”大于等于1秒，就代表经过了一秒
            if (UpCS >= 1)
            {
                DJSTime++;
                TextTxt.text = DJSZH((NeedDJSTime - DJSTime));
                TextTxt.color = Color.red;

                //重置每帧经过时间，进入下一个计算一秒的循环
                UpCS = 0;
            }
        }

        //每执行一次updata方法计算一次每帧经过时间
        UpCS += Time.deltaTime;
    }

    //第二种倒计时方法，直接判断Time.time的时间是否超过判断值（Time.time）
    //适用于放在Updata方法，修改时间波动灵活，只需要修改以下的  Time2Cache = Time.time +【波动时间】;
    //适合敌人每走一个点，停顿以下，在走到下一个点。先等待判断的时间是否到了在执行动作
    private void Time2()
    {
        print(Time.time);
        if (Time2Cache >= Time.time)
        {
            TextTxt.text = DJSZH((int)(NeedDJSTime - Time.time));


            if ((NeedDJSTime - Time.time)< 9)
            {
                TextTxt.color = Color.red;
            }

            if (Time.time >= NeedDJSTime)
            {
                TextTxt.text = "倒计时结束";
                Time.timeScale = 0;
            }

            Time2Cache = Time.time + 1;
        }
    }

    //第三种倒计时方法，直接在Start()方法，重复调用此方法（常用）
    //每隔固定时间，重复执行某一个方法。
    private void Time3()
    {
        print(Time.time);
        TextTxt.text = DJSZH((int)(NeedDJSTime -= 1));


        if (NeedDJSTime - 1 < 9)
        {
            TextTxt.color = Color.red;
        }

        if (NeedDJSTime <= 0)
        {
            TextTxt.text = "倒计时结束";

            //取消InvokeRepeating的重复调用，此方法有两个重载，如实参不给参数，则取消此挂载物体的所有InvokeRepeating调用
            CancelInvoke("Time3");
        }
    }

    //拓展应用，重置计时和修改默认的倒计时时间（在Time2()调用）
    private void OnGUI()
    {
        if (GUILayout.Button("重置倒计时时间为16秒并开始计时"))
        {
            RestDJSTime = 16;
            DJSTime = 0;
            Time.timeScale = 1;
            IsRestDJSTime = false;

        }

        if (GUILayout.Button("设置倒计时时间为120秒并开始计时"))
        {
            RestDJSTime = 120;
            DJSTime = 0;
            Time.timeScale = 1;
            IsRestDJSTime = false;
        }


    }

    //以下使用的是FixedUpdata方法，不受渲染帧影响。（实际案例不建议使用）
    #region
    /*   
    private void FixedUpdate()
    {
        //需要倒计时的时间
        NeedDJSTime = 120;

        //剩余时间大于10秒执行
        if ((NeedDJSTime - DJSTime)>10)
        {
            //FixedUpdate方法每执行一次计算一次+1，每执行50次为1秒
            if (fixCS >= 50)
            {
                //倒计时时间加一
                DJSTime++;
                //将需要倒计时的时间减去DJSTime，就是现在剩余的时间
                //this.GetComponent<Text>().text = (NeedDJSTime - DJSTime).ToString();
                this.GetComponent<Text>().text = DJSZH((NeedDJSTime - DJSTime));

                fixCS = 0;

            }
        }
        else if((NeedDJSTime - DJSTime) == -1) //-1代表需要显示0在显示游戏结束
        {

            this.GetComponent<Text>().text = "游戏结束";
            //剩余时间等于0秒执行，倒计时结束，游戏暂停
            Time.timeScale = 0;


        }
        else
        {
            //剩余时间在10秒之间的，字体变红
            if (fixCS >= 50)
            {
                DJSTime++;
                //this.GetComponent<Text>().text = (NeedDJSTime - DJSTime).ToString();
                this.GetComponent<Text>().text = DJSZH((NeedDJSTime - DJSTime));
                this.GetComponent<Text>().color = Color.red;

                fixCS = 0;
            }
        }


        //FixedUpdate方法每执行一次计算一次+1，每执行50次为1秒
        fixCS++;
    }
    */
    #endregion

    //将时间转变成时分秒制的方法
    private string DJSZH(int DJSTime)
    {
        int Hou = 0;
        int min = 0;
        int sec = 0;

        Hou = DJSTime / 3600;
        //min = DJSTime - (Hou * 60);
        min = (DJSTime - (Hou *3600)) / 60 ;
        sec = (DJSTime - (Hou * 3600) - (min * 60));

        //直接使用占位符的格式转换（d2）向前补零，然后转换string类型返回最后的格式变成00:00:00
        //注意需要变量是整形时，占位符的转换格式才会生效。
        string cache = string.Format("{0:d2}:{1:d2}:{2:d2}", Hou, min, sec);

        return cache;
    }


}

da11

练习效果图如下：