Unity-基本函数用法

1.常用组件

2.常用周期事件

如下输出，各函数的调用次数。

3.向量

        //静态变量.类名来调用
        print(Vector2.down);
        print(Vector2.up);
        print(Vector2.left);
        print(Vector2.right);
        print(Vector2.zero);
        print(Vector2.one);

        //创建向量
        Vector2 a = new Vector2(4,5);
        Vector2 b = new Vector2(1,3);

        //返回向量长度
        print(a.magnitude);
        print(b.magnitude);

        //返回单位化向量,原向量不变
        print(a.normalized);
        print(a.x + "," + a.y);
        print(b.normalized);
        print(b.x + "," +b.y);

        //对向量进行单位化，原向量改变
        a.Normalize();
        print(a.x + "," + a.y);

        //输出两个向量之间的距离
        print(Vector2.Distance(a, b));

        //输出两向量之间的角度
        print(Vector2.Angle(a, b));

4.键盘和鼠标输入

               //获取键盘的输入，检测按下和松开。
        if(Input.GetKey(KeyCode.A))
            print("GetKey:A");
        if(Input.GetKeyDown(KeyCode.A))
            print("GetkeyDown:A");
        if(Input.GetKeyUp(KeyCode.A))
            print("GetKeyUp:A");

        //检测鼠标右键状态
        if (Input.GetMouseButton(1))
            print("Mouse right");
        if (Input.GetMouseButtonDown(1))
            print("Mouse right down");
        if (Input.GetMouseButtonUp(1))
            print("Mouse right up");

获取按钮和虚拟轴：
通过Edit–>Project Setting–>Input Manager–>Axes打开，可以查看相关配置信息。如Fire1的配置如下。按下鼠标左键(Mouse 0)和按下左边的Ctrl都会响应。

        //检测按钮Fire1状态
        if (Input.GetButton("Fire1"))
            print("Button Fire1");
        if (Input.GetButtonDown("Fire1"))
            print("Button Fire1 Down");

获取虚拟轴，按下左右的方向键或者a、d键，输入虚拟轴的值。

        //获取虚拟轴的状态
        //一般用来控制物体的左右，前后移动或者旋转
        float h1 = Input.GetAxis("Horizontal");
        print(h1);

        float h2= Input.GetAxisRaw("Horizontal");
        print(h2);

改变一个游戏对象的颜色。

    private void OnMouseEnter()
    {
        gameObject.GetComponent<MeshRenderer>().material.color = Color.red;
    }
    private void OnMouseExit()
    {
        gameObject.GetComponent<MeshRenderer>().material.color = Color.white;
    }

5.Time类及其成员变量
通过Time类可以获取和时间有光的信息，用来计算帧速率，调整时间流逝的速度等。

        print("Time.time:" + Time.time);
        print("Time.deltaTime:" + Time.deltaTime);
        print("Time.fixedDeltaTime:" + Time.fixedDeltaTime);
        print("Time.fixedTime:" + Time.fixedTime);
        print("Time.timeScale:" + Time.timeScale);

    //通过计时器来控制Cube的状态
    private float time = 3.0f;
    
    //运行时在Unity面板上设置值
    public float speed;
    public float rotaeSpeed;
    
    private void Update()
    {
        time -= Time.deltaTime;
        if(time<=0)
        {
            time = 3.0f;
            //处理逻辑，该属性取反,禁用时，不渲染。
            GetComponent<MeshRenderer>().enabled = !GetComponent<MeshRenderer>().enabled;
        }

        //控制物体每秒移动多少米
        transform.Translate(Vector3.right * Time.deltaTime*speed);

        //控制物体每秒旋转的角度
        transform.Rotate(Vector3.up * Time.deltaTime * rotaeSpeed);

        //通过按键来控制时间流速的大小
        if (Input.GetKeyDown(KeyCode.Q))
            Time.timeScale = 10.0f;
        if (Input.GetKeyDown(KeyCode.P))
            Time.timeScale =0.0f;
    }

6.预制体
预制体：Perfab，预先准备好的物体，可以重复使用，是Unity中很重要的资源。

预制体的创建方法：

• 手动创建：从Hierachy面板用鼠标拖拽游戏物体到Asserts资源文件夹中；
• 脚本动态创建：Instantiate(Prefabs,transform.position,transform.rotation);
  
• 可以置入多个场景中，也可以多次置入一个场景中。
• 在场景中添加一个Prefab,即实例化了一个预制体对象。
• 所有的Prefab实例都是一个Prefab的原型克隆，运行中生成的对象会有Clone的标记。
• 只要原型发生变化，所有的Prefabs都会发生变化。

创建游戏对象的三种方法：

• 通过GameObject构造函数创建游戏对象，生成一个空的游戏对象。
  GameObject g=new GameObject(“g”);
• 通过CreatePrimitive方法创建原型的游戏模型。GameObject.CreatePrimitive(Primitive.Cube);
• 通过Instantiate方法创建游戏对象。
  克隆预制体；
  克隆普通的游戏对象；
  Instantiate(Prefabs,transform.position,transform.rotation);

    public GameObject CubePrefab;
    private GameObject g2;
    GameObject g1;
    void Start()
    {
        g1= new GameObject("g1");

        GameObject.CreatePrimitive(PrimitiveType.Cube);

        Vector3 pos = new Vector3(-1f, 2f, 0f);
        //使用as将Instantiate的返回值转化为GameObject类型
        g2=Instantiate(CubePrefab, pos, Quaternion.identity) as GameObject;

        print(g2.name);
    }

运行前将准备好的预制体赋值给CubePrefab，如下：

结果如图：

游戏对象的销毁：

• 现在销毁一个对象，GameObject.Destroy(Object);
• 延迟销毁一个对象，GameObject.Destroy(Object obj,float time);
• 销毁游戏物体时将销毁该物体所有组件和子物体。

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.D))
        {
            GameObject.Destroy(g2);
            GameObject.Destroy(g1, 5f);
        }
    }

7.查找物体
若物体没激活，则通过名称和标签查不到，通过路径和和根据父物体可以查到。

        GameObject go1=GameObject.Find("s");
        print(go1.name);

        Transform tf1= transform.Find("g1/s");
        print(tf1);

        Transform tf2=GameObject.Find("g1").transform.GetChild(0);
        print(tf2);
		
		//设置s和g2的标签为Player；
        GameObject go2=GameObject.FindGameObjectWithTag("Player");
        print(go2);

        GameObject[] gArray = GameObject.FindGameObjectsWithTag("Player");
        print(gArray.Length);
        print(gArray[0].name);

8.启用和禁用

 	public GameObject Cube;
    void Update()
    {
        if (Input.GetKeyDown(KeyCode.D))
        {
            Cube.SetActive(false);
            print(Cube.activeSelf);
            print(Cube.activeInHierarchy);
        }
        if (Input.GetKeyDown(KeyCode.A))
        {
            Cube.SetActive(true);
            print(Cube.activeSelf);
            print(Cube.activeInHierarchy);
        }
    }

获取组件信息

void Start()
    {
        BoxCollider box= gameObject.GetComponent<BoxCollider>();
        box.size *= 3;

        //获取脚本组件
        s c=gameObject.GetComponent<s>();
        c.name = "txy";
        c.print();
    }

组价的启用和禁用

	void Update()
    {
        //组件的添加和删除
        if(Input.GetKeyDown(KeyCode.A))
        {
            gameObject.AddComponent<Rigidbody>();
        }
        if (Input.GetKeyDown(KeyCode.D))
        {
            GameObject.Destroy(gameObject.GetComponent<Rigidbody>());
        }


        //组件的启用和禁用
        if (Input.GetKeyDown(KeyCode.E))
        {
            gameObject.GetComponent<BoxCollider>().enabled = true;
        }
        if (Input.GetKeyDown(KeyCode.F))
        {
            gameObject.GetComponent<BoxCollider>().enabled =false ;
        }
    }

移动物体

    void Update()
    {
        //控制物体的移动
        //1.通过改变位置信息，添加一个增量，来持续改变位置信息
        transform.position += new Vector3(Time.deltaTime * 0.5f,0, 0);

        //2.通过transform.Translate来移动,默认朝自身坐标系方向运动，可以设置为朝世界坐标系
       transform.Translate(Vector3.right * Time.deltaTime * 0.5f,Space.World);

        //3.通过Vector3.Lerp方法,通过插值,运动为先快后慢
        Vector3 target = new Vector3(4f, 3f, 2f);
        transform.position=Vector3.Lerp(transform.position, target, Time.deltaTime);

        //4.通过Vector3.MoveTowards方法,匀速移动,z增量为Time.deltaTime
        transform.position = Vector3.MoveTowards(transform.position, target, Time.deltaTime);

	    //5.通过A，S，D，W键来控制物体的移动；虚拟轴的值正负来控制移动的方向
        float h = Input.GetAxis("Horizontal");
        float v = Input.GetAxis("Vertical");
        transform.Translate(Vector3.right * h * Time.deltaTime);
        transform.Translate(Vector3.forward * v * Time.deltaTime);
    }
    

物体的旋转

  void Start()
    {
    	//欧拉角与四元素介绍
        //获取物体的欧拉角
        print(transform.eulerAngles);

        //获取四元数
        print(transform.rotation);

        //四元素与欧拉角的相互转换
        print(transform.rotation.eulerAngles);//四元数-->欧拉角
        print(Quaternion.Euler(transform.eulerAngles));// 欧拉角-- > 四元数
    }

    // Update is called once per frame
    void Update()
    {
        //1.使用transform.Rolate方法，y轴每秒旋转30度
        transform.Rotate(Vector3.up * Time.deltaTime * 30);

        //2.使用四元数的乘法来实现，在其基础上y轴旋转5度；
        Quaternion q1 = transform.rotation;
        Vector3 vd = new Vector3(0, 5, 0);
        Quaternion q2 = Quaternion.Euler(vd);
        if(Input.GetKeyDown(KeyCode.R))
        {
            transform.rotation=q1* q2;
        }   
    }

Invoke相关方法

void Start()
    {
        //调用函数CreateBox，延迟两秒
       // Invoke("CreateBox", 2f);
        InvokeRepeating("CreateBox", 4f, 2f);
    }

    // Update is called once per frame
    void Update()
    {
        bool r = IsInvoking("CreateBox");
        print(r);

        if(Input.GetKeyDown(KeyCode.D))
        {
             //CancelInvoke();
            CancelInvoke("CreateBox");
        }
    }
    void CreateBox()
    {
        print("生成物体");
    }
}

9.协成
协成：协成程序，即主程序在运行的同时开启另外一段出路逻辑。
协成方法与普通方法的区别：

• 调用普通方法，会等这个普通方法执行完，然后在继续向下执行；
• 调用协成方法，可以不用等这个方法执行完就继续向下执行；

协成方法的定义:

• 返回值类型是IEnumerator，方法体中使用yield return返回，可以返回空。
• 使用yield语句可以暂停协成的执行，yield return的返回值决定了什么时候恢复协成的执行。

    void Start()
    {
        //普通方法
        print("任务1");
        print("任务2");
        //print("任务3");
        //开启协成
        StartCoroutine("Task3");
        print("任务4");
    }
    //定义协成
    IEnumerator Task3()
    {
        yield return new WaitForSeconds(2f);
        print("任务3");
    }

结果

    void Update()
    {
        //停止协成
        if(Input.GetKeyDown(KeyCode.Space))
        {
            StopCoroutine("Task3");
        }
    }

10.物理引擎
具有刚体组件的物体，满足物理规律，具有碰撞体的物体能进行碰撞检测。

• Mass表示物体的重量
• Drag：空气阻力
• Angular Drag：角阻力，受到扭曲时的空气阻力
• Use Gravity：使用重力

    private Rigidbody r;
    // Start is called before the first frame update
    void Start()
    {
        r = gameObject.GetComponent<Rigidbody>();

    }

    // Update is called once per frame
    void Update()
    {
        //刚体移动
        float h = Input.GetAxis("Horizontal");
        float v = Input.GetAxis("Vertical");
        r.MovePosition(r.position + transform.right * h * Time.deltaTime * 2f);
        r.MovePosition(r.position + transform.forward * v * Time.deltaTime * 2f);
    }

碰撞事件检测方法

    private void OnCollisionEnter(Collision collision)
    {
        print("Enter"+collision.gameObject.name);
    }
    private void OnCollisionExit(Collision collision)
    {
        print("Enter" + collision.gameObject.name);
    }
    private void OnCollisionStay(Collision collision)
    {
        print("Enter" + collision.gameObject.name);
    }

碰撞检测条件

• 两个物体接触并发生碰撞
• 运动物体必须带有碰撞体Collider和刚体Rigidbody
• 另一个物体必须至少带有碰撞体Collider

触发器事件

• 触发器：将碰撞组件属性面板上的“Is Trigger”勾选，当前物体的碰撞体就变成了了触发器。
• 触发器事件：当一个刚体控制的物体进入另一个物体的触发器范围内，就是触发事件。
• 用途：不与目标物体发生碰撞（接触），而是进入目标物体的触发范围，就执行特定操作。

触发器检测条件：

• 运动物体必须带有碰撞体Collider和刚体Rigidbody；
• 另一个物体至少带有碰撞体Collider；
• 其中一个物体勾选Is Trigger；

private void OnTriggerEnter(Collider other)
    {
        if(other.name !="Plane")
        {
            print(other.gameObject.name);
            print(other.name);
        }
    }
    private void OnTriggerExit(Collider other)
    {
        if (other.name != "Plane")
        {
            print(other.gameObject.name);
            print(other.name);
        }
    }

    private void OnTriggerStay(Collider other)
    {
        if (other.name != "Plane")
        {
            print(other.gameObject.name);
            print(other.name);
        }
    }

物理射线

• 从一个点往一个方向发射，该射线与场景中的物体的碰撞体组件碰撞，射线即结束。
• 由于射线可以与物理组件Collider交互，所以也称之为“物理射线”；

物理射线检测方法：

• 通过摄像机创建射线
  Camera.main:指的是tag设置为MainCamera的摄像机的组件Camera的引用；
  ScreenPointToRay(Vector3):摄像机组件的下的方法，屏幕点转化为射线，返回一个Ray类型的射线。
  Input.mousePosition:鼠标所在的位置，Vector3类型；
• 检测射线与其他物体的碰撞
  RaycastHit：一个结构体，存储射线的碰撞信息；
  Physics.Raycast(Ray,out RaycastHit):检测射线，碰撞返回true，否则返回false；第一个参数为需要检测的射线，第二个参数存储碰撞信息。

    private Ray ray;
    private RaycastHit hit;
    void Update()
    {
        if(Input.GetMouseButtonDown(0))
        {
            //获取摄像机，创建一条射线,方向为摄像机到鼠标点击的位置
            ray = Camera.main.ScreenPointToRay(Input.mousePosition);
        }

        //碰撞检测，通过结构体hit和返回关键字out返回碰撞信息
        if(Physics.Raycast(ray, out hit))
        {
            //把碰撞的物体销毁
            GameObject.Destroy(hit.collider.gameObject);
        }
    }

附：
学习至中国大学mooc-Unity2D游戏程序设计