04.20 commit

base/buff.py

@@ -29,7 +29,7 @@ class Buff:
 
     @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}-{self.buff_stack}"
 
     def level_value(self, value):
         if isinstance(value, list):

base/skill.py

@@ -40,7 +40,7 @@ class Skill:
 
     @property
     def display_name(self):
-        return f"{self.skill_name}/{self.skill_id}-{self.skill_level}-{self.skill_stack}"
+        return f"{self.skill_name}#{self.skill_id}-{self.skill_level}-{self.skill_stack}"
 
     @property
     def damage_base(self):

qt/app.py

@@ -73,7 +73,8 @@ class MainWindow(QMainWindow):
             self.equipments_widget, self.consumable_widget, self.bonus_widget
         )
         config_script(
-            parser, self.config_widget, self.talents_widget, self.recipes_widget,
+            parser, self.config_widget,
+            self.talents_widget, self.recipes_widget,
             self.equipments_widget, self.consumable_widget, self.bonus_widget
         )
         talents = talents_script(self.talents_widget)
@@ -81,7 +82,8 @@ 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.dashboard_widget, talents, recipes, equipments, consumables, bonuses)
+        dashboard_script(parser, self.top_widget, self.dashboard_widget,
+                         talents, recipes, equipments, consumables, bonuses)
 
 
 if __name__ == "__main__":

qt/components/dashboard.py

@@ -9,9 +9,9 @@ class DetailWidget(QWidget):
         super().__init__()
         layout = QVBoxLayout(self)
         self.details = {}
-        self.skill_combo = ComboWithLabel("选择技能", info="技能名字/技能ID-技能等级-技能层数")
+        self.skill_combo = ComboWithLabel("选择技能", info="技能名字#技能ID-技能等级-技能层数")
         layout.addWidget(self.skill_combo)
-        self.status_combo = ComboWithLabel("选择增益", info="增益名字/增益ID-增益等级-增益层数")
+        self.status_combo = ComboWithLabel("选择增益", info="增益名字#增益ID-增益等级-增益层数")
         layout.addWidget(self.status_combo)
         detail_table = QWidget()
         detail_table_layout = QHBoxLayout(detail_table)

qt/components/top.py

@@ -1,12 +1,18 @@
-from PySide6.QtWidgets import QWidget, QVBoxLayout, QPushButton
+from PySide6.QtWidgets import QWidget, QHBoxLayout, QPushButton
+from PySide6.QtCore import Qt
+
+from qt.components import ComboWithLabel
 
 
 class TopWidget(QWidget):
     def __init__(self):
         super().__init__()
-        layout = QVBoxLayout()
+        layout = QHBoxLayout()
         self.setLayout(layout)
 
         self.upload_button = QPushButton("请上传JCL")
-
         layout.addWidget(self.upload_button)
+        self.player_select = ComboWithLabel("请选择角色")
+        layout.addWidget(self.player_select)
+        self.player_select.hide()
+        layout.setAlignment(Qt.AlignmentFlag.AlignTop)

qt/scripts/bonuses.py

@@ -20,13 +20,13 @@ class Bonuses(dict):
 def bonuses_script(parser: Parser, bonuses_widget: BonusesWidget):
     bonuses = Bonuses()
 
-    def formation_update(arg):
+    def formation_update(_):
         widget = bonuses_widget.formation
         formation = widget.formation.combo_box.currentText()
         core_rate = widget.core_rate.spin_box.value()
         formation_rate = widget.rate.spin_box.value()
 
-        if formation == parser.school.formation:
+        if formation == parser.school[parser.current_player].formation:
             widget.core_rate.show()
         else:
             core_rate = 0

qt/scripts/config.py

@@ -8,6 +8,7 @@ from qt.components.equipments import EquipmentsWidget
 from qt.components.consumables import ConsumablesWidget
 from qt.components.recipes import RecipesWidget
 from qt.components.talents import TalentsWidget
+from qt.components.top import TopWidget
 from utils.parser import Parser
 
 if not os.path.exists("config"):
@@ -78,7 +79,8 @@ def config_script(
 
     def load_config():
         config_name = config_widget.config_select.combo_box.currentText()
-        config = CONFIG.get(parser.school.school, {}).get(config_name, {})
+        player_id = parser.current_player
+        config = CONFIG.get(parser.school[player_id].school, {}).get(config_name, {})
         if not config:
             return
         category = config_widget.config_category.combo_box.currentText()
@@ -149,10 +151,12 @@ def config_script(
 
     def save_config():
         config_name = config_widget.config_name.text_browser.text()
-        if parser.school.school not in CONFIG:
-            CONFIG[parser.school.school] = {}
-        if config_name not in CONFIG[parser.school.school]:
-            CONFIG[parser.school.school][config_name] = {
+        player_id = parser.current_player
+        school = parser.school[player_id].school
+        if school not in CONFIG:
+            CONFIG[school] = {}
+        if config_name not in CONFIG[school]:
+            CONFIG[school][config_name] = {
                 "equipments": {},
                 "consumables": {},
                 "bonuses": {"formation": {}, "team_gains": {}},
@@ -160,28 +164,30 @@ def config_script(
                 "recipes": []
             }
 
-        save_equipments(CONFIG[parser.school.school][config_name]['equipments'])
-        save_consumables(CONFIG[parser.school.school][config_name]['consumables'])
-        save_bonuses(CONFIG[parser.school.school][config_name]['bonuses'])
+        save_equipments(CONFIG[school][config_name]['equipments'])
+        save_consumables(CONFIG[school][config_name]['consumables'])
+        save_bonuses(CONFIG[school][config_name]['bonuses'])
         # save_recipes(CONFIG[parser.school.school][config_name]['recipes'])
         json.dump(CONFIG, open("config", "w", encoding="utf-8"), ensure_ascii=False)
 
         config_widget.config_select.set_items(
-            list(CONFIG.get(parser.school.school, {})), keep_index=True, default_index=-1
+            list(CONFIG.get(school, {})), keep_index=True, default_index=-1
         )
 
     config_widget.save_config.clicked.connect(save_config)
 
     def delete_config():
         config_name = config_widget.config_name.text_browser.text()
-        if config_name not in CONFIG.get(parser.school.school, {}):
+        player_id = parser.current_player
+        school = parser.school[player_id].school
+        if config_name not in CONFIG.get(school, {}):
             return
 
-        CONFIG[parser.school.school].pop(config_name)
+        CONFIG[school].pop(config_name)
 
         json.dump(CONFIG, open("config", "w", encoding="utf-8"), ensure_ascii=False)
 
-        config_widget.config_select.set_items(list(CONFIG.get(parser.school.school, {})), default_index=-1)
+        config_widget.config_select.set_items(list(CONFIG.get(school, {})), default_index=-1)
         config_widget.config_name.text_browser.clear()
 
     config_widget.delete_config.clicked.connect(delete_config)

qt/scripts/dashboard.py

@@ -1,6 +1,7 @@
 from typing import Dict
 
 from qt.components.dashboard import DashboardWidget
+from qt.components.top import TopWidget
 from qt.constant import ATTR_TYPE_TRANSLATE
 from qt.scripts.bonuses import Bonuses
 from qt.scripts.consumables import Consumables
@@ -45,21 +46,24 @@ def detail_content(detail: Detail):
     return damage_content, gradient_content
 
 
-def dashboard_script(parser: Parser,
+def dashboard_script(parser: Parser, top_widget: TopWidget,
                      dashboard_widget: DashboardWidget, talents: Talents, recipes: Recipes,
                      equipments: Equipments, consumables: Consumables, bonuses: Bonuses):
 
     def select_fight(text):
-        index = parser.record_index[text]
-        dashboard_widget.duration.set_value(parser.duration(index))
+        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()
-        record = parser.records[parser.record_index[dashboard_widget.fight_select.combo_box.currentText()]]
+        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]]
 
-        school = parser.school
+        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

@@ -27,22 +27,35 @@ def top_script(
         if not file_name[0]:
             return
         parser(file_name[0])
-        school = parser.school
+        top_widget.player_select.set_items(
+            [parser.id2name[player_id] for player_id in parser.school], keep_index=True, default_index=0
+        )
+        top_widget.player_select.show()
+        select_player(None)
+
+    top_widget.upload_button.clicked.connect(upload_logs)
+
+    def select_player(_):
+        player_name = top_widget.player_select.combo_box.currentText()
+        if not player_name:
+            return
+        player_id = parser.name2id[player_name]
+        parser.current_player = player_id
+        school = parser.school[player_id]
         """ Update config """
         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)
-        dashboard_widget.fight_select.set_items(record_index)
-        dashboard_widget.duration.set_value(parser.duration(parser.record_index[record_index[0]]))
+        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]]))
 
         """ Update talent options """
         for i, talent_widget in enumerate(talents_widget.values()):
             talents = school.talents[i]
-            default_index = talents.index(parser.select_talents[i]) + 1
+            default_index = talents.index(parser.select_talents[player_id][i]) + 1
             talent_widget.set_items(
-                [""] + [school.talent_decoder[talent] for talent in talents],
-                keep_index=True, default_index=default_index
+                [""] + [school.talent_decoder[talent] for talent in talents], default_index=default_index
             )
 
         """ Update recipe options """
@@ -71,7 +84,7 @@ def top_script(
                 if not (current_index := equipment_widget.stone_level.combo_box.currentIndex()):
                     current_index = MAX_STONE_LEVEL
                 equipment_widget.stone_level.combo_box.setCurrentIndex(current_index)
-            if select_equipment := parser.select_equipments.get(label, {}):
+            if select_equipment := parser.select_equipments[player_id].get(label, {}):
                 if equipment := equipment_widget.equipment_mapping.get(select_equipment['equipment']):
                     if equipment in equipment_widget.equipment.items:
                         equipment_widget.equipment.combo_box.setCurrentText(equipment)
@@ -97,6 +110,6 @@ def top_script(
         config_widget.show()
         bottom_widget.show()
 
-    top_widget.upload_button.clicked.connect(upload_logs)
+    top_widget.player_select.combo_box.currentTextChanged.connect(select_player)
 
     return parser

utils/parser.py

@@ -9,6 +9,14 @@ from base.skill import Skill
 from schools import bei_ao_jue
 from utils.lua import parse
 
+SKILL_TYPE = Tuple[int, 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:
@@ -75,7 +83,6 @@ SUPPORT_SCHOOL = {
     )
 }
 
-
 LABEL_MAPPING = {
     2: "远程武器",
     3: "上衣",
@@ -94,42 +101,40 @@ EMBED_MAPPING = {(5, 24449 - i): 8 - i for i in range(8)}
 
 
 class Parser:
-    records: list
-    status: dict
-    snapshot: dict
-    stacks: dict
-    ticks: dict
-
-    start_time: list
-    end_time: list
-    record_index: Dict[str, int]
-
-    fight_flag: bool
+    current_player: int
+    id2name: Dict[int, str]
+    name2id: Dict[str, int]
+    records: Dict[int, List[RECORD_TYPE]]
+    status: Dict[int, STATUS_TYPE]
+    snapshot: Dict[int, SNAPSHOT_TYPE]
+    stacks: Dict[int, Dict[int, int]]
+    ticks: Dict[int, Dict[int, int]]
 
-    select_talents: List[int]
-    select_equipments: Dict[int, Dict[str, int | list]]
+    fight_flag: Dict[int, bool]
+    start_time: Dict[int, List[int]]
+    end_time: Dict[int, List[int]]
+    record_index: Dict[int, Dict[str, int]]
 
-    school: School | None
+    select_talents: Dict[int, List[int]]
+    select_equipments: Dict[int, Dict[int, Dict[str, int | list]]]
 
-    def duration(self, i):
-        return round((self.end_time[i] - self.start_time[i]) / 1000, 3)
+    school: Dict[int, School]
 
-    @property
-    def current_record(self):
-        return self.records[len(self.start_time) - 1]
+    def duration(self, player_id, i):
+        return round((self.end_time[player_id][i] - self.start_time[player_id][i]) / 1000, 3)
 
-    def available_status(self, skill_id):
+    def available_status(self, player_id, skill_id):
         current_status = []
-        for (buff_id, buff_level), buff_stack in self.status.items():
-            buff = self.school.buffs[buff_id]
+        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))
 
         snapshot_status = []
-        for (buff_id, buff_level), buff_stack in self.snapshot.get(skill_id, {}).items():
-            buff = self.school.buffs[buff_id]
+        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:
@@ -138,103 +143,125 @@ class Parser:
         return tuple(current_status), tuple(snapshot_status)
 
     def reset(self):
-        self.fight_flag = False
-
-        self.records = []
-        self.status = {}
-        self.snapshot = {}
-        self.stacks = defaultdict(int)
-        self.ticks = defaultdict(int)
-
-        self.start_time = []
-        self.end_time = []
-
-        self.record_index = {}
-
-        self.school = None
-
-    def parse_equipments(self, detail):
+        self.id2name = {}
+        self.name2id = {}
+        self.records = defaultdict(list)
+        self.status = defaultdict(dict)
+        self.snapshot = defaultdict(dict)
+        self.stacks = defaultdict(lambda: defaultdict(lambda: 1))
+        self.ticks = defaultdict(lambda: defaultdict(int))
+
+        self.fight_flag = defaultdict(bool)
+        self.start_time = defaultdict(list)
+        self.end_time = defaultdict(list)
+
+        self.select_talents = {}
         self.select_equipments = {}
+        self.school = {}
+
+    @staticmethod
+    def parse_equipments(detail):
+        select_equipments = {}
         for row in detail:
             if not (label := LABEL_MAPPING.get(row[0])):
                 continue
-            select_equipment = self.select_equipments[label] = {}
+            select_equipment = select_equipments[label] = {}
             select_equipment['equipment'] = row[2]
             select_equipment['strength_level'] = row[3]
             select_equipment['embed_levels'] = [EMBED_MAPPING.get(tuple(e), 0) for e in row[4]]
             select_equipment['enchant'] = row[5]
+        return select_equipments
 
-    def parse_info(self, detail):
-        if isinstance(detail, list):
-            self.school = SUPPORT_SCHOOL.get(detail[3])
-            if not self.school:
-                raise AttributeError(f"Cannot support {detail[3]} now")
-            self.parse_equipments(detail[5])
-            self.select_talents = [row[1] for row in detail[6]]
-            return self.school
-
-    def parse_time(self, detail, timestamp):
-        if detail[1]:
-            self.start_time.append(int(timestamp))
-            self.records.append({})
-            self.fight_flag = True
+    @staticmethod
+    def parse_talents(detail):
+        return [row[1] for row in detail]
+
+    def parse_info(self, row):
+        detail = row.strip("{}").split(",")
+        player_id, school_id = int(detail[0]), int(detail[3])
+        if player_id in self.id2name or school_id not in SUPPORT_SCHOOL:
+            return
+        if isinstance(detail := parse(row), list):
+            player_name = detail[1]
+            self.id2name[player_id] = player_name
+            self.name2id[player_name] = player_id
+            if school := SUPPORT_SCHOOL.get(detail[3]):
+                self.school[player_id] = school
+                self.select_equipments[player_id] = self.parse_equipments(detail[5])
+                self.select_talents[player_id] = self.parse_talents(detail[6])
+
+    def parse_time(self, row, timestamp):
+        detail = row.strip("{}").split(",")
+        player_id = int(detail[0])
+        if player_id not in self.school:
+            return
+        if detail[1] == "true":
+            self.start_time[player_id].append(int(timestamp))
+            self.records[player_id].append(defaultdict(lambda: defaultdict(list)))
+            self.fight_flag[player_id] = True
         else:
-            self.end_time.append(int(timestamp))
-            self.fight_flag = False
+            self.end_time[player_id].append(int(timestamp))
+            self.fight_flag[player_id] = False
 
     def parse_buff(self, row):
-        detail = row.split(",")
+        detail = row.strip("{}").split(",")
+        player_id = int(detail[0])
+        if player_id not in self.school:
+            return
         buff_id, buff_stack, buff_level = int(detail[4]), int(detail[5]), int(detail[8])
-        if buff_id not in self.school.buffs:
+        if buff_id not in self.school[player_id].buffs:
             return
         if not buff_stack:
-            self.status.pop((buff_id, buff_level))
+            self.status[player_id].pop((buff_id, buff_level), None)
         else:
-            self.status[(buff_id, buff_level)] = buff_stack
+            self.status[player_id][(buff_id, buff_level)] = buff_stack
 
     def parse_skill(self, row, timestamp):
-        detail = row.split(",")
+        detail = row.strip("{}").split(",")
+        player_id = int(detail[0])
+        if not self.fight_flag[player_id] or player_id not in self.school:
+            return
         skill_id, skill_level, critical = int(detail[4]), int(detail[5]), detail[6] == "true"
-        if skill_id not in self.school.skills:
+        if skill_id not in self.school[player_id].skills:
             return
-        timestamp = int(timestamp) - self.start_time[-1]
-        skill_stack = max(1, self.stacks[skill_id])
-        if self.ticks[skill_id]:
-            self.ticks[skill_id] -= 1
-            if not self.ticks[skill_id]:
-                self.stacks[skill_id] = 0
+        timestamp = int(timestamp) - self.start_time[player_id][-1]
+        skill_stack = self.stacks[player_id][skill_id]
+        if self.ticks[player_id][skill_id]:
+            self.ticks[player_id][skill_id] -= 1
+            if not self.ticks[player_id][skill_id]:
+                self.stacks[player_id].pop(skill_id)
 
         skill_tuple = (skill_id, skill_level, skill_stack)
-        skill = self.school.skills[skill_id]
+        skill = self.school[player_id].skills[skill_id]
         if bind_skill := skill.bind_skill:
-            self.stacks[bind_skill] = min(self.stacks[bind_skill] + 1, skill.max_stack)
-            self.ticks[bind_skill] = skill.tick if not self.ticks[bind_skill] else skill.tick - 1
-            self.snapshot[bind_skill] = self.status.copy()
+            self.stacks[player_id][bind_skill] = min(self.stacks[player_id][bind_skill] + 1, skill.max_stack)
+            self.ticks[player_id][bind_skill] = skill.tick if not self.ticks[player_id][bind_skill] else skill.tick - 1
+            self.snapshot[player_id][bind_skill] = self.status[player_id].copy()
         else:
-            if skill_tuple not in self.current_record:
-                self.current_record[skill_tuple] = {}
-            status_tuple = self.available_status(skill_id)
-            if status_tuple not in self.current_record[skill_tuple]:
-                self.current_record[skill_tuple][status_tuple] = []
-            self.current_record[skill_tuple][status_tuple].append((timestamp, critical))
+            current_record = self.records[player_id][len(self.start_time) - 1]
+            status_tuple = self.available_status(player_id, skill_id)
+            current_record[skill_tuple][status_tuple].append((timestamp, critical))
 
     def __call__(self, file_name):
         self.reset()
         lines = open(file_name).readlines()
         for line in lines:
             row = line.split("\t")
-            if row[4] == "4" and self.parse_info(parse(row[-1])):
-                break
-
+            if row[4] == "4":
+                self.parse_info(row[-1])
         for line in lines:
             row = line.split("\t")
             if row[4] == "5":
-                self.parse_time(parse(row[-1]), row[3])
+                self.parse_time(row[-1], row[3])
             elif row[4] == "13":
                 self.parse_buff(row[-1])
-            elif row[4] == "21" and self.fight_flag:
+            elif row[4] == "21":
                 self.parse_skill(row[-1], row[3])
 
         self.record_index = {
-            f"{i + 1}:{round((end_time - self.start_time[i]) / 1000, 3)}": i for i, end_time in enumerate(self.end_time)
+            player_id: {
+                f"{i + 1}:{round((end_time - self.start_time[player_id][i]) / 1000, 3)}": i
+                for i, end_time in enumerate(self.end_time[player_id])
+            }
+            for player_id in self.end_time
         }