ActionTowerDefense/ActionTowerDefense/Assets/Scripts/EnemyCreater.cs

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using cfg;
using System.Threading.Tasks;
using Base.Common;
using System.Linq;

public class EnemyCreater : MonoBehaviour
{
    public static EnemyCreater instance;
    [SerializeField]public List<SingleCreateEnemyConfig> cfgCreateEnemy;
    public List<SingleCreateBuildingConfig> cfgCreateBuilding;
    public List<bool> createdEnemy;
    public List<float> createEnemyTime;
    public List<bool> createdBuilding;
    public List<float> createBuildingTime;
    public Dictionary<int, List<Enemy>> enemyDic;
    public Dictionary<int, GameObject> buildingDic;
    private LevelSelect.Level curLevel;

    [Header("传送门")]
    public float portalsCreateTime = 10;           //传送门提前出现时间
    public Transform portalUIParent;               //传送门出现提示UI的父物体

    private void Awake()
    {
        if (!instance)
        {
            instance = this;
        }
        else
        {
            DestroyImmediate(gameObject);
            return;
        }
        enemyDic = new Dictionary<int, List<Enemy>>();
        buildingDic = new Dictionary<int, GameObject>();
    }

    private void Start()
    {
        curLevel = GetComponent<LevelSelect>().levelConfig[GetComponent<LevelSelect>().curLevelID];
        cfgCreateEnemy = GameManager.instance.allCfgData.CfgCreateEnemy.DataList;
        cfgCreateBuilding = GameManager.instance.allCfgData.CfgCreateBuilding.DataList;
        createdEnemy = new List<bool>();
        createdBuilding = new List<bool>();
        for (int i = 0; i < cfgCreateEnemy.Count; i++)
        {
            createdEnemy.Add(false);
            createEnemyTime.Add(cfgCreateEnemy[i].Time);
        }
        for (int i = 0; i < cfgCreateBuilding.Count; i++)
        {
            createdBuilding.Add(false);
            createBuildingTime.Add(cfgCreateBuilding[i].Time);
        }
    }

    public void OnGameTimeChange(float gameTime)
    {
        for (int i = 0; i < cfgCreateEnemy.Count; i++)
        {
            if (cfgCreateEnemy[i].LevelID == curLevel.enemyExcelID)
            {
                if (createEnemyTime[i] != 0)
                {
                    if (createEnemyTime[i] + cfgCreateEnemy[i].DelayTime <= gameTime && !createdEnemy[i])
                    {
                        createdEnemy[i] = true;
                        StartCreateEnemy(i);
                    }
                }
                else
                {
                    GameObject result = null;
                    buildingDic.TryGetValue(cfgCreateEnemy[i].BuildingID, out result);
                    if (result != null)
                    {
                        //根据防御塔血量出怪
                        EnemyTower enemyTower = result.GetComponent<EnemyTower>();
                        if (enemyTower != null && !createdEnemy[i] && enemyTower.hp * 100 <= enemyTower.totalHp * cfgCreateEnemy[i].BuildingHP)
                        {
                            if (cfgCreateEnemy[i].DelayTime == 0)
                            {
                                createdEnemy[i] = true;
                                StartCreateEnemy(i);
                            }
                            else
                            {
                                createEnemyTime[i] = gameTime;
                            }
                        }
                        //根据传送门血量出怪
                        CoreCharacter coreCharacter = result.GetComponentInChildren<CoreCharacter>();
                        PortalsCreater portalsCreater = result.GetComponent<PortalsCreater>();
                        if (coreCharacter != null && !createdEnemy[i] && portalsCreater.createTimeCountDown < 0 && coreCharacter.hp * 100 <= coreCharacter.totalHp * cfgCreateEnemy[i].BuildingHP)
                        {
                            if (cfgCreateEnemy[i].DelayTime == 0)
                            {
                                createdEnemy[i] = true;
                                StartCreateEnemy(i);
                            }
                            else
                            {
                                createEnemyTime[i] = gameTime;
                            }
                        }
                    }
                }
            }
        }
        for (int i = 0; i < cfgCreateBuilding.Count; i++)
        {
            if (cfgCreateBuilding[i].LevelID == curLevel.buildingExcelID)
            {
                if (createBuildingTime[i] != 0)
                {
                    if (!createdBuilding[i]
                    && (cfgCreateBuilding[i].Type == 0 && createBuildingTime[i] + cfgCreateBuilding[i].DelayTime - portalsCreateTime <= gameTime
                    || cfgCreateBuilding[i].Type == 1 && createBuildingTime[i] + cfgCreateBuilding[i].DelayTime <= gameTime))
                    {
                        createdBuilding[i] = true;
                        if (gameTime < portalsCreateTime)
                        {
                            StartCreateBuilding(i, createBuildingTime[i] - gameTime);
                        }
                        else
                        {
                            StartCreateBuilding(i, portalsCreateTime);
                        }

                    }
                }
                else
                {
                    GameObject result = null;
                    buildingDic.TryGetValue(cfgCreateBuilding[i].RefreshBuildingID, out result);
                    if (result != null)
                    {
                        //根据防御塔血量出怪
                        EnemyTower enemyTower = result.GetComponent<EnemyTower>();
                        if (enemyTower != null && !createdBuilding[i] && enemyTower.hp * 100 <= enemyTower.totalHp * cfgCreateBuilding[i].RefreshBuildingHP)
                        {
                            if (cfgCreateBuilding[i].DelayTime == 0)
                            {
                                createdBuilding[i] = true;
                                StartCreateBuilding(i, portalsCreateTime);
                            }
                            else
                            {
                                createBuildingTime[i] = gameTime;
                            }
                        }
                        //根据传送门血量出怪
                        CoreCharacter coreCharacter = result.GetComponentInChildren<CoreCharacter>();
                        PortalsCreater portalsCreater = result.GetComponent<PortalsCreater>();
                        if (coreCharacter != null && !createdBuilding[i] && portalsCreater.createTimeCountDown < 0 && coreCharacter.hp * 100 <= coreCharacter.totalHp * cfgCreateBuilding[i].RefreshBuildingHP)
                        {
                            if (cfgCreateBuilding[i].DelayTime == 0)
                            {
                                createdBuilding[i] = true;
                                StartCreateBuilding(i, portalsCreateTime);
                            }
                            else
                            {
                                createBuildingTime[i] = gameTime;
                            }
                        }
                    }
                }
            }
        }
    }

    public void StartCreateBuilding(int id,float createTime)
    {
        SingleCreateBuildingConfig singleCreateBuilding = cfgCreateBuilding[id];
        if (!instance)
        {
            return;
        }
        switch (singleCreateBuilding.Type)
        {
            case 0:
                List<float> pos = singleCreateBuilding.Position.Concat(singleCreateBuilding.Position1).ToList();
                CreatePortal(singleCreateBuilding.ID, singleCreateBuilding.BuildingID, pos, singleCreateBuilding.Scale, singleCreateBuilding.HPRatio, createTime, singleCreateBuilding.DisappearTime);
                break;
            case 1:
                Vector3 positon = new Vector3(singleCreateBuilding.Position[0], singleCreateBuilding.Position[1], singleCreateBuilding.Position[2]);
                CreateEnemyTower(singleCreateBuilding.ID, singleCreateBuilding.BuildingID, singleCreateBuilding.HPRatio, singleCreateBuilding.AttackRatio, positon, singleCreateBuilding.DisappearTime);
                break;
        }
    }

    public async void StartCreateEnemy(int id)
    {
        SingleCreateEnemyConfig singleCreateEnemy = cfgCreateEnemy[id];
        for (int i = 0; i < singleCreateEnemy.Count; i++)
        {
            if (!instance)
            {
                return;
            }
            Vector3 pos = Vector3.zero;
            switch (singleCreateEnemy.Type)
            {
                case 0:
                    pos = new Vector3(
                            singleCreateEnemy.Position[0],
                            singleCreateEnemy.Position[1]
                                + Random.Range(-singleCreateEnemy.YRandomRange / 2, singleCreateEnemy.YRandomRange / 2),
                            singleCreateEnemy.Position[2]
                                + Random.Range(-singleCreateEnemy.ZRandomRange / 2, singleCreateEnemy.ZRandomRange / 2));
                    break;
                case 1:
                    GameObject building = buildingDic[singleCreateEnemy.BuildingID];
                    pos = building.transform.position;
                    pos.y += Random.Range(0, singleCreateEnemy.YRandomRange);
                    pos.z += Random.Range(0, singleCreateEnemy.ZRandomRange);
                    PortalsCreater portalsCreater = building.GetComponent<PortalsCreater>();
                    if (portalsCreater != null)
                    {
                        portalsCreater.enemyNumber -= 1;
                        portalsCreater.enemyNumberText.text = portalsCreater.enemyNumber.ToString();
                    }
                    break;
            }
            CreateEnemy(singleCreateEnemy.EnemyID, pos, singleCreateEnemy.HPRatio, singleCreateEnemy.AttackRatio);
            await Task.Delay((int)(singleCreateEnemy.TimeInterval * 1000));
        }
    }

    public void CreateEnemyTower(int ID, int buildingID, float hpRatio, float attackRatio, Vector3 pos, float disappearTime)
    {
        SingleBuildingConfig cfgBuilding = GameManager.instance.allCfgData.CfgBuilding.Get(buildingID);
        GameObject towerObj = Util.Instantiate(cfgBuilding.BuildingPrefab);
        towerObj.transform.position = pos;
        EnemyTower enemyTower = towerObj.GetComponent<EnemyTower>();
        buildingDic.Add(ID, towerObj);
        enemyTower.totalHp = (int)(cfgBuilding.HP * hpRatio);
        enemyTower.hp = enemyTower.totalHp;
        AttackInfo attackInfo = enemyTower.attack1Infos[0];
        attackInfo.damage = (int)(cfgBuilding.Attack * attackRatio);
        enemyTower.attack1Infos[0] = attackInfo;
        if(disappearTime > 0)
        {
            enemyTower.haveDisappearTime = true;
            enemyTower.disappearTime = disappearTime;
        }
    }

    public void CreatePortal(int ID, int buildingID, List<float> pos, List<float> scale, float hpRatio, float createTime, float disappearTime)
    {
        SingleBuildingConfig cfgBuilding = GameManager.instance.allCfgData.CfgBuilding.Get(buildingID);
        GameObject portalObj = Util.Instantiate(cfgBuilding.BuildingPrefab);
        PortalsCreater portalsCreater = portalObj.GetComponent<PortalsCreater>();
        portalsCreater.id = ID;
        buildingDic.Add(ID, portalObj);
        portalsCreater.totalHp = (int)(cfgBuilding.HP * hpRatio);
        portalsCreater.enemyCreater = this;
        portalsCreater.portalUIParent = portalUIParent;
        portalsCreater.Init(pos,scale,createTime);
        if (portalsCreater.enemyNumber == 0)
        {
            portalsCreater.enemyNumberText.transform.parent.gameObject.SetActive(false);
            if (portalsCreater.onlyEnemy)
            {
                portalsCreater.coreCharacter.CoreBreak();
            }
        }
        if(disappearTime > 0)
        {
            portalsCreater.haveDisappearTime = true;
            portalsCreater.disappearTime = disappearTime + createTime;
        }
    }

    public void CreateEnemy(int enemyId, Vector3 pos, float hpRatio, float attackRatio)
    {
        SingleEnemyConfig cfgEnemy = GameManager.instance.allCfgData.CfgEnemy.Get(enemyId);
        GameObject enemyObj = Util.Instantiate(cfgEnemy.EnemyPrefab, pos);
        if (enemyId > 1000)
        {
            Boss boss = enemyObj.GetComponentInChildren<Boss>();
        }
        else
        {
            Enemy enemy = enemyObj.GetComponent<Enemy>();
            enemy.id = enemyId;
            if (!enemyDic.ContainsKey(enemyId))
            {
                enemyDic.Add(enemyId, new List<Enemy>());
            }
            enemyDic[enemyId].Add(enemy);
            enemy.totalHp = (int)(cfgEnemy.HP * hpRatio);
            enemy.minMoveSpeed = cfgEnemy.MinMoveSpeed;
            enemy.maxMoveSpeed = cfgEnemy.MaxMoveSpeed;
            for (int i = 0; i < cfgEnemy.Attack1.Count; i++)
            {
                AttackInfo attackInfo = enemy.attack1Infos[i];
                attackInfo.damage = (int)(cfgEnemy.Attack1[i] * attackRatio);
                enemy.attack1Infos[i] = attackInfo;
            }
            for (int i = 0; i < cfgEnemy.Attack1.Count; i++)
            {
                AttackInfo attackInfo = enemy.attack2Infos[i];
                attackInfo.damage = (int)(cfgEnemy.Attack2[i] * attackRatio);
                enemy.attack2Infos[i] = attackInfo;
            }
            if (enemy.canFly)
            {
                enemy.flyHeight = enemy.transform.position.y;
            }
            enemy.Init();
            enemy.SetSortingOrder(enemy.baseSortingOrder + enemyDic[enemyId].Count);
        }
    }

    public void OnEnemyRecycle(Enemy enemy)
    {
        if (!enemyDic.ContainsKey(enemy.id))
        {
            return;
        }
        enemyDic[enemy.id].Remove(enemy);
        for (int i = 0; i < enemyDic[enemy.id].Count; i++)
        {
            enemyDic[enemy.id][i].SetSortingOrder(enemy.baseSortingOrder + i);
        }
    }

    public Enemy GetMinDisOtherEnemy(Enemy self)
    {
        Enemy minDisEnemy = null;
        foreach (var item in enemyDic)
        {
            for (int i = 0; i < item.Value.Count; i++)
            {
                if (item.Value[i] != self && !item.Value[i].isDie && item.Value[i].gameObject.activeInHierarchy)
                {
                    if (!minDisEnemy || (minDisEnemy.transform.position - self.transform.position).magnitude 
                        > (item.Value[i].transform.position - self.transform.position).magnitude)
                    {
                        minDisEnemy = item.Value[i];
                    }
                }
            }
        }
        return minDisEnemy;
    }
}