3D游戏设计作业6：智能巡逻兵

智能巡逻兵

游戏截图：

1，作业要求

游戏设计要求：

• 创建一个地图和若干巡逻兵(使用动画)；
• 每个巡逻兵走一个3~5个边的凸多边型，位置数据是相对地址。即每次确定下一个目标位置，用自己当前位置为原点计算；
• 巡逻兵碰撞到障碍物，则会自动选下一个点为目标；
• 巡逻兵在设定范围内感知到玩家，会自动追击玩家；
• 失去玩家目标后，继续巡逻；
• 计分：玩家每次甩掉一个巡逻兵计一分，与巡逻兵碰撞游戏结束；

程序设计要求：

• 必须使用订阅与发布模式传消息
  • subject：OnLostGoal
  • Publisher: ?
  • Subscriber: ?
• 工厂模式生产巡逻兵

友善提示1：生成 3~5个边的凸多边型

• 随机生成矩形
• 在矩形每个边上随机找点，可得到 3 - 4 的凸多边型
• 5 ?

友善提示2：参考以前博客，给出自己新玩法

2，设计思路

1，知识准备

工厂模式： 工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

订阅与发布模式：订阅与发布模式的基本概念就是订阅者把自己想订阅的事件注册到调度中心，当该事件触发时候，发布者发布该事件到调度中心（顺带上下文），由调度中心统一调度订阅者注册到调度中心的处理代码。比如有个界面是实时显示天气，它订阅了天气事件（注册到调度中心，包括处理程序），当天气变化时（定时获取数据），就作为发布者发布天气信息到调度中心，调度中心就调度订阅者的天气处理程序。

2，分析需求

1. 先决定巡逻兵是随机生成的，且巡逻的路径是矩阵，碰到地图中的墙壁后重新生成路径。在巡逻兵下挂载一个空对象，添加box collider来控制巡逻兵敏感的区域，只要玩家进入这些区域，巡逻兵就进行追击。
2. 用一个工厂生产巡逻兵，在游戏刚开始时生产，在游戏重新开始时就重置巡逻兵，不用重新生成巡逻兵，这样可以节省资源。
3. 玩家可以接受w、s、a、d按键的输入进而前进、后退、转向左和转向右的操作。
4. 由于要用到订阅-发布模式，所以我将所有的游戏事件分离出来，用一个类来管理，并发布这些事件，而其他类则订阅这些事件，以便在游戏开始、游戏结束时执行相应的行为。
5. 然后就要用一个最高级的管理类来管理上面的所有行为，同时用一个类来与用户交互，显示各种信息。

3，UML图

这里沿用牧师与魔鬼动作管理器的UML图，加上了一个工厂和碰撞动作。

4，具体设计
玩家、巡逻兵、地图都需要一些资源，这里直接到unity3d的Asset Store中搜索下载。

巡逻兵：

玩家：

地图：

巡逻兵动画：

玩家动画：

3，部分代码
碰撞通知部分：

using UnityEngine;

public class ColiAction : MonoBehaviour {
    FirstSceneController sceneController;
    GameObject myobject = null;
    GameObject player;
    public delegate void AddScore();
    public static event AddScore myAddScore;

    public delegate void GameOver();
    public static event GameOver myGameOver;

    private void Start()
    {
        sceneController = SSDirector.getInstance().currentSceneController as FirstSceneController;
        player = sceneController.player;
    }
    private void OnTriggerEnter(Collider other)
    {
        if (other.gameObject == player)
        {
            int k = this.name[this.name.Length - 1] - '0';
            myobject = sceneController.patrols[k];
            foreach (var i in sceneController.actionManager.seq)
            {
                if (i.gameObject == myobject)
                {
                    i.enable = false;
                    Vector3 a = new Vector3(myobject.transform.position.x, 0, myobject.transform.position.z);
                    Vector3 b = new Vector3(player.transform.position.x, 0, player.transform.position.z);
                    Quaternion rotation = Quaternion.LookRotation(b - a, Vector3.up);
                    myobject.transform.rotation = rotation;
                }
            }
        }
    }
    private void OnTriggerExit(Collider other)
    {
        if (other.gameObject == player)
        {
            int k = this.name[this.name.Length - 1] - '0';
            foreach (var i in sceneController.actionManager.seq)
            {
                if (i.gameObject == myobject)
                {
                    i.enable = true;
                    Vector3 a = new Vector3(myobject.transform.position.x, 0, myobject.transform.position.z);
                    Vector3 b = new Vector3(i.target.x, 0, i.target.z);
                    Quaternion rotation = Quaternion.LookRotation(b - a, Vector3.up);
                    myobject.transform.rotation = rotation;
                }
            }
            myobject = null;
            myAddScore();
        }
    }
    private void OnCollisionEnter(Collision collision)
    {
        if(this.tag == "patrol" && collision.gameObject == player)
        {
            myGameOver();
            var k = collision.gameObject.GetComponent<Animator>();
            k.SetBool("death",true);
        }
    }
    private void Update()
    {
        if (myobject != null && sceneController.flag == 0)
        {
            myobject.transform.position = Vector3.MoveTowards(myobject.transform.position, player.transform.position, 3 * Time.deltaTime);
        }
    }
}

使用空对象和场景控制器载入场景：

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

public class FirstSceneController : MonoBehaviour, IUserAction, ISceneController{
    public CCActionManager actionManager;
    public GameObject player;
    public List<GameObject> patrols = new List<GameObject>();
    public PatrolFactory pf;
    public int flag = 0;
    public int score = 0;

    private void Awake()
    {
        SSDirector director = SSDirector.getInstance();
        director.setFPS(60);
        director.currentSceneController = this;
        this.gameObject.AddComponent<PatrolFactory>();
        pf = Singleton<PatrolFactory>.Instance;
        this.gameObject.AddComponent<UserGUI>();
        director.currentSceneController.GenGameObjects();
        this.gameObject.AddComponent<CCActionManager>();
    }
    private void OnEnable()
    {
        ColiAction.myAddScore += AddScore;
        ColiAction.myGameOver += GameOver;
    }
    private void OnDisable()
    {
        ColiAction.myAddScore -= AddScore;
        ColiAction.myGameOver -= GameOver;
    }

    private void GameOver()
    {
        Pause();
        flag = 1;
    }

    private void Start()
    {
    }
    public void GenGameObjects ()
    {
        int count = 0;
        GameObject plane = Instantiate<GameObject>(Resources.Load<GameObject>("Prefabs/Plane"));
        plane.transform.parent = this.transform;
        for(int i=0;i<3;++i)
        {
            for(int j=0;j<3;++j)
            {
                if (i == 0 && j == 2)
                {
                    player = Instantiate<GameObject>(Resources.Load<GameObject>("Prefabs/player"));
                    player.transform.position = new Vector3(plane.transform.position.x + 9 * (i - 1), 0, plane.transform.position.z + 9 * (j - 1));
                    if (player.GetComponent<Rigidbody>())
                    {
                        player.GetComponent<Rigidbody>().freezeRotation = true;
                    }
                }
                else
                {
                    GameObject trigger = Instantiate<GameObject>(Resources.Load<GameObject>("Prefabs/Trigger"));
                    trigger.transform.parent = plane.transform;
                    trigger.transform.position = new Vector3(plane.transform.position.x + 9 * (i - 1), 0, plane.transform.position.z + 10 * (j - 1));
                    trigger.name = "trigger" + count;
                    count++;
                    GameObject patrol = pf.GetPatrol();
                    patrol.transform.position = trigger.transform.position;
                    patrols.Add(patrol);
                }
            }
        }
    }
    public void Restart()
    {
        SceneManager.LoadScene("1");
    }
    public void Pause ()
    {
        actionManager.Pause();
    }
    private void AddScore()
    {
        score++;
    }
}

管理每个巡逻兵的巡逻动作和用户的输入：

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

public class CCActionManager : SSActionManager, ISSActionCallback {
    public FirstSceneController sceneController;
    public List<CCMoveToAction> seq = new List<CCMoveToAction>();
    public UserAction userAction;
    public PatrolFactory pf;

    protected new void Start()
    {
        sceneController = (FirstSceneController)SSDirector.getInstance().currentSceneController;
        userAction = UserAction.GetSSAction(5);
        sceneController.actionManager = this;
        pf = sceneController.pf;
        RunAction(sceneController.player, userAction, this);
        foreach (var i in sceneController.patrols)
        {
            float x = Random.Range(-3.0f, 3.0f);
            int z = Random.Range(0, 4);
            Vector3 target = new Vector3(z % 2 == 0 ? (z - 1) * 3 : x, 0, z % 2 != 0 ? (z - 2) * 3 : x);
            CCMoveToAction k = CCMoveToAction.GetSSAction(target+i.transform.position,100,i.transform.position);
            seq.Add(k);
            Quaternion rotation = Quaternion.LookRotation(target, Vector3.up);
            i.transform.rotation = rotation;
            RunAction(i, k, this);
        }
    }
    protected new void Update()
    {
        base.Update();
    }
    public void SSActionEvent(SSAction source, SSActionEventType events = SSActionEventType.Completed, int intParam = 0, string strParam = null, Object objParam = null)
    {
        if(source != userAction)
        {
            CCMoveToAction cCMoveTo = source as CCMoveToAction;
            float x = Random.Range(-3.0f, 3.0f);
            int z = Random.Range(0, 4);
            Vector3 target = new Vector3(z % 2 == 0 ? (z - 1) * 3.0f : x, 0, z % 2 == 0 ? x : (z - 2) * 3.0f);
            CCMoveToAction k = CCMoveToAction.GetSSAction(target + cCMoveTo.initPosition, 1.5f, cCMoveTo.initPosition);
            seq.Remove(cCMoveTo);
            source.destory = true;
            seq.Add(k);
            Quaternion rotation = Quaternion.LookRotation(target + cCMoveTo.initPosition - source.transform.position, Vector3.up);
            source.transform.rotation = rotation;
            RunAction(source.gameObject, k, this);
        }
    }
    public void CheckEvent(SSAction source, SSActionEventType events = SSActionEventType.Completed, int intParam = 0, string strParam = null, Object objParam = null)
    {
    }
    public void Pause()
    {
        if(sceneController.flag == 0)
        {
            foreach (var k in seq)
            {
                k.enable = false;
                k.gameObject.GetComponent<Animator>().SetBool("running", false);
            }
            userAction.enable = false;
            sceneController.flag = 2;
        }
        else if(sceneController.flag == 2)
        {
            foreach (var k in seq)
            {
                k.enable = true;
                k.gameObject.GetComponent<Animator>().SetBool("running", true);
            }
            userAction.enable = true;
            sceneController.flag = 0;
        }
    }
}

处理player的移动和动画：

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

public class UserAction : SSAction {
    // Use this for initialization
    private float speed;
    private float rspeed = 90;

    public static UserAction GetSSAction(float speed)
    {
        UserAction action = CreateInstance<UserAction>();
        action.speed = speed;
        return action;
    }

    public override void Start()
    {

    }

    public override void Update()
    {
        if(enable)
        {
            float translationX = Input.GetAxis("Horizontal");
            float translationZ = Input.GetAxis("Vertical");
            if (translationX != 0 || translationZ != 0)
            {
                gameObject.GetComponent<Animator>().SetBool("running", true);
            }
            else
            {
                gameObject.GetComponent<Animator>().SetBool("running", false);
            }
            gameObject.transform.Translate(translationX * speed * Time.deltaTime * 0.1f, 0,translationZ*speed*Time.deltaTime);
            gameObject.transform.Rotate(0, translationX * rspeed * Time.deltaTime, 0);
            if (gameObject.transform.localEulerAngles.x != 0 || gameObject.transform.localEulerAngles.z != 0)
            {
                gameObject.transform.localEulerAngles = new Vector3(0, gameObject.transform.localEulerAngles.y, 0);
            }
            if (gameObject.transform.position.y != 0)
            {
                gameObject.transform.position = new Vector3(gameObject.transform.position.x, 0, gameObject.transform.position.z);
            }
        }
    }
}