unityAPI

1.创建一个新的空游戏对象,将代码挂载到它身上

image

2.创建脚本

3.将脚本挂载到物体身上

image

打印函数

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//*****************************************
//功能说明:打印函数
//***************************************** 
public class No1_PrintDebug : MonoBehaviour
{
    void Start()
    {
        print("API的学习");
        Debug.Log("UnityAPI常用方法类与组件");
        //1.测试
        Calculate();
        //2.检错
        Debug.Log("2+3的计算开始了");
        int a = 1;
        Debug.Log("a赋值完成,具体值是:"+a);
        int b = 3;
        Debug.Log("b赋值完成,具体值是:"+b);
        int num = a + b;
        Debug.Log("2+3="+num);

        Debug.LogWarning("这是一个警告!");
        Debug.LogError("这里有报错!");
    }

    void Update()
    {

    }

    private void Calculate()
    {
        //Debug.Log("计算");
        Add();
        Subtract();
    }

    private int Add()
    {
        //Debug.Log("加法");
        return 1 + 1;
    }

    private int Subtract()
    {
        //Debug.Log("减法");
        return 1 - 1;
    }
}

public class TestDebugAndPrintClass:MonoBehaviour
{ 
    public void TestPrint()
    {
        print("使用print必须让当前类继承自monobehavior");
    }

    public void TestDebug()
    {
        Debug.Log("使用debug再普通类里进行输出");
    }
}

事件函数(生命周期函数)

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//*****************************************
//功能说明:事件函数(生命周期函数)
//***************************************** 
public class No2_EventFunction : MonoBehaviour
{
    public float attackValue=10000;
    public float currentHP;

    //对变量赋值的顺序(左边最先赋值,右边最后赋值,以此类推):
    //变量声明并直接赋值>检视面板赋值>Awake>OnEnable>Start>外部赋值
    //我们一般对一个对象赋值,或者说想要从外部对一个对象的属性或者成员变量的值
    //进行更改的前提是,这个对象已经有了(意味着start方法已经调用),所以外部赋值
    //会后于Start方法进行调用

    private void Reset()
    {
        //1.调用情况
        //此函数只能在编辑器模式下(不运行)调用。
        //2.调用时间,次数与作用
        //当脚本第一次挂载到对象或者使用了Reset命令之后调用,
        //来初始化脚本的各个属性,Reset最常用于在检视面板中提供良好的默认值。
        //Debug.Log("调用了Reset方法");
        //Debug.Log("攻击值重置为默认值");
    }

    private void Awake()
    {
        //1.调用情况
        //a.在加载场景时初始化包含脚本的激活状态的GameObject时
        //b.GameObject从非激活转变为激活状态
        //c.在初始化使用Instantiate创建的GameObject之后
        //2.调用时间,次数与作用
        //在脚本实例的生存期内,Unity 仅调用 Awake 一次。脚本的生存期持续到包含它的场景被卸载为止。
        //Unity 调用每个GameObject的Awake的顺序是不确定的,人为干涉(即设计)来保证程序的正确性和稳定性
        // Awake 来代替构造函数进行初始化,在Unity这里,组件的初始化不使用构造函数 
        //Debug.Log("调用了Awake方法"); 
        //attackValue = 1;
    }

    private void OnEnable()
    {
        //1.调用情况
        //a.游戏物体被激活
        //b.脚本组件被激活
        //2.调用时间,次数与作用
        //每次游戏物体或者脚本被激活都会调用一次
        //重复赋值 变为初始状态
        //Debug.Log("调用了OnEnable方法");
        //currentHP = 100;
        //Debug.Log("当前血量为:"+currentHP);
        //attackValue = 2;
    }

    void Start()
    {
        //1.调用情况
        //a.游戏物体被激活
        //b.脚本组件被激活
        //2.调用时间,次数与作用
        //在脚本实例激活时在第一帧的Update之前被调用
        //后于Awake执行,方便控制逻辑的前后调用顺序
        //Debug.Log("调用了Start方法");
        attackValue = 3;
    }

    void Update()
    {
        //1.调用情况
        //a.游戏物体被激活
        //b.脚本组件被激活
        //2.调用时间,次数与作用
        //每帧调用,是最常用函数,每秒调用60次左右(根据当前电脑的的性能和状态)
        //实时更新数据,接受输入数据
        //Debug.Log("调用了Update方法");
    }

    private void LateUpdate()
    {
        //1.调用情况
        //a.游戏物体被激活
        //b.脚本组件被激活
        //2.调用时间,次数与作用
        //LateUpdate在调用所有Update函数后调用,每秒调用60次左右,安排脚本的执行顺序
        //比如摄像机跟随,一定是人物先移动了,摄像机才会跟随
        //Debug.Log("调用了LateUpdate方法");
    }

    private void OnDisable()
    {
        //1.调用情况
        //a.游戏物体被禁用
        //b.脚本组件被禁用
        //c.游戏物体被销毁
        //2.调用时间,次数与作用
        //满足调用情况时即时调用一次,用于一些对象的状态重置,资源回收与清理
        Debug.Log("调用了OnDisable方法");
    }

    void OnApplicatoinQuit()
    {
        //1.调用情况
        //a.在程序退出之前所有的游戏对象都会调用这个函数
        //b.在编辑器中会在用户终止播放模式时调用
        //c.在网页视图关闭时调用
        //2.调用时间,次数与作用
        //满足调用情况时即时调用一次,用于处理一些游戏退出后的逻辑
        Debug.Log("OnApplicationQuit");
    }


    void OnDestroy()
    {
        //1.调用情况
        //a.场景或游戏结束
        //b.停止播放模式将终止应用程序
        //c.在网页视图关闭时调用
        //d.当前脚本被移除
        //e.当前脚本挂载到的游戏物体被删除
        //2.调用时间,次数与作用
        //满足调用情况时即时调用一次,用于一些游戏物体的销毁
        Debug.Log("OnDestroy");
    }
}

测试外部调用或者外部复制时的顺序

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//*****************************************
//功能说明:用于测试外部调用或者外部复制时的顺序
//***************************************** 
public class No2_ExternalCall : MonoBehaviour
{
    public No2_EventFunction api;

    void Start()
    {
        //通过外部获取组件引用对变量进行赋值
        api.attackValue = -1;
    }

    void Update()
    {

    } 
}

游戏物体

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//*****************************************
//功能说明:游戏物体
//***************************************** 
public class No3_GameObject : MonoBehaviour
{
    public GameObject grisGo;

    void Start()
    {
        //1.创建方式
        //a.使用构造函数(声明+实例化) 创建一个空的游戏对象
        //GameObject myGo = new GameObject("MyGameObject");
        //b.根据现有的预制体(游戏物体)资源或者游戏场景已有的游戏物体来实例化
        //GameObject.Instantiate(grisGo);
        //c.使用特别的API创建一些基本的游戏物体类型(原始几何体)
        //GameObject.CreatePrimitive(PrimitiveType.Plane);
        //2.游戏物体的查找和获取
        //this;//当前组件No3_GameObject
        //this.grisGo;
        //Test();this.Test();
        //this.gameObject;
        Debug.Log("当前脚本挂载到的游戏物体名称是:"+gameObject.name);
        //GameObject.Instantiate;
        //GameObject.CreatePrimitive;
        Debug.Log("当前游戏物体标签是:"+gameObject.tag);
        Debug.Log("当前游戏物体层级是:"+gameObject.layer);
        //游戏物体的激活失活
        gameObject.SetActive(true);
        Debug.Log("当前游戏物体的状态是:"+gameObject.activeInHierarchy);
        Debug.Log("当前游戏物体的状态是:" +gameObject.activeSelf);
        //有引用
        //对自己 this.gameObject
        //对其他游戏物体 
        Debug.Log("gris游戏物体的状态是:"+ grisGo.activeSelf);
        //没有直接引用
        //对其他游戏物体查找(这时游戏物体必须是激活状态)
        //a.通过名称查找
        //GameObject mainCameraGo= GameObject.Find("Main Camera");
        //Debug.Log("mainCamera游戏物体的标签是:" + mainCameraGo.tag);
        //b.通过标签查找
        GameObject mainCameraGo = GameObject.FindGameObjectWithTag("MainCamera");
        Debug.Log("mainCamera游戏物体的名字是:" + mainCameraGo.name);
        //c.通过类型查找
        No2_EventFunction no2_EventFunction= GameObject.FindObjectOfType<No2_EventFunction>();
        Debug.Log("no2_EventFunction游戏物体的名字是:" + no2_EventFunction.name);
        //d.多数查找与获取
        GameObject[] enemyGos= GameObject.FindGameObjectsWithTag("Enemy");
        for (int i = 0; i < enemyGos.Length; i++)
        {
            Debug.Log("查找到的敌人游戏物体名称是:"+enemyGos[i].name);
        }
        BoxCollider[] colliders= GameObject.FindObjectsOfType<BoxCollider>();
        Debug.Log("--------------------------------------------------");
        for (int i = 0; i < colliders.Length; i++)
        {
            Debug.Log("查找到的敌人碰撞器名称是:" + colliders[i].name);
        }
    }

    void Update()
    {

    }

    private void Test() { }
}

MonoBehaviour(基类),所有Unity脚本都派生自该基类

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//*****************************************
//功能说明:MonoBehaviour(基类),所有Unity脚本都派生自该基类
//***************************************** 
public class No4_MonoBehaviour : MonoBehaviour
{
    void Start()
    {
        //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);
        print("Trigger");
        //Destroy();
        //FindObjectsOfType();
        //Instantiate();
    }
}

组件 附加到游戏物体的所有内容的基类

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//*****************************************
//功能说明:组件 附加到游戏物体的所有内容的基类
//***************************************** 
public class No5_Component : MonoBehaviour
{
    public int testValue;

    public GameObject enemyGos;

    void Start()
    {
        //Mono继承自Behaviour,Behaviour继承自Compontent,Compontent继承自Object
        //子辈拥有父辈以及父辈以上(派生程度低的基类)所有的公有,保护的属性,成员变量
        //方法等功能,挂载功能其实是Component,也就是我们写的脚本组件其实指的是Component组件
        //而Mono是在此基础上进行的封装与扩展
        //组件的使用与获取
        //a.组件都是在某一个游戏物体身上挂载的,可以通过游戏物体查找获取之后使用
        No5_Component no5_Component = gameObject.GetComponent<No5_Component>();
        //No2_EventFunction no2_EventFunction = gameObject.GetComponent<No2_EventFunction>();
        //Debug.Log(no2_EventFunction);
        //Debug.Log(no2_EventFunction.attackValue);
        Debug.Log(no5_Component.testValue);
        GameObject grisGo = GameObject.Find("Gris");
        Debug.Log(grisGo.GetComponent<SpriteRenderer>());
        Debug.Log(enemyGos.GetComponentInChildren<BoxCollider>());
        Debug.Log(enemyGos.GetComponentsInChildren<BoxCollider>());
        Debug.Log(enemyGos.GetComponentInParent<BoxCollider>());
        //b.通过其他组件查找
        SpriteRenderer sr= grisGo.GetComponent<SpriteRenderer>();
        sr.GetComponent<Transform>();
        this.GetComponent<Transform>();
    }

    void Update()
    {

    } 
}

变换组件

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//*****************************************
//功能说明:变换组件
//***************************************** 
public class No6_Transform : MonoBehaviour
{
    public GameObject grisGo;

    public float moveSpeed=1;

    void Start()
    {
        //场景中的每个对象都有一个变换组件。 它用于存储和操作对象的位置、旋转和缩放。
        //1.访问与获取
        Debug.Log(this.transform);
        Debug.Log(grisGo.transform);
        Transform grisTrans = grisGo.transform;
        //2.成员变量
        Debug.Log("Gris变换组件所挂载的游戏物体名字是:"+grisTrans.name);
        Debug.Log("Gris变换组件所挂载的游戏物体引用是:"+grisTrans.gameObject);
        Debug.Log("Gris下的子对象(指Transform)的个数是:"+grisTrans.childCount);
        Debug.Log("Gris世界空间中的坐标位置是:"+grisTrans.position);
        Debug.Log("Gris以四元数形式表示的旋转是:"+grisTrans.rotation);
        Debug.Log("Gris以欧拉角形式表示的旋转(以度数为单位)是"+grisTrans.eulerAngles);
        Debug.Log("Gris的父级Transform是:"+grisTrans.parent);
        Debug.Log("Gris相对于父对象的位置坐标是:"+grisTrans.localPosition);
        Debug.Log("Gris相对于父对象以四元数形式表示的旋转是:" + grisTrans.localRotation);
        Debug.Log("Gris相对于父对象以欧拉角形式表示的旋转(以度数为单位)是:" + grisTrans.localEulerAngles);
        Debug.Log("Gris相对于父对象的变换缩放是:"+grisTrans.localScale);
        Debug.Log("Gris的自身坐标正前方(Z轴正方向)是:"+grisTrans.forward);
        Debug.Log("Gris的自身坐标正右方(X轴正方向)是:" + grisTrans.right);
        Debug.Log("Gris的自身坐标正上方(Y轴正方向)是:" + grisTrans.up);
        //共有方法
        //3.查找
        Debug.Log("当前脚本挂载的游戏对象下的叫Gris的子对象身上的Transform组件是:"+transform.Find("Gris"));
        Debug.Log("当前脚本挂载的游戏对象下的第一个(0号索引)子对象的Transform引用是:"+transform.GetChild(0));
        Debug.Log("Gris当前在此父对象同级里所在的索引位置:"+ grisTrans.GetSiblingIndex());
        //静态方法
        //Transform.Destroy(grisTrans);
        //Transform.Destroy(grisTrans.gameObject);
        //Transform.FindObjectOfType();
        //Transform.Instantiate();
    }

    void Update()
    {
        //移动
        //0.第二个参数不填(实际情况按自身坐标系移动,space.self)
        //grisGo.transform.Translate(Vector2.left*moveSpeed);//自身坐标系
        //grisGo.transform.Translate(-grisGo.transform.right*moveSpeed);//世界坐标系
        //1.第一个参数按世界坐标系移动,第二个参数指定世界坐标系(实际情况按世界坐标系移动)
        //grisGo.transform.Translate(Vector2.left*moveSpeed,Space.World);
        //2.第一个参数按世界坐标系移动,第二个参数指定自身坐标系(实际情况按自身坐标系移动)
        //grisGo.transform.Translate(Vector2.left * moveSpeed, Space.Self);
        //3.第一个参数按自身坐标系移动,第二个参数指定世界坐标系(实际情况按自身坐标系移动)
        //grisGo.transform.Translate(-grisGo.transform.right * moveSpeed, Space.World);
        //4.第一个参数按自身坐标系移动,第二个参数指定自身坐标系(实际情况按世界坐标系移动)(一般不使用)
        //grisGo.transform.Translate(-grisGo.transform.right * moveSpeed, Space.Self);
        //旋转
        //grisGo.transform.Rotate(new Vector3(0,0,1));
        grisGo.transform.Rotate(Vector3.forward,1);
    } 

}

用于表示2D向量和点

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//*****************************************
//功能说明:用于表示2D向量和点
//***************************************** 
public class No7_Vector2 : MonoBehaviour
{
    public Transform grisTrans;
    public Transform targetTrans;
    public float percent;
    public float lerpSpeed;
    Vector2 currentVelocity = new Vector2(1, 0);

    //结构体 值类型
    public struct MyStruct
    {
        public string name;
        public int age;
    }
    //类 引用类型
    public class MyClass
    {
        public string name;
        public int age;
    }

    void Start()
    {
        ////静态变量
        //print(Vector2.down);
        //print(Vector2.up);//Y轴正方向
        //print(Vector2.left);
        //print(Vector2.right);//X轴正方向
        //print(Vector2.one);
        //print(Vector2.zero);
        ////构造函数
        //Vector2 v2 = new Vector2(2, 2);
        //print("V2向量是:" + v2);
        ////成员变量
        //print("V2向量的模长是:" + v2.magnitude);
        //print("V2向量的模长的平方是:" + v2.sqrMagnitude);
        //print("V2向量单位化之后是:" + v2.normalized);
        //print("V2向量的XY值分别是:" + v2.x + "," + v2.y);
        //print("V2向量的XY值分别是(使用索引器形式访问):" + v2[0] + "," + v2[1]);
        ////公共函数
        //bool equal = v2.Equals(new Vector2(1, 1));
        //print("V2向量与向量(1,1)是否相等?" + equal);
        //Vector2 v2E = new Vector2(1, 3);
        //bool equalv2E = v2E.Equals(new Vector2(3, 1));
        //print("v2E向量与向量(3,1)是否相等?" + equal);
        //print("V2向量是:" + v2);
        //print("V2向量的单位化向量是:" + v2.normalized + "但是V2向量的值还是:" + v2);
        //v2.Normalize();
        //print("V2向量是:" + v2);
        //v2.Set(5, 9);
        //print("V2向量是:" + v2);
        //transform.position = v2;

        ////transform.position.x = 4;//不可以单独赋值某一个值,比如x
        ////结论1:用属性和方法返回的结构体是不能修改其字段的 

        //MyStruct myStruct = new MyStruct();//A
        //myStruct.name = "Trigger";
        //myStruct.age = 100;
        ////结论2:直接访问公有的结构体是可以修改其字段的

        //MyStruct yourStruct = myStruct;//B
        //yourStruct.name = "小可爱";
        //yourStruct.age = 18;
        //print("原本的结构体对象名字是:" + myStruct.name);
        //print("修改后的结构体对象名字是:" + yourStruct.name);

        //MyClass myClass = new MyClass();//A
        //myClass.name = "Trigger";
        //myClass.age = 100;
        //MyClass yourClass = myClass;//B跟A是同一块内存空间
        //yourClass.name = "小阔爱";
        //yourClass.age = 18;
        //print("原本的结构体对象名字是:" + myClass.name);
        //print("修改后的结构体对象名字是:" + yourClass.name);
        ////总结导致这个问题的原因:
        ////1,Transform中的position是属性(换成方法也一样,因为属性的实现本质上还是方法)而不是公有字段
        ////2,position的类型是Vector的,而Vector是Struct类型
        ////3,Struct之间的赋值是拷贝而不是引用

        ////修改位置
        //transform.position = new Vector2(3, 3);
        //Vector2 vector2 = transform.position;
        //vector2.x = 2;
        //transform.position = vector2;

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

        ////运算符
        //print("va加上vb向量是:" + (va + vb));
        //print("va减去vb向量是:" + (va - vb));
        //print("va减去vb向量是:" + va * 10);
        //print("va与vb是同一个向量吗" + (va == vb));
    }

    void Update()
    {
        //grisTrans.position= Vector2.Lerp(grisTrans.position,targetTrans.position,0.01f);
        //percent += 1 * lerpSpeed * Time.deltaTime;
        //grisTrans.position = Vector2.Lerp(grisTrans.position, targetTrans.position, percent);
        //lerp是先快后慢,moveTowards匀速
        grisTrans.position = Vector2.MoveTowards(grisTrans.position, targetTrans.position, 0.05f);
        //平滑阻尼       
        //grisTrans.position = Vector2.SmoothDamp(grisTrans.position,targetTrans.position,ref currentVelocity,1);
    }
}

访问输入系统的接口类

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//*****************************************
//功能说明:访问输入系统的接口类
//***************************************** 
public class No8_Input : MonoBehaviour
{
    void Start()
    {

    }

    void Update()
    {
        ////连续检测(移动)
        //print("当前玩家输入的水平方向的轴值是:"+Input.GetAxis("Horizontal"));
        //print("当前玩家输入的垂直方向的轴值是:" + Input.GetAxis("Vertical"));
        //print("当前玩家输入的水平方向的边界轴值是:" + Input.GetAxisRaw("Horizontal"));
        //print("当前玩家输入的垂直方向的边界轴值是:" + Input.GetAxisRaw("Vertical"));
        //print("当前玩家鼠标水平移动增量是:"+Input.GetAxis("Mouse X"));
        //print("当前玩家鼠标垂直移动增量是:" + Input.GetAxis("Mouse Y"));

        //连续检测(事件)
        if (Input.GetButton("Fire1"))
        {
            print("当前玩家正在使用武器1进行攻击!");
        }
        if (Input.GetButton("Fire2"))
        {
            print("当前玩家正在使用武器2进行攻击!");
        }
        if (Input.GetButton("RecoverSkill"))
        {
            print("当前玩家使用了恢复技能回血!");
        }
        //间隔检测(事件)
        if (Input.GetButtonDown("Jump"))
        {
            print("当前玩家按下跳跃键");
        }
        if (Input.GetButtonUp("Squat"))
        {
            print("当前玩家松开蹲下建");
        }
        if (Input.GetKeyDown(KeyCode.Q))
        {
            print("当前玩家按下Q键");
        }
        if (Input.anyKeyDown)
        {
            print("当前玩家按下了任意一个按键,游戏开始");
        }
        if (Input.GetMouseButton(0))
        {
            print("当前玩家按住鼠标左键");
        }
        if (Input.GetMouseButtonDown(1))
        {
            print("当前玩家按下鼠标右键");
        }
        if (Input.GetMouseButtonUp(2))
        {
            print("当前玩家抬起鼠标中键(从按下状态松开滚轮)");
        }
    } 
}

消息的发送

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//*****************************************
//功能说明:消息的发送
//***************************************** 
public class No9_Message : MonoBehaviour
{
    void Start()
    {
        //仅发送消息给自己(以及身上的其他MonoBehaviour对象)
        gameObject.SendMessage("GetMsg");
        SendMessage("GetSrcMsg","Trigger");
        SendMessage("GetTestMsg",SendMessageOptions.DontRequireReceiver);
        //广播消息(向下发,所有子对象包括自己)
        BroadcastMessage("GetMsg");
        //向上发送消息(父对象包含自己)
        SendMessageUpwards("GetMsg");
    }

    void Update()
    {

    }

    public void GetMsg()
    {
        print("测试对象本身接收到消息了");
    }

    public void GetSrcMsg(string str)
    {
        print("测试对象本身接收到的消息为:"+str);
    }
}

消息发送子测试对象

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//*****************************************
//功能说明:消息发送子测试对象
//***************************************** 
public class No9_MessageChild : MonoBehaviour
{
    public void GetMsg()
    {
        print("测试对象的子对象接收到消息了");
    }
}

消息发送父测试对象

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//*****************************************
//功能说明:消息发送父测试对象
//***************************************** 
public class No9_MessageParent : MonoBehaviour
{
    public void GetMsg()
    {
        print("测试对象的父对象接收到消息了");
    }
}

消息发送者身上的其他组件

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//*****************************************
//功能说明:消息发送者身上的其他组件
//***************************************** 
public class No9_MessageTest : MonoBehaviour
{
    public void GetMsg()
    {
        print("测试对象身上的其他组件接收到消息了");
    }

    public void GetSrcMsg(string str)
    {
        print("测试对象身上的其他组件接收到的消息为:" + str);
    }
}

动画

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//*****************************************
//功能说明:动画
//***************************************** 
public class No10_Animator : MonoBehaviour
{
    public Animator animator;

    void Start()
    {
        //animator.Play("Run");

        //animator.speed = 5;
        //animator.speed = 0.3f;

        //animator.SetFloat("Speed",1);
        //animator.SetBool("Dead",false);
        //animator.SetInteger("HP",100);
        //print("当前速度参数的值是:"+animator.GetFloat("Speed"));
    }

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.W))
        {
            animator.CrossFade("Walk",1);
        }
        if (Input.GetKeyDown(KeyCode.R))
        {
            //以标准单位化时间进行淡入淡出效果来播放动画
            animator.CrossFade("Run", 0.5f);
        }
        if (Input.GetKeyDown(KeyCode.Alpha0))
        {
            //以秒为单位进行淡入淡出效果来播放动画
            animator.CrossFadeInFixedTime("Run", 0.5f);
        }
        animator.SetFloat("Speed",Input.GetAxisRaw("Horizontal"));
    } 
}

从Unity获取时间信息的接口

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//*****************************************
//功能说明:从Unity获取时间信息的接口
//***************************************** 
public class No11_Time : MonoBehaviour
{
    void Start()
    {
        //Time.timeScale = 10;
    }

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

数学库函数

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//*****************************************
//功能说明:数学库函数
//***************************************** 
public class No12_Mathf : MonoBehaviour
{
    private float endTime = 10;

    void Start()
    {
        ////静态变量
        //print(Mathf.Deg2Rad+",度到弧度换算常量");
        //print(Mathf.Rad2Deg+ ",弧度到度换算常量");
        //print(Mathf.Infinity+"正无穷大的表示形式");
        //print(Mathf.NegativeInfinity + "负无穷大的表示形式");
        //print(Mathf.PI);
        ////静态函数
        //print(Mathf.Abs(-1.2f)+ ",-1.2的绝对值");
        //print(Mathf.Acos(1)+",1(以弧度为单位)的反余弦");
        //print(Mathf.Floor(2.74f)+",小于或等于2.74的最大整数");
        //print(Mathf.FloorToInt(2.74f)+",小于或等于2.74的最大整数");
        ////a+(b-a)*t
        //print(Mathf.Lerp(1,2,0.5f)+",a和b按参数t进行线性插值");        
        //print(Mathf.LerpUnclamped(1, 2, -0.5f) + ",a和b按参数t进行线性插值");
    }

    void Update()
    {
        print("游戏倒计时:" + endTime);
        endTime = Mathf.MoveTowards(endTime,0,0.1f);      
    } 
}

生成随机数的类

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//*****************************************
//功能说明:生成随机数的类
//***************************************** 
public class No13_Random : MonoBehaviour
{
    void Start()
    {
        ////静态变量
        //print(Random.rotation+",随机出的旋转数是(以四元数形式表示)");
        //print(Random.rotation.eulerAngles+",四元数转换成欧拉角");
        //print(Quaternion.Euler(Random.rotation.eulerAngles)+",欧拉角转四元数");
        //print(Random.value+",随机出[0,1]之间的浮点数");
        //print(Random.insideUnitCircle+",在(-1,-1)~(1,1)范围内随机生成的一个vector2");
        print(Random.state+",当前随机数生成器的状态");
        //静态函数
        print(Random.Range(0,4)+",在区间[0,4)(整形重载包含左Min,不包含右Max)产生的随机数");
        print(Random.Range(0, 4f) + ",在区间[0,4)(浮点形重载包含左Min,包含右Max)产生的随机数");
        Random.InitState(1);
        print(Random.Range(0,4f)+",设置完随机数状态之后在[0,4]区间内生成的随机数");
    }

    void Update()
    {

    } 
}

鼠标回调事件(MonoBehaivour里的方法)

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//*****************************************
//功能说明:鼠标回调事件(MonoBehaivour里的方法)
//***************************************** 
public class No14_OnMouseEventFunction : MonoBehaviour
{
    private void OnMouseDown()
    {
        print("在Gris身上按下了鼠标");
    }

    private void OnMouseUp()
    {
        print("在Gris身上按下的鼠标抬起了");
    }

    private void OnMouseDrag()
    {
        print("在Gris身上用鼠标进行了拖拽操作");
    }

    private void OnMouseEnter()
    {
        print("鼠标移入了Gris");
    }

    private void OnMouseExit()
    {
        print("鼠标移出了Gris");
    }

    private void OnMouseOver()
    {
        print("鼠标悬停在了Gris上方");
    }

    private void OnMouseUpAsButton()
    {
        print("鼠标在Gris身上松开了");
    }
}

协程(协同程序)

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//*****************************************
//功能说明:协程(协同程序)
//***************************************** 
public class No15_Coroutine : MonoBehaviour
{
    //用法和用途(1.延时调用,2.和其他逻辑一起协同执行
    //(比如一些很耗时的工作,在这个协程中执行异步操作,比如下载文件,加载文件等)

    public Animator animator;
    public int grisCount;
    private int grisNum;

    void Start()
    {
        //协程的启动
        //StartCoroutine("ChangeState");
        //StartCoroutine(ChangeState());
        //IEnumerator ie = ChangeState();
        //StartCoroutine(ie);
        //协程的停止
        //StopCoroutine("ChangeState");
        //无法停止协程
        //StopCoroutine(ChangeState());

        //StopCoroutine(ie);

        //StopAllCoroutines();


        StartCoroutine("CreateGris");
    }

    void Update()
    {
        
    }

    IEnumerator ChangeState()
    {
        //暂停几秒(协程挂起)
        yield return new WaitForSeconds(2);
        animator.Play("Walk");
        yield return new WaitForSeconds(3);
        animator.Play("Run");
        //等待一帧 yield return n(n是任意数字)
        yield return null;
        yield return 100000;
        print("转换成Run状态了");
        //在本帧帧末执行以下逻辑
        yield return new WaitForEndOfFrame();
    }

    IEnumerator CreateGris()
    {
        StartCoroutine(SetCreateCount(5));
        while (true)
        {
            if (grisNum>=grisCount)
            {
                yield break;
            }
            Instantiate(animator.gameObject);
            grisNum++;
            yield return new WaitForSeconds(2);
        }
    }

    IEnumerator SetCreateCount(int num)
    {
        grisCount =num;
        yield return null;
    }
}

延时调用方法

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//*****************************************
//功能说明:延时调用方法
//***************************************** 
public class No16_Invoke : MonoBehaviour
{
    public GameObject grisGo;

    void Start()
    {
        //调用
        //Invoke("CreateGris",3);
        InvokeRepeating("CreateGris",1,1);
        //停止
        CancelInvoke("CreateGris");
        //CancelInvoke();
        InvokeRepeating("Test",1,1);
    }

    void Update()
    {
        print(IsInvoking("CreateGris"));
        print(IsInvoking());
    }

    private void CreateGris()
    {
        Instantiate(grisGo);
    }

    private void Test()
    {
        
    }
}

刚体(通过物理模拟控制对象的位置)

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//*****************************************
//功能说明:刚体(通过物理模拟控制对象的位置)
//***************************************** 
public class No17_Rigidbody : MonoBehaviour
{
    private Rigidbody2D rb;
    private float moveSpeed=1;
    private float angle=60;

    void Start()
    {
        rb = GetComponent<Rigidbody2D>();
        print(rb.position);
        print(rb.gravityScale+",该对象受重力影响的程度");
        rb.gravityScale = 0;
        //rb.AddForce(Vector2.right*10);
        //rb.AddForce(Vector2.right * 10,ForceMode2D.Impulse);
        rb.velocity = Vector2.right *moveSpeed;
        //rb.MoveRotation(90);
    }

    void FixedUpdate()
    {
        //rb.MovePosition(rb.position+Vector2.right*moveSpeed*Time.fixedDeltaTime);  
        rb.MoveRotation(rb.rotation+angle*Time.fixedDeltaTime);
    } 
}

播放音频的类

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//*****************************************
//功能说明:播放音频的类
//***************************************** 
public class No18_AudioSource : MonoBehaviour
{
    private AudioSource audioSource;
    public AudioClip musicClip;
    public AudioClip soundClip;
    private bool muteState;
    private bool pauseState;
    void Start()
    {
        audioSource = GetComponent<AudioSource>();
        //audioSource.clip = musicClip;
        //audioSource.Play();
        audioSource.volume = 1;
        audioSource.time = 3;
    }

    void Update()
    {
        //静音
        if (Input.GetKeyDown(KeyCode.M))
        {
            muteState = !muteState;
            audioSource.mute = muteState;
        }
        //暂停
        if (Input.GetKeyDown(KeyCode.P))
        {
            pauseState = !pauseState;
            if (pauseState)
            {
                audioSource.Pause();
            }
            else
            {
                audioSource.UnPause();
            }
        }
        //停止
        if (Input.GetKeyDown(KeyCode.S))
        {
            audioSource.Stop();
        }
        //播放一次
        if (Input.GetKeyDown(KeyCode.K))
        {
            //audioSource.PlayOneShot(soundClip);
            AudioSource.PlayClipAtPoint(soundClip,transform.position);
        }
    } 
}

碰撞器Collider

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//*****************************************
//功能说明:碰撞器
//***************************************** 
public class No19_Collider : MonoBehaviour
{

    private void OnCollisionEnter2D(Collision2D collision)
    {
        //碰撞到的游戏物体名字
        Debug.Log(collision.gameObject.name);
    }

    private void OnCollisionStay2D(Collision2D collision)
    {
        Debug.Log("在碰撞器里");
    }

    private void OnCollisionExit2D(Collision2D collision)
    {
        Debug.Log("从碰撞器里移出");
    }

    //private void OnTriggerEnter2D(Collider2D collision)
    //{
    //    //碰撞到的游戏物体名字
    //    Debug.Log(collision.gameObject.name);
    //}

    //private void OnTriggerStay2D(Collider2D collision)
    //{
    //    Debug.Log("在触发器里");
    //}

    //private void OnTriggerExit2D(Collider2D collision)
    //{
    //    Debug.Log("从触发器里移出");
    //}
}

资源加载

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
//*****************************************
//功能说明:资源加载
//***************************************** 
public class No20_Resources : MonoBehaviour
{
    void Start()
    {
        //Debug.Log(Resources.Load<AudioClip>("sound"));
        //AudioClip audioClip = Resources.Load<AudioClip>("sound");
        //AudioSource.PlayClipAtPoint(audioClip,transform.position);
        //AudioSource.PlayClipAtPoint(Resources.Load<AudioClip>("sound"), transform.position);
        //Instantiate(Resources.Load<GameObject>(@"Prefabs/GrisCollierTest"));

        Object obj= Resources.Load("sound");
        //AudioClip ac = obj as AudioClip;
        AudioClip ac = (AudioClip)obj;
        AudioSource.PlayClipAtPoint(ac, transform.position);
        
        //Resources.LoadAll<AudioClip>("Prefabs");
        AudioClip[] audioClips= Resources.LoadAll<AudioClip>("");
        foreach (var item in audioClips)
        {
            Debug.Log(item);
        }

        //Resources.UnloadAsset
    }

    void Update()
    {

    } 
}

场景管理

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.SceneManagement;
//*****************************************
//功能说明:场景管理
//***************************************** 
public class No21_SceneManager : MonoBehaviour
{
    private AsyncOperation ao;
    void Start()
    {
        //SceneManager.LoadScene(1);
        //SceneManager.LoadScene("TriggerTest");
        //SceneManager.LoadScene(2);
        //SceneManager.LoadSceneAsync(2);
    }

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            //SceneManager.LoadSceneAsync(2);
            StartCoroutine(LoadNextAsyncScene());
        }
        if (Input.anyKeyDown&&ao.progress>=0.9f)
        {
            ao.allowSceneActivation = true;
        }
    }

    IEnumerator LoadNextAsyncScene()
    {
        ao= SceneManager.LoadSceneAsync(2);
        ao.allowSceneActivation = false;
        while (ao.progress<0.9f)
        {
            //当前场景加载进度小于0.9
            //当前场景挂起,一直加载,直到加载基本完成
            yield return null;
        }
        Debug.Log("按下任意键继续游戏");
    }
}
posted @ 2023-03-09 22:08  flyall  阅读(74)  评论(0)    收藏  举报