5.14 commit

.github/workflows/nuitka-app.yml

@@ -35,9 +35,9 @@ jobs:
         onefile: false
         enable-plugins: pyside6
         disable-console: true
-        windows-icon-from-ico: qt/assets/icon.ico
+        windows-icon-from-ico: assets/icon.ico
         nofollow-import-to: http,email
-        include-data-dir: qt/assets=qt/assets/
+        include-data-dir: assets=assets/
     - name: Upload Artifact
       uses: actions/upload-artifact@v4
       with:

.github/workflows/pyinstaller-app.yml

@@ -69,17 +69,16 @@ jobs:
         pip install pyside6
     - name: Build
       run: |
-        pyinstaller -F -w -i qt/assets/icon.ico qt/app.py 
+        pyinstaller -F -w -i assets/icon.ico qt/app.py 
         mv dist Formulator
-        mkdir Formulator/qt
-        mv qt/assets Formulator/qt/assets
+        mv assets Formulator/assets
         mkdir ${{ env.PACKAGENAME }}
         mv Formulator ${{ env.PACKAGENAME }}
         7z a -t7z -r "$($Env:PACKAGENAME + '.7z')" "Formulator"
     - name: Upload
       uses: actions/upload-artifact@v4
       with:
-        name: Formulator
+        name: ${{ env.PACKAGENAME }}
         path: ${{ env.PACKAGENAME }}
     - name: upload-win
       uses: actions/upload-release-asset@v1
@@ -90,3 +89,45 @@ jobs:
         asset_path: ${{ env.PACKAGENAME }}.7z
         asset_name: ${{ env.PACKAGENAME }}.7z
         asset_content_type: application/zip
+
+  macos:
+    needs: [ setup, release ]
+    runs-on: macos-11
+    env:
+      PACKAGENAME: ${{ needs.setup.outputs.PACKAGE_PREFIX }}_macos_x64
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python 3.11
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install pyinstaller
+          pip install pyside6
+          brew install create-dmg
+      - name: Build
+        run: |
+          cp assets/icon.icns ./
+          pyinstaller --clean --onedir --name Formulator --strip --windowed -i icon.icns qt/app.py 
+          rm -rf dist/Formulator
+          ln -s /Applications/   dist/Applications
+          xattr -cr dist/Formulator.app
+          create-dmg --volname "Formulator" ${{ env.PACKAGENAME }}.dmg dist/
+          zip -9 Formulator.zip ${{ env.PACKAGENAME }}.dmg
+      - name: Upload
+        uses: actions/upload-artifact@v2
+        with:
+          name: ${{ env.PACKAGENAME }}
+          path: Formulator.zip
+      - name: upload-macos
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ needs.release.outputs.Up_Url }}
+          asset_path: ${{ env.PACKAGENAME }}.dmg
+          asset_name: ${{ env.PACKAGENAME }}.dmg
+          asset_content_type: application/gzip

{qt → assets}/constant.py

@@ -1,20 +1,7 @@
 import os
 
-from dataclasses import dataclass
-from typing import Type, List, Dict, Union, Tuple
-
-from base.attribute import Attribute
-from base.buff import Buff
-from base.gain import Gain
-from base.skill import Skill
-
-# from general.gains import equipment
-
-from schools import bei_ao_jue
-
 """ Directory """
-# ASSETS_DIR = os.path.join(os.getcwd(), "qt/assets")
-ASSETS_DIR = "qt/assets"
+ASSETS_DIR = "assets"
 EQUIPMENTS_DIR = os.path.join(ASSETS_DIR, "equipments")
 ENCHANTS_DIR = os.path.join(ASSETS_DIR, "enchants")
 STONES_DIR = os.path.join(ASSETS_DIR, "stones.json")

get_assets.py

@@ -5,10 +5,10 @@ from functools import cache
 import requests
 from tqdm import tqdm
 
-from qt.constant import MAX_BASE_ATTR, MAX_MAGIC_ATTR, MAX_EMBED_ATTR, MAX_ENCHANT_ATTR
-from qt.constant import ATTR_TYPE_TRANSLATE
-from qt.constant import MAX_STONE_ATTR, MAX_STONE_LEVEL
-from qt.constant import EQUIPMENTS_DIR, ENCHANTS_DIR, STONES_DIR
+from assets.constant import MAX_BASE_ATTR, MAX_MAGIC_ATTR, MAX_EMBED_ATTR, MAX_ENCHANT_ATTR, STONES_DIR
+from assets.constant import ATTR_TYPE_TRANSLATE
+from assets.constant import MAX_STONE_ATTR, MAX_STONE_LEVEL
+from assets.constant import EQUIPMENTS_DIR, ENCHANTS_DIR
 from schools import SUPPORT_SCHOOL
 
 KINDS = set(sum([[school.kind, school.major] for school in SUPPORT_SCHOOL.values()], []))
@@ -320,6 +320,7 @@ def get_stones_list():
             if detail := get_stone_detail(row):
                 current = result
                 for attr in detail['attr']:
+                    attr = ATTR_TYPE_TRANSLATE[attr]
                     if attr not in current:
                         current[attr] = {}
                     current = current[attr]
@@ -370,4 +371,4 @@ if __name__ == '__main__':
     json.dump(
         get_weapon_enchants(), open(os.path.join(ENCHANTS_DIR, "secondary_weapon"), "w", encoding="utf-8")
     )
-    # json.dump(get_stones_list(), open(STONES_DIR, "w", encoding="utf-8"), ensure_ascii=False)
+    json.dump(get_stones_list(), open(STONES_DIR, "w", encoding="utf-8"), ensure_ascii=False)

gr/app.py

@@ -0,0 +1,42 @@
+from gr.components.top import TopComponent
+from gr.components.equipments import EquipmentsComponent
+from gr.components.talents import TalentsComponent
+from gr.components.recipes import RecipesComponent
+from gr.components.combat import CombatComponent
+
+from gr.scripts.top import top_script
+from gr.scripts.equipments import equipments_script
+from gr.scripts.talents import talents_script
+from gr.scripts.recipes import recipes_script
+from gr.scripts.combat import combat_script
+
+import gradio as gr
+
+
+def start():
+    with gr.Blocks(theme=gr.themes.Soft()) as app:
+        top_component = TopComponent()
+        with gr.Group(visible=False) as bottom_component:
+            with gr.Tab("装备"):
+                equipments_component = EquipmentsComponent()
+            with gr.Tab("奇穴"):
+                talents_component = TalentsComponent()
+            with gr.Tab("秘籍"):
+                recipes_component = RecipesComponent()
+            with gr.Tab("战斗"):
+                combat_component = CombatComponent()
+
+        parser = top_script(top_component, bottom_component,
+                            equipments_component, talents_component, recipes_component,
+                            combat_component)
+        equipments = equipments_script(equipments_component)
+        talents = talents_script(talents_component)
+        recipes = recipes_script(recipes_component)
+        combat_script(parser, talents, recipes, equipments, combat_component)
+
+    app.queue()
+    app.launch(allowed_paths=["."])
+
+
+if __name__ == '__main__':
+    start()

gr/components/combat.py

@@ -0,0 +1,32 @@
+import gradio as gr
+
+from base.constant import SHIELD_BASE_MAP
+
+
+class CombatComponent:
+    def __init__(self):
+        with gr.Row():
+            self.combat_duration = gr.Slider(label="战斗时长", step=0.01)
+            target_levels = list(SHIELD_BASE_MAP)
+            self.target_level = gr.Dropdown(choices=target_levels, value=target_levels[0], label="目标等级")
+        self.formulate = gr.Button("开始模拟")
+
+        with gr.Tab("属性"):
+            with gr.Row():
+                self.init_attribute = gr.Textbox("初始属性")
+                self.final_attribute = gr.Textbox("增益后属性")
+        with gr.Tab("伤害总结"):
+            self.skill_select = gr.Dropdown(label="选择技能")
+            self.status_select = gr.Dropdown(label="选择增益")
+            with gr.Row():
+                self.damage_detail = gr.Textbox(label="伤害细节")
+                self.gradient_detail = gr.Textbox(label="属性收益")
+        with gr.Tab("战斗统计"):
+            with gr.Row():
+                self.summary = gr.DataFrame(label="战斗总结", headers=["技能/次数", "命中/%", "会心/%", "伤害/%"], scale=3)
+                with gr.Column(scale=1):
+                    self.dps = gr.Textbox("每秒伤害")
+                    self.gradient = gr.Textbox("属性收益")
+
+
+

gr/components/equipments.py

@@ -0,0 +1,81 @@
+import json
+import os
+
+from assets.constant import POSITION_MAP, STONES_POSITIONS, EQUIPMENTS_DIR, ENCHANTS_DIR, STONES_DIR, MAX_STONE_ATTR, \
+    ATTR_TYPE_TRANSLATE
+from assets.constant import EMBED_POSITIONS, MAX_EMBED_LEVEL, MAX_STONE_LEVEL, SPECIAL_ENCHANT_POSITIONS
+import gradio as gr
+
+
+class EquipmentComponent:
+    def __init__(self, label):
+        self.position = POSITION_MAP[label]
+        self.equipment_json = json.load(open(os.path.join(EQUIPMENTS_DIR, self.position), encoding="utf-8"))
+        self.equipment_mapping = {v['id']: k for k, v in self.equipment_json.items()}
+        self.enchant_json = json.load(open(os.path.join(ENCHANTS_DIR, self.position), encoding="utf-8"))
+        self.enchant_mapping = {v['id']: k for k, v in self.enchant_json.items()}
+
+        self.equipment = gr.Dropdown(label="装备")
+        with gr.Row():
+            with gr.Column(scale=3) as self.detail:
+                with gr.Row():
+                    if not self.enchant_json:
+                        self.enchant = gr.Dropdown(visible=False)
+                    else:
+                        self.enchant = gr.Dropdown(choices=[""] + list(self.enchant_json), label="附魔")
+
+                    if self.position not in SPECIAL_ENCHANT_POSITIONS:
+                        self.special_enchant = gr.Checkbox(visible=False)
+                    else:
+                        self.special_enchant = gr.Checkbox(label="大附魔")
+
+                with gr.Row():
+                    self.strength_level = gr.Dropdown(label="精炼等级")
+
+                    self.embed_levels = []
+                    for i in range(EMBED_POSITIONS[self.position]):
+                        embed_level = gr.Dropdown(
+                            choices=list(range(MAX_EMBED_LEVEL + 1)), value=MAX_EMBED_LEVEL, visible=False
+                        )
+                        self.embed_levels.append(embed_level)
+
+                with gr.Row():
+                    if self.position not in STONES_POSITIONS:
+                        self.stones_json = None
+                        self.stone_level = gr.Dropdown(visible=False)
+                        self.stone_attrs = [gr.Dropdown(visible=False)] * MAX_STONE_ATTR
+                    else:
+                        self.stones_json = json.load(open(STONES_DIR, encoding="utf-8"))
+
+                        self.stone_level = gr.Dropdown(
+                            choices=list(range(MAX_STONE_LEVEL + 1)), value=MAX_STONE_LEVEL, label="五彩石等级"
+                        )
+                        self.stone_attrs = []
+                        for i in range(MAX_STONE_ATTR):
+                            if i:
+                                stone_attr = gr.Dropdown(label=f"五彩石属性-{i + 1}")
+                            else:
+                                stone_attr = gr.Dropdown(choices=list(self.stones_json), label=f"五彩石属性-{i + 1}")
+                            self.stone_attrs.append(stone_attr)
+
+            self.base_attr = gr.Textbox(label="基本属性", visible=False, scale=1, lines=5)
+            self.magic_attr = gr.Textbox(label="精炼属性", visible=False, scale=1, lines=5)
+            self.embed_attr = gr.Textbox(label="镶嵌属性", visible=False, scale=1, lines=5)
+
+
+class EquipmentsComponent:
+    def __init__(self):
+        super().__init__()
+        self.equipments = {}
+        for label in POSITION_MAP:
+            with gr.Tab(label):
+                self.equipments[label] = EquipmentComponent(label)
+
+    def __getitem__(self, item) -> EquipmentComponent:
+        return self.equipments[item]
+
+    def items(self):
+        return self.equipments.items()
+
+    def values(self):
+        return self.equipments.values()

gr/components/recipes.py

@@ -0,0 +1,24 @@
+import gradio as gr
+
+from assets.constant import MAX_RECIPE_SKILLS, MAX_RECIPES
+
+
+class RecipesComponent:
+    def __init__(self):
+
+        self.recipes = []
+
+        columns = 6
+        rows = MAX_RECIPE_SKILLS // columns
+
+        for i in range(rows):
+            with gr.Row():
+                for j in range(columns):
+                    recipe = gr.Dropdown(multiselect=True, max_choices=MAX_RECIPES, visible=False)
+                    self.recipes.append(recipe)
+
+    def __getitem__(self, item) -> gr.Dropdown:
+        return self.recipes[item]
+
+    def values(self) -> list[gr.Dropdown]:
+        return self.recipes

gr/components/talents.py

@@ -0,0 +1,25 @@
+from typing import List
+
+import gradio as gr
+
+from assets.constant import MAX_TALENTS
+
+
+class TalentsComponent:
+    def __init__(self):
+        self.talents = []
+
+        rows = 2
+        columns = MAX_TALENTS // rows
+
+        for i in range(rows):
+            with gr.Row():
+                for j in range(columns):
+                    talent = gr.Dropdown(label=f"奇穴第{i * columns + j + 1}层")
+                    self.talents.append(talent)
+
+    def __getitem__(self, item) -> gr.Dropdown:
+        return self.talents[item]
+
+    def values(self) -> List[gr.Dropdown]:
+        return self.talents

gr/components/top.py

@@ -0,0 +1,13 @@
+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):
+                self.player_select = gr.Dropdown(label="选择角色", visible=False)
+                self.target_select = gr.Dropdown(label="选择目标", visible=False)

gr/scripts/combat.py

@@ -0,0 +1,151 @@
+from typing import Dict
+
+from gr.components.combat import CombatComponent
+from assets.constant import ATTR_TYPE_TRANSLATE
+# from gr.scripts.bonuses import Bonuses
+# from gr.scripts.consumables import Consumables
+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
+
+import gradio as gr
+
+FULL_SPACE = "\u3000"
+
+
+def attribute_content(display_attrs, attribute):
+    content = []
+    for attr, name in 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
+
+
+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}%"]
+        )
+    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 detail_content(detail: Detail):
+    damage_content = "\n".join([
+        "命中伤害\t" + f"{round(detail.damage)}",
+        "会心伤害\t" + f"{round(detail.critical_damage)}",
+        "期望伤害\t" + f"{round(detail.expected_damage)}",
+        "期望会心\t" + f"{round(detail.critical_strike * 100, 2)}%",
+        "实际会心\t" + f"{round(detail.actual_critical_strike * 100, 2)}%",
+        "统计数量\t" + f"{detail.count}"
+    ])
+
+    return damage_content, gradient_content(detail.gradients, detail.expected_damage)
+
+
+def combat_script(
+        parser: Parser,
+        talents: Talents, recipes: Recipes, equipments: Equipments,
+        # consumables: Consumables, bonuses: Bonuses
+        combat_component: CombatComponent,
+):
+    def formulate(target_level, duration):
+        combat_update = {}
+        record = parser.current_records
+        school = parser.current_school
+
+        attribute = school.attribute()
+        attribute.target_level = target_level
+        for attr, value in equipments.attrs.items():
+            setattr(attribute, attr, getattr(attribute, attr) + value)
+        combat_update[combat_component.init_attribute] = gr.update(
+            value=attribute_content(school.display_attrs, attribute)
+        )
+        # for attr, value in consumables.attrs.items():
+        #     setattr(attribute, attr, getattr(attribute, attr) + value)
+
+        equipment_gains = [school.gains[gain] for gain in equipments.gains]
+        talent_gains = [school.talent_gains[school.talent_encoder[talent]] for talent in talents.gains]
+        recipe_gains = [
+            school.recipe_gains[skill][recipe]
+            for i, skill in enumerate(school.recipe_gains)
+            for recipe in recipes.gains[i]
+        ]
+        gains = equipment_gains + talent_gains + recipe_gains  # + bonuses.gains
+
+        for gain in gains:
+            gain.add(attribute, school.skills, school.buffs)
+
+        combat_update[combat_component.final_attribute] = gr.update(
+            value=attribute_content(school.display_attrs, attribute)
+        )
+        total, summary, details = analyze_details(record, duration, attribute, school)
+
+        for gain in gains:
+            gain.sub(attribute, school.skills, school.buffs)
+
+        combat_update[combat_component.dps] = gr.update(value=round(total.expected_damage / duration))
+
+        combat_update[combat_component.gradient] = gradient_content(total.gradients, total.expected_damage)
+        #
+        # dashboard_widget.detail_widget.details = details
+        # set_skills()
+
+        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.init_attribute, combat_component.final_attribute,
+         combat_component.dps, combat_component.gradient, combat_component.summary]
+    )
+
+    # def set_skills():
+    #     detail_widget = dashboard_widget.detail_widget
+    #     detail_widget.skill_combo.set_items(list(detail_widget.details), keep_index=True, default_index=-1)
+    #     set_status(None)
+    #
+    # def set_status(_):
+    #     detail_widget = dashboard_widget.detail_widget
+    #     skill = detail_widget.skill_combo.combo_box.currentText()
+    #     detail_widget.status_combo.set_items(
+    #         list(detail_widget.details.get(skill, {})), keep_index=True, default_index=-1
+    #     )
+    #     set_detail(None)
+    #
+    # dashboard_widget.detail_widget.skill_combo.combo_box.currentTextChanged.connect(set_status)
+    #
+    # def set_detail(_):
+    #     detail_widget = dashboard_widget.detail_widget
+    #     skill = detail_widget.skill_combo.combo_box.currentText()
+    #     status = detail_widget.status_combo.combo_box.currentText()
+    #     if detail := detail_widget.details.get(skill, {}).get(status):
+    #         damage_content, gradient_content = detail_content(detail)
+    #         detail_widget.damage_detail.set_content(damage_content)
+    #         detail_widget.gradient_detail.set_content(gradient_content)
+    #     else:
+    #         detail_widget.damage_detail.table.clear()
+    #         detail_widget.gradient_detail.table.clear()
+    #
+    # dashboard_widget.detail_widget.status_combo.combo_box.currentTextChanged.connect(set_detail)

{qt → gr}/scripts/equipments.py

@@ -1,11 +1,15 @@
 from collections import defaultdict
 from typing import Dict, List, Union, Tuple
 
+import gradio as gr
+
 from general.gains.equipment import EQUIPMENT_GAINS
-from qt.components.equipments import EquipmentsWidget
-from qt.constant import POSITION_MAP, STONES_POSITIONS, EMBED_POSITIONS
-from qt.constant import ATTR_TYPE_TRANSLATE, ATTR_TYPE_TRANSLATE_REVERSE
-from qt.constant import STRENGTH_COF, EMBED_COF, MAX_STRENGTH_LEVEL, MAX_EMBED_LEVEL
+from gr.components.equipments import EquipmentsComponent
+from assets.constant import POSITION_MAP, STONES_POSITIONS, EMBED_POSITIONS
+from assets.constant import ATTR_TYPE_TRANSLATE
+from assets.constant import STRENGTH_COF, EMBED_COF, MAX_STRENGTH_LEVEL, MAX_EMBED_LEVEL
+
+FULL_SPACE = "\u3000"
 
 
 class Enchant:
@@ -97,18 +101,27 @@ class Equipment:
 
     @property
     def base_attr_content(self):
-        return [[ATTR_TYPE_TRANSLATE[k], str(v)] for k, v in self.base_attr.items()]
+        return "\n".join(
+            ATTR_TYPE_TRANSLATE[k].ljust(10, FULL_SPACE) + str(v) for k, v in self.base_attr.items()
+        )
 
     @property
     def magic_attr_content(self):
         if strength_attr := self.strength_attr:
-            return [[ATTR_TYPE_TRANSLATE[k], f"{v}(+{strength_attr[k]})"] for k, v in self.magic_attr.items()]
+            return "\n".join(
+                ATTR_TYPE_TRANSLATE[k].ljust(10, FULL_SPACE) + f"{v}(+{strength_attr[k]})"
+                for k, v in self.magic_attr.items()
+            )
         else:
-            return [[ATTR_TYPE_TRANSLATE[k], f"{v}"] for k, v in self.magic_attr.items()]
+            return "\n".join(
+                ATTR_TYPE_TRANSLATE[k].ljust(10, FULL_SPACE) + str(v) for k, v in self.magic_attr.items()
+            )
 
     @property
     def embed_attr_content(self):
-        return [[ATTR_TYPE_TRANSLATE[k], str(v)] for k, v in self.embed_attr.items()]
+        return "\n".join(
+            ATTR_TYPE_TRANSLATE[k].ljust(10, FULL_SPACE) + str(v) for k, v in self.embed_attr.items()
+        )
 
 
 class Equipments:
@@ -117,7 +130,7 @@ class Equipments:
 
     def __getitem__(self, item) -> Equipment:
         return self.equipments[item]
-    
+
     @property
     def attrs(self):
         final_attrs = defaultdict(int)
@@ -177,67 +190,80 @@ class Equipments:
         return [tuple(gain) if isinstance(gain, list) else gain for gain in final_gains]
 
 
-def equipments_script(equipments_widget: EquipmentsWidget):
+def equipments_script(equipments_component: EquipmentsComponent):
     equipments = Equipments()
 
-    def equipment_update(label):
-        widget = equipments_widget[label]
-        equipment = equipments[label]
-
+    def equipment_changed(label):
         def inner(equipment_name):
-
+            equipment = equipments[label]
+            component = equipments_component[label]
             if not equipment_name:
                 equipment.clear()
-                widget.detail_widget.hide()
-                return
+                return {
+                    component.equipment: gr.update(value=""),
+                    component.detail: gr.update(visible=False)
+                }
 
+            equipment_update = {}
             if equipment.strength_level == equipment.max_strength:
                 max_strength = True
             else:
                 max_strength = False
 
             equipment.name = equipment_name
-            equipment_detail = widget.equipment_json[equipment_name]
+            equipment_detail = component.equipment_json[equipment_name]
             for k, v in equipment_detail.items():
                 setattr(equipment, k, v)
 
             if equipment.base:
-                widget.base_attr.set_content(equipment.base_attr_content)
-                widget.base_attr.show()
+                equipment_update[component.base_attr] = gr.update(
+                    value=equipment.base_attr_content, visible=True
+                )
             else:
-                widget.base_attr.hide()
+                equipment_update[component.base_attr] = gr.update(visible=False)
+
+            if isinstance(equipment.special_enchant, list):
+                equipment.special_enchant = tuple(equipment.special_enchant)
+
+            if equipment.special_enchant:
+                equipment_update[component.special_enchant] = gr.update(
+                    label=EQUIPMENT_GAINS[equipment.special_enchant].gain_name
+                )
 
             if max_strength:
                 equipment.strength_level = equipment.max_strength
 
-            widget.strength_level.set_items([str(i) for i in range(equipment.max_strength + 1)])
-            widget.strength_level.combo_box.setCurrentIndex(equipment.strength_level)
+            equipment_update[component.strength_level] = gr.update(
+                choices=list(range(equipment.max_strength + 1)), value=equipment.strength_level
+            )
+            equipment_update[component.magic_attr] = gr.update(
+                value=equipment.magic_attr_content, visible=True
+            )
 
             if equipment.embed:
-                for i, (attr, value) in enumerate(equipment.embed.items()):
-                    widget.embed_levels[i].set_label(f"镶嵌等级-{ATTR_TYPE_TRANSLATE[attr]}\t")
-                widget.embed_attr.set_content(equipment.embed_attr_content)
-                widget.embed_attr.show()
+                for i, attr in enumerate(equipment.embed):
+                    embed_level_component = component.embed_levels[i]
+                    equipment_update[embed_level_component] = gr.update(
+                        label=f"镶嵌等级-{ATTR_TYPE_TRANSLATE[attr]}", visible=True
+                    )
+                equipment_update[component.embed_attr] = gr.update(
+                    value=equipment.embed_attr_content, visible=True
+                )
             else:
-                widget.embed_attr.hide()
+                for embed_level_component in component.embed_levels:
+                    equipment_update[embed_level_component] = gr.update(visible=False)
 
-            if isinstance(equipment.special_enchant, list):
-                equipment.special_enchant = tuple(equipment.special_enchant)
-
-            if equipment.special_enchant:
-                widget.special_enchant.set_text(EQUIPMENT_GAINS[equipment.special_enchant].gain_name)
-
-            widget.detail_widget.show()
+            equipment_update[component.detail] = gr.update(visible=True)
+            return equipment_update
 
         return inner
 
-    def enchant_update(label):
-        widget = equipments_widget.equipments[label]
-        equipment = equipments[label]
-
+    def enchant_changed(label):
         def inner(enchant_name):
+            equipment = equipments[label]
+            component = equipments_component[label]
             if enchant_name:
-                enchant_detail = widget.enchant_json[enchant_name]
+                enchant_detail = component.enchant_json[enchant_name]
                 equipment.enchant.name = enchant_name
                 for k, v in enchant_detail.items():
                     setattr(equipment.enchant, k, v)
@@ -246,89 +272,99 @@ def equipments_script(equipments_widget: EquipmentsWidget):
 
         return inner
 
-    def special_enchant_update(label):
-        widget = equipments_widget.equipments[label]
-        equipment = equipments[label]
-
-        def inner(_):
-            if widget.special_enchant and widget.special_enchant.radio_button.isChecked():
+    def special_enchant_changed(label):
+        def inner(special_enchant_check):
+            equipment = equipments[label]
+            component = equipments_component[label]
+            if component.special_enchant and special_enchant_check:
                 equipment.special_enchant_gain = [equipment.special_enchant]
             else:
                 equipment.special_enchant_gain = []
 
         return inner
 
-    def strength_level_update(label):
-        widget = equipments_widget.equipments[label]
-        equipment = equipments[label]
-
-        def inner(index):
-            equipment.strength_level = index
+    def strength_level_changed(label):
+        def inner(strength_level):
+            equipment = equipments[label]
+            equipment.strength_level = strength_level
             if magic_attr_content := equipment.magic_attr_content:
-                widget.magic_attr.set_content(magic_attr_content)
-                widget.magic_attr.show()
+                return gr.update(value=magic_attr_content, visible=True)
             else:
-                widget.magic_attr.hide()
+                return gr.update(visible=False)
 
         return inner
 
-    def embed_level_update(i, label):
-        widget = equipments_widget.equipments[label]
-        equipment = equipments[label]
-
-        def inner(index):
-            equipment.embed_levels[i] = index
+    def embed_level_changed(i, label):
+        def inner(embed_level):
+            equipment = equipments[label]
+            equipment.embed_levels[i] = embed_level
             if embed_attr_content := equipment.embed_attr_content:
-                widget.embed_attr.set_content(embed_attr_content)
-                widget.embed_attr.show()
+                return gr.update(value=embed_attr_content, visible=True)
             else:
-                widget.embed_attr.hide()
+                return gr.update(visible=False)
 
         return inner
 
-    def stone_update(label):
-        widget = equipments_widget.equipments[label]
-        equipment = equipments[label]
-
-        def inner(_):
-            level = widget.stone_level.combo_box.currentText()
+    def stone_changed(label):
+        def inner(stone_level, *stone_attrs):
+            equipment = equipments[label]
+            component = equipments_component[label]
 
-            current = widget.stones_json
+            current = component.stones_json
             i = 0
-            while i < len(widget.stone_attrs):
-                attr = ATTR_TYPE_TRANSLATE_REVERSE.get(widget.stone_attrs[i].combo_box.currentText())
-                if attr in current:
-                    current = current[attr]
+            for stone_attr in stone_attrs:
+                if stone_attr in current:
+                    current = current[stone_attr]
                     i += 1
                 else:
                     break
-            if level in current:
-                for k, v in current[level].items():
+
+            stone_update = {component.stone_level: gr.update()}
+            stone_level = str(stone_level)
+            if stone_level in current:
+                for k, v in current[stone_level].items():
                     setattr(equipment.stone, k, v)
-            else:
-                widget.stone_attrs[i].set_items([""] + [ATTR_TYPE_TRANSLATE[k] for k in current])
-                equipment.stone = Stone()
+                return stone_update
+
+            equipment.stone = Stone()
+            stone_update[component.stone_attrs[i]] = gr.Dropdown(
+                choices=list(current)
+            )
 
             i += 1
-            while i < len(widget.stone_attrs):
-                widget.stone_attrs[i].set_items([""])
+            while i < len(stone_attrs):
+                stone_update[component.stone_attrs[i]] = gr.Dropdown(
+                    choices=[]
+                )
                 i += 1
+            return stone_update
 
         return inner
 
-    for equipment_label, equipment_widget in equipments_widget.items():
-
-        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.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))
-        if equipment_widget.stones_json:
-            equipment_widget.stone_level.combo_box.currentIndexChanged.connect(stone_update(equipment_label))
-            for stone_attr in equipment_widget.stone_attrs:
-                stone_attr.combo_box.currentIndexChanged.connect(stone_update(equipment_label))
+    for equipment_label, equipment_component in equipments_component.items():
+        equipment_component.equipment.change(
+            equipment_changed(equipment_label), equipment_component.equipment,
+            [equipment_component.detail, equipment_component.special_enchant,
+             equipment_component.base_attr, equipment_component.magic_attr, equipment_component.embed_attr,
+             equipment_component.strength_level, *equipment_component.embed_levels]
+        )
+        equipment_component.enchant.change(enchant_changed(equipment_label), equipment_component.enchant)
+        equipment_component.special_enchant.change(
+            special_enchant_changed(equipment_label), equipment_component.special_enchant
+        )
+        equipment_component.strength_level.change(
+            strength_level_changed(equipment_label), equipment_component.strength_level, equipment_component.magic_attr
+        )
+        for n, embed_component in enumerate(equipment_component.embed_levels):
+            embed_component.change(
+                embed_level_changed(n, equipment_label), embed_component, equipment_component.embed_attr)
+        stone_components = [equipment_component.stone_level] + equipment_component.stone_attrs
+        equipment_component.stone_level.change(
+            stone_changed(equipment_label), stone_components, stone_components
+        )
+        for stone_attr_component in equipment_component.stone_attrs:
+            stone_attr_component.change(
+                stone_changed(equipment_label), stone_components, stone_components
+            )
 
     return equipments

{qt → gr}/scripts/recipes.py

@@ -1,6 +1,6 @@
-from qt.components.recipes import RecipesWidget
+from gr.components.recipes import RecipesComponent
 
-from qt.constant import MAX_RECIPE_SKILLS, MAX_RECIPES
+from assets.constant import MAX_RECIPE_SKILLS
 
 
 class Recipes:
@@ -15,25 +15,22 @@ class Recipes:
 
     @property
     def gains(self):
-        return [recipe for recipes in self.recipes for recipe in recipes]
+        return self.recipes
 
 
-def recipes_script(recipes_widget: RecipesWidget):
+def recipes_script(recipes_component: RecipesComponent):
     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]
+    def recipe_changed(i):
+        def inner(recipe_list):
+            if recipe_list:
+                recipes[i] = recipe_list
+            else:
+                recipes[i] = []
 
         return inner
 
-    for n, recipe_widget in enumerate(recipes_widget.values()):
-        recipe_widget.list.itemSelectionChanged.connect(recipe_update(n))
+    for n, recipe_component in enumerate(recipes_component.values()):
+        recipe_component.change(recipe_changed(n), recipe_component)
 
     return recipes

{qt → gr}/scripts/talents.py

@@ -1,6 +1,6 @@
-from qt.components.talents import TalentsWidget
+from gr.components.talents import TalentsComponent
 
-from qt.constant import MAX_TALENTS
+from assets.constant import MAX_TALENTS
 
 
 class Talents:
@@ -18,21 +18,16 @@ class Talents:
         return [talent for talent in self.talents if talent]
 
 
-def talents_script(talents_widget: TalentsWidget):
+def talents_script(talents_component: TalentsComponent):
     talents = Talents()
 
-    def talent_update(i):
-        widget = talents_widget[i]
-
-        def inner(index):
-            if talent := widget.combo_box.currentText():
-                talents[i] = talent
-            else:
-                talents[i] = ""
+    def talent_changed(i):
+        def inner(talent):
+            talents[i] = talent
 
         return inner
 
-    for n, talent_widget in enumerate(talents_widget.values()):
-        talent_widget.combo_box.currentIndexChanged.connect(talent_update(n))
+    for n, talent_component in enumerate(talents_component.values()):
+        talent_component.change(talent_changed(n), talent_component)
 
     return talents

gr/scripts/top.py

@@ -0,0 +1,174 @@
+import json
+
+import gradio as gr
+
+from general.consumables import FOODS, POTIONS, WEAPON_ENCHANTS, SNACKS, WINES, SPREADS
+from general.gains.formation import FORMATIONS
+from gr.components.top import TopComponent
+from gr.components.equipments import EquipmentsComponent
+from gr.components.talents import TalentsComponent
+from gr.components.recipes import RecipesComponent
+from gr.components.combat import CombatComponent
+from assets.constant import MAX_RECIPES, MAX_EMBED_ATTR, MAX_EMBED_LEVEL
+from schools import SUPPORT_SCHOOL
+from utils.parser import Parser
+from utils.io import serialize, unserialize
+
+
+def top_script(
+        top_component: TopComponent, bottom_component: gr.Group,
+        equipments_component: EquipmentsComponent,
+        talents_component: TalentsComponent, recipes_component: RecipesComponent,
+        combat_component: CombatComponent
+):
+    parser = Parser()
+
+    def save_json():
+        result = dict(
+            records=serialize(parser.records),
+            file_name=parser.file_name,
+            start_frame=parser.start_frame,
+            end_frame=parser.end_frame,
+            id2name=parser.id2name,
+            name2id=parser.name2id,
+            players={player_id: school.id for player_id, school in parser.players.items()},
+            targets=parser.targets,
+            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
+
+    def upload_log(file_path):
+        if not file_path:
+            return [None] * 4
+        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)
+
+    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]
+    )
+
+    def load_json(file_path):
+        if not file_path:
+            return [None] * 4
+        result = json.load(open(file_path, encoding="utf-8"))
+
+        file_name = 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 player_select(player_name):
+        if not player_name:
+            return {}
+        player_id = parser.name2id[player_name]
+        parser.current_player = player_id
+        school = parser.players[player_id]
+
+        top_update = {
+            top_component.target_select: gr.update(
+                choices=[""] + [parser.id2name[target_id] for target_id in parser.current_targets],
+            ),
+            combat_component.combat_duration: gr.update(value=parser.duration)
+        }
+
+        # """ Update config """
+        # config_choices = list(CONFIG.get(school.school, {}))
+        # config_widget.config_select.set_items(config_choices, default_index=-1)
+        # """ Update dashboard """
+        # dashboard_widget.duration.set_value(parser.duration)
+
+        """ Update talent options """
+        for i, talent_component in enumerate(talents_component.values()):
+            choices = [""] + [school.talent_decoder[talent] for talent in school.talents[i]]
+            value = school.talent_decoder[parser.select_talents[player_id][i]]
+            top_update[talent_component] = gr.update(choices=choices, value=value)
+
+        """ Update recipe options """
+        for recipe_component in recipes_component.values():
+            top_update[recipe_component] = gr.update(choices=[], visible=False)
+
+        for i, (skill, recipes) in enumerate(school.recipes.items()):
+            recipe_component = recipes_component[i]
+            values = recipes[:min(MAX_RECIPES, len(recipes))]
+            top_update[recipe_component] = gr.update(choices=recipes, value=values, label=skill, visible=True)
+
+        """ Update equipment options """
+        for label, equipment_component in equipments_component.items():
+            top_update[equipment_component.equipment] = equipment_update = gr.update()
+            top_update[equipment_component.enchant] = enchant_update = gr.update()
+            top_update[equipment_component.strength_level] = strength_level = gr.update()
+            embed_level_updates = [gr.update(value=MAX_EMBED_LEVEL)] * MAX_EMBED_ATTR
+            for i, embed_level in enumerate(equipment_component.embed_levels):
+                top_update[embed_level] = embed_level_updates[i]
+
+            equipment_update["choices"] = equipment_choices = [""]
+            for name, detail in equipment_component.equipment_json.items():
+                if detail['kind'] not in (school.kind, school.major):
+                    continue
+                if detail['school'] not in ("精简", "通用", school.school):
+                    continue
+                equipment_choices.append(name)
+            if select_equipment := parser.select_equipments[player_id].get(label, {}):
+                if equipment_name := equipment_component.equipment_mapping.get(select_equipment['equipment']):
+                    equipment_update["value"] = equipment_name
+                if enchant := equipment_component.enchant_mapping.get(select_equipment['enchant']):
+                    enchant_update["value"] = enchant
+                strength_level["value"] = select_equipment['strength_level']
+                for i, embed_level in enumerate(select_equipment['embed_levels']):
+                    embed_level_updates[i] = gr.update(value=embed_level)
+
+        return top_update
+        #
+        # """ Update consumable options """
+        # consumables_widget.major_food.set_items([""] + FOODS[school.major], keep_index=True)
+        # consumables_widget.minor_food.set_items([""] + FOODS[school.kind] + FOODS[""], keep_index=True)
+        # consumables_widget.major_potion.set_items([""] + POTIONS[school.major], keep_index=True)
+        # consumables_widget.minor_potion.set_items([""] + POTIONS[school.kind] + POTIONS[""], keep_index=True)
+        # consumables_widget.weapon_enchant.set_items([""] + WEAPON_ENCHANTS[school.kind], keep_index=True)
+        # consumables_widget.home_snack.set_items([""] + SNACKS[school.kind] + SNACKS[""], keep_index=True)
+        # consumables_widget.home_wine.set_items([""] + WINES[school.major] + WINES[""], keep_index=True)
+        # consumables_widget.spread.set_items([""] + SPREADS[school.major] + SPREADS[school.kind], keep_index=True)
+        #
+        # """ Update bonus options """
+        # bonus_widget.formation.formation.set_items([""] + FORMATIONS[school.kind] + FORMATIONS[""], keep_index=True)
+        # config_widget.show()
+        # bottom_widget.show()
+
+    top_component.player_select.change(
+        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]
+    )
+
+    def target_select(target_name):
+        target_id = parser.name2id.get(target_name, "")
+        parser.current_target = target_id
+
+    top_component.target_select.change(
+        target_select, top_component.target_select
+    )
+
+    return parser

qt/app.py

@@ -1,94 +0,0 @@
-import sys
-
-
-from PySide6.QtGui import QIcon
-
-from qt.components.top import TopWidget
-from qt.scripts.config import config_script
-from qt.scripts.top import top_script
-from qt.components.config import ConfigWidget
-from qt.components.equipments import EquipmentsWidget
-from qt.scripts.equipments import equipments_script
-from qt.components.consumables import ConsumablesWidget
-from qt.scripts.consumables import consumables_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.components.bonuses import BonusesWidget
-from qt.scripts.bonuses import bonuses_script
-from qt.components.dashboard import DashboardWidget
-from qt.scripts.dashboard import dashboard_script
-
-from PySide6.QtWidgets import QApplication, QMainWindow, QStyleFactory
-from PySide6.QtWidgets import QVBoxLayout, QHBoxLayout, QWidget, QTabWidget
-
-
-class MainWindow(QMainWindow):
-    def __init__(self):
-        super().__init__()
-
-        self.setWindowTitle("Formulator")
-
-        icon = QIcon("qt/assets/icon.ico")
-        self.setWindowIcon(icon)
-
-        self.central_widget = QWidget(self)
-        self.setCentralWidget(self.central_widget)
-
-        self.showMaximized()
-        layout = QVBoxLayout(self.central_widget)
-
-        self.top_widget = TopWidget()
-        layout.addWidget(self.top_widget, 1)
-
-        self.config_widget = ConfigWidget()
-        layout.addWidget(self.config_widget, 1)
-        self.config_widget.hide()
-
-        self.bottom_widget = QWidget()
-        layout.addWidget(self.bottom_widget, 8)
-        self.bottom_widget.hide()
-
-        bottom_layout = QHBoxLayout(self.bottom_widget)
-        self.detail_widget = QTabWidget()
-        self.dashboard_widget = DashboardWidget()
-        bottom_layout.addWidget(self.detail_widget, 1)
-        bottom_layout.addWidget(self.dashboard_widget, 1)
-
-        self.equipments_widget = EquipmentsWidget()
-        self.detail_widget.addTab(self.equipments_widget, "配装")
-        self.consumable_widget = ConsumablesWidget()
-        self.detail_widget.addTab(self.consumable_widget, "消耗品")
-        self.bonus_widget = BonusesWidget()
-        self.detail_widget.addTab(self.bonus_widget, "增益")
-        self.talents_widget = TalentsWidget()
-        self.detail_widget.addTab(self.talents_widget, "奇穴")
-        self.recipes_widget = RecipesWidget()
-        self.detail_widget.addTab(self.recipes_widget, "秘籍")
-
-        parser = top_script(
-            self.top_widget, self.config_widget, self.bottom_widget,
-            self.dashboard_widget, self.talents_widget, self.recipes_widget,
-            self.equipments_widget, self.consumable_widget, self.bonus_widget
-        )
-        config_script(
-            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)
-        recipes = recipes_script(self.recipes_widget)
-        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)
-
-
-if __name__ == "__main__":
-    app = QApplication(sys.argv)
-    app.setStyle(QStyleFactory.create('Fusion'))
-    window = MainWindow()
-    window.show()
-    sys.exit(app.exec())

qt/components/__init__.py

@@ -1,208 +0,0 @@
-from PySide6.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QLabel
-from PySide6.QtWidgets import QAbstractItemView, QTableWidgetItem, QHeaderView, QListView
-from PySide6.QtWidgets import QComboBox, QRadioButton, QLineEdit, QSpinBox, QDoubleSpinBox, QListWidget, QTableWidget
-
-
-class LabelWidget(QWidget):
-    def __init__(self, label, info: str = ""):
-        super().__init__()
-        if info:
-            self.label = QLabel(f"{label} - {info}")
-        else:
-            self.label = QLabel(label)
-
-    def set_label(self, label):
-        self.label.setText(label)
-
-
-class TableWithLabel(LabelWidget):
-    def __init__(self, label, row_count: int = 0, column_count: int = 0, headers: list = None):
-        super().__init__(label)
-        layout = QVBoxLayout()
-        self.setLayout(layout)
-
-        self.table = QTableWidget()
-
-        if row_count:
-            self.table.setRowCount(row_count)
-        if column_count:
-            self.table.setColumnCount(column_count)
-        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)
-
-    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))
-
-
-class ListWithLabel(LabelWidget):
-    def __init__(self, label, max_select: int = 4, items: list = None):
-        super().__init__(label)
-        layout = QVBoxLayout(self)
-
-        self.max_select = max_select
-
-        self.list = QListWidget()
-        self.list.setSelectionMode(QAbstractItemView.SelectionMode.MultiSelection)
-        self.list.setResizeMode(QListView.ResizeMode.Adjust)
-
-        if items:
-            self.set_items(items)
-        layout.addWidget(self.label)
-        layout.addWidget(self.list)
-
-    def set_items(self, items):
-        self.list.clear()
-        self.list.addItems(items)
-
-
-class ComboWithLabel(LabelWidget):
-    def __init__(self, label, info: str = "", items: list = None, index=None):
-        super().__init__(label, info)
-        layout = QVBoxLayout()
-        self.setLayout(layout)
-
-        self.combo_box = QComboBox()
-        self.items = []
-        if items:
-            self.set_items(items)
-        if index:
-            self.combo_box.setCurrentIndex(index)
-
-        layout.addWidget(self.label)
-        layout.addWidget(self.combo_box)
-
-        layout.addStretch()
-
-    def set_items(self, items, keep_index=False, default_index=0):
-        self.items = items
-        self.combo_box.blockSignals(True)
-        current_text = self.combo_box.currentText()
-        self.combo_box.clear()
-        self.combo_box.addItems(items)
-        self.combo_box.blockSignals(False)
-        if keep_index and current_text and current_text in items:
-            self.combo_box.setCurrentIndex(items.index(current_text))
-        else:
-            self.combo_box.setCurrentIndex(default_index)
-
-
-class RadioWithLabel(LabelWidget):
-    def __init__(self, label, text: str = None):
-        super().__init__(label)
-        layout = QVBoxLayout()
-        self.setLayout(layout)
-
-        self.radio_button = QRadioButton()
-        if text:
-            self.radio_button.setText(text)
-
-        layout.addWidget(self.label)
-        layout.addWidget(self.radio_button)
-
-        layout.addStretch()
-
-    def set_text(self, text):
-        self.radio_button.setText(text)
-
-
-class SpinWithLabel(LabelWidget):
-    def __init__(self, label, info="", minimum=None, maximum=None, value=None):
-        super().__init__(label, info)
-        layout = QVBoxLayout()
-        self.setLayout(layout)
-
-        self.spin_box = QSpinBox()
-        if minimum:
-            self.spin_box.setMinimum(minimum)
-
-        if maximum:
-            self.spin_box.setMaximum(maximum + 1)
-        else:
-            self.spin_box.setMaximum(10 ** 8)
-
-        if value:
-            self.spin_box.setValue(value)
-
-        layout.addWidget(self.label)
-        layout.addWidget(self.spin_box)
-
-        layout.addStretch()
-
-    def set_value(self, value):
-        self.spin_box.setValue(value)
-
-
-class DoubleSpinWithLabel(LabelWidget):
-    def __init__(self, label, info="", minimum=None, maximum=None, value=None):
-        super().__init__(label, info)
-        layout = QVBoxLayout()
-        self.setLayout(layout)
-
-        self.spin_box = QDoubleSpinBox()
-        if minimum:
-            self.spin_box.setMinimum(minimum)
-
-        if maximum:
-            self.spin_box.setMaximum(maximum + 1)
-        else:
-            self.spin_box.setMaximum(10 ** 8)
-
-        if value:
-            self.spin_box.setValue(value)
-
-        layout.addWidget(self.label)
-        layout.addWidget(self.spin_box)
-
-        layout.addStretch()
-
-    def set_value(self, value):
-        self.spin_box.setValue(value)
-
-class TextWithLabel(LabelWidget):
-    def __init__(self, label):
-        super().__init__(label)
-        layout = QVBoxLayout(self)
-
-        self.text_browser = QLineEdit()
-
-        layout.addWidget(self.label)
-        layout.addWidget(self.text_browser)
-
-        layout.addStretch()
-
-    def set_text(self, text):
-        self.text_browser.setText(text)
-
-
-class LabelWithLabel(QWidget):
-    def __init__(self, label):
-        super().__init__()
-        layout = QHBoxLayout()
-        self.setLayout(layout)
-
-        self.label = QLabel(label)
-        self.text = QLabel()
-        # self.text_browser.textChanged.connect(self.resize_height)
-
-        layout.addWidget(self.label)
-        layout.addWidget(self.text)
-
-        layout.addStretch()
-
-    def set_text(self, text):
-        self.text.setText(text)

qt/components/bonuses.py

@@ -1,239 +0,0 @@
-from general.gains.team import TEAM_GAIN_LIMIT
-from qt.components import ComboWithLabel, SpinWithLabel, RadioWithLabel
-from PySide6.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QGridLayout, QTabWidget
-
-
-class FormationWidget(QWidget):
-    def __init__(self):
-        super().__init__()
-        layout = QHBoxLayout()
-        self.setLayout(layout)
-
-        self.formation = ComboWithLabel("阵法")
-        layout.addWidget(self.formation)
-        self.core_rate = SpinWithLabel("四重覆盖(%)", maximum=100)
-        layout.addWidget(self.core_rate)
-        self.rate = SpinWithLabel("五重覆盖(%)", maximum=100)
-        layout.addWidget(self.rate)
-
-
-class TeamGainsWidget(QWidget):
-    def __init__(self):
-        super().__init__()
-        layout = QVBoxLayout(self)
-
-        self.team_gains = {}
-
-        self.real_formulation = RadioWithLabel("开启真实团队增益模拟(仅包括存在覆盖率的角色BUFF,不包含目标和常驻BUFF)")
-
-        layout.addWidget(self.real_formulation)
-
-        tabs = QTabWidget()
-        layout.addWidget(tabs)
-
-        tab = QWidget()
-        tab_layout = QGridLayout(tab)
-        tabs.addTab(tab, "七秀")
-
-        self.team_gains["袖气"] = RadioWithLabel("袖气", "常驻")
-        tab_layout.addWidget(self.team_gains["袖气"], 0, 0)
-
-        self.team_gains["左旋右转"] = {
-            "stack": SpinWithLabel("左旋右转", "层数", maximum=TEAM_GAIN_LIMIT["左旋右转"]["stack"]),
-            "rate": SpinWithLabel("左旋右转", "覆盖(%)", maximum=100)
-        }
-        tab_layout.addWidget(self.team_gains["左旋右转"]["stack"], 1, 0)
-        tab_layout.addWidget(self.team_gains["左旋右转"]["rate"], 1, 1)
-        self.team_gains["泠风解怀"] = {
-            "rate": SpinWithLabel("泠风解怀", "覆盖(%)", maximum=100)
-        }
-        tab_layout.addWidget(self.team_gains["泠风解怀"]["rate"], 2, 0)
-
-        tab = QWidget()
-        tab_layout = QGridLayout(tab)
-        tabs.addTab(tab, "天策")
-
-        self.team_gains["撼如雷"] = RadioWithLabel("撼如雷", "常驻")
-        tab_layout.addWidget(self.team_gains["撼如雷"], 0, 0)
-
-        self.team_gains["破风"] = {
-            "variety": ComboWithLabel("破风", "种类", ["", "破风", "劲风"])
-        }
-        tab_layout.addWidget(self.team_gains["破风"]["variety"], 1, 0)
-
-        self.team_gains["乘龙箭"] = {
-            "rate": SpinWithLabel("乘龙箭", "覆盖(%)", maximum=100)
-        }
-        tab_layout.addWidget(self.team_gains["乘龙箭"]["rate"], 2, 0)
-
-        self.team_gains["号令三军"] = {
-            "stack": SpinWithLabel("号令三军", "层数", maximum=TEAM_GAIN_LIMIT["号令三军"]["stack"]),
-            "rate": SpinWithLabel("号令三军", "覆盖(%)", maximum=100)
-        }
-        tab_layout.addWidget(self.team_gains["号令三军"]["stack"], 3, 0)
-        tab_layout.addWidget(self.team_gains["号令三军"]["rate"], 3, 1)
-
-        self.team_gains["激雷"] = {
-            "rate": SpinWithLabel("激雷", "覆盖(%)", maximum=100)
-        }
-        tab_layout.addWidget(self.team_gains["激雷"]["rate"], 4, 0)
-
-        tab = QWidget()
-        tab_layout = QGridLayout(tab)
-        tabs.addTab(tab, "少林")
-
-        self.team_gains["立地成佛"] = {
-            "rate": SpinWithLabel("立地成佛", "覆盖(%)", maximum=100)
-        }
-        tab_layout.addWidget(self.team_gains["立地成佛"]["rate"], 0, 0)
-
-        self.team_gains["舍身弘法"] = {
-            "stack": SpinWithLabel("舍身弘法", "层数", maximum=TEAM_GAIN_LIMIT["舍身弘法"]["stack"]),
-            "rate": SpinWithLabel("舍身弘法", "覆盖(%)", maximum=100)
-        }
-        tab_layout.addWidget(self.team_gains["舍身弘法"]["stack"], 1, 0)
-        tab_layout.addWidget(self.team_gains["舍身弘法"]["rate"], 1, 1)
-
-        tab = QWidget()
-        tab_layout = QGridLayout(tab)
-        tabs.addTab(tab, "万花")
-
-        self.team_gains["秋肃"] = RadioWithLabel("秋肃", "常驻")
-        tab_layout.addWidget(self.team_gains["秋肃"], 0, 0)
-
-        self.team_gains["皎素"] = {
-            "rate": SpinWithLabel("皎素", "覆盖(%)", maximum=100)
-        }
-        tab_layout.addWidget(self.team_gains["皎素"]["rate"], 1, 0)
-
-        tab = QWidget()
-        tab_layout = QGridLayout(tab)
-        tabs.addTab(tab, "纯阳")
-
-        self.team_gains["碎星辰"] = RadioWithLabel("碎星辰", "常驻")
-        tab_layout.addWidget(self.team_gains["碎星辰"], 0, 0)
-
-        self.team_gains["破苍穹"] = RadioWithLabel("破苍穹", "常驻")
-        tab_layout.addWidget(self.team_gains["破苍穹"], 1, 0)
-
-        tab = QWidget()
-        tab_layout = QGridLayout(tab)
-        tabs.addTab(tab, "藏剑")
-
-        self.team_gains["剑锋百锻"] = {
-            "rate": SpinWithLabel("剑锋百锻", "覆盖(%)", maximum=100)
-        }
-        tab_layout.addWidget(self.team_gains["剑锋百锻"]["rate"], 0, 0)
-
-        tab = QWidget()
-        tab_layout = QGridLayout(tab)
-        tabs.addTab(tab, "五毒")
-
-        self.team_gains["仙王蛊鼎"] = {
-            "rate": SpinWithLabel("仙王蛊鼎", "覆盖(%)", maximum=100)
-        }
-        tab_layout.addWidget(self.team_gains["仙王蛊鼎"]["rate"], 0, 0)
-
-        tab = QWidget()
-        tab_layout = QGridLayout(tab)
-        tabs.addTab(tab, "明教")
-
-        self.team_gains["戒火"] = RadioWithLabel("戒火", "常驻")
-        tab_layout.addWidget(self.team_gains["戒火"], 0, 0)
-
-        self.team_gains["朝圣言"] = {
-            "stack": SpinWithLabel("朝圣言", "层数", maximum=TEAM_GAIN_LIMIT["朝圣言"]["stack"]),
-            "rate": SpinWithLabel("朝圣言", "覆盖(%)", maximum=100),
-            "variety": ComboWithLabel("朝圣言", "种类", ["", "朝圣言", "圣浴明心"])
-        }
-        tab_layout.addWidget(self.team_gains["朝圣言"]["variety"], 1, 0)
-        tab_layout.addWidget(self.team_gains["朝圣言"]["stack"], 1, 1)
-        tab_layout.addWidget(self.team_gains["朝圣言"]["rate"], 1, 2)
-
-        tab = QWidget()
-        tab_layout = QGridLayout(tab)
-        tabs.addTab(tab, "丐帮")
-
-        self.team_gains["酒中仙"] = RadioWithLabel("酒中仙", "常驻")
-        tab_layout.addWidget(self.team_gains["酒中仙"], 0, 0)
-
-        tab = QWidget()
-        tab_layout = QGridLayout(tab)
-        tabs.addTab(tab, "苍云")
-
-        self.team_gains["虚弱"] = RadioWithLabel("虚弱", "常驻")
-        tab_layout.addWidget(self.team_gains["虚弱"], 0, 0)
-
-        self.team_gains["寒啸千军"] = {
-            "rate": SpinWithLabel("寒啸千军", "覆盖(%)", maximum=100)
-        }
-        tab_layout.addWidget(self.team_gains["寒啸千军"]["rate"], 1, 0)
-
-        self.team_gains["振奋"] = {
-            "stack": SpinWithLabel("振奋", "层数", maximum=TEAM_GAIN_LIMIT["振奋"]["stack"]),
-            "rate": SpinWithLabel("振奋", "覆盖(%)", maximum=100)
-        }
-        tab_layout.addWidget(self.team_gains["振奋"]["stack"], 2, 0)
-        tab_layout.addWidget(self.team_gains["振奋"]["rate"], 2, 1)
-
-        tab = QWidget()
-        tab_layout = QGridLayout(tab)
-        tabs.addTab(tab, "长歌")
-
-        self.team_gains["庄周梦"] = {
-            "stack": SpinWithLabel("庄周梦", "层数", maximum=TEAM_GAIN_LIMIT["庄周梦"]["stack"]),
-            "rate": SpinWithLabel("庄周梦", "覆盖(%)", maximum=100)
-        }
-        tab_layout.addWidget(self.team_gains["庄周梦"]["stack"], 0, 0)
-        tab_layout.addWidget(self.team_gains["庄周梦"]["rate"], 0, 1)
-        self.team_gains["弄梅"] = {
-            "rate": SpinWithLabel("弄梅", "覆盖(%)", maximum=100)
-        }
-        tab_layout.addWidget(self.team_gains["弄梅"]["rate"], 1, 0)
-
-        tab = QWidget()
-        tab_layout = QGridLayout(tab)
-        tabs.addTab(tab, "霸刀")
-
-        self.team_gains["疏狂"] = {
-            "rate": SpinWithLabel("疏狂", "覆盖(%)", maximum=100)
-        }
-        tab_layout.addWidget(self.team_gains["疏狂"]["rate"], 0, 0)
-
-        tab = QWidget()
-        tab_layout = QGridLayout(tab)
-        tabs.addTab(tab, "药宗")
-
-        self.team_gains["配伍"] = {
-            "rate": SpinWithLabel("配伍", "覆盖(%)", maximum=100)
-        }
-        tab_layout.addWidget(self.team_gains["配伍"]["rate"], 0, 0)
-
-        # self.team_gains["飘黄"] = {
-        #     "rate": SpinWithLabel("飘黄", "覆盖", maximum=100)
-        # }
-        # tab_layout.addWidget(self.team_gains["飘黄"]["rate"], 1, 0)
-
-        layout.addStretch()
-
-    def __getitem__(self, item):
-        return self.team_gains[item]
-
-    def items(self):
-        return self.team_gains.items()
-
-
-class BonusesWidget(QWidget):
-    def __init__(self):
-        super().__init__()
-        layout = QVBoxLayout()
-        self.setLayout(layout)
-
-        self.tab = QTabWidget()
-        layout.addWidget(self.tab)
-        self.formation = FormationWidget()
-        self.tab.addTab(self.formation, "阵法")
-        self.team_gains = TeamGainsWidget()
-        self.tab.addTab(self.team_gains, "团队增益")
-
-        layout.addStretch()

qt/components/config.py

@@ -1,26 +0,0 @@
-from PySide6.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QPushButton
-
-from qt.components import ComboWithLabel, TextWithLabel
-
-
-class ConfigWidget(QWidget):
-    def __init__(self):
-        super().__init__()
-        layout = QVBoxLayout(self)
-        top_layout = QHBoxLayout()
-        layout.addLayout(top_layout)
-        bottom_layout = QHBoxLayout()
-        layout.addLayout(bottom_layout)
-
-        self.config_select = ComboWithLabel("选择预设方案")
-        top_layout.addWidget(self.config_select, 1)
-        self.config_category = ComboWithLabel("选择导入类别", items=["全部", "装备", "消耗品", "增益"])
-        top_layout.addWidget(self.config_category, 1)
-        self.load_config = QPushButton("导入预设方案")
-        bottom_layout.addWidget(self.load_config, 2)
-        self.config_name = TextWithLabel("设置预设方案")
-        top_layout.addWidget(self.config_name, 2)
-        self.save_config = QPushButton("保存预设方案")
-        bottom_layout.addWidget(self.save_config, 1)
-        self.delete_config = QPushButton("删除预设方案")
-        bottom_layout.addWidget(self.delete_config, 1)