NLDClient-yudde/ProjectNLD/Assets/Code/Scripts/Gameplay/Bounds/Data/CombineSingleBounds.cs

using System.Collections.Generic;
using Code.Scripts.Gameplay.Enviorment;
using Gameplay.Buff;
using Gameplay.Character;
using Gameplay.Unit;
using Gameplay.Unit.Data;

namespace Utils.Bounds.Data
{
    using cfg.BoundsCfg;

    public class CombineSingleBounds
    {

        public int tagId;
        public int triggerCount;

        public List<DataBounds> rawConfigs;

        public CombineSingleBounds(DataBounds data)
        {
            rawConfigs = new List<DataBounds>();
            tagId = (int)data.BoundTag;
            triggerCount = data.TriggerCount;

            rawConfigs.Add(data);
        }

        public void AddBounds(DataBounds data)
        {
            rawConfigs.Add(data);
        }

        private bool _FilterLevelWeather(List<int> weatherIds)
        {
            if (weatherIds.Count == 0)
            {
                return true;
            }
            var nowLevelWeatherId = EnviormentManager.instance.currentWeatherId;
            return weatherIds.Contains(nowLevelWeatherId);
        }
        
        private bool _FilterLevelTerrain(List<int> terrainIds)
        {
            if (terrainIds.Count == 0)
            {
                return true;
            }
            var nowLevelTerrainId = EnviormentManager.instance.currentLevelTerrainId;
            return terrainIds.Contains(nowLevelTerrainId);
        }

        private bool _FilterUnitTag(EBoundsTarget targetType,
            GameUnit unit)
        {
            if (unit.statusData.isDead) return false;
            switch (targetType)
            {
                case EBoundsTarget.SameTag:
                    // 只针对同tag的单位
                    // 只有角色才有tag
                    if (unit.gameunitType == EGameUnitType.Character
                        && unit.commonData.troopId == ETroopsId.Self)
                    {
                        if (unit is Character character)
                        {
                            var cTags = character.runtimeData.configData.boundTags;
                            if (cTags.Contains(tagId))
                            {
                                return true;
                            }
                        }
                    }
                    break;
                case EBoundsTarget.AllEnemySide:
                    // 只针对敌方单位
                    if (unit.commonData.troopId != ETroopsId.Self)
                    {
                        return true;
                    }
                    break;
                case EBoundsTarget.AllSelfSide:
                    // 只针对己方单位
                    if (unit.commonData.troopId == ETroopsId.Self)
                    {
                        return true;
                    }
                    break;
                default:
                    DebugUtil.LogError("暂未处理的羁绊类型:{0}", targetType);
                    break;
            }
            return false;
        }

        private List<GameUnit> _FilterUnits(EBoundsTarget targetType)
        {
            var result = new List<GameUnit>();
            var allUnits = GameUnitManager.instance.infightUnits;
            for (int i = 0; i < allUnits.count; i++)
            {
                var unit = allUnits.GetByIndex(i);
                if (unit == null) continue;
                if (unit.statusData.isDead) continue;
                var canAdd = _FilterUnitTag(targetType, unit);
                if (canAdd)
                {
                    result.Add(unit);
                }
            }
            return result;
        }

        public void TriggerAdd(GameUnit unit)
        {
            for (int i = 0; i < rawConfigs.Count; i++)
            {
                var rawConfig = rawConfigs[i];
                var filterType = rawConfig.TargetType;
                var canAdd = _FilterUnitTag(filterType, unit);
                if (!canAdd) continue;
                canAdd = _FilterLevelWeather(rawConfig.TriggerWeatherIds);
                if (!canAdd) continue;
                canAdd = _FilterLevelTerrain(rawConfig.TriggerLevelTerrianIds);
                if (!canAdd) continue;
                var buffIds = rawConfig.BuffIds;
                for (int k = 0; k < buffIds.Count; k++)
                {
                    var buffId = buffIds[k];
                    var createBuff = BuffManager.instance.CreateBuffById(unit, buffId);
                    unit.buffManager.AddBuff(createBuff);
                }
            }
        }

        public void TriggerRemove(GameUnit unit)
        {
            for (int i = 0; i < rawConfigs.Count; i++)
            {
                var filterType = rawConfigs[i].TargetType;
                var canRemove = _FilterUnitTag(filterType, unit);
                if (!canRemove) continue;
                canRemove = _FilterLevelWeather(rawConfigs[i].TriggerWeatherIds);
                if (!canRemove) continue;
                canRemove = _FilterLevelTerrain(rawConfigs[i].TriggerLevelTerrianIds);
                if (!canRemove) continue;
                var buffIds = rawConfigs[i].BuffIds;
                for (int k = 0; k < buffIds.Count; k++)
                {
                    var buffId = buffIds[k];
                    unit.buffManager.RemoveBuffById(buffId);
                }
            }
        }

    }
}