1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
using UnityEngine;
using System.Collections.Generic;
using Cysharp.Threading.Tasks;
using System;
 
 
//  如果这个Action卡住了 大概率是因为 动作被其他动作中断了 导致没有回调
public class DeathRecordAction : RecordAction
{
    protected List<BattleDeadPack> deadPackList = new List<BattleDeadPack>();
 
    protected Dictionary<BattleDeadPack, SkillRecordAction> deathActionDict = new Dictionary<BattleDeadPack, SkillRecordAction>();
 
    protected Dictionary<BattleDeadPack, Func<bool>> deadActionStatesDict = new Dictionary<BattleDeadPack, Func<bool>>();
 
    protected Dictionary<int, bool> dropStateDict = new Dictionary<int, bool>();
 
    public DeathRecordAction(BattleField _battleField, List<BattleDeadPack> _deadPackList)
        : base(RecordActionType.Death, _battleField, null)
    {
        deadPackList = _deadPackList;
    }
 
 
    public override void Run()
    {
        //  该死的正常死
        //  有技能的则按照顺序播放死亡技能 后再正常死
        if (isFinish)
            return;
 
 
        if (!isRunOnce)
        {
            isRunOnce = true;
 
            foreach (var battleDeadPack in deadPackList)
            {
                if (battleDeadPack.deadTriggerSkill != null)
                {
                    var skillAction = battleDeadPack.deadTriggerSkill.CreateSkillAction();
                    if (null != skillAction)
                    {
                        deathActionDict.Add(battleDeadPack, skillAction);
                    }
                }
                else
                {
                    deadActionStatesDict.Add(battleDeadPack, CreateDeadActionState(battleDeadPack));
                }
            }
        }
        else
        {
            List<BattleDeadPack> finishedKeys = new List<BattleDeadPack>();
            foreach (var kv in deathActionDict)
            {
                if (!kv.Key.isPlaySkill)
                {
                    // battleField.recordPlayer.ImmediatelyPlay(kv.Value);
                    kv.Key.isPlaySkill = true;
                }
 
                if (!kv.Value.IsFinished())
                {
                    kv.Value.Run();
                }
                else
                {
                    deadActionStatesDict.Add(kv.Key, CreateDeadActionState(kv.Key, true));
                    finishedKeys.Add(kv.Key);
                }
                break;
            }
 
            foreach (var key in finishedKeys)
            {
                deathActionDict.Remove(key);
            }
 
            int completeNum = 0;
 
            foreach (var kv in deadActionStatesDict)
            {
                if (kv.Value())
                {
                    completeNum++;
                }
            }
 
            if (completeNum == deadPackList.Count)
            {
                isFinish = true;
            }
        }
    }
 
    private Func<bool> CreateDeadActionState(BattleDeadPack deadPack, bool withoutAnime = false)
    {
        BattleObject deadObj = battleField.battleObjMgr.GetBattleObject((int)deadPack.deadPack.ObjID);
        if (null == deadObj)
        {
            return () => true;
        }
 
        PerformDrop(deadObj);
 
        bool isComplete = false;
 
        deadObj.OnDeath(() => {
            isComplete = true;
        }, withoutAnime);
 
        return () => isComplete;
    }
 
    public override void ForceFinish()
    {
        isFinish = true;
 
        foreach (var kv in deathActionDict)
        {
            kv.Value.ForceFinish();
        }
 
        //  直接结束
        foreach (var deadPack in deadPackList)
        {
            BattleObject deadObj = battleField.battleObjMgr.GetBattleObject((int)deadPack.deadPack.ObjID);
            if (null != deadObj)
            {
                PerformDrop(deadObj);
            }
            deadObj.SetDeath();
        }
 
        base.ForceFinish();
    }
 
    private void PerformDrop(BattleObject deadObj)
    {
        //  只有主线掉落物品
        if (battleField.MapID == 1 || battleField.MapID == 2)
        {
            if (dropStateDict.ContainsKey(deadObj.ObjID))
            {
                return;
            }
            dropStateDict.Add(deadObj.ObjID, true);
            deadObj.PerformDrop();
        }
    }
}