Tower Defense Toolkit 学习

代码太多,就不贴了.用到的基本已注释.

游戏中的数据存放在Resources/Database中.游戏运行时,通过Resources.Load加载

UI构成

 

对象池

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

namespace VoidGame {

    /// <summary>
    /// 对象池管理类
    /// </summary>
    public class ObjectPoolManager : MonoBehaviour {
        /// <summary>
        /// ObjectPoolManager单例
        /// </summary>
        public static ObjectPoolManager m_instance;
        /// <summary>
        /// 对象池列表
        /// </summary>
        public List<ObjectPool> m_objectPoolList = new List<ObjectPool>();


        private void Awake() {
            m_instance = this;
        }

        /// <summary>
        /// 获取对象池管理类所属游戏物体的transform
        /// </summary>
        /// <returns>transform</returns>
        public Transform GetTransform() {
            return transform;
        }

        /// <summary>
        /// 孵化
        /// </summary>
        /// <param name="prefabGo">预设游戏物体</param>
        /// <param name="position">位置</param>
        /// <param name="rotation">旋转</param>
        /// <returns>游戏物体</returns>
        public GameObject Spawn(GameObject prefabGo,Vector3 position,Quaternion rotation) {
            if(prefabGo == null) {
                Debug.Log("NullReferenceException.");
                return null;
            }
            //查找是否已经有使用此预设的对象池
            int index = GetObjectPoolIndex(prefabGo);

            //没找到,新建
            if(index == -1) {
                index = New(prefabGo);
            }

            //返回
            return m_objectPoolList[index].Spawn(position,rotation);
        }

        /// <summary>
        /// 回收
        /// </summary>
        /// <param name="go">要回收的游戏对象</param>
        public void Unspawn(GameObject go) {
            //遍历所有对象池,回收此对象
            for(int i = 0;i < m_objectPoolList.Count;i++) {
                if(m_objectPoolList[i].Unspawn(go)) {
                    return;
                }
            }
            //没有在对象池中找到此对象,直接删除
            Destroy(go);
        }

        /// <summary>
        /// 新建游戏对象
        /// </summary>
        /// <param name="prefabGo">游戏对象预设</param>
        /// <param name="count">数量</param>
        /// <returns>返回此对象所在的对象池列表索引</returns>
        public int New(GameObject prefabGo,int count = 2) {
            //新建对象池
            ObjectPool pool = new ObjectPool();
            //设置对象池的预设对象为此对象
            pool.m_prefabGo = prefabGo;
                
            pool.MatchObjectCount(count);
            //添加此对象池到对象池列表
            m_objectPoolList.Add(pool);
            int index = m_objectPoolList.Count - 1;
            return index;
        }

        /// <summary>
        /// 获取游戏物体所在对象池的位置.没有找到返回-1
        /// </summary>
        /// <param name="prefabGo">预设游戏物体</param>
        /// <returns>返回游戏预设所在的对象池索引,没找到返回-1</returns>
        private int GetObjectPoolIndex(GameObject prefabGo) {
            for(int i = 0;i < m_objectPoolList.Count;i++) {
                if(m_objectPoolList[i].m_prefabGo == prefabGo) {
                    return i;
                }
            }
            return -1;
        }

        /// <summary>
        /// 清空
        /// </summary>
        public void Clear() {
            for(int i = 0;i < m_instance.m_objectPoolList.Count;i++) {
                m_objectPoolList[i].Clear();
            }
            m_objectPoolList = new List<ObjectPool>();
        }
    }

    /// <summary>
    /// 对象池类
    /// </summary>
    [System.Serializable]
    public class ObjectPool {
        /// <summary>
        /// 这个对象池使用的预设
        /// </summary>
        public GameObject m_prefabGo;

        /// <summary>
        /// 活动游戏物体列表
        /// </summary>
        public List<GameObject> m_activeGoList = new List<GameObject>();
        /// <summary>
        /// 非活动游戏物体列表
        /// </summary>
        public List<GameObject> m_inactiveGoList = new List<GameObject>();

        /// <summary>
        /// 上限
        /// </summary>
        public int m_cap = 1000;

        /// <summary>
        /// 孵化
        /// </summary>
        /// <param name="position">位置</param>
        /// <param name="rotation">旋转</param>
        /// <returns></returns>
        public GameObject Spawn(Vector3 position,Quaternion rotation) {
            GameObject go = null;
            //如果非活动物体列表的数量为0创建一个新的物体
            if(m_inactiveGoList.Count == 0) {
                go = (GameObject)Object.Instantiate(m_prefabGo,position,rotation);
            } else {
                //保存非活动物体列表中第一个对象的引用
                go = m_inactiveGoList[0];
                go.transform.parent = null;
                go.transform.position = position;
                go.transform.rotation = rotation;
                go.SetActive(true);
                //移除非活动物体列表的第一个元素
                m_inactiveGoList.RemoveAt(0);
            }
            //将物体添加到活动物体列表
            m_activeGoList.Add(go);
            return go;
        }

        /// <summary>
        /// 回收
        /// </summary>
        /// <param name="go">要回收的游戏物体</param>
        /// <returns></returns>
        public bool Unspawn(GameObject go) {
            //如果活动游戏物体列表包含要回收的游戏对象
            if(m_activeGoList.Contains(go)) {
                go.SetActive(false);
                //设置物体的父物体为游戏管理物体
                go.transform.parent = ObjectPoolManager.m_instance.GetTransform();
                //从活动物体列表中移除这个物体
                m_activeGoList.Remove(go);
                //将这个对象添加到非活动物体列表
                m_inactiveGoList.Add(go);
                return true;
            }
            return false;
        }

        /// <summary>
        /// 匹配对象池的数量,即填充(count - currentcount)个对象池中非活动物体列表
        /// </summary>
        /// <param name="count">非活动游戏物体的对象</param>
        public void MatchObjectCount(int count) {
            //数量大于上限返回
            if(count > m_cap) {
                return;
            }
            //获取对象池内当前游戏对象的总量
            int currentCount = GetTotalObjectCount();
            for(int i = currentCount;i < count;i++) {
                //实例化对象
                GameObject go = Object.Instantiate(m_prefabGo);
                go.SetActive(false);
                //设置父对象
                go.transform.parent = ObjectPoolManager.m_instance.GetTransform();
                //将对象添加到非活动物体列表
                m_inactiveGoList.Add(go);
            }
        }

        /// <summary>
        /// 获取所有的游戏物体数量
        /// </summary>
        /// <returns>游戏物体数量</returns>
        public int GetTotalObjectCount() {
            //非活动列表的对象总数+活动列表中的对象总数
            return m_inactiveGoList.Count + m_activeGoList.Count;
        }

        /// <summary>
        /// 清空所有的游戏对象
        /// </summary>
        public void Clear() {
            //销毁非活动物体列表中的对象
            for(int i = 0;i < m_inactiveGoList.Count;i++) {
                if(m_inactiveGoList[i] != null) {
                    Object.Destroy(m_inactiveGoList[i]);
                }
            }
            //销毁活动物体列表中的对象
            for(int i = 0;i < m_activeGoList.Count;i++) {
                if(m_activeGoList[i] != null) {
                    Object.Destroy(m_inactiveGoList[i]);
                }
            }
        }
    }

游戏中的单位:

资源管理: 

能力系统:玩家在游戏界面点击能力按钮,选择目标然后释放

建造管理:当玩家点击一个平台时,显示可以建造的塔按钮列表,点击其中一个塔按钮开始建造.

孵化管理:

路径:

游戏视频:https://pan.baidu.com/s/1gfkhnRd

游戏项目:https://pan.baidu.com/s/1mhQujws