ActionTowerDefense/ActionTowerDefense/Assets/Scripts/Characters/SearchTrigger.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Net;
using UnityEngine;
using UnityEngine.TextCore.Text;
using uTools;

public class SearchTrigger : MonoBehaviour
{
    public Character owner;

    public List<BeSearchTrigger> trigDemonicList;
    public List<BeSearchTrigger> trigTowerList;
    public List<BeSearchTrigger> trigPlayerList;
    public List<BeSearchTrigger> trigEnemyList;
    public List<BeSearchTrigger> trigEnemyTowerList;
    public List<BeSearchTrigger> trigBossList;
    public Dictionary<TargetType, List<BeSearchTrigger>> trigCharacterDic;
    Dictionary<TargetType, bool> targetTypeDic;

    public bool needToChange;
    public float maxLen, minLen;    //col大小
    private BoxCollider col;
    private Vector3 origSize;

    private void Awake()
    {
        owner = GetComponentInParent<Character>();
        trigCharacterDic = new Dictionary<TargetType, List<BeSearchTrigger>>
        {
            { TargetType.Demonic, trigDemonicList },
            { TargetType.Tower, trigTowerList },
            { TargetType.Player, trigPlayerList },
            { TargetType.Enemy, trigEnemyList },
            { TargetType.EnemyTower, trigEnemyTowerList },
            { TargetType.Boss, trigBossList },
        };
        targetTypeDic = new Dictionary<TargetType, bool>();
        for (int i = 0; i < owner.attackController.targetTypes.Count; i++)
        {
            if (!targetTypeDic.ContainsKey(owner.attackController.targetTypes[i]))
            {
                targetTypeDic.Add(owner.attackController.targetTypes[i], true);
            }
        }
    }

    private void Start()
    {
        if (needToChange)
        {
            col = GetComponent<BoxCollider>();
            origSize = col.size;
            col.size = new Vector3(UnityEngine.Random.Range(minLen, maxLen), origSize.y, origSize.z);
        }
    }

    private void OnDisable()
    {
        for (int i = 0; i < owner.attackController.targetTypes.Count; i++)
        {
            if (trigCharacterDic.ContainsKey(owner.attackController.targetTypes[i]))
            {
                trigCharacterDic[owner.attackController.targetTypes[i]].Clear();
            }
        }
    }

    private void FixedUpdate()
    {
        for (int i = 0; i < owner.attackController.targetTypes.Count; i++)
        {
            if (trigCharacterDic.ContainsKey(owner.attackController.targetTypes[i]))
            {
                List<BeSearchTrigger> trigList = trigCharacterDic[owner.attackController.targetTypes[i]];
                for (int j = trigList.Count - 1; j >= 0; j--)
                {
                    if (trigList[j] == null || !trigList[j].enabled || !trigList[j].gameObject.activeInHierarchy || trigList[j].owner.isDie)
                    {
                        if (trigList[j].owner == owner.targetCharacter)
                        {
                            owner.targetCharacter = null;
                        }
                        trigList.RemoveAt(j);
                    }
                }
            }
        }
    }

    private void OnTriggerEnter(Collider other)
    {
        BeSearchTrigger trigger = other.GetComponent<BeSearchTrigger>();
        if (trigger)
        {
            TargetType otherTargetType = (TargetType)Enum.Parse(typeof(TargetType), trigger.owner.tag);
            if (HasTargetType(otherTargetType) && trigCharacterDic.ContainsKey(otherTargetType))
            {
                trigCharacterDic[otherTargetType].Add(trigger);
            }
        }
    }

    private void OnTriggerExit(Collider other)
    {
        BeSearchTrigger trigger = other.GetComponent<BeSearchTrigger>();
        if (trigger)
        {
            TargetType otherTargetType = (TargetType)Enum.Parse(typeof(TargetType), trigger.owner.tag);
            if (HasTargetType(otherTargetType) && trigCharacterDic.ContainsKey(otherTargetType))
            {
                if (trigger.owner == owner.targetCharacter)
                {
                    owner.targetCharacter = null;
                }
                trigCharacterDic[otherTargetType].Remove(trigger);
            }
        }
    }

    public bool HasTargetType(TargetType targetType)
    {
        return targetTypeDic.ContainsKey(targetType);
    }

    public List<Character> GetAllTargets(List<TargetType> targetTypes, bool canHitFly)
    {
        List<Character> list = new List<Character>();
        for (int i = 0; i < targetTypes.Count; i++)
        {
            if (trigCharacterDic.ContainsKey(targetTypes[i]))
            {
                List<BeSearchTrigger> trigList = trigCharacterDic[targetTypes[i]];
                switch (targetTypes[i])
                {
                    case TargetType.Demonic:
                        for (int j = 0; j < trigList.Count; j++)
                        {
                            Character character = trigList[j].owner;
                            if (!character.gameObject.activeInHierarchy || character.isDie)
                            {
                                continue;
                            }
                            if (owner == character)
                            {
                                continue;
                            }
                            Demonic demonic = trigList[j].owner as Demonic;
                            if (demonic.canFly && !canHitFly)
                            {
                                continue;
                            }
                            list.Add(trigList[j].owner);
                        }
                        break;
                    case TargetType.Enemy:
                        for (int j = 0; j < trigList.Count; j++)
                        {
                            Character character = trigList[j].owner;
                            if (!character.gameObject.activeInHierarchy || character.isDie)
                            {
                                continue;
                            }
                            if (owner == character)
                            {
                                continue;
                            }
                            Enemy enemy = trigList[j].owner as Enemy;
                            if (enemy.canFly && !canHitFly)
                            {
                                continue;
                            }
                            list.Add(trigList[j].owner);
                        }
                        break;
                    case TargetType.Tower:
                    case TargetType.Player:
                    case TargetType.EnemyTower:
                    case TargetType.Boss:
                        for (int j = 0; j < trigList.Count; j++)
                        {
                            Character character = trigList[j].owner;
                            if (!character.gameObject.activeInHierarchy || character.isDie)
                            {
                                continue;
                            }
                            if (owner == character)
                            {
                                continue;
                            }
                            list.Add(trigList[j].owner);
                        }
                        break;
                    default:
                        break;
                }
            }
        }
        return list;
    }

    public Character GetMinDisTarget(List<TargetType> targetTypes, bool canHitFly,SearchMode searchMode)
    {
        if (!enabled || !gameObject.activeInHierarchy)
        {
            return null;
        }
        List<Character> list = GetAllTargets(targetTypes, canHitFly);
        switch (searchMode)
        {
            case SearchMode.MinDistance:
                Character minDisChar = null;
                float minDistance = -1;
                for (int i = 0; i < list.Count; i++)
                {
                    Character character = list[i];
                    //判断对象是否在远程单位的射击夹角范围内
                    AttackController.AttackMethod am = owner.attackController.curAttackMethod;
                    if (am.attackType == AttackController.AttackType.Shoot)
                    {
                        float up = am.maxUpAngle;
                        float down = am.maxDownAngle;
                        Vector3 dir = character.beSearchTrigger.transform.position - transform.position;
                        float angle = Vector3.Angle(dir, Vector3.left * owner.bodyTrans.localScale.x);
                        if ((dir.y > 0 && angle > up) || (dir.y < 0 && angle > down))
                        {
                            continue;
                        }
                    }
                    //判断是否在攻击范围内
                    float distance = Mathf.Abs(character.transform.position.x - owner.transform.position.x);
                    if (minDisChar == null || minDistance == -1 || minDistance > distance)
                    {
                        minDisChar = character;
                        minDistance = distance;
                    }
                }
                return minDisChar;
            case SearchMode.MaxDistance:
                Character maxDisChar = null;
                float maxDistance = -1;
                for (int i = 0; i < list.Count; i++)
                {
                    Character character = list[i];
                    //判断对象是否在远程单位的射击夹角范围内
                    AttackController.AttackMethod am = owner.attackController.curAttackMethod;
                    if (am.attackType == AttackController.AttackType.Shoot)
                    {
                        float up = am.maxUpAngle;
                        float down = am.maxDownAngle;
                        Vector3 dir = character.beSearchTrigger.transform.position - transform.position;
                        float angle = Vector3.Angle(dir, Vector3.left * owner.bodyTrans.localScale.x);
                        if ((dir.y > 0 && angle > up) || (dir.y < 0 && angle > down))
                        {
                            continue;
                        }
                    }
                    //判断是否在攻击范围内
                    float distance = Mathf.Abs(character.transform.position.x - owner.transform.position.x);
                    if (maxDisChar == null || maxDistance == -1 || maxDistance < distance)
                    {
                        maxDisChar = character;
                        maxDistance = distance;
                    }
                }
                Debug.Log(maxDisChar);
                return maxDisChar;
            case SearchMode.MinHp:
                Character minHPChar = null;
                for (int i = 0; i < list.Count; i++)
                {
                    Character character = list[i];
                    //判断对象是否在远程单位的射击夹角范围内
                    AttackController.AttackMethod am = owner.attackController.curAttackMethod;
                    if (am.attackType == AttackController.AttackType.Shoot)
                    {
                        float up = am.maxUpAngle;
                        float down = am.maxDownAngle;
                        Vector3 dir = character.beSearchTrigger.transform.position - transform.position;
                        float angle = Vector3.Angle(dir, Vector3.left * owner.bodyTrans.localScale.x);
                        if ((dir.y > 0 && angle > up) || (dir.y < 0 && angle > down))
                        {
                            continue;
                        }
                    }
                    if (minHPChar == null || minHPChar.hp < character.hp)
                    {
                        minHPChar = character;
                    }
                }
                return minHPChar;
            case SearchMode.MaxHp:
                Character maxHPChar = null;
                for (int i = 0; i < list.Count; i++)
                {
                    Character character = list[i];
                    //判断对象是否在远程单位的射击夹角范围内
                    AttackController.AttackMethod am = owner.attackController.curAttackMethod;
                    if (am.attackType == AttackController.AttackType.Shoot)
                    {
                        float up = am.maxUpAngle;
                        float down = am.maxDownAngle;
                        Vector3 dir = character.beSearchTrigger.transform.position - transform.position;
                        float angle = Vector3.Angle(dir, Vector3.left * owner.bodyTrans.localScale.x);
                        if ((dir.y > 0 && angle > up) || (dir.y < 0 && angle > down))
                        {
                            continue;
                        }
                    }
                    if (maxHPChar == null || maxHPChar.hp > character.hp)
                    {
                        maxHPChar = character;
                    }
                }
                return maxHPChar;
            case SearchMode.ByType:
                break;
        }
        //Character minDisChar = null;
        //float minDistance = -1;
        //for (int i = 0; i < list.Count; i++)
        //{
        //    Character character = list[i];
        //    //判断对象是否在远程单位的射击夹角范围内
        //    AttackController.AttackMethod am = owner.attackController.curAttackMethod;
        //    if (am.attackType == AttackController.AttackType.Shoot)
        //    {
        //        float up = am.maxUpAngle;
        //        float down = am.maxDownAngle;
        //        Vector3 dir = character.beSearchTrigger.transform.position - transform.position;
        //        float angle = Vector3.Angle(dir, Vector3.left * owner.bodyTrans.localScale.x);
        //        if ((dir.y > 0 && angle > up) || (dir.y < 0 && angle > down))
        //        {
        //            continue;
        //        }
        //    }
        //    //判断是否在攻击范围内
        //    float distance = Mathf.Abs(character.transform.position.x - owner.transform.position.x);
        //    if (minDisChar == null || minDistance == -1 || minDistance > distance)
        //    {
        //        minDisChar = character;
        //        minDistance = distance;
        //    }
        //}
        return null;
    }

    public Character GetMinHPCharacter(List<TargetType> targetTypes, bool canHitFly)
    {
        List<Character> list = GetAllTargets(targetTypes, canHitFly);

        Character minHPChar = null;
        for (int i = 0; i < list.Count; i++)
        {
            Character character = list[i];
            if (minHPChar == null || minHPChar.hp > character.hp)
            {
                minHPChar = character;
            }
        }
        return minHPChar;
    }
}

public enum SearchMode
{
    MinDistance,
    MaxDistance,
    MinHp,
    MaxHp,
    ByType
}