geometry-tower-defense/Assets/GameMain/Scripts/CustomComponent/CombatNode/EnemyManager/EnemyConfigProvider.cs

using System;
using GameFramework.DataTable;
using GeometryTD.DataTable;
using UnityEngine;
using UnityGameFramework.Runtime;

namespace GeometryTD.CustomComponent
{
    public sealed class EnemyConfigProvider
    {
        private const int DefaultEnemyConfigId = 1;

        private IDataTable<DREnemy> _drEnemy;
        private bool _enemyConfigMissingLogged;

        public void Reset()
        {
            _drEnemy = null;
            _enemyConfigMissingLogged = false;
        }

        public DREnemy GetEnemyConfig(int enemyId)
        {
            if (_drEnemy == null)
            {
                _drEnemy = GameEntry.DataTable.GetDataTable<DREnemy>();
                if (_drEnemy == null)
                {
                    if (!_enemyConfigMissingLogged)
                    {
                        Log.Warning("EnemyConfigProvider can not find DREnemy data table.");
                        _enemyConfigMissingLogged = true;
                    }

                    return null;
                }
            }

            if (enemyId > 0)
            {
                DREnemy targetConfig = _drEnemy.GetDataRow(enemyId);
                if (targetConfig != null)
                {
                    return targetConfig;
                }
            }

            DREnemy defaultConfig = _drEnemy.GetDataRow(DefaultEnemyConfigId);
            if (defaultConfig != null)
            {
                return defaultConfig;
            }

            DREnemy[] allConfigs = _drEnemy.GetAllDataRows();
            if (allConfigs.Length > 0)
            {
                return allConfigs[0];
            }

            if (!_enemyConfigMissingLogged)
            {
                Log.Warning("EnemyConfigProvider found no enemy configs.");
                _enemyConfigMissingLogged = true;
            }

            return null;
        }

        public int ResolveScaledEnemyBaseHp(int baseHp, CombatScheduler combatScheduler)
        {
            int resolvedBaseHp = Mathf.Max(1, baseHp);
            int completedLoopCount = ResolveCompletedLoopCount(combatScheduler);
            if (completedLoopCount <= 0)
            {
                return resolvedBaseHp;
            }

            double scaled = resolvedBaseHp * Math.Pow(2d, completedLoopCount);
            if (scaled >= int.MaxValue)
            {
                return int.MaxValue;
            }

            return Math.Max(1, (int)Math.Round(scaled));
        }

        private static int ResolveCompletedLoopCount(CombatScheduler combatScheduler)
        {
            if (combatScheduler == null)
            {
                return 0;
            }

            int phaseCount = combatScheduler.PhaseCount;
            int displayPhaseIndex = combatScheduler.DisplayPhaseIndex;
            if (phaseCount <= 0 || displayPhaseIndex <= 0)
            {
                return 0;
            }

            return Mathf.Max(0, (displayPhaseIndex - 1) / phaseCount);
        }
    }
}