HW4: 游戏对象与图形基础

作业简介：
1.基本操作演练（游戏场景）
2.编程实践

一、基本操作演练#

下载Fantasy Skybox FREE，构建自己的游戏场景（含天空、光源、音效、地形）

写一个简单的总结，总结游戏对象的使用

目前学习到的一些游戏对象包括：3D Object里的基本物体和Terrain、Light、Camera、Skybox、Audio。每个GameObject都有Transform属性来设置位置旋转大小等。

基本物体（Cube、Sphere之类的）：单纯的物体，通过添加材质更改外观，添加各种组件实现功能。
Terrain：地面，通过Terrain自带的编辑工具可以编辑地形，如更改地形大小，修改地形高度，给地形“上色”，还可以添加树木花草等。我们更多地会选择使用别人做好现成的素材。

terrain1

terrain2
Light：灯光。光影的合理设置能更好地表达3D环境的颜色与情绪。有平行光、聚光灯、点光源、区域光等，不同光有不同属性面板。

如点光源这个面板，我们能看到像颜色、阴影等设置。

Light
Camera：摄影机。第一人称游戏可以作为玩家的眼睛，第三人称游戏可以跟随玩家运动。多摄像机是制造效果的重要手段。摄像机属性面板如下：

Camera

各属性说明可参考官方文档：https://docs.unity.cn/cn/2021.3/Manual/class-Camera.html
Skybox：天空盒（一种材料）。根据shader着色器的类型不同，需要配置不同的天空盒素材。如Skybox/Cubemap是一个圆形图片、Mobile/Skybox是6面图片、Skybox/Panoramic是一张全景图。制作好天空盒材质后，可以放到Camera的Skybox部件中。

skybox

skybox2
Audio：音源。可利用Audio Source在场景中播放声音，利用附着在角色对象上的Audio Listener监听场景中的声音。Audio Source可以设置为3D，听起来有立体的效果。通过混响等技巧可以产生更复杂的效果。

audio

二、编程实践#

牧师与魔鬼动作分离版+设计一个裁判类（当游戏到达结束条件时，通知场景控制器游戏结束）

项目地址：https://github.com/Cauchyoooo/3DGameDesign/tree/main/hw4/Assets/Scripts

对比上一个版本的一些区别：

将动作抽离出来形成一个动作管理器
增加了裁判类通知游戏结束
增加了计时器功能
游戏结束会在船靠岸之后才提示弹出来

实际效果如下图：

1 动作管理器的设计#

通过门面模式（控制器模式）输出组合好的几个动作，供原来程序调用。
通过组合模式实现动作组合，按组合模式设计方法
接口回调（函数回调）实现管理者与被管理者解耦
通过模板方法，让使用者减少对动作管理过程细节的要求
优点：
- 程序更能适应需求变化
- 对象更容易被复用
- 程序更易于维护

1.动作基类(SSAction)

SSAction是动作的基类，其他动作类都继承于它。
ScriptableObject是不需要绑定GameObject对象的可编程基类。这些对象受Unity引擎场景管理。
protected 防止用户自己new抽象的对象
使用virtual申明虚方法，通过重写实现多态。
利用接口(ISSActionCallback)实现消息通知，避免与动作管理者直接依赖

1
public class SSAction : ScriptableObject
2
{
3
    public bool enable = true;
4
    public bool destroy = false;
5

6
    public GameObject gameObject {get; set;}
7
    public Transform transform {get; set;}
8
    public ISSActionCallback callback {get; set;}
9

10
    protected SSAction(){}
11

12
    public virtual void Start()
13
    {
14
        throw new System.NotImplementedException();
15
    }
16

17
    public virtual void Update()
18
    {
19
        throw new System.NotImplementedException();
20
    }
21
}

2.动作管理基类(SSActionManager)

该类实现所有动作的基本管理，CCActionManager会继承于它。
利用一个动作字典来进行动作的运行，先将waitingAdd中的动作加入字典中，运行动作后，再将它加入到waitingDelete中销毁。由于字典是线程不安全的，如果控制好队列，如每次最多存在一个动作，就不会导致动作的混乱。
提供了添加新动作的方法RunAction。该方法把游戏对象与动作绑定，并绑定该动作事件的消息接受者。

1
public class SSActionManager : MonoBehaviour {
2
    //动作集，以字典形式存在
3
    private Dictionary<int, SSAction> actions = new Dictionary<int, SSAction>();
4
    //等待被加入的动作队列(动作即将开始)
5
    private List<SSAction> waitingAdd = new List<SSAction>();
6
    //等待被删除的动作队列(动作已完成)
7
    private List<int> waitingDelete = new List<int>();
8

9
    protected void Update()
10
    {
11
        //将waitingAdd中的动作保存
12
        foreach (SSAction ac in waitingAdd)
13
            actions[ac.GetInstanceID()] = ac;
14
        waitingAdd.Clear();
15

16
        //运行被保存的事件
17
        foreach (KeyValuePair<int, SSAction> kv in actions)
18
        {
19
            SSAction ac = kv.Value;
20
            if (ac.destroy)
21
            {
22
                waitingDelete.Add(ac.GetInstanceID());
23
            }
24
            else if (ac.enable)
25
            {
26
                ac.Update();
27
            }
28
        }
29

30
        //销毁waitingDelete中的动作
31
        foreach (int key in waitingDelete)
32
        {
33
            SSAction ac = actions[key];
34
            actions.Remove(key);
35
            Destroy(ac);
36
        }
37
        waitingDelete.Clear();
38
    }
39

40
    //准备运行一个动作，将动作初始化，并加入到waitingAdd
41
    public void RunAction(GameObject gameObject, SSAction action, ISSActionCallback manager)
42
    {
43
        action.gameObject = gameObject;
44
        action.transform = gameObject.transform;
45
        action.callback = manager;
46
        waitingAdd.Add(action);
47
        action.Start();
48
    }
49

50
    protected void Start()
51
    {
52

53
    }
54
}

3.动作事件接口定义(ISSActionCallback)

接口作为接收通知对象的抽象类型，所有事件管理者都必须实现该接口，来实现事件调度。
事件类型定义，使用了枚举变量。

1
public enum SSActionEventType:int {Started, Completed}
2
public interface ISSActionCallback
3
{
4
    //回调函数
5
    void SSActionEvent(
6
        SSAction source,
7
        SSActionEventType events = SSActionEventType.Completed,
8
        int intParam = 0,
9
        string strParam = null,
10
        Object objectParam = null
11
    );
12
}

4.简单动作实现(CCMoveToAction)

实现移动动作，将物体移动到目标位置，并通知任务完成。
让Unity创建动作类，确保内存正确回收。
override 多态，c++必须申明重写，java则默认重写。

1
public class CCMoveToAction : SSAction
2
{
3

4
    public Vector3 target; //目的地
5
    public float speed; //速度
6

7
    private CCMoveToAction(){}
8

9
    //生产函数(工厂模式)
10
    public static CCMoveToAction GetSSAction(Vector3 target, float speed)
11
    {
12
        CCMoveToAction action = ScriptableObject.CreateInstance<CCMoveToAction>();
13
        action.target = target;
14
        action.speed = speed;
15
        return action;
16
    }
17

18
    public override void Start(){}
19

20
    public override void Update()
21
    {
22
        //判断是否符合移动条件
23
        if (this.gameObject == null || this.transform.position == target)
24
        {
25

26
            this.destroy = true;
27
            this.callback.SSActionEvent(this);
28
            return;
29
        }
30
        //移动
31
        this.transform.position = Vector3.MoveTowards(this.transform.position, target, speed * Time.deltaTime);
32
    }
33
}

5.顺序动作组合类实现(CCSequenceAction)

实现一个动作组合序列，顺序播放动作。
让动作组合继承抽象动作SSAction，能够进一步组合；实现回调接收，能接受被组合动作的事件。
创建一个动作顺序执行序列，-1表示无限循环，start开始动作。
SSActionEvent 收到当前动作执行完成，推下一个动作，如果完成一次循环，减次数。如完成，通知该动作的管理者。
Start 执行动作前，为每个动作注入当前动作游戏对象，并将自己作为动作事件的接收者。
OnDestroy 如果自己被注销，应该释放自己管理的动作。这里不会被注销，因此没有实现该功能。
这是标准的组合设计模式。被组合对象和组合对象同属一种类型。通过该模式，我们能实现几乎满足所有越位需要、非常复杂的动作管理。

1
public class CCSequenceAction : SSAction, ISSActionCallback
2
{
3
    public List<SSAction> sequence; //动作序列
4
    public int repeat = -1; //重复次数
5
    public int start = 0; //动作开始指针
6

7
    //生产函数(工厂模式)
8
    public static CCSequenceAction GetSSAction(int repeat, int start, List<SSAction> sequence)
9
    {
10
        CCSequenceAction action = ScriptableObject.CreateInstance<CCSequenceAction>();
11
        action.repeat = repeat;
12
        action.sequence = sequence;
13
        action.start = start;
14
        return action;
15
    }
16

17
    public override void Start()
18
    {
19
        foreach (SSAction action in sequence)
20
        {
21
            action.gameObject = this.gameObject;
22
            action.transform = this.transform;
23
            action.callback = this;
24
            action.Start();
25
        }
26
    }
27

28
    public override void Update()
29
    {
30
        if (sequence.Count == 0)
31
            return;
32
        if (start < sequence.Count)
33
            sequence[start].Update();
34
    }
35

36
    //回调处理，当有动作完成时触发
37
    public void SSActionEvent(
38
        SSAction source,
39
        SSActionEventType events = SSActionEventType.Completed,
40
        int Param = 0,
41
        string strParam = null,
42
        Object objectParam = null)
43
    {
44
        source.destroy = false;
45
        this.start++;
46
        if (this.start >= sequence.Count)
47
        {
48
            this.start = 0;
49
            if (repeat > 0)
50
                repeat--;
51
            if (repeat == 0)
52
            {
53
                this.destroy = true;
54
                this.callback.SSActionEvent(this);
55
            }
56
        }
57
    }
58

59
    void OnDestroy()
60
    {
61
        //TODO: Something
62
    }
63
}

6.动作组合管理(CCActionManager)

上一版本的moveable脚本拆分到这个类和FirstController的方法中，实现船和角色的移动管理。

1
// 将原来移动的方法 放在这里
2
public class CCActionManager : SSActionManager, ISSActionCallback
3
{
4
    //是否正在运动
5
    private bool isMoving = false;
6
    //船移动动作类
7
    public CCMoveToAction moveBoatAction;
8
    //人移动动作类(需要组合)
9
    public CCSequenceAction moveRoleAction;
10
    //控制器
11
    public FirstController controller;
12

13
    protected new void Start()
14
    {
15
        controller = (FirstController)Director.getInstance().currentSceneController;
16
        controller.actionManager = this;
17
    }
18

19
    public bool IsMoving()
20
    {
21
        return isMoving;
22
    }
23

24
    //移动船
25
    public void MoveBoat(GameObject boat, Vector3 target, float speed)
26
    {
27
        if (isMoving)
28
            return;
29
        isMoving = true;
30
        moveBoatAction = CCMoveToAction.GetSSAction(target, speed);
31
        this.RunAction(boat, moveBoatAction, this);
32
    }
33

34
    //移动人
35
    public void MoveRole(GameObject role, Vector3 mid_destination, Vector3 destination, int speed)
36
    {
37
        if (isMoving)
38
            return;
39
        isMoving = true;
40
        moveRoleAction = CCSequenceAction.GetSSAction(0, 0, new List<SSAction>
41
            {   CCMoveToAction.GetSSAction(mid_destination, speed),
42
                CCMoveToAction.GetSSAction(destination, speed) });
43
        this.RunAction(role, moveRoleAction, this);
44
    }
45

46
    //回调函数
47
    public void SSActionEvent(SSAction source,
48
    SSActionEventType events = SSActionEventType.Completed,
49
    int intParam = 0,
50
    string strParam = null,
51
    Object objectParam = null)
52
    {
53
        isMoving = false;
54
    }
55
}

2 部分控制类的设计#

1.最高层控制器(FirstController)

这里仅展示有增改的函数方法，增添了一个裁判反馈信息JudgeCallback，实现裁判类的回调函数。
将原有检测游戏状态的check函数抽离给裁判类JudgeController处理。
处理了原有可移动脚本moveable的一些部分，利于与动作管理器结合。

1
public class FirstController : MonoBehaviour, ISceneController, IUserAction
2
{
3
    readonly Vector3 waterPos = new Vector3(0,0.5F,0);
4
    public CCActionManager actionManager;
5
    public JudgeController judgeController;
6
    public CoastController startCoast;
7
    public CoastController endCoast;
8
    public BoatController boat;
9
    private myCharacterController[] characters;
10
    myUserGUI userGUI;
11
    public bool isRunning;
12
    public float time;
13

14
    public void JudgeCallback(bool _isRunning, string message)
15
    {
16
        userGUI.gameMessage = message;
17
        userGUI.time = (int)time;
18
        this.isRunning = _isRunning;
19
    }
20

21
    void Start ()
22
    {
23
        Director director = Director.getInstance();
24
        director.currentSceneController = this;
25
        userGUI = gameObject.AddComponent<myUserGUI>() as myUserGUI;
26
        actionManager = gameObject.AddComponent<CCActionManager>() as CCActionManager;
27
        judgeController = gameObject.AddComponent<JudgeController>() as JudgeController;
28
        characters = new myCharacterController[6];
29
        isRunning = true;
30
        time = 60;
31
        LoadResources();
32
    }
33

34
    public void moveBoat(){
35
        if(isRunning == false || actionManager.IsMoving())
36
            return;
37
        if(boat.isEmpty())
38
            return;
39
        string direct = boat.getDirection();
40
        Vector3 destination = boat.getPosition();
41
        if (direct == "End") {
42
      boat.setDirection("Start");
43
    }
44
    else {
45
      boat.setDirection("End");
46
    }
47
        actionManager.MoveBoat(boat.getGameobj(), destination, 20);
48
    }
49

50
    public void ClickCharacter(myCharacterController cC){
51
        if(isRunning == false || actionManager.IsMoving())
52
            return;
53
        if(cC.isOnBoat()){
54
            CoastController coast;
55
            if(boat.getDirection()=="Start")
56
                coast = startCoast;
57
            else
58
                coast = endCoast;
59

60
            boat.getOffBoat(cC.getName());
61
            Vector3 destination = coast.getEmptyPosition();
62
            Vector3 middle = destination;
63
            if (destination.y < cC.GetGameObject().transform.position.y) {
64
          middle.y = cC.GetGameObject().transform.position.y;
65
        }
66
        else {
67
          middle.x = cC.GetGameObject().transform.position.x;
68
        }
69
            // cC.moveTo(coast.getEmptyPosition());
70
            actionManager.MoveRole(cC.GetGameObject(), middle, destination, 20);
71
            cC.getOnCoast(coast);
72
            coast.getOnCoast(cC);
73
        }
74
        else{
75
            CoastController coast = cC.getCoastController();
76
            if(boat.getEmptyIndex () == -1 || coast.getDirection() != boat.getDirection())
77
                return;
78
            coast.getOffCoast(cC.getName());
79
            Vector3 destination = boat.getEmptyPosition();
80
            Vector3 middle = destination;
81
            if (destination.y < cC.GetGameObject().transform.position.y) {
82
          middle.y = cC.GetGameObject().transform.position.y;
83
        }
84
        else {
85
          middle.x = cC.GetGameObject().transform.position.x;
86
        }
87
            actionManager.MoveRole(cC.GetGameObject(), middle, destination, 20);
88
            // cC.moveTo(boat.getEmptyPosition());
89
            cC.getOnBoat(boat);
90
            boat.getOnBoat(cC);
91
        }
92
    }
93

94
    public void Restart(){
95
        //boat 移动归位
96
        if(boat.getDirection()=="End"){
97
            Vector3 destination = boat.getPosition();
98
            actionManager.MoveBoat(boat.getGameobj(), destination, 20);
99
        }
100
        boat.reset();
101
        startCoast.reset();
102
        endCoast.reset();
103
        for(int i=0;i<characters.Length;i++)
104
            characters[i].reset();
105
        isRunning = true;
106
        time = 60;
107
    }
108

109
}

2.裁判类(JudgeController)

实现原有FristController的check函数功能，检测游戏状态，在游戏结束时用过回调信息通知FirstController。

1
public class JudgeController : MonoBehaviour {
2
    public FirstController mainController;
3
    public CoastController startCoast;
4
    public CoastController endCoast;
5
    public BoatController boat;
6

7

8
    void Start()
9
    {
10
        this.mainController = (FirstController)Director.getInstance().currentSceneController;
11
        this.startCoast = mainController.startCoast;
12
        this.endCoast = mainController.endCoast;
13
        this.boat = mainController.boat;
14

15
    }
16

17
    void Update()
18
    {
19
        if (!mainController.isRunning)
20
            return;
21
        if(!boat.isStop())
22
            return;
23
        if (mainController.time <= 0)
24
        {
25
            mainController.JudgeCallback(false, "Game Over!");
26
            return;
27
        }
28

29
        this.gameObject.GetComponent<myUserGUI>().gameMessage = "";
30

31
        int startPriest = 0;
32
        int endPriest = 0;
33
        int startDevil = 0;
34
        int endDevil = 0;
35

36
        int[] startCount = startCoast.getNum();
37
        startPriest += startCount[0];
38
        startDevil += startCount[1];
39

40
        int[] endCount = endCoast.getNum();
41
        endPriest += endCount[0];
42
        endDevil += endCount[1];
43

44
        if(endDevil+endPriest ==6){
45
            mainController.JudgeCallback(false, "You Win!");
46
            return;
47
        }
48

49
        int[] boatCount = boat.getNum();
50
        if(boat.getDirection() == "End"){
51
            endPriest += boatCount[0];
52
            endDevil += boatCount[1];
53
        }
54
        else{
55
            startPriest += boatCount[0];
56
            startDevil += boatCount[1];
57
        }
58

59
        if(startPriest<startDevil && startPriest>0){
60
            mainController.JudgeCallback(false, "Game Over!");
61
            return;
62
        }
63
        if(endPriest<endDevil && endPriest>0){
64
            mainController.JudgeCallback(false, "Game Over!");
65
            return;
66
        }
67
    }
68
}

音乐

音乐

一、基本操作演练#

二、编程实践#

1 动作管理器的设计#

2 部分控制类的设计#

文章分享

评论区

音乐

文章目录