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;
using System;

[Serializable]
public struct CreaterControl
{
    public bool isCreated;
    public GameMapTile tile;
    public int spawnTimeId;
    public Vector3 pos;
}


public class EnemyCreater : MonoBehaviour
{
    public static EnemyCreater instance;
    public List<CreaterControl> createCharacter = new();
    public Dictionary<int, List<Enemy>> enemyDic;
    public Dictionary<int, List<GameObject>> buildingDic;
    private LevelSelect.Level curLevel;
    public GameMapsAsset mapsAsset;

    //import
    public LevelSelect levelSelect;


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

    private void Start()
    {
        levelSelect = GetComponent<LevelSelect>();
        curLevel = GetComponent<LevelSelect>().levelConfig[levelSelect.curLevelID - 1];
        LoadMapAsset(0);

        //把所有怪物prefab生成一遍防止后面初次生成卡顿
        //foreach (var item in createCharacter)
        //{
        //    for(int i = 0; i < item.tile.spawnTime[item.spawnTimeId].num; i++)
        //    {
        //        CreateEnemy(item.tile, Vector3.zero, 1, 1,false);
        //    }
        //}
    }


    public void refreshHasOut(GameMap map)
    {
        for (int i = 0; i < map.LayerCount; i++)
        {
            int[] grid = map.GetlayerData(i);
            int idx = 0;
            for (int y = 0; y < map.height; y++)
            {
                for (int x = 0; x < map.width; x++)
                {
                    GameMapTile t = mapsAsset.tileAsset.GetTile(grid[idx++]);
                    if (t == null) continue;
                    t.hasOut = false;
                    t.index = -1;
                }
            }
        }
    }

    public void LoadMapAsset(int mapIdx)
    {
        GameMap map = mapsAsset.maps[mapIdx];
        refreshHasOut(map);
        for (int i = 0; i < map.LayerCount; i++)
        {
            int[] grid = map.GetlayerData(i);
            int idx = 0;
            for (int y = 0; y < map.height; y++)
            {
                for (int x = 0; x < map.width; x++)
                {
                    GameMapTile t = mapsAsset.tileAsset.GetTile(grid[idx++]);
                    if (t == null) continue;
                    if (!t.hasOut)
                    {
                        t.hasOut = true;
                        for (int j = 0; j < t.spawnTime.Length; j++)
                        {
                            CreaterControl createrControl = new();
                            createrControl.isCreated = false;
                            createrControl.tile = t;
                            createrControl.spawnTimeId = j;
                            createrControl.pos = new Vector3(x, y, 0);
                            createCharacter.Add(createrControl);
                        }
                    }
                }
            }
        }
    }

    public void OnGameTimeChange(float gameTime)
    {
        for (int i = 0; i < createCharacter.Count; i++)
        {
            GameMapTile gameMapTile = createCharacter[i].tile;
            if (gameMapTile.spawnTime[createCharacter[i].spawnTimeId].startTime <= gameTime && !createCharacter[i].isCreated)
            {
                CreaterControl createrControl = createCharacter[i];
                createrControl.isCreated = true;
                createCharacter[i] = createrControl;
                StartCreateEnemy(createCharacter[i]);
            }
        }
    }

    public async void StartCreateEnemy(CreaterControl createrControl)
    {
        SpawnTime spawnTime = createrControl.tile.spawnTime[createrControl.spawnTimeId];
        for (int i = 0; i < spawnTime.num; i++)
        {
            if (!instance)
            {
                return;
            }
            CreateEnemy(createrControl.tile, createrControl.pos, 1, 1);
            float TimeInterval = (float)(spawnTime.endTime - spawnTime.startTime) / (spawnTime.num - 1);
            await Task.Delay((int)(TimeInterval * 1000));
        }
    }


    public GameObject CreateEnemy(GameMapTile gameMapTile, Vector3 pos, float hpRatio, float attackRatio, bool active = true)
    {
        string enemyStr = $"Prefab/{Enum.GetName(typeof(GameMapTile.Type), gameMapTile.type)}/{gameMapTile.ch}";
        GameObject enemyObj = Util.Instantiate(enemyStr, pos, active: active);
        Parameter parameter = gameMapTile.parameter;
        AttackInfo attackInfo;
        switch (gameMapTile.type)
        {
            case GameMapTile.Type.Tower:
                EnemyTower enemyTower = enemyObj.GetComponent<EnemyTower>();
                Tower tower = enemyObj.GetComponent<Tower>();
                if (enemyTower != null)
                {
                    enemyTower.id = gameMapTile.id;

                    enemyTower.totalHp = (int)(parameter.HP * hpRatio);
                    enemyTower.hp = enemyTower.totalHp;

                    attackInfo = enemyTower.Attack_summonInfos[0];
                    attackInfo.damage = (int)(parameter.Attack_summon * attackRatio);
                    enemyTower.Attack_summonInfos[0] = attackInfo;
                    enemyTower.Init();
                }
                if (tower != null)
                {
                    tower.id = gameMapTile.id;

                    tower.totalHp = (int)(parameter.HP * hpRatio);
                    tower.hp = tower.totalHp;

                    attackInfo = enemyTower.Attack_summonInfos[0];
                    attackInfo.damage = (int)(parameter.Attack_summon * attackRatio);
                    tower.Attack_summonInfos[0] = attackInfo;
                    tower.Init();
                }
                if (!buildingDic.ContainsKey(gameMapTile.id))
                {
                    buildingDic.Add(gameMapTile.id, new List<GameObject>());
                }
                buildingDic[gameMapTile.id].Add(enemyObj);

                break;
            case GameMapTile.Type.Enemy:
                Enemy enemy = enemyObj.GetComponent<Enemy>();
                enemy.id = gameMapTile.id;
                if (!enemyDic.ContainsKey(gameMapTile.id))
                {
                    enemyDic.Add(gameMapTile.id, new List<Enemy>());
                }
                enemyDic[gameMapTile.id].Add(enemy);

                enemy.totalHp = (int)(parameter.HP * hpRatio);
                enemy.hp = enemy.totalHp;
                enemy.minMoveSpeed = parameter.MinMoveSpeed;
                enemy.maxMoveSpeed = parameter.MaxMoveSpeed;
                attackInfo = enemy.Attack_summonInfos[0];
                attackInfo.damage = (int)(parameter.Attack_summon * attackRatio);
                enemy.Attack_summonInfos[0] = attackInfo;

                attackInfo = enemy.Attack_marchInfos[0];
                attackInfo.damage = (int)(parameter.Attack_march * attackRatio);
                enemy.Attack_marchInfos[0] = attackInfo;

                if (enemy.canFly)
                {
                    enemy.flyHeight = enemy.transform.position.y;
                }
                enemy.Init();
                enemy.SetSortingOrder(enemy.baseSortingOrder + enemyDic[gameMapTile.id].Count);
                break;
        }
        enemyObj.transform.position = pos;
        return enemyObj;
    }

    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;
    }
}