14.GameObject游戏对象

  1. 14.Unity重要组件和API-GameObject
    1. 14.1 知识点
      1. GameObject中的成员变量
        1. name变量 对象的名称
        2. activeSelf变量 对象的是否激活
        3. isStatic变量 对象的是否是静态对象
        4. layer变量 对象的层级
        5. tag变量 对象的标签
        6. transform变量对象的位置、旋转和缩放
      2. GameObject中的静态方法
        1. CreatePrimitive方法 创建一个具有原始网格渲染器和相应碰撞体的游戏对象
        2. 查找单个对象的注意事项
        3. Find方法 查找单个对象
        4. FindWithTag方法、FindGameObjectWithTag方法 通过tag来查找对象
        5. 得到某一个单个对象的两种方式
        6. 查找多个对象的注意事项
        7. Unity中的Object和C#中的万物之父的区别
        8. FindGameObjectsWithTag方法 通过tag找到多个对象
        9. FindObjectOfType方法 找到场景中挂载某一个脚本(组件)的对象
        10. Instantiate方法 实例化对象(克隆对象)
        11. Destroy方法 删除对象
        12. DestroyImmediate方法 立即删除对象
        13. 删除对象的注意事项:
        14. DontDestroyOnLoad方法 过场景不移除对象
      3. GameObject中的成员方法
        1. GameObject构造函数 创建空物体
        2. AddComponent方法 为对象添加脚本
        3. GetComponent方法 得到对象的脚本
        4. CompareTag方法 标签比较
        5. SetActive方法 设置对象激活失活
        6. 次要的成员方法
        7. SendMessage方法 广播自己执行方法
        8. BroadcastMessage方法 广播自己和所有子对象执行方法
        9. SendMessageUpwards方法 广播自己和所有父对象对象执行方法
      4. 总结
    2. 14.2 知识点代码
      1. Lesson14_最小单位GameObject
      2. Lesson14_最小单位GameObjectTest
    3. 14.3 练习题
      1. 一个空物体上挂了一个脚本,游戏运行时该脚本可以实例化出之前的坦克预设体
      2. 一个脚本A一个脚本B,脚本A挂在A对象上,脚本B挂在B对象上,实现在A脚本的Start函数中将B对象上的B脚本失活(用GameObject相关知识做)
      3. 一个对象A和一个对象B,在A上挂一个脚本,通过这个脚本可以让B对象改名,失活,延迟删除,立即删除。可以在Inspector窗口进行设置,让B实现不同的效果(提示:GameObject、枚举)
    4. 14.4 练习题代码
      1. Lesson14_练习题
      2. Lesson14_练习题_A
      3. Lesson14_练习题_A1
      4. Lesson14_练习题_B

14.Unity重要组件和API-GameObject


14.1 知识点

GameObject中的成员变量

name变量 对象的名称

print(this.gameObject.name);
this.gameObject.name = "Lesson14_最小单位GameObject林文韬改名";
print(this.gameObject.name);

activeSelf变量 对象的是否激活

print(this.gameObject.activeSelf);

isStatic变量 对象的是否是静态对象

print(this.gameObject.isStatic);

layer变量 对象的层级

print(this.gameObject.layer);

tag变量 对象的标签

print(this.gameObject.tag);

transform变量对象的位置、旋转和缩放

//this.transform 上一节课讲解的 通过Mono去得到的依附对象的GameObject的位置信息
//他们得到的信息是一样 都是依附的GameObject的位置信息
print(this.gameObject.transform.position);

GameObject中的静态方法

CreatePrimitive方法 创建一个具有原始网格渲染器和相应碰撞体的游戏对象

GameObject tempCube = GameObject.CreatePrimitive(PrimitiveType.Cube);
tempCube.name = "林文韬创建的临时立方体";
//只要得到了一个GameObject对象 我就可以得到它身上挂在的任何脚本信息
//通过obj.GetComponent来得去

查找单个对象的注意事项

  • 无法找到失活的对象,只能找到激活的对象
  • 如果场景中存在多个满足条件的对象,我们无法准确确定找到的是谁

Find方法 查找单个对象

//通过对象名查找 传入 name 查找 GameObject 然后返回它
//这个查找效率比较低下  因为他会在场景中的所有对象去查找
//没有找到 就会返回null
GameObject findGameObject = GameObject.Find("林文韬");
if (findGameObject != null)
{
    print("Find方法找到了" + findGameObject.name);
}
else
{
    print("Find方法找到了没有找到对应对象");
}

FindWithTag方法、FindGameObjectWithTag方法 通过tag来查找对象

//返回一个标记为 tag 的活动 GameObject。如果未找到 GameObject,则返回 null。
//FindWithTag方法和FindGameObjectWithTag方法 效果一样 只是名字不一样而已
GameObject findWithTagGameObject = GameObject.FindWithTag("Player");
GameObject findGameObjectWithTagGameObject = GameObject.FindGameObjectWithTag("Player");
if (findWithTagGameObject != null)
{
    print("FindWithTag方法找的对象" + findWithTagGameObject.name);
}
else
{
    print("FindWithTag没有找到对应对象");
}

得到某一个单个对象的两种方式

  • 是public对象后,从Unity的Inspector窗口拖拽进行关联
  • 通过API去查找

查找多个对象的注意事项

  • GameObject中的查找多个对象的API只能是通过tag去找多个对象,没有通过名字查找多个对象的方法
  • Object中也有查找多个对象的API,用的比较少。Object提供是GameObject的父类

Unity中的Object和C#中的万物之父的区别

  • Unity里面的Object不是指在System中的万物之父object
  • Unity里的Object,命名空间在UnityEngine中的Object类,也是继承万物之父的一个自定义类
  • C#中的Object,命名空间是在System中的

FindGameObjectsWithTag方法 通过tag找到多个对象

//返回标签为 tag 的活动 GameObjects 的数组。如果未找到任何 GameObject,则返回空数组。
//FindGameObjectsWithTag方法 只能找到 激活对象 无法找到失活对象
GameObject[] findGameObjectsWithTagGameObjectsArray = GameObject.FindGameObjectsWithTag("Player");
print("找到tag为Player对象的个数" + findGameObjectsWithTagGameObjectsArray.Length);

FindObjectOfType方法 找到场景中挂载某一个脚本(组件)的对象

//返回与指定类型匹配的对象。如果没有任何匹配该类型的对象,则返回 null。
//效率更低 上面的GameObject.Find 和通过FindWithTag找 只是遍历对象
//这个方法 不仅要遍历对象 还要遍历对象上挂载的脚本 
Lesson14_最小单位GameObject findObjectOfTypeLesson14 = GameObject.FindObjectOfType<Lesson14_最小单位GameObject>();
print(findObjectOfTypeLesson14.gameObject.name);

Instantiate方法 实例化对象(克隆对象)

//克隆 original 对象并返回克隆对象。
//实例化(克隆)对象 它的作用 是根据一个GameObject对象 创建出一个和它一模一样的对象
GameObject InstantiatePrefab1 = GameObject.Instantiate(Prefab1);
//以后学了更多知识点 就可以使用Instantiate方法的重载操作InstantiatePrefab1
//如果你继承了 MonoBehavior 其实可以不用写GameObject一样可以使用
//因为 这个方法是Unity里面的 Object基类提供给我们的 所以可以直接用
//Instantiate(Prefab1);

Destroy方法 删除对象

//移除 GameObject、组件或资源。
//传入GameObject删除对象
GameObject.Destroy(Prefab2);
//第二个参数 代表延迟几秒钟删除
GameObject.Destroy(InstantiatePrefab1, 5);
//Destroy不仅可以删除对象 还可以删除脚本
//GameObject.Destroy(this);//挂载的脚本会被移除 为了方便演示注释
//如果是继承MonoBehavior的类 不用写GameObject
//Destroy(Prefab2);

DestroyImmediate方法 立即删除对象

//立即销毁对象 /obj/。强烈建议您改用 Destroy。
GameObject.DestroyImmediate(Prefab3);


//如果是继承MonoBehavior的类 不用写GameObject
//DestroyImmediate(Prefab3);

删除对象的注意事项:

  • Destroy方法不会马上移除对象,只是给这个对象加了一个移除标识。
  • 一般情况下,它会在下一帧时把这个对象移除并从内存中移除。
  • 如果没有特殊需求,一定要马上移除一个对象的话,建议使用Destroy方法,因为是异步的,降低卡顿的几率。
  • DestroyImmediate方法立即把对象从内存中移除了,可能会造成卡顿。

DontDestroyOnLoad方法 过场景不移除对象

//在加载新的 Scene 时,请勿销毁 Object。
//默认情况 在切换场景时 场景中对象都会被自动删除掉
//如果你希望某个对象 过场景不被移除 
//下面这句代码 就是不想谁过场景被移除 就传谁 
//一般都是传 依附的GameObject对象
//比如下面这句代码的意思 就是自己依附的GameObject对象 过场景不被删除
GameObject.DontDestroyOnLoad(this.gameObject);
//如果是继承MonoBehavior的类 不用写GameObject
//DontDestroyOnLoad(this.gameObject);

GameObject中的成员方法

GameObject构造函数 创建空物体

//new一个GameObject就是在创建一个空物体
GameObject newGameObject1 = new GameObject();//无参构造
GameObject newGameObject2 = new GameObject("林文韬创建的空物体");//传入名字
GameObject newGameObject3 = new GameObject("顺便加脚本的空物体", typeof(Lesson07_反射机制和游戏场景), typeof(Lesson09_脚本基本规则Test));//传入名字和想加入的组件

AddComponent方法 为对象添加脚本

//将名为 className 的组件类添加到该游戏对象。
//继承MOnoBehavior的脚本 是不能够去new 
//如果想要动态的添加继承MonoBehavior的脚本 在某一个对象上
//直接使用GameObject提供的添加脚本方法即可
//传入脚本类 想要得到返回的脚本需要as一下
Lesson07_反射机制和游戏场景 lesson7_1 = newGameObject1.AddComponent(typeof(Lesson07_反射机制和游戏场景)) as Lesson07_反射机制和游戏场景;
//AddComponent方法泛型重载 直接得到不用as
Lesson07_反射机制和游戏场景 lesson7_2 = newGameObject1.AddComponent<Lesson07_反射机制和游戏场景>();
//通过返回值 可以得到加入的脚本信息
//来进行一些处理

GetComponent方法 得到对象的脚本

//如果游戏对象附加了类型为 type 的组件,则将其返回,否则返回 null。
//得到脚本的成员方法 和继承MonoBehaviour的类得到脚本的方法 一模一样
//传入脚本类 想要得到返回的脚本需要as一下
Lesson07_反射机制和游戏场景 lesson7_3 = newGameObject1.GetComponent(typeof(Lesson07_反射机制和游戏场景)) as Lesson07_反射机制和游戏场景;
//AddComponent方法泛型重载 直接得到不用as
Lesson07_反射机制和游戏场景 lesson7_4 = newGameObject1.GetComponent<Lesson07_反射机制和游戏场景>();

CompareTag方法 标签比较

//此游戏对象是否使用 tag 进行了标记?
if (this.gameObject.CompareTag("Player"))
{
    print("对象的标签 是 Player");
}
//也可以直接得到游戏对象的标签对象后再比较 两种比较方法是一样的是一样的 只是CompareTag方法更方便
if (this.gameObject.tag == "Player")
{
    print("对象的标签 是 Player");
}

SetActive方法 设置对象激活失活

//根据给定的值 true 或 / false /,激活 / 停用 GameObject。
//false失活 true激活
newGameObject1.SetActive(false);
newGameObject2.SetActive(false);
newGameObject3.SetActive(true);

次要的成员方法

  • 下面讲的方法了解即可,都不建议大家使用,效率比较低
  • 通过广播或者发送消息的形式,让自己或者别人执行某些行为方法

SendMessage方法 广播自己执行方法

//调用此游戏对象中的每个 MonoBehaviour 上名为 methodName 的方法。
//在自己依附的GameObject的 所有挂载了继承MonoBehaviour的脚本里 搜索所有有相同对应名字的方法并执行
this.gameObject.SendMessage("TestFun");
this.gameObject.SendMessage("TestFun2", 666999);

BroadcastMessage方法 广播自己和所有子对象执行方法

//调用此游戏对象或其任何子项中的每个 MonoBehaviour 上名为 methodName 的方法。
this.gameObject.BroadcastMessage("函数名");

SendMessageUpwards方法 广播自己和所有父对象对象执行方法

//调用此游戏对象中的每个 MonoBehaviour 上或此行为的每个父级上名为 methodName 的方法。
this.gameObject.SendMessageUpwards("函数名");

总结

  • GameObject的常用内容
  • 基本成员变量:名字 失活激活状态 标签 层级等等
  • 静态方法相关:创建自带几何体 查找场景中对象 实例化对象 删除对象 过场景不移除
  • 成员方法:为对象 动态添加和获取指定脚本 设置失活激活的状态

14.2 知识点代码

Lesson14_最小单位GameObject

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

public class Lesson14_最小单位GameObject : MonoBehaviour
{
    //准备用来克隆的对象
    //1.直接是场景上的某个对象
    //2.可以是一个预设体对象
    public GameObject Prefab1;
    public GameObject Prefab2;
    public GameObject Prefab3;
 
    void Start()
    {
        #region 知识点一 GameObject中的成员变量

        //name变量 对象的名称
        print(this.gameObject.name);
        this.gameObject.name = "Lesson14_最小单位GameObject林文韬改名";
        print(this.gameObject.name);

        //activeSelf变量 对象的是否激活
        print(this.gameObject.activeSelf);

        //isStatic变量 对象的是否是静态对象
        print(this.gameObject.isStatic);

        //layer变量 对象的层级
        print(this.gameObject.layer);

        //tag变量 对象的标签
        print(this.gameObject.tag);

        //transform变量 对象的位置、旋转和缩放
        //this.transform 上一节课讲解的 通过Mono去得到的依附对象的GameObject的位置信息
        //他们得到的信息是一样 都是依附的GameObject的位置信息
        print(this.gameObject.transform.position);

        #endregion

        #region 知识点二 GameObject中的静态方法

        //CreatePrimitive方法 创建一个具有原始网格渲染器和相应碰撞体的游戏对象 传入PrimitiveType类型枚举
        GameObject tempCube = GameObject.CreatePrimitive(PrimitiveType.Cube);
        tempCube.name = "林文韬创建的临时立方体";
        //只要得到了一个GameObject对象 我就可以得到它身上挂在的任何脚本信息
        //通过obj.GetComponent来得去

        //查找对象相关的知识

        //查找单个对象

        //查找单个对象方法的共同点:
        //1.无法找到失活的对象的 只能找到激活的对象
        //2.如果场景中 存在多个满足条件的对象 我们无法准确确定找到的是谁 

        //Find方法 查找单个对象
        //通过对象名查找 传入 name 查找 GameObject 然后返回它
        //这个查找效率比较低下  因为他会在场景中的所有对象去查找
        //没有找到 就会返回null
        GameObject findGameObject = GameObject.Find("林文韬");
        if (findGameObject != null)
        {
            print("Find方法找到了" + findGameObject.name);
        }
        else
        {
            print("Find方法找到了没有找到对应对象");
        }

        //FindWithTag方法 FindGameObjectWithTag方法 通过tag来查找对象
        //返回一个标记为 tag 的活动 GameObject。如果未找到 GameObject,则返回 null。
        //FindWithTag方法和FindGameObjectWithTag方法 效果一样 只是名字不一样而已
        GameObject findWithTagGameObject = GameObject.FindWithTag("Player");
        GameObject findGameObjectWithTagGameObject = GameObject.FindGameObjectWithTag("Player");
        if (findWithTagGameObject != null)
        {
            print("FindWithTag方法找的对象" + findWithTagGameObject.name);
        }
        else
        {
            print("FindWithTag没有找到对应对象");
        }

        //得到某一个单个对象 目前有两种方式
        //1.是public对象后 从Unity的Inspector窗口拖拽 进行关联
        //2.通过API去查找


        //查找多个对象
        //GameObject中的查找多个对象的API 只能是通过tag去找多个对象 没有通过名字查找多个对象的方法
        //Object中也有的查找多个对象的API 用的比较少  Object提供是GameObject的父类

        //Unity中的Object和C#中的万物之父的区别
        //Unity里面的Object 不是指在System中的万物之父object
        //Unity里的Object 命名空间在UnityEngine中的 Object类 也是集成万物之父的一个自定义类
        //C#中的Object 命名空间是在System中的 

        //FindGameObjectsWithTag方法 通过tag找到多个对象
        //返回标签为 tag 的活动 GameObjects 的数组。如果未找到任何 GameObject,则返回空数组。
        //FindGameObjectsWithTag方法 只能找到 激活对象 无法找到失活对象
        GameObject[] findGameObjectsWithTagGameObjectsArray = GameObject.FindGameObjectsWithTag("Player");
        print("找到tag为Player对象的个数" + findGameObjectsWithTagGameObjectsArray.Length);


        //FindObjectOfType方法 找到场景中挂载某一个脚本(组件)的对象
        //返回与指定类型匹配的对象。如果没有任何匹配该类型的对象,则返回 null。
        //效率更低 上面的GameObject.Find 和通过FindWithTag找 只是遍历对象
        //这个方法 不仅要遍历对象 还要遍历对象上挂载的脚本 
        Lesson14_最小单位GameObject findObjectOfTypeLesson14 = GameObject.FindObjectOfType<Lesson14_最小单位GameObject>();
        print(findObjectOfTypeLesson14.gameObject.name);

        //Instantiate方法 实例化对象(克隆对象)
        //克隆 original 对象并返回克隆对象。
        //实例化(克隆)对象 它的作用 是根据一个GameObject对象 创建出一个和它一模一样的对象
        GameObject InstantiatePrefab1 = GameObject.Instantiate(Prefab1);
        //以后学了更多知识点 就可以使用Instantiate方法的重载操作InstantiatePrefab1
        //如果你继承了 MonoBehavior 其实可以不用写GameObject一样可以使用
        //因为 这个方法是Unity里面的 Object基类提供给我们的 所以可以直接用
        //Instantiate(Prefab1);

        //Destroy方法 删除对象
        //移除 GameObject、组件或资源。
        //传入GameObject删除对象
        GameObject.Destroy(Prefab2);
        //第二个参数 代表延迟几秒钟删除
        GameObject.Destroy(InstantiatePrefab1, 5);
        //Destroy不仅可以删除对象 还可以删除脚本
        //GameObject.Destroy(this);//挂载的脚本会被移除 为了方便演示注释
        //如果是继承MonoBehavior的类 不用写GameObject
        //Destroy(Prefab2);

        //DestroyImmediate方法 立即删除对象
        //立即销毁对象 /sphere/。强烈建议您改用 Destroy。
        GameObject.DestroyImmediate(Prefab3);
        //如果是继承MonoBehavior的类 不用写GameObject
        //DestroyImmediate(Prefab3);

        //删除对象的注意事项:
        //Destroy方法 不会马上移除对象 只是给这个对象加了一个移除标识 
        //一般情况下 它会在下一帧时把这个对象移除并从内存中移除
        //如果没有特殊需求 一定要马上移除一个对象的话 
        //建议使用Destroy方法 因为 是异步的 降低卡顿的几率
        //DestroyImmediate方法立即把对象从内存中移除了 可能会造成卡顿


        //DontDestroyOnLoad方法 过场景不移除对象
        //在加载新的 Scene 时,请勿销毁 Object。
        //默认情况 在切换场景时 场景中对象都会被自动删除掉
        //如果你希望某个对象 过场景不被移除 
        //下面这句代码 就是不想谁过场景被移除 就传谁 
        //一般都是传 依附的GameObject对象
        //比如下面这句代码的意思 就是自己依附的GameObject对象 过场景不被删除
        GameObject.DontDestroyOnLoad(this.gameObject);
        //如果是继承MonoBehavior的类 不用写GameObject
        //DontDestroyOnLoad(this.gameObject);

        #endregion

        #region 知识点三 GameObject中的成员方法

        //GameObject构造函数 创建空物体
        //new一个GameObject就是在创建一个空物体
        GameObject newGameObject1 = new GameObject();//无参构造
        GameObject newGameObject2 = new GameObject("林文韬创建的空物体");//传入名字
        GameObject newGameObject3 = new GameObject("顺便加脚本的空物体", typeof(Lesson07_反射机制和游戏场景), typeof(Lesson09_脚本基本规则Test));//传入名字和想加入的组件

        //AddComponent方法 为对象添加脚本
        //将名为 className 的组件类添加到该游戏对象。
        //继承MOnoBehavior的脚本 是不能够去new 
        //如果想要动态的添加继承MonoBehavior的脚本 在某一个对象上
        //直接使用GameObject提供的添加脚本方法即可
        //传入脚本类 想要得到返回的脚本需要as一下
        Lesson07_反射机制和游戏场景 lesson7_1 = newGameObject1.AddComponent(typeof(Lesson07_反射机制和游戏场景)) as Lesson07_反射机制和游戏场景;
        //AddComponent方法泛型重载 直接得到不用as
        Lesson07_反射机制和游戏场景 lesson7_2 = newGameObject1.AddComponent<Lesson07_反射机制和游戏场景>();
        //通过返回值 可以得到加入的脚本信息
        //来进行一些处理

        //GetComponent方法 得到对象的脚本
        //如果游戏对象附加了类型为 type 的组件,则将其返回,否则返回 null。
        //得到脚本的成员方法 和继承MonoBehaviour的类得到脚本的方法 一模一样
        //传入脚本类 想要得到返回的脚本需要as一下
        Lesson07_反射机制和游戏场景 lesson7_3 = newGameObject1.GetComponent(typeof(Lesson07_反射机制和游戏场景)) as Lesson07_反射机制和游戏场景;
        //AddComponent方法泛型重载 直接得到不用as
        Lesson07_反射机制和游戏场景 lesson7_4 = newGameObject1.GetComponent<Lesson07_反射机制和游戏场景>();

        //CompareTag方法标签比较
        //此游戏对象是否使用 tag 进行了标记?
        if (this.gameObject.CompareTag("Player"))
        {
            print("对象的标签 是 Player");
        }
        //也可以直接得到游戏对象的标签对象后再比较 两种比较方法是一样的是一样的 只是CompareTag方法更方便
        if (this.gameObject.tag == "Player")
        {
            print("对象的标签 是 Player");
        }

        //SetActive方法 设置对象激活失活
        //根据给定的值 true 或 / false /,激活 / 停用 GameObject。
        //false失活 true激活
        newGameObject1.SetActive(false);
        newGameObject2.SetActive(false);
        newGameObject3.SetActive(true);

        //次要的成员方法
        //下面讲的方法 了解即可 都不建议大家使用 效率比较低
        //通过广播或者发送消息的形式 让自己或者别人 执行某些行为方法

        //SendMessage方法 广播自己执行方法
        //调用此游戏对象中的每个 MonoBehaviour 上名为 methodName 的方法。
        //在自己依附的GameObject的 所有挂载了继承MonoBehaviour的脚本里 搜索所有有相同对应名字的方法并执行
        this.gameObject.SendMessage("TestFun");
        this.gameObject.SendMessage("TestFun2", 666999);

        //BroadcastMessage方法 广播自己和所有子对象执行方法
        //调用此游戏对象或其任何子项中的每个 MonoBehaviour 上名为 methodName 的方法。
        this.gameObject.BroadcastMessage("函数名");

        //SendMessageUpwards方法 广播自己和所有父对象对象执行方法
        //调用此游戏对象中的每个 MonoBehaviour 上或此行为的每个父级上名为 methodName 的方法。
        this.gameObject.SendMessageUpwards("函数名");

        #endregion
    }

    void TestFun()
    {
        print("Lesson14_最小单位GameObject的TestFun");
    }

    void TestFun2(int a)
    {
        print("Lesson14_最小单位GameObject的TestFun2" + a);
    }

    //总结

    //GameObject的常用内容
    //基本成员变量:名字 失活激活状态 标签 层级 等等
    //静态方法相关:创建自带几何体 查找场景中对象 实例化对象 删除对象 过场景不移除
    //成员方法:为对象 动态添加和获取指定脚本 设置失活激活的状态
}

Lesson14_最小单位GameObjectTest

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

public class Lesson14_最小单位GameObjectTest : MonoBehaviour
{
    void TestFun()
    {
        print("Lesson14_最小单位GameObjectTest的TestFun");
    }

    void TestFun2(int a)
    {
        print("Lesson14_最小单位GameObjectTest的TestFun2" + a);
    }

}

14.3 练习题

一个空物体上挂了一个脚本,游戏运行时该脚本可以实例化出之前的坦克预设体

//一般情况下 我们实例化出的对象 都是克隆拖进来的预设体 但是也可拖场景上的对象进行克隆
GameObject tankObj = GameObject.Instantiate(tank);
tankObj.name = "坦克";

//找一个对象来克隆
GameObject obj = GameObject.Find("Tank");
if (obj != null)
{
    //继承MonoBehavior的类 可以不写GameObject
    tankObj = Instantiate(obj);
    tankObj.name = "找到场景中的坦克 再创建出的坦克";
}

一个脚本A一个脚本B,脚本A挂在A对象上,脚本B挂在B对象上,实现在A脚本的Start函数中将B对象上的B脚本失活(用GameObject相关知识做)

public Lesson14_练习题_B Lesson14_练习题_B_Component2;

void Start()
{
    //找对象 有几种方法
    //方法一:就是通过GameObject提供的查找对象的方法
    //你要控制别人 那就要得到你想要控制的对象
    //先找到 然后再操作
    //找到场景中名字叫 Lesson14_练习题_B 的对象 
    GameObject Lesson14_练习题_B_GameObject = GameObject.Find("Lesson14_练习题_B");
    //然后再得到该对象上挂载的某一个脚本 然后进行操作即可
    Lesson14_练习题_B Lesson14_练习题_B_Component = Lesson14_练习题_B_GameObject.GetComponent<Lesson14_练习题_B>();
    if (Lesson14_练习题_B_Component != null)
    {
        Lesson14_练习题_B_Component.enabled = false;
    }

    //方法二:通过公共成员变量直接进行关联 来控制
    //虽然方法二简单 但是是有一些破坏面向对象思想的结构的
    //现在相当于 A 有个一个特征 是B
    Lesson14_练习题_B_Component2.enabled = false;
}

一个对象A和一个对象B,在A上挂一个脚本,通过这个脚本可以让B对象改名,失活,延迟删除,立即删除。可以在Inspector窗口进行设置,让B实现不同的效果(提示:GameObject、枚举)

public enum E_DoSomething_Type
{
    //改名
    ChangeName,
    //失活
    ActiveFlase, 
    //延迟删除
    DelayDes,
    //删除
    Des,
}

public class Lesson14_练习题_A1 : MonoBehaviour
{
    //申明一个枚举 表示不同的状态 可以在Unity的Inspector窗口切换
    public E_DoSomething_Type type = E_DoSomething_Type.ChangeName;

    //通过Inspector窗口 关联B 这种方式 更加效率
    public GameObject Lesson14_练习题_B_GameObject;

    void Start()
    {
        switch (type)
        {
            case E_DoSomething_Type.ChangeName:
                Lesson14_练习题_B_GameObject.name = "B改名";
                break;
            case E_DoSomething_Type.ActiveFlase:
                Lesson14_练习题_B_GameObject.SetActive(false);
                break;
            case E_DoSomething_Type.DelayDes:
                Destroy(Lesson14_练习题_B_GameObject, 5);
                break;
            case E_DoSomething_Type.Des:
                DestroyImmediate(Lesson14_练习题_B_GameObject);
                break;
            default:
                break;
        }
    }
}

14.4 练习题代码

Lesson14_练习题

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

public class Lesson14_练习题 : MonoBehaviour
{
    public GameObject tank;
    
    void Start()
    {
        #region 练习题一
        //1.一个空物体上挂了一个脚本,游戏运行时该脚本可以 实例化 出之前的 坦克预设体

        //一般情况下 我们实例化出的对象 都是克隆拖进来的预设体 但是也可拖场景上的对象进行克隆
        GameObject tankObj = GameObject.Instantiate(tank);
        tankObj.name = "坦克";

        //找一个对象来克隆
        GameObject obj = GameObject.Find("Tank");
        if (obj != null)
        {
            //继承MonoBehavior的类 可以不写GameObject
            tankObj = Instantiate(obj);
            tankObj.name = "找到场景中的坦克 再创建出的坦克";
        }

        #endregion

        #region 练习题二
        //2.一个脚本A一个脚本B,脚本A挂在A对象上,脚本B挂在B对象上
        //实现在A脚本的Start函数中将B对象上的B脚本失活(用GameObject相关知识做)
        #endregion

        #region 练习题三
        //3.一个对象A和一个对象B,在A上挂一个脚本,
        //通过这个脚本可以让B对象改名,失活,延迟删除,立即删除。
        //可以在Inspector窗口进行设置,让B实现不同的效果(提示:GameObject、枚举)
        #endregion
    }
}

Lesson14_练习题_A

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

public class Lesson14_练习题_A : MonoBehaviour
{
    public Lesson14_练习题_B Lesson14_练习题_B_Component2;

    void Start()
    {
        //找对象 有几种方法
        //方法一:就是通过GameObject提供的查找对象的方法
        //你要控制别人 那就要得到你想要控制的对象
        //先找到 然后再操作
        //找到场景中名字叫 Lesson14_练习题_B 的对象 
        GameObject Lesson14_练习题_B_GameObject = GameObject.Find("Lesson14_练习题_B");
        //然后再得到该对象上挂载的某一个脚本 然后进行操作即可
        Lesson14_练习题_B Lesson14_练习题_B_Component = Lesson14_练习题_B_GameObject.GetComponent<Lesson14_练习题_B>();
        if (Lesson14_练习题_B_Component != null)
        {
            Lesson14_练习题_B_Component.enabled = false;
        }

        //方法二:通过公共成员变量直接进行关联 来控制
        //虽然方法二简单 但是是有一些破坏面向对象思想的结构的
        //现在相当于 A 有个一个特征 是B
        Lesson14_练习题_B_Component2.enabled = false;
    }
}

Lesson14_练习题_A1

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

public enum E_DoSomething_Type
{
    //改名
    ChangeName,
    //失活
    ActiveFlase, 
    //延迟删除
    DelayDes,
    //删除
    Des,
}

public class Lesson14_练习题_A1 : MonoBehaviour
{
    //申明一个枚举 表示不同的状态 可以在Unity的Inspector窗口切换
    public E_DoSomething_Type type = E_DoSomething_Type.ChangeName;

    //通过Inspector窗口 关联B 这种方式 更加效率
    public GameObject Lesson14_练习题_B_GameObject;

    void Start()
    {
        switch (type)
        {
            case E_DoSomething_Type.ChangeName:
                Lesson14_练习题_B_GameObject.name = "B改名";
                break;
            case E_DoSomething_Type.ActiveFlase:
                Lesson14_练习题_B_GameObject.SetActive(false);
                break;
            case E_DoSomething_Type.DelayDes:
                Destroy(Lesson14_练习题_B_GameObject, 5);
                break;
            case E_DoSomething_Type.Des:
                DestroyImmediate(Lesson14_练习题_B_GameObject);
                break;
            default:
                break;
        }
    }
}

Lesson14_练习题_B

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

public class Lesson14_练习题_B : MonoBehaviour
{

}


转载请注明来源,欢迎对文章中的引用来源进行考证,欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论,也可以邮件至 785293209@qq.com

×

喜欢就点赞,疼爱就打赏