04.10 commit

base/attribute.py

@@ -147,7 +147,7 @@ class Major:
     _magical_overcome: float = 0
 
     """ Major Attr Function"""
-    
+
     @property
     def all_major_base(self):
         return self._all_major_base
@@ -779,7 +779,7 @@ class Minor:
 
     @property
     def physical_critical_power_percent(self):
-        return CRITICAL_POWER_BASE + self._physical_critical_power_percent
+        return BASE_CRITICAL_POWER + self._physical_critical_power_percent
 
     @physical_critical_power_percent.setter
     def physical_critical_power_percent(self, physical_critical_power_percent):
@@ -814,7 +814,7 @@ class Minor:
 
     @property
     def magical_critical_power_percent(self):
-        return CRITICAL_POWER_BASE + self._magical_critical_power_percent
+        return BASE_CRITICAL_POWER + self._magical_critical_power_percent
 
     @magical_critical_power_percent.setter
     def magical_critical_power_percent(self, magical_critical_power_percent):
@@ -954,6 +954,7 @@ class Attribute(Major, Minor, Target):
 
     def __init__(self):
         self.all_major_base += MAJOR_BASE
+        self.all_critical_power_base = 0  # init critical power attr
 
     @property
     def level_reduction(self):

base/buff.py

@@ -1,5 +1,5 @@
 from dataclasses import dataclass
-from typing import Dict, List, Union, Tuple
+from typing import Dict, List, Union
 
 from base.attribute import Attribute
 from base.skill import Skill
@@ -9,11 +9,10 @@ ATTR_DICT = Dict[str, Union[List[int], int]]
 
 @dataclass
 class Buff:
-    buff_id: int
-    buff_name: str
+    buff_id: int = 0
+    buff_name: str = ""
     buff_level: int = 0
-
-    stack: int = 1
+    buff_stack: int = 0
 
     gain_skills: Dict[int, ATTR_DICT] = None
     gain_attributes: ATTR_DICT = None
@@ -22,22 +21,29 @@ class Buff:
         self.gain_skills = {}
         self.gain_attributes = {}
 
-    def __radd__(self, other: Tuple[Attribute, Dict[int, Skill]]):
-        attribute, skills = other
-        for skill_id, gain in self.gain_skills.items():
-            skill = skills[skill_id]
-            for attr, value in gain.items():
-                setattr(skill, attr, getattr(skill, attr) + value)
-        for attr, value in self.gain_attributes.items():
-            setattr(attribute, attr, getattr(attribute, attr) + value)
-        return attribute, skills
-
-    def __rsub__(self, other: Tuple[Attribute, Dict[int, Skill]]):
-        attribute, skills = other
-        for skill_id, gain in self.gain_skills.items():
-            skill = skills[skill_id]
-            for attr, value in gain.items():
-                setattr(skill, attr, getattr(skill, attr) - value)
-        for attr, value in self.gain_attributes.items():
-            setattr(attribute, attr, getattr(attribute, attr) - value)
-        return attribute, skills
+    @property
+    def display_name(self):
+        return f"{self.buff_name}/{self.buff_id}-{self.buff_level}-{self.buff_stack}"
+
+    def __radd__(self, other: Union[Attribute, Dict[int, Skill]]):
+        if isinstance(other, Attribute):
+            for attr, value in self.gain_attributes.items():
+                setattr(other, attr, getattr(other, attr) + value * self.buff_stack)
+        else:
+            for skill_id, gain in self.gain_skills.items():
+                skill = other[skill_id]
+                for attr, value in gain.items():
+                    setattr(skill, attr, getattr(skill, attr) + value * self.buff_stack)
+        return other
+
+    def __rsub__(self, other: Union[Attribute, Dict[int, Skill]]):
+        if isinstance(other, Attribute):
+            for attr, value in self.gain_attributes.items():
+                setattr(other, attr, getattr(other, attr) - value * self.buff_stack)
+        else:
+            for skill_id, gain in self.gain_skills.items():
+                skill = other[skill_id]
+                for attr, value in gain.items():
+                    setattr(skill, attr, getattr(skill, attr) - value * self.buff_stack)
+        return other
+

base/calculator.py

@@ -1,50 +0,0 @@
-from base.attribute import Attribute
-from qt.scripts.top import Parser, School
-
-
-def refresh_status(existed_buffs, buffs, attribute: Attribute, school: School):
-    for buff in [buff for buff in existed_buffs if buff not in buffs]:
-        existed_buffs.remove(buff)
-        buff_id, buff_level, buff_stack = buff
-        buff = school.buffs[buff_id]
-        buff.buff_level = buff_level
-        for _ in range(buff_stack):
-            attribute, school.skills = (attribute, school.skills) - buff
-
-    for buff in [buff for buff in buffs if buff not in existed_buffs]:
-        existed_buffs.append(buff)
-        buff_id, buff_level, buff_stack = buff
-        buff = school.buffs[buff_id]
-        buff.buff_level = buff_level
-        for _ in range(buff_stack):
-            attribute, school.skills = (attribute, school.skills) + buff
-
-
-def analyze_details(parser: Parser, attribute: Attribute):
-    existed_buffs = []
-    for start_time, record in parser.records.items():
-        for skill, status in record.items():
-            skill_id, skill_level = skill
-            skill = parser.school.skills[skill_id]
-            skill.skill_level = skill_level
-            for buffs, timeline in status.items():
-                refresh_status(existed_buffs, buffs, attribute, parser.school)
-
-                damage, critical_damage, expected_damage = skill(attribute)
-
-                status[buffs] = {
-                    "damage": damage, "critical_damage": critical_damage, "expected_damage": expected_damage,
-                    "timeline": [round(t / 1000, 2) for t in timeline],
-                    "gradients": analyze_gradients(skill, attribute)
-                }
-        refresh_status(existed_buffs, [], attribute, parser.school)
-
-
-def analyze_gradients(skill, attribute):
-    results = {}
-    for attr, value in attribute.grad_attrs.items():
-        origin_value = getattr(attribute, attr)
-        setattr(attribute, attr, origin_value + value)
-        _, _, results[attr] = skill(attribute)
-        setattr(attribute, attr, origin_value)
-    return results

base/constant.py

@@ -31,7 +31,7 @@ SHIELD_BASE_MAP = {
 }
 
 MAJOR_BASE = 41
-CRITICAL_POWER_BASE = 1.75
+BASE_CRITICAL_POWER = 1.75
 
 AGILITY_TO_CRITICAL_STRIKE = 655 / BINARY_SCALE
 STRENGTH_TO_ATTACK_POWER = 153 / BINARY_SCALE

base/recipe.py

@@ -1,22 +1,19 @@
+from base.buff import Buff
 
 
 def damage_addition_recipe(skill_ids, value, name="伤害增加"):
-    return {
-        "buff_name": name,
-        "gain_skills": {
+    return Buff(
+        -1, name, gain_skills={
             skill_id: {
                 "skill_damage_addition": value
             } for skill_id in skill_ids
-        }
-    }
+        })
 
 
 def critical_strike_recipe(skill_ids, value, name="会心增加"):
-    return {
-        "buff_name": name,
-        "gain_skills": {
+    return Buff(
+        -1, name, gain_skills={
             skill_id: {
                 "skill_critical_strike": value
             } for skill_id in skill_ids
-        }
-    }
+        })

base/skill.py

@@ -1,6 +1,6 @@
 from base.attribute import Attribute
 from base.constant import *
-from base.damage import *
+from utils.damage import *
 
 from typing import List, Union
 from dataclasses import dataclass
@@ -31,6 +31,10 @@ class Skill:
     _skill_critical_strike: int = 0
     _skill_critical_power: int = 0
 
+    @property
+    def display_name(self):
+        return f"{self.skill_name}/{self.skill_id}-{self.skill_level}"
+
     @property
     def damage_base(self):
         if isinstance(self._damage_base, list):
@@ -154,7 +158,7 @@ class Skill:
 
         expected_damage = critical_strike * critical_damage + (1 - critical_strike) * damage
 
-        return damage, critical_damage, expected_damage
+        return damage, critical_strike, critical_damage, expected_damage
     
     
 class PhysicalDamage(Skill):

general/recipes.py

@@ -0,0 +1,66 @@
+from base.status import Status
+
+
+class EmptyRecipe:
+    def __call__(self, status: Status):
+        pass
+
+
+class DamageRecipe:
+    def __init__(self, skills, value):
+        self.skills = skills
+        self.value = value
+
+    def __call__(self, status: Status):
+        for skill in self.skills:
+            status.skills[skill].skill_damage_addition += self.value
+
+
+class AttackPowerRecipe:
+    def __init__(self, skills, value):
+        self.skills = skills
+        self.value = value
+
+    def __call__(self, status: Status):
+        for skill in self.skills:
+            status.skills[skill].attack_power_cof_gain += self.value
+
+
+class CriticalRecipe:
+    def __init__(self, skills, value):
+        self.skills = skills
+        self.value = value
+
+    def __call__(self, status: Status):
+        for skill in self.skills:
+            status.skills[skill].skill_critical_strike += self.value
+
+
+class CDReductionRecipe:
+    def __init__(self, skills, value):
+        self.skills = skills
+        self.value = value
+
+    def __call__(self, status: Status):
+        for skill in self.skills:
+            status.skills[skill].cd_base -= self.value
+
+
+class TickIncreaseRecipe:
+    def __init__(self, skills, value):
+        self.skills = skills
+        self.value = value
+
+    def __call__(self, status: Status):
+        for skill in self.skills:
+            status.skills[skill].tick_base += self.value
+
+
+class IntervalReductionRecipe:
+    def __init__(self, skills, value):
+        self.skills = skills
+        self.value = value
+
+    def __call__(self, status: Status):
+        for skill in self.skills:
+            status.skills[skill].interval_base -= self.value

qt/app.py

@@ -8,18 +8,17 @@ from qt.scripts.top import top_script
 from qt.components.equipments import EquipmentsWidget
 from qt.scripts.equipments import equipments_script
 from qt.components.talents import TalentsWidget
-# from qt.scripts.talents import talents_script
-# from qt.components.recipes import RecipesWidget
-# from qt.scripts.recipes import recipes_script
+from qt.scripts.talents import talents_script
+from qt.components.recipes import RecipesWidget
+from qt.scripts.recipes import recipes_script
 # from qt.components.consumables import ConsumablesWidget
 # from qt.scripts.consumables import consumables_script
 # from qt.components.bonuses import BonusesWidget
 # from qt.scripts.bonuses import bonuses_script
-# from qt.components.combat import CombatWidget
-# from qt.scripts.combat import combat_script
+from qt.components.dashboard import DashboardWidget
+from qt.scripts.dashboard import dashboard_script
 
-from PySide6.QtWidgets import QApplication, QMainWindow, QStyleFactory, QMessageBox, QVBoxLayout, QWidget, QTabWidget, \
-    QGridLayout
+from PySide6.QtWidgets import QApplication, QMainWindow, QStyleFactory, QVBoxLayout, QGridLayout, QWidget, QSizePolicy
 
 
 class MainWindow(QMainWindow):
@@ -30,9 +29,6 @@ class MainWindow(QMainWindow):
 
         icon = QIcon("qt/assets/icon.ico")
         self.setWindowIcon(icon)
-        self.message_box = QMessageBox()
-
-        self.message_box.setWindowIcon(icon)
 
         self.central_widget = QWidget(self)
         self.setCentralWidget(self.central_widget)
@@ -46,20 +42,31 @@ class MainWindow(QMainWindow):
         layout.addWidget(self.top_widget)
         layout.addWidget(self.config_widget)
 
+        self.dashboard_widget = DashboardWidget()
+        config_layout.addWidget(self.dashboard_widget, 0, 1)
+        self.dashboard_widget.setSizePolicy(QSizePolicy.Policy.MinimumExpanding, QSizePolicy.Policy.MinimumExpanding)
+
         self.equipments_widget = EquipmentsWidget()
         config_layout.addWidget(self.equipments_widget, 0, 0)
+        # self.equipments_widget.setSizePolicy(QSizePolicy.Policy.MinimumExpanding, QSizePolicy.Policy.MinimumExpanding)
+
+        self.talents_widget = TalentsWidget()
+        config_layout.addWidget(self.talents_widget, 1, 0)
+        # self.talents_widget.setSizePolicy(QSizePolicy.Policy.MinimumExpanding, QSizePolicy.Policy.MinimumExpanding)
 
-        self.talent_widget = TalentsWidget()
-        config_layout.addWidget(self.talent_widget, 0, 1)
+        self.recipes_widget = RecipesWidget()
+        config_layout.addWidget(self.recipes_widget, 2, 0)
+        # self.recipes_widget.setSizePolicy(QSizePolicy.Policy.MinimumExpanding, QSizePolicy.Policy.MinimumExpanding)
 
-        parser = top_script(self.top_widget, self.config_widget, self.equipments_widget, self.talent_widget)
+        parser = top_script(
+            self.top_widget, self.config_widget, self.dashboard_widget,
+            self.equipments_widget, self.talents_widget, self.recipes_widget
+        )
         equipments = equipments_script(self.equipments_widget)
+        talents = talents_script(self.talents_widget)
+        recipes = recipes_script(self.recipes_widget)
+        dashboard_script(parser, equipments, talents, recipes, self.dashboard_widget)
 
-        #
-        # config_layout.addWidget(self.equipments_widget, 1, 0)
-        #
-        # config_layout.addWidget(self.equipments_widget, 1, 1)
-        #
         # self.talents_widget = TalentsWidget()
         # self.tab_widget.addTab(self.talents_widget, "奇穴")
         #

qt/components/__init__.py

@@ -1,5 +1,5 @@
 from PySide6.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QLabel, QAbstractItemView, QTableWidgetItem, \
-    QHeaderView, QSizePolicy
+    QHeaderView, QSizePolicy, QListWidgetItem, QSpacerItem
 from PySide6.QtWidgets import QComboBox, QRadioButton, QTextBrowser, QTextEdit, QSpinBox, QListWidget, QTableWidget
 from PySide6.QtCore import Qt
 
@@ -31,34 +31,39 @@ class TableWithLabel(LabelWidget):
         if headers:
             self.table.setColumnCount(len(headers))
             self.table.setHorizontalHeaderLabels(headers)
+        else:
+            self.table.horizontalHeader().setVisible(False)
 
         self.table.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
+        self.table.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeMode.Stretch)
+        self.table.verticalHeader().setSectionResizeMode(QHeaderView.ResizeMode.Stretch)
+        self.table.verticalHeader().setVisible(False)
 
         layout.addWidget(self.label)
         layout.addWidget(self.table)
 
-        layout.addStretch()
-
     def set_content(self, content):
         self.table.setRowCount(len(content))
 
         for i, row in enumerate(content):
             for j, e in enumerate(row):
                 self.table.setItem(i, j, QTableWidgetItem(e))
+
         self.table.resizeColumnsToContents()
 
 
 class ListWithLabel(LabelWidget):
-    def __init__(self, label, items: list = None):
+    def __init__(self, label, max_select: int = 4, items: list = None):
         super().__init__(label)
-        layout = QVBoxLayout()
-        self.setLayout(layout)
+        layout = QVBoxLayout(self)
+
+        self.max_select = max_select
 
         self.list = QListWidget()
         self.list.setSelectionMode(QAbstractItemView.SelectionMode.MultiSelection)
 
         if items:
-            self.list.addItems(items)
+            self.set_items(items)
         layout.addWidget(self.label)
         layout.addWidget(self.list)
 
@@ -86,11 +91,12 @@ class ComboWithLabel(LabelWidget):
 
         layout.addStretch()
 
-    def set_items(self, items):
+    def set_items(self, items, default_index=0):
         self.combo_box.blockSignals(True)
         self.combo_box.clear()
         self.combo_box.addItems(items)
         self.combo_box.blockSignals(False)
+        self.combo_box.setCurrentIndex(default_index)
 
 
 class RadioWithLabel(LabelWidget):
@@ -125,7 +131,7 @@ class SpinWithLabel(LabelWidget):
         if maximum:
             self.spin_box.setMaximum(maximum + 1)
         else:
-            self.spin_box.setMaximum(10e8)
+            self.spin_box.setMaximum(10 ** 8)
 
         if value:
             self.spin_box.setValue(value)
@@ -173,3 +179,6 @@ class LabelWithLabel(QWidget):
         layout.addWidget(self.text)
 
         layout.addStretch()
+
+    def set_text(self, text):
+        self.text.setText(text)

qt/components/dashboard.py

@@ -0,0 +1,80 @@
+from PySide6.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QPushButton, QTabWidget
+
+from qt.components import ComboWithLabel, SpinWithLabel, TextWithLabel, LabelWithLabel, TableWithLabel
+from base.constant import SHIELD_BASE_MAP
+
+
+class DashboardWidget(QWidget):
+    def __init__(self):
+        super().__init__()
+        layout = QVBoxLayout()
+        self.setLayout(layout)
+
+        top = QWidget()
+        top_layout = QHBoxLayout(top)
+        layout.addWidget(top)
+
+        self.fight_select = ComboWithLabel("选择战斗")
+        top_layout.addWidget(self.fight_select)
+        self.target_level = ComboWithLabel("目标等级", items=[str(level) for level in SHIELD_BASE_MAP])
+        top_layout.addWidget(self.target_level)
+        self.duration = SpinWithLabel("战斗时长", maximum=3600, value=180)
+        top_layout.addWidget(self.duration)
+
+        self.button = QPushButton(text="开始模拟!")
+        layout.addWidget(self.button)
+
+        bottom = QWidget()
+        bottom_layout = QHBoxLayout(bottom)
+        layout.addWidget(bottom)
+
+        tab = QTabWidget()
+        bottom_layout.addWidget(tab, 2)
+        result = QWidget()
+        result_layout = QVBoxLayout(result)
+        bottom_layout.addWidget(result, 1)
+
+        attribute = QWidget()
+        attribute_layout = QHBoxLayout(attribute)
+        tab.addTab(attribute, "属性")
+
+        self.init_attribute = TableWithLabel("增益前属性", column_count=2)
+        attribute_layout.addWidget(self.init_attribute)
+        self.final_attribute = TableWithLabel("增益后属性", column_count=2)
+        attribute_layout.addWidget(self.final_attribute)
+
+        detail = QWidget()
+        detail_layout = QVBoxLayout(detail)
+        tab.addTab(detail, "伤害总结")
+        self.details = {}
+        self.skill_combo = ComboWithLabel("选择技能")
+        detail_layout.addWidget(self.skill_combo)
+        self.status_combo = ComboWithLabel("选择增益")
+        detail_layout.addWidget(self.status_combo)
+        detail_table = QWidget()
+        detail_table_layout = QHBoxLayout(detail_table)
+        self.damage_detail = TableWithLabel("伤害细节", column_count=2)
+        detail_table_layout.addWidget(self.damage_detail)
+        self.gradient_detail = TableWithLabel("属性收益", column_count=2)
+        detail_table_layout.addWidget(self.damage_detail)
+        detail_layout.addWidget(detail_table)
+
+        detail_layout.addStretch()
+
+        self.summary = TableWithLabel("伤害统计", headers=["技能/次数", "命中/%", "会心/%", "伤害/%"])
+
+        tab.addTab(self.summary, "战斗总结")
+
+        self.dps = LabelWithLabel("每秒伤害")
+        result_layout.addWidget(self.dps)
+
+        self.gradients = TableWithLabel("属性收益", column_count=2)
+
+        result_layout.addWidget(self.gradients)
+
+        result_layout.addStretch()
+
+        layout.addStretch()
+
+
+

qt/components/equipments.py

@@ -3,8 +3,8 @@ import os
 
 from qt.constant import POSITION_MAP, STONES_POSITIONS, EQUIPMENTS_DIR, ENCHANTS_DIR, STONES_DIR, MAX_STONE_ATTR
 from qt.constant import EMBED_POSITIONS, MAX_EMBED_LEVEL, MAX_STONE_LEVEL, SPECIAL_ENCHANT_POSITIONS
-from qt.components import ComboWithLabel, RadioWithLabel, TextWithLabel
-from PySide6.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QGridLayout, QTabWidget
+from qt.components import ComboWithLabel, RadioWithLabel, TableWithLabel
+from PySide6.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QGridLayout, QTabWidget, QSizePolicy, QSpacerItem
 from PySide6.QtCore import Qt
 
 
@@ -72,14 +72,15 @@ class EquipmentWidget(QWidget):
                 stone_attr = ComboWithLabel(f"五彩石属性-{i + 1}")
                 self.stone_attrs.append(stone_attr)
                 detail_layout.addWidget(stone_attr, 2, i + 1)
+        self.detail_widget.hide()
 
-        self.base_attr = TextWithLabel("基本属性")
+        self.base_attr = TableWithLabel("基本属性", column_count=2)
         output_layout.addWidget(self.base_attr)
-        self.magic_attr = TextWithLabel("精炼属性")
+        self.magic_attr = TableWithLabel("精炼属性", column_count=2)
         output_layout.addWidget(self.magic_attr)
-        self.embed_attr = TextWithLabel("镶嵌属性")
+        self.embed_attr = TableWithLabel("镶嵌属性", column_count=2)
         output_layout.addWidget(self.embed_attr)
-        output_layout.addStretch()
+        self.output_widget.hide()
 
 
 class EquipmentsWidget(QTabWidget):

qt/components/recipes.py

@@ -0,0 +1,27 @@
+from qt.components import ListWithLabel
+from PySide6.QtWidgets import QWidget, QGridLayout
+
+from qt.constant import MAX_RECIPE_SKILLS
+
+
+class RecipesWidget(QWidget):
+    def __init__(self):
+        super().__init__()
+        layout = QGridLayout()
+        self.setLayout(layout)
+
+        self.recipes = []
+
+        columns = 6
+        rows = MAX_RECIPE_SKILLS // columns
+        for i in range(rows):
+            for j in range(columns):
+                recipe = ListWithLabel("")
+                self.recipes.append(recipe)
+                layout.addWidget(recipe, i, j)
+        
+    def __getitem__(self, item) -> ListWithLabel:
+        return self.recipes[item]
+
+    def values(self) -> list[ListWithLabel]:
+        return self.recipes

qt/constant.py

@@ -1,10 +1,13 @@
 import os
+
+
 from dataclasses import dataclass
-from typing import Type, Dict, List
+from typing import Type, List, Dict
 
 from base.attribute import Attribute
 from base.buff import Buff
 from base.skill import Skill
+
 # from general.gains import equipment
 
 from schools import first
@@ -126,9 +129,24 @@ class School:
     kind: str
     attribute: Type[Attribute]
     formation: str
-    talents: List[Dict[int, Buff]]
+    talent_gains: List[Dict[int, Buff]]
+    talent_decoder: Dict[int, str]
+    talent_encoder: Dict[str, int]
+    recipe_gains: Dict[str, Dict[str, Buff]]
+    recipes: Dict[str, List[str]]
     skills: Dict[int, Skill]
     buffs: Dict[int, Buff]
+    display_attrs: Dict[str, str]
+
+    def attr_content(self, attribute):
+        content = []
+        for attr, name in self.display_attrs.items():
+            value = getattr(attribute, attr)
+            if isinstance(value, int):
+                content.append([name, f"{value}"])
+            else:
+                content.append([name, f"{round(value * 100, 2)}%"])
+        return content
 
 
 SUPPORT_SCHOOL = {
@@ -138,9 +156,30 @@ SUPPORT_SCHOOL = {
         kind="外功",
         attribute=first.BeiAoJue,
         formation="霜岚洗锋阵",
-        talents=first.TALENTS,
+        talent_gains=first.TALENT_GAINS,
+        talent_decoder=first.TALENT_DECODER,
+        talent_encoder=first.TALENT_ENCODER,
+        recipe_gains=first.RECIPE_GAINS,
+        recipes=first.RECIPES,
         skills=first.SKILLS,
-        buffs=first.BUFFS
+        buffs=first.BUFFS,
+        display_attrs={
+            "strength": "力道",
+            "base_physical_attack_power": "基础攻击",
+            "physical_attack_power": "攻击",
+            "base_physical_critical_strike": "会心等级",
+            "physical_critical_strike": "会心",
+            "physical_critical_power_base": "会效等级",
+            "physical_critical_power": "会效",
+            "base_physical_overcome": "基础破防",
+            "final_physical_overcome": "最终破防",
+            "physical_overcome": "破防",
+            "weapon_damage_base": "基础武器伤害",
+            "weapon_damage_rand": "浮动武器伤害",
+            "strain_base": "无双等级",
+            "strain": "无双",
+            "surplus": "破招",
+        }
     )
 }
 

qt/scripts/dashboard.py

@@ -0,0 +1,103 @@
+from PySide6.QtWidgets import QMessageBox
+
+from qt.components.dashboard import DashboardWidget
+from qt.constant import ATTR_TYPE_TRANSLATE
+from qt.scripts.top import Parser
+from qt.scripts.equipments import Equipments
+# from qt.scripts.consumables import Consumables
+# from qt.scripts.bonuses import Bonuses
+from qt.scripts.recipes import Recipes
+from qt.scripts.talents import Talents
+from utils.analyzer import analyze_details
+
+
+def summary_content(summary, total_damage):
+    content = []
+    for skill in sorted(summary, key=lambda x: summary[x]['damage'], reverse=True):
+        detail = summary[skill]
+        critical = round(detail['critical'], 2)
+        critical_rate = round(detail['critical'] / detail['count'] * 100, 2)
+        hit = round(detail['count'] - critical, 2)
+        hit_rate = round(100 - critical_rate, 2)
+        damage = round(detail['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}%"]
+        )
+    return content
+
+
+def detail_content(detail):
+    damage_content = [
+        ["命中伤害", f"{detail['damage']}"],
+        ["会心伤害", f"{detail['critical_damage']}"],
+        ["期望会心", f"{round(detail['critical_strike'] * 100, 2)}%"],
+        ["期望伤害", f"{round(detail['expected_damage'], 2)}"]
+    ]
+    gradient_content = [
+        [ATTR_TYPE_TRANSLATE[k], f"{round(v / detail['expected_damage'] * 100, 2)}%"]
+        for k, v in detail['gradients'].items()
+    ]
+
+    return damage_content, gradient_content
+
+
+def dashboard_script(parser: Parser,
+                     equipments: Equipments, talents: Talents, recipes: Recipes,
+                     # consumables: Consumables, bonuses: Bonuses,
+                     dashboard_widget: DashboardWidget):
+
+    def select_fight(text):
+        index = parser.record_index[text]
+        dashboard_widget.duration.set_value(parser.duration(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()]]
+
+        school = parser.school
+        attribute = school.attribute()
+        attribute.target_level = int(dashboard_widget.target_level.combo_box.currentText())
+        for attr, value in equipments.attrs.items():
+            setattr(attribute, attr, getattr(attribute, attr) + value)
+        # for attr, value in consumables.attrs.items():
+        #     setattr(attribute, attr, getattr(attribute, attr) + value)
+
+        dashboard_widget.init_attribute.set_content(school.attr_content(attribute))
+        # gains = sum([equipments.gains, talents.gains, recipes.gains, bonuses.gains], [])
+        #
+        # dashboard_widget.final_attribute.set_text(school.attr_text(attribute))
+        total_damage, total_gradient, details, summary = analyze_details(record, attribute, school)
+        dashboard_widget.dps.set_text(str(round(total_damage / duration)))
+        dashboard_widget.gradients.set_content(
+            [[ATTR_TYPE_TRANSLATE[k], f"{round(v, 2)}%"] for k, v in total_gradient.items()]
+        )
+        dashboard_widget.details = details
+        dashboard_widget.skill_combo.set_items(list(details), default_index=-1)
+        dashboard_widget.summary.set_content(summary_content(summary, total_damage))
+
+    dashboard_widget.button.clicked.connect(formulate)
+
+    def select_skill(skill):
+        if skill:
+            dashboard_widget.status_combo.set_items(list(dashboard_widget.details[skill]))
+        else:
+            dashboard_widget.status_combo.combo_box.clear()
+
+    dashboard_widget.skill_combo.combo_box.currentTextChanged.connect(select_skill)
+
+    def select_status(status):
+        if status:
+            skill = dashboard_widget.skill_combo.combo_box.currentText()
+            detail = dashboard_widget.details[skill][status]
+            damage_content, gradient_content = detail_content(detail)
+            dashboard_widget.damage_detail.set_content(damage_content)
+            dashboard_widget.gradient_detail.set_content(gradient_content)
+        else:
+            dashboard_widget.damage_detail.table.clear()
+            dashboard_widget.gradient_detail.table.clear()
+
+    dashboard_widget.status_combo.combo_box.currentTextChanged.connect(select_status)

qt/scripts/equipments.py

@@ -11,6 +11,9 @@ class Enchant:
     name: str
     attr: Dict[str, int]
 
+    def __init__(self):
+        self.clear()
+
     def clear(self):
         self.name = ""
         self.attr = {}
@@ -21,6 +24,9 @@ class Stone:
     level: int
     attr: Dict[str, int]
 
+    def __init__(self):
+        self.clear()
+
     def clear(self):
         self.name = ""
         self.attr = {}
@@ -40,6 +46,8 @@ class Equipment:
     set_gain: Dict[int, List[int]]
 
     def __init__(self, label):
+        self.clear()
+
         self.label = label
         self.position = POSITION_MAP[label]
 
@@ -87,21 +95,19 @@ class Equipment:
         }
 
     @property
-    def base_attr_text(self):
-        return "\n".join([f"{ATTR_TYPE_TRANSLATE[k]}:\t{v}" for k, v in self.base_attr.items()])
+    def base_attr_content(self):
+        return [[ATTR_TYPE_TRANSLATE[k], str(v)] for k, v in self.base_attr.items()]
 
     @property
-    def magic_attr_text(self):
+    def magic_attr_content(self):
         if strength_attr := self.strength_attr:
-            return "\n".join([
-                f"{ATTR_TYPE_TRANSLATE[k]}:\t{v}(+{strength_attr[k]})" for k, v in self.magic_attr.items()
-            ])
+            return [[ATTR_TYPE_TRANSLATE[k], f"{v}(+{strength_attr[k]})"] for k, v in self.magic_attr.items()]
         else:
-            return "\n".join([f"{ATTR_TYPE_TRANSLATE[k]}:\t{v}" for k, v in self.magic_attr.items()])
+            return [[ATTR_TYPE_TRANSLATE[k], f"{v}"] for k, v in self.magic_attr.items()]
 
     @property
-    def embed_attr_text(self):
-        return "\n".join([f"{ATTR_TYPE_TRANSLATE[k]}:\t{v}" for k, v in self.embed_attr.items()])
+    def embed_attr_content(self):
+        return [[ATTR_TYPE_TRANSLATE[k], str(v)] for k, v in self.embed_attr.items()]
 
 
 class Equipments:
@@ -177,8 +183,7 @@ def equipments_script(equipments_widget: EquipmentsWidget):
         widget = equipments_widget[label]
         equipment = equipments[label]
 
-        def inner(index):
-            equipment_name = widget.equipment.combo_box.currentText()
+        def inner(equipment_name):
 
             if not equipment_name:
                 equipment.clear()
@@ -197,7 +202,7 @@ def equipments_script(equipments_widget: EquipmentsWidget):
                 setattr(equipment, k, v)
 
             if equipment.base:
-                widget.base_attr.set_text(equipment.base_attr_text)
+                widget.base_attr.set_content(equipment.base_attr_content)
                 widget.base_attr.show()
             else:
                 widget.base_attr.hide()
@@ -211,7 +216,7 @@ def equipments_script(equipments_widget: EquipmentsWidget):
             if equipment.embed:
                 for i, (attr, value) in enumerate(equipment.embed.items()):
                     widget.embed_levels[i].set_label(f"镶嵌等级-{ATTR_TYPE_TRANSLATE[attr]}")
-                widget.embed_attr.set_text(equipment.embed_attr_text)
+                widget.embed_attr.set_content(equipment.embed_attr_content)
                 widget.embed_attr.show()
             else:
                 widget.embed_attr.hide()
@@ -228,8 +233,7 @@ def equipments_script(equipments_widget: EquipmentsWidget):
         widget = equipments_widget.equipments[label]
         equipment = equipments[label]
 
-        def inner(index):
-            enchant_name = widget.enchant.combo_box.currentText()
+        def inner(enchant_name):
             if enchant_name:
                 enchant_detail = widget.enchant_json[enchant_name]
                 equipment.enchant.name = enchant_name
@@ -244,7 +248,7 @@ def equipments_script(equipments_widget: EquipmentsWidget):
         widget = equipments_widget.equipments[label]
         equipment = equipments[label]
 
-        def inner(index):
+        def inner(_):
             if widget.special_enchant and widget.special_enchant.radio_button.isChecked():
                 equipment.special_enchant_gain = equipment.special_enchant
             else:
@@ -258,8 +262,8 @@ def equipments_script(equipments_widget: EquipmentsWidget):
 
         def inner(index):
             equipment.strength_level = index
-            if magic_attr_text := equipment.magic_attr_text:
-                widget.magic_attr.text_browser.setText(magic_attr_text)
+            if magic_attr_content := equipment.magic_attr_content:
+                widget.magic_attr.set_content(magic_attr_content)
                 widget.magic_attr.show()
             else:
                 widget.magic_attr.hide()
@@ -272,8 +276,8 @@ def equipments_script(equipments_widget: EquipmentsWidget):
 
         def inner(index):
             equipment.embed_levels[i] = index
-            if embed_attr_text := equipment.embed_attr_text:
-                widget.embed_attr.text_browser.setText(embed_attr_text)
+            if embed_attr_content := equipment.embed_attr_content:
+                widget.embed_attr.set_content(embed_attr_content)
                 widget.embed_attr.show()
             else:
                 widget.embed_attr.hide()
@@ -284,7 +288,7 @@ def equipments_script(equipments_widget: EquipmentsWidget):
         widget = equipments_widget.equipments[label]
         equipment = equipments[label]
 
-        def inner(index):
+        def inner(_):
             level = widget.stone_level.combo_box.currentText()
 
             current = widget.stones_json
@@ -297,10 +301,11 @@ def equipments_script(equipments_widget: EquipmentsWidget):
                 else:
                     break
             if level in current:
-                for k, v in current[level]:
+                for k, v in current[level].items():
                     setattr(equipment.stone, k, v)
             else:
                 widget.stone_attrs[i].set_items([""] + [ATTR_TYPE_TRANSLATE[k] for k in current])
+                equipment.stone = {}
 
             i += 1
             while i < len(widget.stone_attrs):
@@ -311,11 +316,11 @@ def equipments_script(equipments_widget: EquipmentsWidget):
 
     for equipment_label, equipment_widget in equipments_widget.items():
 
-        equipment_widget.equipment.combo_box.currentIndexChanged.connect(equipment_update(equipment_label))
+        equipment_widget.equipment.combo_box.currentTextChanged.connect(equipment_update(equipment_label))
         if equipment_widget.special_enchant:
             equipment_widget.special_enchant.radio_button.clicked.connect(special_enchant_update(equipment_label))
         if equipment_widget.enchant:
-            equipment_widget.enchant.combo_box.currentIndexChanged.connect(enchant_update(equipment_label))
+            equipment_widget.enchant.combo_box.currentTextChanged.connect(enchant_update(equipment_label))
         equipment_widget.strength_level.combo_box.currentIndexChanged.connect(strength_level_update(equipment_label))
         for n, embed_widget in enumerate(equipment_widget.embed_levels):
             embed_widget.combo_box.currentIndexChanged.connect(embed_level_update(n, equipment_label))

qt/scripts/recipes.py

@@ -0,0 +1,39 @@
+from qt.components.recipes import RecipesWidget
+
+from qt.constant import MAX_RECIPE_SKILLS, MAX_RECIPES
+
+
+class Recipes:
+    def __init__(self):
+        self.recipes = [[] for _ in range(MAX_RECIPE_SKILLS)]
+
+    def __getitem__(self, item):
+        return self.recipes[item]
+
+    def __setitem__(self, key, value):
+        self.recipes[key] = value
+
+    @property
+    def gains(self):
+        return [recipe for recipes in self.recipes for recipe in recipes]
+
+
+def recipes_script(recipes_widget: RecipesWidget):
+    recipes = Recipes()
+
+    def recipe_update(i):
+        widget = recipes_widget[i]
+
+        def inner():
+            skill = widget.label.text()
+            if selected_items := widget.list.selectedItems():
+                while len(selected_items) > MAX_RECIPES:
+                    selected_items.pop().setSelected(False)
+            recipes[i] = [(skill, item.text()) for item in selected_items]
+
+        return inner
+
+    for n, recipe_widget in enumerate(recipes_widget.values()):
+        recipe_widget.list.itemSelectionChanged.connect(recipe_update(n))
+
+    return recipes

qt/scripts/top.py

@@ -4,7 +4,9 @@ from PySide6.QtWidgets import QTabWidget, QFileDialog, QWidget
 
 from base.buff import Buff
 from base.skill import Skill
+from qt.components.dashboard import DashboardWidget
 from qt.components.equipments import EquipmentsWidget
+from qt.components.recipes import RecipesWidget
 from qt.components.talents import TalentsWidget
 from utils.lua import parse
 # from qt.components.equipments import EquipmentsWidget
@@ -21,11 +23,12 @@ from qt.constant import School, SUPPORT_SCHOOL, MAX_RECIPES, MAX_STONE_LEVEL
 
 
 class Parser:
-    records: dict
+    records: list
     status: dict
 
     start_time: list
     end_time: list
+    record_index: Dict[str, int]
 
     fight_flag: bool
 
@@ -33,15 +36,20 @@ class Parser:
 
     school: School | None
 
+    def duration(self, i):
+        return round((self.end_time[i] - self.start_time[i]) / 1000, 3)
+
     def reset(self):
         self.fight_flag = False
 
-        self.records = {}
+        self.records = []
         self.status = {}
 
         self.start_time = []
         self.end_time = []
 
+        self.record_index = {}
+
         self.school = None
 
     def parse_info(self, detail):
@@ -55,7 +63,7 @@ class Parser:
     def parse_time(self, detail, timestamp):
         if detail[1]:
             self.start_time.append(int(timestamp))
-            self.records[self.start_time[-1]] = {}
+            self.records.append({})
             self.fight_flag = True
         else:
             self.end_time.append(int(timestamp))
@@ -75,7 +83,7 @@ class Parser:
         if skill[0] not in self.school.skills:
             return
 
-        current_record = self.records[self.start_time[-1]]
+        current_record = self.records[len(self.start_time) - 1]
         if skill not in current_record:
             current_record[skill] = {}
         status = tuple(
@@ -102,26 +110,35 @@ class Parser:
             elif row[4] == "21" and self.fight_flag:
                 self.parse_skill(parse(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)
+        }
 
-def top_script(top_widget: TopWidget, config_widget: QWidget,
-               equipments_widget: EquipmentsWidget, talents_widget: TalentsWidget,
+
+def top_script(top_widget: TopWidget, config_widget: QWidget, dashboard_widget: DashboardWidget,
+               equipments_widget: EquipmentsWidget, talents_widget: TalentsWidget, recipes_widget: RecipesWidget,
                ):
-               # equipments_widget: EquipmentsWidget, talents_widget: TalentsWidget, recipes_widget: RecipesWidget,
-               # consumables_widget: ConsumablesWidget, bonuses_widget: BonusesWidget,
-               # combat_widget: CombatWidget):
+    # equipments_widget: EquipmentsWidget, talents_widget: TalentsWidget, recipes_widget: RecipesWidget,
+    # consumables_widget: ConsumablesWidget, bonuses_widget: BonusesWidget,
+    # combat_widget: CombatWidget):
     parser = Parser()
 
     def upload_logs():
         file_name = QFileDialog(top_widget, "Choose File").getOpenFileName()
         parser(file_name[0])
+        school = parser.school
+        """ 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]]))
 
         """ Update equipment options """
         for equipment_widget in equipments_widget.values():
             choices = [""]
             for name, detail in equipment_widget.equipment_json.items():
-                if detail['kind'] not in (parser.school.kind, parser.school.major):
+                if detail['kind'] not in (school.kind, school.major):
                     continue
-                if detail['school'] not in ("精简", "通用", parser.school.school):
+                if detail['school'] not in ("精简", "通用", school.school):
                     continue
                 choices.append(name)
 
@@ -132,10 +149,23 @@ def top_script(top_widget: TopWidget, config_widget: QWidget,
 
         """ Update talent options """
         for i, talent_widget in enumerate(talents_widget.values()):
-            talents = parser.school.talents[i]
-            default_index = list(talents).index(parser.select_talents[i]) + 1
-            talent_widget.set_items([""] + list(talents.values()))
-            talent_widget.combo_box.setCurrentIndex(default_index)
+            talents = list(school.talent_gains[i])
+            default_index = talents.index(parser.select_talents[i]) + 1
+            talent_widget.set_items([""] + [school.talent_decoder[talent] for talent in talents],
+                                    default_index=default_index)
+
+        """ Update recipe options """
+        for recipe_widget in recipes_widget.values():
+            recipe_widget.list.clear()
+            recipe_widget.hide()
+
+        for i, (skill, recipes) in enumerate(school.recipes.items()):
+            recipes_widget[i].set_label(skill)
+            recipes_widget[i].set_items(recipes)
+            for n in range(MAX_RECIPES):
+                recipes_widget[i].list.item(n).setSelected(True)
+            recipes_widget[i].show()
+
         config_widget.show()
 
     top_widget.upload_button.clicked.connect(upload_logs)

schools/first/__init__.py

@@ -1,4 +1,5 @@
 from schools.first.skills import SKILLS
 from schools.first.buffs import BUFFS
-from schools.first.talents import TALENTS
+from schools.first.talents import TALENT_GAINS, TALENT_DECODER, TALENT_ENCODER
+from schools.first.recipes import RECIPE_GAINS, RECIPES
 from schools.first.attribute import BeiAoJue

schools/first/recipes.py

@@ -1,71 +1,63 @@
-from typing import Dict, List, Tuple
+from typing import Dict, List
 
 from base.buff import Buff
 from base.recipe import damage_addition_recipe, critical_strike_recipe
 
-RECIPES: Dict[str, List[Tuple[str, dict]]] = {
-    "雷走风切": [
-        ("5%伤害", damage_addition_recipe([16631, 16599], 51)),
-        ("4%伤害", damage_addition_recipe([16631, 16599], 41)),
-        ("4%会心", critical_strike_recipe([16631, 16599], 400)),
-        ("3%伤害", damage_addition_recipe([16631, 16599], 31)),
-        ("3%会心", critical_strike_recipe([16631, 16599], 300)),
-        ("2%会心", critical_strike_recipe([16631, 16599], 200)),
-    ]
-    ,
-
-    "项王击鼎": [
-        ("5%伤害", damage_addition_recipe([16760, 16382], 51)),
-        ("4%伤害", damage_addition_recipe([16760, 16382], 41)),
-        ("4%会心", critical_strike_recipe([16760, 16382], 400)),
-        ("3%伤害", damage_addition_recipe([16760, 16382], 31)),
-        ("3%会心", critical_strike_recipe([16760, 16382], 300)),
-        ("2%会心", critical_strike_recipe([16760, 16382], 200)),
-    ]
-    ,
-
-    "破釜沉舟": [
-        ("5%伤害", damage_addition_recipe([20991], 51)),
-        ("4%伤害", damage_addition_recipe([20991], 41)),
-        ("4%会心", critical_strike_recipe([20991], 400)),
-        ("3%伤害", damage_addition_recipe([20991], 31)),
-        ("3%会心", critical_strike_recipe([20991], 300)),
-        ("2%会心", critical_strike_recipe([20991], 200)),
-    ]
-    ,
-
-    "上将军印": [
-        ("4%伤害", damage_addition_recipe([16803, 16802, 16801, 16800, 17043, 19423, 19424, 32859], 41)),
-        ("4%会心", critical_strike_recipe([16803, 16802, 16801, 16800, 17043, 19423, 19424], 400)),
-        ("3%伤害", damage_addition_recipe([16803, 16802, 16801, 16800, 17043, 19423, 19424, 32859], 31)),
-        ("3%会心", critical_strike_recipe([16803, 16802, 16801, 16800, 17043, 19423, 19424], 300)),
-        ("2%伤害", damage_addition_recipe([16803, 16802, 16801, 16800, 17043, 19423, 19424, 32859], 21)),
-        ("2%会心", critical_strike_recipe([16803, 16802, 16801, 16800, 17043, 19423, 19424], 200)),
-    ]
-    ,
-
-    "擒龙六斩": [
-        ("5%伤害", damage_addition_recipe([16933, 16934, 16935, 16936, 16937, 16938], 51)),
-        ("4%伤害", damage_addition_recipe([16933, 16934, 16935, 16936, 16937, 16938], 41)),
-        ("4%会心", critical_strike_recipe([16933, 16934, 16935, 16936, 16937, 16938], 400)),
-        ("3%伤害", damage_addition_recipe([16933, 16934, 16935, 16936, 16937, 16938], 31)),
-        ("3%会心", critical_strike_recipe([16933, 16934, 16935, 16936, 16937, 16938], 300)),
-        ("2%会心", critical_strike_recipe([16933, 16934, 16935, 16936, 16937, 16938], 200)),
-    ],
-    "刀啸风吟": [
-        ("5%伤害", damage_addition_recipe([16610], 51)),
-        ("4%伤害", damage_addition_recipe([16610], 41)),
-        ("4%会心", critical_strike_recipe([16610], 400)),
-        ("3%会心", critical_strike_recipe([16610], 300)),
-        ("2%会心", critical_strike_recipe([16610], 200)),
-    ]
-
+RECIPE_GAINS: Dict[str, Dict[str, dict | Buff]] = {
+    "雷走风切": {
+        "5%伤害": damage_addition_recipe([16631, 16599], 51),
+        "4%伤害": damage_addition_recipe([16631, 16599], 41),
+        "3%伤害": damage_addition_recipe([16631, 16599], 31),
+        "4%会心": critical_strike_recipe([16631, 16599], 400),
+        "3%会心": critical_strike_recipe([16631, 16599], 300),
+        "2%会心": critical_strike_recipe([16631, 16599], 200),
+    },
+    "项王击鼎": {
+        "5%伤害": damage_addition_recipe([16760, 16382], 51),
+        "4%伤害": damage_addition_recipe([16760, 16382], 41),
+        "3%伤害": damage_addition_recipe([16760, 16382], 31),
+        "4%会心": critical_strike_recipe([16760, 16382], 400),
+        "3%会心": critical_strike_recipe([16760, 16382], 300),
+        "2%会心": critical_strike_recipe([16760, 16382], 200),
+    },
+    "破釜沉舟": {
+        "5%伤害": damage_addition_recipe([20991], 51),
+        "4%伤害": damage_addition_recipe([20991], 41),
+        "3%伤害": damage_addition_recipe([20991], 31),
+        "4%会心": critical_strike_recipe([20991], 400),
+        "3%会心": critical_strike_recipe([20991], 300),
+        "2%会心": critical_strike_recipe([20991], 200),
+    },
+    "上将军印": {
+        "4%伤害": damage_addition_recipe([16803, 16802, 16801, 16800, 17043, 19423, 19424, 32859], 41),
+        "3%伤害": damage_addition_recipe([16803, 16802, 16801, 16800, 17043, 19423, 19424, 32859], 31),
+        "2%伤害": damage_addition_recipe([16803, 16802, 16801, 16800, 17043, 19423, 19424, 32859], 21),
+        "4%会心": critical_strike_recipe([16803, 16802, 16801, 16800, 17043, 19423, 19424], 400),
+        "3%会心": critical_strike_recipe([16803, 16802, 16801, 16800, 17043, 19423, 19424], 300),
+        "2%会心": critical_strike_recipe([16803, 16802, 16801, 16800, 17043, 19423, 19424], 200),
+    },
+    "擒龙六斩": {
+        "5%伤���": damage_addition_recipe([16933, 16934, 16935, 16936, 16937, 16938], 51),
+        "4%伤害": damage_addition_recipe([16933, 16934, 16935, 16936, 16937, 16938], 41),
+        "3%伤害": damage_addition_recipe([16933, 16934, 16935, 16936, 16937, 16938], 31),
+        "4%会心": critical_strike_recipe([16933, 16934, 16935, 16936, 16937, 16938], 400),
+        "3%会心": critical_strike_recipe([16933, 16934, 16935, 16936, 16937, 16938], 300),
+        "2%会心": critical_strike_recipe([16933, 16934, 16935, 16936, 16937, 16938], 200),
+    },
+    "刀啸风吟": {
+        "5%伤害": damage_addition_recipe([16610], 51),
+        "4%伤害": damage_addition_recipe([16610], 41),
+        "4%会心": critical_strike_recipe([16610], 400),
+        "3%会心": critical_strike_recipe([16610], 300),
+        "2%会心": critical_strike_recipe([16610], 200),
+    }
 }
 
-for skill_name, recipes in RECIPES.items():
-    for skill_name, detail in recipe.items():
-        if not detail:
-            continue
-        talent[talent_id] = Buff(talent_id, detail.pop("buff_name"))
-        for attr, value in detail.items():
-            setattr(talent[talent_id], attr, value)
+RECIPES: Dict[str, List[str]] = {
+    "雷走风切": ["5%伤害", "4%伤害", "3%伤害", "4%会心", "3%会心", "2%会心"], 
+    "项王击鼎": ["5%伤害", "4%伤害", "3%伤害", "4%会心", "3%会心", "2%会心"], 
+    "破釜沉舟": ["5%伤害", "4%伤害", "3%伤害", "4%会心", "3%会心", "2%会心"], 
+    "上将军印": ["4%伤害", "3%伤害", "2%伤害", "4%会心", "3%会心", "2%会心"], 
+    "擒龙六斩": ["5%伤害", "4%伤害", "3%伤害", "4%会心", "3%会心", "2%会心"], 
+    "刀啸风吟": ["5%伤害", "4%伤害", "4%会心", "3%会心", "2%会心"]
+}

schools/first/skills.py

@@ -1,6 +1,8 @@
-from base.skill import PhysicalDamage, PhysicalDotDamage
+from typing import Dict
 
-SKILLS = {
+from base.skill import PhysicalDamage, PhysicalDotDamage, Skill
+
+SKILLS: Dict[int, Skill | dict] = {
     32823: {
         "skill_class": PhysicalDamage,
         "skill_name": "破",
@@ -288,3 +290,6 @@ for skill_id, detail in SKILLS.items():
     SKILLS[skill_id] = detail.pop('skill_class')(skill_id, detail.pop('skill_name'))
     for attr, value in detail.items():
         setattr(SKILLS[skill_id], attr, value)
+
+SKILL_DECODER = {skill_id: skill.skill_name for skill_id, skill in SKILLS.items()}
+SKILL_ENCODER = {v: k for k, v in SKILL_DECODER.items()}

schools/first/talents.py

@@ -2,9 +2,9 @@ from typing import Dict, List
 
 from base.buff import Buff
 
-TALENTS: List[Dict[int, dict | Buff]] = [
-    {16691: {}},
-    {16847: {}},
+TALENT_GAINS: List[Dict[int, dict | Buff]] = [
+    {16691: {"buff_name": "龙息"}},
+    {16847: {"buff_name": "归酣"}},
     {
         26904: {
             "buff_name": "冥鼔",
@@ -35,12 +35,12 @@ TALENTS: List[Dict[int, dict | Buff]] = [
             }
         }
     },
-    {16799: {}},
-    {25633: {}},
-    {32857: {}},
-    {17047: {}},
+    {16799: {"buff_name": "霜天"}},
+    {25633: {"buff_name": "含风"}},
+    {32857: {"buff_name": "见尘"}},
+    {17047: {"buff_name": "分疆"}},
     {
-        25258: {},
+        25258: {"buff_name": "掠关"},
         16728: {
             "buff_name": "星火",
             "gain_attributes": {
@@ -56,7 +56,7 @@ TALENTS: List[Dict[int, dict | Buff]] = [
             }
         }
     },
-    {16737: {}},
+    {16737: {"buff_name": "楚歌"}},
     {
         17056: {
             "buff_name": "绝期",
@@ -67,14 +67,19 @@ TALENTS: List[Dict[int, dict | Buff]] = [
             }
         }
     },
-    {16893: {}},
-    {21858: {}}
+    {16893: {"buff_name": "重烟"}},
+    {21858: {"buff_name": "降麒式"}}
 ]
 
-for talent in TALENTS:
+for talent in TALENT_GAINS:
     for talent_id, detail in talent.items():
         if not detail:
-            continue
-        talent[talent_id] = Buff(talent_id, detail.pop("buff_name"))
+            talent[talent_id] = Buff()
+        else:
+            talent[talent_id] = Buff(talent_id, detail.pop("buff_name"))
         for attr, value in detail.items():
             setattr(talent[talent_id], attr, value)
+
+
+TALENT_DECODER = {talent_id: talent.buff_name for talents in TALENT_GAINS for talent_id, talent in talents.items()}
+TALENT_ENCODER = {v: k for k, v in TALENT_DECODER.items()}

schools/first/test.py

@@ -1,4 +1,4 @@
-from base.calculator import analyze_details
+from utils.analyzer import analyze_details
 from qt.scripts.top import Parser
 from schools.first.attribute import BeiAoJue
 
@@ -17,5 +17,5 @@ if __name__ == '__main__':
 
     parser = Parser()
     parser("logs.jcl")
-    analyze_details(parser, attribute)
+    analyze_details(parser, attribute, parser.school)
     print(parser.records)

utils/analyzer.py

@@ -0,0 +1,89 @@
+from base.attribute import Attribute
+from qt.scripts.top import School
+
+
+def refresh_status(existed_buffs, buffs, attribute: Attribute, school: School):
+    for buff in [buff for buff in existed_buffs if buff not in buffs]:
+        existed_buffs.remove(buff)
+        buff_id, buff_level, buff_stack = buff
+        buff = school.buffs[buff_id]
+        buff.buff_level, buff.buff_stack = buff_level, buff_stack
+        attribute = attribute - buff
+        school.skills = school.skills - buff
+
+    for buff in [buff for buff in buffs if buff not in existed_buffs]:
+        existed_buffs.append(buff)
+        buff_id, buff_level, buff_stack = buff
+        buff = school.buffs[buff_id]
+        buff.buff_level, buff.buff_stack = buff_level, buff_stack
+        attribute = attribute + buff
+        school.skills = school.skills + buff
+
+
+def analyze_details(record, attribute: Attribute, school: School):
+    details = {}
+    total_damage = 0
+    total_gradients = {attr: 0 for attr in attribute.grad_attrs}
+
+    existed_buffs = []
+    for skill, status in record.items():
+        skill_id, skill_level = skill
+        skill = school.skills[skill_id]
+        skill.skill_level = skill_level
+
+        skill_detail = {}
+        details[skill.display_name] = skill_detail
+        for buffs, timeline in status.items():
+            refresh_status(existed_buffs, buffs, attribute, school)
+
+            damage, critical_strike, critical_damage, expected_damage = skill(attribute)
+            gradients = analyze_gradients(skill, attribute)
+
+            total_damage += expected_damage * len(timeline)
+            for attr, residual_damage in gradients.items():
+                total_gradients[attr] += residual_damage * len(timeline)
+
+            buffs = ";".join(school.buffs[buff_id].display_name for buff_id, _, _ in buffs)
+            if not buffs:
+                buffs = "~-~-~"
+            skill_detail[buffs] = dict(
+                damage=damage,
+                critical_strike=critical_strike,
+                critical_damage=critical_damage,
+                expected_damage=expected_damage,
+                # "timeline": [round(t / 1000, 3) for t in timeline],
+                count=len(timeline),
+                gradients=gradients
+            )
+
+    refresh_status(existed_buffs, [], attribute, school)
+
+    for attr, residual_damage in total_gradients.items():
+        total_gradients[attr] = round(residual_damage / total_damage * 100, 4)
+
+    summary = analyze_summary(details)
+    return total_damage, total_gradients, details, summary
+
+
+def analyze_summary(details):
+    summary = {}
+    for skill, skill_detail in details.items():
+        skill = skill.split("/")[0]
+        if skill not in summary:
+            summary[skill] = {"count": 0, "hit": 0, "critical": 0, "damage": 0}
+        for buff, detail in skill_detail.items():
+            summary[skill]["count"] += detail['count']
+            summary[skill]["critical"] += detail['count'] * detail['critical_strike']
+            summary[skill]["damage"] += detail['count'] * detail['expected_damage']
+
+    return summary
+
+
+def analyze_gradients(skill, attribute):
+    results = {}
+    for attr, value in attribute.grad_attrs.items():
+        origin_value = getattr(attribute, attr)
+        setattr(attribute, attr, origin_value + value)
+        _, _, _, results[attr] = skill(attribute)
+        setattr(attribute, attr, origin_value)
+    return results