private void GenerateBattleTurns(BattleResult battle, bool isGroup = false)
        {
            battle.Statistics = new Dictionary <string, BattleStatisticsData>();
            for (int i = 0; i < battle.CombatInfo.Count; i++)
            {
                BattleTurn turn = battle.CombatInfo[i];
                turn.CurrentTurn = i + 1;
                GenerateBattleTurn(battle, turn);

                if (turn.HinjuredConmbatList != null)
                {
                    foreach (var p in turn.HinjuredConmbatList)
                    {
                        GenerateBattleTurn(battle, p, false);

                        MergeHpList(turn.HpList, p.HpList);
                    }
                }
            }
        }
        private void GenerateBattleTurn(BattleResult battle, BattleTurn turn, bool isDirect = true)
        {
            ICharacter attacker = FindBattleChar(battle, turn.Attacker);
            ICharacter target   = FindBattleChar(battle, turn.Hinjured);

            if (target != null)
            {
                turn.HpList = new List <BattleTurnHp>()
                {
                    new BattleTurnHp()
                    {
                        id  = target.Id,
                        hp  = target.Life,
                        chp = turn.SurplusHealth,
                    }
                };

                if (battle.LifeAfter.ContainsKey(target.Id))
                {
                    battle.LifeAfter[target.Id] = turn.SurplusHealth;
                }
            }
            else
            {
                turn.HpList = new List <BattleTurnHp>();
            }

            if (attacker != null)
            {
                if (!battle.Statistics.ContainsKey(attacker.Id))
                {
                    battle.Statistics.Add(attacker.Id, new BattleStatisticsData()
                    {
                        Id = attacker.Id, Name = attacker.Name
                    });
                }

                switch (turn.HurtType)
                {
                case BattleHurtType.PhysicalDamage:
                    battle.Statistics[attacker.Id].PhysicalDamage += ConvertDamage(turn.Hurt);
                    break;

                case BattleHurtType.MagicalDamage:
                    battle.Statistics[attacker.Id].MagicalDamage += ConvertDamage(turn.Hurt);
                    break;

                case BattleHurtType.DotDamage:
                    battle.Statistics[attacker.Id].DotDamage += ConvertDamage(turn.Hurt);
                    break;

                case BattleHurtType.CounterDamage:
                    battle.Statistics[attacker.Id].CounterDamage += ConvertDamage(turn.Hurt);
                    break;

                case BattleHurtType.Heal:
                    battle.Statistics[attacker.Id].Heal += ConvertDamage(turn.Hurt);
                    break;

                case null:
                    battle.Statistics[attacker.Id].NormalDamage += ConvertDamage(turn.Hurt);
                    break;

                default: break;
                }
            }
        }