5.13 commit

base/buff.py

@@ -7,33 +7,16 @@ from base.skill import Skill
 ATTR_DICT = Dict[str, Union[List[int], int]]
 
 
-@dataclass
-class Buff:
-    buff_id: int
+class BaseBuff:
+    SNAPSHOT_ATTRS = ["attack_power", "critical_strike", "critical_power", "strain", "damage_addition", "pve_addition"]
+    PET_ATTRS = ["attack_power", "critical_power", "overcome", "strain", "damage_addition", "pve_addition"]
+
     _buff_name: Union[List[str], str] = ""
     buff_level: int = 0
     buff_stack: int = 1
 
-    frame_shift: int = 0
-    second_shift: int = 0
-    activate: bool = True
-
     max_stack: int = 1
-
-    gain_skills: Dict[int, ATTR_DICT] = None
-    gain_attributes: ATTR_DICT = None
-
-    SNAPSHOT_ATTRS = ["attack_power", "critical_strike", "critical_power", "strain", "damage_addition", "pve_addition"]
-
-    def __post_init__(self):
-        if self.gain_skills is None:
-            self.gain_skills = {}
-        if self.gain_attributes is None:
-            self.gain_attributes = {}
-
-    @property
-    def shifted(self):
-        return self.second_shift or self.frame_shift
+    interval: int = 0
 
     @property
     def buff_name(self):
@@ -52,6 +35,28 @@ class Buff:
         else:
             self._buff_name = [buff_name]
 
+
+@dataclass
+class Buff(BaseBuff):
+    buff_id: int
+
+    frame_shift: int = 0
+    second_shift: int = 0
+    activate: bool = True
+
+    gain_skills: Dict[int, ATTR_DICT] = None
+    gain_attributes: ATTR_DICT = None
+
+    def __post_init__(self):
+        if self.gain_skills is None:
+            self.gain_skills = {}
+        if self.gain_attributes is None:
+            self.gain_attributes = {}
+
+    @property
+    def shifted(self):
+        return self.second_shift or self.frame_shift
+
     @property
     def display_name(self):
         return f"{self.buff_name}#{self.buff_id}-{self.buff_level}-{self.buff_stack}"

base/skill.py

@@ -6,23 +6,11 @@ from typing import List, Union
 from dataclasses import dataclass
 
 
-@dataclass
-class Skill:
-    skill_id: int
+class BaseSkill:
     _skill_name: Union[List[str], str] = ""
     skill_level: int = 0
     skill_stack: int = 1
 
-    activate: bool = True
-
-    bind_skill: int = None
-    bind_buff: int = None
-    max_stack: int = 1
-    tick: int = 1
-    interval: int = 0
-    duration: int = 0
-    last_dot: bool = True
-
     _damage_base: Union[List[int], int] = 0
     _damage_rand: Union[List[int], int] = 0
 
@@ -44,10 +32,6 @@ class Skill:
     skill_critical_strike: int = 0
     skill_critical_power: int = 0
 
-    @property
-    def display_name(self):
-        return f"{self.skill_name}#{self.skill_id}-{self.skill_level}-{self.skill_stack}"
-
     @property
     def skill_name(self):
         if not isinstance(self._skill_name, list):
@@ -154,7 +138,7 @@ class Skill:
             self._weapon_damage_cof = weapon_damage_cof
         else:
             self._weapon_damage_cof = [weapon_damage_cof]
-        
+
     @property
     def skill_shield_gain(self):
         if not isinstance(self._skill_shield_gain, list):
@@ -188,41 +172,93 @@ class Skill:
             self._skill_pve_addition = skill_pve_addition
         else:
             self._skill_pve_addition = [skill_pve_addition]
-            
+
+
+@dataclass
+class Skill(BaseSkill):
+    skill_id: int
+
+    activate: bool = True
+
+    interval: int = 0
+    bind_skill: int = 0
+    tick: int = 1
+    max_stack: int = 1
+    last_dot: bool = True
+
+    pre_effects: list = None
+    pre_buffs: dict = None
+    pre_target_buffs: dict = None
+    post_effects: list = None
+    post_buffs: dict = None
+    post_target_buffs: dict = None
+
+    def __post_init__(self):
+        if not self.pre_effects:
+            self.pre_effects = []
+        if not self.pre_buffs:
+            self.pre_buffs = {}
+        if not self.pre_target_buffs:
+            self.pre_target_buffs = {}
+        if not self.post_effects:
+            self.post_effects = []
+        if not self.post_buffs:
+            self.post_buffs = {}
+        if not self.post_target_buffs:
+            self.post_target_buffs = {}
+
+    @property
+    def display_name(self):
+        return f"{self.skill_name}#{self.skill_id}-{self.skill_level}-{self.skill_stack}"
+
+    def pre_record(self, parser):
+        for (buff_id, buff_level), buff_stack in self.pre_buffs.items():
+            buff_level = buff_level if buff_level else self.skill_level
+            parser.refresh_buff(buff_id, buff_level, buff_stack)
+        for (buff_id, buff_level), buff_stack in self.pre_target_buffs.items():
+            buff_level = buff_level if buff_level else self.skill_level
+            parser.refresh_target_buff(buff_id, buff_level, buff_stack)
+        for effect in self.pre_effects:
+            effect(parser)
+
     def record(self, critical, parser):
         pass
 
+    def post_record(self, parser):
+        for (buff_id, buff_level), buff_stack in self.post_buffs.items():
+            buff_level = buff_level if buff_level else self.skill_level
+            parser.refresh_buff(buff_id, buff_level, buff_stack)
+        for (buff_id, buff_level), buff_stack in self.post_target_buffs.items():
+            buff_level = buff_level if buff_level else self.skill_level
+            parser.refresh_target_buff(buff_id, buff_level, buff_stack)
+        for effect in self.post_effects:
+            effect(parser)
+
+    def parse(self, critical, parser):
+        self.pre_record(parser)
+        self.record(critical, parser)
+        self.post_record(parser)
+
     def __call__(self, attribute: Attribute):
         return 0
 
 
-class HiddenBuffSkill(Skill):
-    def record(self, critical, parser):
-        super().record(critical, parser)
-        if self.bind_buff not in parser.current_school.buffs:
-            return
-        max_stack = parser.current_school.buffs[self.bind_buff].max_stack
-        buff = (self.bind_buff, 1)
-        parser.current_hidden_buffs.pop(buff, None)
-        parser.current_target_buffs[buff] = min(parser.current_target_buffs.get(buff, 0) + 1, max_stack)
-        end_frame = parser.current_frame + self.duration
-        parser.current_hidden_buffs[buff] = end_frame
-
-
 class DotSkill(Skill):
     def record(self, critical, parser):
         super().record(critical, parser)
         bind_skill = parser.current_school.skills[self.bind_skill]
-        if not parser.current_ticks[self.bind_skill]:
-            parser.current_stacks[self.bind_skill] = 0
-        parser.current_ticks[self.bind_skill] = bind_skill.tick
-        parser.current_stacks[self.bind_skill] = min(parser.current_stacks[self.bind_skill] + 1, bind_skill.max_stack)
-        parser.current_dot_snapshot[self.bind_skill] = parser.current_player_buffs.copy()
+        if not parser.current_dot_ticks[self.bind_skill]:
+            parser.current_dot_stacks[self.bind_skill] = 0
+        parser.current_dot_ticks[self.bind_skill] = bind_skill.tick
+        parser.current_dot_stacks[self.bind_skill] = min(
+            parser.current_dot_stacks.get(self.bind_skill, 0) + 1, bind_skill.max_stack
+        )
+        parser.current_dot_snapshot[self.bind_skill] = parser.current_buff_stacks.copy()
 
 
 class DotConsumeSkill(Skill):
     def consume_next(self, parser):
-        tick = min(parser.current_ticks[self.bind_skill], self.tick)
+        tick = min(parser.current_dot_ticks[self.bind_skill], self.tick)
         parser.current_next_dot[self.bind_skill] = tick
 
     def consume_last(self, parser):
@@ -230,12 +266,12 @@ class DotConsumeSkill(Skill):
             return
         skill_tuple, status_tuple = last_dot
         skill_id, skill_level, skill_stack = skill_tuple
-        parser.current_ticks[skill_id] += 1
-        tick = min(parser.current_ticks[skill_id], self.tick)
+        parser.current_dot_ticks[skill_id] += 1
+        tick = min(parser.current_dot_ticks[skill_id], self.tick)
         parser.current_records[(skill_id, skill_level, skill_stack * tick)][status_tuple].append(
             parser.current_records[skill_tuple][status_tuple].pop()
         )
-        parser.current_ticks[skill_id] -= tick
+        parser.current_dot_ticks[skill_id] -= tick
 
     def record(self, critical, parser):
         super().record(critical, parser)
@@ -248,7 +284,7 @@ class DotConsumeSkill(Skill):
 class Damage(Skill):
     def record(self, critical, parser):
         super().record(critical, parser)
-        skill_stack = parser.current_stacks[self.skill_id]
+        skill_stack = parser.current_dot_stacks[self.skill_id]
         skill_tuple = (self.skill_id, self.skill_level, skill_stack)
         status_tuple = parser.status(self.skill_id)
         parser.current_records[skill_tuple][status_tuple].append(
@@ -257,6 +293,21 @@ class Damage(Skill):
         return skill_tuple, status_tuple
 
 
+class DotDamage(Damage):
+    def record(self, critical, parser):
+        skill_tuple, status_tuple = super().record(critical, parser)
+
+        if tick := parser.current_next_dot.pop(self.skill_id, None):
+            _, _, skill_stack = skill_tuple
+            parser.current_records[(self.skill_id, self.skill_level, skill_stack * tick)][status_tuple].append(
+                parser.current_records[skill_tuple][status_tuple].pop()
+            )
+            parser.current_dot_ticks[self.skill_id] -= tick
+        else:
+            parser.current_last_dot[self.skill_id] = (skill_tuple, status_tuple)
+            parser.current_dot_ticks[self.skill_id] -= 1
+
+
 class NpcDamage(Damage):
     pass
 
@@ -296,21 +347,6 @@ class PetDamage(Damage):
         return damage, critical_damage, expected_damage, critical_strike
 
 
-class DotDamage(Damage):
-    def record(self, critical, parser):
-        skill_tuple, status_tuple = super().record(critical, parser)
-
-        if tick := parser.current_next_dot.pop(self.skill_id, None):
-            _, _, skill_stack = skill_tuple
-            parser.current_records[(self.skill_id, self.skill_level, skill_stack * tick)][status_tuple].append(
-                parser.current_records[skill_tuple][status_tuple].pop()
-            )
-            parser.current_ticks[self.skill_id] -= tick
-        else:
-            parser.current_last_dot[self.skill_id] = (skill_tuple, status_tuple)
-            parser.current_ticks[self.skill_id] -= 1
-
-
 class PureSkill(Skill):
     def __call__(self, attribute: Attribute):
         damage = init_result(self.damage_base, self.damage_rand, 0, 0, 0, 0, 0, 0)

general/buffs/team.py

@@ -22,6 +22,7 @@ GENERAL_BUFFS = {
     },
     3465: {
         "buff_name": "破甲",
+        "interval": 128,
         "gain_attributes": {
             "physical_shield_gain": -102
         }

general/skills.py

@@ -3,13 +3,15 @@ from typing import Dict
 from base.skill import PhysicalDamage, MagicalDamage, Skill, PureDamage
 
 GENERAL_SKILLS: Dict[int, Skill | dict] = {
-    29535: {
-        "skill_class": MagicalDamage,
-        "skill_name": "逐云寒蕊",
-        "damage_base": 40,
-        "damage_rand": 17,
-        "attack_power_cof": [90, 200 * 1.2],
-        "skill_shield_gain": -1024
+    **{
+        skill_id: {
+            "skill_class": MagicalDamage,
+            "skill_name": "逐云寒蕊",
+            "damage_base": 40,
+            "damage_rand": 17,
+            "attack_power_cof": [90, 200 * 1.2],
+            "skill_shield_gain": -1024
+        } for skill_id in (29532, 29533, 29534, 29535)
     },
     29536: {
         "skill_class": PhysicalDamage,

general/skills/team.py

@@ -1,13 +1,12 @@
 from typing import Dict
 
-from base.skill import PhysicalDamage, MagicalDamage, Skill, PureDamage, HiddenBuffSkill
+from base.skill import PhysicalDamage, MagicalDamage, Skill
 
 GENERAL_SKILLS: Dict[int, Skill | dict] = {
     13778: {
-        "skill_class": HiddenBuffSkill,
+        "skill_class": Skill,
         "skill_name": "乘龙箭",
-        "bind_buff": 3465,
-        "duration": 128
+        "post_target_buffs": {(3465, 1): 1},
     },
     29535: {
         "skill_class": MagicalDamage,

schools/ao_xue_zhan_yi/__init__.py

@@ -7,4 +7,4 @@ from schools.ao_xue_zhan_yi.attribute import AoXueZhanYi
 
 
 def prepare(self, player_id):
-    pass
+    self.buff_stacks[player_id][(-1, 1)] = 5

schools/ao_xue_zhan_yi/buffs.py

@@ -10,6 +10,10 @@ BUFFS = {
             "physical_critical_power_gain": 41
         }
     },
+    -1: {
+        "buff_name": "战意",
+        "max_stack": 5
+    },
     6121: {
         "buff_name": "驰骋",
         "gain_attributes": {
@@ -19,10 +23,10 @@ BUFFS = {
     6363: {
         "buff_name": "激雷",
         "gain_attributes": {
-            "physical_attack_power_gain": [205, 0] * 2,
-            "physical_overcome_gain": [205, 0] * 2,
-            "physical_critical_strike_gain": [0] + [3000] * 3,
-            "all_shield_ignore": [0] * 3 + [717]
+            "physical_attack_power_gain": [205, 0, 205, 0],
+            "physical_overcome_gain": [205, 0, 205, 0],
+            "physical_critical_strike_gain": [0, 3000, 3000, 3000],
+            "all_shield_ignore": [0, 0, 0, 717]
         }
     },
     14981: {
@@ -44,24 +48,30 @@ BUFFS = {
             "all_damage_addition": 72
         }
     },
-    # 12608: {
-    #     "buff_name": "风虎",
-    #     "frame_shift": 1,
-    #     "gain_skills": {
-    #         skill_id: {
-    #             "skill_damage_addition": [51, 102, 154, 205, 256]
-    #         } for skill_id in [18207] + [18603] + [18773, 15002] + [702, 24898, 6526]
-    #     }
-    # },
-    26008: {
+    -12608: {
+        "buff_name": "风虎",
+        "activate": False,
+        "interval": 16,
+        "gain_skills": {
+            skill_id: {
+                "skill_damage_addition": [51, 102, 154, 205, 256]
+            } for skill_id in [18207] + [18603] + [18773, 15002] + [702, 24898, 6526]
+        }
+    },
+    -26008: {
         "buff_name": "战心",
-        "frame_shift": -2,
+        "interval": 4,
         "gain_skills": {
             3442: {
                 "attack_power_cof_gain": 1.2
             }
         }
-    }
+    },
+    -28169: {
+        "buff_name": "龙印",
+        "interval": 480,
+        "max_stack": 3
+    },
 }
 
 for buff_id, detail in BUFFS.items():

schools/ao_xue_zhan_yi/skills.py

@@ -3,6 +3,16 @@ from typing import Dict
 from base.skill import Skill, DotSkill, PhysicalDamage, PhysicalDotDamage
 from general.skills import GENERAL_SKILLS
 
+
+class 战意判定(Skill):
+    final_buff = -12608
+    bind_buff = -1
+
+    def record(self, critical, parser):
+        if buff_level := parser.current_buff_stacks.get((self.bind_buff, 1)):
+            parser.refresh_buff(self.final_buff, buff_level)
+
+
 SKILLS: Dict[int, Skill | dict] = {
     32820: {
         "skill_class": PhysicalDamage,
@@ -37,7 +47,8 @@ SKILLS: Dict[int, Skill | dict] = {
         "damage_base": 39,
         "damage_rand": 3,
         "attack_power_cof": 16,
-        "weapon_damage_cof": 1024
+        "weapon_damage_cof": 1024,
+        "post_buffs": {(-1, 1): 3}
     },
     431: {
         "skill_class": PhysicalDamage,
@@ -55,13 +66,14 @@ SKILLS: Dict[int, Skill | dict] = {
         "weapon_damage_cof": 1024
     },
     702: {
-        "skill_class": PhysicalDamage,
+        "skill_class": type("Mixing", (PhysicalDamage, DotSkill), {}),
         "skill_name": "灭",
         "skill_level": 19,
         "damage_base": 160 * 1.3,
         "damage_rand": 10,
         "attack_power_cof": 170 * 1.12,
-        "weapon_damage_cof": 1024
+        "weapon_damage_cof": 1024,
+        "bind_skill": 3442,
     },
     18207: {
         "skill_class": PhysicalDamage,
@@ -69,8 +81,9 @@ SKILLS: Dict[int, Skill | dict] = {
         "skill_level": 28,
         "damage_base": 160,
         "damage_rand": 15,
-        "attack_power_cof": 158 * 1.05*1.1*1.1*1.12*1.1,
-        "weapon_damage_cof": 1024
+        "attack_power_cof": 158 * 1.05 * 1.1 * 1.1 * 1.12 * 1.1,
+        "weapon_damage_cof": 1024,
+        "post_buffs": {(-1, 1): 1}
     },
     18603: {
         "skill_class": PhysicalDamage,
@@ -79,7 +92,8 @@ SKILLS: Dict[int, Skill | dict] = {
         "damage_base": 289 * 0.65,
         "damage_rand": 15,
         "attack_power_cof": 184 * 1.1 * 1.1 * 1.12 * 1.1 * 1.1 * 1.2,
-        "weapon_damage_cof": 1024
+        "weapon_damage_cof": 1024,
+        "post_buffs": {(-1, 1): 2}
     },
     18773: {
         "skill_class": PhysicalDamage,
@@ -88,7 +102,8 @@ SKILLS: Dict[int, Skill | dict] = {
         "damage_base": 445 * 0.5,
         "damage_rand": 15,
         "attack_power_cof": 197 * 1.1 * 1.1 * 1.15 * 1.1 * 1.1 * 1.12 * 0.9 * 1.1 * 1.05,
-        "weapon_damage_cof": 1024
+        "weapon_damage_cof": 1024,
+        "post_buffs": {(-1, 1): -3}
     },
     37618: {
         "skill_class": PhysicalDamage,
@@ -114,6 +129,10 @@ SKILLS: Dict[int, Skill | dict] = {
         "attack_power_cof": 170 * 1.12 * 1,
         "weapon_damage_cof": 1024 / 4
     },
+    18740: {
+        "skill_class": 战意判定,
+        "skill_name": "战意判定"
+    },
     15002: {
         "skill_class": PhysicalDamage,
         "skill_name": "龙牙",
@@ -124,6 +143,11 @@ SKILLS: Dict[int, Skill | dict] = {
         "attack_power_cof": 197 * 1.1 * 1.1 * 1.15 * 0.4 * 1.1 * 1.1 * 1.12 * 0.9 * 1.1 * 1.05,
         "weapon_damage_cof": 1024 * 0.1
     },
+    1850: {
+        "skill_class": Skill,
+        "skill_name": "特效触发",
+        "post_buffs": {(-1, 1): 5}
+    },
     25772: {
         "skill_class": PhysicalDamage,
         "skill_name": "龙牙·神兵",
@@ -136,7 +160,7 @@ SKILLS: Dict[int, Skill | dict] = {
         "skill_name": "画角闻龙",
         "damage_base": 523 * 0.95,
         "damage_rand": 523 * 0.1,
-        "attack_power_cof": 205
+        "attack_power_cof": 205,
     },
 }
 

schools/ao_xue_zhan_yi/talents.py

@@ -1,6 +1,6 @@
 from typing import Dict
 
-from base.attribute import Attribute
+from base.buff import Buff
 from base.gain import Gain
 from base.skill import Skill
 
@@ -36,21 +36,21 @@ class 神勇(Gain):
 
 
 class 风虎(Gain):
+    def add_buffs(self, buffs: Dict[int, Buff]):
+        buffs[-12608].activate = True
+
+    def sub_buffs(self, buffs: Dict[int, Buff]):
+        buffs[-12608].activate = False
+
+
+class 战心(Gain):
     def add_skills(self, skills: Dict[int, Skill]):
-        skills[18207].skill_damage_addition += 205
-        skills[18603].skill_damage_addition += 102
-        for skill_id in [18773, 15002]:
-            skills[skill_id].skill_damage_addition += 256
-        for skill_id in [702, 24898, 6526]:
-            skills[skill_id].skill_damage_addition += 102
+        skills[702].pre_buffs[(-26008, 1)] = 1
+        skills[702].post_buffs[(-1, 1)] = 3
 
     def sub_skills(self, skills: Dict[int, Skill]):
-        skills[18207].skill_damage_addition -= 205
-        skills[18603].skill_damage_addition -= 102
-        for skill_id in [18773, 15002]:
-            skills[skill_id].skill_damage_addition -= 256
-        for skill_id in [702, 24898, 6526]:
-            skills[skill_id].skill_damage_addition -= 102
+        skills[702].pre_buffs.pop((-26008, 1))
+        skills[702].post_buffs.pop((-1, 1))
 
 
 class 骁勇(Gain):
@@ -61,6 +61,20 @@ class 骁勇(Gain):
         skills[3442].attack_power_cof_gain /= 1.12
 
 
+class 虎贲(Gain):
+    @staticmethod
+    def effect(parser):
+        if parser.current_buff_stacks.get((-28169, 1)) == 3:
+            parser.refresh_buff(-1, 1, 3)
+        parser.refresh_buff(-28169, 1)
+
+    def add_skills(self, skills: Dict[int, Skill]):
+        skills[18773].post_effects.append(self.effect)
+
+    def sub_skills(self, skills: Dict[int, Skill]):
+        skills[18773].post_effects.remove(self.effect)
+
+
 TALENT_GAINS: Dict[int, Gain] = {
     18487: Gain("百折"),
     5656: 封侯("封侯"),
@@ -72,11 +86,11 @@ TALENT_GAINS: Dict[int, Gain] = {
     14824: Gain("驰骋"),
     6511: Gain("牧云"),
     5666: 风虎("风虎"),
-    6781: Gain("战心"),
+    6781: 战心("战心"),
     6524: Gain("破楼兰"),
     5678: Gain("夜征"),
     15001: Gain("龙血"),
-    6517: Gain("虎贲")
+    6517: 虎贲("虎贲")
 }
 
 TALENTS = [

schools/bei_ao_jue/buffs.py

@@ -1,7 +1,6 @@
 from base.buff import Buff
 from general.buffs import GENERAL_BUFFS
 
-
 BUFFS = {
     11378: {
         "buff_name": "朔气",
@@ -11,15 +10,17 @@ BUFFS = {
             "physical_critical_power_gain": 41
         }
     },
-    18384: {
+    -18384: {
         "buff_name": "含风",
+        "interval": 384,
         "gain_attributes": {
             "physical_critical_strike_gain": 1000,
             "physical_critical_power_gain": 102
         }
     },
-    23066: {
+    -23066: {
         "buff_name": "含风",
+        "interval": 384,
         "gain_skills": {
             skill_id: {
                 "skill_damage_addition": 102,
@@ -42,4 +43,4 @@ for buff_id, detail in BUFFS.items():
 
 for buff_id, buff in GENERAL_BUFFS.items():
     if buff_id not in BUFFS:
-        BUFFS[buff_id] = buff
+        BUFFS[buff_id] = buff

schools/bei_ao_jue/talents.py

@@ -35,6 +35,16 @@ class 阳关(Gain):
         skills[32859].skill_damage_addition -= 154
 
 
+class 含风(Gain):
+    def add_skills(self, skills: Dict[int, Skill]):
+        skills[16610].pre_buffs[(-18384, 1)] = 1
+        skills[16610].pre_buffs[(-23066, 2)] = 1
+
+    def sub_skills(self, skills: Dict[int, Skill]):
+        skills[16610].pre_buffs.pop((-18384, 1))
+        skills[16610].pre_buffs.pop((-23066, 2))
+
+
 class 星火(Gain):
     def add_attribute(self, attribute: Attribute):
         attribute.strength_gain += 102
@@ -65,7 +75,7 @@ TALENT_GAINS: Dict[int, Gain] = {
     26904: 冥鼓("冥鼔"),
     17042: 阳关("阳关"),
     16799: Gain("霜天"),
-    25633: Gain("含风"),
+    25633: 含风("含风"),
     32857: Gain("见尘"),
     17047: Gain("分疆"),
     25258: Gain("掠关"),

schools/bing_xin_jue/__init__.py

@@ -7,5 +7,5 @@ from schools.bing_xin_jue.attribute import BingXinJue
 
 
 def prepare(self, player_id):
-    self.player_buffs[player_id][(409, 21)] = 10
-    self.player_buffs[player_id][(17969, 1)] = 1
+    self.buff_stacks[player_id][(409, 21)] = 10
+    self.buff_stacks[player_id][(17969, 1)] = 1

schools/bing_xin_jue/buffs.py

@@ -70,4 +70,4 @@ for buff_id, detail in BUFFS.items():
 
 for buff_id, buff in GENERAL_BUFFS.items():
     if buff_id not in BUFFS:
-        BUFFS[buff_id] = buff
+        BUFFS[buff_id] = buff

schools/du_jing/skills.py

@@ -11,7 +11,7 @@ class 灵蛇引(Skill):
     def record(self, critical, parser):
         super().record(critical, parser)
         pet_buffs = {(bind_buff, 1): 1 for bind_buff in self.bind_buffs}
-        parser.current_next_pet_snapshot.append(pet_buffs)
+        parser.current_next_pet_buff_stacks.append(pet_buffs)
 
 
 SKILLS: Dict[int, Skill | dict] = {

schools/fen_shan_jing/buffs.py

@@ -12,14 +12,14 @@ BUFFS: Dict[int, Buff | dict] = {
             "physical_critical_power_gain": 41
         }
     },
-    9052: {
-        "buff_name": "绝刀",
-        "gain_skills": {
-            13075: {
-                "skill_damage_addition": [205, 410, 614, 819] * 2
-            }
-        }
-    },
+    # 9052: {
+    #     "buff_name": "绝刀",
+    #     "gain_skills": {
+    #         13075: {
+    #             "skill_damage_addition": [205, 410, 614, 819] * 2
+    #         }
+    #     }
+    # },
     8244: {
         "buff_name": "血怒",
         "gain_attributes": {

schools/gu_feng_jue/buffs.py

@@ -1,7 +1,6 @@
 from base.buff import Buff
 from general.buffs import GENERAL_BUFFS
 
-
 BUFFS = {
     11378: {
         "buff_name": "朔气",
@@ -16,7 +15,7 @@ BUFFS = {
         "gain_attributes": {
             "physical_overcome_gain": 102,
             "physical_critical_strike_gain": 1000,
-            "physical_critical_power_gain": 102
+            "physical_critical_power_gain": 100
         }
     },
     24557: {
@@ -25,7 +24,7 @@ BUFFS = {
             skill_id: {
                 "skill_damage_addition": 154,
             }
-            for skill_id in [32602, 32603, 32604, 32234] + [32235, 32236, 32237, 32238, 32239, 32891, 32892]
+            for skill_id in [32602, 32603, 32604] + [32234] + [32235, 32236, 32237, 32238, 32239, 32891, 32892]
         }
     },
     24180: {
@@ -42,7 +41,7 @@ BUFFS = {
             "all_shield_ignore": 410
         }
     },
-    -32513: {
+    -24056: {
         "buff_name": "涤瑕",
         "activate": False,
         "gain_skills": {
@@ -60,4 +59,4 @@ for buff_id, detail in BUFFS.items():
 
 for buff_id, buff in GENERAL_BUFFS.items():
     if buff_id not in BUFFS:
-        BUFFS[buff_id] = buff
+        BUFFS[buff_id] = buff

schools/gu_feng_jue/skills.py

@@ -6,15 +6,18 @@ from general.skills import GENERAL_SKILLS
 
 
 class 横刀断浪流血(Skill):
+    bind_buff: int = -24222
+    stack: int
+
     def record(self, critical, parser):
-        bind_skill = parser.current_school.skills(self.bind_skill)
+        bind_skill = parser.current_school.skills[self.bind_skill]
         bind_buff = self.bind_buff
-        parser.current_ticks[self.bind_skill] = bind_skill.tick
-        parser.current_stacks[self.bind_skill] = self.max_stack
-        for level in range(self.max_stack):
-            parser.current_target_buffs.pop((bind_buff, level + 1), None)
-        parser.current_target_buffs[(bind_buff, self.max_stack)] = 1
-        parser.current_dot_snapshot[self.bind_skill] = parser.current_player_buffs.copy()
+        for level in range(self.stack):
+            parser.clear_target_buff(bind_buff, level + 1)
+        parser.refresh_target_buff(bind_buff, self.stack, 1)
+        parser.current_dot_ticks[self.bind_skill] = bind_skill.tick
+        parser.current_dot_stacks[self.bind_skill] = self.stack
+        parser.current_dot_snapshot[self.bind_skill] = parser.current_buff_stacks.copy()
 
 
 SKILLS: Dict[int, Skill | dict] = {
@@ -182,8 +185,7 @@ SKILLS: Dict[int, Skill | dict] = {
             "skill_class": 横刀断浪流血,
             "skill_name": "流血",
             "bind_skill": 24443,
-            "bind_buff": -32513,
-            "max_stack": i + 1,
+            "stack": i + 1,
         } for i, skill_id in enumerate([32874, 32873, 32872, 32871, 32870, 32869])
     },
     32234: {

schools/gu_feng_jue/talents.py

@@ -50,10 +50,10 @@ class 涣衍(Gain):
 
 class 涤瑕(Gain):
     def add_buffs(self, buffs: Dict[int, Buff]):
-        buffs[-32513].activate = True
+        buffs[-24222].activate = True
 
     def sub_buffs(self, buffs: Dict[int, Buff]):
-        buffs[-32513].activate = False
+        buffs[-24222].activate = False
 
 
 TALENT_GAINS: Dict[int, Gain] = {

schools/hua_jian_you/skills.py

@@ -21,8 +21,8 @@ class DotConsumeSkill(Skill):
         else:
             new_status_tuple = status_tuple
         skill_id, skill_level, skill_stack = skill_tuple
-        parser.current_ticks[skill_id] += 1
-        tick = parser.current_ticks.pop(skill_id)
+        parser.current_dot_ticks[skill_id] += 1
+        tick = parser.current_dot_ticks.pop(skill_id)
         parser.current_records[(skill_id, skill_level, skill_stack * tick)][new_status_tuple].append(
             parser.current_records[skill_tuple][status_tuple].pop()
         )

schools/shan_hai_xin_jue/recipes.py

@@ -7,9 +7,9 @@ from base.recipe import damage_addition_recipe, critical_strike_recipe, pve_addi
 RECIPE_GAINS: Dict[str, Dict[str, Gain]] = {
     "劲风簇": {
         "4%会心": critical_strike_recipe([35866], 400),
-        "3%伤害": damage_addition_recipe([35866], 31),
+        "3%伤害": damage_addition_recipe([35866, 36453], 31),
         "3%会心": critical_strike_recipe([35866], 300),
-        "2%伤害": damage_addition_recipe([35866], 21)
+        "2%伤害": damage_addition_recipe([35866, 36453], 21)
     },
     "饮羽簇": {
         "15%伤害": pve_addition_recipe([35987], 154),

schools/tai_xu_jian_yi/__init__.py

@@ -7,4 +7,4 @@ from schools.tai_xu_jian_yi.attribute import TaiXuJianYi
 
 
 def prepare(self, player_id):
-    self.player_buffs[player_id][(9949, 1)] = 3
+    self.buff_stacks[player_id][(9949, 1)] = 3

schools/yi_jin_jing/__init__.py

@@ -7,4 +7,4 @@ from schools.yi_jin_jing.attribute import YiJinJing
 
 
 def prepare(self, player_id):
-    self.player_buffs[player_id][(10023, 1)] = 1
+    self.buff_stacks[player_id][(10023, 1)] = 1

schools/yi_jin_jing/buffs.py

@@ -12,14 +12,17 @@ BUFFS = {
     },
     890: {
         "buff_name": "普渡",
+        "interval": 352,
         "max_stack": 2
     },
     12479: {
         "buff_name": "普渡",
+        "interval": 352,
         "max_stack": 3
     },
     19635: {
         "buff_name": "普渡",
+        "interval": 4,
         "gain_attributes": {
             "magical_vulnerable": [41, 82, 123]
         }
@@ -96,4 +99,4 @@ for buff_id, detail in BUFFS.items():
 
 for buff_id, buff in GENERAL_BUFFS.items():
     if buff_id not in BUFFS:
-        BUFFS[buff_id] = buff
+        BUFFS[buff_id] = buff

schools/yi_jin_jing/skills.py

@@ -1,25 +1,26 @@
 from typing import Dict
 
-from base.skill import Skill, HiddenBuffSkill, DotSkill, PhysicalDamage, MagicalDamage, MagicalDotDamage
+from base.skill import Skill, DotSkill, PhysicalDamage, MagicalDamage, MagicalDotDamage
 from general.skills import GENERAL_SKILLS
 
 
 class 明法判定(Skill):
     final_buff = 19635
+    bind_buff = 890
 
     def record(self, critical, parser):
-        buff_level = parser.current_target_buffs.get((self.bind_buff, 1))
-        if buff_level:
-            parser.current_target_buffs[(self.final_buff, buff_level)] = 1
+        if buff_level := parser.current_target_buff_stacks.get((self.bind_buff, 1)):
+            parser.current_target_buff_stacks[(self.final_buff, buff_level)] = 1
 
 
 class 明法移除(Skill):
     final_buff = 19635
+    bind_buff = 890
 
     def record(self, critical, parser):
-        buff_level = parser.current_target_buffs.get((self.bind_buff, 1), 0)
+        buff_level = parser.current_target_buff_stacks.get((self.bind_buff, 1), 0)
         for level in range(buff_level):
-            parser.current_target_buffs.pop((self.final_buff, level + 1), None)
+            parser.current_target_buff_stacks.pop((self.final_buff, level + 1), None)
 
 
 SKILLS: Dict[int, Skill | dict] = {
@@ -41,7 +42,6 @@ SKILLS: Dict[int, Skill | dict] = {
     26989: {
         "skill_class": 明法判定,
         "skill_name": "明法判定",
-        "bind_buff": 890,
     },
     26991: {
         "skill_class": 明法移除,
@@ -54,7 +54,7 @@ SKILLS: Dict[int, Skill | dict] = {
         "weapon_damage_cof": [1024, 2048, 1024, 1024, 2048],
     },
     17641: {
-        "skill_class": type("Mixing", (MagicalDamage, HiddenBuffSkill), {}),
+        "skill_class": MagicalDamage,
         "skill_name": "普渡四方",
         "damage_base": [23, 27, 31, 38, 43, 50, 54, 58] + [e * 0.5 for e in
                                                            [123, 133, 143, 153, 163, 173, 183, 193, 203, 213, 223, 233,
@@ -64,8 +64,7 @@ SKILLS: Dict[int, Skill | dict] = {
         "attack_power_cof": [16 * 1.1 * 1.15 * 1.1 * 1.05 * 1.2] * 9 +
                             [(16 + (i - 9) * 6) * 1.1 * 1.15 * 1.1 * 1.05 * 1.2 for i in range(10, 28)] +
                             [128 * 1.1 * 1.15 * 1.1 * 1.05 * 1.2],
-        "bind_buff": 890,
-        "duration": 352
+        "post_target_buffs": {(890, 1): 1}
     },
     236: {
         "skill_class": MagicalDamage,
@@ -92,35 +91,29 @@ SKILLS: Dict[int, Skill | dict] = {
         "bind_skill": 743
     },
     3848: {
-        "skill_class": type("Mixing", (MagicalDamage, HiddenBuffSkill), {}),
+        "skill_class": MagicalDamage,
         "skill_name": "韦陀献杵",
         "damage_base": [77, 83, 90, 94, 100, 105, 108, 111, 114, 117, 120, 123, 126, 129, 132, 135, 138, 141, 144, 147,
                         150, 153, 156, 159, 162, 165, 168, 171, 174],
         "damage_rand": [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
                         10],
-        "attack_power_cof": 144 * 1.2 * 1.15 * 1.15 * 1.35 * 0.9 * 1.15 * 1.1 * 1.05 * 1.1,
-        "bind_buff": 0,
-        "duration": 352
+        "attack_power_cof": 144 * 1.2 * 1.15 * 1.15 * 1.35 * 0.9 * 1.15 * 1.1 * 1.05 * 1.1
     },
     3849: {
-        "skill_class": type("Mixing", (MagicalDamage, HiddenBuffSkill), {}),
+        "skill_class": MagicalDamage,
         "skill_name": "韦陀献杵",
         "damage_base": [73, 87, 100, 114, 127, 141, 154, 168, 181, 195, 208, 222, 235, 249, 262, 276, 289, 303, 316,
                         330, 343, 357, 370, 384, 397, 411, 424, 438, 451],
         "damage_gain": 0.4 / 3,
         "attack_power_cof": 48 * 1.2 * 1.15 * 1.15 * 1.35 * 0.9 * 1.15 * 1.1 * 1.05 * 1.1,
-        "bind_buff": 0,
-        "duration": 352
     },
     3850: {
-        "skill_class": type("Mixing", (MagicalDamage, HiddenBuffSkill), {}),
+        "skill_class": MagicalDamage,
         "skill_name": "韦陀献杵",
         "damage_base": [73, 87, 100, 114, 127, 141, 154, 168, 181, 195, 208, 222, 235, 249, 262, 276, 289, 303, 316,
                         330, 343, 357, 370, 384, 397, 411, 424, 438, 451],
         "damage_gain": 0.4 * 2 / 3,
         "attack_power_cof": 96 * 1.2 * 1.15 * 1.15 * 1.35 * 0.9 * 1.15 * 1.1 * 1.05 * 1.1,
-        "bind_buff": 0,
-        "duration": 352
     },
     28619: {
         "skill_class": MagicalDamage,

schools/yi_jin_jing/talents.py

@@ -15,15 +15,17 @@ class 涅果(Gain):
 class 明法(Gain):
     def add_skills(self, skills: Dict[int, Skill]):
         for skill_id in (26989, 26991, 17641):
-            skills[skill_id].bind_buff = 12479
+            skills[skill_id].post_target_buffs.pop((890, 1))
+            skills[skill_id].post_target_buffs = {(12479, 1): 1}
         for skill_id in (3848, 3849, 3850):
-            skills[skill_id].bind_buff = 12479
+            skills[skill_id].post_target_buffs[(12479, 1)] = 1
 
     def sub_skills(self, skills: Dict[int, Skill]):
         for skill_id in (26989, 26991, 17641):
-            skills[skill_id].bind_buff = 890
+            skills[skill_id].post_target_buffs.pop((12479, 1))
+            skills[skill_id].post_target_buffs[(890, 1)] = 1
         for skill_id in (3848, 3849, 3850):
-            skills[skill_id].bind_buff = 0
+            skills[skill_id].post_target_buffs.pop((12479, 1))
 
 
 class 华香(Gain):

schools/yin_long_jue/buffs.py

@@ -79,4 +79,4 @@ for buff_id, detail in BUFFS.items():
 
 for buff_id, buff in GENERAL_BUFFS.items():
     if buff_id not in BUFFS:
-        BUFFS[buff_id] = buff
+        BUFFS[buff_id] = buff

schools/zi_xia_gong/__init__.py

@@ -7,4 +7,4 @@ from schools.zi_xia_gong.attribute import ZiXiaGong
 
 
 def prepare(self, player_id):
-    self.player_buffs[player_id][(17918, 1)] = 1
+    self.buff_stacks[player_id][(17918, 1)] = 1

utils/damage.py

@@ -8,6 +8,7 @@ def defense_result(shield_base, shield_gain, shield_ignore, shield_constant):
     shield = shield_base
     shield += int(shield * shield_gain / BINARY_SCALE)
     shield -= int(shield * shield_ignore / BINARY_SCALE)
+    shield = max(shield, 0)
     return int(shield * BINARY_SCALE / (shield + shield_constant))
 
 

utils/parser.py

@@ -35,7 +35,7 @@ LABEL_MAPPING = {
 EMBED_MAPPING: Dict[tuple, int] = {(5, 24449 - i): 8 - i for i in range(8)}
 
 
-class Parser:
+class BaseParser:
     current_player: PLAYER_ID_TYPE
     current_caster: CASTER_ID_TYPE
     current_target: TARGET_ID_TYPE
@@ -46,24 +46,24 @@ class Parser:
 
     id2name: Dict[PLAYER_ID_TYPE | TARGET_ID_TYPE, PLAYER_NAME_TYPE]
     name2id: Dict[PLAYER_NAME_TYPE, PLAYER_ID_TYPE | TARGET_ID_TYPE]
-    employers: Dict[PET_ID_TYPE, PLAYER_ID_TYPE]
+    pet2employer: Dict[PET_ID_TYPE, PLAYER_ID_TYPE]
 
     records: Dict[PLAYER_ID_TYPE, Dict[TARGET_ID_TYPE, RECORD_TYPE]]
 
     frame_shift_buffs: Dict[FRAME_TYPE, Dict[PLAYER_ID_TYPE, Dict[BUFF_TYPE, BUFF_STACK_TYPE]]]
     second_shift_buffs: Dict[SECOND_TYPE, Dict[PLAYER_ID_TYPE, Dict[BUFF_TYPE, BUFF_STACK_TYPE]]]
-    hidden_buffs: Dict[TARGET_ID_TYPE, Dict[PLAYER_ID_TYPE, Dict[BUFF_TYPE, FRAME_TYPE]]]
 
-    player_buffs: Dict[PLAYER_ID_TYPE, Dict[BUFF_TYPE, BUFF_STACK_TYPE]]
-    target_buffs: Dict[TARGET_ID_TYPE, Dict[PLAYER_ID_TYPE, Dict[BUFF_TYPE, BUFF_STACK_TYPE]]]
+    buff_stacks: Dict[CASTER_ID_TYPE, Dict[BUFF_TYPE, BUFF_STACK_TYPE]]
+    buff_intervals: Dict[CASTER_ID_TYPE, Dict[BUFF_TYPE, FRAME_TYPE]]
+    target_buff_stacks: Dict[TARGET_ID_TYPE, Dict[PLAYER_ID_TYPE, Dict[BUFF_TYPE, BUFF_STACK_TYPE]]]
+    target_buff_intervals: Dict[TARGET_ID_TYPE, Dict[PLAYER_ID_TYPE, Dict[BUFF_TYPE, FRAME_TYPE]]]
 
-    stacks: Dict[TARGET_ID_TYPE, Dict[PLAYER_ID_TYPE, Dict[SKILL_ID_TYPE, int]]]
-    ticks: Dict[TARGET_ID_TYPE, Dict[PLAYER_ID_TYPE, Dict[SKILL_ID_TYPE, int]]]
-
-    pet_snapshot: Dict[PET_ID_TYPE, Dict[BUFF_TYPE, BUFF_STACK_TYPE]]
-    next_pet_snapshot: Dict[PLAYER_ID_TYPE, List[Dict[BUFF_TYPE, BUFF_STACK_TYPE]]]
+    dot_stacks: Dict[TARGET_ID_TYPE, Dict[PLAYER_ID_TYPE, Dict[SKILL_ID_TYPE, int]]]
+    dot_ticks: Dict[TARGET_ID_TYPE, Dict[PLAYER_ID_TYPE, Dict[SKILL_ID_TYPE, int]]]
     dot_snapshot: Dict[TARGET_ID_TYPE, Dict[PLAYER_ID_TYPE, Dict[SKILL_ID_TYPE, Dict[BUFF_TYPE, BUFF_STACK_TYPE]]]]
 
+    next_pet_buff_stacks: Dict[PLAYER_ID_TYPE, List[Dict[BUFF_TYPE, BUFF_STACK_TYPE]]]
+
     last_dot: Dict[TARGET_ID_TYPE, Dict[PLAYER_ID_TYPE, Dict[SKILL_ID_TYPE, Tuple[SKILL_TYPE, Tuple[tuple, tuple]]]]]
     next_dot: Dict[TARGET_ID_TYPE, Dict[PLAYER_ID_TYPE, Dict[SKILL_ID_TYPE, int]]]
 
@@ -89,39 +89,43 @@ class Parser:
         return self.records[self.current_player][self.current_target]
 
     @property
-    def current_hidden_buffs(self):
-        return self.hidden_buffs[self.current_target][self.current_player]
+    def current_buff_stacks(self):
+        return self.buff_stacks[self.current_player]
 
     @property
-    def current_player_buffs(self):
-        return self.player_buffs[self.current_player]
+    def current_buff_intervals(self):
+        return self.buff_intervals[self.current_player]
 
     @property
-    def current_target_buffs(self):
-        return self.target_buffs[self.current_target][self.current_player]
+    def current_target_buff_stacks(self):
+        return self.target_buff_stacks[self.current_target][self.current_player]
+
+    @property
+    def current_target_buff_intervals(self):
+        return self.target_buff_intervals[self.current_target][self.current_player]
 
     @property
     def current_snapshot(self):
-        if self.current_caster in self.pet_snapshot:
-            return self.pet_snapshot[self.current_caster]
+        if self.current_caster in self.pet2employer:
+            return self.buff_stacks[self.current_caster]
         else:
             return self.dot_snapshot[self.current_target][self.current_player].get(self.current_skill, {})
 
     @property
-    def current_next_pet_snapshot(self):
-        return self.next_pet_snapshot[self.current_player]
+    def current_next_pet_buff_stacks(self):
+        return self.next_pet_buff_stacks[self.current_player]
 
     @property
     def current_dot_snapshot(self):
         return self.dot_snapshot[self.current_target][self.current_player]
 
     @property
-    def current_stacks(self):
-        return self.stacks[self.current_target][self.current_player]
+    def current_dot_stacks(self):
+        return self.dot_stacks[self.current_target][self.current_player]
 
     @property
-    def current_ticks(self):
-        return self.ticks[self.current_target][self.current_player]
+    def current_dot_ticks(self):
+        return self.dot_ticks[self.current_target][self.current_player]
 
     @property
     def current_last_dot(self):
@@ -131,32 +135,28 @@ class Parser:
     def current_next_dot(self):
         return self.next_dot[self.current_target][self.current_player]
 
-    @property
-    def duration(self):
-        return round((self.end_frame - self.start_frame) / FRAME_PER_SECOND, 3)
-
     def reset(self):
         self.current_frame = 0
         self.current_second = 0
 
         self.id2name = {}
         self.name2id = {}
-        self.employers = {}
+        self.pet2employer = {}
 
         self.records = defaultdict(lambda: defaultdict(lambda: defaultdict(lambda: defaultdict(list))))
 
-        self.hidden_buffs = defaultdict(lambda: defaultdict(dict))
         self.frame_shift_buffs = defaultdict(lambda: defaultdict(dict))
         self.second_shift_buffs = defaultdict(lambda: defaultdict(dict))
 
-        self.player_buffs = defaultdict(dict)
-        self.target_buffs = defaultdict(lambda: defaultdict(dict))
+        self.buff_stacks = defaultdict(dict)
+        self.buff_intervals = defaultdict(dict)
+        self.target_buff_stacks = defaultdict(lambda: defaultdict(dict))
+        self.target_buff_intervals = defaultdict(lambda: defaultdict(dict))
 
-        self.stacks = defaultdict(lambda: defaultdict(lambda: defaultdict(lambda: 1)))
-        self.ticks = defaultdict(lambda: defaultdict(lambda: defaultdict(lambda: 0)))
+        self.dot_stacks = defaultdict(lambda: defaultdict(lambda: defaultdict(lambda: 1)))
+        self.dot_ticks = defaultdict(lambda: defaultdict(lambda: defaultdict(lambda: 0)))
 
-        self.pet_snapshot = dict()
-        self.next_pet_snapshot = defaultdict(list)
+        self.next_pet_buff_stacks = defaultdict(list)
         self.dot_snapshot = defaultdict(lambda: defaultdict(dict))
         self.last_dot = defaultdict(lambda: defaultdict(dict))
         self.next_dot = defaultdict(lambda: defaultdict(dict))
@@ -169,6 +169,46 @@ class Parser:
         self.players = {}
         self.targets = defaultdict(list)
 
+    def refresh_buff(self, buff_id, buff_level, buff_stack=1):
+        buff = self.current_school.buffs[buff_id]
+        buff_tuple = (buff_id, buff_level)
+        stack = max(min(self.current_buff_stacks.get(buff_tuple, 0) + buff_stack, buff.max_stack), 0)
+        if stack:
+            self.current_buff_stacks[buff_tuple] = stack
+            if buff.interval > 0:
+                self.current_buff_intervals[buff_tuple] = self.current_frame + buff.interval + 1
+        else:
+            self.current_buff_stacks.pop(buff_tuple, None)
+            self.current_buff_intervals.pop(buff_tuple, None)
+
+    def refresh_target_buff(self, buff_id, buff_level, buff_stack=1):
+        buff = self.current_school.buffs[buff_id]
+        buff_tuple = (buff_id, buff_level)
+        stack = max(min(self.current_target_buff_stacks.get(buff_tuple, 0) + buff_stack, buff.max_stack), 0)
+        if stack:
+            self.current_target_buff_stacks[buff_tuple] = stack
+            if buff.interval > 0:
+                self.current_target_buff_intervals[buff_tuple] = self.current_frame + buff.interval + 1
+        else:
+            self.current_target_buff_stacks.pop(buff_tuple, None)
+            self.current_target_buff_intervals.pop(buff_tuple, None)
+
+    def clear_buff(self, buff_id, buff_level):
+        buff_tuple = (buff_id, buff_level)
+        self.current_buff_stacks.pop(buff_tuple, None)
+        self.current_buff_intervals.pop(buff_tuple, None)
+
+    def clear_target_buff(self, buff_id, buff_level):
+        buff_tuple = (buff_id, buff_level)
+        self.current_target_buff_stacks.pop(buff_tuple, None)
+        self.current_target_buff_intervals.pop(buff_tuple, None)
+
+
+class Parser(BaseParser):
+    @property
+    def duration(self):
+        return round((self.end_frame - self.start_frame) / FRAME_PER_SECOND, 3)
+
     @staticmethod
     def parse_equipments(detail):
         select_equipments = {}
@@ -207,26 +247,25 @@ class Parser:
 
     def parse_npc(self, row):
         detail = row.strip("{}").split(",")
-        npc_id, player_id = int(detail[0]), int(detail[3])
+        npc_id, employer_id = int(detail[0]), int(detail[3])
         if npc_id in self.id2name:
             return
 
         npc_name = detail[1]
         self.id2name[npc_id] = npc_name
         self.name2id[npc_name] = npc_id
-        if player_id in self.players:
-            self.employers[npc_id] = player_id
+        if employer_id in self.players:
+            self.pet2employer[npc_id] = employer_id
 
     def parse_pet(self, row):
         detail = row.strip().strip("{}")
         pet_id = int(detail[0])
-        if pet_id in self.employers:
-            player_id = self.employers[pet_id]
-            if self.next_pet_snapshot[player_id]:
-                pet_buffs = self.next_pet_snapshot[player_id].pop()
+        if player_id := self.pet2employer.get(pet_id):
+            if self.next_pet_buff_stacks[player_id]:
+                pet_buff_stacks = self.next_pet_buff_stacks[player_id].pop()
             else:
-                pet_buffs = {}
-            self.pet_snapshot[pet_id] = {**self.player_buffs[player_id].copy(), **pet_buffs}
+                pet_buff_stacks = {}
+            self.buff_stacks[pet_id] = {**self.buff_stacks[player_id].copy(), **pet_buff_stacks}
 
     def parse_shift_buff(self, row):
         detail = row.strip("{}").split(",")
@@ -250,9 +289,9 @@ class Parser:
             for player_id, shift_buffs in self.frame_shift_buffs.pop(frame).items():
                 for buff, buff_stack in shift_buffs.items():
                     if buff_stack:
-                        self.player_buffs[player_id][buff] = buff_stack
+                        self.buff_stacks[player_id][buff] = buff_stack
                     else:
-                        self.player_buffs[player_id].pop(buff, None)
+                        self.buff_stacks[player_id].pop(buff, None)
 
     def parse_second_shift_status(self):
         for second in list(self.second_shift_buffs):
@@ -261,26 +300,44 @@ class Parser:
             for player_id, shift_buffs in self.second_shift_buffs.pop(second).items():
                 for buff, buff_stack in shift_buffs.items():
                     if buff_stack:
-                        self.player_buffs[player_id][buff] = buff_stack
+                        self.buff_stacks[player_id][buff] = buff_stack
                     else:
-                        self.player_buffs[player_id].pop(buff, None)
-
-    def parse_hidden_buffs(self):
-        for target_id in self.hidden_buffs:
-            for player_id, hidden_buffs in self.hidden_buffs[target_id].items():
-                for buff, end_frame in hidden_buffs.items():
+                        self.buff_stacks[player_id].pop(buff, None)
+
+    def parse_buff_intervals(self):
+        for caster_id, buffs in self.buff_intervals.items():
+            pop_buffs = []
+            for buff, end_frame in buffs.items():
+                if end_frame < self.current_frame:
+                    self.buff_stacks[caster_id].pop(buff, None)
+                    pop_buffs.append(buff)
+            for pop_buff in pop_buffs:
+                buffs.pop(pop_buff)
+        for target_id in self.target_buff_intervals:
+            for caster_id, buffs in self.target_buff_intervals[target_id].items():
+                pop_buffs = []
+                for buff, end_frame in buffs.items():
                     if end_frame < self.current_frame:
-                        self.target_buffs[target_id][player_id].pop(buff, None)
+                        self.target_buff_stacks[target_id][caster_id].pop(buff, None)
+                        pop_buffs.append(buff)
+                for pop_buff in pop_buffs:
+                    buffs.pop(pop_buff)
 
     def parse_buff(self, row):
         detail = row.strip("{}").split(",")
         caster_id = int(detail[0])
-        if caster_id in self.employers:
-            player_id = self.employers[caster_id]
-            buffs = self.pet_snapshot.get(caster_id, {})
+        if caster_id in self.pet2employer:
+            player_id = self.pet2employer[caster_id]
+            if caster_id in self.buff_stacks:
+                buff_stacks = self.buff_stacks[caster_id]
+            elif self.next_pet_buff_stacks[player_id]:
+                buff_stacks = self.next_pet_buff_stacks[player_id][0]
+            else:
+                buff_stacks = {}
+                self.next_pet_buff_stacks[player_id].append(buff_stacks)
         else:
             player_id = caster_id
-            buffs = self.player_buffs[player_id]
+            buff_stacks = self.buff_stacks[player_id]
 
         if player_id not in self.players:
             return
@@ -294,15 +351,15 @@ class Parser:
             return
 
         if buff_stack:
-            buffs[(buff_id, buff_level)] = buff_stack
+            buff_stacks[(buff_id, buff_level)] = buff_stack
         else:
-            buffs.pop((buff_id, buff_level), None)
+            buff_stacks.pop((buff_id, buff_level), None)
 
     def parse_skill(self, row):
         detail = row.strip("{}").split(",")
         caster_id, target_id = int(detail[0]), int(detail[1])
-        if caster_id in self.employers:
-            player_id = self.employers[caster_id]
+        if caster_id in self.pet2employer:
+            player_id = self.pet2employer[caster_id]
         else:
             player_id = caster_id
 
@@ -324,11 +381,11 @@ class Parser:
         self.current_skill = skill_id
         skill = self.players[player_id].skills[skill_id]
         skill.skill_level = skill_level
-        skill.record(critical, self)
+        skill.parse(critical, self)
 
     def status(self, skill_id):
         current_status = []
-        for (buff_id, buff_level), buff_stack in self.current_player_buffs.items():
+        for (buff_id, buff_level), buff_stack in self.current_buff_stacks.items():
             buff = self.current_school.buffs[buff_id]
             if buff.gain_attributes:
                 current_status.append((buff_id, buff_level, buff_stack))
@@ -345,7 +402,7 @@ class Parser:
                 snapshot_status.append((buff_id, buff_level, buff_stack))
 
         target_status = []
-        for (buff_id, buff_level), buff_stack in self.current_target_buffs.items():
+        for (buff_id, buff_level), buff_stack in self.current_target_buff_stacks.items():
             buff = self.current_school.buffs[buff_id]
             if buff.gain_attributes:
                 target_status.append((buff_id, buff_level, buff_stack))
@@ -382,7 +439,7 @@ class Parser:
             if (current_frame := int(row[1])) != self.current_frame:
                 self.current_frame = current_frame
                 self.parse_frame_shift_status()
-                self.parse_hidden_buffs()
+                self.parse_buff_intervals()
             # if (current_second := int(row[3])) != self.current_second:
             #     self.current_second = current_second
             #     self.parse_frame_shift_status()