5.16 commit

.github/workflows/space_sync.yml

@@ -0,0 +1,22 @@
+name: Sync to Space
+on:
+  push:
+    branches: [ "gradio" ]
+  workflow_dispatch:
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          lfs: true
+      - name: Push to HuggingFace
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: git push -f https://AngoHF:[email protected]/spaces/AngoHF/Formulator gradio:main
+#      - name: Push to ModelScope
+#        env:
+#          MS_TOKEN: ${{ secrets.MS_TOKEN }}
+#        run: git push -f http://oauth2:[email protected]/studios/AngoMS/Formulator.git gradio:master

README.md

@@ -1,3 +1,14 @@
+---
+title: Formulator
+emoji: 🚀
+colorFrom: yellow
+colorTo: purple
+sdk: gradio
+sdk_version: 4.31.0
+python_version: 3.11
+app_file: app.py
+license: mit
+---
 # Comprehensive Damage Formulator with JCL Parser
 
 ## User Guide

base/buff.py

@@ -59,7 +59,7 @@ class Buff(BaseBuff):
 
     @property
     def display_name(self):
-        return f"{self.buff_name}#{self.buff_id}-{self.buff_level}-{self.buff_stack}"
+        return f"{self.buff_name}#{self.buff_id}-{self.buff_level}"
 
     def value(self, values, stackable):
         if isinstance(values, list):

base/skill.py

@@ -221,7 +221,7 @@ class Skill(BaseSkill):
         for effect in self.pre_effects:
             effect(parser)
 
-    def record(self, critical, parser):
+    def record(self, parser):
         pass
 
     def post_record(self, parser):
@@ -234,18 +234,18 @@ class Skill(BaseSkill):
         for effect in self.post_effects:
             effect(parser)
 
-    def parse(self, critical, parser):
+    def parse(self, parser):
         self.pre_record(parser)
-        self.record(critical, parser)
+        self.record(parser)
         self.post_record(parser)
 
     def __call__(self, attribute: Attribute):
-        return 0
+        return 0, 0, 0., 0
 
 
 class DotSkill(Skill):
-    def record(self, critical, parser):
-        super().record(critical, parser)
+    def record(self, parser):
+        super().record(parser)
         bind_skill = parser.current_school.skills[self.bind_skill]
         if not parser.current_dot_ticks[self.bind_skill]:
             parser.current_dot_stacks[self.bind_skill] = 0
@@ -253,7 +253,7 @@ class DotSkill(Skill):
         parser.current_dot_stacks[self.bind_skill] = min(
             parser.current_dot_stacks.get(self.bind_skill, 0) + 1, bind_skill.max_stack
         )
-        parser.current_dot_snapshot[self.bind_skill] = parser.current_buff_stacks.copy()
+        parser.current_dot_buffs[self.bind_skill] = parser.current_index
 
 
 class DotConsumeSkill(Skill):
@@ -262,19 +262,15 @@ class DotConsumeSkill(Skill):
         parser.current_next_dot[self.bind_skill] = tick
 
     def consume_last(self, parser):
-        if not (last_dot := parser.current_last_dot.pop(self.bind_skill, None)):
+        if not (last_dot_index := parser.current_last_dot.pop(self.bind_skill, None)):
             return
-        skill_tuple, status_tuple = last_dot
-        skill_id, skill_level, skill_stack = skill_tuple
-        parser.current_dot_ticks[skill_id] += 1
-        tick = min(parser.current_dot_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.current_dot_ticks[skill_id] -= tick
+        parser.current_dot_ticks[self.bind_skill] += 1
+        tick = min(parser.current_dot_ticks[self.bind_skill], self.tick)
+        parser.records.current_records[last_dot_index]['skill_stack'] *= tick
+        parser.current_dot_ticks[self.bind_skill] -= tick
 
-    def record(self, critical, parser):
-        super().record(critical, parser)
+    def record(self, parser):
+        super().record(parser)
         if self.last_dot:
             self.consume_last(parser)
         else:
@@ -282,29 +278,19 @@ class DotConsumeSkill(Skill):
 
 
 class Damage(Skill):
-    def record(self, critical, parser):
-        super().record(critical, parser)
-        skill_stack = parser.current_dot_stacks[self.skill_id]
-        skill_tuple = (self.skill_id, self.skill_level, skill_stack)
-        status_tuple = parser.status(self.skill_id)
-        parser.current_records[skill_tuple][status_tuple].append(
-            (parser.current_frame - parser.start_frame, critical)
-        )
-        return skill_tuple, status_tuple
+    pass
 
 
 class DotDamage(Damage):
-    def record(self, critical, parser):
-        skill_tuple, status_tuple = super().record(critical, parser)
-
+    def record(self, parser):
+        super().record(parser)
+        parser.current_record['skill_stack'] = parser.current_dot_stacks[self.skill_id]
+        parser.current_record['snapshot_index'] = parser.current_dot_buffs[self.skill_id]
         if tick := parser.current_next_dot.pop(self.skill_id, None):
-            _, _, skill_stack = skill_tuple
-            parser.current_records[(self.skill_id, self.skill_level, skill_stack * tick)][status_tuple].append(
-                parser.current_records[skill_tuple][status_tuple].pop()
-            )
+            parser.current_record['skill_stack'] *= tick
             parser.current_dot_ticks[self.skill_id] -= tick
         else:
-            parser.current_last_dot[self.skill_id] = (skill_tuple, status_tuple)
+            parser.current_last_dot[self.skill_id] = parser.current_index
             parser.current_dot_ticks[self.skill_id] -= 1
 
 
@@ -344,7 +330,7 @@ class PetDamage(Damage):
 
         expected_damage = critical_strike * critical_damage + (1 - critical_strike) * damage
 
-        return damage, critical_damage, expected_damage, critical_strike
+        return damage, critical_damage, critical_strike, expected_damage
 
 
 class PureSkill(Skill):
@@ -354,7 +340,7 @@ class PureSkill(Skill):
         damage = level_reduction_result(damage, attribute.level_reduction)
         damage = vulnerable_result(damage, attribute.vulnerable)
 
-        return damage, damage, damage, 0
+        return damage, damage, 0, damage
 
 
 class PhysicalSkill(Skill):
@@ -390,7 +376,7 @@ class PhysicalSkill(Skill):
 
         expected_damage = critical_strike * critical_damage + (1 - critical_strike) * damage
 
-        return damage, critical_damage, expected_damage, critical_strike
+        return damage, critical_damage, critical_strike, expected_damage
 
 
 class MagicalSkill(Skill):
@@ -426,7 +412,7 @@ class MagicalSkill(Skill):
 
         expected_damage = critical_strike * critical_damage + (1 - critical_strike) * damage
 
-        return damage, critical_damage, expected_damage, critical_strike
+        return damage, critical_damage, critical_strike, expected_damage
 
 
 class AdaptiveSkill(Skill):
@@ -462,7 +448,7 @@ class AdaptiveSkill(Skill):
 
         expected_damage = critical_strike * critical_damage + (1 - critical_strike) * damage
 
-        return damage, critical_damage, expected_damage, critical_strike
+        return damage, critical_damage, critical_strike, expected_damage
 
 
 class PureDamage(PureSkill, Damage):

gr/components/combat.py

@@ -13,21 +13,18 @@ class CombatComponent:
 
         with gr.Tab("属性"):
             with gr.Row():
-                self.init_attribute = gr.Textbox(label="初始属性")
-                self.final_attribute = gr.Textbox(label="增益后属性")
+                self.init_attribute = gr.Textbox(label="初始属性", lines=20)
+                self.final_attribute = gr.Textbox(label="增益后属性", lines=20)
         with gr.Tab("伤害总结"):
-            self.details = gr.State({})
             self.skill_select = gr.Dropdown(label="选择技能")
-            self.status_select = gr.Dropdown(label="选择增益")
+            self.status_select = gr.Dropdown(label="选择增益", multiselect=True)
             with gr.Row():
-                self.damage_detail = gr.Textbox(label="伤害细节")
-                self.damage_gradient = gr.Textbox(label="属性收益")
+                self.damage_detail = gr.Textbox(label="伤害细节", lines=10)
+                self.damage_timeline = gr.DataFrame(show_label=False, scale=4)
         with gr.Tab("战斗统计"):
             with gr.Row():
-                self.summary = gr.DataFrame(label="战斗总结", headers=["技能/次数", "命中/%", "会心/%", "伤害/%"], scale=3)
+                self.summary = gr.DataFrame(label="战斗总结", headers=["技能/次数", "命中/%", "会心/%", "伤害/%"],
+                                            show_label=False, scale=3)
                 with gr.Column(scale=1):
                     self.dps = gr.Textbox(label="每秒伤害")
                     self.gradient = gr.Textbox(label="属性收益", lines=10)
-
-
-

gr/components/top.py

@@ -4,10 +4,12 @@ import gradio as gr
 class TopComponent:
     def __init__(self):
         with gr.Row():
-            self.upload_log = gr.UploadButton("上传JCL")
             with gr.Column():
-                self.upload_json = gr.UploadButton("上传JSON")
-                self.save_json = gr.DownloadButton("保存JSON", visible=False)
-            with gr.Column(scale=2):
+                with gr.Row():
+                    self.upload_log = gr.UploadButton("上传JCL")
+                    self.upload_json = gr.UploadButton("上传JSON")
+                self.copy_json = gr.Textbox(label="复制JSON", show_copy_button=True, max_lines=2)
+
+            with gr.Column():
                 self.player_select = gr.Dropdown(label="选择角色", visible=False)
                 self.target_select = gr.Dropdown(label="选择目标", visible=False)

gr/scripts/combat.py

@@ -1,4 +1,4 @@
-from typing import Dict
+import pandas as pd
 
 from gr.components.combat import CombatComponent
 from assets.constant import ATTR_TYPE_TRANSLATE
@@ -8,11 +8,43 @@ from gr.scripts.top import Parser
 from gr.scripts.equipments import Equipments
 from gr.scripts.recipes import Recipes
 from gr.scripts.talents import Talents
-from utils.analyzer import analyze_details, Detail
+from utils.analyzer import analyze_records
 
 import gradio as gr
 
 FULL_SPACE = "\u3000"
+BUFF_CONCAT = ":"
+
+
+class Detail:
+    records: pd.DataFrame = pd.DataFrame()
+
+    skill: str = ""
+    status_set: list = []
+
+    @property
+    def current_records(self):
+        records = self.records
+        if self.skill:
+            records = records[records.skill == self.skill]
+        if self.status_set:
+            for buff in self.status_set:
+                column, stack = buff.split(BUFF_CONCAT)
+                records = records[records[column] == int(stack)]
+        return records
+
+    @property
+    def available_status(self):
+        status_set = []
+        records = self.current_records
+        for column in records.columns:
+            if "#" not in column:
+                continue
+            for stack in records[column].unique():
+                if not stack:
+                    continue
+                status_set.append(f"{column}{BUFF_CONCAT}{stack:.0f}")
+        return status_set
 
 
 def attribute_content(display_attrs, attribute):
@@ -22,47 +54,57 @@ def attribute_content(display_attrs, attribute):
         if isinstance(value, int):
             content.append(name.ljust(10, FULL_SPACE) + str(value))
         else:
-            content.append(name.ljust(10, FULL_SPACE) + f"{round(value * 100, 2)}%")
+            content.append(name.ljust(10, FULL_SPACE) + f"{value * 100:.2f}%")
     return "\n".join(content)
 
 
-def summary_content(summary: Dict[str, Detail], total_damage):
-    content = []
-    for skill in sorted(summary, key=lambda x: summary[x].expected_damage, reverse=True):
-        detail = summary[skill]
-        critical = round(detail.critical_count, 2)
-        critical_rate = round(detail.critical_count / detail.count * 100, 2)
-        hit = round(detail.count - critical, 2)
-        hit_rate = round(100 - critical_rate, 2)
-        damage = round(detail.expected_damage, 2)
-        damage_rate = round(damage / total_damage * 100, 2)
-        content.append(
-            [f"{skill}/{detail.count}",
-             f"{hit}/{hit_rate}%", f"{critical}/{critical_rate}%", f"{damage}/{damage_rate}%"]
+def summary_content(records, total_damage):
+    content = {}
+    group_records = records.groupby("skill_name")
+    sum_expected_damage = group_records.expected_damage.sum()
+    mean_critical_strike = group_records.critical_strike.mean()
+    for skill_name, count in group_records.skill_name.count().items():
+        critical_strike = mean_critical_strike[skill_name]
+        critical_count = critical_strike * count
+        hit = 1 - critical_strike
+        hit_count = count - critical_strike
+        expected_damage = sum_expected_damage[skill_name]
+        content[expected_damage] = (
+            [f"{skill_name}/{count}",
+             f"{hit_count:.2f}/{hit * 100:.2f}%", f"{critical_count:.2f}/{critical_strike * 100:.2f}%",
+             f"{expected_damage:.2f}/{expected_damage / total_damage:.2f}%"]
         )
+    content = [content[k] for k in sorted(content, reverse=True)]
     return content
 
 
-def gradient_content(gradients, total_damage):
-    return "\n".join(
-        ATTR_TYPE_TRANSLATE[k].ljust(10, FULL_SPACE) + f"{round(v / total_damage * 100, 2)}%"
-        for k, v in gradients.items()
-    )
+def gradient_content(records, attribute, total_damage):
+    content = []
+    for attr in attribute.grad_attrs:
+        gradient = records[attr].sum() / total_damage - 1
+        content.append(ATTR_TYPE_TRANSLATE[attr].ljust(10, FULL_SPACE) + f"{gradient * 100:.2f}")
+    return "\n".join(content)
 
 
-def detail_content(detail: Detail):
+def detail_content(records):
     damage_detail = "\n".join([
-        "命中伤害".ljust(10) + f"{round(detail.damage)}",
-        "会心伤害".ljust(10) + f"{round(detail.critical_damage)}",
-        "期望伤害".ljust(10) + f"{round(detail.expected_damage)}",
-        "期望会心".ljust(10) + f"{round(detail.critical_strike * 100, 2)}%",
-        "实际会心".ljust(10) + f"{round(detail.actual_critical_strike * 100, 2)}%",
-        "统计数量".ljust(10) + f"{detail.count}"
+        "统计数量".ljust(10) + f"{len(records)}",
+        "命中伤害".ljust(10) + f"{records.damage.mean():.0f}",
+        "会心伤害".ljust(10) + f"{records.critical_damage.mean():.0f}",
+        "期望伤害".ljust(10) + f"{records.expected_damage.mean():.0f}",
+        "实际伤害".ljust(10) + f"{records.actual_damage.mean():.0f}",
+        "期望会心".ljust(10) + f"{records.critical_strike.mean() * 100:.2f}%",
+        "实际会心".ljust(10) + f"{records.actual_critical_strike.mean() * 100:.2f}%"
     ])
 
-    damage_gradient = gradient_content(detail.gradients, detail.expected_damage)
+    # damage_gradient = gradient_content(records, attribute, records.expected_damage.sum())
 
-    return damage_detail, damage_gradient
+    return damage_detail
+
+
+def timeline_content(records):
+    columns = [column for column in records.columns if "#" in column]
+    return records[["time", "skill"] + columns].rename(columns={"time": "时间", "skill": "技能"})
 
 
 def combat_script(
@@ -71,9 +113,10 @@ def combat_script(
         # consumables: Consumables, bonuses: Bonuses
         combat_component: CombatComponent,
 ):
-    def formulate(target_level, duration, skill, status):
+    detail = Detail()
+
+    def formulate(target_level, duration):
         combat_update = {}
-        record = parser.current_records
         school = parser.current_school
 
         attribute = school.attribute()
@@ -101,59 +144,64 @@ def combat_script(
         combat_update[combat_component.final_attribute] = gr.update(
             value=attribute_content(school.display_attrs, attribute)
         )
-        total, summary, details = analyze_details(record, duration, attribute, school)
+        records = analyze_records(parser, duration, attribute)
 
         for gain in gains:
             gain.sub(attribute, school.skills, school.buffs)
 
-        combat_update[combat_component.dps] = gr.update(value=round(total.expected_damage / duration))
+        total_damage = records.expected_damage.sum()
+        combat_update[combat_component.dps] = gr.update(value=f"{total_damage / duration:.0f}")
 
-        combat_update[combat_component.gradient] = gradient_content(total.gradients, total.expected_damage)
+        combat_update[combat_component.gradient] = gradient_content(records, attribute, total_damage)
 
-        combat_update[combat_component.details] = details
-        combat_update[combat_component.skill_select] = gr.update(choices=list(details))
-        if skill_detail := details.get(skill, {}):
-            combat_update[combat_component.status_select] = gr.update(choices=[""] + list(skill_detail))
-        if detail := skill_detail.get(status):
-            damage_detail, damage_gradient = detail_content(detail)
-            combat_update[combat_component.damage_detail] = gr.update(value=damage_detail)
-            combat_update[combat_component.damage_gradient] = gr.update(value=damage_gradient)
-        else:
-            combat_update[combat_component.damage_detail] = gr.update(value="")
-            combat_update[combat_component.damage_gradient] = gr.update(value="")
+        combat_update[combat_component.summary] = summary_content(records, total_damage)
+
+        detail.records = records
+
+        combat_update[combat_component.skill_select] = gr.update(choices=list(records.skill.unique()))
+        if detail.current_records.empty:
+            detail.status_set = []
+        records = detail.current_records
+
+        combat_update[combat_component.status_select] = gr.update(choices=detail.available_status)
+        combat_update[combat_component.damage_detail] = gr.update(value=detail_content(records), visible=True)
+        combat_update[combat_component.damage_timeline] = gr.update(value=timeline_content(records), visible=True)
 
-        combat_update[combat_component.summary] = summary_content(summary, total.expected_damage)
         return combat_update
 
     combat_component.formulate.click(
         formulate,
-        [combat_component.target_level, combat_component.combat_duration,
-         combat_component.skill_select, combat_component.status_select],
+        [combat_component.target_level, combat_component.combat_duration],
         [combat_component.init_attribute, combat_component.final_attribute,
          combat_component.dps, combat_component.gradient, combat_component.summary,
-         combat_component.details, combat_component.skill_select, combat_component.status_select,
-         combat_component.damage_detail, combat_component.damage_gradient
-         ]
+         combat_component.skill_select, combat_component.status_select,
+         combat_component.damage_detail, combat_component.damage_timeline]
     )
 
-    def skill_changed(skill, details):
-        if skill not in details:
-            return None
-        return gr.update(choices=[""] + list(details[skill]))
+    def skill_changed(skill):
+        detail.skill = skill
+
+        if detail.current_records.empty:
+            detail.status_set = []
+
+        records = detail.current_records
+        return gr.update(choices=detail.available_status), detail_content(records), timeline_content(records)
 
     combat_component.skill_select.change(
-        skill_changed, [combat_component.skill_select, combat_component.details], combat_component.status_select
+        skill_changed, combat_component.skill_select,
+        [combat_component.status_select, combat_component.damage_detail, combat_component.damage_timeline]
     )
 
-    def status_changed(skill, status, details):
-        if skill not in details:
-            return None, None
-        if status not in details[skill]:
-            return None, None
-        damage_detail, damage_gradient = detail_content(details[skill][status])
-        return gr.update(value=damage_detail), gr.update(value=damage_gradient)
+    def status_changed(status_set):
+        detail.status_set = status_set
+        records = detail.current_records
+
+        if records.empty:
+            return gr.update(visible=False), gr.update(visible=False)
+        return (gr.update(value=detail_content(records), visible=True),
+                gr.update(value=timeline_content(records), visible=True))
 
     combat_component.status_select.change(
-        status_changed, [combat_component.skill_select, combat_component.status_select, combat_component.details],
-        [combat_component.damage_detail, combat_component.damage_gradient]
+        status_changed, combat_component.status_select,
+        [combat_component.damage_detail, combat_component.damage_timeline]
     )

gr/scripts/top.py

@@ -1,5 +1,4 @@
 import json
-import os
 
 import gradio as gr
 
@@ -37,9 +36,8 @@ def top_script(
             select_talents=parser.select_talents,
             select_equipments=parser.select_equipments,
         )
-        file_name = parser.file_name.split(".jcl")[0] + ".json"
-        json.dump(result, open(file_name, "w", encoding="utf-8"), ensure_ascii=False)
-        return file_name
+        result = json.dumps(result, ensure_ascii=False)
+        return result
 
     def upload_log(file_path):
         if not file_path:
@@ -47,38 +45,35 @@ def top_script(
         parser(file_path)
         players = [parser.id2name[player_id] for player_id in parser.players]
         player_select_update = gr.update(choices=players, value=players[0], visible=True)
-        json_link = f"/file={save_json()}"
-        return player_select_update, gr.update(visible=True), gr.update(visible=True), gr.update(value=json_link)
+        json_copy_update = gr.update(value=save_json(), visible=True)
+        return player_select_update, json_copy_update, gr.update(visible=True)
 
     top_component.upload_log.upload(
         upload_log, top_component.upload_log,
-        [top_component.player_select, top_component.save_json, bottom_component, top_component.save_json]
+        [top_component.player_select, top_component.copy_json, bottom_component], show_progress="full"
     )
 
-    def load_json(file_path):
-        if not file_path:
-            return [None] * 4
-        result = json.load(open(file_path, encoding="utf-8"))
-
-        file_name = os.path.basename(result['file_name']).split(".jcl")[0] + ".json"
-        json.dump(result, open(file_name, "w", encoding="utf-8"), ensure_ascii=False)
-
-        result['records'] = unserialize(result['records'])
-        for player_id, school_id in result['players'].items():
-            result['players'][player_id] = SUPPORT_SCHOOL[school_id]
-        for k, v in result.items():
-            setattr(parser, k, v)
-
-        json_link = f"/file={save_json()}"
-
-        players = [parser.id2name[player_id] for player_id in parser.players]
-        player_select_update = gr.update(choices=players, value=players[0], visible=True)
-        return player_select_update, gr.update(visible=True), gr.update(visible=True), gr.update(value=json_link)
-
-    top_component.upload_json.upload(
-        load_json, top_component.upload_json,
-        [top_component.player_select, top_component.save_json, bottom_component, top_component.save_json]
-    )
+    # def load_json(file_path):
+    #     if not file_path:
+    #         return [None] * 4
+    #     result = json.load(open(file_path, encoding="utf-8"))
+    #
+    #     result['records'] = unserialize(result['records'])
+    #     for player_id, school_id in result['players'].items():
+    #         result['players'][player_id] = SUPPORT_SCHOOL[school_id]
+    #     for k, v in result.items():
+    #         setattr(parser, k, v)
+    #
+    #     json_link = f"/file={save_json()}"
+    #
+    #     players = [parser.id2name[player_id] for player_id in parser.players]
+    #     player_select_update = gr.update(choices=players, value=players[0], visible=True)
+    #     return player_select_update, gr.update(visible=True), gr.update(visible=True), gr.update(value=json_link)
+    #
+    # top_component.upload_json.upload(
+    #     load_json, top_component.upload_json,
+    #     [top_component.player_select, top_component.save_json, bottom_component, top_component.save_json]
+    # )
 
     def player_select(player_name):
         if not player_name:
@@ -89,9 +84,9 @@ def top_script(
 
         top_update = {
             top_component.target_select: gr.update(
-                choices=[""] + [parser.id2name[target_id] for target_id in parser.current_targets],
+                choices=[""] + [parser.id2name[target_id] for target_id in parser.current_targets], visible=True
             ),
-            combat_component.combat_duration: gr.update(value=parser.duration)
+            combat_component.combat_duration: gr.update(value=parser.duration, maximum=parser.duration)
         }
 
         # """ Update config """
@@ -161,11 +156,11 @@ def top_script(
         player_select, top_component.player_select,
         sum([[e.equipment, e.enchant, e.strength_level, *e.embed_levels] for e in equipments_component.values()], []) +
         talents_component.talents + recipes_component.recipes +
-        [combat_component.combat_duration] + [top_component.target_select]
+        [combat_component.combat_duration] + [top_component.target_select],
     )
 
     def target_select(target_name):
-        target_id = parser.name2id.get(target_name, "")
+        target_id = parser.name2id.get(target_name)
         parser.current_target = target_id
 
     top_component.target_select.change(

parse_new_school.py

@@ -1,6 +1,6 @@
 import json
 
-from utils.lua import parse
+from utils.lua import parse_player
 
 
 class Parser:
@@ -39,7 +39,7 @@ class Parser:
         for line in lines:
             row = line.split("\t")
             if row[4] == "4":
-                detail = parse(row[-1])
+                detail = parse_player(row[-1])
                 self.school_id = int(detail[3])
                 if isinstance(detail, list):
                     self.talents = self.parse_talents(detail[6])

parse_skill.py

@@ -1,8 +1,8 @@
-from utils.lua import parse
+from utils.lua import parse_player
 lua = """
 
 """
-result = parse(lua)
+result = parse_player(lua)
 damage_base = [row['nDamageBase'] for row in result]
 print(f'"damage_base": {damage_base},')
 damage_rand = [row['nDamageRand'] for row in result]

schools/ao_xue_zhan_yi/__init__.py

@@ -7,4 +7,4 @@ from schools.ao_xue_zhan_yi.attribute import AoXueZhanYi
 
 
 def prepare(self, player_id):
-    self.buff_stacks[player_id][(-1, 1)] = 5
+    self.buffs[player_id][(-1, 1)] = 5

schools/ao_xue_zhan_yi/skills.py

@@ -9,7 +9,7 @@ class 战意判定(Skill):
     bind_buff = -1
 
     def record(self, critical, parser):
-        if buff_level := parser.current_buff_stacks.get((self.bind_buff, 1)):
+        if buff_level := parser.current_buffs.get((self.bind_buff, 1)):
             parser.refresh_buff(self.final_buff, buff_level)
 
 

schools/ao_xue_zhan_yi/talents.py

@@ -64,7 +64,7 @@ class 骁勇(Gain):
 class 虎贲(Gain):
     @staticmethod
     def effect(parser):
-        if parser.current_buff_stacks.get((-28169, 1)) == 3:
+        if parser.current_buffs.get((-28169, 1)) == 3:
             parser.refresh_buff(-1, 1, 3)
         parser.refresh_buff(-28169, 1)
 

schools/bing_xin_jue/__init__.py

@@ -7,5 +7,5 @@ from schools.bing_xin_jue.attribute import BingXinJue
 
 
 def prepare(self, player_id):
-    self.buff_stacks[player_id][(409, 21)] = 10
-    self.buff_stacks[player_id][(17969, 1)] = 1
+    self.buffs[player_id][(409, 21)] = 10
+    self.buffs[player_id][(17969, 1)] = 1

schools/du_jing/skills.py

@@ -11,7 +11,7 @@ class 灵蛇引(Skill):
     def record(self, critical, parser):
         super().record(critical, parser)
         pet_buffs = {(bind_buff, 1): 1 for bind_buff in self.bind_buffs}
-        parser.current_next_pet_buff_stacks.append(pet_buffs)
+        parser.current_next_pet_buffs.append(pet_buffs)
 
 
 SKILLS: Dict[int, Skill | dict] = {

schools/gu_feng_jue/skills.py

@@ -17,7 +17,7 @@ class 横刀断浪流血(Skill):
         parser.refresh_target_buff(bind_buff, self.stack, 1)
         parser.current_dot_ticks[self.bind_skill] = bind_skill.tick
         parser.current_dot_stacks[self.bind_skill] = self.stack
-        parser.current_dot_snapshot[self.bind_skill] = parser.current_buff_stacks.copy()
+        parser.current_dot_buffs[self.bind_skill] = parser.current_buffs.copy()
 
 
 SKILLS: Dict[int, Skill | dict] = {

schools/ling_hai_jue/buffs.py

@@ -55,13 +55,13 @@ BUFFS = {
             }
         }
     },
-    14029: {
-        "buff_name": "神降",
-        "activate": False,
-        "gain_attributes": {
-            "all_damage_addition": 102
-        }
-    }
+    # 14029: {
+    #     "buff_name": "神降",
+    #     "activate": False,
+    #     "gain_attributes": {
+    #         "all_damage_addition": 102
+    #     }
+    # }
 }
 
 for buff_id, detail in BUFFS.items():

schools/tai_xu_jian_yi/__init__.py

@@ -7,4 +7,4 @@ from schools.tai_xu_jian_yi.attribute import TaiXuJianYi
 
 
 def prepare(self, player_id):
-    self.buff_stacks[player_id][(9949, 1)] = 3
+    self.buffs[player_id][(9949, 1)] = 3

schools/yi_jin_jing/__init__.py

@@ -7,4 +7,4 @@ from schools.yi_jin_jing.attribute import YiJinJing
 
 
 def prepare(self, player_id):
-    self.buff_stacks[player_id][(10023, 1)] = 1
+    self.buffs[player_id][(10023, 1)] = 1

schools/yi_jin_jing/skills.py

@@ -9,8 +9,8 @@ class 明法判定(Skill):
     bind_buff = 890
 
     def record(self, critical, parser):
-        if buff_level := parser.current_target_buff_stacks.get((self.bind_buff, 1)):
-            parser.current_target_buff_stacks[(self.final_buff, buff_level)] = 1
+        if buff_level := parser.current_target_buffs.get((self.bind_buff, 1)):
+            parser.current_target_buffs[(self.final_buff, buff_level)] = 1
 
 
 class 明法移除(Skill):
@@ -18,9 +18,9 @@ class 明法移除(Skill):
     bind_buff = 890
 
     def record(self, critical, parser):
-        buff_level = parser.current_target_buff_stacks.get((self.bind_buff, 1), 0)
+        buff_level = parser.current_target_buffs.get((self.bind_buff, 1), 0)
         for level in range(buff_level):
-            parser.current_target_buff_stacks.pop((self.final_buff, level + 1), None)
+            parser.current_target_buffs.pop((self.final_buff, level + 1), None)
 
 
 SKILLS: Dict[int, Skill | dict] = {

schools/zi_xia_gong/__init__.py

@@ -7,4 +7,4 @@ from schools.zi_xia_gong.attribute import ZiXiaGong
 
 
 def prepare(self, player_id):
-    self.buff_stacks[player_id][(17918, 1)] = 1
+    self.buffs[player_id][(17918, 1)] = 1

utils/analyzer.py

@@ -1,76 +1,40 @@
-from dataclasses import dataclass
-from collections import defaultdict
-from typing import Dict
+import pandas as pd
 
 from base.attribute import Attribute
-from base.constant import FRAME_PER_SECOND
 from base.skill import Skill, DotDamage, NpcDamage, PetDamage
-from utils.parser import School
+from utils.parser import School, Parser, CALCULATE_COLUMNS
 
+DAMAGE_COLUMNS = ["damage", "critical_damage", "critical_strike", "expected_damage"]
 
-@dataclass
-class Detail:
-    damage: int = 0
-    critical_damage: int = 0
-    expected_damage: float = 0.
-    critical_strike: float = 0.
 
-    gradients: Dict[str, float] = None
-
-    critical_count: int = 0
-    count: int = 0
-
-    def __post_init__(self):
-        self.gradients = defaultdict(float)
-
-    @property
-    def actual_critical_strike(self):
-        if self.count:
-            return self.critical_count / self.count
-        return 0
-
-
-def filter_status(status, school: School, skill_id):
+def filter_status(status, school: School):
     buffs = []
     for buff_id, buff_level, buff_stack in status:
         buff = school.buffs[buff_id]
-        if not buff.activate:
-            continue
-        buff.buff_level, buff.buff_stack = buff_level, buff_stack
-        if buff.gain_attributes:
-            buffs.append(buff)
-        elif skill_id in buff.gain_skills:
+        if buff.activate:
             buffs.append(buff)
 
-    return tuple(sorted(buffs, key=lambda x: x.buff_id))
+    return buffs
 
 
 def add_buffs(current_buffs, snapshot_buffs, target_buffs, attribute: Attribute, skill: Skill):
-    final_buffs = []
     if not snapshot_buffs:
         for buff in current_buffs:
             buff.add_all(attribute, skill)
-            final_buffs.append(buff)
     elif isinstance(skill, DotDamage):
         for buff in snapshot_buffs:
-            if buff.add_dot(attribute, skill, True):
-                final_buffs.append(buff)
+            buff.add_dot(attribute, skill, True)
         for buff in current_buffs:
-            if buff.add_dot(attribute, skill, False):
-                final_buffs.append(buff)
+            buff.add_dot(attribute, skill, False)
     elif isinstance(skill, NpcDamage):
         for buff in snapshot_buffs:
             buff.add_all(attribute, skill)
-            final_buffs.append(buff)
     elif isinstance(skill, PetDamage):
         for buff in snapshot_buffs:
             buff.add_all(attribute, skill)
-            final_buffs.append(buff)
     for buff in target_buffs:
         buff.add_all(attribute, skill)
 
-    return final_buffs + list(target_buffs)
-
 
 def sub_buffs(current_buffs, snapshot_buffs, target_buffs, attribute: Attribute, skill: Skill):
     if not snapshot_buffs:
@@ -91,85 +55,50 @@ def sub_buffs(current_buffs, snapshot_buffs, target_buffs, attribute: Attribute,
         buff.sub_all(attribute, skill)
 
 
-def concat_buffs(buffs):
-    buffs = ",".join(buff.display_name for buff in buffs)
-    if not buffs:
-        buffs = "~"
-    return buffs
-
+def analyze_records(parser: Parser, duration: int, attribute: Attribute):
+    records: pd.DataFrame = parser.current_records
+    school = parser.current_school
+    condition = (records.player_id == parser.current_player) & (records.time < duration)
+    if parser.current_target:
+        condition = condition & (records.target_id == parser.current_target)
+    records = records[condition].copy()
 
-def analyze_details(record, duration: int, attribute: Attribute, school: School):
-    total = Detail()
-    details = {}
-    summary = {}
-    duration *= FRAME_PER_SECOND
+    damage_columns = [(0 for _ in DAMAGE_COLUMNS)] * len(records)
+    grad_attrs = list(attribute.grad_attrs)
+    gradient_columns = [(0 for _ in grad_attrs)] * len(records)
 
-    for skill, status in record.items():
-        skill_id, skill_level, skill_stack = skill
+    for row, indices in records.groupby(CALCULATE_COLUMNS).indices.items():
+        skill_id, skill_level, skill_stack, current_status, target_status, snapshot_index = row
         skill: Skill = school.skills[skill_id]
-        if not skill.activate:
-            continue
         skill.skill_level, skill.skill_stack = skill_level, skill_stack
-        skill_name = skill.skill_name
-
-        skill_detail = details[skill.display_name] = {}
-        if not (skill_summary := summary.get(skill_name)):
-            skill_summary = summary[skill_name] = Detail()
-        skill_total = skill_detail[""] = Detail()
-        for (current_status, snapshot_status, target_status), timeline in status.items():
-            if not (timeline := [t for t in timeline if t[0] < duration]):
-                continue
-            critical_timeline = [t for t in timeline if t[1]]
-
-            current_buffs = filter_status(current_status, school, skill_id)
-            snapshot_buffs = filter_status(snapshot_status, school, skill_id)
-            target_buffs = filter_status(target_status, school, skill_id)
-
-            buffs = add_buffs(current_buffs, snapshot_buffs, target_buffs, attribute, skill)
-            buffs = concat_buffs(buffs)
-            if buffs in skill_detail:
-                detail = skill_detail[buffs]
-            else:
-                detail = skill_detail[buffs] = Detail(*skill(attribute))
-                detail.gradients = analyze_gradients(skill, attribute)
-            sub_buffs(current_buffs, snapshot_buffs, target_buffs, attribute, skill)
-
-            detail.critical_count += len(critical_timeline)
-            detail.count += len(timeline)
-            skill_total.critical_count += len(critical_timeline)
-            skill_total.count += len(timeline)
-
-            skill_total.damage += detail.damage * len(timeline)
-            skill_total.critical_damage += detail.critical_damage * len(timeline)
-            skill_total.expected_damage += detail.expected_damage * len(timeline)
-            skill_total.critical_strike += detail.critical_strike * len(timeline)
-            for attr, residual_damage in detail.gradients.items():
-                skill_total.gradients[attr] += residual_damage * len(timeline)
-
-        if skill_total.count:
-            total.expected_damage += skill_total.expected_damage
-            skill_summary.expected_damage += skill_total.expected_damage
-            skill_summary.critical_count += skill_total.critical_strike
-            skill_summary.count += skill_total.count
-            skill_total.damage /= skill_total.count
-            skill_total.critical_damage /= skill_total.count
-            skill_total.expected_damage /= skill_total.count
-            skill_total.critical_strike /= skill_total.count
-            for attr, residual_damage in skill_total.gradients.items():
-                total.gradients[attr] += residual_damage
-                skill_total.gradients[attr] /= skill_total.count
+
+        current_buffs = filter_status(current_status, school)
+        target_buffs = filter_status(target_status, school)
+        if snapshot_index < 0:
+            snapshot_buffs = tuple()
         else:
-            details.pop(skill.display_name)
+            snapshot_buffs = filter_status(records.loc[snapshot_index].current_status, school)
+
+        add_buffs(current_buffs, snapshot_buffs, target_buffs, attribute, skill)
+        damage_tuple = skill(attribute)
+        gradient_tuple = analyze_gradients(skill, attribute)
+        for index in indices:
+            damage_columns[index] = damage_tuple
+            gradient_columns[index] = gradient_tuple
+        sub_buffs(current_buffs, snapshot_buffs, target_buffs, attribute, skill)
+
+    records[DAMAGE_COLUMNS] = damage_columns
+    records[grad_attrs] = gradient_columns
 
-    summary = {skill: detail for skill, detail in summary.items() if detail.count}
-    return total, summary, details
+    return records
 
 
 def analyze_gradients(skill, attribute):
-    results = {}
+    results = []
     for attr, value in attribute.grad_attrs.items():
         origin_value = getattr(attribute, attr)
         setattr(attribute, attr, origin_value + value)
-        _, _, results[attr], _ = skill(attribute)
+        _, _, _, expected_damage = skill(attribute)
+        results.append(expected_damage)
         setattr(attribute, attr, origin_value)
     return results

utils/io.py

@@ -1,7 +1,6 @@
 import json
 from collections import defaultdict
-
-from base.constant import FRAME_PER_SECOND
+from utils.parser import COLUMNS
 
 DELIMITER = "-"
 COMMA = ","
@@ -9,18 +8,9 @@ SEMICOLON = ";"
 
 
 def serialize(records):
-    result = defaultdict(lambda: defaultdict(lambda: defaultdict(dict)))
+    result = {}
     for player_id in records:
-        for target_id in records[player_id]:
-            for skill, status in records[player_id][target_id].items():
-                skill = DELIMITER.join(str(e) for e in skill)
-                for (current_status, snapshot_status, target_status), timeline in status.items():
-                    current_status = COMMA.join(DELIMITER.join(str(e) for e in buff) for buff in current_status)
-                    snapshot_status = COMMA.join(DELIMITER.join(str(e) for e in buff) for buff in snapshot_status)
-                    target_status = COMMA.join(DELIMITER.join(str(e) for e in buff) for buff in target_status)
-                    concat_status = SEMICOLON.join((current_status, snapshot_status, target_status))
-
-                    result[player_id][target_id][skill][concat_status] = timeline
+        result[player_id] = records[player_id][COLUMNS].to_dict(orient="records")
 
     return result
 

utils/lua.py

@@ -1,350 +1,16 @@
-def node_to_table(node):
-    if len(node["entries"]) == node["lua_len"]:
-        lst = []
-        for kv in node["entries"]:
-            lst.append(kv[1])
-        return lst
-    else:
-        dct = {}
-        for kv in node["entries"]:
-            dct[kv[0]] = kv[1]
-        return dct
+from ast import literal_eval
+import re
 
+DAMAGE_RESULT_PATTERN = re.compile(r"\[[0-4]\]=(\d+)")
 
-def sorter(kv):
-    if isinstance(kv[0], int):
-        return kv[0]
-    return float("inf")
 
+def parse_player(lua_data):
+    try:
+        python_data = lua_data.strip().replace("{", "[").replace("}", "]")
+        return literal_eval(python_data)
+    except:
+        return None
 
-def node_entries_append(node, key, val):
-    node["entries"].append([key, val])
-    node["entries"].sort(key=sorter)
-    lua_len = 0
-    for kv in node["entries"]:
-        if kv[0] == lua_len + 1:
-            lua_len = lua_len + 1
-    node["lua_len"] = lua_len
 
-
-def parse(raw, encoding="utf-8", multi_val=False, verbose=False):
-    sbins = raw.encode(encoding)
-    root = {"entries": [], "lua_len": 0, "is_root": True}
-    node = root
-    stack = []
-    state = "SEEK_CHILD"
-    pos = 0
-    slen = len(sbins)
-    byte_quoting_char = None
-    key = None
-    escaping = False
-    comment = None
-    component_name = None
-    errmsg = None
-
-    while pos <= slen:
-        byte_current = None
-        byte_current_is_space = False
-        if pos < slen:
-            byte_current = sbins[pos: pos + 1]
-            byte_current_is_space = (
-                    byte_current == b" "
-                    or byte_current == b"\r"
-                    or byte_current == b"\n"
-                    or byte_current == b"\t"
-            )
-        if verbose:
-            print("[step] pos", pos, byte_current, state, comment, key, node)
-
-        if comment == "MULTILINE":
-            if byte_current == b"]" and sbins[pos: pos + 2] == b"]]":
-                comment = None
-                pos = pos + 1
-        elif comment == "INLINE":
-            if byte_current == b"\n":
-                comment = None
-        elif state == "SEEK_CHILD":
-            if byte_current is None:
-                break
-            if byte_current == b"-" and sbins[pos: pos + 4] == b"--[[":
-                comment = "MULTILINE"
-                pos = pos + 3
-            elif byte_current == b"-" and sbins[pos: pos + 2] == b"--":
-                comment = "INLINE"
-                pos = pos + 1
-            elif not node["is_root"] and (
-                    (b"A" <= byte_current <= b"Z")
-                    or (b"a" <= byte_current <= b"z")
-                    or byte_current == b"_"
-            ):
-                state = "KEY_SIMPLE"
-                pos1 = pos
-            elif not node["is_root"] and byte_current == b"[":
-                state = "KEY_EXPRESSION_OPEN"
-            elif byte_current == b"}":
-                if len(stack) == 0:
-                    errmsg = (
-                        "unexpected table closing, no matching opening braces found."
-                    )
-                    break
-                prev_env = stack.pop()
-                if prev_env["state"] == "KEY_EXPRESSION_OPEN":
-                    key = node_to_table(node)
-                    state = "KEY_END"
-                elif prev_env["state"] == "VALUE":
-                    node_entries_append(
-                        prev_env["node"],
-                        prev_env["key"],
-                        node_to_table(node),
-                    )
-                    state = "VALUE_END"
-                    key = None
-                node = prev_env["node"]
-            elif not byte_current_is_space:
-                key = node["lua_len"] + 1
-                state = "VALUE"
-                pos = pos - 1
-        elif state == "VALUE":
-            if byte_current is None:
-                errmsg = "unexpected empty value."
-                break
-            if byte_current == b"-" and sbins[pos: pos + 4] == b"--[[":
-                comment = "MULTILINE"
-                pos = pos + 3
-            elif byte_current == b"-" and sbins[pos: pos + 2] == b"--":
-                comment = "INLINE"
-                pos = pos + 1
-            elif byte_current == b'"' or byte_current == b"'":
-                state = "TEXT"
-                component_name = "VALUE"
-                pos1 = pos + 1
-                byte_quoting_char = byte_current
-            elif byte_current == b"-" or (
-                    b"0" <= byte_current <= b"9"
-            ):
-                state = "INT"
-                component_name = "VALUE"
-                pos1 = pos
-            elif byte_current == b".":
-                state = "FLOAT"
-                component_name = "VALUE"
-                pos1 = pos
-            elif byte_current == b"t" and sbins[pos: pos + 4] == b"true":
-                node_entries_append(node, key, True)
-                state = "VALUE_END"
-                key = None
-                pos = pos + 3
-            elif byte_current == b"f" and sbins[pos: pos + 5] == b"false":
-                node_entries_append(node, key, False)
-                state = "VALUE_END"
-                key = None
-                pos = pos + 4
-            elif byte_current == b"{":
-                stack.append({"node": node, "state": state, "key": key})
-                state = "SEEK_CHILD"
-                node = {"entries": [], "lua_len": 0, "is_root": False}
-        elif state == "TEXT":
-            if byte_current is None:
-                errmsg = "unexpected string ending: missing close quote."
-                break
-            if escaping:
-                escaping = False
-            elif byte_current == b"\\":
-                escaping = True
-            elif byte_current == byte_quoting_char:
-                data = (
-                    sbins[pos1:pos]
-                    .replace(b"\\\n", b"\n")
-                    .replace(b'\\"', b'"')
-                    .replace(b"\\\\", b"\\")
-                    .decode(encoding)
-                )
-                if component_name == "KEY":
-                    key = data
-                    state = "KEY_EXPRESSION_FINISH"
-                elif component_name == "VALUE":
-                    node_entries_append(node, key, data)
-                    state = "VALUE_END"
-                    key = None
-                data = None
-        elif state == "INT":
-            if byte_current == b".":
-                state = "FLOAT"
-            elif byte_current is None or byte_current < b"0" or byte_current > b"9":
-                data = int(sbins[pos1:pos].decode(encoding))
-                if component_name == "KEY":
-                    key = data
-                    state = "KEY_EXPRESSION_FINISH"
-                    pos = pos - 1
-                elif component_name == "VALUE":
-                    node_entries_append(node, key, data)
-                    state = "VALUE_END"
-                    key = None
-                    pos = pos - 1
-                data = None
-        elif state == "FLOAT":
-            if byte_current is None or byte_current < b"0" or byte_current > b"9":
-                if pos == pos1 + 1 and sbins[pos1:pos] == b".":
-                    errmsg = "unexpected dot."
-                    break
-                else:
-                    data = float(sbins[pos1:pos].decode(encoding))
-                    if component_name == "KEY":
-                        key = data
-                        state = "KEY_EXPRESSION_FINISH"
-                        pos = pos - 1
-                    elif component_name == "VALUE":
-                        node_entries_append(node, key, data)
-                        state = "VALUE_END"
-                        key = None
-                        pos = pos - 1
-                    data = None
-        elif state == "VALUE_END":
-            if byte_current is None:
-                pass
-            elif byte_current == b"-" and sbins[pos: pos + 4] == b"--[[":
-                comment = "MULTILINE"
-                pos = pos + 3
-            elif byte_current == b"-" and sbins[pos: pos + 2] == b"--":
-                comment = "INLINE"
-                pos = pos + 1
-            elif byte_current == b",":
-                state = "SEEK_CHILD"
-            elif byte_current == b"}":
-                state = "SEEK_CHILD"
-                pos = pos - 1
-            elif not byte_current_is_space:
-                errmsg = "unexpected character."
-                break
-        elif state == "KEY_EXPRESSION_OPEN":
-            if byte_current is None:
-                errmsg = "key expression expected."
-                break
-            if byte_current == b"-" and sbins[pos: pos + 4] == b"--[[":
-                comment = "MULTILINE"
-                pos = pos + 3
-            elif byte_current == b"-" and sbins[pos: pos + 2] == b"--":
-                comment = "INLINE"
-                pos = pos + 1
-            elif byte_current == b'"' or byte_current == b"'":
-                state = "TEXT"
-                component_name = "KEY"
-                pos1 = pos + 1
-                byte_quoting_char = byte_current
-            elif byte_current == b"-" or (
-                    b"0" <= byte_current <= b"9"
-            ):
-                state = "INT"
-                component_name = "KEY"
-                pos1 = pos
-            elif byte_current == b".":
-                state = "FLOAT"
-                component_name = "KEY"
-                pos1 = pos
-            elif byte_current == b"t" and sbins[pos: pos + 4] == b"true":
-                errmsg = "python do not support bool as dict key."
-                break
-                key = True
-                state = "KEY_EXPRESSION_FINISH"
-                pos = pos + 3
-            elif byte_current == b"f" and sbins[pos: pos + 5] == b"false":
-                errmsg = "python do not support bool variable as dict key."
-                break
-                key = False
-                state = "KEY_EXPRESSION_FINISH"
-                pos = pos + 4
-            elif byte_current == b"{":
-                errmsg = "python do not support lua table variable as dict key."
-                break
-                state = "SEEK_CHILD"
-                stack.push({"node": node, "state": state, "key": key})
-                node = {"entries": [], "lua_len": 0}
-        elif state == "KEY_EXPRESSION_FINISH":
-            if byte_current is None:
-                errmsg = 'unexpected end of table key expression, "]" expected.'
-                break
-            if byte_current == b"-" and sbins[pos: pos + 4] == b"--[[":
-                comment = "MULTILINE"
-                pos = pos + 3
-            elif byte_current == b"-" and sbins[pos: pos + 2] == b"--":
-                comment = "INLINE"
-                pos = pos + 1
-            elif byte_current == b"]":
-                state = "KEY_EXPRESSION_CLOSE"
-            elif not byte_current_is_space:
-                errmsg = 'unexpected character, "]" expected.'
-                break
-        elif state == "KEY_EXPRESSION_CLOSE":
-            if byte_current == b"=":
-                state = "VALUE"
-            elif byte_current == b"-" and sbins[pos: pos + 4] == b"--[[":
-                comment = "MULTILINE"
-                pos = pos + 3
-            elif byte_current == b"-" and sbins[pos: pos + 2] == b"--":
-                comment = "INLINE"
-                pos = pos + 1
-            elif not byte_current_is_space:
-                errmsg = 'unexpected character, "=" expected.'
-                break
-        elif state == "KEY_SIMPLE":
-            if not (
-                    (b"A" <= byte_current <= b"Z")
-                    or (b"a" <= byte_current <= b"z")
-                    or (b"0" <= byte_current <= b"9")
-                    or byte_current == b"_"
-            ):
-                key = sbins[pos1:pos].decode(encoding)
-                state = "KEY_SIMPLE_END"
-                pos = pos - 1
-        elif state == "KEY_SIMPLE_END":
-            if byte_current_is_space:
-                pass
-            elif byte_current == b"-" and sbins[pos: pos + 4] == b"--[[":
-                comment = "MULTILINE"
-                pos = pos + 3
-            elif byte_current == b"-" and sbins[pos: pos + 2] == b"--":
-                comment = "INLINE"
-                pos = pos + 1
-            elif byte_current == b"=":
-                state = "VALUE"
-            elif byte_current == b"," or byte_current == b"}":
-                if key == "true":
-                    node_entries_append(node, node["lua_len"] + 1, True)
-                    state = "VALUE_END"
-                    key = None
-                    pos = pos - 1
-                elif key == "false":
-                    node_entries_append(node, node["lua_len"] + 1, False)
-                    state = "VALUE_END"
-                    key = None
-                    pos = pos - 1
-                else:
-                    key = None
-                    errmsg = "invalied table simple key character."
-                    break
-        pos += 1
-        if verbose:
-            print("          ", pos, "    ", state, comment, key, node)
-
-    # check if there is any errors
-    if errmsg is None and len(stack) != 0:
-        errmsg = 'unexpected end of table, "}" expected.'
-    if errmsg is None and root["lua_len"] == 0:
-        errmsg = "nothing can be unserialized from input string."
-    if errmsg is not None:
-        pos = min(pos, slen)
-        start_pos = max(0, pos - 4)
-        end_pos = min(pos + 10, slen)
-        err_parts = sbins[start_pos:end_pos].decode(encoding)
-        err_indent = " " * (pos - start_pos)
-        raise Exception(
-            "Unserialize luadata failed on pos %d:\n    %s\n    %s^\n    %s"
-            % (pos, err_parts, err_indent, errmsg)
-        )
-
-    res = []
-    for kv in root["entries"]:
-        res.append(kv[1])
-    if multi_val:
-        return tuple(res)
-    return res[0]
+def parse_damage(lua_data):
+    return sum(int(damage) for damage in DAMAGE_RESULT_PATTERN.findall(lua_data))

utils/parser.py

@@ -1,23 +1,28 @@
-import os.path
+import os
+import time
 from collections import defaultdict
 
+import pandas as pd
+from line_profiler import profile
+
 from base.constant import FRAME_PER_SECOND
 from schools import *
-from utils.lua import parse
+from utils.lua import parse_player, parse_damage
 
-FRAME_TYPE, SECOND_TYPE = int, int
-PLAYER_ID_TYPE, PLAYER_NAME_TYPE, TARGET_ID_TYPE, PET_ID_TYPE = str, str, str, str
+FRAME_TYPE, INDEX_TYPE = int, int
+PLAYER_ID_TYPE, TARGET_ID_TYPE, PET_ID_TYPE = str, str, str
 CASTER_ID_TYPE = PLAYER_ID_TYPE | PET_ID_TYPE
-SKILL_ID_TYPE, SKILL_LEVEL_TYPE, SKILL_STACK_TYPE, SKILL_CRITICAL_TYPE = int, int, int, bool
+ENTITY_ID_TYPE, ENTITY_NAME_TYPE = CASTER_ID_TYPE | TARGET_ID_TYPE, str
+SKILL_ID_TYPE, SKILL_LEVEL_TYPE, SKILL_STACK_TYPE = int, int, int
+ACTUAL_DAMAGE, ACTUAL_CRITICAL_STRIKE = int, bool
 SKILL_TYPE = Tuple[SKILL_ID_TYPE, SKILL_LEVEL_TYPE, SKILL_STACK_TYPE]
 BUFF_ID_TYPE, BUFF_LEVEL_TYPE, BUFF_STACK_TYPE = int, int, int
 BUFF_TYPE = Tuple[BUFF_ID_TYPE, BUFF_LEVEL_TYPE]
 
-CURRENT_STATUS_TYPE, SNAPSHOT_STATUS_TYPE, TARGET_STATUS_TYPE = tuple, tuple, tuple
-STATUS_TUPLE = Tuple[CURRENT_STATUS_TYPE, SNAPSHOT_STATUS_TYPE, TARGET_STATUS_TYPE]
-TIMELINE_TYPE = Tuple[FRAME_TYPE, SKILL_CRITICAL_TYPE]
-SUB_RECORD_TYPE = Dict[STATUS_TUPLE, List[TIMELINE_TYPE]]
-RECORD_TYPE = Dict[SKILL_TYPE, SUB_RECORD_TYPE]
+TAG_COLUMNS = ["frame", "time", "player_id", "caster_id", "target_id", "skill", "skill_name"]
+CALCULATE_COLUMNS = ["skill_id", "skill_level", "skill_stack", "current_status", "target_status", "snapshot_index"]
+COMPARE_COLUMNS = ["actual_critical_strike", "actual_damage"]
+COLUMNS = TAG_COLUMNS + CALCULATE_COLUMNS + COMPARE_COLUMNS
 
 LABEL_MAPPING = {
     2: "远程武器",
@@ -43,29 +48,29 @@ class BaseParser:
     current_skill: SKILL_ID_TYPE
 
     current_frame: FRAME_TYPE
-    current_second: SECOND_TYPE
+    current_index: INDEX_TYPE
 
-    id2name: Dict[PLAYER_ID_TYPE | TARGET_ID_TYPE, PLAYER_NAME_TYPE]
-    name2id: Dict[PLAYER_NAME_TYPE, PLAYER_ID_TYPE | TARGET_ID_TYPE]
+    id2name: Dict[ENTITY_ID_TYPE, ENTITY_NAME_TYPE]
+    name2id: Dict[ENTITY_NAME_TYPE, ENTITY_ID_TYPE]
     pet2employer: Dict[PET_ID_TYPE, PLAYER_ID_TYPE]
 
-    records: Dict[PLAYER_ID_TYPE, Dict[TARGET_ID_TYPE, RECORD_TYPE]]
+    records: Dict[PLAYER_ID_TYPE, List[dict] | pd.DataFrame]
 
-    frame_shift_buffs: Dict[FRAME_TYPE, Dict[PLAYER_ID_TYPE, Dict[BUFF_TYPE, BUFF_STACK_TYPE]]]
-    second_shift_buffs: Dict[SECOND_TYPE, Dict[PLAYER_ID_TYPE, Dict[BUFF_TYPE, BUFF_STACK_TYPE]]]
+    skill_display_names: Dict[tuple, str]
+    buff_display_names: Dict[tuple, str]
 
-    buff_stacks: Dict[CASTER_ID_TYPE, Dict[BUFF_TYPE, BUFF_STACK_TYPE]]
+    buffs: Dict[CASTER_ID_TYPE, Dict[BUFF_TYPE, BUFF_STACK_TYPE]]
     buff_intervals: Dict[CASTER_ID_TYPE, Dict[BUFF_TYPE, FRAME_TYPE]]
-    target_buff_stacks: Dict[TARGET_ID_TYPE, Dict[PLAYER_ID_TYPE, Dict[BUFF_TYPE, BUFF_STACK_TYPE]]]
+    target_buffs: Dict[TARGET_ID_TYPE, Dict[PLAYER_ID_TYPE, Dict[BUFF_TYPE, BUFF_STACK_TYPE]]]
     target_buff_intervals: Dict[TARGET_ID_TYPE, Dict[PLAYER_ID_TYPE, Dict[BUFF_TYPE, FRAME_TYPE]]]
 
     dot_stacks: Dict[TARGET_ID_TYPE, Dict[PLAYER_ID_TYPE, Dict[SKILL_ID_TYPE, int]]]
     dot_ticks: Dict[TARGET_ID_TYPE, Dict[PLAYER_ID_TYPE, Dict[SKILL_ID_TYPE, int]]]
-    dot_snapshot: Dict[TARGET_ID_TYPE, Dict[PLAYER_ID_TYPE, Dict[SKILL_ID_TYPE, Dict[BUFF_TYPE, BUFF_STACK_TYPE]]]]
+    dot_buffs: Dict[TARGET_ID_TYPE, Dict[PLAYER_ID_TYPE, Dict[SKILL_ID_TYPE, INDEX_TYPE]]]
 
-    next_pet_buff_stacks: Dict[PLAYER_ID_TYPE, List[Dict[BUFF_TYPE, BUFF_STACK_TYPE]]]
+    next_pet_buffs: Dict[PLAYER_ID_TYPE, List[Dict[BUFF_TYPE, BUFF_STACK_TYPE]]]
 
-    last_dot: Dict[TARGET_ID_TYPE, Dict[PLAYER_ID_TYPE, Dict[SKILL_ID_TYPE, Tuple[SKILL_TYPE, Tuple[tuple, tuple]]]]]
+    last_dot: Dict[TARGET_ID_TYPE, Dict[PLAYER_ID_TYPE, Dict[SKILL_ID_TYPE, INDEX_TYPE]]]
     next_dot: Dict[TARGET_ID_TYPE, Dict[PLAYER_ID_TYPE, Dict[SKILL_ID_TYPE, int]]]
 
     start_frame: FRAME_TYPE
@@ -87,38 +92,35 @@ class BaseParser:
 
     @property
     def current_records(self):
-        return self.records[self.current_player][self.current_target]
+        return self.records[self.current_player]
+
+    @property
+    def current_record(self):
+        return self.current_records[-1]
 
     @property
-    def current_buff_stacks(self):
-        return self.buff_stacks[self.current_player]
+    def current_buffs(self):
+        return self.buffs[self.current_caster]
 
     @property
     def current_buff_intervals(self):
         return self.buff_intervals[self.current_player]
 
     @property
-    def current_target_buff_stacks(self):
-        return self.target_buff_stacks[self.current_target][self.current_player]
+    def current_target_buffs(self):
+        return self.target_buffs[self.current_target][self.current_player]
 
     @property
     def current_target_buff_intervals(self):
         return self.target_buff_intervals[self.current_target][self.current_player]
 
     @property
-    def current_snapshot(self):
-        if self.current_caster in self.pet2employer:
-            return self.buff_stacks[self.current_caster]
-        else:
-            return self.dot_snapshot[self.current_target][self.current_player].get(self.current_skill, {})
-
-    @property
-    def current_next_pet_buff_stacks(self):
-        return self.next_pet_buff_stacks[self.current_player]
+    def current_next_pet_buffs(self):
+        return self.next_pet_buffs[self.current_player]
 
     @property
-    def current_dot_snapshot(self):
-        return self.dot_snapshot[self.current_target][self.current_player]
+    def current_dot_buffs(self):
+        return self.dot_buffs[self.current_target][self.current_player]
 
     @property
     def current_dot_stacks(self):
@@ -138,27 +140,25 @@ class BaseParser:
 
     def reset(self):
         self.current_frame = 0
-        self.current_second = 0
+        self.current_index = 0
 
         self.id2name = {}
         self.name2id = {}
         self.pet2employer = {}
 
-        self.records = defaultdict(lambda: defaultdict(lambda: defaultdict(lambda: defaultdict(list))))
+        self.records = defaultdict(list)
 
-        self.frame_shift_buffs = defaultdict(lambda: defaultdict(dict))
-        self.second_shift_buffs = defaultdict(lambda: defaultdict(dict))
-
-        self.buff_stacks = defaultdict(dict)
+        self.buff_display_names = {}
+        self.buffs = defaultdict(dict)
         self.buff_intervals = defaultdict(dict)
-        self.target_buff_stacks = defaultdict(lambda: defaultdict(dict))
+        self.target_buffs = defaultdict(lambda: defaultdict(dict))
         self.target_buff_intervals = defaultdict(lambda: defaultdict(dict))
 
         self.dot_stacks = defaultdict(lambda: defaultdict(lambda: defaultdict(lambda: 1)))
         self.dot_ticks = defaultdict(lambda: defaultdict(lambda: defaultdict(lambda: 0)))
 
-        self.next_pet_buff_stacks = defaultdict(list)
-        self.dot_snapshot = defaultdict(lambda: defaultdict(dict))
+        self.next_pet_buffs = defaultdict(list)
+        self.dot_buffs = defaultdict(lambda: defaultdict(dict))
         self.last_dot = defaultdict(lambda: defaultdict(dict))
         self.next_dot = defaultdict(lambda: defaultdict(dict))
 
@@ -173,42 +173,61 @@ class BaseParser:
     def refresh_buff(self, buff_id, buff_level, buff_stack=1):
         buff = self.current_school.buffs[buff_id]
         buff_tuple = (buff_id, buff_level)
-        stack = max(min(self.current_buff_stacks.get(buff_tuple, 0) + buff_stack, buff.max_stack), 0)
+        stack = max(min(self.current_buffs.get(buff_tuple, 0) + buff_stack, buff.max_stack), 0)
         if stack:
-            self.current_buff_stacks[buff_tuple] = stack
+            self.current_buffs[buff_tuple] = stack
             if buff.interval > 0:
                 self.current_buff_intervals[buff_tuple] = self.current_frame + buff.interval + 1
         else:
-            self.current_buff_stacks.pop(buff_tuple, None)
+            self.current_buffs.pop(buff_tuple, None)
             self.current_buff_intervals.pop(buff_tuple, None)
 
     def refresh_target_buff(self, buff_id, buff_level, buff_stack=1):
         buff = self.current_school.buffs[buff_id]
         buff_tuple = (buff_id, buff_level)
-        stack = max(min(self.current_target_buff_stacks.get(buff_tuple, 0) + buff_stack, buff.max_stack), 0)
+        stack = max(min(self.current_target_buffs.get(buff_tuple, 0) + buff_stack, buff.max_stack), 0)
         if stack:
-            self.current_target_buff_stacks[buff_tuple] = stack
+            self.current_target_buffs[buff_tuple] = stack
             if buff.interval > 0:
                 self.current_target_buff_intervals[buff_tuple] = self.current_frame + buff.interval + 1
         else:
-            self.current_target_buff_stacks.pop(buff_tuple, None)
+            self.current_target_buffs.pop(buff_tuple, None)
             self.current_target_buff_intervals.pop(buff_tuple, None)
 
     def clear_buff(self, buff_id, buff_level):
         buff_tuple = (buff_id, buff_level)
-        self.current_buff_stacks.pop(buff_tuple, None)
+        self.current_buffs.pop(buff_tuple, None)
         self.current_buff_intervals.pop(buff_tuple, None)
 
     def clear_target_buff(self, buff_id, buff_level):
         buff_tuple = (buff_id, buff_level)
-        self.current_target_buff_stacks.pop(buff_tuple, None)
+        self.current_target_buffs.pop(buff_tuple, None)
         self.current_target_buff_intervals.pop(buff_tuple, None)
 
+    def buff_timer(self):
+        for caster_id, buffs in self.buff_intervals.items():
+            pop_buffs = []
+            for buff, end_frame in buffs.items():
+                if end_frame < self.current_frame:
+                    self.buffs[caster_id].pop(buff, None)
+                    pop_buffs.append(buff)
+            for pop_buff in pop_buffs:
+                buffs.pop(pop_buff)
+        for target_id in self.target_buff_intervals:
+            for caster_id, buffs in self.target_buff_intervals[target_id].items():
+                pop_buffs = []
+                for buff, end_frame in buffs.items():
+                    if end_frame < self.current_frame:
+                        self.target_buffs[target_id][caster_id].pop(buff, None)
+                        pop_buffs.append(buff)
+                for pop_buff in pop_buffs:
+                    buffs.pop(pop_buff)
+
 
 class Parser(BaseParser):
     @property
     def duration(self):
-        return round((self.end_frame - self.start_frame) / FRAME_PER_SECOND, 3)
+        return round((self.end_frame - self.start_frame) / FRAME_PER_SECOND, 2)
 
     @staticmethod
     def parse_equipments(detail):
@@ -236,8 +255,9 @@ class Parser(BaseParser):
         if player_id in self.id2name or school_id not in SUPPORT_SCHOOL:
             return
 
-        if isinstance(detail := parse(row), list) and (school := SUPPORT_SCHOOL.get(detail[3])):
+        if detail := parse_player(row):
             player_name = detail[1]
+            school = SUPPORT_SCHOOL[school_id]
             self.id2name[player_id] = player_name
             self.name2id[player_name] = player_id
             self.select_equipments[player_id] = self.parse_equipments(detail[5])
@@ -248,12 +268,8 @@ class Parser(BaseParser):
 
     def parse_npc(self, row):
         detail = row.strip("{}").split(",")
-        npc_id, employer_id = detail[0], detail[3]
-        if npc_id in self.id2name:
-            return
-
-        npc_name = detail[1].strip('"')
-        if not npc_name:
+        npc_id, npc_name, employer_id = detail[0], detail[1].strip('"'), detail[3]
+        if npc_id in self.id2name or not npc_name:
             return
 
         self.id2name[npc_id] = npc_name
@@ -262,86 +278,29 @@ class Parser(BaseParser):
             self.pet2employer[npc_id] = employer_id
 
     def parse_pet(self, row):
-        detail = row.strip().strip("{}")
-        pet_id = detail[0]
+        pet_id = row.strip("{}")
         if player_id := self.pet2employer.get(pet_id):
-            if self.next_pet_buff_stacks[player_id]:
-                pet_buff_stacks = self.next_pet_buff_stacks[player_id].pop()
+            if self.next_pet_buffs[player_id]:
+                pet_buff_stacks = self.next_pet_buffs[player_id].pop()
             else:
                 pet_buff_stacks = {}
-            self.buff_stacks[pet_id] = {**self.buff_stacks[player_id].copy(), **pet_buff_stacks}
-
-    def parse_shift_buff(self, row):
-        detail = row.strip("{}").split(",")
-        player_id = detail[0]
-        if player_id not in self.players:
-            return
-
-        buff_id, buff_stack, buff_level = int(detail[4]), int(detail[5]), int(detail[8])
-        if buff_id not in self.players[player_id].buffs:
-            return
-        buff = self.players[player_id].buffs[buff_id]
-        if frame_shift := buff.frame_shift:
-            self.frame_shift_buffs[self.current_frame + frame_shift][player_id][(buff_id, buff_level)] = buff_stack
-        # elif second_shift := buff.second_shift:
-        #     self.second_shift_buffs[self.current_second + second_shift][player_id][(buff_id, buff_level)] = buff_stack
-
-    def parse_frame_shift_status(self):
-        for frame in list(self.frame_shift_buffs):
-            if frame > self.current_frame:
-                break
-            for player_id, shift_buffs in self.frame_shift_buffs.pop(frame).items():
-                for buff, buff_stack in shift_buffs.items():
-                    if buff_stack:
-                        self.buff_stacks[player_id][buff] = buff_stack
-                    else:
-                        self.buff_stacks[player_id].pop(buff, None)
-
-    def parse_second_shift_status(self):
-        for second in list(self.second_shift_buffs):
-            if second > self.current_second:
-                break
-            for player_id, shift_buffs in self.second_shift_buffs.pop(second).items():
-                for buff, buff_stack in shift_buffs.items():
-                    if buff_stack:
-                        self.buff_stacks[player_id][buff] = buff_stack
-                    else:
-                        self.buff_stacks[player_id].pop(buff, None)
-
-    def parse_buff_intervals(self):
-        for caster_id, buffs in self.buff_intervals.items():
-            pop_buffs = []
-            for buff, end_frame in buffs.items():
-                if end_frame < self.current_frame:
-                    self.buff_stacks[caster_id].pop(buff, None)
-                    pop_buffs.append(buff)
-            for pop_buff in pop_buffs:
-                buffs.pop(pop_buff)
-        for target_id in self.target_buff_intervals:
-            for caster_id, buffs in self.target_buff_intervals[target_id].items():
-                pop_buffs = []
-                for buff, end_frame in buffs.items():
-                    if end_frame < self.current_frame:
-                        self.target_buff_stacks[target_id][caster_id].pop(buff, None)
-                        pop_buffs.append(buff)
-                for pop_buff in pop_buffs:
-                    buffs.pop(pop_buff)
+            self.buffs[pet_id] = {**self.buffs[player_id].copy(), **pet_buff_stacks}
 
     def parse_buff(self, row):
         detail = row.strip("{}").split(",")
         caster_id = detail[0]
         if caster_id in self.pet2employer:
             player_id = self.pet2employer[caster_id]
-            if caster_id in self.buff_stacks:
-                buff_stacks = self.buff_stacks[caster_id]
-            elif self.next_pet_buff_stacks[player_id]:
-                buff_stacks = self.next_pet_buff_stacks[player_id][0]
+            if caster_id in self.buffs:
+                buffs = self.buffs[caster_id]
+            elif self.next_pet_buffs[player_id]:
+                buffs = self.next_pet_buffs[player_id][0]
             else:
-                buff_stacks = {}
-                self.next_pet_buff_stacks[player_id].append(buff_stacks)
+                buffs = {}
+                self.next_pet_buffs[player_id].append(buffs)
         else:
             player_id = caster_id
-            buff_stacks = self.buff_stacks[player_id]
+            buffs = self.buffs[player_id]
 
         if player_id not in self.players:
             return
@@ -350,15 +309,12 @@ class Parser(BaseParser):
         if buff_id not in self.players[player_id].buffs:
             return
 
-        frame_shift = self.players[player_id].buffs[buff_id].frame_shift
-        if frame_shift:
-            return
-
         if buff_stack:
-            buff_stacks[(buff_id, buff_level)] = buff_stack
+            buffs[(buff_id, buff_level)] = buff_stack
         else:
-            buff_stacks.pop((buff_id, buff_level), None)
+            buffs.pop((buff_id, buff_level), None)
 
+    @profile
     def parse_skill(self, row):
         detail = row.strip("{}").split(",")
         caster_id, target_id = detail[0], detail[1]
@@ -370,7 +326,8 @@ class Parser(BaseParser):
         if player_id not in self.players:
             return
 
-        react, skill_id, skill_level, critical = int(detail[2]), int(detail[4]), int(detail[5]), detail[6] == "true"
+        react, skill_id, skill_level = int(detail[2]), int(detail[4]), int(detail[5])
+        actual_critical_strike, actual_damage = detail[6] == "true", parse_damage(row)
         if react or skill_id not in self.players[player_id].skills:
             return
 
@@ -383,38 +340,65 @@ class Parser(BaseParser):
             self.current_targets.append(target_id)
         self.current_target = target_id
         self.current_skill = skill_id
+
         skill = self.players[player_id].skills[skill_id]
         skill.skill_level = skill_level
-        skill.parse(critical, self)
-
-    def status(self, skill_id):
+        self.current_records.append({
+            "frame": self.current_frame, **self.current_buffs, **self.current_target_buffs,
+            "player_id": self.current_player, "caster_id": self.current_caster, "target_id": self.current_target,
+            "skill_id": skill_id, "skill_level": skill_level, "skill_stack": 1, "skill_name": skill.skill_name,
+            "actual_critical_strike": actual_critical_strike, "actual_damage": actual_damage,
+           })
+        self.set_status()
+        skill.parse(self)
+        self.current_index += 1
+
+    @profile
+    def set_status(self):
         current_status = []
-        for (buff_id, buff_level), buff_stack in self.current_buff_stacks.items():
+        for (buff_id, buff_level), buff_stack in self.current_buffs.items():
             buff = self.current_school.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:
+            elif buff.gain_skills and self.current_skill in buff.gain_skills:
                 current_status.append((buff_id, buff_level, buff_stack))
-
-        self.current_skill = skill_id
-        snapshot_status = []
-        for (buff_id, buff_level), buff_stack in self.current_snapshot.items():
-            buff = self.current_school.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))
+        self.current_record['current_status'] = tuple(sorted(current_status))
 
         target_status = []
-        for (buff_id, buff_level), buff_stack in self.current_target_buff_stacks.items():
+        for (buff_id, buff_level), buff_stack in self.current_target_buffs.items():
             buff = self.current_school.buffs[buff_id]
             if buff.gain_attributes:
                 target_status.append((buff_id, buff_level, buff_stack))
-            elif buff.gain_skills and skill_id in buff.gain_skills:
+            elif buff.gain_skills and self.current_skill in buff.gain_skills:
                 target_status.append((buff_id, buff_level, buff_stack))
-
-        return tuple(current_status), tuple(snapshot_status), tuple(target_status)
-
+        self.current_record['target_status'] = tuple(sorted(target_status))
+
+    def convert_records(self):
+        for player_id, records in self.records.items():
+            records = pd.DataFrame(records)
+            records.snapshot_index = records.snapshot_index.fillna(-1)
+            records = records.fillna(0)
+            records['time'] = (records.frame - self.start_frame) / FRAME_PER_SECOND
+            skills = [""] * len(records)
+            for skill_tuple, indices in records.groupby(["skill_id", "skill_level", "skill_stack"]).indices.items():
+                skill_id, skill_level, skill_stack = skill_tuple
+                skill = self.players[player_id].skills[skill_id]
+                skill.skill_level, skill.skill_stack = skill_level, skill_stack
+                for index in indices:
+                    skills[index] = skill.display_name
+            records["skill"] = skills
+            buffs = {}
+            for buff_tuple in [column for column in records.columns if isinstance(column, tuple)]:
+                buff_id, buff_level = buff_tuple
+                buff = self.players[player_id].buffs[buff_id]
+                buff.buff_level = buff_level
+                buffs[buff_tuple] = buff.display_name
+            records = records.rename(columns=buffs)
+            columns = [c for c in COLUMNS if c in records.columns] + [c for c in records.columns if c not in COLUMNS]
+            records = records[columns]
+            self.records[player_id] = records
+
+    @profile
     def __call__(self, file_name):
         self.file_name = os.path.basename(file_name)
         self.reset()
@@ -433,27 +417,17 @@ class Parser(BaseParser):
             for talent_id in self.select_talents[player_id]:
                 school.talent_gains[talent_id].add_skills(school.skills)
 
-        for row in rows:
-            self.current_frame = int(row[1])
-            # self.current_second = int(row[3])
-            if row[4] == "13":
-                self.parse_shift_buff(row[-1])
-
         for row in rows:
             if (current_frame := int(row[1])) != self.current_frame:
                 self.current_frame = current_frame
-                self.parse_frame_shift_status()
-                self.parse_buff_intervals()
-            # if (current_second := int(row[3])) != self.current_second:
-            #     self.current_second = current_second
-            #     self.parse_frame_shift_status()
+                self.buff_timer()
 
             if row[4] == "6":
-                self.parse_pet(row[-1])
+                self.parse_pet(row[-1].strip())
             elif row[4] == "13":
-                self.parse_buff(row[-1])
+                self.parse_buff(row[-1].strip())
             elif row[4] == "21":
-                self.parse_skill(row[-1])
+                self.parse_skill(row[-1].strip())
 
         self.end_frame = self.current_frame
 
@@ -461,10 +435,4 @@ class Parser(BaseParser):
             for talent_id in self.select_talents[player_id]:
                 school.talent_gains[talent_id].sub_skills(school.skills)
 
-        for player_id in self.records:
-            player_record = defaultdict(lambda: defaultdict(list))
-            for target_id, records in self.records[player_id].items():
-                for skill_tuple, status in records.items():
-                    for status_tuple, timeline in status.items():
-                        player_record[skill_tuple][status_tuple] += timeline
-            self.records[player_id][""] = player_record
+        self.convert_records()