04.11 commit

.github/workflows/nuitka-app.yml

@@ -0,0 +1,45 @@
+# This workflow will install Python dependencies, run tests and lint with a single version of Python
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python
+
+name: Nuitka Packaging
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+permissions:
+  contents: write
+
+jobs:
+  build:
+
+    runs-on: windows-latest
+
+    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 pyside6
+    - uses: Nuitka/Nuitka-Action@main
+      with:
+        nuitka-version: main
+        script-name: qt/app.py
+        standalone: true
+        onefile: false
+        enable-plugins: pyside6
+        disable-console: true
+        windows-icon-from-ico: qt/assets/icon.ico
+        nofollow-import-to: http,email
+        include-data-dir: qt/assets=qt/assets/
+    - name: Upload Artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: Formulator
+        path: build/app.dist

base/attribute.py

@@ -4,56 +4,23 @@ from base.constant import *
 class Target:
     target_level: int = 124
 
-    _physical_shield_base: int = 0
-    _magical_shield_base: int = 0
-
-    _physical_shield_gain: int = 0
-    _magical_shield_gain: int = 0
+    physical_shield_base: int = 0
+    magical_shield_base: int = 0
+    physical_shield_gain: int = 0
+    magical_shield_gain: int = 0
 
     _all_vulnerable: float = 0
-    _physical_vulnerable: float = 0
-    _magical_vulnerable: float = 0
+    physical_vulnerable: float = 0
+    magical_vulnerable: float = 0
 
     @property
     def shield_base(self):
         raise NotImplementedError
 
-    @property
-    def physical_shield_base(self):
-        return SHIELD_BASE_MAP[self.target_level] + self._physical_shield_base
-
-    @physical_shield_base.setter
-    def physical_shield_base(self, physical_shield_base):
-        self._physical_shield_base = physical_shield_base
-
-    @property
-    def magical_shield_base(self):
-        return SHIELD_BASE_MAP[self.target_level] + self._magical_shield_base
-
-    @magical_shield_base.setter
-    def magical_shield_base(self, magical_shield_base):
-        self._magical_shield_base = magical_shield_base
-
     @property
     def shield_gain(self):
         raise NotImplementedError
 
-    @property
-    def physical_shield_gain(self):
-        return self._physical_shield_gain / BINARY_SCALE
-
-    @physical_shield_gain.setter
-    def physical_shield_gain(self, physical_shield_gain):
-        self._physical_shield_gain = physical_shield_gain
-
-    @property
-    def magical_shield_gain(self):
-        return self._magical_shield_gain / BINARY_SCALE
-
-    @magical_shield_gain.setter
-    def magical_shield_gain(self, magical_shield_gain):
-        self._magical_shield_gain = magical_shield_gain
-
     @property
     def vulnerable(self):
         raise NotImplementedError
@@ -69,22 +36,6 @@ class Target:
         self.magical_vulnerable += residual
         self._all_vulnerable = all_vulnerable
 
-    @property
-    def physical_vulnerable(self):
-        return self._physical_vulnerable / BINARY_SCALE
-
-    @physical_vulnerable.setter
-    def physical_vulnerable(self, physical_vulnerable):
-        self._physical_vulnerable = physical_vulnerable
-
-    @property
-    def magical_vulnerable(self):
-        return self._magical_vulnerable / BINARY_SCALE
-
-    @magical_vulnerable.setter
-    def magical_vulnerable(self, magical_vulnerable):
-        self._magical_vulnerable = magical_vulnerable
-
     @property
     def shield_constant(self):
         return SHIELD_SCALE * (LEVEL_SCALE * self.target_level - LEVEL_CONSTANT)
@@ -93,58 +44,32 @@ class Target:
 class Major:
     _all_major_base: int = 0
     _all_major_gain: int = 0
-    _agility_base: int = 0
-    _agility_gain: int = 0
-    _agility: int = 0
-    _strength_base: int = 0
-    _strength_gain: int = 0
-    _strength: int = 0
-    _spirit_base: int = 0
-    _spirit_gain: int = 0
-    _spirit: int = 0
-    _spunk_base: int = 0
-    _spunk_gain: int = 0
-    _spunk: int = 0
-
-    _physical_attack_power_base: int = 0
-    _base_physical_attack_power: int = 0
-    _physical_attack_power_gain: int = 0
-    _extra_physical_attack_power: int = 0
-    _physical_attack_power: int = 0
-    _magical_attack_power_base: int = 0
-    _base_magical_attack_power: int = 0
-    _magical_attack_power_gain: int = 0
-    _extra_magical_attack_power: int = 0
-    _magical_attack_power: int = 0
+    agility_base: int = 0
+    agility_gain: int = 0
+    strength_base: int = 0
+    strength_gain: int = 0
+    spirit_base: int = 0
+    spirit_gain: int = 0
+    spunk_base: int = 0
+    spunk_gain: int = 0
+
+    physical_attack_power_base: int = 0
+    physical_attack_power_gain: int = 0
+    magical_attack_power_base: int = 0
+    magical_attack_power_gain: int = 0
 
     _all_critical_strike_base: int = 0
     _all_critical_strike_gain: int = 0
 
-    _physical_critical_strike_base: int = 0
-    _base_physical_critical_strike: int = 0
-    _extra_physical_critical_strike: int = 0
-    _physical_critical_strike_percent: float = 0
-    _physical_critical_strike_gain: int = 0
-    _physical_critical_strike: float = 0
-    _magical_critical_strike_base: int = 0
-    _base_magical_critical_strike: int = 0
-    _extra_magical_critical_strike: int = 0
-    _magical_critical_strike_percent: float = 0
-    _magical_critical_strike_gain: int = 0
-    _magical_critical_strike: float = 0
-
-    _physical_overcome_base: int = 0
-    _base_physical_overcome: int = 0
-    _final_physical_overcome: int = 0
-    _physical_overcome_gain: int = 0
-    _extra_physical_overcome: int = 0
-    _physical_overcome: float = 0
-    _magical_overcome_base: int = 0
-    _base_magical_overcome: int = 0
-    _final_magical_overcome: int = 0
-    _magical_overcome_gain: int = 0
-    _extra_magical_overcome: int = 0
-    _magical_overcome: float = 0
+    physical_critical_strike_base: int = 0
+    physical_critical_strike_gain: int = 0
+    magical_critical_strike_base: int = 0
+    magical_critical_strike_gain: int = 0
+
+    physical_overcome_base: int = 0
+    physical_overcome_gain: int = 0
+    magical_overcome_base: int = 0
+    magical_overcome_gain: int = 0
 
     """ Major Attr Function"""
 
@@ -174,121 +99,21 @@ class Major:
         self.spunk_gain += residual
         self._all_major_gain = all_major_gain
 
-    @property
-    def agility_base(self):
-        return self._agility_base
-
-    @agility_base.setter
-    def agility_base(self, agility_base):
-        self._agility_base = agility_base
-        self.agility = agility_base * (1 + self.agility_gain)
-
-    @property
-    def agility_gain(self):
-        return self._agility_gain / BINARY_SCALE
-
-    @agility_gain.setter
-    def agility_gain(self, agility_gain):
-        self._agility_gain = agility_gain
-        self.agility = self.agility_base * (1 + self.agility_gain)
-
     @property
     def agility(self):
-        return self._agility
-
-    @agility.setter
-    def agility(self, agility):
-        agility = int(agility)
-        self._agility = agility
-        self.base_physical_critical_strike = (self.physical_critical_strike_base + self.extra_physical_critical_strike
-                                              + agility * AGILITY_TO_CRITICAL_STRIKE)
-
-    @property
-    def strength_base(self):
-        return self._strength_base
-
-    @strength_base.setter
-    def strength_base(self, strength_base):
-        self._strength_base = strength_base
-        self.strength = strength_base * (1 + self.strength_gain)
-
-    @property
-    def strength_gain(self):
-        return self._strength_gain / BINARY_SCALE
-
-    @strength_gain.setter
-    def strength_gain(self, strength_gain):
-        self._strength_gain = strength_gain
-        self.strength = self.strength_base * (1 + self.strength_gain)
+        return int(self.agility_base * (1 + self.agility_gain / BINARY_SCALE))
 
     @property
     def strength(self):
-        return self._strength
-
-    @strength.setter
-    def strength(self, strength):
-        strength = int(strength)
-        self._strength = strength
-        self.base_physical_attack_power = self.physical_attack_power_base + strength * STRENGTH_TO_ATTACK_POWER
-        self.base_physical_overcome = self.physical_overcome_base + strength * STRENGTH_TO_OVERCOME
-
-    @property
-    def spirit_base(self):
-        return self._spirit_base
-
-    @spirit_base.setter
-    def spirit_base(self, spirit_base):
-        self._spirit_base = spirit_base
-        self.spirit = spirit_base * (1 + self.spirit_gain)
-
-    @property
-    def spirit_gain(self):
-        return self._spirit_gain / BINARY_SCALE
-
-    @spirit_gain.setter
-    def spirit_gain(self, spirit_gain):
-        self._spirit_gain = spirit_gain
-        self.spirit = self.spirit_base * (1 + self.spirit_gain)
+        return int(self.strength_base * (1 + self.strength_gain / BINARY_SCALE))
 
     @property
     def spirit(self):
-        return self._spirit
-
-    @spirit.setter
-    def spirit(self, spirit):
-        spirit = int(spirit)
-        self._spirit = spirit
-        self.base_magical_critical_strike = (self.magical_critical_strike_base + self.extra_magical_critical_strike
-                                             + spirit * SPIRIT_TO_CRITICAL_STRIKE)
-
-    @property
-    def spunk_base(self):
-        return self._spunk_base
-
-    @spunk_base.setter
-    def spunk_base(self, spunk_base):
-        self._spunk_base = spunk_base
-        self.spunk = spunk_base * (1 + self.spunk_gain)
-
-    @property
-    def spunk_gain(self):
-        return self._spunk_gain / BINARY_SCALE
-
-    @spunk_gain.setter
-    def spunk_gain(self, spunk_gain):
-        self._spunk_gain = spunk_gain
-        self.spunk = self.spunk_base * (1 + self.spunk_gain)
+        return int(self.spirit_base * (1 + self.spirit_gain / BINARY_SCALE))
 
     @property
     def spunk(self):
-        return self._spunk
-
-    @spunk.setter
-    def spunk(self, spunk):
-        spunk = int(spunk)
-        self._spunk = spunk
-        self.base_magical_attack_power = self.magical_attack_power_base + spunk * SPUNK_TO_ATTACK_POWER
-        self.base_magical_overcome = self.magical_overcome_base + spunk * SPUNK_TO_OVERCOME
+        return int(self.spunk_base * (1 + self.spunk_gain / BINARY_SCALE))
 
     """ Attack Power Function """
 
@@ -296,109 +121,31 @@ class Major:
     def attack_power(self):
         raise NotImplementedError
 
-    @property
-    def physical_attack_power_base(self):
-        return self._physical_attack_power_base
-
-    @physical_attack_power_base.setter
-    def physical_attack_power_base(self, physical_attack_power_base):
-        self._physical_attack_power_base = physical_attack_power_base
-        self.base_physical_attack_power = physical_attack_power_base + self.strength * STRENGTH_TO_ATTACK_POWER
-
     @property
     def base_physical_attack_power(self):
-        return self._base_physical_attack_power
-
-    @base_physical_attack_power.setter
-    def base_physical_attack_power(self, base_physical_attack_power):
-        base_physical_attack_power = int(base_physical_attack_power)
-        self._base_physical_attack_power = base_physical_attack_power
-        self.physical_attack_power = (self.base_physical_attack_power +
-                                      self.base_physical_attack_power * self.physical_attack_power_gain +
-                                      self.extra_physical_attack_power)
-
-    @property
-    def physical_attack_power_gain(self):
-        return self._physical_attack_power_gain / BINARY_SCALE
-
-    @physical_attack_power_gain.setter
-    def physical_attack_power_gain(self, physical_attack_power_gain):
-        self._physical_attack_power_gain = physical_attack_power_gain
-        self.physical_attack_power = (self.base_physical_attack_power +
-                                      self.base_physical_attack_power * self.physical_attack_power_gain +
-                                      self.extra_physical_attack_power)
+        return int(self.physical_attack_power_base + self.strength * STRENGTH_TO_ATTACK_POWER)
 
     @property
     def extra_physical_attack_power(self):
-        return self._extra_physical_attack_power
-
-    @extra_physical_attack_power.setter
-    def extra_physical_attack_power(self, extra_physical_attack_power):
-        extra_physical_attack_power = int(extra_physical_attack_power)
-        self._extra_physical_attack_power = extra_physical_attack_power
-        self.physical_attack_power = (self.base_physical_attack_power +
-                                      self.base_physical_attack_power * self.physical_attack_power_gain +
-                                      self.extra_physical_attack_power)
+        return 0
 
     @property
     def physical_attack_power(self):
-        return self._physical_attack_power
-
-    @physical_attack_power.setter
-    def physical_attack_power(self, physical_attack_power):
-        self._physical_attack_power = int(physical_attack_power)
-
-    @property
-    def magical_attack_power_base(self):
-        return self._magical_attack_power_base
-
-    @magical_attack_power_base.setter
-    def magical_attack_power_base(self, magical_attack_power_base):
-        self._magical_attack_power_base = magical_attack_power_base
-        self.base_magical_attack_power = magical_attack_power_base + self.spunk_base * SPUNK_TO_ATTACK_POWER
+        return int(self.base_physical_attack_power * (1 + self.physical_attack_power_gain / BINARY_SCALE) +
+                   self.extra_physical_attack_power)
 
     @property
     def base_magical_attack_power(self):
-        return self._base_magical_attack_power
-
-    @base_magical_attack_power.setter
-    def base_magical_attack_power(self, base_magical_attack_power):
-        base_magical_attack_power = int(base_magical_attack_power)
-        self._base_magical_attack_power = base_magical_attack_power
-        self.magical_attack_power = (self.base_magical_attack_power +
-                                     self.base_magical_attack_power * self.magical_attack_power_gain +
-                                     self.extra_magical_attack_power)
-
-    @property
-    def magical_attack_power_gain(self):
-        return self._magical_attack_power_gain / BINARY_SCALE
-
-    @magical_attack_power_gain.setter
-    def magical_attack_power_gain(self, magical_attack_power_gain):
-        self._magical_attack_power_gain = magical_attack_power_gain
-        self.magical_attack_power = (self.base_magical_attack_power +
-                                     self.base_magical_attack_power * self.magical_attack_power_gain +
-                                     self.extra_magical_attack_power)
+        return int(self.magical_attack_power_base + self.spunk_base * SPUNK_TO_ATTACK_POWER)
 
     @property
     def extra_magical_attack_power(self):
-        return self._extra_magical_attack_power
-
-    @extra_magical_attack_power.setter
-    def extra_magical_attack_power(self, extra_magical_attack_power):
-        extra_magical_attack_power = int(extra_magical_attack_power)
-        self._extra_magical_attack_power = extra_magical_attack_power
-        self.magical_attack_power = (self.base_magical_attack_power +
-                                     self.base_magical_attack_power * self.magical_attack_power_gain +
-                                     self.extra_magical_attack_power)
+        return 0
 
     @property
     def magical_attack_power(self):
-        return self._magical_attack_power
-
-    @magical_attack_power.setter
-    def magical_attack_power(self, magical_attack_power):
-        self._magical_attack_power = int(magical_attack_power)
+        return int(self.base_magical_attack_power * (1 + self.magical_attack_power_gain / BINARY_SCALE) +
+                   self.extra_magical_attack_power)
 
     """ Critical Strike Function"""
 
@@ -428,119 +175,39 @@ class Major:
         self.magical_critical_strike_gain += residual
         self._all_critical_strike_gain = all_critical_strike_gain
 
-    @property
-    def physical_critical_strike_base(self):
-        return self._physical_critical_strike_base
-
-    @physical_critical_strike_base.setter
-    def physical_critical_strike_base(self, physical_critical_strike_base):
-        self._physical_critical_strike_base = physical_critical_strike_base
-        self.base_physical_critical_strike = (self.physical_critical_strike_base + self.extra_physical_critical_strike
-                                              + self.agility * AGILITY_TO_CRITICAL_STRIKE)
-
     @property
     def extra_physical_critical_strike(self):
-        return self._extra_physical_critical_strike
-
-    @extra_physical_critical_strike.setter
-    def extra_physical_critical_strike(self, extra_physical_critical_strike):
-        extra_physical_critical_strike = int(extra_physical_critical_strike)
-        self._extra_physical_critical_strike = extra_physical_critical_strike
-        self.base_physical_critical_strike = (self.physical_critical_strike_base + self.extra_physical_critical_strike
-                                              + self.agility * AGILITY_TO_CRITICAL_STRIKE)
+        return 0
 
     @property
     def base_physical_critical_strike(self):
-        return self._base_physical_critical_strike
-
-    @base_physical_critical_strike.setter
-    def base_physical_critical_strike(self, base_physical_critical_strike):
-        base_physical_critical_strike = int(base_physical_critical_strike)
-        self._base_physical_critical_strike = base_physical_critical_strike
-        self.physical_critical_strike_percent = self.base_physical_critical_strike / CRITICAL_STRIKE_SCALE
+        return int(self.physical_critical_strike_base + self.agility * AGILITY_TO_CRITICAL_STRIKE +
+                   self.extra_physical_critical_strike)
 
     @property
     def physical_critical_strike_percent(self):
-        return self._physical_critical_strike_percent
-
-    @physical_critical_strike_percent.setter
-    def physical_critical_strike_percent(self, physical_critical_strike_percent):
-        self._physical_critical_strike_percent = physical_critical_strike_percent
-        self.physical_critical_strike = self.physical_critical_strike_percent + self.physical_critical_strike_gain
-
-    @property
-    def physical_critical_strike_gain(self):
-        return self._physical_critical_strike_gain / DECIMAL_SCALE
-
-    @physical_critical_strike_gain.setter
-    def physical_critical_strike_gain(self, physical_critical_strike_gain):
-        self._physical_critical_strike_gain = physical_critical_strike_gain
-        self.physical_critical_strike = self.physical_critical_strike_percent + self.physical_critical_strike_gain
+        return self.base_physical_critical_strike / CRITICAL_STRIKE_SCALE
 
     @property
     def physical_critical_strike(self):
-        return self._physical_critical_strike
-
-    @physical_critical_strike.setter
-    def physical_critical_strike(self, physical_critical_strike):
-        self._physical_critical_strike = physical_critical_strike
-
-    @property
-    def magical_critical_strike_base(self):
-        return self._magical_critical_strike_base
-
-    @magical_critical_strike_base.setter
-    def magical_critical_strike_base(self, magical_critical_strike_base):
-        self._magical_critical_strike_base = magical_critical_strike_base
-        self.base_magical_critical_strike = (self.magical_critical_strike_base + self.extra_magical_critical_strike
-                                             + self.spirit * SPIRIT_TO_CRITICAL_STRIKE)
+        return self.physical_critical_strike_percent + self.physical_critical_strike_gain / DECIMAL_SCALE
 
     @property
     def extra_magical_critical_strike(self):
-        return self._extra_magical_critical_strike
-
-    @extra_magical_critical_strike.setter
-    def extra_magical_critical_strike(self, extra_magical_critical_strike):
-        extra_magical_critical_strike = int(extra_magical_critical_strike)
-        self._extra_magical_critical_strike = extra_magical_critical_strike
-        self.base_magical_critical_strike = (self.magical_critical_strike_base + self.extra_magical_critical_strike
-                                             + self.spirit * SPIRIT_TO_CRITICAL_STRIKE)
+        return 0
 
     @property
     def base_magical_critical_strike(self):
-        return self._base_magical_critical_strike
-
-    @base_magical_critical_strike.setter
-    def base_magical_critical_strike(self, base_magical_critical_strike):
-        base_magical_critical_strike = int(base_magical_critical_strike)
-        self._base_magical_critical_strike = base_magical_critical_strike
-        self.magical_critical_strike_percent = self.base_magical_critical_strike / CRITICAL_STRIKE_SCALE
+        return int(self.magical_critical_strike_base + self.extra_magical_critical_strike +
+                   self.spirit * SPIRIT_TO_CRITICAL_STRIKE)
 
     @property
     def magical_critical_strike_percent(self):
-        return self._magical_critical_strike_percent
-
-    @magical_critical_strike_percent.setter
-    def magical_critical_strike_percent(self, magical_critical_strike_percent):
-        self._magical_critical_strike_percent = magical_critical_strike_percent
-        self.magical_critical_strike = self.magical_critical_strike_percent + self.magical_critical_strike_gain
-
-    @property
-    def magical_critical_strike_gain(self):
-        return self._magical_critical_strike_gain / DECIMAL_SCALE
-
-    @magical_critical_strike_gain.setter
-    def magical_critical_strike_gain(self, magical_critical_strike_gain):
-        self._magical_critical_strike_gain = magical_critical_strike_gain
-        self.magical_critical_strike = self.magical_critical_strike_percent + self.magical_critical_strike_gain
+        return self.base_magical_critical_strike / CRITICAL_STRIKE_SCALE
 
     @property
     def magical_critical_strike(self):
-        return self._magical_critical_strike
-
-    @magical_critical_strike.setter
-    def magical_critical_strike(self, magical_critical_strike):
-        self._magical_critical_strike = magical_critical_strike
+        return self.magical_critical_strike_percent + self.magical_critical_strike_gain / DECIMAL_SCALE
 
     """ Overcome Function"""
 
@@ -548,197 +215,81 @@ class Major:
     def overcome(self):
         raise NotImplementedError
 
-    @property
-    def physical_overcome_base(self):
-        return self._physical_overcome_base
-
-    @physical_overcome_base.setter
-    def physical_overcome_base(self, physical_overcome_base):
-        self._physical_overcome_base = physical_overcome_base
-        self.base_physical_overcome = self.physical_overcome_base + self.strength * STRENGTH_TO_OVERCOME
-
     @property
     def base_physical_overcome(self):
-        return self._base_physical_overcome
-
-    @base_physical_overcome.setter
-    def base_physical_overcome(self, base_physical_overcome):
-        base_physical_overcome = int(base_physical_overcome)
-        self._base_physical_overcome = base_physical_overcome
-        self.final_physical_overcome = (self.base_physical_overcome * (1 + self.physical_overcome_gain)
-                                        + self.extra_physical_overcome)
-
-    @property
-    def physical_overcome_gain(self):
-        return self._physical_overcome_gain / BINARY_SCALE
-
-    @physical_overcome_gain.setter
-    def physical_overcome_gain(self, physical_overcome_gain):
-        self._physical_overcome_gain = physical_overcome_gain
-        self.final_physical_overcome = (self.base_physical_overcome * (1 + self.physical_overcome_gain)
-                                        + self.extra_physical_overcome)
+        return int(self.physical_overcome_base + self.strength * STRENGTH_TO_OVERCOME)
 
     @property
     def extra_physical_overcome(self):
-        return self._extra_physical_overcome
-
-    @extra_physical_overcome.setter
-    def extra_physical_overcome(self, extra_physical_overcome):
-        extra_physical_overcome = int(extra_physical_overcome)
-        self._extra_physical_overcome = extra_physical_overcome
-        self.final_physical_overcome = (self.base_physical_overcome * (1 + self.physical_overcome_gain)
-                                        + self.extra_physical_overcome)
+        return 0
 
     @property
     def final_physical_overcome(self):
-        return self._final_physical_overcome
-
-    @final_physical_overcome.setter
-    def final_physical_overcome(self, final_physical_overcome):
-        final_physical_overcome = int(final_physical_overcome)
-        self._final_physical_overcome = final_physical_overcome
-        self.physical_overcome = final_physical_overcome / OVERCOME_SCALE
+        return int(self.base_physical_overcome * (1 + self.physical_overcome_gain / BINARY_SCALE) +
+                   self.extra_physical_overcome)
 
     @property
     def physical_overcome(self):
-        return self._physical_overcome
-
-    @physical_overcome.setter
-    def physical_overcome(self, physical_overcome):
-        self._physical_overcome = physical_overcome
-
-    @property
-    def magical_overcome_base(self):
-        return self._magical_overcome_base
-
-    @magical_overcome_base.setter
-    def magical_overcome_base(self, magical_overcome_base):
-        self._magical_overcome_base = magical_overcome_base
-        self.base_magical_overcome = self.magical_overcome_base + self.spunk * SPUNK_TO_OVERCOME
+        return self.final_physical_overcome / OVERCOME_SCALE
 
     @property
     def base_magical_overcome(self):
-        return self._base_magical_overcome
-
-    @base_magical_overcome.setter
-    def base_magical_overcome(self, base_magical_overcome):
-        base_magical_overcome = int(base_magical_overcome)
-        self._base_magical_overcome = base_magical_overcome
-        self.final_magical_overcome = (self.base_magical_overcome * (1 + self.magical_overcome_gain)
-                                       + self.extra_magical_overcome)
-
-    @property
-    def magical_overcome_gain(self):
-        return self._magical_overcome_gain / BINARY_SCALE
-
-    @magical_overcome_gain.setter
-    def magical_overcome_gain(self, magical_overcome_gain):
-        self._magical_overcome_gain = magical_overcome_gain
-        self.final_magical_overcome = (self.base_magical_overcome * (1 + self.magical_overcome_gain)
-                                       + self.extra_magical_overcome)
+        return int(self.magical_overcome_base + self.spunk * SPUNK_TO_OVERCOME)
 
     @property
     def extra_magical_overcome(self):
-        return self._extra_magical_overcome
-
-    @extra_magical_overcome.setter
-    def extra_magical_overcome(self, extra_magical_overcome):
-        extra_magical_overcome = int(extra_magical_overcome)
-        self._extra_magical_overcome = extra_magical_overcome
-        self.final_magical_overcome = (self.base_magical_overcome * (1 + self.magical_overcome_gain)
-                                       + self.extra_magical_overcome)
+        return 0
 
     @property
     def final_magical_overcome(self):
-        return self._final_magical_overcome
-
-    @final_magical_overcome.setter
-    def final_magical_overcome(self, final_magical_overcome):
-        final_magical_overcome = int(final_magical_overcome)
-        self._final_magical_overcome = final_magical_overcome
-        self.magical_overcome = final_magical_overcome / OVERCOME_SCALE
+        return int(self.base_magical_overcome * (1 + self.magical_overcome_gain / BINARY_SCALE) +
+                   self.extra_magical_overcome)
 
     @property
     def magical_overcome(self):
-        return self._magical_overcome
-
-    @magical_overcome.setter
-    def magical_overcome(self, magical_overcome):
-        self._magical_overcome = magical_overcome
+        return self.final_magical_overcome / OVERCOME_SCALE
 
 
 class Minor:
     surplus: int = 0
 
-    _strain_base: int = 0
-    _strain_percent: float = 0
-    _strain_gain: int = 0
-    _strain: float = 0
+    strain_base: int = 0
+    strain_gain: int = 0
+
+    haste_base: int = 0  # Not Apply
 
     _all_critical_power_base: int = 0
     _all_critical_power_gain: int = 0
 
-    _physical_critical_power_base: int = 0
-    _physical_critical_power_percent: float = 0
-    _physical_critical_power_gain: int = 0
-    _physical_critical_power: float = 0
-    _magical_critical_power_base: int = 0
-    _magical_critical_power_percent: float = 0
-    _magical_critical_power_gain: int = 0
-    _magical_critical_power: float = 0
+    physical_critical_power_base: int = 0
+    physical_critical_power_gain: int = 0
+    magical_critical_power_base: int = 0
+    magical_critical_power_gain: int = 0
 
-    _weapon_damage_rand: int = 0
-    _weapon_damage_base: int = 0
-    _weapon_damage_gain: int = 0
-    _weapon_damage: int = 0
+    weapon_damage_rand: int = 0
+    weapon_damage_base: int = 0
+    weapon_damage_gain: int = 0
 
     _all_shield_ignore: float = 0
 
-    _physical_shield_ignore: float = 0
-    _magical_shield_ignore: float = 0
+    physical_shield_ignore: float = 0
+    magical_shield_ignore: float = 0
 
     _all_damage_addition: float = 0
-    _physical_damage_addition: float = 0
-    _magical_damage_addition: float = 0
+    physical_damage_addition: float = 0
+    magical_damage_addition: float = 0
 
-    _pve_addition: float = 0
+    pve_addition: float = 0
 
     """ Minor Function """
 
-    @property
-    def strain_base(self):
-        return self._strain_base
-
-    @strain_base.setter
-    def strain_base(self, strain_base):
-        self._strain_base = strain_base
-        self.strain_percent = strain_base / STRAIN_SCALE
-
     @property
     def strain_percent(self):
-        return self._strain_percent
-
-    @strain_percent.setter
-    def strain_percent(self, strain_percent):
-        self._strain_percent = strain_percent
-        self.strain = strain_percent + self.strain_gain
-
-    @property
-    def strain_gain(self):
-        return self._strain_gain / BINARY_SCALE
-
-    @strain_gain.setter
-    def strain_gain(self, strain_gain):
-        self._strain_gain = strain_gain
-        self.strain = self.strain_percent + self.strain_gain
+        return self.strain_base / STRAIN_SCALE
 
     @property
     def strain(self):
-        return self._strain
-
-    @strain.setter
-    def strain(self, strain):
-        self._strain = strain
+        return self.strain_percent + self.strain_gain / BINARY_SCALE
 
     """ Critical Power Function"""
 
@@ -768,112 +319,27 @@ class Minor:
         self.magical_critical_power_gain += residual
         self._all_critical_power_gain = all_critical_power_gain
 
-    @property
-    def physical_critical_power_base(self):
-        return self._physical_critical_power_base
-
-    @physical_critical_power_base.setter
-    def physical_critical_power_base(self, physical_critical_power_base):
-        self._physical_critical_power_base = physical_critical_power_base
-        self.physical_critical_power_percent = self.physical_critical_power_base / CRITICAL_POWER_SCALE
-
     @property
     def physical_critical_power_percent(self):
-        return BASE_CRITICAL_POWER + self._physical_critical_power_percent
-
-    @physical_critical_power_percent.setter
-    def physical_critical_power_percent(self, physical_critical_power_percent):
-        self._physical_critical_power_percent = physical_critical_power_percent
-        self.physical_critical_power = self.physical_critical_power_percent + self.physical_critical_power_gain
-
-    @property
-    def physical_critical_power_gain(self):
-        return self._physical_critical_power_gain / BINARY_SCALE
-
-    @physical_critical_power_gain.setter
-    def physical_critical_power_gain(self, physical_critical_power_gain):
-        self._physical_critical_power_gain = physical_critical_power_gain
-        self.physical_critical_power = self.physical_critical_power_percent + self.physical_critical_power_gain
+        return BASE_CRITICAL_POWER + self.physical_critical_power_base / CRITICAL_POWER_SCALE
 
     @property
     def physical_critical_power(self):
-        return self._physical_critical_power
-
-    @physical_critical_power.setter
-    def physical_critical_power(self, physical_critical_power):
-        self._physical_critical_power = physical_critical_power
-
-    @property
-    def magical_critical_power_base(self):
-        return self._magical_critical_power_base
-
-    @magical_critical_power_base.setter
-    def magical_critical_power_base(self, magical_critical_power_base):
-        self._magical_critical_power_base = magical_critical_power_base
-        self.magical_critical_power_percent = self.magical_critical_power_base / CRITICAL_POWER_SCALE
+        return self.physical_critical_power_percent + self.physical_critical_power_gain / BINARY_SCALE
 
     @property
     def magical_critical_power_percent(self):
-        return BASE_CRITICAL_POWER + self._magical_critical_power_percent
-
-    @magical_critical_power_percent.setter
-    def magical_critical_power_percent(self, magical_critical_power_percent):
-        self._magical_critical_power_percent = magical_critical_power_percent
-        self.magical_critical_power = self.magical_critical_power_percent + self.magical_critical_power_gain
-
-    @property
-    def magical_critical_power_gain(self):
-        return self._magical_critical_power_gain / BINARY_SCALE
-
-    @magical_critical_power_gain.setter
-    def magical_critical_power_gain(self, magical_critical_power_gain):
-        self._magical_critical_power_gain = magical_critical_power_gain
-        self.magical_critical_power = self.magical_critical_power_percent + self.magical_critical_power_gain
+        return BASE_CRITICAL_POWER + self.magical_critical_power_base / CRITICAL_POWER_SCALE
 
     @property
     def magical_critical_power(self):
-        return self._magical_critical_power
-
-    @magical_critical_power.setter
-    def magical_critical_power(self, magical_critical_power):
-        self._magical_critical_power = magical_critical_power
+        return self.magical_critical_power_percent + self.magical_critical_power_gain / BINARY_SCALE
 
     """ Weapon Damage Function """
 
-    @property
-    def weapon_damage_rand(self):
-        return self._weapon_damage_rand
-
-    @weapon_damage_rand.setter
-    def weapon_damage_rand(self, weapon_damage_rand):
-        self._weapon_damage_rand = weapon_damage_rand
-        self.weapon_damage = self.weapon_damage_base * (1 + self.weapon_damage_gain) + self.weapon_damage_rand / 2
-
-    @property
-    def weapon_damage_base(self):
-        return self._weapon_damage_base
-
-    @weapon_damage_base.setter
-    def weapon_damage_base(self, weapon_damage_base):
-        self._weapon_damage_base = weapon_damage_base
-        self.weapon_damage = self.weapon_damage_base * (1 + self.weapon_damage_gain) + self.weapon_damage_rand / 2
-
-    @property
-    def weapon_damage_gain(self):
-        return self._weapon_damage_gain / BINARY_SCALE
-
-    @weapon_damage_gain.setter
-    def weapon_damage_gain(self, weapon_damage_gain):
-        self._weapon_damage_gain = weapon_damage_gain
-        self.weapon_damage = self.weapon_damage_base * (1 + self.weapon_damage_gain) + self.weapon_damage_rand / 2
-
     @property
     def weapon_damage(self):
-        return self._weapon_damage
-
-    @weapon_damage.setter
-    def weapon_damage(self, weapon_damage):
-        self._weapon_damage = int(weapon_damage)
+        return int(self.weapon_damage_base * (1 + self.weapon_damage_gain) + self.weapon_damage_rand / 2)
 
     """ Others """
 
@@ -892,22 +358,6 @@ class Minor:
         self.magical_shield_ignore += residual
         self._all_shield_ignore = all_shield_ignore
 
-    @property
-    def physical_shield_ignore(self):
-        return self._physical_shield_ignore / BINARY_SCALE
-
-    @physical_shield_ignore.setter
-    def physical_shield_ignore(self, physical_shield_ignore):
-        self._physical_shield_ignore = physical_shield_ignore
-
-    @property
-    def magical_shield_ignore(self):
-        return self._magical_shield_ignore / BINARY_SCALE
-
-    @magical_shield_ignore.setter
-    def magical_shield_ignore(self, magical_shield_ignore):
-        self._magical_shield_ignore = magical_shield_ignore
-
     @property
     def damage_addition(self):
         raise NotImplementedError
@@ -923,30 +373,6 @@ class Minor:
         self.magical_damage_addition += residual
         self._all_damage_addition = all_damage_addition
 
-    @property
-    def physical_damage_addition(self):
-        return self._physical_damage_addition / BINARY_SCALE
-
-    @physical_damage_addition.setter
-    def physical_damage_addition(self, physical_damage_addition):
-        self._physical_damage_addition = physical_damage_addition
-
-    @property
-    def magical_damage_addition(self):
-        return self._magical_damage_addition / BINARY_SCALE
-
-    @magical_damage_addition.setter
-    def magical_damage_addition(self, magical_damage_addition):
-        self._magical_damage_addition = magical_damage_addition
-
-    @property
-    def pve_addition(self):
-        return self._pve_addition / BINARY_SCALE
-
-    @pve_addition.setter
-    def pve_addition(self, pve_addition):
-        self._pve_addition = pve_addition
-
 
 class Attribute(Major, Minor, Target):
     level: int = 120

base/buff.py

@@ -12,14 +12,16 @@ class Buff:
     buff_id: int = 0
     buff_name: str = ""
     buff_level: int = 0
-    buff_stack: int = 0
+    buff_stack: int = 1
 
     gain_skills: Dict[int, ATTR_DICT] = None
     gain_attributes: ATTR_DICT = None
 
     def __post_init__(self):
-        self.gain_skills = {}
-        self.gain_attributes = {}
+        if self.gain_skills is None:
+            self.gain_skills = {}
+        if self.gain_attributes is None:
+            self.gain_attributes = {}
 
     @property
     def display_name(self):
@@ -33,7 +35,11 @@ class Buff:
             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)
+                    if isinstance(value, list):
+                        setattr(skill, attr, value)
+                    else:
+                        setattr(skill, attr, getattr(skill, attr) + value * self.buff_stack)
+
         return other
 
     def __rsub__(self, other: Union[Attribute, Dict[int, Skill]]):
@@ -44,6 +50,10 @@ class Buff:
             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)
+                    if isinstance(value, list):
+                        setattr(skill, attr, value)
+                    else:
+                        value *= self.buff_stack
+                        setattr(skill, attr, getattr(skill, attr) + value)
         return other
 

base/gain.py

@@ -0,0 +1,23 @@
+from typing import Union, Dict
+
+from base.attribute import Attribute
+from base.skill import Skill
+
+
+class Gain:
+    def __init__(self, gain_name):
+        self.gain_name = gain_name
+
+    def add(self, other):
+        pass
+
+    def sub(self, other):
+        pass
+
+    def __radd__(self, other: Union[Attribute, Dict[int, Skill]]):
+        self.add(other)
+        return other
+
+    def __rsub__(self, other: Union[Attribute, Dict[int, Skill]]):
+        self.sub(other)
+        return other

base/recipe.py

@@ -1,19 +1,42 @@
-from base.buff import Buff
+from typing import List
+
+from base.gain import Gain
+
+
+class Recipe(Gain):
+    def __init__(self, gain_name: str, skill_ids: List[int], value: int):
+        super().__init__(gain_name)
+        self.skill_ids = skill_ids
+        self.value = value
+
+
+class DamageAdditionRecipe(Recipe):
+    def add(self, other):
+        if isinstance(other, dict):
+            for skill_id in self.skill_ids:
+                other[skill_id].skill_damage_addition += self.value
+
+    def sub(self, other):
+        if isinstance(other, dict):
+            for skill_id in self.skill_ids:
+                other[skill_id].skill_damage_addition -= self.value
+
+
+class CriticalStrikeRecipe(Recipe):
+    def add(self, other):
+        if isinstance(other, dict):
+            for skill_id in self.skill_ids:
+                other[skill_id].skill_critical_strike += self.value
+
+    def sub(self, other):
+        if isinstance(other, dict):
+            for skill_id in self.skill_ids:
+                other[skill_id].skill_critical_strike -= self.value
 
 
 def damage_addition_recipe(skill_ids, value, name="伤害增加"):
-    return Buff(
-        -1, name, gain_skills={
-            skill_id: {
-                "skill_damage_addition": value
-            } for skill_id in skill_ids
-        })
+    return DamageAdditionRecipe(name, skill_ids, value)
 
 
 def critical_strike_recipe(skill_ids, value, name="会心增加"):
-    return Buff(
-        -1, name, gain_skills={
-            skill_id: {
-                "skill_critical_strike": value
-            } for skill_id in skill_ids
-        })
+    return CriticalStrikeRecipe(name, skill_ids, value)

base/skill.py

@@ -26,10 +26,10 @@ class Skill:
     surplus_cof_gain: float = 0.
     weapon_damage_cof_gain: float = 0.
 
-    _skill_damage_addition: int = 0
+    skill_damage_addition: int = 0
     _skill_shield_gain: Union[List[int], int] = 0
-    _skill_critical_strike: int = 0
-    _skill_critical_power: int = 0
+    skill_critical_strike: int = 0
+    skill_critical_power: int = 0
 
     @property
     def display_name(self):
@@ -94,40 +94,24 @@ class Skill:
     def weapon_damage_cof(self, weapon_damage_cof):
         self._weapon_damage_cof = weapon_damage_cof
 
-    @property
-    def skill_damage_addition(self):
-        return self._skill_damage_addition / BINARY_SCALE
-
-    @skill_damage_addition.setter
-    def skill_damage_addition(self, skill_damage_addition):
-        self._skill_damage_addition = skill_damage_addition
-
     @property
     def skill_shield_gain(self):
         if isinstance(self._skill_shield_gain, list):
-            return self._skill_shield_gain[self.skill_level - 1] / BINARY_SCALE
+            return self._skill_shield_gain[self.skill_level - 1]
         else:
-            return self._skill_shield_gain / BINARY_SCALE
+            return self._skill_shield_gain
 
     @skill_shield_gain.setter
     def skill_shield_gain(self, skill_shield_gain):
         self._skill_shield_gain = skill_shield_gain
 
     @property
-    def skill_critical_strike(self):
-        return self._skill_critical_strike / DECIMAL_SCALE
-
-    @skill_critical_strike.setter
-    def skill_critical_strike(self, skill_critical_strike):
-        self._skill_critical_strike = skill_critical_strike
+    def skill_critical_strike_gain(self):
+        return self.skill_critical_strike / DECIMAL_SCALE
 
     @property
-    def skill_critical_power(self):
-        return self._skill_critical_power / BINARY_SCALE
-
-    @skill_critical_power.setter
-    def skill_critical_power(self, skill_critical_power):
-        self._skill_critical_power = skill_critical_power
+    def skill_critical_power_gain(self):
+        return self.skill_critical_power / BINARY_SCALE
 
     def __call__(self, attribute: Attribute):
         damage = init_result(
@@ -144,7 +128,7 @@ class Skill:
                                  attribute.shield_ignore,
                                  attribute.shield_constant)
 
-        critical_damage = critical_result(damage, attribute.critical_power + self.skill_critical_power)
+        critical_damage = critical_result(damage, attribute.critical_power + self.skill_critical_power_gain)
 
         damage = level_reduction_result(damage, attribute.level_reduction)
         critical_damage = level_reduction_result(critical_damage, attribute.level_reduction)
@@ -154,7 +138,7 @@ class Skill:
         critical_damage = pve_addition_result(critical_damage, attribute.pve_addition)
         damage = vulnerable_result(damage, attribute.vulnerable)
         critical_damage = vulnerable_result(critical_damage, attribute.vulnerable)
-        critical_strike = min(1, attribute.critical_strike + self.skill_critical_strike)
+        critical_strike = min(1, attribute.critical_strike + self.skill_critical_strike_gain)
 
         expected_damage = critical_strike * critical_damage + (1 - critical_strike) * damage
 

general/gains/equipment.py

@@ -0,0 +1,73 @@
+from typing import Dict, Union, Tuple
+
+from base.attribute import Attribute
+from base.gain import Gain
+
+
+class HatSpecialEnchant(Gain):
+    overcome = [0] * 9 + [822, 999, 1098]
+
+    def __init__(self, level):
+        self.level = level
+        super().__init__(f"{self.overcome[self.level]} 破防")
+
+    def add(self, other):
+        if isinstance(other, Attribute):
+            other.physical_overcome_base += self.overcome[self.level]
+
+    def sub(self, other):
+        if isinstance(other, Attribute):
+            other.physical_overcome_base -= self.overcome[self.level]
+
+
+class JacketSpecialEnchant(Gain):
+    physical_ap = [0] * 9 + [371, 450, 495]
+    magical_ap = [0] * 9 + [442, 538, 591]
+
+    def __init__(self, level):
+        self.level = level
+        super().__init__(f"{self.physical_ap[self.level]}/{self.magical_ap[self.level]} 外攻/内攻")
+
+    def add(self, other):
+        if isinstance(other, Attribute):
+            other.physical_attack_power_base += self.physical_ap[self.level]
+            other.magical_attack_power_base += self.magical_ap[self.level]
+
+    def sub(self, other):
+        if isinstance(other, Attribute):
+            other.physical_attack_power_base -= self.physical_ap[self.level]
+            other.magical_attack_power_base -= self.magical_ap[self.level]
+
+
+class BeltSpecialEnchant(Gain):
+    damage_addition = {
+        51: 0.7,
+        10: 0.3
+    }
+    duration = 128
+    cooldown = 480
+
+    def __init__(self):
+        self.all_damage_addition = sum(k * v for k, v in self.damage_addition.items()) * self.duration / self.cooldown
+        super().__init__(f"{self.all_damage_addition} 伤害增加")
+
+    def add(self, other):
+        if isinstance(other, Attribute):
+            other.all_damage_addition += self.all_damage_addition
+
+    def sub(self, other):
+        if isinstance(other, Attribute):
+            other.all_damage_addition -= self.all_damage_addition
+
+
+EQUIPMENT_GAINS: Dict[Union[Tuple[int, int], int], Gain] = {
+    **{
+        (15436, i): HatSpecialEnchant(i)
+        for i in range(12)
+    },
+    **{
+        (22151, i): JacketSpecialEnchant(i)
+        for i in range(12)
+    },
+    15455: BeltSpecialEnchant()
+}

parser.py

@@ -1,85 +0,0 @@
-from typing import Dict
-
-from base.buff import Buff
-from base.skill import Skill
-from utils.lua import parse
-
-
-class Parser:
-    records: dict
-    status: dict
-
-    start_time: list
-    end_time: list
-
-    info_flag: bool
-    fight_flag: bool
-
-    school: int
-
-    def __init__(self, skills: Dict[str, Skill], buffs: Dict[str, Buff]):
-        self.skills = skills
-        self.buffs = buffs
-
-    def reset(self):
-        self.info_flag = True
-        self.fight_flag = False
-
-        self.records = {}
-        self.status = {}
-
-        self.start_time = []
-        self.end_time = []
-
-    def parse_info(self, detail):
-        if isinstance(detail, list):
-            self.info_flag = False
-
-    def parse_time(self, detail, timestamp):
-        if detail[1]:
-            self.start_time.append(int(timestamp))
-            self.records[self.start_time[-1]] = {}
-            self.fight_flag = True
-        else:
-            self.end_time.append(int(timestamp))
-            self.fight_flag = False
-
-    def parse_buff(self, detail):
-        buff_id, buff_stack, buff_level = detail[4], detail[5], detail[8]
-        if buff_id not in self.buffs:
-            return
-        if not buff_stack:
-            self.status.pop((buff_id, buff_level))
-        else:
-            self.status[(buff_id, buff_level)] = buff_stack
-
-    def parse_skill(self, detail, timestamp):
-        skill = detail[4], detail[5]
-        if skill[0] not in self.skills:
-            return
-
-        current_record = self.records[self.start_time[-1]]
-        if skill not in current_record:
-            current_record[skill] = {}
-        status = tuple(
-            (buff_id, buff_level, buff_stack) for (buff_id, buff_level), buff_stack in self.status.items()
-        )
-        if status not in current_record[skill]:
-            current_record[skill][status] = []
-        current_record[skill][status].append(int(timestamp) - self.start_time[-1])
-
-    def __call__(self, file_name):
-        self.reset()
-
-        for line in open(file_name):
-            row = line.split("\t")
-            if row[4] == "4" and self.info_flag:
-                self.parse_info(parse(row[-1]))
-            elif row[4] == "5":
-                self.parse_time(parse(row[-1]), row[3])
-            elif row[4] == "13":
-                self.parse_buff(parse(row[-1]))
-            elif row[4] == "21" and self.fight_flag:
-                self.parse_skill(parse(row[-1]), row[3])
-
-        return self.records

qt/app.py

@@ -25,7 +25,7 @@ class MainWindow(QMainWindow):
     def __init__(self):
         super().__init__()
 
-        self.setWindowTitle("Simulator")
+        self.setWindowTitle("Formulator")
 
         icon = QIcon("qt/assets/icon.ico")
         self.setWindowIcon(icon)

qt/components/dashboard.py

@@ -4,11 +4,30 @@ from qt.components import ComboWithLabel, SpinWithLabel, TextWithLabel, LabelWit
 from base.constant import SHIELD_BASE_MAP
 
 
+class DetailWidget(QWidget):
+    def __init__(self):
+        super().__init__()
+        layout = QVBoxLayout(self)
+        self.details = {}
+        self.skill_combo = ComboWithLabel("选择技能")
+        layout.addWidget(self.skill_combo)
+        self.status_combo = ComboWithLabel("选择增益")
+        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.gradient_detail)
+        layout.addWidget(detail_table)
+
+        layout.addStretch()
+
+
 class DashboardWidget(QWidget):
     def __init__(self):
         super().__init__()
-        layout = QVBoxLayout()
-        self.setLayout(layout)
+        layout = QVBoxLayout(self)
 
         top = QWidget()
         top_layout = QHBoxLayout(top)
@@ -43,23 +62,8 @@ class DashboardWidget(QWidget):
         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.detail_widget = DetailWidget()
+        tab.addTab(self.detail_widget, "伤害总结")
 
         self.summary = TableWithLabel("伤害统计", headers=["技能/次数", "命中/%", "会心/%", "伤害/%"])
 

qt/components/equipments.py

@@ -80,6 +80,7 @@ class EquipmentWidget(QWidget):
         output_layout.addWidget(self.magic_attr)
         self.embed_attr = TableWithLabel("镶嵌属性", column_count=2)
         output_layout.addWidget(self.embed_attr)
+        output_layout.addStretch()
         self.output_widget.hide()
 
 

qt/constant.py

@@ -2,10 +2,11 @@ import os
 
 
 from dataclasses import dataclass
-from typing import Type, List, Dict
+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
@@ -129,13 +130,15 @@ class School:
     kind: str
     attribute: Type[Attribute]
     formation: str
-    talent_gains: List[Dict[int, Buff]]
+    skills: Dict[int, Skill]
+    buffs: Dict[int, Buff]
+    talent_gains: Dict[int, Gain]
+    talents: List[List[int]]
     talent_decoder: Dict[int, str]
     talent_encoder: Dict[str, int]
-    recipe_gains: Dict[str, Dict[str, Buff]]
+    recipe_gains: Dict[str, Dict[str, Gain]]
     recipes: Dict[str, List[str]]
-    skills: Dict[int, Skill]
-    buffs: Dict[int, Buff]
+    gains: Dict[Union[Tuple[int, int], int], Gain]
     display_attrs: Dict[str, str]
 
     def attr_content(self, attribute):
@@ -156,13 +159,15 @@ SUPPORT_SCHOOL = {
         kind="外功",
         attribute=first.BeiAoJue,
         formation="霜岚洗锋阵",
+        skills=first.SKILLS,
+        buffs=first.BUFFS,
         talent_gains=first.TALENT_GAINS,
+        talents=first.TALENTS,
         talent_decoder=first.TALENT_DECODER,
         talent_encoder=first.TALENT_ENCODER,
         recipe_gains=first.RECIPE_GAINS,
         recipes=first.RECIPES,
-        skills=first.SKILLS,
-        buffs=first.BUFFS,
+        gains=first.GAINS,
         display_attrs={
             "strength": "力道",
             "base_physical_attack_power": "基础攻击",

qt/scripts/dashboard.py

@@ -67,37 +67,57 @@ def dashboard_script(parser: Parser,
         #     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))
+
+        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 skill, recipe in recipes.gains]
+        gains = sum([equipment_gains, talent_gains, recipe_gains], [])
+
+        for gain in gains:
+            attribute += gain
+            school.skills += gain
+
+        dashboard_widget.final_attribute.set_content(school.attr_content(attribute))
+
         total_damage, total_gradient, details, summary = analyze_details(record, attribute, school)
+        for gain in gains:
+            attribute -= gain
+            school.skills -= gain
+
         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)
+
+        detail_widget = dashboard_widget.detail_widget
+        detail_widget.details = details
+        detail_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):
+        detail_widget = dashboard_widget.detail_widget
         if skill:
-            dashboard_widget.status_combo.set_items(list(dashboard_widget.details[skill]))
+            status_choices = list(detail_widget.details[skill])
+            detail_widget.status_combo.set_items(status_choices, default_index=-1)
         else:
-            dashboard_widget.status_combo.combo_box.clear()
+            detail_widget.status_combo.combo_box.clear()
 
-    dashboard_widget.skill_combo.combo_box.currentTextChanged.connect(select_skill)
+    dashboard_widget.detail_widget.skill_combo.combo_box.currentTextChanged.connect(select_skill)
 
     def select_status(status):
+        detail_widget = dashboard_widget.detail_widget
+        skill = detail_widget.skill_combo.combo_box.currentText()
         if status:
-            skill = dashboard_widget.skill_combo.combo_box.currentText()
-            detail = dashboard_widget.details[skill][status]
+            detail = detail_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)
+            detail_widget.damage_detail.set_content(damage_content)
+            detail_widget.gradient_detail.set_content(gradient_content)
         else:
-            dashboard_widget.damage_detail.table.clear()
-            dashboard_widget.gradient_detail.table.clear()
+            detail_widget.damage_detail.table.clear()
+            detail_widget.gradient_detail.table.clear()
 
-    dashboard_widget.status_combo.combo_box.currentTextChanged.connect(select_status)
+    dashboard_widget.detail_widget.status_combo.combo_box.currentTextChanged.connect(select_status)

qt/scripts/equipments.py

@@ -1,6 +1,7 @@
 from collections import defaultdict
-from typing import Dict, List
+from typing import Dict, List, Union, Tuple
 
+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
@@ -39,7 +40,7 @@ class Equipment:
     max_strength: int
     embed: Dict[str, int]
     gains: List[int]
-    special_enchant: List[int | List[int]]
+    special_enchant: Union[int | Tuple[int, int]]
     special_enchant_gain: List[int | List[int]]
     set_id: str
     set_attr: Dict[int, Dict[str, int]]
@@ -161,7 +162,7 @@ class Equipments:
         for equipment in self.equipments.values():
             if not equipment.name:
                 continue
-            final_gains += [gain for gain in equipment.gains + equipment.special_enchant]
+            final_gains += [gain for gain in equipment.gains + equipment.special_enchant_gain]
             if equipment.set_id not in set_count:
                 set_count[equipment.set_id] = 0
                 set_effect[equipment.set_id] = equipment.set_gain
@@ -173,7 +174,7 @@ class Equipments:
                     break
                 final_gains += gains
 
-        return [gain for gain in set(final_gains)]
+        return [gain for gain in final_gains]
 
 
 def equipments_script(equipments_widget: EquipmentsWidget):
@@ -221,8 +222,11 @@ def equipments_script(equipments_widget: EquipmentsWidget):
             else:
                 widget.embed_attr.hide()
 
+            if isinstance(equipment.special_enchant, list):
+                equipment.special_enchant = tuple(*equipment.special_enchant)
+
             if equipment.special_enchant:
-                widget.special_enchant.set_text(str(equipment.special_enchant))
+                widget.special_enchant.set_text(EQUIPMENT_GAINS[equipment.special_enchant].gain_name)
 
             widget.detail_widget.show()
             widget.output_widget.show()
@@ -250,7 +254,7 @@ def equipments_script(equipments_widget: EquipmentsWidget):
 
         def inner(_):
             if widget.special_enchant and widget.special_enchant.radio_button.isChecked():
-                equipment.special_enchant_gain = equipment.special_enchant
+                equipment.special_enchant_gain = [equipment.special_enchant]
             else:
                 equipment.special_enchant_gain = []
 

qt/scripts/top.py

@@ -149,7 +149,7 @@ def top_script(top_widget: TopWidget, config_widget: QWidget, dashboard_widget:
 
         """ Update talent options """
         for i, talent_widget in enumerate(talents_widget.values()):
-            talents = list(school.talent_gains[i])
+            talents = school.talents[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)

schools/first/__init__.py

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

schools/first/attribute.py

@@ -24,15 +24,9 @@ class BeiAoJue(PhysicalAttribute):
         }
 
     @property
-    def strength(self):
-        return self._strength
-
-    @strength.setter
-    def strength(self, strength):
-        strength = int(strength)
-        self._strength = strength
-        self._extra_physical_attack_power = int(strength * self.STRENGTH_TO_ATTACK_POWER)
-        self.base_physical_attack_power = self._physical_attack_power_base + strength * STRENGTH_TO_ATTACK_POWER
-        self._extra_physical_overcome = int(strength * self.STRENGTH_TO_OVERCOME)
-        self.base_physical_overcome = self._physical_overcome_base + strength * STRENGTH_TO_OVERCOME
+    def extra_physical_attack_power(self):
+        return int(self.strength * self.STRENGTH_TO_ATTACK_POWER)
 
+    @property
+    def extra_physical_overcome(self):
+        return int(self.strength * self.STRENGTH_TO_OVERCOME)

schools/first/gains.py

@@ -0,0 +1,4 @@
+from general.gains.equipment import EQUIPMENT_GAINS
+
+
+GAINS = EQUIPMENT_GAINS

schools/first/recipes.py

@@ -1,9 +1,9 @@
 from typing import Dict, List
 
-from base.buff import Buff
+from base.gain import Gain
 from base.recipe import damage_addition_recipe, critical_strike_recipe
 
-RECIPE_GAINS: Dict[str, Dict[str, dict | Buff]] = {
+RECIPE_GAINS: Dict[str, Dict[str, Gain]] = {
     "雷走风切": {
         "5%伤害": damage_addition_recipe([16631, 16599], 51),
         "4%伤害": damage_addition_recipe([16631, 16599], 41),

schools/first/talents.py

@@ -1,85 +1,102 @@
-from typing import Dict, List
-
-from base.buff import Buff
-
-TALENT_GAINS: List[Dict[int, dict | Buff]] = [
-    {16691: {"buff_name": "龙息"}},
-    {16847: {"buff_name": "归酣"}},
-    {
-        26904: {
-            "buff_name": "冥鼔",
-            "gain_skills": {
-                **{
-                    skill_id: {
-                        "physical_damage_addition": 205,
-                        "physical_shield_gain": -512
-                    } for skill_id in [16760, 16382, 20991]
-                },
-                32823: {
-                    "physical_shield_gain": [0, 0, -512, -512]
-                },
-            }
-        },
-        17042: {
-            "buff_name": "阳关",
-            "gain_skills": {
-                **{
-                    skill_id: {
-                        "physical_damage_addition": 154,
-                        "physical_shield_gain": -205
-                    } for skill_id in [16803, 16802, 16801, 16800, 17043, 19423, 19424]
-                },
-                32859: {
-                    "physical_damage_addition": 154,
-                },
-            }
-        }
-    },
-    {16799: {"buff_name": "霜天"}},
-    {25633: {"buff_name": "含风"}},
-    {32857: {"buff_name": "见尘"}},
-    {17047: {"buff_name": "分疆"}},
-    {
-        25258: {"buff_name": "掠关"},
-        16728: {
-            "buff_name": "星火",
-            "gain_attributes": {
-                "strength_gain": 102
-            }
-        },
-        34677: {
-            "buff_name": "绝河",
-            "gain_skills": {
-                20991: {
-                    "physical_damage_addition": 307
-                }
-            }
-        }
-    },
-    {16737: {"buff_name": "楚歌"}},
-    {
-        17056: {
-            "buff_name": "绝期",
-            "gain_skills": {
-                11447: {
-                    "attack_power_cof_gain": 0.7
-                }
-            }
-        }
-    },
-    {16893: {"buff_name": "重烟"}},
-    {21858: {"buff_name": "降麒式"}}
-]
+from typing import Dict
+
+from base.attribute import Attribute
+from base.gain import Gain
+
+
+class 冥鼓(Gain):
+    def add(self, other):
+        if isinstance(other, dict):
+            for skill_id in [16760, 16382, 20991]:
+                other[skill_id].skill_damage_addition += 205
+                other[skill_id].skill_shield_gain -= 512
+            other[32823].skill_shield_gain = [0, 0, -512, -512]
+
+    def sub(self, other):
+        if isinstance(other, dict):
+            for skill_id in [16760, 16382, 20991]:
+                other[skill_id].skill_damage_addition -= 205
+                other[skill_id].skill_shield_gain += 512
+            other[32823].skill_shield_gain = 0
+
+
+class 阳关(Gain):
+    def add(self, other):
+        if isinstance(other, dict):
+            for skill_id in [16803, 16802, 16801, 16800, 17043, 19423, 19424]:
+                other[skill_id].skill_damage_addition += 154
+                other[skill_id].skill_shield_gain -= 205
+            other[32859].skill_damage_addition += 154
+
+    def sub(self, other):
+        if isinstance(other, dict):
+            for skill_id in [16803, 16802, 16801, 16800, 17043, 19423, 19424]:
+                other[skill_id].skill_damage_addition -= 154
+                other[skill_id].skill_shield_gain += 205
+            other[32859].skill_damage_addition -= 154
+
 
-for talent in TALENT_GAINS:
-    for talent_id, detail in talent.items():
-        if not detail:
-            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)
+class 星火(Gain):
+    def add(self, other):
+        if isinstance(other, Attribute):
+            other.strength_gain += 102
 
+    def sub(self, other):
+        if isinstance(other, Attribute):
+            other.strength_gain -= 102
 
-TALENT_DECODER = {talent_id: talent.buff_name for talents in TALENT_GAINS for talent_id, talent in talents.items()}
+
+class 绝河(Gain):
+    def add(self, other):
+        if isinstance(other, dict):
+            other[20991].skill_damage_addition += 307
+
+    def sub(self, other):
+        if isinstance(other, dict):
+            other[20991].skill_damage_addition -= 307
+
+
+class 绝期(Gain):
+    def add(self, other):
+        if isinstance(other, dict):
+            other[11447].attack_power_cof_gain += 0.7
+
+    def sub(self, other):
+        if isinstance(other, dict):
+            other[11447].attack_power_cof_gain -= 0.7
+
+
+TALENT_GAINS: Dict[int, Gain] = {
+    16691: Gain("龙息"),
+    16847: Gain("归酣"),
+    26904: 冥鼓("冥鼔"),
+    17042: 阳关("阳关"),
+    16799: Gain("霜天"),
+    25633: Gain("含风"),
+    32857: Gain("见尘"),
+    17047: Gain("分疆"),
+    25258: Gain("掠关"),
+    16728: 星火("星火"),
+    34677: 绝河("绝河"),
+    16737: Gain("楚歌"),
+    17056: 绝期("绝期"),
+    16893: Gain("重烟"),
+    21858: Gain("降麒式")
+}
+
+TALENTS = [
+    [16691],
+    [16847],
+    [26904, 17042],
+    [16799],
+    [25633],
+    [32857],
+    [17047],
+    [25258, 16728, 34677],
+    [16737],
+    [17056],
+    [16893],
+    [21858]
+]
+TALENT_DECODER = {talent_id: talent.gain_name for talent_id, talent in TALENT_GAINS.items()}
 TALENT_ENCODER = {v: k for k, v in TALENT_DECODER.items()}

utils/damage.py

@@ -1,11 +1,13 @@
 from functools import cache
 
+from base.constant import BINARY_SCALE
+
 
 @cache
 def defense(shield_base, shield_gain, shield_ignore, shield_constant):
     shield = shield_base
-    shield += int(shield * shield_gain)
-    shield -= int(shield * shield_ignore)
+    shield += int(shield * shield_gain / BINARY_SCALE)
+    shield -= int(shield * shield_ignore / BINARY_SCALE)
     return max(0, shield / (shield + shield_constant))
 
 
@@ -50,7 +52,7 @@ def init_result(damage_base, damage_rand, damage_gain,
 
 @cache
 def damage_addition_result(damage, damage_addition):
-    return int(damage * (1 + damage_addition))
+    return int(damage * (1 + damage_addition / BINARY_SCALE))
 
 
 @cache
@@ -76,9 +78,9 @@ def strain_result(damage, strain):
 
 @cache
 def pve_addition_result(damage, pve_addition):
-    return int(damage * (1 + pve_addition))
+    return int(damage * (1 + pve_addition / BINARY_SCALE))
 
 
 @cache
 def vulnerable_result(damage, vulnerable):
-    return int(damage * (1 + vulnerable))
+    return int(damage * (1 + vulnerable / BINARY_SCALE))