其他分享
首页 > 其他分享> > Unity 游戏实例开发集合 之 CutFruit (切水果(水果忍者)) 休闲小游戏快速实现

Unity 游戏实例开发集合 之 CutFruit (切水果(水果忍者)) 休闲小游戏快速实现

作者:互联网

Unity 游戏实例开发集合 之 CutFruit (切水果(水果忍者)) 休闲小游戏快速实现

目录

Unity 游戏实例开发集合 之 CutFruit (切水果(水果忍者)) 休闲小游戏快速实现

一、简单介绍

二、CutFruit (切水果(水果忍者)) 游戏内容与操作

三、相关说明

四、游戏代码框架

五、知识点

六、游戏效果预览​

七、实现步骤

八、工程源码地址

九、延伸扩展


一、简单介绍

Unity 游戏实例开发集合,使用简单易懂的方式,讲解常见游戏的开发实现过程,方便后期类似游戏开发的借鉴和复用。

本节介绍,CutFruit (切水果(水果忍者))休闲小游戏快速实现的方法,希望能帮到你,若有不对,请留言。

这是一个 3D 游戏,主要是使用精灵图(水果特效等)、3D 重力、3D 碰撞体,TrailRenderer (切刀效果) 实现。

二、CutFruit (切水果(水果忍者)) 游戏内容与操作

1、游戏开始,底部会自动生成向上运动的水果

2、按下鼠标,移动就会生成切水果的刀锋

3、鼠标刀锋碰到水果,水果就会被切开

4、松开鼠标,切割刀锋消失

5、当切到水果,会对应加分,切刀炸弹,会对应失去生命

6、生命没有了,则游戏结束

三、相关说明

1、这里底部生成水果位置,做了屏幕适配,x 方向是:宽度的20% - 80%,y 方向是:屏幕向下高度的 20 %

2、随机生成水果和炸弹的规则是:随机某个范围,指定某个数是炸弹,其他是随机水果

3、这里 3D 水果和炸弹,使用 Collider 3D 碰撞体,但是使用了的是 Trigger 效果,Knife 可以喝水果碰撞,触发事件,但是不会发生实际碰撞效果

4、这里水果或者水果碎片回收,使用的是 OnBecameInvisible() 函数(编辑状态下,包括编辑Scene 的窗口,不仅仅是游戏Game窗口),既是:水果出相机视野,则进行,对应的回收,对象池中继续使用,节约性能

5、脚本复刻这块建议:先复刻 Common 和 Tools 文件夹的脚本,然后 Fruit 和 Effect 文件夹的脚本,接着 Manager 的各个脚本(顺序可按实现步骤的顺序来),最后 GameManager 和 GameStart 即可

6、这里值得注意的是,水果的枚举的作用:1)枚举值是随机生成水果的随机值对应;2)枚举是对应的预制体名称一致;3)枚举是对饮水果的脚本名称一致

四、游戏代码框架

 

五、知识点

1、MonoBehaviour 生命周期函数:Awake,Start,Update,Destroy

2、Input 按键的监控鼠标按键的状态

3、GameObject.Instantiate 物体的生成,GameObject.Destroy 物体的销毁

4、简单的对象池管理

5、Rigidbody 重力效果,添加 CirecleCollider ,进行 碰撞检测(Trigger)

6、简单UGUI的使用

7、简单屏幕适配(主要是UI和 水果生成位置)

8、一些数据,路径等的统一常量管理

9、Transform.Rotate 旋转使用

10、IEnumerator 协程 , StartCoroutine 开始协程 和 StopAllCoroutines 停止所有协程的使用

11、IManager 简单的接口规范 Manager 类函数

12、Action<int> OnChangeValue 属性变化中委托的使用

13、Resources.Load<GameObject>() 代码加载预制体的使用

14、简单的屏幕坐标转为世界坐标的工具类

15、 SceneManager.LoadScene 加载,和 SceneManager.GetActiveScene() 当前场景的获取

16、游戏开发的资源脚本文件夹分类管理

17、等等


六、游戏效果预览

 

七、实现步骤

1、打开 Unity,导入水果 等相关资源

 

2、然后把对应的资源做成预制体

3、这个说明一下 Knife 的制作过程:1)图片是刀锋,可以替换图片更换刀锋;2) 创建一个拖尾的材质Trail,对应shader 为 Particles/Additive,并赋值对应刀锋图;3)创建一个 Sphere ,改名为Knife,添加 TrailRenderer 组件,并赋值 Trail 材质,TrailRenderer  Time 适当改小为 0.1,Knife scale 适当改小为 0.2(可参照实际水果大小调整)

 

4、取消 Knife 的MeshRenderer 渲染,保留 Collier ,用于与水果触发碰撞事件

 

5、其中水果预制体,添加 Rigibody,和 MeshCollider ,MeshCollider  勾选 Convex 和 Is Trigger(碰撞的时候只触发碰撞事件,不发生实际碰撞效果),Bomb 类似操作

 

6、BombEffect 和 Splash 是 Spriterenderer 图片动画来的

 

7、在场景中,创建一个 GameObject,改名为 World(pos(0,0,0)),把默认的Main Camera(位置修改为(0,0,0)) 和 Direction Light 至于World 下面,类似依次创建 GameObject,改名为 SpawnFruitPos、SpawnSplashPos、SpawnKnifePos、SpawnBombPos、SpawnBombEffectPos,位置都为(0,0,0),功能如其名,用来把对应生成的游戏物体统一管理

8、创建一个 GameObject,改名为UI(Pos(0,0,0)),添加一个Canvas (自动添加EventSystem),设置 Canvas Scaler 的 UI Scale Mode 为 Scale with Screen Size ,Reference Resolution 为  1080 x 1920 ,Match 滑动到 Height

 

9、LifeText 放置在左边上,改变锚点,文字加粗居中显示,可以根据实际情况自行调整

 

10、ScoreText 放置在右边上,改变锚点,文字加粗居中显示,可以根据实际情况自行调整

 

 11、GameOverImage 图片铺满屏幕,设置为黑色,增加透明度,GameOverText 文字加粗居中显示,RestartGameButton 放大,文字调大,可以根据实际情况自行调整,最终如图

 

12、修改屏幕为 1080x1920 ,最终 UI 效果如下

 

13、在工程中添加 Enum 脚本,管理所有枚举,目前只是水果类型,和水果破碎类型枚举

	/// <summary>
	/// 水果类型
	/// </summary>
	public enum FruitType { 
		Apple = 0,
		Lemon,
		Watermelon,

		SUM_COUNT, // 水果类型总数
	}

	/// <summary>
	/// 破碎水果类型
	/// </summary>
	public enum FruitBrokenType { 
		Apple_Broken = 0,
		Lemon_Broken,
		Watermelon_Broken,


		SUM_COUNT,  // 破碎水果类型总数
	}

14、在工程中添加 GameConfig 脚本,管理游戏中的一些数据

	/// <summary>
	/// 游戏配置数据
	/// </summary>
	public class GameConfig 
	{
		public const string NAME_SPACE_NAME = "MGP_005CutFruit.";

		// Knife 预制体名称(用于碰撞触发判断使用)
		public const string KNIFE_NAME = "Knife";

		// 水果、炸弹、Knife 等游戏生成的统一深度距离
		public const float GAME_OBJECT_Z_VALUE = 5;	

		// 底部间隔几秒生成物体
		public const float BOTTOM_SPAWN_INTERVAL_TIME = 2;	

		// 游戏生命(可切破几次炸弹)
		public const int GAME_LIFE_LENGTH = 3;
		// 游戏剩余几条命结束
		public const int REMAIN_LIFE_IS_GAME_OVER = 0;

		// 水果 炸弹生成向上的最小最大速度
		public const float FRUIT_UP_Y_VELOSITY_MIN_VALUE = 8;
		public const float FRUIT_UP_Y_VELOSITY_MAX_VALUE = 10;

		/// <summary>
		/// 随机生成水果炸弹的数值范围
		/// 随机数多少是炸弹
		/// </summary>
		public const int FRUIT_RANDOM_MIN_VALUE = 0;
		public const int FRUIT_RANDOM_MAX_VALUE = 15;
		public const int BOMB_RANDOM_VALUE = 10;

		/// <summary>
		/// 切刀不同水果的得分
		/// </summary>
		public const int FRUIT_APPLE_SCORE = 10;
		public const int FRUIT_LEMON_SCORE = 20;
		public const int FRUIT_WATERMELON_SCORE = 30;

		//切到炸弹失去的生命值
		public const int BOMB_REDUCE_LIFE = 1;
	}

15、在工程中添加 GameObjectPathInSceneDefine 脚本,定义场景中的游戏物体路径类,ResPathDefine 定义预制体路径类

	/// <summary>
	/// 定义场景中的游戏物体路径类
	/// </summary>
	public class GameObjectPathInSceneDefine 
	{
		public const string WORLD_PATH = "World";
		public const string UI_PATH = "UI";

		public const string SPAWN_FRUIT_POS_PATH = "SpawnFruitPos";
		public const string SPAWN_SPLASH_POS_PATH = "SpawnSplashPos";
		public const string SPAWN_KNIFE_POS_PATH = "SpawnKnifePos";
		public const string SPAWN_BMOB_POS_PATH = "SpawnBombPos";
		public const string SPAWN_BMOB_EFFECT_POS_PATH = "SpawnBombEffectPos";


		public const string UI_LIFE_TEXT_PATH = "Canvas/LifeText";
		public const string UI_SCORE_TEXT_PATH = "Canvas/ScoreText";
		public const string UI_GAME_OVER_IMAGE_PATH = "Canvas/GameOverImage";
		public const string UI_RESTART_GAME_BUTTON_PATH = "Canvas/GameOverImage/RestartGameButton";


	}

	/// <summary>
	/// 定义预制体路径类
	/// </summary>
	public class ResPathDefine 
	{
		public const string FRUIT_PREFAB_BASE_PATH = "Prefabs/CutFruits/";

		public const string SPLASH_PREFAB_PATH = "Prefabs/Splash";
		public const string KNIFE_PREFAB_PATH = "Prefabs/Knife";
		public const string BOMB_PREFAB_PATH = "Prefabs/Bomb";
		public const string BOMB_EFFECT_PREFAB_PATH = "Prefabs/BombEffect";
	}

 

16、在工程中添加 BaseFruit 脚本,水果基类脚本,主要管理水果和 Knife 碰撞事件(加分,生成水果碎片,特效等),以及出相机视野外的回收处理,关键代码如下

        /// <summary>
        /// 碰撞事件
        /// </summary>
        /// <param name="other"></param>
        private void OnTriggerEnter(Collider other)
        {
            if (other.name.StartsWith( GameConfig.KNIFE_NAME))
            {
                //增加分数
                m_DataModelManager.Score.Value += Score;


                for (int i = 0; i < 2; i++)
                {
                    //产生破碎的水果
                    FruitBroken fruitBroken = SpawnBroken();
                    fruitBroken.Init(FruitBrokenType,m_FruitManager);
                    GameObject temp = fruitBroken.gameObject;
                    temp.SetActive(true);
                    temp.transform.position = transform.position;
                    temp.transform.eulerAngles = new Vector3(Random.Range(0, 360), Random.Range(0, 360), Random.Range(0, 360));
                    //-3 -2  2 3

                    // 随机水果碎片速度
                    float x, y;
                    int ranX = Random.Range(0, 2);
                    if (ranX == 0)
                    {
                        x = Random.Range(-3.0f, -2.0f);
                    }
                    else
                    {
                        x = Random.Range(2.0f, 3.0f);
                    }

                    int ranY = Random.Range(0, 2);
                    if (ranY == 0)
                    {
                        y = Random.Range(-3.0f, -2.0f);
                    }
                    else
                    {
                        y = Random.Range(2.0f, 3.0f);
                    }

                    temp.GetComponent<Rigidbody>().velocity = new Vector2(x, y);

                }

                //产生果汁特效
                Splash splash = SpawnSplash();
                splash.transform.position = transform.position;
                splash.transform.rotation = Quaternion.Euler(Vector3.forward * Random.Range(-180,180));
                splash.Show(FruitSplahColor, m_SplashManager.RecycleSplah);
                

                //隐藏水果物体
                m_FruitManager.RecycleFruit(FruitType,this);
                m_IsRecycle = false;
            }
            if (other.tag == "BottomCollider")
            {
                gameObject.SetActive(false);
            }
        }

        private void OnBecameVisible()
        {
            m_IsRecycle = true;
        }

        /// <summary>
        /// 相机视野外
        /// 回收水果
        /// </summary>
        private void OnBecameInvisible()
        {
            if (m_IsRecycle==true)
            {
                m_FruitManager.RecycleFruit(FruitType, this);
                m_IsRecycle = false;

            }
        }

17、在工程中添加Apple、Lemon、Watermelon 脚本,继承 BaseFruit ,实现抽象类,设置其对应水果类型,水果破碎类型,碎果Splash 颜色,和得分

	public class Apple : BaseFruit
	{
       

        public override FruitType FruitType => FruitType.Apple;

        public override FruitBrokenType FruitBrokenType => FruitBrokenType.Apple_Broken;

        public override Color FruitSplahColor => Color.red;

        public override int Score => GameConfig.FRUIT_APPLE_SCORE;
    }

18、在工程中添加 FruitManager 脚本,主要管理水果和水果碎片的预制体加载,以及水果和水果碎片对象池的初始化,并提供接口,从对象池中获取水果和水果碎片,和回收水果和水果碎片

        /// <summary>
        /// 获取水果碎片
        /// </summary>
        /// <param name="fruitBrokenType"></param>
        /// <returns></returns>
        public FruitBroken GetFruitBroken(FruitBrokenType fruitBrokenType)
        {
            Queue<FruitBroken> fruitBrokenQue = m_FruitBrokenObjectPoolDict[fruitBrokenType];
            if (fruitBrokenQue.Count > 0)
            {
                return fruitBrokenQue.Dequeue();
            }
            else
            {
                return InstantiateFruitBroken(fruitBrokenType);
            }
        }

        /// <summary>
        /// 回收水果
        /// </summary>
        /// <param name="fruitType"></param>
        /// <param name="baseFruit"></param>
        public void RecycleFruit(FruitType fruitType,BaseFruit baseFruit) {
            baseFruit.gameObject.SetActive(false);
            if (m_FruitObjectPoolDict!=null && m_FruitObjectPoolDict[fruitType]!=null)
            {
                m_FruitObjectPoolDict[fruitType].Enqueue(baseFruit);

            }
        }

        /// <summary>
        /// 回收水果碎片
        /// </summary>
        /// <param name="fruitBrokenType"></param>
        /// <param name="fruitBroken"></param>
        public void RecycleFruitBroken(FruitBrokenType fruitBrokenType, FruitBroken fruitBroken)
        {
            fruitBroken.gameObject.SetActive(false);
            m_FruitBrokenObjectPoolDict[fruitBrokenType].Enqueue(fruitBroken);
        }

        /// <summary>
        /// 加载预制体和预载水果到对象池中
        /// </summary>
        private void InitFruit() {

            // 加载预制体
            m_FruitPrefabsDict = new Dictionary<string, GameObject>();
            for (FruitType fruitType = FruitType.Apple; fruitType < FruitType.SUM_COUNT; fruitType++)
            {
                GameObject prefab = Resources.Load<GameObject>(ResPathDefine.FRUIT_PREFAB_BASE_PATH+fruitType.ToString());
                if (prefab == null)
                {
                    Debug.LogError(GetType() + "/InitFruit()/prefab is null, path = " + ResPathDefine.FRUIT_PREFAB_BASE_PATH + fruitType.ToString());
                }
                else {
                    m_FruitPrefabsDict.Add(fruitType.ToString(),prefab);
                }
            }

            // 加载预制体
            for (FruitBrokenType fruitBrokenType = FruitBrokenType.Apple_Broken; fruitBrokenType < FruitBrokenType.SUM_COUNT; fruitBrokenType++)
            {
                GameObject prefab = Resources.Load<GameObject>(ResPathDefine.FRUIT_PREFAB_BASE_PATH + fruitBrokenType.ToString());
                if (prefab == null)
                {
                    Debug.LogError(GetType() + "/InitFruit()/prefab is null, path = " + ResPathDefine.FRUIT_PREFAB_BASE_PATH + fruitBrokenType.ToString());
                }
                else
                {
                    m_FruitPrefabsDict.Add(fruitBrokenType.ToString(), prefab);
                }
            }

            // 预载水果
            m_FruitObjectPoolDict = new Dictionary<FruitType, Queue<BaseFruit>>();
            for (FruitType fruitType = FruitType.Apple; fruitType < FruitType.SUM_COUNT; fruitType++) {
                Queue<BaseFruit> fruits = new Queue<BaseFruit>();
                m_FruitObjectPoolDict.Add(fruitType, fruits);

                RecycleFruit(fruitType, InstantiateFruit(fruitType));
            }

            // 预载水果 Broken
            m_FruitBrokenObjectPoolDict = new Dictionary<FruitBrokenType, Queue<FruitBroken>>();
            for (FruitBrokenType fruitBrokenType = FruitBrokenType.Apple_Broken; fruitBrokenType < FruitBrokenType.SUM_COUNT; fruitBrokenType++)
            {
                Queue<FruitBroken> fruitBrokens = new Queue<FruitBroken>();
                m_FruitBrokenObjectPoolDict.Add(fruitBrokenType, fruitBrokens);

                RecycleFruitBroken(fruitBrokenType, InstantiateFruitBroken(fruitBrokenType));
            }
        }

        /// <summary>
        /// 生成指定水果对象
        /// </summary>
        /// <param name="fruitType"></param>
        /// <returns></returns>
        private BaseFruit InstantiateFruit(FruitType fruitType) {
            GameObject fruit = GameObject.Instantiate(m_FruitPrefabsDict[fruitType.ToString()], m_SpawnFruitPosTrans);
            // 反射获取脚本类型,添加脚本 (注意添加命名空间)
            Type type = Type.GetType( GameConfig.NAME_SPACE_NAME+ fruitType.ToString());
            return (fruit.AddComponent(type) as BaseFruit);
        }

        /// <summary>
        /// 生成破碎水果
        /// </summary>
        /// <param name="fruitBrokenType"></param>
        /// <returns></returns>
        private FruitBroken InstantiateFruitBroken(FruitBrokenType fruitBrokenType)
        {
            GameObject fruit = GameObject.Instantiate(m_FruitPrefabsDict[fruitBrokenType.ToString()], m_SpawnFruitPosTrans);
          
            return fruit.AddComponent<FruitBroken>();
        }

19、在工程中添加 Bomb 脚本,主要功能是 Bomb 与 Knife 的碰撞(减少生命值,以及生成特效),以及相机视野外后回收

        private void OnTriggerEnter(Collider other)
        {
            if (other.name.StartsWith( GameConfig.KNIFE_NAME))
            {
                //减少生命值
                m_DataModelManager.Life.Value -= GameConfig.BOMB_REDUCE_LIFE;

                //产生爆炸特效
                BombEffect bombEffect = m_BombEffectManager.GetBombEffect();
                bombEffect.Show(transform.position, m_BombEffectManager.RecycleBombEffect);

                //隐藏物体
                m_BmobManager.RecycleBomb(this);
            }
        }


        private void OnBecameVisible()
        {
            m_IsRecycle = true;
        }


        /// <summary>
        /// 相机是野外事件
        /// </summary>
        private void OnBecameInvisible()
        {
            if (m_IsRecycle == true)
            {
                m_BmobManager.RecycleBomb( this);
                m_IsRecycle = false;

            }
        }

20、在工程中添加 BombManager 脚本,主要管理 Bomb 预制体加载,对象池初始化,提供接口获取和回收 Bomb

        /// <summary>
        /// 获取 Bomb 
        /// </summary>
        /// <returns></returns>
        public Bomb GetBmob()
        {
            if (m_BombQueue.Count > 0)
            {
                Bomb bomb = m_BombQueue.Dequeue();
                bomb.gameObject.SetActive(true);
                return bomb;
            }
            else
            {
                return InstantiateBomb();
            }
        }

        /// <summary>
        /// 回收 Bomb 
        /// </summary>
        /// <param name="bomb"></param>
        public void RecycleBomb(Bomb bomb)
        {
            bomb.gameObject.SetActive(false);
            m_BombQueue.Enqueue(bomb);
        }

        /// <summary>
        /// 初始化
        /// </summary>
        private void InitBmob()
        {
            // 加载预制体
            m_BombPrefab = Resources.Load<GameObject>(ResPathDefine.BOMB_PREFAB_PATH);

            // 预载 Bomb
            m_BombQueue = new Queue<Bomb>();
            RecycleBomb(InstantiateBomb());
        }

        private Bomb InstantiateBomb()
        {
            GameObject go = GameObject.Instantiate(m_BombPrefab, m_SpawnBombPosTrans);

            return go.AddComponent<Bomb>();
        }

21、在工程中添加 BombEffect 脚本,主要功能是 显示特效,并且定时回收特效

		/// <summary>
		/// 显示特效
		/// </summary>
		/// <param name="pos"></param>
		/// <param name="showAnimationEndAction"></param>
		public void Show(Vector3 pos, Action<BombEffect> showAnimationEndAction)
		{
			// 赋值位置和随机旋转,并且定时回收
			transform.position = pos;
			transform.rotation = Quaternion.Euler(Vector3.forward * UnityEngine.Random.Range(-180, 180));
			StartCoroutine(Recycle(showAnimationEndAction));

		}

		/// <summary>
		/// 协程回收特效
		/// </summary>
		/// <param name="showAnimationEndAction"></param>
		/// <returns></returns>
		IEnumerator Recycle(Action<BombEffect> showAnimationEndAction) {
			yield return new WaitForSeconds(m_AnimationLength);
            if (showAnimationEndAction!=null)
            {
				showAnimationEndAction.Invoke(this);

			}
		}

22、在工程中添加 BombEffectManager 脚本,主要管理 Bomb 预制体加载,对象池初始化,提供接口获取和回收 BombEffect

        /// <summary>
        /// 获取爆炸特效
        /// </summary>
        /// <returns></returns>
        public BombEffect GetBombEffect()
        {
            if (m_BombEffectQueue.Count > 0)
            {
                BombEffect bombEffect = m_BombEffectQueue.Dequeue();
                bombEffect.gameObject.SetActive(true);
                return bombEffect;
            }
            else
            {
                return InstantiateBombEffect();
            }
        }

        /// <summary>
        /// 回收爆炸特效
        /// </summary>
        /// <param name="bombEffect"></param>
        public void RecycleBombEffect(BombEffect bombEffect)
        {
            bombEffect.gameObject.SetActive(false);
            m_BombEffectQueue.Enqueue(bombEffect);
        }

        /// <summary>
        /// 初始化特效
        /// </summary>
        private void InitBombEffect()
        {
            // 加载预制体
            m_BombEffectPrefab = Resources.Load<GameObject>(ResPathDefine.BOMB_EFFECT_PREFAB_PATH);

            // 预载 BombEffect
            m_BombEffectQueue = new Queue<BombEffect>();
            RecycleBombEffect(InstantiateBombEffect());
        }

        private BombEffect InstantiateBombEffect()
        {
            GameObject go = GameObject.Instantiate(m_BombEffectPrefab, m_SpawnBombEffectPosTrans);

            return go.AddComponent<BombEffect>();
        }

23、在工程中添加 Splash 脚本,主要功能是 显示 Splash ,并且定时回收 Splash

		/// <summary>
		/// 显示特效
		/// </summary>
		/// <param name="color"></param>
		/// <param name="showAnimationEndAction"></param>
		public void Show(Color32 color, Action<Splash> showAnimationEndAction)
		{
			StartCoroutine(EffectAnimation(color, showAnimationEndAction));
		}

		/// <summary>
		/// 特效动画
		/// </summary>
		/// <param name="color"></param>
		/// <param name="showAnimationEndAction"></param>
		/// <returns></returns>
		IEnumerator EffectAnimation(Color color, Action<Splash> showAnimationEndAction)
		{
			m_ColorValue = 0;
			color.a = 0;
			SpriteRenderer.color = color;
			while (true)
			{
				// lerp 匀速插值处理
				m_ColorValue += 1.0f / SPEED * Time.deltaTime;
				color.a = Mathf.Lerp(color.a, 1, m_ColorValue);
				SpriteRenderer.color = color;
				if ((1 - color.a <= 0.05f))
				{
					color.a = 1;
					SpriteRenderer.color = color;

					break;
				}


				yield return new WaitForEndOfFrame();
			}
			m_ColorValue = 0;
			while (true)
			{
				// lerp 匀速插值处理
				m_ColorValue += 1.0f / SPEED * Time.deltaTime;
				color.a = Mathf.Lerp(color.a, 0, m_ColorValue);
				SpriteRenderer.color = color;
				if ((color.a - 0) <= 0.05f)
				{
					color.a = 0;
					SpriteRenderer.color = color;
					break;
				}


				yield return new WaitForEndOfFrame();
			}


			if (showAnimationEndAction != null)
			{
				showAnimationEndAction.Invoke(this);
			}
		}

24、在工程中添加 SplashManager 脚本,主要管理 Bomb 预制体加载,对象池初始化,提供接口获取和回收 Splash

        /// <summary>
        /// 获取 Splash
        /// </summary>
        /// <returns></returns>
        public Splash GetSplash()
        {
            if (m_SplashQueue.Count > 0)
            {
                Splash splash = m_SplashQueue.Dequeue();
                splash.gameObject.SetActive(true);
                return splash;
            }
            else
            {
                return InstantiateSplash();
            }
        }

        /// <summary>
        /// 回收 Splash
        /// </summary>
        /// <param name="splash"></param>
        public void RecycleSplah(Splash splash)
        {
            splash.gameObject.SetActive(false);
            m_SplashQueue.Enqueue(splash);
        }

        /// <summary>
        /// 初始化 SPlash
        /// </summary>
        private void InitSplash()
        {
            // 加载预制体
            m_SplashPrefab = Resources.Load<GameObject>(ResPathDefine.SPLASH_PREFAB_PATH);

            // 预载Splash
            m_SplashQueue = new Queue<Splash>();
            RecycleSplah(InstantiateSplash());
        }

        private Splash InstantiateSplash()
        {
            GameObject go = GameObject.Instantiate(m_SplashPrefab, m_SpawnSplashPosTrans);

            return go.AddComponent<Splash>();
        }

25、在工程中添加 Tools 脚本,主要功能是 把屏幕坐标转为世界坐标

public class Tools
	{
		/// <summary>
		/// 把屏幕坐标转为世界坐标
		/// </summary>
		/// <param name="refTran">对应参照对象</param>
		/// <param name="refCamera">对应参照相机</param>
		/// <param name="screenPos">屏幕位置</param>
		/// <returns>屏幕位置的世界位置</returns>
		public static Vector3 ScreenPosToWorldPos(Transform refTran, Camera refCamera, Vector2 screenPos)
		{
			//将对象坐标换成屏幕坐标
			Vector3 pos = refCamera.WorldToScreenPoint(refTran.position);
			//让鼠标的屏幕坐标与对象坐标一致
			Vector3 mousePos = new Vector3(screenPos.x, screenPos.y, pos.z);
			//将正确的鼠标屏幕坐标换成世界坐标交给物体
			return refCamera.ScreenToWorldPoint(mousePos);

		}
	}

26、在工程中添加 KnifeManager 脚本,主要管理 Knife 预制体加载,监控鼠标按下情况,进行刀锋切水果功能

        /// <summary>
        /// 加载预制体
        /// </summary>
        void LoadPrefab() {
            m_KnifePrefab = Resources.Load<GameObject>(ResPathDefine.KNIFE_PREFAB_PATH);
            if (m_KnifePrefab == null)
            {
                Debug.LogError(GetType() + "/LoadPrefab()/ prefab  is  null, path = " + ResPathDefine.KNIFE_PREFAB_PATH);
            }
            else {
                m_KnifeTrans = GameObject.Instantiate(m_KnifePrefab,m_SpawnKnifePosTrans).transform;
                m_KnifeTrans.position = Vector3.forward * GameConfig.GAME_OBJECT_Z_VALUE;
                m_KnifeTrans.gameObject.SetActive(false);
            }
        }

        /// <summary>
        /// 游戏未结束时,鼠标按下更新刀锋
        /// </summary>
        void UpdateShowKnife() {
            if (m_KnifeTrans!=null && m_IsGameOver==false)
            {
                if (Input.GetMouseButtonDown(0))
                {
                    m_KnifeTrans.position = Tools.ScreenPosToWorldPos(m_KnifeTrans, Camera.main, Input.mousePosition);
                    m_KnifeTrans.gameObject.SetActive(true);
                }
                else if (Input.GetMouseButton(0))
                {
                    m_KnifeTrans.position = Tools.ScreenPosToWorldPos(m_KnifeTrans, Camera.main, Input.mousePosition);
                }
                else if (Input.GetMouseButtonUp(0))
                {
                    m_KnifeTrans.gameObject.SetActive(false);
                }
            }
            
        }

27、在工程中添加 Model 脚本,主要功能是 分数和生命数据模型,包含数值记录,和数值变化事件委托

	/// <summary>
	/// 数据模型
	/// </summary>
	public class Model 
	{
		private int m_Value;
		public int Value
		{
			get { return m_Value; }
			set
			{
				if (m_Value != value)
				{
					m_Value = value;

					if (OnValueChanged != null)
					{
						OnValueChanged.Invoke(value);

					}
				}
			}
		}

		/// <summary>
		/// 数值变化事件
		/// </summary>
		public Action<int> OnValueChanged;
	}

28、在工程中添加 DataModelManager 脚本,主要管理 分数Score 和 生命Life

        public Model Score => m_Scroe;
        public Model Life => m_Life;

        public void Init(Transform rootTrans, params object[] manager)
        {
            m_Scroe = new Model();
            m_Scroe.Value = 0;
            m_Life = new Model();
            m_Life.Value = GameConfig.GAME_LIFE_LENGTH;
        }

29、在工程中添加 UIManager 脚本,主要管理 UI 相关获取,以及数据显示,游戏结束,按钮事件重新加载游戏

        private Text m_LifeText;
        private Text m_ScoreText;
        private GameObject m_GameOverImageGo;
        private Button m_RestartGameButton;

        private DataModelManager m_DataModelManager;
        public void Init(Transform rootTrans, params object[] managers)
        {
            m_LifeText = rootTrans.Find(GameObjectPathInSceneDefine.UI_LIFE_TEXT_PATH).GetComponent<Text>();
            m_ScoreText = rootTrans.Find(GameObjectPathInSceneDefine.UI_SCORE_TEXT_PATH).GetComponent<Text>();
            m_GameOverImageGo = rootTrans.Find(GameObjectPathInSceneDefine.UI_GAME_OVER_IMAGE_PATH).gameObject;
            m_RestartGameButton = rootTrans.Find(GameObjectPathInSceneDefine.UI_RESTART_GAME_BUTTON_PATH).GetComponent<Button>();

            m_DataModelManager = managers[0] as DataModelManager;

            m_GameOverImageGo.SetActive(false);
            m_LifeText.text = m_DataModelManager.Life.Value.ToString();
            m_ScoreText.text = m_DataModelManager.Score.Value.ToString();
            m_DataModelManager.Life.OnValueChanged += OnLifeValueChanged;
            m_DataModelManager.Score.OnValueChanged += OnScroeValueChanged;
            m_RestartGameButton.onClick.AddListener(OnRestartButton);
        }

        public void OnGameOver()
        {
            m_GameOverImageGo.SetActive(true);
        }

        private void OnLifeValueChanged(int life)
        {
            m_LifeText.text = life.ToString();
        }

        private void OnScroeValueChanged(int score)
        {
            m_ScoreText.text = score.ToString();
        }

        private void OnRestartButton()
        {
            SceneManager.LoadScene(SceneManager.GetActiveScene().name);
        }

30、在工程中添加 GameManager 脚本(单例脚本),主要功能:1)获取场景中相关游戏物体或者 UI,2)new 相关的 Manager 管理类,初始化Init,Update 、和Destroy;3)定时生成水果和炸弹;4)判断游戏是否结束;

        /// <summary>
        /// 底部生成
        /// </summary>
        private void BottomSpawnFruitAndBomb()
        {
            GameObject go = null;
            // 随机数,判断生成水果还是炸弹
            int ran = Random.Range(GameConfig.FRUIT_RANDOM_MIN_VALUE, GameConfig.FRUIT_RANDOM_MAX_VALUE);
            if (ran != GameConfig.BOMB_RANDOM_VALUE)
            {
                BaseFruit fruit = m_FruitManager.GetRandomFruit();
                fruit.Init(m_FruitManager, m_SplashManager, m_DataModelManager);
                go = fruit.gameObject;
            }
            else
            {
                Bomb bomb = m_BmobManager.GetBmob();
                bomb.Init(m_BmobManager,m_BombEffectManager,m_DataModelManager);
                go = bomb.gameObject;
            }

            
            // 生成物体的位置和,向上速度
            go.transform.position = new Vector3(Random.Range(m_Bottom_Spawn_X_Min, m_Bottom_Spawn_X_Max), m_Bottom_Spawn_Y, GameConfig.GAME_OBJECT_Z_VALUE);
            go.transform.rotation = Quaternion.identity;
            go.GetComponent<Rigidbody>().velocity = new Vector2(0, Random.Range(GameConfig.FRUIT_UP_Y_VELOSITY_MIN_VALUE,
                GameConfig.FRUIT_UP_Y_VELOSITY_MAX_VALUE));

        }

        /// <summary>
        /// 判断游戏是否结束
        /// </summary>
        /// <param name="life"></param>
        void JudageGameOverByLife(int life) {
            if (life == GameConfig.REMAIN_LIFE_IS_GAME_OVER)
            {
                OnGameOver();
            }
        }

        /// <summary>
        /// 结束的操作
        /// </summary>
        void OnGameOver() {
            m_IsGameOver = true;
            m_UIManager.OnGameOver();
            m_KnifeManager.OnGameOver();
        }

31、在工程中添加 GameStart 脚本,整个游戏的入口,管理对应 GameManager 的 Awake(),Start(),Update(),OnDestroy() 对应函数功能

    /// <summary>
    /// 游戏入口
    /// </summary>
	public class GameStart : MonoBehaviour
	{
        private void Awake()
        {
            GameManager.Instance.Awake(this);
        }

        // Start is called before the first frame update
        void Start()
		{
            GameManager.Instance.Start();
        }

		// Update is called once per frame
		void Update()
		{
            GameManager.Instance.Update();
        }

        private void OnDestroy()
        {
            GameManager.Instance.Destroy();
        }
     }

32、在场景中添加 GameObject 空物体,改名为 GameStart,并且挂载 GameStart 脚本

34、运行游戏,自动生水果,按下鼠标,既可以切割水果了

八、工程源码地址

github 地址:GitHub - XANkui/UnityMiniGameParadise: Unity 游戏开发集合代码集

的 MGP_005CutFruit 工程

九、延伸扩展

游戏的好不好玩,趣味性,视觉化等诸多因素影响,下面简单介绍几个方面拓展游戏的方向,仅做参考

1、可以根据自己需要修改游戏资源,换肤什么的等

2、可以根据需要添加加分特效,音效,背景更多的细节变化等等

3、添加 UI 面板等,美化游戏

4、Effect 可以设置不同类型的的特效,或者3D 粒子特效

5、特殊水果特殊事件,冰冻,火烧等;

6、添加最高分数保留,和游戏排行榜等;

7、炸弹的特效,可以进行设置不同炸弹,不同特效;

8、水果生成只设置底部生成,可以添加两侧生成也生成水果炸弹等

9、可以是设置,不同波数的水果数量,和间歇频次,定时游戏时间

10、等等
 

标签:忍者,水果,const,void,private,Unity,PATH,public
来源: https://blog.csdn.net/u014361280/article/details/122616242