Unity代码基础第七天之“API常用方法和类详细讲解”笔记

 

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;

public class Scene_a : MonoBehaviour
{
    public int a = 8; //七、Mathf类中的
    public int b = 20; //七、Mathf类中的
    public float t = 0; //七、Mathf类中的

    public Transform cube;//在二、Time时间类函数里面需要的

    public GameObject prefab;//在三、GameObject类中的
    public GameObject obja;//在三、GameObject类中的

    public GameObject targer;//在三、GameObject类中的

    public GameObject cubea;//在五、协程中的

    private IEnumerator ie;//在五、协程中的

    public Transform cubec;//在七、Mathf类

    public Transform cubed;//在七、Mathf类
    public Transform cubee;//在七、Mathf类

    public Rigidbody playerRgd;//十四、Rigidbody刚体组件中position和MovePosition控制移动

    public Transform enemy;

    private Camera mainCamera;//十六、Camera类和常用方法-摄像机
    void Start()
    {
       
       
        //print("游戏物体初始化运行一次");

        //三、GameObject类
        //1、创建物体的三种方法
        //1_1、new GameObject("组件名称");//创建出来的是空的游戏物体
        GameObject go = new GameObject("Cube");//创建Cube
        go.AddComponent<MeshRenderer>();//添加组件
        go.AddComponent<BoxCollider>();//添加组件
        go.AddComponent<MeshFilter>();//添加组件
        go.GetComponent<MeshRenderer>().material.color = Color.red;//给组件添加颜色

        //1_2、根据prefab进行实列化
        //GameObject.Instantiate(实列物体,开始位置，旋转位置);
        GameObject.Instantiate(prefab, obja.transform.position, transform.rotation);//复制prefab游戏物体

        //1_3.创建原始的形状（指定一个类型）
        GameObject.CreatePrimitive(PrimitiveType.Plane);//创建Plane

        //2、如何给游戏物体通过代码添加组件（组件可以是我们自己自定义的脚本）
        //GameObject go_a = GameObject.CreatePrimitive(PrimitiveType.Cube);//创建游戏物体cube
        //go_a.AddComponent<Rigidbody>();//给物体添加刚体组件
        //go_a.AddComponent<Scene1>();//给物体添加脚本

        //3.如何禁用和启用一个游戏物体
        //3_1.区分不同的游戏物体GameObject.FindWithTag
        GameObject go_b = GameObject.FindGameObjectWithTag("bja");
        Debug.Log(go_b);

        //3_2.判断游戏物体是否是激活状态activeInHierarchy
        go_b.SetActive(false);//false隐藏  true显示//如果不去获取物体，可以直接go_b.gameObject.SetActive(true);
        Debug.Log(go_b.activeInHierarchy);

        //4.UnityEngine.Object中的共有方法与变量：GameObject、Component和Object的关系
        //4_1.关系
        //游戏-场景-游戏物体（GameObject）-组件（Component）
        //1个游戏由多个场景组成-1个场景有多个游戏物体组成-1个游戏物体由多个组件组成

        //4_2.name: 名字-通过GameObject还是Component都是返回游戏物体的名字
        //unityEngine.Object对象由组件和（游戏物体）组成
        Debug.Log(prefab.name);
        Debug.Log(prefab.GetComponent<Transform>().name);//组件的名字跟游戏物体的名字是一样的

        //4_3.unityEngine下object拥有的静态(static)方法(FindObjectOfType、enabled)
        Light light = FindObjectOfType<Light>();//查找舞台上的light组件，也就是光源 //FindGameObjectWithTag :如果查到的是多个，则只返回查找到的第一个
        light.enabled = true;//flase是将组件禁用，这边光源就没了
        
        Transform[] ts = FindObjectsOfType<Transform>();
        foreach (Transform t in ts) {
            Debug.Log(t);
        }

        //5.GameObject独有的静态方法（查找）
        GameObject go_c = GameObject.FindGameObjectWithTag("bja");//返回的是单个
        GameObject[] go_cs = GameObject.FindGameObjectsWithTag("bja");//返回的是数组
        go_cs[0].SetActive(false);//false隐藏游戏物体

        //6.游戏物体间的消息的发送和接收
        //发送：
        //6_1.BroadcastMessage,当前游戏物体以及所有的孩子都会接收这个消息(前提是所有物体都挂有调用Attack方法的脚本，才可以生效)
        //发送消息，是不会显示的，需要方法去接收，才可以显示,方法要新建一个脚本，拖拽给另一个物体，然后去调用Attack方法名，列如：
        //targer.BroadcastMessage("Attack", null, SendMessageOptions.DontRequireReceiver);//Attack是方法名- //null传参数，可以为空null//DontRequireReceiver不一定需要接收者

        //6_2.只会针对当前游戏物体接收消息，不会给子集(前提是所有物体都挂有调用Attack方法的脚本，才可以生效)
        targer.SendMessage("Attack", null, SendMessageOptions.DontRequireReceiver);

        //6_3.//自身会调用，它的父亲，祖祖父都会调用(前提是所有物体都挂有调用Attack方法的脚本，才可以生效)
        //targer.SendMessageUpwards("Attack", null, SendMessageOptions.DontRequireReceiver);

        //接收：需要新建一个脚本去定义
        //void Attack()
        // {//接收的话，需要定义一个一模一样的方法Attack
        //    Debug.Log(this.gameObject + "物体之间的接收消息");
        // }

        //7.得到游戏物体、组件的各种方法函数(脚本是一个组件类型)
        //7_1.通过拖拽物体获取想要的组件(脚本是一个组件类型)
        Jieshou jiShoua = targer.GetComponent<Jieshou>();//通过拖拽的targer物体去查找jjeshou脚本
        Transform transformMo = targer.GetComponent<Transform>();//想获取拖拽物体targer的Transform组件

        //7_2.获取拖拽物体上挂载组件的数量
        Jieshou[] jieshouS = targer.GetComponents<Jieshou>();
        foreach (Jieshou y in jieshouS) {//不能用int类型去表示脚本，所以必须是脚本jieshou类型
            Debug.Log(y);//加length
        }

        //7_2.获取拖拽物体下面的所有孩子（游戏物体）
        Jieshou[] jieshouSa = targer.GetComponentsInChildren<Jieshou>();
        foreach (Jieshou y in jieshouSa)
        {//不能用int类型去表示脚本，所以必须是脚本jieshou类型
            Debug.Log(y);
        }

        //7_3.获取拖拽物体自身以及父亲
        Jieshou[] jieshouSb = targer.GetComponentsInParent<Jieshou>();
        foreach (Jieshou y in jieshouSa)
        {//不能用int类型去表示脚本，所以必须是脚本jieshou类型
            Debug.Log(y);
        }

        //8.删除游戏物体
        GameObject wuTi = GameObject.FindGameObjectWithTag("tagB");
        Destroy(wuTi);//删除游戏物体，但是不会立马在unity中删除，而是会先进行回收，等确定没对象使用的时候，在进行删除


        //四、MonoBehaviour里面的常用变量
        //1.gameObject是否处于激活状态-isActiveAndEnabled
        Debug.Log(this.isActiveAndEnabled);

        //2.控制游戏物体的组件显示与隐藏-enabled
        //是控制一个物体是否在屏幕上渲染或显示，而物体实s际还是存在，只是相当于隐身，而物体本身的碰撞体还依然存在的
        Debug.Log(this.enabled);

        //3.游戏物体的名称获取
        Debug.Log(name);//名称

        //4.游戏物体的tag标签获取
        Debug.Log(tag);//标签

        //5.游戏物体的组件获取
        Debug.Log(transform);

        //6.MonoBehaviour中Invoke的使用
        //6_1.多少时间后调用某个方法
        Invoke("TimeFuna", 11);

        //6_2.多少时间后调用某个方法，再过多少时间后再次重新调用
        InvokeRepeating("TimeFun",6,3);//方法名-时间1-时间2
         
        //6_2.补充一个：WaitForSeconds(1);//WaitForSeconds设置一个1s的时间

        //6_3.判断是否在调用方法，false是不在调用
        bool re = IsInvoking("TimeFun");
        Debug.Log(re);//有返回值返回bool型。正在调用就返回true 

        //6_4.取消方法名的调用,删除时间器
        CancelInvoke("TimeFun");//不指定参数会把所有的invoke取消

        //五、协程（Coroutine）-案例“见缝插针”
        //1.什么是协成？-Coroutine
        //普通方法：执行顺序是从上往下的，遇到方法会先执行方法里的，再继续往下执行
        //协成方法：但是如果你是执行的协成方法，遇到方法不会先执行方法里的，它会继续往下执行（并且自身可以暂停）

        //2.协成方法注意项（看CPU的强大，如果强，还是跟普通方法一样的调用顺序，如果不强，则会按它的规则顺序执行）

        //3.协程的4个特点
        //3_1.返回值是IEnumerator,也就是必须有返回值
        //3_2.返回参数的时候要使用到 yield return null可以是其他值
        //3_3.调用StartCoroutine（ie）;其中的ie是私有定义的一个对象，需要ie = Changecolorb();处理
        //3_4.关闭协成的方法StopCoroutine(ie);其中的ie是私有定义的一个对象，需要ie = Changecolorb();处理
        StartCoroutine(Fade());

        //六、鼠标相关事件函数OnMouseXXX
        //OnMouseDown//Debug.Log("按下的时候触发，只执行1次");
        //OnMouseOver//Debug.Log("当鼠标在触发物体的上面时，则一直触发");
        //OnMouseUp//Debug.Log("松开后执行1次");
        //OnMouseEnter/Debug.Log("当鼠标进入的时候触发，进入一次触发一次");
        //OnMouseDrag//Debug.Log("当鼠标按住不放的时候一直触发，是每一帧进行触发");
        //OnMouseExit//Debug.Log("当鼠标移出的时候触发1次");
        //OnMouseUpAsButton//("相当于是按钮的功能，当鼠标在同一个游戏物体上按下抬起的时候才会触发，按下与抬起不在同一个游戏上的话则不会进行触发。");

        //七、Mathf类-运动方式
        //1.Mathf里面的静态常量
        Debug.Log(Mathf.Deg2Rad);//度数转弧度
        Debug.Log(Mathf.Rad2Deg);//弧度数转度数
        Debug.Log(Mathf.Infinity);//无限大的数，表示不出来，会显示Infinity
        Debug.Log(Mathf.NegativeInfinity);//负的无限大的数-Infinity
        Debug.Log(Mathf.PI);//圆周率3.141593//默认保留6数小数
        Debug.Log(Mathf.Epsilon);//(小正数)一个很小的浮点数值。1.401298E-45

        //2.Mathf中的Clamp限定方法
        //cubeb.position = new Vector3(Mathf.Clamp(Time.time, 1.0F, 4.0F), 0, 0);//如果Time.time的值小于1F,就会返回1F,如果大于4F，就返回4F,所以从1运动到4后，就不再运动了
        //-要放在Update方法中一直执行才能动（注意如果父级中有移动的话，父级的位置也要算进去）


        //3.Mathf中的常用方法
        Debug.Log(Mathf.ClosestPowerOfTwo(2));//2  //取的2的power次方
        Debug.Log(Mathf.ClosestPowerOfTwo(3));//4   
        Debug.Log(Mathf.Max(1,2));//2
        Debug.Log(Mathf.Max(1, 2,5,3,10));//10 //取最大值
        Debug.Log(Mathf.Min(1, 2));//1
        Debug.Log(Mathf.Min(1, 2, 5, 3, 10));//1  //取最小值
        Debug.Log(Mathf.Pow(4, 3));//4的3次方 4*4*4 = 64
        Debug.Log(Mathf.Sqrt(3));//1.732051  //参数的平方根
        Debug.Log(Mathf.Abs(-26.55f));//26  取绝对值

        Debug.Log(Mathf.Ceil(28.45f));// 29 向上取整 float类型
        Debug.Log(Mathf.CeilToInt(26.55f));// 27 向上取整 int类型

        Debug.Log(Mathf.Floor(26.55f));// 26 向下取整 float类型
        Debug.Log(Mathf.FloorToInt(26.55f));// 26 向下取整 int类型

        Debug.Log(Mathf.Round(32.55f));//33  //四舍五入

        //4.插值运算(常用的)--特点是运动的话-先快后慢
        //Debug.Log(Mathf.Lerp(a, b, t));
        //基于浮点数t返回a到b之间的插值，t限制在0～1之间。当t = 0返回a，当t = 1 返回b。当t = 0.1-0.9 返回a和b的平均值。
        //特点是先快后慢
        cubec.position = new Vector3(0,0,0);
        cubed.position = new Vector3(0, 0, 0);
        //5.使用MoveTowards做匀速运动
        //和插值运算差不多

        //6使用PingPong方法实现乒乓的来回运动效果
        //cubee.position = new Vector3(Mathf.PingPong(Time.deltaTime * 3, 10), 0, 0);//循环值(Time.deltaTime * 3)，使输出不会大于等于l0，也不会小于0。

        //八、Input类输入类（键盘、鼠标、虚拟键盘、移动、鼠标坐标）
        //1.Input里面的GetKeyXXX的使用（键盘）
        //1_1.Input.GetKeyDown(KeyCode.S)//按下s键的时候
        //1_2.Input.GetKeyUp(KeyCode.S)//按下s键,松开的时候
        //1_3.Input.GetKey(KeyCode.S)//只要按键不抬起，就会一直触发

        //2.鼠标按键事件的监测（鼠标）
        //2_1.Input.GetKeyDown("left shift")//控制左边的shift键
        //2_2.Input.GetMouseButton(0)//left  //鼠标左键
        //2_3.Input.GetMouseButton(1)//right //鼠标右键
        //2_4.Input.GetMouseButton(2)//middle //鼠标中键

        //3.GetButtonXXX相关事件监测-虚拟键盘
        //3_1.input.GetButtonDown(string buttonName);“Fire1”  //buttonName要在unity里面的Edit-Project Settings-Input-Axes中填写

        //4.使用GetAxis得到轴的值的变化来控制移动（案例-梦幻世界）
        //float h = Input.GetAxis("Horizontal");//方向键，水平
        //float v = Input.GetAxis("Vertical");//垂直
        //rd.AddForce(new Vector3(h, 0, v) * speed);//移动 = 力的大小、力的方向 

        //5.屏幕坐标系和鼠标的坐标-检测是否有按键被按下
        //5_1.input.anykeyDown   //鼠标和键盘都触发  //检测是否有按键被按下
        //5_2.Debug.Log(Input.mousePosition);//鼠标当前移动的坐标，是以像素为单位

        //九、Vector2中的变量和方法
        //1.静态变量和公有变量
        //静态变量
        Debug.Log(Vector2.down);//0,-1 //向下
        Debug.Log(Vector2.up);//0,1
        Debug.Log(Vector2.left);//-1,0  //向左
        Debug.Log(Vector2.right);//1,0
        Debug.Log(Vector2.one);//1,1
        Debug.Log(Vector2.zero);//0,0
        

        //公有变量
        Vector2 a = new Vector2(2,2);//向量a
        Vector2 b = new Vector2(3,4);//向量b
        Vector2 c = new Vector2(3, 0);

        Debug.Log(a.magnitude);//2.828427  //返回向量的长度
        Debug.Log(a.sqrMagnitude);//8 //返回这个向量的长度的平方
        Debug.Log(b.magnitude);//5  //返回向量的长度
        Debug.Log(b.sqrMagnitude);//25  //返回这个向量的长度的平方

        Debug.Log(a.normalized);//返回向量的长度为1  （0.7，0.7）
        Debug.Log(b.normalized);//（0.6，0.8）

        //取一个向量的x和y有2种方法
        Debug.Log(a.x + "," + a.y);
        Debug.Log(a[0] + "," + a[1]);

        //2.向量是结构体
        //Vector2和Vector3是结构体，不是类，他们是有区别的!
        //比如：想修改x坐标
        transform.position = new Vector3(0,0,0);
        //transform.position.x = 10;//这样写是错的
        Vector3 por = transform.position;
        por.x = 10;
        transform.position = por;
        //类的话，就不是这样写了，方便的多，是可以直接修改的

        //3.二维向量Vector2中的静态方法
        Debug.Log(Vector2.Angle(a,b));//在a和b之间返回一个角度8.130115
        Debug.Log(Vector2.Angle(a, c));//45

        Debug.Log(Vector2.ClampMagnitude(c, 2));//返回向量的长度，最大不超过2所指示的长度。（2，0）
        Debug.Log(Vector2.Distance(b, c));//返回a和b之间的距离。4

        Debug.Log(Vector2.Lerp(a, b, 0.5f));//当t=0时，返回from。当t=1时，返回to。当t=0.5时放回from和to之间的平均数（2.5,3）
        Debug.Log(Vector2.LerpUnclamped(a, b, 0.5f));//（2.5,3）

        Debug.Log(Vector2.Lerp(a, b, 2f));//当t=0时，返回from。当t=1时，返回to。当t=0.5时放回from和to之间的平均数（3，4）
        Debug.Log(Vector2.LerpUnclamped(a, b, 2f));//（4，6）

        Debug.Log(Vector2.Max(a, b));//返回一个由两个向量的最大组件组成的向量。（3，4）
        Debug.Log(Vector2.Min(a, b)); //返回一个由两个向量的最小组件组成的向量。（2，2）

        //十、Vector3中的变量和方法
        //1.跟，Vector2有区别
        //2.比如：forward只有3维变量才有
        Debug.Log(Vector3.forward);//0,0,1

        //静态变量
        Debug.Log(Vector3.down);//0,-1,0 //向下
        Debug.Log(Vector3.up);//0,1,0
        Debug.Log(Vector3.left);//-1,0,0  //向左
        Debug.Log(Vector3.right);//1,0,0
        Debug.Log(Vector3.one);//1,1,1
        Debug.Log(Vector3.zero);//0,0,0
        
     
        //十一、对向量的加减乘除操作
        Vector2 res = b - a;//1,2
        Debug.Log(a+b);
        Debug.Log(b - a);
        Debug.Log(res*10);
        Debug.Log(res/5);
        Debug.Log(a == b);

        //十二、使用Random生成随机数

        //1.Debug.Log(Random.Range(4,10));//返回一个随机浮点数，在min（包含）和max（不包含）之间，不包括最大值
        //2.Random.InitState(0);//种子生成器//就是之前点击的随机数，重置之后，再次点击的顺序，是跟之前一致的

        //用种子生成器做一个随机数序列
        //Random.InitState((int)System.DateTime.Now.Ticks);

        //3.Random.value 返回0.0和1.0的数。
        Debug.Log(Random.value);

        //4.Random.rotation 旋转角度

        //5.Random.insideUnitSphere 返回半径为1的球体内的一个随机点

        //6.Random.onUnitSphere 返回半径为1的球体在表面上的一个随机点

        //十三、Quaternion类四元数介绍以及和欧拉角的区别
        //Quaternion（四元数）用于计算Unity旋转
        //Quaternion.LookRotation，//创建一个旋转，沿着forward（z轴）并且头部沿着upwards（y轴）的约束注视。也就是建立一个旋转，使z轴朝向view  y轴朝向up。
        //Quaternion.Angle  //返回a和b两者之间的角度。
        //Quaternion.Euler //欧拉角  返回一个旋转角度，绕z轴旋转z度，绕x轴旋转x度，绕y轴旋转y度（像这样的顺序）。
        //Quaternion.Slerp(from : Quaternion, to : Quaternion, t : float)   //球形插值，通过t值from向to之间插值。
        //Quaternion.FromToRotation (fromDirection : Vector3, toDirection : Vector3) //从fromDirection到toDirection创建一个旋转。
        //Quaternion.identity //同一性旋转（只读）。该四元数，相当于"无旋转"：这个物体完全对齐于世界或父轴。
        //Quaternion.Lerp(from : Quaternion, to : Quaternion, t : float)   通过t值from向to之间插值，并且规范化结果。
        //Quaternion.Slerp (from : Quaternion, to : Quaternion, t : float)  //球形插值，通过t值from向to之间插值。


        //十四、Rigidbody类-通过刚体控制游戏物体
        //一个游戏物体有Rigidbody刚体组件的情况下，推荐用，不然就用Transform.position
        //1.Rigidbody刚体组件中position和MovePosition控制移动
        //1_1.position-只是把刚体从一个位置设置到另一个位置
        //playerRgd.position = playerRgd.transform.position + Vector3.forward * Time.deltaTime;//此写法在此无效方法-在Update中有

        //1_2.MovePosition-持续移动的话
        //playerRgd.MovePosition = playerRgd.transform.position + Vector3.forward * Time.deltaTime;//此写法在此无效方法-在Update中有


        //2.通过刚体控制游戏物体旋转
        //一个游戏物体有Rigidbody刚体组件的情况下，推荐用，不然就用Transform.rotation
        //playerRgd.MoveRotation(Quaternion.Lerp(playerRgd.rotation, target, Time.deltaTime));//此写法在此无效方法-在Update中有

        //3.刚体组件的注意点；
        //如果一个物体的头部有其他物体，加上刚体组件运动后，会因为，头重，而倒下，这个时候，你需要调整，
        //刚体组件Rigidbody下面的Constraints中的X和Z打上对勾，说明要将X和Z固定住，这样就不会倒地了

        //十五、通过AddForce控制运动
        //AddForce (force : Vector3, mode : ForceMode = ForceMode.Force)//添加一个力到刚体。作为结果刚体将开始移动


        //十六、Camera类和常用方法-摄像机-射线检测(不管是什么物体他都可以检测的到)
        //1.获取的2种方法
        //1_1.全局查找
        mainCamera = GameObject.Find("Main Camera").GetComponent<Camera>();//全局查找

        //1_2.根据tag默认的标签进去查找
        mainCamera = Camera.main;//根据tag默认的标签进去查找

        //2.ScreenPointToRay把屏幕上的点转为一条射线-射线检测
        /*此方法要在Update，才能生效
        Ray ray = mainCamera.ScreenPointToRay(Input.mousePosition);//把屏幕上的点转为一条射线
        RaycastHit hit;//射线检测
        bool isCollider = Physics.Raycast(ray,out hit);//判断是否碰撞到
        if (isCollider) {//如果碰撞到了
            Debug.Log(hit.collider);//打印出碰撞到的物体  - 这样不管是什么物体他都可以检测的到
        }
        */

        //十七、Application获取datapath（Application中的常用静态变量和静态方法）在浏览器中打开url、退出游戏、截图
        //1.存放位置
        //创建StreamingAssets文件夹，不会被打包，一般放视频、音频等流文件

        //2.获取-Application.dataPath
        //2_1.在PC平台
        //2_2.在苹果平台
        //2_3.在安卓平台

        Debug.Log(Application.dataPath);//数据文件夹的路径//工程所在目录
        Debug.Log(Application.streamingAssetsPath);//工程所在下的streamingAssets文件夹
        Debug.Log(Application.persistentDataPath);//进行持久化的目录//数据预计将保持运行，可以被储存
        Debug.Log(Application.temporaryCachePath);//临时目录//临时数据可以被保存

        //3.常用静态变量
        //3_1.if (Application.isWebPlayer)//是否在一个网络播放器中运行？
        //3_2.if ( Application.isPlaying ) //处于播放模式时返回真

        //3_6.if (Application.srcValue != "game.unity3d")//相对于html文件的web播放器数据文件的路径
        Debug.Log(Application.identifier);//标识，默认的没有标识
        Debug.Log(Application.companyName);//Company没有设置
        Debug.Log(Application.productName);//项目名字
        Debug.Log(Application.installerName);//没有安装名
        Debug.Log(Application.isEditor);//是在Unity编辑器内运行
        Debug.Log(Application.isFocused);//默认最开始运行的时候game窗口是焦点的
        Debug.Log(Application.isMobilePlatform);//当前的运行时平台是否为已知的移动平台
        Debug.Log(Application.platform);//返回游戏运行的平台
        Debug.Log(Application.unityVersion);//用于播放内容的Unity运行时版本
        Debug.Log(Application.version);//游戏的版本可以自己设置
        Debug.Log(Application.runInBackground);//让游戏在后台时也运行

        //4.常用静态方法
        //4_1.Application.OpenURL ("http://game.ceeger.com/");//在浏览器中打开url
        //4_2.Application.Quit();//退出应用程序。在编辑器或者web播放器中退出被忽略
        //4_3.Application.CaptureScreenshot("游戏截图");//捕捉屏幕作为一个PNG文件保存在路径filename

        //十八、SceneManager类的静态方法和事件（如何切换加载场景）
        //注意：需要引用资源-using UnityEngine.SceneManagement;

        //1.静态方法
        //SceneManager.CreateScene//运行时用给定的名称创建一个空的新场景
        //SceneManager.GetActiveScene//获取当前场景激活的场景
        //SceneManager.GetSceneByBuildIndex//获取已加载场景列表里的索引值的场景
        //SceneManager.GetSceneByPath//从构建索引中获取一个场景结构
        //SceneManager.GetSceneByName//搜索所有加载场景的路径
        //SceneManager.LoadScene(0);//可以是场景名字加载、index加载
        //SceneManager.LoadSceneAsync//在背景中异步加载场景
        //SceneManager.MergeScenes//将一个游戏对象从当前场景移动到一个新的场景
        //SceneManager.SetActiveScene//将场景设置为激活状态
        //SceneManager.UnloadSceneAsync//销毁所有给场景相关的游戏对象，并从SceneManager中删除场景

        Debug.Log(SceneManager.sceneCount);//当前加载的场景数量
        Debug.Log(SceneManager.sceneCountInBuildSettings);//总场景数量
        Debug.Log(SceneManager.GetActiveScene().name);//获取当前场景激活的场景,的名字
        Debug.Log(SceneManager.GetSceneAt(0).name);//获取已加载场景列表的索引值的场景，的名字

        Debug.Log(SceneManager.GetSceneByName("Scenea").buildIndex);//返回index为0

        //2.事件
        //activeSceneChanged//场景发生改变时触发
        //SceneManager.sceneLoaded()//加载场景时触发
        //SceneManager.sceneUnloaded()//加载场景后触发



    }

    IEnumerator Changecolorb() {//改变物体的颜色
        print("协成1");
        yield return new WaitForSeconds(3);//上一句执行后在这句停3s再执行下一句
        cubea.GetComponent<MeshRenderer>().material.color = Color.blue;//给物体添加一个材质，蓝色
        print("协成2");
        yield return null;//不加会报错，因为这个方法要返回这个类型，所以要做一个返回，null可以是其他值
    }

    IEnumerator Fade()//Coroutine协程实现渐变效果
    {
        for (; ; )
        {
            //Color color = cubecolor.GetComponent<MeshRenderer>().material.color =new Color(i,i,i,i);
            Color color = cubea.GetComponent<MeshRenderer>().material.color;//获取当前颜色
            Color newcolor = Color.Lerp(color, Color.red, 0.02f);//当前颜色-新的颜色-用时
            cubea.GetComponent<MeshRenderer>().material.color = newcolor;//赋值
            yield return new WaitForSeconds(0.02f);//暂停一个时间来看变化0.2S一个变化
            if (Mathf.Abs(Color.red.g - newcolor.g) <= 0.01f)
            {//判断颜色什么时候结束，Mathf.Abs绝对值，如果2个颜色的g值，相差的值小于等于0.01就让它结束
                break;
            }

        }
    }

    void TimeFun() {
        Debug.Log("10s后调用");
    }
    void TimeFuna()
    {
        Debug.Log("11s后调用");
    }

    void Update()
    {
        //鼠标当前移动的坐标，是以像素为单位
        //Debug.Log(Input.mousePosition);


        //Debug.Log("每一帧都会运行这个方法");
        if (Input.GetKeyDown(KeyCode.Space)) {
            
            ie = Changecolorb();//必须这样去处理，不然后面不能关闭协程  ie是私有定义的一个对象

            // StartCoroutine(ie);//方式1
             StartCoroutine("Changecolorb");//方式2
        }

        if (Input.GetKeyDown(KeyCode.S)) {//按下s键的时候，触发
            Debug.Log(123);
            //StopCoroutine(Changecolorb());//这样关闭是无效的
            //StopCoroutine(ie);//方式1
            StopCoroutine("Changecolorb");//方式2
        }

        //种子生成器的运用
        if (Input.GetKeyDown(KeyCode.T)) {
            Debug.Log(Random.Range(4, 10));
        }

        //Mathf中的Clamp限定方法
        Transform cubeb = cubea.GetComponent<Transform>();
        cubeb.position = new Vector3(Mathf.Clamp(Time.time,1.0F,4.0F),0,0);//从1运动到3后，就不再运动了

        //插值运算
        //Debug.Log(Mathf.Lerp(a, b, t));//t = 0.5的时候，输出的是a-b的中间值
        //static function Lerp(from : float, to : float, t : float) : float
        //基于浮点数t返回a到b之间的插值，t限制在0～1之间。当t = 0返回from，当t = 1 返回to。当t = 0.5 返回from和to的平均值。
        float x = cubec.position.x;
        float newX = Mathf.Lerp(x,10,Time.deltaTime);//特点是先快后慢
        cubec.position = new Vector3(newX,0,0);


        //匀速运动
        float xa = cubed.position.x;
        float newXa = Mathf.MoveTowards(xa, 10, Time.deltaTime*3);//每秒3米的速度   - 特点是匀速
        cubed.position = new Vector3(newXa, 0, 0);

        //PingPong运动效果
        cubee.position = new Vector3(Mathf.PingPong(Time.time*3,10), 0, 0);//循环值(Time.deltaTime * 3)，使输出不会大于等于l0，也不会小于0。

        //鼠标中键
        if (Input.GetMouseButton(2)) {
            Debug.Log("middle");
        }

        //Rigidbody刚体组件中position和MovePosition控制移动
        //playerRgd.position = playerRgd.transform.position + Vector3.forward * Time.deltaTime;//只是把刚体从一个位置设置到另一个位置
        //playerRgd.MovePosition(playerRgd.transform.position + Vector3.forward * Time.deltaTime);//持续移动的话


        //刚体组件MoveRotation控制旋转
        /*if (Input.GetKey(KeyCode.P)) {
            Vector3 dir = enemy.position - playerRgd.position;
            //dir.y = -8.77f;
            //playerRgd.rotation = Quaternion.LookRotation(dir);
            Quaternion target = Quaternion.LookRotation(dir);
            playerRgd.MoveRotation(Quaternion.Lerp(playerRgd.rotation, target, Time.deltaTime));
        }
        */

        //通过AddForce控制运动
        float h = Input.GetAxis("Horizontal");//方向键，水平
        float v = Input.GetAxis("Vertical");//垂直
        playerRgd.AddForce(new Vector3(h, 0, v) * 3);//移动 = 力的大小、力的方向 

        //射线检测
        Ray ray = mainCamera.ScreenPointToRay(Input.mousePosition);//把屏幕上的点转为一条射线
        RaycastHit hit;//射线检测
        bool isCollider = Physics.Raycast(ray, out hit);//判断是否碰撞到
        if (isCollider)
        {//如果碰撞到了
            Debug.Log(hit.collider);//打印出碰撞到的物体  - 这样不管是什么物体他都可以检测的到
        }
        
        //查看射线
        //Ray ray = mainCamera.ScreenPointToRay(new Vector3(200, 200, 0));
        //Debug.DrawRay(ray.origin,ray.direction*10,Color.red);


    }

    private void LateUpdate()
    {
        Debug.Log("每一帧都会运行这个方法,晚于Update的运行顺序");
    }
    private void Awake()
    {
        Debug.Log("都是在游戏物体初始化运行一次，但是Awake的运行顺序高于Start的，并且只要脚本中存在Awake方法，则无论是否挂载了该脚本都会执行该方法");
    }

    private void Reset()
    {
        Debug.Log("游戏物体上按reset时触发");
    }
}
//一、事件函数
//Reset() :被附加脚本时、在游戏物体的组件上按Reset时会触发该事件函数
//Start() :在游戏初始化时会执行一次
//Update() :每一帧都会运行这个方法
//LateUpdate() Update(): 晚于Update的运行顺序，但是FPS和Update是一样的
//Awake() Start() : 都是在游戏物体初始化运行一次，但是Awake的运行顺序高于Start的，并且只要脚本中存在Awake方法，则无论是否挂载了该脚本都会执行该方法
//OnEnable(): 当将物体的SetActive设置为true时就会自动调用调用该方法
//OnDestory(): 当关闭游戏则会调用该方法
//FixedUpdate(): 会在指定帧调用该方法多少次


//二、Time时间类函数：
//Time.time 表示从游戏开发到现在的时间，会随着游戏的暂停而停止计算。
//Time.timeSinceLevelLoad 表示从当前Scene开始到目前为止的时间，也会随着暂停操作而停止。
//Time.deltaTime 表示从上一帧到当前帧时间，以秒为单位。【一般用来控制角色、动画的运动】
//举例：cube.Translate(Vector3.forward * Time.deltaTime * 3);//1s运行3米

//Time.fixedTime 表示以秒计游戏开始的时间，固定时间以定期间隔更新（相当于fixedDeltaTime）直到达到time属性。
//Time.fixedDeltaTime 表示以秒计间隔，在物理和其他固定帧率进行更新，在Edit->ProjectSettings->Time的Fixed Timestep可以自行设置。
//Time.SmoothDeltaTime 表示一个平稳的deltaTime，根据前 N帧的时间加权平均的值。
//Time.timeScale 时间缩放，默认值为1，若设置<1，表示时间减慢，若设置>1,表示时间加快，可以用来加速和减速游戏，回放等、非常有用。如果游戏中控制运动的都是使用了Time.deltatime的话，则可以通过设置Time.timeScale=0来暂停其运动等。
//举例：Time.timeScale = 3f;//1s运行9米，对所有deltaTime的进行加速，Time.timeScale = 0;//可以用来暂停动画

//Time.frameCount 总帧数
//Time.realtimeSinceStartup 表示自游戏开始后的总时间，即使暂停也会不断的增加。【一般用作性能测试】
//Time.captureFramerate 表示设置每秒的帧率，然后不考虑真实时间。
//Time.unscaledDeltaTime 以秒计算，完成最后一帧的时间 不考虑timescale时候与deltaTime相同，若timescale被设置，则无效。
//Time.unscaledTime 从游戏开始到现在所用的时间 不考虑timescale时候与time相同，若timescale被设置，则无效。