04.22 commit

.github/workflows/pyinstaller-app.yml

@@ -0,0 +1,92 @@
+# 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: Pyinstaller Packaging
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+permissions:
+  contents: write
+
+jobs:
+  setup:
+    runs-on: ubuntu-latest
+    outputs:
+      PACKAGE_PREFIX: ${{ steps.get-package_prefix.outputs.PACKAGE_PREFIX }}
+      TAG_NAME: ${{ steps.get-package_prefix.outputs.TAG_NAME }}
+      HEAD_SHA_SHORT: ${{ steps.get-package_prefix.outputs.HEAD_SHA_SHORT }}
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          fetch-depth: '0'
+      - name: get-package_prefix
+        id: get-package_prefix
+        run: |
+          LIB_NAME=Formulator
+          TAG_NAME=pre
+          HEAD_SHA_SHORT=$(git rev-parse --short HEAD)
+          echo "::set-output name=PACKAGE_PREFIX::${LIB_NAME}_${TAG_NAME}"
+          echo "::set-output name=TAG_NAME::${TAG_NAME}"
+          echo "::set-output name=HEAD_SHA_SHORT::${HEAD_SHA_SHORT}"
+
+  release:
+    needs: [setup]
+    runs-on: ubuntu-latest
+    outputs:
+      Up_Url: ${{ steps.create_release.outputs.upload_url }}
+    steps:
+      - name: create_release
+        id: create_release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: v0.0
+          release_name: Pre Release
+          draft: true
+          prerelease: true
+
+  windows:
+    needs: [setup, release]
+    runs-on: windows-latest
+    env:
+      PACKAGENAME: ${{ needs.setup.outputs.PACKAGE_PREFIX }}_windows_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
+    - name: Build
+      run: |
+        mv qt/assets/icon.ico ./
+        pyinstaller -F -w -i icon.ico app.py 
+        mv dist formulator
+        mv qt/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
+        path: ${{ env.PACKAGENAME }}
+    - name: upload-win
+      uses: actions/upload-release-asset@v1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ needs.release.outputs.Up_Url }}
+        asset_path: ${{ env.PACKAGENAME }}.7z
+        asset_name: ${{ env.PACKAGENAME }}.7z
+        asset_content_type: application/zip

base/buff.py

@@ -20,6 +20,7 @@ class Buff:
     gain_attributes: ATTR_DICT = None
 
     SNAPSHOT_ATTRS = ["attack_power", "critical_strike", "critical_power", "strain", "damage_addition"]
+    PET_ATTRS = ["attack_power", "critical_power", "overcome", "strain"]
 
     def __post_init__(self):
         if self.gain_skills is None:
@@ -37,47 +38,24 @@ class Buff:
         else:
             return value
 
-    def add(self, attribute: Attribute, skill: Skill, snapshot=None):
-        if snapshot is None:
-            self.add_all(attribute, skill)
-        elif snapshot:
-            self.add_snapshot(attribute, skill)
-        else:
-            self.add_current(attribute, skill)
-
     def add_all(self, attribute: Attribute, skill: Skill):
         for attr, value in self.gain_attributes.items():
             setattr(attribute, attr, getattr(attribute, attr) + self.level_value(value) * self.buff_stack)
         for attr, value in self.gain_skills.get(skill.skill_id, {}).items():
             setattr(skill, attr, getattr(skill, attr) + self.level_value(value) * self.buff_stack)
 
-    def add_snapshot(self, attribute: Attribute, skill: Skill):
+    def add_dot(self, attribute: Attribute, skill: Skill, snapshot: bool = True):
         for attr, value in self.gain_attributes.items():
-            if all(snapshot_attr not in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
-                continue
-            setattr(attribute, attr, getattr(attribute, attr) + self.level_value(value) * self.buff_stack)
-        for attr, value in self.gain_skills.get(skill.skill_id, {}).items():
-            if all(snapshot_attr not in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
-                continue
-            setattr(skill, attr, getattr(skill, attr) + self.level_value(value) * self.buff_stack)
+            if snapshot and any(snapshot_attr in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
+                setattr(attribute, attr, getattr(attribute, attr) + self.level_value(value) * self.buff_stack)
+            elif not snapshot and all(snapshot_attr not in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
+                setattr(attribute, attr, getattr(attribute, attr) + self.level_value(value) * self.buff_stack)
 
-    def add_current(self, attribute: Attribute, skill: Skill):
-        for attr, value in self.gain_attributes.items():
-            if any(snapshot_attr in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
-                continue
-            setattr(attribute, attr, getattr(attribute, attr) + self.level_value(value) * self.buff_stack)
         for attr, value in self.gain_skills.get(skill.skill_id, {}).items():
-            if any(snapshot_attr in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
-                continue
-            setattr(skill, attr, getattr(skill, attr) + self.level_value(value) * self.buff_stack)
-
-    def sub(self, attribute: Attribute, skill: Skill, snapshot=None):
-        if snapshot is None:
-            self.sub_all(attribute, skill)
-        elif snapshot:
-            self.sub_snapshot(attribute, skill)
-        else:
-            self.sub_current(attribute, skill)
+            if snapshot and any(snapshot_attr in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
+                setattr(skill, attr, getattr(skill, attr) + self.level_value(value) * self.buff_stack)
+            elif not snapshot and all(snapshot_attr not in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
+                setattr(skill, attr, getattr(skill, attr) + self.level_value(value) * self.buff_stack)
 
     def sub_all(self, attribute: Attribute, skill: Skill):
         for attr, value in self.gain_attributes.items():
@@ -85,22 +63,14 @@ class Buff:
         for attr, value in self.gain_skills.get(skill.skill_id, {}).items():
             setattr(skill, attr, getattr(skill, attr) - self.level_value(value) * self.buff_stack)
 
-    def sub_snapshot(self, attribute: Attribute, skill: Skill):
-        for attr, value in self.gain_attributes.items():
-            if all(snapshot_attr not in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
-                continue
-            setattr(attribute, attr, getattr(attribute, attr) - self.level_value(value) * self.buff_stack)
-        for attr, value in self.gain_skills.get(skill.skill_id, {}).items():
-            if all(snapshot_attr not in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
-                continue
-            setattr(skill, attr, getattr(skill, attr) - self.level_value(value) * self.buff_stack)
-
-    def sub_current(self, attribute: Attribute, skill: Skill):
+    def sub_dot(self, attribute: Attribute, skill: Skill, snapshot: bool = True):
         for attr, value in self.gain_attributes.items():
-            if any(snapshot_attr in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
-                continue
-            setattr(attribute, attr, getattr(attribute, attr) - self.level_value(value) * self.buff_stack)
+            if snapshot and any(snapshot_attr in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
+                setattr(attribute, attr, getattr(attribute, attr) - self.level_value(value) * self.buff_stack)
+            elif not snapshot and all(snapshot_attr not in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
+                setattr(attribute, attr, getattr(attribute, attr) - self.level_value(value) * self.buff_stack)
         for attr, value in self.gain_skills.get(skill.skill_id, {}).items():
-            if any(snapshot_attr in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
-                continue
-            setattr(skill, attr, getattr(skill, attr) - self.level_value(value) * self.buff_stack)
+            if snapshot and any(snapshot_attr in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
+                setattr(skill, attr, getattr(skill, attr) - self.level_value(value) * self.buff_stack)
+            elif not snapshot and all(snapshot_attr not in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
+                setattr(skill, attr, getattr(skill, attr) - self.level_value(value) * self.buff_stack)

base/constant.py

@@ -33,12 +33,12 @@ SHIELD_BASE_MAP = {
 MAJOR_BASE = 41
 BASE_CRITICAL_POWER = 1.75
 
-AGILITY_TO_CRITICAL_STRIKE = 655 / BINARY_SCALE
-STRENGTH_TO_ATTACK_POWER = 153 / BINARY_SCALE
-STRENGTH_TO_OVERCOME = 307 / BINARY_SCALE
-SPIRIT_TO_CRITICAL_STRIKE = 655 / BINARY_SCALE
-SPUNK_TO_ATTACK_POWER = 184 / BINARY_SCALE
-SPUNK_TO_OVERCOME = 307 / BINARY_SCALE
+AGILITY_TO_CRITICAL_STRIKE = 0.64
+STRENGTH_TO_ATTACK_POWER = 0.15
+STRENGTH_TO_OVERCOME = 0.3
+SPIRIT_TO_CRITICAL_STRIKE = 0.64
+SPUNK_TO_ATTACK_POWER = 0.18
+SPUNK_TO_OVERCOME = 0.3
 
 DELTA_SCALE = 1
 MAJOR_DELTA = 198

base/skill.py

@@ -34,6 +34,7 @@ class Skill:
     weapon_damage_cof_gain: float = 0.
 
     skill_damage_addition: int = 0
+    skill_pve_addition: int = 0
     _skill_shield_gain: Union[List[int], int] = 0
     skill_critical_strike: int = 0
     skill_critical_power: int = 0
@@ -142,7 +143,7 @@ class Skill:
         damage = strain_result(damage, attribute.strain)
         critical_damage = strain_result(critical_damage, attribute.strain)
         damage = pve_addition_result(damage, attribute.pve_addition)
-        critical_damage = pve_addition_result(critical_damage, attribute.pve_addition)
+        critical_damage = pve_addition_result(critical_damage, attribute.pve_addition + self.skill_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_gain)
@@ -152,7 +153,27 @@ class Skill:
         return damage, critical_damage, expected_damage, critical_strike
 
 
-class PhysicalDamage(Skill):
+class DotSkill(Skill):
+    pass
+
+
+class DotConsumeSkill(Skill):
+    pass
+
+
+class Damage(Skill):
+    pass
+
+
+class DotDamage(Damage):
+    pass
+
+
+class PetDamage(Damage):
+    pass
+
+
+class PhysicalDamage(Damage):
     @property
     def attack_power_cof(self):
         return PHYSICAL_ATTACK_POWER_COF(super().attack_power_cof + self.interval)
@@ -162,13 +183,13 @@ class PhysicalDamage(Skill):
         self._attack_power_cof = attack_power_cof
 
 
-class MagicalDamage(Skill):
+class MagicalDamage(Damage):
     @property
     def attack_power_cof(self):
         return MAGICAL_ATTACK_POWER_COF(super().attack_power_cof + self.interval)
 
 
-class PhysicalDotDamage(Skill):
+class PhysicalDotDamage(DotDamage):
     @property
     def attack_power_cof(self):
         return PHYSICAL_DOT_ATTACK_POWER_COF(super().attack_power_cof, self.interval)
@@ -178,7 +199,7 @@ class PhysicalDotDamage(Skill):
         self._attack_power_cof = attack_power_cof
 
 
-class MagicalDotDamage(Skill):
+class MagicalDotDamage(DotDamage):
     @property
     def attack_power_cof(self):
         return MAGICAL_DOT_ATTACK_POWER_COF(super().attack_power_cof, self.interval)

parse_new_school.py

@@ -58,4 +58,4 @@ class Parser:
 
 if __name__ == '__main__':
     parser = Parser()
-    parser("单押.jcl")
+    parser("new.jcl")

schools/bei_ao_jue/skills.py

@@ -1,6 +1,6 @@
 from typing import Dict
 
-from base.skill import PhysicalDamage, PhysicalDotDamage, Skill
+from base.skill import Skill, DotSkill, PhysicalDamage, PhysicalDotDamage
 from general.skills import GENERAL_SKILLS
 
 SKILLS: Dict[int, Skill | dict] = {
@@ -60,7 +60,7 @@ SKILLS: Dict[int, Skill | dict] = {
         "interval": 48
     },
     17060: {
-        "skill_class": Skill,
+        "skill_class": DotSkill,
         "skill_name": "闹须弥",
         "bind_skill": 11447,
         "tick": 8
@@ -367,7 +367,7 @@ SKILLS: Dict[int, Skill | dict] = {
 
     },
     26934: {
-        "skill_class": Skill,
+        "skill_class": DotSkill,
         "skill_name": "背水沉舟",
         "bind_skill": 19555,
         "max_stack": 3,

schools/shan_hai_xin_jue/__init__.py

@@ -0,0 +1,6 @@
+from schools.shan_hai_xin_jue.skills import SKILLS
+from schools.shan_hai_xin_jue.buffs import BUFFS
+from schools.shan_hai_xin_jue.talents import TALENT_GAINS, TALENTS, TALENT_DECODER, TALENT_ENCODER
+# from schools.bei_ao_jue.recipes import RECIPE_GAINS, RECIPES
+# from schools.shan_hai_xin_jue.gains import GAINS
+from schools.shan_hai_xin_jue.attribute import ShanHaiXinJue

schools/shan_hai_xin_jue/attribute.py

@@ -0,0 +1,33 @@
+from base.attribute import PhysicalAttribute
+from base.constant import *
+
+
+class ShanHaiXinJue(PhysicalAttribute):
+    AGILITY_TO_ATTACK_POWER = 1485 / BINARY_SCALE
+    AGILITY_TO_CRITICAL_STRIKE = 594 / BINARY_SCALE
+
+    def __init__(self):
+        super().__init__()
+        self.physical_attack_power_base += 3277
+        self.physical_critical_strike_base += 2929
+        self.pve_addition += 82
+
+        self.grad_attrs = {
+            "agility_base": MAJOR_DELTA,
+            "strength_base": MAJOR_DELTA,
+            "surplus": MINOR_DELTA,
+            "strain_base": MINOR_DELTA,
+            "physical_attack_power_base": PHYSICAL_DELTA,
+            "physical_critical_strike_base": MINOR_DELTA,
+            "physical_critical_power_base": MINOR_DELTA,
+            "physical_overcome_base": MINOR_DELTA,
+            "weapon_damage_base": WEAPON_DELTA
+        }
+
+    @property
+    def extra_physical_attack_power(self):
+        return int(self.agility * self.AGILITY_TO_ATTACK_POWER)
+
+    @property
+    def extra_physical_critical_strike(self):
+        return int(self.agility * self.AGILITY_TO_CRITICAL_STRIKE)

schools/shan_hai_xin_jue/buffs.py

@@ -1,7 +1,9 @@
+from typing import Dict
+
 from base.buff import Buff
 from general.buffs import GENERAL_BUFFS
 
-BUFFS = {
+BUFFS: Dict[int, Buff | dict] = {
     16025: {
         "buff_name": "雷引",
         "gain_attributes": {

schools/shan_hai_xin_jue/skills.py

@@ -1,10 +1,10 @@
 from typing import Dict
 
-from base.skill import PhysicalDamage, PhysicalDotDamage, Skill
+from base.skill import Skill, DotSkill, DotConsumeSkill, PhysicalDamage, PhysicalDotDamage
 from general.skills import GENERAL_SKILLS
 
 SKILLS: Dict[int, Skill | dict] = {
-    32823: {
+    36177: {
         "skill_class": PhysicalDamage,
         "skill_name": "破",
         "surplus_cof": 0
@@ -13,7 +13,8 @@ SKILLS: Dict[int, Skill | dict] = {
         "skill_class": PhysicalDamage,
         "skill_name": "风矢",
         "attack_power_cof": 16,
-        "weapon_damage_cof": 1024
+        "weapon_damage_cof": 1024,
+        "skill_damage_addition": 205
     },
     35866: {
         "skill_class": PhysicalDamage,
@@ -63,12 +64,18 @@ SKILLS: Dict[int, Skill | dict] = {
         "attack_power_cof": 0
     },
     26856: {
-        "skill_class": PhysicalDamage,
+        "skill_class": PhysicalDotDamage,
         "skill_name": "贯穿(DOT)",
         "attack_power_cof": 0
     },
+    36165: {
+        "skill_class": DotConsumeSkill,
+        "skill_name": "贯穿",
+        "bind_skill": 26856,
+        "tick": 3
+    },
     35771: {
-        "skill_class": Skill,
+        "skill_class": DotSkill,
         "skill_name": "贯穿",
         "bind_skill": 26856,
         "max_stack": 6,

schools/shan_hai_xin_jue/talents.py

@@ -0,0 +1,83 @@
+from typing import Dict
+
+from base.attribute import Attribute
+from base.gain import Gain
+from base.skill import Skill
+
+
+class 彤弓(Gain):
+    def add_skills(self, skills: Dict[int, Skill]):
+        skills[35866].skill_critical_strike += 102
+        skills[35866].skill_critical_power += 102
+
+    def sub_skills(self, skills: Dict[int, Skill]):
+        skills[35866].skill_critical_strike -= 102
+        skills[35866].skill_critical_power -= 102
+
+
+class 素矰(Gain):
+    def add_skills(self, skills: Dict[int, Skill]):
+        skills[26856].attack_power_cof_gain += 0.05
+
+    def sub_skills(self, skills: Dict[int, Skill]):
+        skills[26856].attack_power_cof_gain -= 0.05
+
+
+class 桑柘(Gain):
+    def add_skills(self, skills: Dict[int, Skill]):
+        skills[35771].tick += 1
+
+    def sub_skills(self, skills: Dict[int, Skill]):
+        skills[35771].tick -= 1
+
+
+class 卢令(Gain):
+    def add_attribute(self, attribute: Attribute):
+        attribute.agility_gain += 102
+
+    def sub_attribute(self, attribute: Attribute):
+        attribute.agility_gain -= 102
+
+
+class 贯侯(Gain):
+    def add_skills(self, skills: Dict[int, Skill]):
+        skills[26856].skill_pve_addition += 205
+
+    def sub_skills(self, skills: Dict[int, Skill]):
+        skills[26856].skill_pve_addition -= 205
+
+
+TALENT_GAINS: Dict[int, Gain] = {
+    35715: 素矰("素矰"),
+    35714: 彤弓("彤弓"),
+    35718: Gain("棘矢"),
+    35719: Gain("孰湖"),
+    35721: Gain("襄尺"),
+    35725: Gain("长右"),
+    35729: Gain("鹿蜀"),
+    35736: 桑柘("桑柘"),
+    35737: Gain("于狩"),
+    35745: 卢令("卢令"),
+    35749: Gain("托月"),
+    35751: Gain("佩弦"),
+    35757: 贯侯("贯侯"),
+    35764: Gain("朝仪万汇"),
+    35761: Gain("朱厌")
+}
+
+TALENTS = [
+    [35715, 35714],
+    [35718, 35719],
+    [35721],
+    [35725],
+    [35729],
+    [35736],
+    [35737],
+    [35745],
+    [35749],
+    [35751],
+    [35757],
+    [35764, 35761]
+]
+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/analyzer.py

@@ -3,7 +3,7 @@ from collections import defaultdict
 from typing import Dict
 
 from base.attribute import Attribute
-from base.skill import Skill
+from base.skill import Skill, DotDamage
 from utils.parser import School
 
 
@@ -46,22 +46,22 @@ def add_buffs(current_buffs, snapshot_buffs, attribute: Attribute, skill: Skill)
     if not snapshot_buffs:
         for buff in current_buffs:
             buff.add_all(attribute, skill)
-    else:
+    elif isinstance(skill, DotDamage):
         for buff in snapshot_buffs:
-            buff.add_snapshot(attribute, skill)
+            buff.add_dot(attribute, skill, True)
         for buff in current_buffs:
-            buff.add_current(attribute, skill)
+            buff.add_dot(attribute, skill, False)
 
 
 def sub_buffs(current_buffs, snapshot_buffs, attribute: Attribute, skill: Skill):
     if not snapshot_buffs:
         for buff in current_buffs:
             buff.sub_all(attribute, skill)
-    else:
+    elif isinstance(skill, DotDamage):
         for buff in snapshot_buffs:
-            buff.sub_snapshot(attribute, skill)
+            buff.sub_dot(attribute, skill, True)
         for buff in current_buffs:
-            buff.sub_current(attribute, skill)
+            buff.sub_dot(attribute, skill, False)
 
 
 def concat_buffs(current_buffs, snapshot_buffs):
@@ -117,15 +117,17 @@ def analyze_details(record, duration: int, attribute: Attribute, school: School)
             for attr, residual_damage in detail.gradients.items():
                 skill_total.gradients[attr] += residual_damage * len(timeline)
 
-        total.expected_damage += skill_total.expected_damage
-        skill_summary.expected_damage += skill_total.expected_damage
-        skill_summary.critical_count += skill_total.critical_strike
-        skill_summary.count += skill_total.count
-
-        skill_total.damage /= skill_total.count
-        skill_total.critical_damage /= skill_total.count
-        skill_total.expected_damage /= skill_total.count
-        skill_total.critical_strike /= skill_total.count
+        if skill_total.count:
+            total.expected_damage += skill_total.expected_damage
+            skill_summary.expected_damage += skill_total.expected_damage
+            skill_summary.critical_count += skill_total.critical_strike
+            skill_summary.count += skill_total.count
+            skill_total.damage /= skill_total.count
+            skill_total.critical_damage /= skill_total.count
+            skill_total.expected_damage /= skill_total.count
+            skill_total.critical_strike /= skill_total.count
+        else:
+            summary.pop(skill_name)
         for attr, residual_damage in skill_total.gradients.items():
             total.gradients[attr] += residual_damage
             skill_total.gradients[attr] /= skill_total.count

utils/parser.py

@@ -5,8 +5,8 @@ from collections import defaultdict
 from base.attribute import Attribute
 from base.buff import Buff
 from base.gain import Gain
-from base.skill import Skill
-from schools import bei_ao_jue
+from base.skill import Skill, DotSkill, DotConsumeSkill, Damage, DotDamage
+from schools import bei_ao_jue, shan_hai_xin_jue
 from utils.lua import parse
 
 SKILL_TYPE = Tuple[int, int, int]
@@ -80,6 +80,39 @@ SUPPORT_SCHOOL = {
             "strain": "无双",
             "surplus": "破招",
         }
+    ),
+    10756: School(
+        school="万灵",
+        major="身法",
+        kind="外功",
+        attribute=shan_hai_xin_jue.ShanHaiXinJue,
+        formation="苍梧引灵阵",
+        skills=shan_hai_xin_jue.SKILLS,
+        buffs=shan_hai_xin_jue.BUFFS,
+        talent_gains=shan_hai_xin_jue.TALENT_GAINS,
+        talents=shan_hai_xin_jue.TALENTS,
+        talent_decoder=shan_hai_xin_jue.TALENT_DECODER,
+        talent_encoder=shan_hai_xin_jue.TALENT_ENCODER,
+        recipe_gains=None,
+        recipes=None,
+        gains=None,
+        display_attrs={
+            "agility": "身法",
+            "base_physical_attack_power": "基础攻击",
+            "physical_attack_power": "攻击",
+            "base_physical_critical_strike": "会心等级",
+            "physical_critical_strike": "会心",
+            "physical_critical_power_base": "会效等级",
+            "physical_critical_power": "会效",
+            "base_physical_overcome": "基础破防",
+            "final_physical_overcome": "最终破防",
+            "physical_overcome": "破防",
+            "weapon_damage_base": "基础武器伤害",
+            "weapon_damage_rand": "浮动武器伤害",
+            "strain_base": "无双等级",
+            "strain": "无双",
+            "surplus": "破招",
+        }
     )
 }
 
@@ -107,8 +140,10 @@ class Parser:
     records: Dict[int, List[RECORD_TYPE]]
     status: Dict[int, STATUS_TYPE]
     snapshot: Dict[int, SNAPSHOT_TYPE]
+    last_dot: Dict[int, Dict[int, Tuple[Tuple[int, int, int], Tuple[tuple, tuple]]]]
     stacks: Dict[int, Dict[int, int]]
     ticks: Dict[int, Dict[int, int]]
+    pets: Dict[int, int]
 
     fight_flag: Dict[int, bool]
     start_time: Dict[int, List[int]]
@@ -148,8 +183,10 @@ class Parser:
         self.records = defaultdict(list)
         self.status = defaultdict(dict)
         self.snapshot = defaultdict(dict)
+        self.last_dot = defaultdict(dict)
         self.stacks = defaultdict(lambda: defaultdict(lambda: 1))
         self.ticks = defaultdict(lambda: defaultdict(int))
+        self.pets = {}
 
         self.fight_flag = defaultdict(bool)
         self.start_time = defaultdict(list)
@@ -190,6 +227,12 @@ class Parser:
                 self.select_equipments[player_id] = self.parse_equipments(detail[5])
                 self.select_talents[player_id] = self.parse_talents(detail[6])
 
+    def parse_pet(self, row):
+        detail = row.strip("{}").split(",")
+        pet_id, player_id = int(detail[0]), int(detail[3])
+        if player_id in self.school:
+            self.pets[pet_id] = player_id
+
     def parse_time(self, row, timestamp):
         detail = row.strip("{}").split(",")
         player_id = int(detail[0])
@@ -218,7 +261,12 @@ class Parser:
 
     def parse_skill(self, row, timestamp):
         detail = row.strip("{}").split(",")
-        player_id = int(detail[0])
+        caster_id = int(detail[0])
+        if caster_id in self.pets:
+            player_id = self.pets[caster_id]
+        else:
+            player_id = caster_id
+
         if not self.fight_flag[player_id] or player_id not in self.school:
             return
         skill_id, skill_level, critical = int(detail[4]), int(detail[5]), detail[6] == "true"
@@ -226,21 +274,34 @@ class Parser:
             return
         timestamp = int(timestamp) - self.start_time[player_id][-1]
         skill_stack = self.stacks[player_id][skill_id]
-        if self.ticks[player_id][skill_id]:
-            self.ticks[player_id][skill_id] -= 1
-            if not self.ticks[player_id][skill_id]:
-                self.stacks[player_id].pop(skill_id)
 
-        skill_tuple = (skill_id, skill_level, skill_stack)
         skill = self.school[player_id].skills[skill_id]
-        if bind_skill := skill.bind_skill:
+        if isinstance(skill, DotSkill):
+            bind_skill = skill.bind_skill
+            if not self.ticks[player_id][bind_skill]:
+                self.stacks[player_id][bind_skill] = 0
+            self.ticks[player_id][bind_skill] = skill.tick
             self.stacks[player_id][bind_skill] = min(self.stacks[player_id][bind_skill] + 1, skill.max_stack)
-            self.ticks[player_id][bind_skill] = skill.tick if not self.ticks[player_id][bind_skill] else skill.tick - 1
             self.snapshot[player_id][bind_skill] = self.status[player_id].copy()
-        else:
+        elif isinstance(skill, DotConsumeSkill):
+            bind_skill = skill.bind_skill
+            skill_tuple, status_tuple = self.last_dot[player_id][bind_skill]
+            skill_id, skill_level, skill_stack = skill_tuple
+            self.ticks[player_id][skill_id] += 1
+            tick = min(self.ticks[player_id][skill_id], skill.tick)
             current_record = self.records[player_id][len(self.start_time) - 1]
+            current_record[(skill_id, skill_level, skill_stack * tick)][status_tuple].append(
+                current_record[skill_tuple][status_tuple].pop()
+            )
+            self.ticks[player_id][skill_id] -= tick
+        elif isinstance(skill, Damage):
+            skill_tuple = (skill_id, skill_level, skill_stack)
             status_tuple = self.available_status(player_id, skill_id)
+            current_record = self.records[player_id][len(self.start_time) - 1]
             current_record[skill_tuple][status_tuple].append((timestamp, critical))
+            if isinstance(skill, DotDamage):
+                self.last_dot[player_id][skill_id] = (skill_tuple, status_tuple)
+                self.ticks[player_id][skill_id] -= 1
 
     def __call__(self, file_name):
         self.reset()
@@ -253,6 +314,8 @@ class Parser:
             row = line.split("\t")
             if row[4] == "5":
                 self.parse_time(row[-1], row[3])
+            if row[4] == "8":
+                self.parse_pet(row[-1])
             elif row[4] == "13":
                 self.parse_buff(row[-1])
             elif row[4] == "21":
@@ -265,3 +328,9 @@ class Parser:
             }
             for player_id in self.end_time
         }
+
+
+if __name__ == '__main__':
+    parser = Parser()
+    parser("../new.jcl")
+    print(parser)