作业七

智能巡逻兵

要求

游戏设计要求

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

程序设计要求

• 必须使用订阅与发布模式传消息
• 工厂模式生产巡逻兵

组织结构

这次依然是使用了动作分离，MVC模式和工厂模式，以及新加了订阅与发表模式，结构如下所示：

人物和场景预制

为了完成场景的布置，我们从商店中选用比较好的成品人物，`FreeVoxelGirl`这个包提供了免费的人物模型和动作，主要是其包含人物的死亡、行走和跑步这一系列的动作。我们进行人物的预制如下，主要是添加了刚体的碰撞器以及控制器和标签`Player`，标签会在我们之后的代码中用到：

人物的动作控制器如下所示，包括了人物的跑步、站立和死亡三种动作：

同样的，我们也给我们的巡逻兵添加预制，如下所示：

其控制器如下所示：

巡逻兵还需要添加一个和玩家相碰撞之后的处理代码，如下所示：

public class PlayerCollide : MonoBehaviour
{

    void OnCollisionEnter(Collision other)
    {
        if (other.gameObject.tag == "Player")
        {
            Debug.Log("sd");
            GameEventManager.Instance.PlayerGameover();
        }
    }
}

然后就是地图的设计了，我们用现有的资源搭建了一个小地图，分成了九个区域：

每个区域还添加了触发器代码，让玩家进入区域之后巡逻兵可以进行追击：

public class AreaCollide : MonoBehaviour
{
    public int sign = 0;
    FirstSceneController sceneController;
    
    private void Start()
    {
        sceneController = SSDirector.getInstance().currentScenceController as FirstSceneController;
    }
    
    void OnTriggerEnter(Collider collider)
    {
        if (collider.gameObject.tag == "Player")
        {
            sceneController.SetPlayerArea(sign);
            GameEventManager.Instance.PlayerEscape();
        }
    }
}

代码实现

巡逻兵生产与动作

我们还是利用工厂模式进行巡逻兵的生产，将每个巡逻兵和对应的区域号对应起来存放到字典中：

public class PatrolFactory
{
    public static PatrolFactory PF = new PatrolFactory();
    private Dictionary<int, GameObject> store = new Dictionary<int, GameObject>();

    private PatrolFactory() {}

    int[] posX = { -7, 1, 7 };
    int[] posZ = { 8, 2, -8 };

    public Dictionary<int, GameObject> GetPatrol()
    {
        for (int i = 0; i < 3; ++ i)
        {
            for (int j = 0; j < 3; ++ j)
            {
                GameObject newPatrol = GameObject.Instantiate<GameObject>(Resources.Load<GameObject>("Prefabs/Patrol"));
                newPatrol.AddComponent<Patrol>();
                newPatrol.transform.position = new Vector3(posX[j], 0, posZ[i]);
                newPatrol.GetComponent<Patrol>().block = i * 3 + j;
                newPatrol.SetActive(true);
                store.Add(i * 3 + j, newPatrol);
            }
        }
        return store;
    }

    public void StopPatrol()
    {
        for (int i = 0; i < 3; ++ i)
        {
            for (int j = 0; j < 3; ++ j)
            {
                store[i * 3 + j].transform.position = new Vector3(posX[j], 0, posZ[i]);
            }
        }
    }
}

巡逻兵类的实现：

public class Patrol : MonoBehaviour
{
    public int block;
    public bool follow_player = false;

    private void Start()
    {
        if (gameObject.GetComponent<Rigidbody>())
        {
            gameObject.GetComponent<Rigidbody>().freezeRotation = true;
        }
    }

    void Update()
    {
        if (this.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);
        }
    }
}

巡逻兵基础动作类的实现还是和之前的作业一样：

public class SSAction : ScriptableObject
{
    public bool enable = true;
    public bool destroy = false;

    public GameObject gameObject;
    public Transform transform;
    public SSActionCallback CallBack;

    public virtual void Start()
    {
        throw new System.NotImplementedException();
    }

    public virtual void Update()
    {
        throw new System.NotImplementedException();
    }
}

基类的动作管理实现如下，主要是存储了每个动作和编号的对应关系以及保存了两个队列，待添加和待删除的队列，这也和之前的游戏基本一样：

public class SSActionManager : MonoBehaviour
{
    private Dictionary<int, SSAction> actions = new Dictionary<int, SSAction>();
    private List<SSAction> waitingToAdd = new List<SSAction>();
    private List<int> watingToDelete = new List<int>();

    protected void Update()
    {
        foreach (SSAction ac in waitingToAdd)
        {
            actions[ac.GetInstanceID()] = ac;
        }
        waitingToAdd.Clear();

        foreach (KeyValuePair<int, SSAction> kv in actions)
        {
            SSAction ac = kv.Value;
            if (ac.destroy)
            {
                watingToDelete.Add(ac.GetInstanceID());
            }
            else if (ac.enable)
            {
                ac.Update();
            }
        }

        foreach (int key in watingToDelete)
        {
            SSAction ac = actions[key];
            actions.Remove(key);
            Object.Destroy(ac);
        }
        watingToDelete.Clear();
    }

    public void addAction(GameObject gameObject, SSAction action, SSActionCallback ICallBack)
    {
        action.gameObject = gameObject;
        action.transform = gameObject.transform;
        action.CallBack = ICallBack;
        waitingToAdd.Add(action);
        action.Start();
    }
}

然后是巡逻兵向玩家行走的动作基类实现，这里主要是要获取两个参数，target代表玩家，speed代表速度，表示朝向玩家以何种速度前进。如果玩家已经不在巡逻兵的范围之内的，也就是follow_player的值为假的时候，我们就销毁这个动作：

public class CCTracertAction : SSAction
{
    public GameObject target;
    public float speed;

    private CCTracertAction() { }

    public static CCTracertAction getAction(GameObject target, float speed)
    {
        CCTracertAction action = ScriptableObject.CreateInstance<CCTracertAction>();
        action.target = target;
        action.speed = speed;
        return action;
    }

    public override void Update()
    {
        this.transform.position = Vector3.MoveTowards(transform.position, target.transform.position, speed * Time.deltaTime);
        Quaternion rotation = Quaternion.LookRotation(target.transform.position - gameObject.transform.position, Vector3.up);
        gameObject.transform.rotation = rotation;
        if (gameObject.GetComponent<Patrol>().follow_player == false || transform.position == target.transform.position)
        {
            destroy = true;
            CallBack.SSActionCallback(this);
        }
    }

    public override void Start()
    {

    }
}

在没有玩家进入视野的时候，巡逻兵需要自己随机行进，我们也设置一个运动基类来表示这一动作：

public class CCMoveToAction : SSAction
{
    public Vector3 target;
    public float speed;
    public int block;

    private CCMoveToAction() { }

    public static CCMoveToAction getAction(int block, float speed, Vector3 position)
    {
        CCMoveToAction action = ScriptableObject.CreateInstance<CCMoveToAction>();
        action.target = position;
        action.speed = speed;
        action.block = block;
        return action;
    }

    public override void Update()
    {
        if (this.transform.position == target)
        {
            destroy = true;
            CallBack.SSActionCallback(this);
        }
        this.transform.position = Vector3.MoveTowards(transform.position, target, speed * Time.deltaTime);

    }

    public override void Start()
    {
        Quaternion rotation = Quaternion.LookRotation(target - transform.position, Vector3.up);
        transform.rotation = rotation;
    }
}

最后就是实现运动管理类和回调函数：

public class CCActionManager : SSActionManager, SSActionCallback
{
    public SSActionEventType Complete = SSActionEventType.Completed;
    Dictionary<int, CCMoveToAction> actionList = new Dictionary<int, CCMoveToAction>();

    public void Tracert(GameObject p, GameObject player)
    {
        if (actionList.ContainsKey(p.GetComponent<Patrol>().block)) actionList[p.GetComponent<Patrol>().block].destroy = true;
        CCTracertAction action = CCTracertAction.getAction(player, 0.8f);
        addAction(p.gameObject, action, this);
    }

    public void GoAround(GameObject p)
    {
        CCMoveToAction action = CCMoveToAction.getAction(p.GetComponent<Patrol>().block, 0.6f, GetNewTarget(p));
        actionList.Add(p.GetComponent<Patrol>().block, action);
        addAction(p.gameObject, action, this);
    }

    private Vector3 GetNewTarget(GameObject p)
    {
        Vector3 pos = p.transform.position;
        int block = p.GetComponent<Patrol>().block;
        float ZUp = 13.2f - (block / 3) * 9.65f;
        float ZDown = 5.5f - (block / 3) * 9.44f;
        float XUp = -4.7f + (block % 3) * 8.8f;
        float XDown = -13.3f + (block % 3) * 10.1f;
        Vector3 Move = new Vector3(Random.Range(-2f, 2f), 0, Random.Range(-2f, 2f));
        Vector3 Next = pos + Move;
        while (!(Next.x < XUp && Next.x > XDown && Next.z < ZUp && Next.z > ZDown))
        {
            Move = new Vector3(Random.Range(-1f, 1f), 0, Random.Range(-1f, 1f));
            Next = pos + Move;
        }
        return Next;
    }

    public void StopAll()
    {
        foreach (CCMoveToAction x in actionList.Values)
        {
            x.destroy = true;
        }
        actionList.Clear();
    }

    public void SSActionCallback(SSAction source)
    {
        if (actionList.ContainsKey(source.gameObject.GetComponent<Patrol>().block))
            actionList.Remove(source.gameObject.GetComponent<Patrol>().block);
        GoAround(source.gameObject);
    }
}

接口，场景控制器和GUI

接口类声明在命名空间Interface中，UserAction类中主要为GUI和场景控制器交互的的方法，SSActionCallback中则为运动控制器的回调函数：

namespace Interfaces
{
    public interface ISceneController
    {
        void LoadResources();
    }

    public interface UserAction
    {
        int GetScore();
        void Restart();
        bool GetGameState();
        //移动玩家
        void MovePlayer(float translationX, float translationZ);
    }

    public enum SSActionEventType : int { Started, Completed }

    public interface SSActionCallback
    {
        void SSActionCallback(SSAction source);
    }
}

场景控制器FirstSceneController继承了接口ISceneController和UserAction，并且在其中实现了接口声明的函数。场景控制器还是订阅者，在初始化时将自身相应的事件处理函数提交给消息处理器，在相应事件发生时被自动调用：

public class FirstSceneController : MonoBehaviour, ISceneController, UserAction
{
    GameObject player = null;
    PatrolFactory PF;
    int score = 0;
    int PlayerArea = 4;
    bool gameState = false;
    Dictionary<int, GameObject> allProp = null;
    CCActionManager CCManager = null;

    void Awake()
    {
        SSDirector director = SSDirector.getInstance();
        director.currentScenceController = this;
        PF = PatrolFactory.PF;
        if (CCManager == null)
            CCManager = gameObject.AddComponent<CCActionManager>();
        if (player == null && allProp == null)
        {
            Instantiate(Resources.Load<GameObject>("Prefabs/Plane"), new Vector3(0, 0, 0), Quaternion.identity);
            player = Instantiate(Resources.Load("Prefabs/Player"), new Vector3(0, 0, 0), Quaternion.identity) as GameObject;
            var camera = GameObject.Find("Camera");
            camera.transform.parent = player.transform;
            camera.transform.position = player.transform.position + new Vector3(0, 5, -5);
            allProp = PF.GetPatrol();
        }
        if (player.GetComponent<Rigidbody>())
            player.GetComponent<Rigidbody>().freezeRotation = true;
    }

    // Update is called once per frame
    void Update()
    {
        if (player.transform.localEulerAngles.x != 0 || player.transform.localEulerAngles.z != 0)
        {
            player.transform.localEulerAngles = new Vector3(0, player.transform.localEulerAngles.y, 0);
        }
        if (player.transform.position.y <= 0)
        {
            player.transform.position = new Vector3(player.transform.position.x, 0, player.transform.position.z);
        }
    }

    void OnEnable()
    {
        GameEventManager.ScoreChange += AddScore;
        GameEventManager.GameoverChange += Gameover;
    }

    void OnDisable()
    {
        GameEventManager.ScoreChange -= AddScore;
        GameEventManager.GameoverChange -= Gameover;
    }

    public void LoadResources()
    {

    }

    public int GetScore()
    {
        return score;
    }

    public void Restart()
    {
        player.GetComponent<Animator>().Play("New State");
        PF.StopPatrol();
        gameState = true;
        score = 0;
        player.transform.position = new Vector3(0, 0, 0);
        allProp[PlayerArea].GetComponent<Patrol>().follow_player = true;
        CCManager.Tracert(allProp[PlayerArea], player);
        foreach (GameObject x in allProp.Values)
        {
            if (!x.GetComponent<Patrol>().follow_player)
            {
                CCManager.GoAround(x);
            }
        }
    }

    public bool GetGameState()
    {
        return gameState;
    }

    public void SetPlayerArea(int x)
    {
        if (PlayerArea != x && gameState)
        {
            allProp[PlayerArea].GetComponent<Animator>().SetBool("run", false);
            allProp[PlayerArea].GetComponent<Patrol>().follow_player = false;
            PlayerArea = x;
        }
    }

    void AddScore()
    {
        if (gameState)
        {
            score ++;
            allProp[PlayerArea].GetComponent<Patrol>().follow_player = true;
            CCManager.Tracert(allProp[PlayerArea], player);
            allProp[PlayerArea].GetComponent<Animator>().SetBool("run", true);
        }
    }

    void Gameover()
    {
        CCManager.StopAll();
        allProp[PlayerArea].GetComponent<Patrol>().follow_player = false;
        player.GetComponent<Animator>().SetTrigger("death");
        gameState = false;
    }

    public void MovePlayer(float translationX, float translationZ)
    {
        if (gameState && player != null)
        {
            if (translationX != 0 || translationZ != 0)
            {
                player.GetComponent<Animator>().SetBool("run", true);
            }
            else
            {
                player.GetComponent<Animator>().SetBool("run", false);
            }
            player.transform.Translate(0, 0, translationZ * 4f * Time.deltaTime);
            player.transform.Rotate(0, translationX * 50f * Time.deltaTime, 0);
        }
    }
}

GUI界面主要实现显示分数和计时，并且在游戏结束的时候显示开始按钮以重开游戏。

public class InterfaceGUI : MonoBehaviour
{
    UserAction UserActionController;
    ISceneController SceneController;
    public GameObject t;
    bool ss = false;
    float S;

    // Use this for initialization
    void Start()
    {
        UserActionController = SSDirector.getInstance().currentScenceController as UserAction;
        SceneController = SSDirector.getInstance().currentScenceController as ISceneController;
        S = Time.time;
    }

    private void OnGUI()
    {
        if (!ss) S = Time.time;
        GUI.Label(new Rect(Screen.width - 160, 30, 150, 30), "Score: " + UserActionController.GetScore().ToString() + "  Time:  " + ((int)(Time.time - S)).ToString());
        if (ss)
        {
            if (!UserActionController.GetGameState())
            {
                ss = false;
            }
        }
        else
        {
            if (GUI.Button(new Rect(Screen.width / 2 - 30, Screen.height / 2 - 30, 100, 50), "Start"))
            {
                ss = true;
                SceneController.LoadResources();
                S = Time.time;
                UserActionController.Restart();
            }
        }
    }

    private void Update()
    {
        float translationX = Input.GetAxis("Horizontal");
        float translationZ = Input.GetAxis("Vertical");
        UserActionController.MovePlayer(translationX, translationZ);
    }
}

游戏事件管理器

游戏事件管理器是订阅与发布模式中的中继者，消息的订阅者通过与管理器中相应的事件委托绑定，在管理器相应的函数被发布者调用（也就是发布者发布相应消息时），订阅者绑定的相应事件处理函数也会被调用。订阅与发布模式实现了一部分消息的发布者和订阅者之间的解耦，让发布者和订阅者不必产生直接联系，其实现如下所示：

public class GameEventManager
{
    public static GameEventManager Instance = new GameEventManager();
    public delegate void ScoreEvent();
    public static event ScoreEvent ScoreChange;

    public delegate void GameoverEvent();
    public static event GameoverEvent GameoverChange;

    private GameEventManager() { }

    public void PlayerEscape()
    {
        if (ScoreChange != null)
        {
            ScoreChange();
        }
    }

    public void PlayerGameover()
    {
        if (GameoverChange != null)
        {
            GameoverChange();
        }
    }
}

导演类

导演类还是和之前的作业一样，实现如下：

public class SSDirector : System.Object
{

    private static SSDirector _instance;

    public ISceneController currentScenceController { get; set; }
    public bool running { get; set; }

    public static SSDirector getInstance()
    {
        if (_instance == null)
        {
            _instance = new SSDirector();
        }
        return _instance;
    }

    public int getFPS()
    {
        return Application.targetFrameRate;
    }

    public void setFPS(int fps)
    {
        Application.targetFrameRate = fps;
    }
}

效果展示

我们给地图再添加了一些围栏、小物品之后，最终效果如下所示：