devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Unity常用API方法与类

作者：weixin_40725706 | 2024-02-16 12:36:16

赞

踩

unity常用api

一、事件函数（生命周期函数）

1. Reset()

调用情况：此函数只能在编辑器模式下（不运行时）调用；

调用时间：当脚本第一次挂载到对象身上或者使用了Reset命令之后调用；

调用次数与作用：会调用一次，来初始化脚本的各个属性，Reset最常用于在检视面板中提供良好的默认值。

2. Awake()

调用情况：

（1）在加载场景时，初始化包含脚本的激活状态的 GameObject时；

（2）GameObject从非激活状态转变为激活状态时；

（3）在初始化使用Instantiate创建的GameObject之后；

调用时间、次数与作用：

在脚本实例的生存期内，Unity仅调用Awake一次。脚本的生存期持续到包含它的场景被卸载为止。Unity调用每个GameObject的Awake的顺序是不确定的，人为干涉（即设计）来保证程序的正确性和稳定性。Awake来代替构造函数进行初始化，在Unity这里，组件的初始化不适用构造函数。

3. OnEnable()

调用情况：

（1）游戏物体被激活；

（2）脚本组件被激活；

调用时间、次数与作用：

每次游戏物体或者脚本被激活都会调用一次；重复赋值；变为初始状态；

4. Start()

调用情况：

（1）游戏物体被激活；

（2）脚本组件被激活；

调用时间、次数与作用：

在脚本实例激活时，在第一帧的Update之前被调用，在Awake之后执行，方便控制逻辑的前后调用顺序。

5. Update()

调用情况：

（1）游戏物体被激活；

（2）脚本组件被激活；

调用时间、次数与作用：

每帧调用，是最常用函数；每秒调用60次左右（根据当前电脑的性能和状态）；

实时更新数据，接受输入数据。

6. LateUpdate()

调用情况：

（1）游戏物体被激活；

（2）脚本组件被激活；

调用时间、次数与作用：

LateUpdate在调用所有Update函数后调用，每秒调用60次左右，安排脚本的执行顺序，比如摄像机跟随，一定是人物先移动了，摄像机才会跟随。

7. OnDisable()

调用情况：

（1）游戏物体被禁用；

（2）脚本组件被禁用；

（3）游戏物体被销毁；

调用时间、次数与作用：

满足调用情况时即时调用一次，用于一些对象的状态重置，资源回收与清理。

8. OnApplicationQuit()

调用情况：

（1）在程序退出之前所有的游戏对象都会调用这个函数；

（2）在编辑器中会在用户终止播放模式时调用；

（3）在网页视图关闭时调用；

调用时间、次数与作用：

满足调用情况时即时调用一次，用于处理一些游戏退出后的逻辑。

9. OnDestroy()

调用情况：

（1）场景或游戏结束；

（2）停止播放模式将终止应用程序；

（3）在网页视图关闭时调用；

（4）当前脚本被移除；

（5）当前脚本挂载到的游戏物体被删除；

调用时间、次数与作用：

满足调用情况时即时调用一次，用于一些游戏物体的销毁。

二、游戏物体

1. 创建方式

（1）使用构造函数（声明+实例化），创建一个空的游戏对象；

GameObject myGo=new GameObject("MyGameObject");

（2）根据现有的预制体（游戏物体）资源或者游戏场景已有的游戏物体来实例化；

GameObject.Instantiate(grisGo);

（3）使用特别的API创建一些基本的游戏物体类型（原始几何体）

GameObject.CreatePrimitive(PrimitiveType.Plane);

2.游戏物体的查找和获取

a.有引用

Debug.Log("当前游戏物体的状态是："+gameObject.activeInHierarchy);

Debug.Log("当前游戏物体的状态是："+gameObject.activeSelf);

b.没有直接引用（这时的游戏物体必须是激活状态）

（1）通过名称查找

GameObject mainCameraGo=GameObject.Find("Main Camera");

（2）通过标签查找

GameObject mainCameraGo=GameObject.FindGameObjectWithTag("MainCamera");

（3）通过类型查找

Script script=GameObject.FindObjectOfType<Script>();

（4）多数查找与获取

  1. GameObject[] enemyGos= GameObject.FindGameObjectsWithTag("Enemy");
  2.         for (int i = 0; i < enemyGos.Length; i++)
  3.         {
  4.             Debug.Log("查找到的敌人游戏物体名称是："+enemyGos[i].name);
  5.         }
  6.         BoxCollider[] colliders= GameObject.FindObjectsOfType<BoxCollider>();
  7.         Debug.Log("--------------------------------------------------");
  8.         for (int i = 0; i < colliders.Length; i++)
  9.         {
  10.             Debug.Log("查找到的敌人碰撞器名称是：" + colliders[i].name);
  11.         }

三、MonoBehaviour

功能说明：MonoBehaviour(基类)，所有Unity脚本都派生自该基类。

//MonoBehaviour派生自组件脚本,因此组件脚本所有的公有，保护的属性，成员变量
        //方法等功能，MonoBehaviour也都有，继承mono之后这类可以挂载到游戏物体上   
        Debug.Log("No4_MonoBehaviour组件的激活状态是："+this.enabled);
        Debug.Log("No4_MonoBehaviour组件挂载的对象名称是：" + this.name);
        Debug.Log("No4_MonoBehaviour组件挂载的标签名称是：" + this.tag);
        Debug.Log("No4_MonoBehaviour组件是否已激活并启用Behaviour：" + this.isActiveAndEnabled);

四、Component

功能说明：组件，附加到游戏物体的所有内容的基类。

Mono继承自Behaviour，Behaviour继承自Component，Component继承自Object；

子辈拥有父辈以及父辈以上（派生程度低的基类）所有的公有/保护的属性、成员变量、方法等功能，挂载功能其实是Component，也就是我们写的脚本组件其实指的是Component组件，而Mono是在此基础上进行的封装与扩展。

组件的使用与获取：

1.组件都是在某一个游戏物体身上挂载的，可以通过游戏物体查找获取之后使用；

  1. Debug.Log(grisGo.GetComponent<SpriteRenderer>());
  2.         Debug.Log(enemyGos.GetComponentInChildren<BoxCollider>());
  3.         Debug.Log(enemyGos.GetComponentsInChildren<BoxCollider>());
  4.         Debug.Log(enemyGos.GetComponentInParent<BoxCollider>());

2.通过其他组件查找

  1. SpriteRenderer sr= grisGo.GetComponent<SpriteRenderer>();
  2.         sr.GetComponent<Transform>();
  3.         this.GetComponent<Transform>();

五、Transform

功能说明：变换组件，场景中每个对象都有一个变换组件。它用于存储和操作对象的位置、旋转和缩放。

1. 访问与获取

Transform grisTrans=grisGo.transform;

2. 成员变量

  1. Debug.Log("Gris变换组件所挂载的游戏物体名字是："+grisTrans.name);
  2.         Debug.Log("Gris变换组件所挂载的游戏物体引用是："+grisTrans.gameObject);
  3.         Debug.Log("Gris下的子对象（指Transform）的个数是："+grisTrans.childCount);
  4.         Debug.Log("Gris世界空间中的坐标位置是："+grisTrans.position);
  5.         Debug.Log("Gris以四元数形式表示的旋转是："+grisTrans.rotation);
  6.         Debug.Log("Gris以欧拉角形式表示的旋转（以度数为单位）是"+grisTrans.eulerAngles);
  7.         Debug.Log("Gris的父级Transform是："+grisTrans.parent);
  8.         Debug.Log("Gris相对于父对象的位置坐标是："+grisTrans.localPosition);
  9.         Debug.Log("Gris相对于父对象以四元数形式表示的旋转是：" + grisTrans.localRotation);
  10.         Debug.Log("Gris相对于父对象以欧拉角形式表示的旋转（以度数为单位）是：" + grisTrans.localEulerAngles);
  11.         Debug.Log("Gris相对于父对象的变换缩放是："+grisTrans.localScale);
  12.         Debug.Log("Gris的自身坐标正前方（Z轴正方向）是："+grisTrans.forward);
  13.         Debug.Log("Gris的自身坐标正右方（X轴正方向）是：" + grisTrans.right);
  14.         Debug.Log("Gris的自身坐标正上方（Y轴正方向）是：" + grisTrans.up);

3. 查找

  1.  Debug.Log("当前脚本挂载的游戏对象下的叫Gris的子对象身上的Transform组件是："+transform.Find("Gris"));
  2.         Debug.Log("当前脚本挂载的游戏对象下的第一个（0号索引）子对象的Transform引用是："+transform.GetChild(0));
  3.         Debug.Log("Gris当前在此父对象同级里所在的索引位置："+ grisTrans.GetSiblingIndex());

4.移动

  1. //0.第二个参数不填（实际情况按自身坐标系移动,space.self）
  2.         //grisGo.transform.Translate(Vector2.left*moveSpeed);//自身坐标系
  3.         //grisGo.transform.Translate(-grisGo.transform.right*moveSpeed);//世界坐标系
  4.         //1.第一个参数按世界坐标系移动，第二个参数指定世界坐标系（实际情况按世界坐标系移动）
  5.         //grisGo.transform.Translate(Vector2.left*moveSpeed,Space.World);
  6.         //2.第一个参数按世界坐标系移动，第二个参数指定自身坐标系（实际情况按自身坐标系移动）
  7.         //grisGo.transform.Translate(Vector2.left * moveSpeed, Space.Self);
  8.         //3.第一个参数按自身坐标系移动，第二个参数指定世界坐标系（实际情况按自身坐标系移动）
  9.         //grisGo.transform.Translate(-grisGo.transform.right * moveSpeed, Space.World);
  10.         //4.第一个参数按自身坐标系移动，第二个参数指定自身坐标系（实际情况按世界坐标系移动）(一般不使用)
  11.         //grisGo.transform.Translate(-grisGo.transform.right * moveSpeed, Space.Self);
  12.         //旋转
  13.         //grisGo.transform.Rotate(new Vector3(0,0,1));
  14.         grisGo.transform.Rotate(Vector3.forward,1);

六、Vector2

1.静态变量

  1. print(Vector2.up);//Y轴正方向
  2. print(Vector2.down);
  3. print(Vector2.left);
  4. print(Vector2.right);//X轴正方向
  5. print(Vector2.zero);
  6. print(Vector2.one);

2.构造函数

  1. Vector2 v2=new Vector2(2,2);
  2. print("v2向量是："+v2);

3.成员变量

  1. print("V2向量的模长是："+v2.magnitude);
  2. print("V2向量的模长的平方是："+v2.sqrMagnitude)；
  3. print("V2向量单位化之后是："+v2.normalized);
  4. print("V2向量的XY值分别是："+v2.x+","+v2.y);
  5. print("V2向量的XY值分别是（使用索引器形式访问）："+v2[0]+","+v2[1]);

4.公共函数

  1. bool equal=v2.Equals(new Vector2(1,1));
  2. print("V2向量与向量（1,1）是否相等？"+equal);
  3.  
  4. Vector2 v2E=new Vector2(1,3);
  5. bool equalv2E=v2E.Equals(new Vector2(3,1));
  6. print("v2E向量与向量(3,1)是否相等？"+equal);
  7. print("V2向量是："+v2);
  8. print("V2向量的单位化向量是：" + v2.normalized + "但是V2向量的值还是：" + v2);
  9. v2.Normalize();
  10. print("V2向量是：" + v2);
  11. v2.Set(5, 9);
  12. print("V2向量是：" + v2);
  13. transform.position = v2;

5.修改位置

  1. transform.position = new Vector2(3, 3);
  2. Vector2 vector2 = transform.position;
  3. vector2.x = 2;
  4. transform.position = vector2;

6.静态函数

  1. Vector2 va = new Vector2(1, 0);
  2. Vector2 vb = new Vector2(0, 1);
  3. Debug.Log("从va指向vb方向计算的无符号夹角是：" + Vector2.Angle(va, vb));
  4. print("va点与vb点之间的距离是：" + Vector2.Distance(va, vb));
  5. print("向量va与向量vb的点积是：" + Vector2.Dot(va, vb));
  6. print("向量va和向量vb在各个方向上的最大分量组成的新向量是：" + Vector2.Max(va, vb));
  7. print("向量va和向量vb在各个方向上的最小分量组成的新向量是：" + Vector2.Min(va, vb));
  8.  
  9. //具体得到的新向量的结果的计算公式是:a+(b-a)*t
  10. print("va向vb按照0.5的比例进行线性插值变化之后的结果是" + Vector2.Lerp(va, vb, 0.5f));
  11. print("va向vb按照参数为-1的形式进行（无限制）线性插值变化之后的结果是" + Vector2.LerpUnclamped(va, vb, -1));
  12. float maxDistance = 0.5f;
  13. print("将点va以最大距离不超过maxDistance为移动步频移向vb" + Vector2.MoveTowards(va, vb, maxDistance));
  14. print("va和vb之间的有符号角度（以度为单位，顺时针为正）是" + Vector2.SignedAngle(va, vb));
  15. print("vb和va之间的有符号角度（以度为单位，顺时针为正）是" + Vector2.SignedAngle(vb, va));
  16. print("va和vb在各个方向上的分量相乘得到的新向量是：" + Vector2.Scale(va, vb));
  17. Vector2 currentVelocity = new Vector2(1, 0);
  18. print(Vector2.SmoothDamp(va, vb, ref currentVelocity, 0.1f));

7.运算符

  1. print("va加上vb向量是："+(va+vb));
  2. print("va减去vb向量是：" + (va - vb));
  3. print("va减去vb向量是：" + va * 10);
  4. print("va与vb是同一个向量吗" + (va == vb));
  1. void Update()
  2.     {
  3.         grisTrans.position= Vector2.Lerp(grisTrans.position,targetTrans.position,0.01f);
  4.         percent += 1 * lerpSpeed * Time.deltaTime;
  5.         grisTrans.position = Vector2.Lerp(grisTrans.position, targetTrans.position, percent);
  6.         //lerp是先快后慢，moveTowards匀速
  7.         grisTrans.position = Vector2.MoveTowards(grisTrans.position, targetTrans.position, 0.05f);
  8.         //平滑阻尼       
  9.         grisTrans.position = Vector2.SmoothDamp(grisTrans.position,targetTrans.position,ref currentVelocity,1);
  10.     }

七、Input

功能说明：访问输入系统的接口类

  1. void Update()
  2.     {
  3.         //连续检测（移动）
  4.         print("当前玩家输入的水平方向的轴值是："+Input.GetAxis("Horizontal"));
  5.         print("当前玩家输入的垂直方向的轴值是：" + Input.GetAxis("Vertical"));
  6.         print("当前玩家输入的水平方向的边界轴值是：" + Input.GetAxisRaw("Horizontal"));
  7.         print("当前玩家输入的垂直方向的边界轴值是：" + Input.GetAxisRaw("Vertical"));
  8.         print("当前玩家鼠标水平移动增量是："+Input.GetAxis("Mouse X"));
  9.         print("当前玩家鼠标垂直移动增量是：" + Input.GetAxis("Mouse Y"));
  10.  
  11.         //连续检测（事件）
  12.         if (Input.GetButton("Fire1"))
  13.         {
  14.             print("当前玩家正在使用武器1进行攻击！");
  15.         }
  16.         if (Input.GetButton("Fire2"))
  17.         {
  18.             print("当前玩家正在使用武器2进行攻击！");
  19.         }
  20.         if (Input.GetButton("RecoverSkill"))
  21.         {
  22.             print("当前玩家使用了恢复技能回血！");
  23.         }
  24.         //间隔检测（事件）
  25.         if (Input.GetButtonDown("Jump"))
  26.         {
  27.             print("当前玩家按下跳跃键");
  28.         }
  29.         if (Input.GetButtonUp("Squat"))
  30.         {
  31.             print("当前玩家松开蹲下建");
  32.         }
  33.         if (Input.GetKeyDown(KeyCode.Q))
  34.         {
  35.             print("当前玩家按下Q键");
  36.         }
  37.         if (Input.anyKeyDown)
  38.         {
  39.             print("当前玩家按下了任意一个按键，游戏开始");
  40.         }
  41.         if (Input.GetMouseButton(0))
  42.         {
  43.             print("当前玩家按住鼠标左键");
  44.         }
  45.         if (Input.GetMouseButtonDown(1))
  46.         {
  47.             print("当前玩家按下鼠标右键");
  48.         }
  49.         if (Input.GetMouseButtonUp(2))
  50.         {
  51.             print("当前玩家抬起鼠标中键（从按下状态松开滚轮）");
  52.         }
  53.     }

八、Message

功能说明：消息的发送

  1. using UnityEngine;
  2.  
  3. public class Test: MonoBehaviour
  4. {
  5.     void Start()
  6.     {
  7.         //仅发送消息给自己（以及身上的其他MonoBehaviour对象）
  8.         gameObject.SendMessage("GetMsg");
  9.         SendMessage("GetSrcMsg", "Trigger");
  10.         SendMessage("GetTestMsg", SendMessageOptions.DontRequireReceiver);
  11.         //广播消息（向下发，所有子对象包括自己）
  12.         BroadcastMessage("GetMsg");
  13.         //向上发送消息(父对象包含自己)
  14.         SendMessageUpwards("GetMsg");
  15.     }
  16.  
  17.     public void GetMsg()
  18.     {
  19.         print("测试对象本身接收到消息了");
  20.     }
  21.  
  22.     public void GetSrcMsg(string str)
  23.     {
  24.         print("测试对象本身接收到的消息为：" + str);
  25.     }
  26. }
  1. using UnityEngine;
  2.  
  3. public class Test_Child : MonoBehaviour {
  4.  
  5.     public void GetMsg()
  6.     {
  7.         print("测试对象的子对象接收到消息了");
  8.     }
  9. }
  1. using UnityEngine;
  2.  
  3. public class Test_Parent : MonoBehaviour {
  4.  
  5.     public void GetMsg()
  6.     {
  7.         print("测试对象的父对象接收到消息了");
  8.     }
  9. }

九、Animator

功能说明：动画

  1. public Animator animator;
  2.  
  3.     void Start()
  4.     {
  5.         animator.Play("Run");
  6.  
  7.         animator.speed = 5;
  8.         animator.speed = 0.3f;
  9.  
  10.         animator.SetFloat("Speed",1);
  11.         animator.SetBool("Dead",false);
  12.         animator.SetInteger("HP",100);
  13.         print("当前速度参数的值是："+animator.GetFloat("Speed"));
  14.     }
  15.  
  16.     void Update()
  17.     {
  18.         if (Input.GetKeyDown(KeyCode.W))
  19.         {
  20.             animator.CrossFade("Walk",1);
  21.         }
  22.         if (Input.GetKeyDown(KeyCode.R))
  23.         {
  24.             //以标准单位化时间进行淡入淡出效果来播放动画
  25.             animator.CrossFade("Run", 0.5f);
  26.         }
  27.         if (Input.GetKeyDown(KeyCode.Alpha0))
  28.         {
  29.             //以秒为单位进行淡入淡出效果来播放动画
  30.             animator.CrossFadeInFixedTime("Run", 0.5f);
  31.         }
  32.         animator.SetFloat("Speed",Input.GetAxisRaw("Horizontal"));
  33.     }

十、Time

功能说明：从Unity获取时间信息的接口

  1. void Update()
  2.     {
  3.         print(Time.deltaTime + ",完成上一帧所用的时间（以秒为单位）");
  4.         print(Time.fixedDeltaTime + ",执行物理或者其他固定帧率更新的时间间隔");
  5.         print(Time.fixedTime + ",自游戏启动以来的总时间（以物理或者其他固定帧率更新的时间间隔累计计算的）");
  6.         print(Time.time + ",游戏开始以来的总时间");
  7.         print(Time.realtimeSinceStartup + ",游戏开始以来的实际时间");
  8.         print(Time.smoothDeltaTime + ",经过平滑处理的Time.deltaTime的时间");
  9.         print(Time.timeScale + ",时间流逝的标度,可以用来慢放动作");
  10.         print(Time.timeSinceLevelLoad + ",自加载上一个关卡以来的时间");
  11.     }

十一、Maths

功能说明：数学库函数

  1. private float endTime = 10;
  2.  
  3.     void Start()
  4.     {
  5.         //静态变量
  6.         print(Mathf.Deg2Rad+",度到弧度换算常量");
  7.         print(Mathf.Rad2Deg+ ",弧度到度换算常量");
  8.         print(Mathf.Infinity+"正无穷大的表示形式");
  9.         print(Mathf.NegativeInfinity + "负无穷大的表示形式");
  10.         print(Mathf.PI);
  11.         //静态函数
  12.         print(Mathf.Abs(-1.2f)+ ",-1.2的绝对值");
  13.         print(Mathf.Acos(1)+",1（以弧度为单位）的反余弦");
  14.         print(Mathf.Floor(2.74f)+",小于或等于2.74的最大整数");
  15.         print(Mathf.FloorToInt(2.74f)+",小于或等于2.74的最大整数");
  16.         //a+(b-a)*t
  17.         print(Mathf.Lerp(1,2,0.5f)+",a和b按参数t进行线性插值");        
  18.         print(Mathf.LerpUnclamped(1, 2, -0.5f) + ",a和b按参数t进行线性插值");
  19.     }
  20.  
  21.     void Update()
  22.     {
  23.         print("游戏倒计时：" + endTime);
  24.         endTime = Mathf.MoveTowards(endTime,0,0.1f);      
  25.     }

十二、Random

功能说明：生成随机数的类

  1. void Start()
  2.     {
  3.         //静态变量
  4.         print(Random.rotation+",随机出的旋转数是(以四元数形式表示)");
  5.         print(Random.rotation.eulerAngles+",四元数转换成欧拉角");
  6.         print(Quaternion.Euler(Random.rotation.eulerAngles)+",欧拉角转四元数");
  7.         print(Random.value+",随机出[0,1]之间的浮点数");
  8.         print(Random.insideUnitCircle+",在（-1，-1）~（1,1）范围内随机生成的一个vector2");
  9.         print(Random.state+",当前随机数生成器的状态");
  10.         //静态函数
  11.         print(Random.Range(0,4)+",在区间[0,4）（整形重载包含左Min,不包含右Max）产生的随机数");
  12.         print(Random.Range(0, 4f) + ",在区间[0,4）（浮点形重载包含左Min,包含右Max）产生的随机数");
  13.         Random.InitState(1);
  14.         print(Random.Range(0,4f)+",设置完随机数状态之后在[0,4]区间内生成的随机数");
  15.     }

十三、OnMouseEventFunction

功能说明：鼠标回调事件(MonoBehaviour里的方法)

  1. private void OnMouseDown()
  2.     {
  3.         print("在Gris身上按下了鼠标");
  4.     }
  5.  
  6.     private void OnMouseUp()
  7.     {
  8.         print("在Gris身上按下的鼠标抬起了");
  9.     }
  10.  
  11.     private void OnMouseDrag()
  12.     {
  13.         print("在Gris身上用鼠标进行了拖拽操作");
  14.     }
  15.  
  16.     private void OnMouseEnter()
  17.     {
  18.         print("鼠标移入了Gris");
  19.     }
  20.  
  21.     private void OnMouseExit()
  22.     {
  23.         print("鼠标移出了Gris");
  24.     }
  25.  
  26.     private void OnMouseOver()
  27.     {
  28.         print("鼠标悬停在了Gris上方");
  29.     }
  30.  
  31.     private void OnMouseUpAsButton()
  32.     {
  33.         print("鼠标在Gris身上松开了");
  34.     }

十四、Coroutine

功能说明：协程（协同程序）

用法和用途：

1.延时调用；

2.和其他逻辑一起协同执行；（比如一些很耗时的工作，在这个协程中执行异步操作，比如下载文件，加载文件等）

  1. public Animator animator;
  2.     public int grisCount;
  3.     private int grisNum;
  4.  
  5.     void Start()
  6.     {
  7.         //协程的启动
  8.         //StartCoroutine("ChangeState");
  9.         //StartCoroutine(ChangeState());
  10.         //IEnumerator ie = ChangeState();
  11.         //StartCoroutine(ie);
  12.         //协程的停止
  13.         //StopCoroutine("ChangeState");
  14.         //无法停止协程
  15.         //StopCoroutine(ChangeState());
  16.  
  17.         //StopCoroutine(ie);
  18.  
  19.         //StopAllCoroutines();
  20.  
  21.         StartCoroutine("CreateGris");
  22.     }
  23.  
  24.     IEnumerator ChangeState()
  25.     {
  26.         //暂停几秒（协程挂起）
  27.         yield return new WaitForSeconds(2);
  28.         animator.Play("Walk");
  29.         yield return new WaitForSeconds(3);
  30.         animator.Play("Run");
  31.         //等待一帧 yield return n(n是任意数字)
  32.         yield return null;
  33.         yield return 100000;
  34.         print("转换成Run状态了");
  35.         //在本帧帧末执行以下逻辑
  36.         yield return new WaitForEndOfFrame();
  37.     }
  38.  
  39.     IEnumerator CreateGris()
  40.     {
  41.         StartCoroutine(SetCreateCount(5));
  42.         while (true)
  43.         {
  44.             if (grisNum>=grisCount)
  45.             {
  46.                 yield break;
  47.             }
  48.             Instantiate(animator.gameObject);
  49.             grisNum++;
  50.             yield return new WaitForSeconds(2);
  51.         }
  52.     }
  53.  
  54.     IEnumerator SetCreateCount(int num)
  55.     {
  56.         grisCount =num;
  57.         yield return null;
  58.     }

十五、Invoke

功能说明：延时调用方法

  1. public GameObject grisGo;
  2.  
  3.     void Start()
  4.     {
  5.         //调用
  6.         //Invoke("CreateGris",3);
  7.         InvokeRepeating("CreateGris",1,1);
  8.         //停止
  9.         CancelInvoke("CreateGris");
  10.         //CancelInvoke();
  11.         InvokeRepeating("Test",1,1);
  12.     }
  13.  
  14.     void Update()
  15.     {
  16.         print(IsInvoking("CreateGris"));
  17.         print(IsInvoking());
  18.     }
  19.  
  20.     private void CreateGris()
  21.     {
  22.         Instantiate(grisGo);
  23.     }
  24.  
  25.     private void Test()
  26.     {
  27.         
  28.     }

十六、Rigidbody

功能说明：刚体(通过物理模拟控制对象的位置)

  1. private Rigidbody2D rb;
  2.     private float moveSpeed=1;
  3.     private float angle=60;
  4.  
  5.     void Start()
  6.     {
  7.         rb = GetComponent<Rigidbody2D>();
  8.         print(rb.position);
  9.         print(rb.gravityScale+",该对象受重力影响的程度");
  10.         rb.gravityScale = 0;
  11.         //rb.AddForce(Vector2.right*10);
  12.         //rb.AddForce(Vector2.right * 10,ForceMode2D.Impulse);
  13.         rb.velocity = Vector2.right *moveSpeed;
  14.         //rb.MoveRotation(90);
  15.     }
  16.  
  17.     void FixedUpdate()
  18.     {
  19.         //rb.MovePosition(rb.position+Vector2.right*moveSpeed*Time.fixedDeltaTime);  
  20.         rb.MoveRotation(rb.rotation+angle*Time.fixedDeltaTime);
  21.     }

十七、AudioSource

功能说明：播放音频的类

  1. private AudioSource audioSource;
  2.     public AudioClip musicClip;
  3.     public AudioClip soundClip;
  4.     private bool muteState;
  5.     private bool pauseState;
  6.     void Start()
  7.     {
  8.         audioSource = GetComponent<AudioSource>();
  9.         //audioSource.clip = musicClip;
  10.         //audioSource.Play();
  11.         audioSource.volume = 1;
  12.         audioSource.time = 3;
  13.     }
  14.  
  15.     void Update()
  16.     {
  17.         //静音
  18.         if (Input.GetKeyDown(KeyCode.M))
  19.         {
  20.             muteState = !muteState;
  21.             audioSource.mute = muteState;
  22.         }
  23.         //暂停
  24.         if (Input.GetKeyDown(KeyCode.P))
  25.         {
  26.             pauseState = !pauseState;
  27.             if (pauseState)
  28.             {
  29.                 audioSource.Pause();
  30.             }
  31.             else
  32.             {
  33.                 audioSource.UnPause();
  34.             }
  35.         }
  36.         //停止
  37.         if (Input.GetKeyDown(KeyCode.S))
  38.         {
  39.             audioSource.Stop();
  40.         }
  41.         //播放一次
  42.         if (Input.GetKeyDown(KeyCode.K))
  43.         {
  44.             //audioSource.PlayOneShot(soundClip);
  45.             AudioSource.PlayClipAtPoint(soundClip,transform.position);
  46.         }

十八、Collider

功能说明：碰撞器

  1. private void OnCollisionEnter2D(Collision2D collision)
  2.     {
  3.         //碰撞到的游戏物体名字
  4.         Debug.Log(collision.gameObject.name);
  5.     }
  6.  
  7.     private void OnCollisionStay2D(Collision2D collision)
  8.     {
  9.         Debug.Log("在碰撞器里");
  10.     }
  11.  
  12.     private void OnCollisionExit2D(Collision2D collision)
  13.     {
  14.         Debug.Log("从碰撞器里移出");
  15.     }
  16.  
  17.     //private void OnTriggerEnter2D(Collider2D collision)
  18.     //{
  19.     //    //碰撞到的游戏物体名字
  20.     //    Debug.Log(collision.gameObject.name);
  21.     //}
  22.  
  23.     //private void OnTriggerStay2D(Collider2D collision)
  24.     //{
  25.     //    Debug.Log("在触发器里");
  26.     //}
  27.  
  28.     //private void OnTriggerExit2D(Collider2D collision)
  29.     //{
  30.     //    Debug.Log("从触发器里移出");
  31.     //}

十九、Resources

功能说明：资源加载

  1. void Start()
  2.     {
  3.         //Debug.Log(Resources.Load<AudioClip>("sound"));
  4.         //AudioClip audioClip = Resources.Load<AudioClip>("sound");
  5.         //AudioSource.PlayClipAtPoint(audioClip,transform.position);
  6.         //AudioSource.PlayClipAtPoint(Resources.Load<AudioClip>("sound"), transform.position);
  7.         //Instantiate(Resources.Load<GameObject>(@"Prefabs/GrisCollierTest"));
  8.  
  9.         Object obj= Resources.Load("sound");
  10.         //AudioClip ac = obj as AudioClip;
  11.         AudioClip ac = (AudioClip)obj;
  12.         AudioSource.PlayClipAtPoint(ac, transform.position);
  13.         
  14.         //Resources.LoadAll<AudioClip>("Prefabs");
  15.         AudioClip[] audioClips= Resources.LoadAll<AudioClip>("");
  16.         foreach (var item in audioClips)
  17.         {
  18.             Debug.Log(item);
  19.         }
  20.  
  21.         //Resources.UnloadAsset
  22.     }

二十、SceneManager

功能说明：场景管理

  1. private AsyncOperation ao;
  2.     void Start()
  3.     {
  4.         //SceneManager.LoadScene(1);
  5.         //SceneManager.LoadScene("TriggerTest");
  6.         //SceneManager.LoadScene(2);
  7.         //SceneManager.LoadSceneAsync(2);
  8.     }
  9.  
  10.     void Update()
  11.     {
  12.         if (Input.GetKeyDown(KeyCode.Space))
  13.         {
  14.             //SceneManager.LoadSceneAsync(2);
  15.             StartCoroutine(LoadNextAsyncScene());
  16.         }
  17.         if (Input.anyKeyDown&&ao.progress>=0.9f)
  18.         {
  19.             ao.allowSceneActivation = true;
  20.         }
  21.     }
  22.  
  23.     IEnumerator LoadNextAsyncScene()
  24.     {
  25.         ao= SceneManager.LoadSceneAsync(2);
  26.         ao.allowSceneActivation = false;
  27.         while (ao.progress<0.9f)
  28.         {
  29.             //当前场景加载进度小于0.9
  30.             //当前场景挂起，一直加载，直到加载基本完成
  31.             yield return null;
  32.         }
  33.         Debug.Log("按下任意键继续游戏");
  34.     }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/93289
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号