3D游戏_HW2_离散仿真引擎基础

简答题

• 解释 游戏对象（GameObjects） 和 资源（Assets）的区别与联系。
  区别： 通过查找Unity的manual我们可以得到两者的官方定义：游戏对象是指游戏中的每一个对象，如我们在Unity中的灯光和相机、以及我们创建的角色等等；而资产则是指我们在游戏或者项目中使用的任何项目，对于Unity来说，我们在平台中创建的混音器、动画控制器算资产，我们引用的外部的图像、音频这些同样算是资产。
  联系： 资源可以作为模板创建对象；游戏对象可以作为资源保存。
• 下载几个游戏案例，分别总结资源、对象组织的结构（指资源的目录组织结构与游戏对象树的层次结构）
  资源采用目录组织结构，即不同类型的资源分放在不同的目录下，比如预设、脚本、材质等不同资源放入不同的目录以便于管理和调用。
  游戏对象采用树层次结构，即不同对象之间存在层次关系，如课上练习所做的table则包括了四个table子对象。不同层次之间的对象通过树层次结构可以更方便地将游戏过程分解成不同部分，降低耦合。
• 编写一个代码，使用 debug 语句来验证 MonoBehaviour 基本行为或事件触发的条件
  - 基本行为包括 Awake() Start() Update() FixedUpdate() LateUpdate()
  - 常用事件包括 OnGUI() OnDisable() OnEnable()
  打开unity，创建一个空游戏对象和一个新的脚本。因为要使用 debug 语句来验证 MonoBehaviour基本行为或事件触发的条件，因此我们可以调用Debug.Log来把触发信息显示在控制面板上。脚本代码如下，完成后将脚本拖到空游戏对象中运行。

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

public class NewBehaviourScript: MonoBehaviour 
{
	void Start()
	{
		Debug.Log("Start enable!");
	}

	void Awake()
	{
		Debug.Log("Awake enable!");
	}

	void Update()
	{
		Debug.Log("Update enable!");
	}

	void FixedUpdate()
	{
		Debug.Log("FixedUpdate enable!");
	}

	void LateUpdate()
	{
		Debug.Log("LateUpdate enable!");
	}

	void OnGUI()
    {
        Debug.Log("OnGUI enable!");
    }

    void OnDisable()
    {
        Debug.Log("OnDisable enable!");
    }

    void OnEnable()
    {
        Debug.Log("OnEnable enable!");
    }
}

控制台输出如下：


根据unity的manual和输出结果，总结出基本行为或事件触发的条件为：  
Awake() 当一个脚本实例被载入时Awake被调用。
Start() 在所有Update函数之前被调用一次。
Update() 当行为启用时，其Update在每一帧被调用。
FixedUpdate() 当行为启用时，其 FixedUpdate 在每一时间片被调用。
LateUpdate() 当行为启用时，在所有Update函数之后执行。例如：摄像机跟随。
OnGUI() 渲染和处理GUI事件时调用。
OnEnable() 当对象变为可用或激活状态时被调用。
OnDisable() 当对象变为不可用或非激活状态时被调用。

• 查找脚本手册，了解 GameObject，Transform，Component 对象

  • 分别翻译官方对三个对象的描述（Description）
    GameObject: GameObject是Unity场景里面所有实体的基类。
    Transform: 对象的位置、旋转、以及比例。
    Component: 一切附加到游戏物体的基类。

  • 描述下图中 table 对象（实体）的属性、table 的 Transform 的属性、 table 的部件
    

    • 本题目要求是把可视化图形编程界面与 Unity API 对应起来，当你在 Inspector 面板上每一个内 容，应该知道对应 API。
    • 例如：table 的对象是 GameObject，第一个选择框是 activeSelf 属性。
      table 的对象是 GameObject，第一个选择框是 activeSelf 属性,第二个是tag属性，第三个是layer属性，第四个是prefab属性。
      
      table的Trasnsform属性第一个是position属性，第二个是rotation属性，第三个是localScale属性。其中Position通过三个坐标来控制对象的位置；Rotation则通过三个坐标来控制旋转；Scale通过三个坐标来控制小桌子的缩放/扩大等等。
      
      table的组件有 Transform、Cube、Mesh Render、Box Colider。MeshFilter是对象与网格的接口，BoxCollider用于调整坐标系的位置和大小，MeshRenderer为网格的渲染。
      

  • 用 UML 图描述 三者的关系（请使用 UMLet 14.1.1 stand-alone版本出图）
    

• 资源预设（Prefabs）与 对象克隆 (clone)

  • 预设（Prefabs）有什么好处？
    使用资源预设可以使我们更加方便快捷地创建多个相同对象。而且修改预设就可以完成对生成对象的修改，就不需要在后期优化时在多个地方修改了，使得我们可以轻松地对整个项目进行广泛的更改，而无需对资产的每个副本重复进行相同的编辑。
  • 预设与对象克隆 (clone or copy or Instantiate of Unity Object) 关系？
  • 两者都可以直接创造出和母体相同的副本。预设创建出的对象与源预设还有联系，源预设修改了由预设创建的对象也会被修改。克隆出的对象与源对象不再有联系。
  • 制作 table 预制，写一段代码将 table 预制资源实例化成游戏对象
    代码如下：

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

public class test : MonoBehaviour
{
    // Start is called before the first frame update
    public GameObject prefab = null;
    void Start () {
        GameObject table = (GameObject)Instantiate(prefab);
        table.transform.position = new Vector3(0,0,0);
    }

    // Update is called once per frame
    void Update()
    {
        
    }
}

将脚本拖到空游戏对象中，然后将预设Table拖入到空游戏对象的Test组件中的Prefeb参数。

运行结果：

成功实例化

编程实践，小游戏

• 游戏内容： 井字棋 或 贷款计算器 或 简单计算器 等等
• 技术限制： 仅允许使用 IMGUI 构建 UI
• 作业目的：
  • 了解 OnGUI() 事件，提升 debug 能力
  • 提升阅读 API 文档能力

选择实现井字棋

完整代码见个人仓库

• 首先定义需要用到的变量

    private int empty = 9;  //记录空的格子个数
    private int turn = 1;   //记录玩家轮次
    private int[,] chess = new int[3, 3];   //定义棋盘变量

• 实现游戏初始化的函数

    //初始化游戏的实现
    void reset()
    {
        empty = 9;  //棋盘空格数变为9
        turn = 1;   //轮到玩家1开始
        for (int i = 0; i < 3; i++)//初始化棋盘
        {
            for (int j = 0; j < 3; j++)
            {
                chess[i, j] = 0;
            }
        }
    }

• 构建UI，其中包括玩家点击空格子生成图像，显示图像和胜负判断

    private void OnGUI()
    {
        GUI.skin.button.fontSize = 30;
        GUI.skin.label.fontSize = 30;
        //若点击Reset按钮，游戏初始化
        //Reset按钮距离画布左侧450个像素，距离画布顶部400个像素
        if (GUI.Button(new Rect(350, 330, 200, 80), "Reset"))
        {
            reset();
        }
        //获取结果变量result
        int result = is_win();
        //若result为1，玩家1获胜，为2玩家2获胜，3则平局
        if (result == 1)
        {   
            //若玩家1获胜，画布显示O获胜。
            GUI.Label(new Rect(400, 10, 100, 50), "O wins");
        }
        else if (result == 2)
        {
            //若玩家2获胜，画布显示X获胜。
            GUI.Label(new Rect(400, 10, 100, 50), "X wins");
        }
        else if (result == 3)
        {
            //若平局，显示平局
            GUI.Label(new Rect(400, 10, 200, 50), "Draw");
        }
    
        for (int i = 0; i < 3; i++)
        {
            for (int j = 0; j < 3; j++)
            {   
                //若玩家1点击一个空格子，该格子显示“O”
                if (chess[i, j] == 1) { 
                    GUI.Button(new Rect(i * 90 + 315, j * 90 + 50, 90, 90), "O");
                }
                //若玩家1点击一个空格子，该格子显示“X”
                if (chess[i, j] == 2) {
                    GUI.Button(new Rect(i * 90 + 315, j * 90 + 50, 90, 90), "X");
                } 
                //若点击到一个空格子，若是玩家1轮次，该格子显示“O”，否则为“X”
                if (GUI.Button(new Rect(i * 90 + 315, j * 90 + 50, 90, 90), ""))
                {
                    if (result == 0)
                    {
                        if (turn == 1) { 
                            chess[i, j] = 1;
                        }
                        if (turn == 2) { 
                            chess[i, j] = 2;
                        } 
                        empty--;
                        turn = (turn==1)? 2:1;
                    }
                }
            }
        }
    }
    
    int is_win()
    {
        //判断是否中心的十字形或者X字形
        int temp = chess[1, 1];
        if (temp != 0)
        {
            if (temp == chess[0, 0] && temp == chess[2, 2])
            {
                return temp;
            }
            if (temp == chess[0, 2] && temp == chess[2, 0])
            {
                return temp;
            }
            if (temp == chess[0, 1] && temp == chess[2, 1])
            {
                return temp;
            }
            if (temp == chess[1, 0] && temp == chess[1, 2])
            {
                return temp;
            }
        }
        
        //判断是否是第一行或者第一列相同
        temp = chess[0, 0];
        if (temp != 0)
        {
            if (temp == chess[0, 1] && temp == chess[0, 2])
            {
                return temp;
            }
            if (temp == chess[1, 0] && temp == chess[2, 0])
            {
                return temp;
            }
        }
        
        //判断是否是第三行或者第三列相同
        temp = chess[2, 2];
        if (temp != 0)
        {
            if (temp == chess[2, 0] && temp == chess[2, 1])
            {
                return temp;
            }
            if (temp == chess[0, 2] && temp == chess[1, 2])
            {
                return temp;
            }
        }
        
        if (empty == 0)
        {
            //没有空的地方，因此双方平局
            return 3;
        }
        else
        {
            //还未分出胜负
            return 0;
        }
    }

完成代码之后将脚本拖入到空白游戏对象中。运行。

• 运行结果如图
  O获胜
  
  X获胜
  
  平局
  

思考题

• 微软 XNA 引擎的 Game 对象屏蔽了游戏循环的细节，并使用一组虚方法让继承者完成它们，我们称这种设计为“模板方法模式”。
  • 为什么是“模板方法”模式而不是“策略模式”呢？
    模板方法是先定义一个操作的算法结构，然后子类将通过继承实现子步骤中实现，这样子类不会改变算法的结构重定义算法，类似于C语言中的虚函数。
    策略模式是指一个算法对于场景敏感，在不同的场景有不同的实现。
    微软 XNA 引擎的 Game 对象屏蔽了游戏循环的细节，并使用一组虚方法让继承者完成它，其实就是在不改变代码的结构的基础上，将某些模块交由继承者实现，这种方式更符合模板方法。
• 将游戏对象组成树型结构，每个节点都是游戏对象（或数）。
  • 尝试解释组合模式（Composite Pattern / 一种设计模式）。
    组合模式，又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式能将对象组合成树形结构，构成”部分-整体“的层次结构。
  • 使用 BroadcastMessage() 方法，向子对象发送消息。你能写出 BroadcastMessage() 的伪代码吗?
    父类：
    void Start(){
    this.BroadcastMessage(“son_func”);
    }
    子类：
    void son_func(){
    Debug.Log(“son_func enabled!”);
    }
• 一个游戏对象用许多部件描述不同方面的特征。我们设计坦克（Tank）游戏对象不是继承于GameObject对象，而是 GameObject 添加一组行为部件（Component）。
  • 这是什么设计模式？
    装饰器（Decorator）模式。
  • 为什么不用继承设计特殊的游戏对象？
    按照网上查找的资料。继承相比装饰器模式虽然也能实现代码的复用，但是滥用继承，使用多重继承容易使代码变得脆弱且不易理解，在设计模式中，存在着设计原则：优先使用对象组合而非类继承。使用装饰器模式能够明确的划分具体功能的职责，灵活地给对象添加额外的职责，比生成子类更加灵活。