5.2 commit

.github/workflows/nuitka-app.yml

@@ -26,7 +26,7 @@ jobs:
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install - ./requirements.txt
+        pip install -r ./requirements.txt
     - uses: Nuitka/Nuitka-Action@main
       with:
         nuitka-version: main

base/skill.py

@@ -168,7 +168,7 @@ class Skill:
         else:
             self._skill_shield_gain = [skill_shield_gain]
 
-    def record(self, current_frame, player_id, skill_level, skill_stack, critical, parser):
+    def record(self, skill_level, skill_stack, critical, parser):
         pass
 
     def __call__(self, attribute: Attribute):
@@ -184,38 +184,33 @@ class BuffConsumeSkill(Skill):
 
 
 class DotSkill(Skill):
-    def record(self, current_frame, player_id, skill_level, skill_stack, critical, parser):
-        super().record(current_frame, player_id, skill_level, skill_stack, critical, parser)
+    def record(self, skill_level, skill_stack, critical, parser):
+        super().record(skill_level, skill_stack, critical, parser)
         bind_skill = self.bind_skill
-        if not parser.ticks[player_id][bind_skill]:
-            parser.stacks[player_id][bind_skill] = 0
-        parser.ticks[player_id][bind_skill] = self.tick
-        parser.stacks[player_id][bind_skill] = min(parser.stacks[player_id][bind_skill] + 1, self.max_stack)
-        parser.snapshot[player_id][bind_skill] = parser.status[player_id].copy()
+        if not parser.current_ticks[bind_skill]:
+            parser.current_stacks[bind_skill] = 0
+        parser.current_ticks[bind_skill] = self.tick
+        parser.current_stacks[bind_skill] = min(parser.current_stacks[bind_skill] + 1, self.max_stack)
+        parser.current_snapshot[bind_skill] = parser.current_status.copy()
 
 
 class DotConsumeSkill(Skill):
-    def record(self, current_frame, player_id, skill_level, skill_stack, critical, parser):
-        super().record(current_frame, player_id, skill_level, skill_stack, critical, parser)
+    def record(self, skill_level, skill_stack, critical, parser):
+        super().record(skill_level, skill_stack, critical, parser)
         bind_skill = self.bind_skill
-        skill_tuple, status_tuple = parser.last_dot[player_id][bind_skill]
+        skill_tuple, status_tuple = parser.current_last_dot[bind_skill]
         skill_id, skill_level, skill_stack = skill_tuple
-        parser.ticks[player_id][skill_id] += 1
-        tick = min(parser.ticks[player_id][skill_id], self.tick)
-        current_record = parser.records[player_id][-1]
-        current_record[(skill_id, skill_level, skill_stack * tick)][status_tuple].append(
-            current_record[skill_tuple][status_tuple].pop()
+        parser.current_ticks[skill_id] += 1
+        tick = min(parser.current_ticks[skill_id], self.tick)
+        parser.current_records[(skill_id, skill_level, skill_stack * tick)][status_tuple].append(
+            parser.current_records[skill_tuple][status_tuple].pop()
         )
-        parser.ticks[player_id][skill_id] -= tick
+        parser.current_ticks[skill_id] -= tick
 
 
 class PureSkill(Skill):
     def __call__(self, attribute: Attribute):
-        damage = init_result(
-            self.damage_base, self.damage_rand,
-            0, 0,
-            0, 0, 0, 0
-        )
+        damage = init_result(self.damage_base, self.damage_rand, 0, 0, 0, 0, 0, 0)
 
         damage = level_reduction_result(damage, attribute.level_reduction)
         damage = vulnerable_result(damage, attribute.vulnerable)
@@ -326,22 +321,21 @@ class MixingSkill(Skill):
 
 
 class Damage(Skill):
-    def record(self, current_frame, player_id, skill_level, skill_stack, critical, parser):
-        super().record(current_frame, player_id, skill_level, skill_stack, critical, parser)
+    def record(self, skill_level, skill_stack, critical, parser):
+        super().record(skill_level, skill_stack, critical, parser)
         skill_tuple = (self.skill_id, skill_level, skill_stack)
-        status_tuple = parser.available_status(player_id, self.skill_id)
-        current_record = parser.records[player_id][-1]
-        current_record[skill_tuple][status_tuple].append(
-            (current_frame - parser.start_time[player_id][-1], critical)
+        status_tuple = parser.available_status(self.skill_id)
+        parser.current_records[skill_tuple][status_tuple].append(
+            (parser.current_frame - parser.start_frame, critical)
         )
         return skill_tuple, status_tuple
 
 
 class DotDamage(Damage):
-    def record(self, current_frame, player_id, skill_level, skill_stack, critical, parser):
-        skill_tuple, status_tuple = super().record(current_frame, player_id, skill_level, skill_stack, critical, parser)
-        parser.last_dot[player_id][self.skill_id] = (skill_tuple, status_tuple)
-        parser.ticks[player_id][self.skill_id] -= 1
+    def record(self, skill_level, skill_stack, critical, parser):
+        skill_tuple, status_tuple = super().record(skill_level, skill_stack, critical, parser)
+        parser.current_last_dot[self.skill_id] = (skill_tuple, status_tuple)
+        parser.current_ticks[self.skill_id] -= 1
 
 
 class PetDamage(Damage):

qt/app.py

@@ -82,7 +82,7 @@ class MainWindow(QMainWindow):
         equipments = equipments_script(self.equipments_widget)
         consumables = consumables_script(self.consumable_widget)
         bonuses = bonuses_script(parser, self.bonus_widget)
-        dashboard_script(parser, self.top_widget, self.dashboard_widget,
+        dashboard_script(parser, self.dashboard_widget,
                          talents, recipes, equipments, consumables, bonuses)
 
 

qt/components/dashboard.py

@@ -32,8 +32,6 @@ class DashboardWidget(QWidget):
         top_layout = QHBoxLayout()
         layout.addLayout(top_layout)
 
-        self.fight_select = ComboWithLabel("选择战斗")
-        top_layout.addWidget(self.fight_select)
         self.target_level = ComboWithLabel("目标等级", items=[str(level) for level in SHIELD_BASE_MAP])
         top_layout.addWidget(self.target_level)
         self.duration = DoubleSpinWithLabel("战斗时长", maximum=3600, value=180)

qt/scripts/dashboard.py

@@ -46,24 +46,15 @@ def detail_content(detail: Detail):
     return damage_content, gradient_content
 
 
-def dashboard_script(parser: Parser, top_widget: TopWidget,
+def dashboard_script(parser: Parser,
                      dashboard_widget: DashboardWidget, talents: Talents, recipes: Recipes,
                      equipments: Equipments, consumables: Consumables, bonuses: Bonuses):
 
-    def select_fight(text):
-        player_id = parser.current_player
-        index = parser.record_index[player_id][text]
-        dashboard_widget.duration.set_value(parser.duration(player_id, index))
-
-    dashboard_widget.fight_select.combo_box.currentTextChanged.connect(select_fight)
-
     def formulate():
         duration = dashboard_widget.duration.spin_box.value()
-        player_id = parser.current_player
-        record_index = dashboard_widget.fight_select.combo_box.currentText()
-        record = parser.records[player_id][parser.record_index[player_id][record_index]]
+        record = parser.current_records
+        school = parser.school[parser.current_player]
 
-        school = parser.school[player_id]
         attribute = school.attribute()
         attribute.target_level = int(dashboard_widget.target_level.combo_box.currentText())
         for attr, value in equipments.attrs.items():

qt/scripts/top.py

@@ -46,9 +46,7 @@ def top_script(
         config_choices = list(CONFIG.get(school.school, {}))
         config_widget.config_select.set_items(config_choices, default_index=-1)
         """ Update dashboard """
-        record_index = list(parser.record_index[player_id])
-        dashboard_widget.fight_select.set_items(record_index, default_index=0)
-        dashboard_widget.duration.set_value(parser.duration(player_id, parser.record_index[player_id][record_index[0]]))
+        dashboard_widget.duration.set_value(parser.duration)
 
         """ Update talent options """
         for i, talent_widget in enumerate(talents_widget.values()):

schools/__init__.py

@@ -8,16 +8,6 @@ from base.skill import Skill
 
 from schools import bei_ao_jue, shan_hai_xin_jue, ling_hai_jue, wu_fang, gu_feng_jue, tai_xu_jian_yi, tian_luo_gui_dao
 
-SKILL_TYPE = Tuple[int, int, int]
-BUFFER_TYPE = Tuple[int, int, int, bool]
-# BUFFER_TYPE = Tuple[int, int]
-BUFF_TYPE = Tuple[int, int, int]
-TIMELINE_TYPE = List[Tuple[int, bool]]
-SUB_RECORD_TYPE = Dict[Tuple[tuple, tuple], TIMELINE_TYPE]
-RECORD_TYPE = Dict[SKILL_TYPE, SUB_RECORD_TYPE]
-STATUS_TYPE = Dict[Tuple[int, int], int]
-SNAPSHOT_TYPE = Dict[int, STATUS_TYPE]
-
 
 @dataclass
 class School:

utils/parser.py

@@ -4,6 +4,19 @@ from base.constant import FRAME_PER_SECOND
 from schools import *
 from utils.lua import parse
 
+FRAME_TYPE, PLAYER_ID_TYPE, PLAYER_NAME_TYPE, PET_ID_TYPE = int, int, int, int
+SKILL_ID_TYPE, SKILL_LEVEL_TYPE, SKILL_STACK_TYPE, SKILL_CRITICAL_TYPE = int, int, int, bool
+SKILL_BUFFER_TYPE = Tuple[SKILL_ID_TYPE, SKILL_LEVEL_TYPE, SKILL_STACK_TYPE, SKILL_CRITICAL_TYPE]
+SKILL_TYPE = Tuple[SKILL_ID_TYPE, SKILL_LEVEL_TYPE, SKILL_STACK_TYPE]
+BUFF_ID_TYPE, BUFF_LEVEL_TYPE, BUFF_STACK_TYPE = int, int, int
+STATUS_BUFFER_TYPE = Tuple[BUFF_ID_TYPE, BUFF_LEVEL_TYPE]
+STATUS_TYPE = Tuple[BUFF_ID_TYPE, BUFF_LEVEL_TYPE, BUFF_STACK_TYPE]
+
+SNAPSHOT_TYPE = Dict[SKILL_ID_TYPE, List[STATUS_TYPE]]
+
+TIMELINE_TYPE = List[Tuple[FRAME_TYPE, SKILL_CRITICAL_TYPE]]
+SUB_RECORD_TYPE = Dict[Tuple[tuple, tuple], TIMELINE_TYPE]
+RECORD_TYPE = Dict[SKILL_TYPE, SUB_RECORD_TYPE]
 
 LABEL_MAPPING = {
     2: "远程武器",
@@ -21,71 +34,89 @@ LABEL_MAPPING = {
 }
 EMBED_MAPPING: Dict[tuple, int] = {(5, 24449 - i): 8 - i for i in range(8)}
 
-BUFFER_DELAY = 2
+BUFFER_DELAY = -2
 
 
 class Parser:
-    current_player: int
-    current_frame: int
+    current_player: PLAYER_ID_TYPE
+    current_frame: FRAME_TYPE
+    frames: List[FRAME_TYPE]
 
-    id2name: Dict[int, str]
-    name2id: Dict[str, int]
-    records: Dict[int, List[RECORD_TYPE]]
-    buffers: Dict[int, Dict[int, List[BUFFER_TYPE]]]
-    status: Dict[int, STATUS_TYPE]
-    snapshot: Dict[int, SNAPSHOT_TYPE]
-    last_dot: Dict[int, Dict[int, Tuple[Tuple[int, int, int], Tuple[tuple, tuple]]]]
-    stacks: Dict[int, Dict[int, int]]
-    ticks: Dict[int, Dict[int, int]]
-    pets: Dict[int, int]
+    id2name: Dict[PLAYER_ID_TYPE, PLAYER_NAME_TYPE]
+    name2id: Dict[PLAYER_NAME_TYPE, PLAYER_ID_TYPE]
+    pets: Dict[PET_ID_TYPE, PLAYER_ID_TYPE]
+    records: Dict[PLAYER_ID_TYPE, RECORD_TYPE]
 
-    start_time: Dict[int, List[int]]
-    end_time: Dict[int, List[int]]
-    record_index: Dict[int, Dict[str, int]]
+    skills: Dict[FRAME_TYPE, Dict[PLAYER_ID_TYPE, List[SKILL_BUFFER_TYPE]]]
+    status_buffer: Dict[PLAYER_ID_TYPE, Dict[STATUS_BUFFER_TYPE, Tuple[BUFF_STACK_TYPE, FRAME_TYPE]]]
+    status: Dict[FRAME_TYPE, Dict[PLAYER_ID_TYPE, List[STATUS_TYPE]]]
 
-    select_talents: Dict[int, List[int]]
-    select_equipments: Dict[int, Dict[int, Dict[str, int | list]]]
+    stacks: Dict[PLAYER_ID_TYPE, Dict[SKILL_ID_TYPE, int]]
+    ticks: Dict[PLAYER_ID_TYPE, Dict[SKILL_ID_TYPE, int]]
 
-    school: Dict[int, School]
+    snapshot: Dict[PLAYER_ID_TYPE, SNAPSHOT_TYPE]
+    last_dot: Dict[PLAYER_ID_TYPE, Dict[SKILL_ID_TYPE, Tuple[SKILL_TYPE, Tuple[tuple, tuple]]]]
 
-    def duration(self, player_id, i):
-        return round((self.end_time[player_id][i] - self.start_time[player_id][i]) / FRAME_PER_SECOND, 3)
+    start_frame: FRAME_TYPE
+    end_frame: FRAME_TYPE
 
-    def available_status(self, player_id, skill_id):
-        current_status = []
-        for (buff_id, buff_level), buff_stack in self.status[player_id].items():
-            buff = self.school[player_id].buffs[buff_id]
-            if buff.gain_attributes:
-                current_status.append((buff_id, buff_level, buff_stack))
-            elif buff.gain_skills and skill_id in buff.gain_skills:
-                current_status.append((buff_id, buff_level, buff_stack))
+    select_talents: Dict[PLAYER_ID_TYPE, List[int]]
+    select_equipments: Dict[PLAYER_ID_TYPE, Dict[int, Dict[str, int | list]]]
 
-        snapshot_status = []
-        for (buff_id, buff_level), buff_stack in self.snapshot[player_id].get(skill_id, {}).items():
-            buff = self.school[player_id].buffs[buff_id]
-            if buff.gain_attributes:
-                snapshot_status.append((buff_id, buff_level, buff_stack))
-            elif buff.gain_skills and skill_id in buff.gain_skills:
-                snapshot_status.append((buff_id, buff_level, buff_stack))
+    school: Dict[PLAYER_ID_TYPE, School]
 
-        return tuple(current_status), tuple(snapshot_status)
+    @property
+    def current_records(self):
+        return self.records[self.current_player]
+
+    @property
+    def current_skills(self):
+        return self.skills[self.current_frame][self.current_player]
+
+    @property
+    def current_status(self):
+        return self.status[self.current_frame][self.current_player]
+
+    @property
+    def current_snapshot(self):
+        return self.snapshot[self.current_player]
+
+    @property
+    def current_stacks(self):
+        return self.stacks[self.current_player]
+
+    @property
+    def current_ticks(self):
+        return self.ticks[self.current_player]
+
+    @property
+    def current_last_dot(self):
+        return self.last_dot[self.current_player]
+
+    @property
+    def duration(self):
+        return round((self.end_frame - self.start_frame) / FRAME_PER_SECOND, 3)
 
     def reset(self):
         self.current_frame = 0
 
+        self.frames = []
+
         self.id2name = {}
         self.name2id = {}
-        self.records = defaultdict(list)
-        self.buffers = defaultdict(lambda: defaultdict(list))
-        self.status = defaultdict(dict)
+        self.pets = {}
+        self.records = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
+
+        self.skills = defaultdict(lambda: defaultdict(list))
+        self.status_buffer = defaultdict(dict)
+        self.status = defaultdict(lambda: defaultdict(list))
+
+        self.stacks = defaultdict(lambda: defaultdict(lambda: 1))
+        self.ticks = defaultdict(lambda: defaultdict(lambda: 0))
         self.snapshot = defaultdict(dict)
         self.last_dot = defaultdict(dict)
-        self.stacks = defaultdict(lambda: defaultdict(lambda: 1))
-        self.ticks = defaultdict(lambda: defaultdict(int))
-        self.pets = {}
 
-        self.start_time = defaultdict(list)
-        self.end_time = defaultdict(list)
+        self.start_frame = 0
 
         self.select_talents = {}
         self.select_equipments = {}
@@ -131,18 +162,8 @@ class Parser:
         if player_id in self.school:
             self.pets[pet_id] = player_id
 
-    def parse_time(self, row):
-        detail = row.strip("{}").split(",")
-        player_id = int(detail[0])
-        if player_id not in self.school:
-            return
-        if detail[1] == "true" and len(self.start_time[player_id]) == len(self.end_time[player_id]):
-            self.start_time[player_id].append(self.current_frame)
-            self.records[player_id].append(defaultdict(lambda: defaultdict(list)))
-        elif detail[1] == "false" and len(self.start_time[player_id]) - len(self.end_time[player_id]) == 1:
-            self.end_time[player_id].append(self.current_frame)
-
     def parse_buff(self, row):
+
         detail = row.strip("{}").split(",")
         player_id = int(detail[0])
         if player_id not in self.school:
@@ -150,10 +171,26 @@ class Parser:
         buff_id, buff_stack, buff_level = int(detail[4]), int(detail[5]), int(detail[8])
         if buff_id not in self.school[player_id].buffs:
             return
-        if not buff_stack:
-            self.status[player_id].pop((buff_id, buff_level), None)
-        else:
-            self.status[player_id][(buff_id, buff_level)] = buff_stack
+
+        if (buff_id, buff_level) in self.status_buffer[player_id]:
+            buffer_stack, start_frame = self.status_buffer[player_id][(buff_id, buff_level)]
+            if buff_stack == buffer_stack:
+                return
+            for frame in range(start_frame + BUFFER_DELAY, self.current_frame + BUFFER_DELAY):
+                self.status[frame][player_id].append((buff_id, buff_level, buffer_stack))
+            self.status_buffer[player_id].pop((buff_id, buff_level))
+
+            # self.status_buffer[player_id][(buff_id, buff_level, buffer_stack)] = self.status_buffer[player_id].get(
+            #     (buff_id, buff_level, buffer_stack), []) + [(start_frame, self.current_frame)]
+        if buff_stack:
+            self.status_buffer[player_id][(buff_id, buff_level)] = (buff_stack, self.current_frame)
+
+    def clear_status_buffer(self):
+        self.end_frame = self.current_frame
+        for player_id, status in self.status_buffer.items():
+            for (buff_id, buff_level), (buff_stack, start_frame) in status.items():
+                for frame in range(start_frame + BUFFER_DELAY, self.end_frame + BUFFER_DELAY):
+                    self.status[frame][player_id].append((buff_id, buff_level, buff_stack))
 
     def parse_skill(self, row):
         detail = row.strip("{}").split(",")
@@ -169,30 +206,34 @@ class Parser:
         if react or skill_id not in self.school[player_id].skills:
             return
         skill_stack = self.stacks[player_id][skill_id]
-        self.buffers[self.current_frame][player_id].append((skill_id, skill_level, skill_stack, critical))
-
-        if len(self.start_time[player_id]) == len(self.end_time[player_id]):
-            self.start_time[player_id].append(self.current_frame)
-            self.records[player_id].append(defaultdict(lambda: defaultdict(list)))
-
-    def record(self, current_frame, player_id, skill_id, skill_level, skill_stack, critical):
-        skill = self.school[player_id].skills[skill_id]
-        skill.record(current_frame, player_id, skill_level, skill_stack, critical, self)
-
-    def parse_record(self):
-        last_frame = self.current_frame - BUFFER_DELAY
-        pop_frames = [frame for frame in self.buffers if frame <= last_frame]
-        for pop_frame in pop_frames:
-            for player_id, buffers in self.buffers.pop(pop_frame).items():
-                for buffer_tuple in buffers:
-                    self.record(pop_frame, player_id, *buffer_tuple)
-
-    # def parse_buffer(self):
-    #     frames = [frame for frame in self.buffers if frame <= self.current_frame]
-    #     for frame in frames:
-    #         for player_id, buffers in self.buffers.pop(frame).items():
-    #             for buffer_tuple in buffers:
-    #                 self.status[player_id].pop(buffer_tuple, None)
+
+        self.skills[self.current_frame][player_id].append((skill_id, skill_level, skill_stack, critical))
+
+        if not self.start_frame:
+            self.start_frame = self.current_frame
+
+    def available_status(self, skill_id):
+        current_status = []
+        for buff_id, buff_level, buff_stack in self.current_status:
+            buff = self.school[self.current_player].buffs[buff_id]
+            if buff.gain_attributes:
+                current_status.append((buff_id, buff_level, buff_stack))
+            elif buff.gain_skills and skill_id in buff.gain_skills:
+                current_status.append((buff_id, buff_level, buff_stack))
+
+        snapshot_status = []
+        for buff_id, buff_level, buff_stack in self.current_snapshot.get(skill_id, []):
+            buff = self.school[self.current_player].buffs[buff_id]
+            if buff.gain_attributes:
+                snapshot_status.append((buff_id, buff_level, buff_stack))
+            elif buff.gain_skills and skill_id in buff.gain_skills:
+                snapshot_status.append((buff_id, buff_level, buff_stack))
+
+        return tuple(current_status), tuple(snapshot_status)
+
+    def record(self, skill_id, skill_level, skill_stack, critical):
+        skill = self.school[self.current_player].skills[skill_id]
+        skill.record(skill_level, skill_stack, critical, self)
 
     def __call__(self, file_name):
         self.reset()
@@ -202,19 +243,11 @@ class Parser:
             if row[4] == "4":
                 self.parse_info(row[-1])
 
-        for player_id, school in self.school.items():
-            for talent_id in self.select_talents[player_id]:
-                school.talent_gains[talent_id].add_skills(school.skills)
-
         for line in lines:
             row = line.split("\t")
-            if self.current_frame != int(row[1]):
-                self.parse_record()
-                self.current_frame = int(row[1])
+            self.current_frame = int(row[1])
 
             match row[4]:
-                case "5":
-                    self.parse_time(row[-1])
                 case "8":
                     self.parse_pet(row[-1])
                 case "13":
@@ -222,14 +255,26 @@ class Parser:
                 case "21":
                     self.parse_skill(row[-1])
 
+        self.clear_status_buffer()
+
+        for player_id, school in self.school.items():
+            for talent_id in self.select_talents[player_id]:
+                school.talent_gains[talent_id].add_skills(school.skills)
+
+        for frame, players in self.skills.items():
+            self.current_frame = frame
+            for player_id, skills in players.items():
+                self.current_player = player_id
+                for skill_id, skill_level, skill_stack, critical in skills:
+                    skill = self.school[player_id].skills[skill_id]
+                    skill.record(skill_level, skill_stack, critical, self)
+
         for player_id, school in self.school.items():
             for talent_id in self.select_talents[player_id]:
                 school.talent_gains[talent_id].sub_skills(school.skills)
 
-        self.record_index = {
-            player_id: {
-                f"{i + 1}:{round((end_time - self.start_time[player_id][i]) / FRAME_PER_SECOND, 3)}": i
-                for i, end_time in enumerate(self.end_time[player_id])
-            }
-            for player_id in self.end_time
-        }
+
+if __name__ == '__main__':
+    parser = Parser()
+    parser("../new.jcl")
+    print(1)