游戏简介
在打飞碟游戏中,玩家可以通过点击飞出的飞碟得分,目标是争取获得更高的分。
游戏规则
游戏有 n 个 round,每个 round 都包括10 次 trial。
每个 trial 的飞碟的色彩、大小、发射位置、速度、角度、同时出现的个数都可能不同。它们由该 round 的 ruler 控制。
每个 trial 的飞碟有随机性,总体难度随 round 上升。
鼠标点中得分,得分规则按色彩、大小、速度不同计算,规则可自由设定。
项目实现效果
uml图:
计分规则:
加分项 | 加分 |
---|---|
飞碟为红色 | 加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;
}
}
}
接着实现图中负责游戏每轮飞碟的创建和销毁,记录得分和游戏状态的这一部分:
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;
}
}
}
}
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);
}
}
}
游戏中截图: