开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> 游戏开发 -> 用Unity3D实现打飞碟游戏 -> 正文阅读

[游戏开发]用Unity3D实现打飞碟游戏

用Unity3D实现打飞碟游戏

项目地址

打飞碟游戏

完成效果图

请添加图片描述

类图

请添加图片描述

要求

游戏规则

游戏有 n 个 round，每个 round 都包括10 次 trial。
每个 trial 的飞碟的色彩、大小、发射位置、速度、角度、同时出现的个数都可能不同。它们由该 round 的 ruler 控制。
每个 trial 的飞碟有随机性，总体难度随 round 上升。
鼠标点中得分，得分规则按色彩、大小、速度不同计算，规则可自由设定。

实现要求

使用带缓存的工厂模式管理不同飞碟的生产与回收，该工厂必须是场景单实例的！具体实现见参考资源 Singleton 模板类。
尽可能使用前面 MVC 结构实现人机交互与游戏模型分离。
按adapter模式设计图修改飞碟游戏，使它同时支持物理运动与运动学（变换）运动。

实现心得

首先要设计出计分规则，比如：

加分项	加分
飞碟为红色	加1分
飞碟为绿色	加2分
飞碟为蓝色	加3分
飞碟的size为1（小飞碟）	加3分
飞碟的size为2（中飞碟）	加2分
飞碟的size为3（大飞碟）	加1分
飞碟的速度为x	加x分

然后要设计单实例类：

因为要求场景单实例，所以可以导入一个Singleton单实例模板类：

public class Singleton<T> : MonoBehaviour where T : MonoBehaviour {
	protected static T instance;

	public static T Instance {
		get {
			if (instance == null) {
				instance = (T)FindObjectOfType (typeof(T));
				if (instance == null) {
					Debug.LogError ("An instance of " + typeof(T) +
					" is needed in the scene, but there is none.");
				}
			}
			return instance;
		}
	}
}

或者使用导演类，使主控制器实现唯一：

public class Director : System.Object {
    private static Director instance;
    public MainController mainController { get; set; }
    public static Director GetInstance() {
        if (instance == null) {
            instance = new Director();
        }
        return instance;
    }
}

接着实现图中负责游戏每轮飞碟的创建和销毁，记录得分和游戏状态的这一部分：

请添加图片描述

DiskFactory.cs：

飞碟工厂类负责飞碟对象的创建和销毁，其在场景中是单实例的，且使用了对象池，实现了缓存功能，当一个飞碟对象被创建时，会首先在对象池中寻找没有被使用的空闲飞碟对象，有的话就根据规则设置飞碟对象相应属性后直接使用，没有再创建，这样就省下了一部分开销，销毁则直接将飞碟对象加入对象池的空闲部分，下次要使用时直接拿出即可，实现如下：

public class DiskFactory : MonoBehaviour {
    public GameObject diskPrefab; // 飞碟游戏对象，创建新的飞碟游戏对象的复制对象
    private List<DiskData> used; // 正在被游戏使用的飞碟对象
    private List<DiskData> free; // 没有被使用的空闲飞碟对象

    public void Start() {
        diskPrefab = GameObject.Instantiate(Resources.Load<GameObject>("Prefabs/Disk"), Vector3.zero, Quaternion.identity);
        diskPrefab.SetActive(false);
        used = new List<DiskData>();
        free = new List<DiskData>();
    }

    // 飞碟获取方法，根据ruler获取相应飞碟
    public GameObject GetDisk(Ruler ruler) {
        GameObject disk;

        // 从缓存中获取飞碟，没有则先创建
        int diskNum = free.Count;
        if (diskNum == 0) {
            disk = GameObject.Instantiate(diskPrefab, Vector3.zero, Quaternion.identity);
            disk.AddComponent(typeof(DiskData));
        }
        else {
            disk = free[diskNum - 1].gameObject;
            free.Remove(free[diskNum - 1]);
        }

        // 根据ruler设置disk的速度、颜色、大小、飞入方向
        disk.GetComponent<DiskData>().speed = ruler.speed;
        disk.GetComponent<DiskData>().color = ruler.color;
        disk.GetComponent<DiskData>().size = ruler.size;
        
        // 给飞碟上颜色
        if (ruler.color == "red") {
            disk.GetComponent<Renderer>().material.color = Color.red;
        }
        else if (ruler.color == "green") {
            disk.GetComponent<Renderer>().material.color = Color.green;
        }
        else {
            disk.GetComponent<Renderer>().material.color = Color.blue;
        }

        // 绘制飞碟大小
        disk.transform.localScale = new Vector3(1.2f, 0.1f * (float)ruler.size, 1.2f);
        
        // 选择飞碟飞入屏幕的起始位置
        disk.transform.position = ruler.beginPos;
        
        // 设置飞碟显示
        disk.SetActive(true);
    
        // 将飞碟加入使用队列
        used.Add(disk.GetComponent<DiskData>());

        return disk;
    }

    // 飞碟回收方法，将不使用的飞碟从使用队列放到空闲队列中
    public void FreeDisk(GameObject disk) {
        foreach (DiskData d in used) {
            if (d.gameObject.GetInstanceID() == disk.GetInstanceID()) {
                disk.SetActive(false);
                used.Remove(d);
                free.Add(d);
                break;
            }

        }
    }
}

disk:GameObject是飞碟的预制，需要提前制作好，并加上刚体组件Rigidbody，将Use Gravity项勾选上：

请添加图片描述

DiskData.cs：

DiskData是飞碟的模型，包含了飞碟相应的数据：

public class DiskData : MonoBehaviour {
    public int size; // 大小
    public string color; // 颜色
    public int speed; // 发射速度
}

这样就使用工厂方法 + 单实例 + 对象池完成了飞碟的创建和销毁，实现要求。

ScoreRecorder.cs：

记分类根据记分规则，对被点击中的飞碟得分进行记录，实现如下：

public class ScoreRecorder {
    public int score; // 游戏分数

    public ScoreRecorder() {
        score = 0;
    }

    /* 记录分数，根据点击中的飞碟的大小，速度，颜色计算得分 */
    public void Record(DiskData disk) {
        // 飞碟越小分就越高，大小为1得3分，大小为2得2分，大小为3得1分
        int diskSize = disk.size;
        switch (diskSize) {
            case 1:
                score += 3;
                break;
            case 2:
                score += 2;
                break;
            case 3:
                score += 1;
                break;
            default: break;
        }

        // 速度越快分就越高
        score += disk.speed;

        // 颜色为红色得1分，颜色为黄色得2分，颜色为蓝色得3分
        string diskColor = disk.color;
        if (diskColor.CompareTo("red") == 0) {
            score += 1;
        }
        else if (diskColor.CompareTo("green") == 0) {
            score += 2;
        }
        else if (diskColor.CompareTo("blue") == 0) {
            score += 3;
        }
    }

    /* 重置分数，设为0 */
    public void Reset() {
        score = 0;
    }
}

RoundController.cs：

回合控制器控制飞碟对象的运动类型为运动学运动或物理运动，并根据一定规则请求飞碟工厂生成相应的飞碟对象，控制游戏飞碟对象的发射和轮次的进行，实现如下：

public class RoundController : MonoBehaviour {
    private IActionManager actionManager; // 选择飞碟的运动类型
    private ScoreRecorder scoreRecorder; // 记分器
    private MainController mainController;
    private Ruler ruler; // 飞碟获取规则

    void Start() {
        // 一开始飞碟的运动类型默认为运动学运动
        actionManager = gameObject.AddComponent<CCActionManager>();
        gameObject.AddComponent<PhysisActionManager>();
        scoreRecorder = new ScoreRecorder();
        mainController = Director.GetInstance().mainController;
        gameObject.AddComponent<DiskFactory>();
        InitRuler();
    }

    void InitRuler() {
        ruler.trialNum = 0;
        ruler.roundNum = 0;
        ruler.sendTime = 0;
        ruler.roundDisksNum = new int [10];
        generateRoundDisksNum();
    }

    // 生成每trial同时发出的飞碟数量的数组，同时发出飞碟个数不超过4
    public void generateRoundDisksNum() {
        for (int i = 0; i < 10; ++i) {
            ruler.roundDisksNum[i] = Random.Range(0, 4) + 1;
        }
    }

    public void Reset() {
        InitRuler();
        scoreRecorder.Reset();
    }

    public void Record(DiskData disk) {
        scoreRecorder.Record(disk);
    }

    public int GetScores() {
        return scoreRecorder.score;
    }

    public void SetRoundSum(int roundSum) {
        ruler.roundSum = roundSum;
    }

    // 设置游戏模式，同时支持物理运动模式和动力学运动模式
    public void SetPlayDiskModeToPhysis(bool isPhysis) {
        if (isPhysis) {
            actionManager = Singleton<PhysisActionManager>.Instance as IActionManager;
        }
        else {
            actionManager = Singleton<CCActionManager>.Instance as IActionManager;
        }
    }

    // 发射飞碟
    public void LaunchDisk() {
        // 使飞碟飞入位置尽可能分开，从不同位置飞入使用的数组
        int [] beginPosY = new int [4]{0, 0, 0, 0};

        for (int i = 0; i < ruler.roundDisksNum[ruler.trialNum]; ++i) {
            // 获取随机数
            int randomNum = Random.Range(0, 3) + 1;
            // 飞碟速度随回合数增加而变快，这样难度增加
            ruler.speed = randomNum * (ruler.roundNum + 4);

            // 重新选取随机数，并根据随机数选择飞碟颜色
            randomNum = Random.Range(0, 3) + 1;
            if (randomNum == 1) {
                ruler.color = "red";
            }
            else if (randomNum == 2) {
                ruler.color = "green";
            }
            else {
                ruler.color = "blue";
            }

            // 重新选取随机数，并根据随机数选择飞碟的大小
            ruler.size = Random.Range(0, 3) + 1;

            // 重新选取随机数，并根据随机数选择飞碟飞入的方向
            randomNum = Random.Range(0, 2);
            if (randomNum == 1) {
                ruler.direction = new Vector3(3, 1, 0);
            }
            else {
                ruler.direction = new Vector3(-3, 1, 0);
            }

            // 重新选取随机数，并使不同飞碟的飞入位置尽可能分开
            do {
                randomNum = Random.Range(0, 4);
            } while (beginPosY[randomNum] != 0);
            beginPosY[randomNum] = 1;
            ruler.beginPos = new Vector3(-ruler.direction.x * 4, -0.5f * randomNum, 0);

            // 根据ruler从工厂中生成一个飞碟
            GameObject disk = Singleton<DiskFactory>.Instance.GetDisk(ruler);
        
            // 设置飞碟的飞行动作
            actionManager.PlayDisk(disk, ruler.speed, ruler.direction);
        }
    }

    // 释放工厂飞碟
    public void FreeFactoryDisk(GameObject disk) {
        Singleton<DiskFactory>.Instance.FreeDisk(disk);
    }

    // 释放所有工厂飞碟
    public void FreeAllFactoryDisk() {
        GameObject[] obj = FindObjectsOfType(typeof(GameObject)) as GameObject[];
        foreach (GameObject g in obj) {
            if (g.gameObject.name == "Disk(Clone)(Clone)") {
                Singleton<DiskFactory>.Instance.FreeDisk(g);
            }
        }
    }

    void Update() {
        if (mainController.GetGameState() == (int)GameState.Playing) {
            ruler.sendTime += Time.deltaTime;
            // 每隔2s发送一次飞碟(trial)
            if (ruler.sendTime > 2) {
                ruler.sendTime = 0;
                // 如果为无限回合或还未到设定回合数
                if (ruler.roundSum == -1 || ruler.roundNum < ruler.roundSum) {
                    // 发射飞碟，次数trial增加
                    mainController.SetViewTip("");
                    LaunchDisk();
                    ruler.trialNum++;
                    // 当次数trial等于10时，说明一个回合已经结束，回合加一，重新生成飞碟数组
                    if (ruler.trialNum == 10) {
                        ruler.trialNum = 0;
                        ruler.roundNum++;
                        generateRoundDisksNum();
                    }
                }
                // 否则游戏结束，提示重新进行游戏
                else {
                    mainController.SetViewTip("Click Restart and Play Again!");
                    mainController.SetGameState((int)GameState.GameOver);
                }
                // 设置回合数和trial数目的提示
                if (ruler.trialNum == 0) mainController.SetViewRoundNum(ruler.roundNum);
                else mainController.SetViewRoundNum(ruler.roundNum + 1);
                mainController.SetViewTrialNum(ruler.trialNum);
            }
        }
    }
}

Ruler为飞碟规则：

// 飞碟获取规则
public struct Ruler {
    public int trialNum; // 当前trial的编号
    public int roundNum; // 当前round的编号
    public int roundSum; // 一共round的总数目
    public int [] roundDisksNum; // 每一轮对于trial的飞碟数量
    public float sendTime; // 发射间隔时间

    public int size; // 飞碟大小
    public int speed; // 飞碟速度
    public string color; // 飞碟颜色
    public Vector3 direction; // 飞碟飞入方向
    public Vector3 beginPos; // 飞碟飞入位置
};

然后实现图中负责飞碟运动动作的这一部分：

请添加图片描述

IActionManager.cs：

IActionManager是飞碟运动类型动作的管理接口，里面有一个方法PlayDisk，由CCActionManager和PhysisActionManager两个适配器类分别实现，描述飞碟的不同运动过程，实现如下：

public interface IActionManager {
    void PlayDisk(GameObject disk, float speed, Vector3 direction);
}

ISSActionCallback.cs：

ISSActionCallback是飞碟运动完成后的回调接口，当飞碟飞行完成之后，就会调用这个接口里的SSActionEvent方法，完成对飞碟对象的销毁，由CCActionManager和PhysisActionManager两个适配器类继承：

public enum SSActionEventType : int { Started, Competed }
public interface ISSActionCallback {
    // 回调函数
    void SSActionEvent(SSAction source,
        SSActionEventType events = SSActionEventType.Competed,
        int intParam = 0,
        string strParam = null,
        Object objectParam = null);
}

CCActionManager.cs和PhysisActionManager.cs：

这两个类是运动学运动动作和物理运动动作的管理类，分别实现了继承的IActionManager接口中的PlayDisk方法，也实现了继承的ISSActionCallback这个接口中的回调方法SSActionEvent，实现如下：

public class CCActionManager : SSActionManager, ISSActionCallback, IActionManager {
    CCPlayDiskAction PlayDiskAction; // 飞碟空中动作

    public void PlayDisk(GameObject disk, float speed, Vector3 direction) {
        PlayDiskAction = CCPlayDiskAction.GetSSAction(direction, speed);
        RunAction(disk, PlayDiskAction, this);
    }

    // 回调函数
    public void SSActionEvent(SSAction source,
    SSActionEventType events = SSActionEventType.Competed,
    int intParam = 0,
    string strParam = null,
    Object objectParam = null)
    {
        // 结束飞行后回收飞碟
        Singleton<RoundController>.Instance.FreeFactoryDisk(source.gameObject);
    }
}

public class PhysisActionManager : SSActionManager, ISSActionCallback, IActionManager {
    PhysisPlayDiskAction PlayDiskAction; // 飞碟空中动作

    public void PlayDisk(GameObject disk, float speed, Vector3 direction) {
        PlayDiskAction = PhysisPlayDiskAction.GetSSAction(direction, speed);
        RunAction(disk, PlayDiskAction, this);
    }

    // 回调函数
    public void SSActionEvent(SSAction source,
    SSActionEventType events = SSActionEventType.Competed,
    int intParam = 0,
    string strParam = null,
    Object objectParam = null)
    {
        // 结束飞行后回收飞碟
        Singleton<RoundController>.Instance.FreeFactoryDisk(source.gameObject);
    }
}

SSAction.cs和SSActionManager.cs：

SSAction是动作基类，SSActionManager是动作管理者的基类，其实现分别为：

public class SSAction : ScriptableObject {
    public bool enable = true; // 动作可进行
    public bool destroy = false; // 动作已完成可被销毁

    public GameObject gameObject { get; set; } // 附着游戏对象
    public Transform transform { get; set; } // 游戏对象的的运动
    public ISSActionCallback callback { get; set; } // 回调函数

    public virtual void Start() {} // Start()重写方法

    public virtual void Update() {} // Update()重写方法
}

public class SSActionManager : MonoBehaviour {
    // 动作集在
    private Dictionary<int, SSAction> actions = new Dictionary<int, SSAction>();
    // 即将开始的动作的等待加入队列
    private List<SSAction> waitingAdd = new List<SSAction>();
    // 已完成的的动作的等待删除队列
    private List<int> waitingDelete = new List<int>();

    protected void Update() {
        // 载入即将开始的动作
        foreach (SSAction ac in waitingAdd) {
            actions[ac.GetInstanceID()] = ac;
        }
        // 清空等待加入队列
        waitingAdd.Clear();

        // 运行载入动作
        foreach (KeyValuePair<int, SSAction> kv in actions) {
            SSAction ac = kv.Value;
            if (ac.destroy) {
                waitingDelete.Add(ac.GetInstanceID());
            }
            else if (ac.enable) {
                ac.Update();
            }
        }

        // 清空已完成的动作
        foreach (int key in waitingDelete) {
            SSAction ac = actions[key];
            actions.Remove(key);
            Destroy(ac);
        }
        // 清空等待删除队列
        waitingDelete.Clear();
    }

    // 初始化动作并加入到等待加入队列
    public void RunAction(GameObject gameObject, SSAction action, ISSActionCallback manager) {
        action.gameObject = gameObject;
        action.transform = gameObject.transform;
        action.callback = manager;
        waitingAdd.Add(action);
        action.Start();
    }
}

CCPlayDiskAction.cs和PhysisPlayDiskAction.cs：

这两个类是运动学运动动作和物理运动动作的类，分别实现了继承的SSAction接口中的Start和Update方法，实现如下：

public class CCPlayDiskAction : SSAction {
    float gravity; // 垂直速度
    float speed; // 水平速度
    Vector3 direction;  // 方向
    float time; // 时间

    public static CCPlayDiskAction GetSSAction(Vector3 direction, float speed) {
        CCPlayDiskAction action = ScriptableObject.CreateInstance<CCPlayDiskAction>();
        action.gravity = 9.8f;
        action.time = 0;
        action.speed = speed;
        action.direction = direction;
        return action;
    }

    public override void Start() {
        gameObject.GetComponent<Rigidbody>().isKinematic = true;
    }

    public override void Update() {
        time += Time.deltaTime;
        transform.Translate(Vector3.down * gravity * time * Time.deltaTime);
        transform.Translate(direction * speed * Time.deltaTime);
        // 飞碟到达底部动作结束，回调
        if (this.transform.position.y < -5) {
            this.destroy = true;
            this.enable = false;
            this.callback.SSActionEvent(this);
        }
    }
}

public class PhysisPlayDiskAction : SSAction {
    float speed; // 水平速度
    Vector3 direction; // 飞行方向

    public static PhysisPlayDiskAction GetSSAction(Vector3 direction, float speed) {
        PhysisPlayDiskAction action = ScriptableObject.CreateInstance<PhysisPlayDiskAction>();
        action.speed = speed;
        action.direction = direction;
        return action;
    }

    public override void Start() {
        gameObject.GetComponent<Rigidbody>().isKinematic = false;
        // 水平初速度
        gameObject.GetComponent<Rigidbody>().velocity = speed * direction;
    }

    public override void Update() {
        // 飞碟到达底部动作结束，回调
        if (this.transform.position.y < -5) {
            this.destroy = true;
            this.enable = false;
            this.callback.SSActionEvent(this);
        }
    }
}

最后实现图中控制回合控制器的主控制器及其控制的视图部分：

请添加图片描述

MainController.cs：

主控制类MainController负责控制回合控制器以及游戏视图，回合控制器RoundController监测游戏事件发生之后，通知主控制器MainController，然后主控制器控制游戏视图View类显示相应内容，通过设置主控制类中的成员变量N，可以调整普通模式的默认回合，代码如下：

/* 游戏状态，0为准备进行，1为正在进行游戏，2为结束 */
enum GameState {
    Ready = 0, Playing = 1, GameOver = 2
};

public class MainController : MonoBehaviour {
    private RoundController roundController; // 回合控制器
    private View view; // 游戏视图
    private int N = 2; // 默认游戏回合
    private int gameState;
    public GUISkin gameSkin;

    void Start() {
        Director.GetInstance().mainController = this;
        roundController = gameObject.AddComponent<RoundController>();
        view = gameObject.AddComponent<View>();
        gameState = (int)GameState.Ready;
        view.gameSkin = gameSkin;
    }

    public int GetN() {
        return N;
    }

    public void Restart() {
        view.Init();
        roundController.Reset();
    }

    public void SetGameState(int state) {
        gameState = state;
    }

    public int GetGameState() {
        return gameState;
    }

    public void ShowPage() {
        switch(gameState) {
            case 0:
                view.ShowHomePage();
                break;
            case 1:
                view.ShowGamePage();
                break;
            case 2:
                view.ShowRestart();
                break;
        }
    }

    public void SetRoundSum(int roundSum) {
        roundController.SetRoundSum(roundSum);
    }

    public void SetPlayDiskModeToPhysis(bool isPhysis) {
        roundController.SetPlayDiskModeToPhysis(isPhysis);
    }

    public void SetViewTip(string tip) {
        view.SetTip(tip);
    }

    public void SetViewScore(int score) {
        view.SetScore(score);
    }

    public void SetViewRoundNum(int round) {
        view.SetRoundNum(round);
    }

    public void SetViewTrialNum(int trial) {
        view.SetTrialNum(trial);
    }

    public void Hit(Vector3 position) {
        Camera camera = Camera.main;
        Ray ray = camera.ScreenPointToRay(position);

        RaycastHit[] hits;
        hits = Physics.RaycastAll(ray);

        for (int i = 0; i < hits.Length; i++) {
            RaycastHit hit = hits[i];
            if (hit.collider.gameObject.GetComponent<DiskData>() != null) {
                // 把击中的飞碟移出屏幕，触发回调释放
                hit.collider.gameObject.transform.position = new Vector3(0, -6, 0);
                // 记录飞碟得分
                roundController.Record(hit.collider.gameObject.GetComponent<DiskData>());
                // 显示当前得分
                view.SetScore(roundController.GetScores());
            }
        }
    }

    // 释放所有工厂飞碟
    public void FreeAllFactoryDisk() {
        roundController.FreeAllFactoryDisk();
    }
}

View.cs：

视图类经过主控制器的控制，显示相应内容：

public class View : MonoBehaviour {
    private MainController mainController;
    private int score;
    private string tip;
    private string roundNum;
    private string trialNum;
    public GUISkin gameSkin;  // 游戏控件的皮肤风格

    void Start() {
        score = 0;
        tip = "";
        roundNum = "";
        trialNum = "";
        mainController = Director.GetInstance().mainController;
    }

    public void SetTip(string tip) {
        this.tip = tip;
    }

    public void SetScore(int score) {
        this.score = score;
    }

    public void SetRoundNum(int round) {
        roundNum = "回合: " + round;
    }

    public void SetTrialNum(int trial) {
        if (trial == 0) trial = 10;
        trialNum = "Trial: " + trial;
    }

    public void Init() {
        score = 0;
        tip = "";
        roundNum = "";
        trialNum = "";
    }

    public void AddTitle() {
        GUIStyle titleStyle = new GUIStyle();
        titleStyle.normal.textColor = Color.black;
        titleStyle.fontSize = 50;

        GUI.Label(new Rect(Screen.width / 2 - 80, 20, 60, 100), "Hit UFO", titleStyle);
    }

    public void AddChooseModeButton() {
        GUI.skin = gameSkin;
        if (GUI.Button(new Rect(280, 100, 160, 80), "普通模式\n(默认为" + mainController.GetN() + "回合)")) {
            mainController.SetRoundSum(mainController.GetN());
            mainController.Restart();
            mainController.SetGameState((int)GameState.Playing);
        }
        if (GUI.Button(new Rect(280, 210, 160, 80), "无尽模式\n(回合数无限)")) {
            mainController.SetRoundSum(-1);
            mainController.Restart();
            mainController.SetGameState((int)GameState.Playing);
        }
    }

    public void ShowHomePage() {
        AddChooseModeButton();
    }

    public void AddActionModeButton() {
        GUI.skin = gameSkin;
        if (GUI.Button(new Rect(10, Screen.height - 100, 110, 40), "运动学模式")) {
            mainController.FreeAllFactoryDisk();
            mainController.SetPlayDiskModeToPhysis(false);
        }
        if (GUI.Button(new Rect(10, Screen.height - 50, 110, 40), "物理模式")) {
            mainController.FreeAllFactoryDisk();
            mainController.SetPlayDiskModeToPhysis(true);
        }
    }

    public void AddBackButton() {
        GUI.skin = gameSkin;
        if (GUI.Button(new Rect(10, 10, 60, 40), "Back")) {
            mainController.FreeAllFactoryDisk();
            mainController.Restart();
            mainController.SetGameState((int)GameState.Ready);
        }
    }

    public void AddGameLabel() {
        GUIStyle labelStyle = new GUIStyle();
        labelStyle.normal.textColor = Color.black;
        labelStyle.fontSize = 30;

        GUI.Label(new Rect(570, 10, 100, 50), "得分: " + score, labelStyle);
        GUI.Label(new Rect(170, 80, 50, 200), tip, labelStyle);
        GUI.Label(new Rect(570, 60, 100, 50), roundNum, labelStyle);
        GUI.Label(new Rect(570, 110, 100, 50), trialNum, labelStyle);
    }

    public void AddRestartButton() {
        if (GUI.Button(new Rect(300, 150, 100, 60), "Restart")) {
            mainController.FreeAllFactoryDisk();
            mainController.Restart();
            mainController.SetGameState((int)GameState.Playing);
        }
    }

    public void ShowGamePage() {
        AddGameLabel();
        AddBackButton();
        AddActionModeButton();
        if (Input.GetButtonDown("Fire1")) {
            mainController.Hit(Input.mousePosition);
        }
    }

    public void ShowRestart() {
        ShowGamePage();
        AddRestartButton();
    }

    void OnGUI() {
        AddTitle();
        mainController.ShowPage();
    }
}

核心算法

在RoundController的LaunchDisk方法中，飞碟以随机方式进行发射，因为要求随着回合往后难度增大，所以这里设置了飞碟的速度随回合的增加而增大，表现难度增加：

// 发射飞碟
public void LaunchDisk() {
    // 使飞碟飞入位置尽可能分开，从不同位置飞入使用的数组
    int [] beginPosY = new int [4]{0, 0, 0, 0};

    for (int i = 0; i < ruler.roundDisksNum[ruler.trialNum]; ++i) {
        // 获取随机数
        int randomNum = Random.Range(0, 3) + 1;
        // 飞碟速度随回合数增加而变快，这样难度增加
        ruler.speed = randomNum * (ruler.roundNum + 4);

        // 重新选取随机数，并根据随机数选择飞碟颜色
        randomNum = Random.Range(0, 3) + 1;
        if (randomNum == 1) {
            ruler.color = "red";
        }
        else if (randomNum == 2) {
            ruler.color = "green";
        }
        else {
            ruler.color = "blue";
        }

        // 重新选取随机数，并根据随机数选择飞碟的大小
        ruler.size = Random.Range(0, 3) + 1;

        // 重新选取随机数，并根据随机数选择飞碟飞入的方向
        randomNum = Random.Range(0, 2);
        if (randomNum == 1) {
            ruler.direction = new Vector3(3, 1, 0);
        }
        else {
            ruler.direction = new Vector3(-3, 1, 0);
        }

        // 重新选取随机数，并使不同飞碟的飞入位置尽可能分开
        do {
            randomNum = Random.Range(0, 4);
        } while (beginPosY[randomNum] != 0);
        beginPosY[randomNum] = 1;
        ruler.beginPos = new Vector3(-ruler.direction.x * 4, -0.5f * randomNum, 0);

        // 根据ruler从工厂中生成一个飞碟
        GameObject disk = Singleton<DiskFactory>.Instance.GetDisk(ruler);
    
        // 设置飞碟的飞行动作
        actionManager.PlayDisk(disk, ruler.speed, ruler.direction);
    }
}

在RoundController的FreeAllFactoryDisk方法中，因为运动模式变化时飞碟的运动属性可能会不一样，点击返回按钮或重新开始按钮时也有可能有飞碟没有被销毁，影响下一次进行游戏，所以需要在点击这些按钮时，直接将所有飞碟都销毁，再去进行游戏：

// 释放所有工厂飞碟
public void FreeAllFactoryDisk() {
    GameObject[] obj = FindObjectsOfType(typeof(GameObject)) as GameObject[];
    foreach (GameObject g in obj) {
        if (g.gameObject.name == "Disk(Clone)(Clone)") {
            Singleton<DiskFactory>.Instance.FreeDisk(g);
        }
    }
}