Spaces:

AngoHF
/

Formulator

Runtime error

App Files Files Community

ango commited on May 8, 2024

Commit

17a347d

1 Parent(s): c255694

5.8 commit

Browse files

This view is limited to 50 files because it contains too many changes. See raw diff

Files changed (50) hide show

base/buff.py +37 -30
base/skill.py +22 -27
general/buffs/__init__.py +6 -0
general/{buffs.py → buffs/equipment.py} +0 -0
general/buffs/team.py +105 -0
general/gains/team.py +22 -6
general/skills/__init__.py +6 -0
general/skills/equipment.py +92 -0
general/skills/team.py +28 -0
get_assets.py +1 -3
parse_new_school.py +1 -1
qt/assets/equipments/belt +0 -0
qt/assets/equipments/bottoms +0 -0
qt/assets/equipments/hat +0 -0
qt/assets/equipments/jacket +0 -0
qt/assets/equipments/necklace +1 -1
qt/assets/equipments/pendant +0 -0
qt/assets/equipments/primary_weapon +0 -0
qt/assets/equipments/ring +1 -1
qt/assets/equipments/shoes +0 -0
qt/assets/equipments/tertiary_weapon +0 -0
qt/assets/equipments/wrist +0 -0
qt/components/bonuses.py +7 -1
qt/components/dashboard.py +8 -2
qt/scripts/bonuses.py +9 -2
qt/scripts/dashboard.py +18 -4
qt/scripts/top.py +5 -2
requirements.txt +1 -3
schools/__init__.py +9 -1
schools/bing_xin_jue/__init__.py +2 -2
schools/fen_shan_jing/__init__.py +10 -0
schools/fen_shan_jing/attribute.py +21 -0
schools/fen_shan_jing/buffs.py +36 -0
schools/fen_shan_jing/gains.py +17 -0
schools/fen_shan_jing/recipes.py +26 -0
schools/fen_shan_jing/skills.py +159 -0
schools/fen_shan_jing/talents.py +95 -0
schools/gu_feng_jue/buffs.py +1 -6
schools/gu_feng_jue/skills.py +5 -3
schools/hua_jian_you/buffs.py +6 -4
schools/hua_jian_you/recipes.py +3 -6
schools/hua_jian_you/skills.py +20 -16
schools/mo_wen/buffs.py +1 -1
schools/tai_xu_jian_yi/__init__.py +1 -1
schools/yi_jin_jing/__init__.py +1 -1
schools/yi_jin_jing/buffs.py +4 -4
schools/yi_jin_jing/recipes.py +3 -3
schools/yi_jin_jing/skills.py +16 -15
utils/analyzer.py +25 -16
utils/io.py +25 -0

base/buff.py CHANGED Viewed

@@ -17,7 +17,6 @@ class Buff:
     frame_shift: int = 0
     activate: bool = True
-    stackable: bool = True
     max_stack: int = 1
     gain_skills: Dict[int, ATTR_DICT] = None
@@ -52,76 +51,84 @@ class Buff:
     def display_name(self):
         return f"{self.buff_name}#{self.buff_id}-{self.buff_level}-{self.buff_stack}"
-    def value(self, values):
         if isinstance(values, list):
             value = values[self.buff_level - 1]
         else:
             value = values
-        if self.stackable:
             value = value * self.buff_stack
-        if isinstance(value, float):
-            value = 1 + value
         return value
     def add_all(self, attribute: Attribute, skill: Skill):
         for attr, values in self.gain_attributes.items():
-            setattr(attribute, attr, getattr(attribute, attr) + self.value(values))
         for attr, values in self.gain_skills.get(skill.skill_id, {}).items():
-            value = self.value(values)
             if isinstance(value, float):
-                setattr(skill, attr, getattr(skill, attr) * self.value(values))
             else:
-                setattr(skill, attr, getattr(skill, attr) + self.value(values))
     def add_dot(self, attribute: Attribute, skill: Skill, snapshot: bool = True):
         for attr, values in self.gain_attributes.items():
             if snapshot and any(snapshot_attr in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
-                setattr(attribute, attr, getattr(attribute, attr) + self.value(values))
             elif not snapshot and all(snapshot_attr not in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
-                setattr(attribute, attr, getattr(attribute, attr) + self.value(values))
         for attr, values in self.gain_skills.get(skill.skill_id, {}).items():
             if snapshot and any(snapshot_attr in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
-                value = self.value(values)
                 if isinstance(value, float):
-                    setattr(skill, attr, getattr(skill, attr) * self.value(values))
                 else:
-                    setattr(skill, attr, getattr(skill, attr) + self.value(values))
             elif not snapshot and all(snapshot_attr not in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
-                value = self.value(values)
                 if isinstance(value, float):
-                    setattr(skill, attr, getattr(skill, attr) * self.value(values))
                 else:
-                    setattr(skill, attr, getattr(skill, attr) + self.value(values))
     def sub_all(self, attribute: Attribute, skill: Skill):
         for attr, values in self.gain_attributes.items():
-            setattr(attribute, attr, getattr(attribute, attr) - self.value(values))
         for attr, values in self.gain_skills.get(skill.skill_id, {}).items():
-            value = self.value(values)
             if isinstance(value, float):
-                setattr(skill, attr, getattr(skill, attr) / self.value(values))
             else:
-                setattr(skill, attr, getattr(skill, attr) - self.value(values))
     def sub_dot(self, attribute: Attribute, skill: Skill, snapshot: bool = True):
         for attr, values in self.gain_attributes.items():
             if snapshot and any(snapshot_attr in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
-                setattr(attribute, attr, getattr(attribute, attr) - self.value(values))
             elif not snapshot and all(snapshot_attr not in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
-                setattr(attribute, attr, getattr(attribute, attr) - self.value(values))
         for attr, values in self.gain_skills.get(skill.skill_id, {}).items():
             if snapshot and any(snapshot_attr in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
-                value = self.value(values)
                 if isinstance(value, float):
-                    setattr(skill, attr, getattr(skill, attr) / self.value(values))
                 else:
-                    setattr(skill, attr, getattr(skill, attr) - self.value(values))
             elif not snapshot and all(snapshot_attr not in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
-                value = self.value(values)
                 if isinstance(value, float):
-                    setattr(skill, attr, getattr(skill, attr) / self.value(values))
                 else:
-                    setattr(skill, attr, getattr(skill, attr) - self.value(values))

     frame_shift: int = 0
     activate: bool = True
     max_stack: int = 1
     gain_skills: Dict[int, ATTR_DICT] = None
     def display_name(self):
         return f"{self.buff_name}#{self.buff_id}-{self.buff_level}-{self.buff_stack}"
+    def value(self, values, stackable):
         if isinstance(values, list):
             value = values[self.buff_level - 1]
         else:
             value = values
+        if stackable:
             value = value * self.buff_stack
         return value
+    def attribute_value(self, values):
+        return self.value(values, True)
+    def skill_value(self, values):
+        return self.value(values, False)
     def add_all(self, attribute: Attribute, skill: Skill):
         for attr, values in self.gain_attributes.items():
+            setattr(attribute, attr, getattr(attribute, attr) + self.attribute_value(values))
         for attr, values in self.gain_skills.get(skill.skill_id, {}).items():
+            value = self.skill_value(values)
             if isinstance(value, float):
+                setattr(skill, attr, getattr(skill, attr) * value)
             else:
+                setattr(skill, attr, getattr(skill, attr) + value)
     def add_dot(self, attribute: Attribute, skill: Skill, snapshot: bool = True):
+        return_tag = False
         for attr, values in self.gain_attributes.items():
             if snapshot and any(snapshot_attr in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
+                return_tag = True
+                setattr(attribute, attr, getattr(attribute, attr) + self.attribute_value(values))
             elif not snapshot and all(snapshot_attr not in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
+                return_tag = True
+                setattr(attribute, attr, getattr(attribute, attr) + self.attribute_value(values))
         for attr, values in self.gain_skills.get(skill.skill_id, {}).items():
+            value = self.skill_value(values)
             if snapshot and any(snapshot_attr in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
+                return_tag = True
                 if isinstance(value, float):
+                    setattr(skill, attr, getattr(skill, attr) * value)
                 else:
+                    setattr(skill, attr, getattr(skill, attr) + value)
             elif not snapshot and all(snapshot_attr not in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
+                return_tag = True
                 if isinstance(value, float):
+                    setattr(skill, attr, getattr(skill, attr) * value)
                 else:
+                    setattr(skill, attr, getattr(skill, attr) + value)
+        return return_tag
     def sub_all(self, attribute: Attribute, skill: Skill):
         for attr, values in self.gain_attributes.items():
+            setattr(attribute, attr, getattr(attribute, attr) - self.attribute_value(values))
         for attr, values in self.gain_skills.get(skill.skill_id, {}).items():
+            value = self.skill_value(values)
             if isinstance(value, float):
+                setattr(skill, attr, getattr(skill, attr) / value)
             else:
+                setattr(skill, attr, getattr(skill, attr) - value)
     def sub_dot(self, attribute: Attribute, skill: Skill, snapshot: bool = True):
         for attr, values in self.gain_attributes.items():
             if snapshot and any(snapshot_attr in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
+                setattr(attribute, attr, getattr(attribute, attr) - self.attribute_value(values))
             elif not snapshot and all(snapshot_attr not in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
+                setattr(attribute, attr, getattr(attribute, attr) - self.attribute_value(values))
         for attr, values in self.gain_skills.get(skill.skill_id, {}).items():
+            value = self.skill_value(values)
             if snapshot and any(snapshot_attr in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
                 if isinstance(value, float):
+                    setattr(skill, attr, getattr(skill, attr) / value)
                 else:
+                    setattr(skill, attr, getattr(skill, attr) - value)
             elif not snapshot and all(snapshot_attr not in attr for snapshot_attr in self.SNAPSHOT_ATTRS):
                 if isinstance(value, float):
+                    setattr(skill, attr, getattr(skill, attr) / value)
                 else:
+                    setattr(skill, attr, getattr(skill, attr) - value)

base/skill.py CHANGED Viewed

@@ -171,7 +171,7 @@ class Skill:
         else:
             self._skill_shield_gain = [skill_shield_gain]
-    def record(self, skill_level, critical, parser):
         pass
     def __call__(self, attribute: Attribute):
@@ -179,27 +179,27 @@ class Skill:
 class BuffSkill(Skill):
-    def record(self, skill_level, critical, parser):
-        super().record(skill_level, critical, parser)
         if self.bind_buff not in parser.current_school.buffs:
             return
-        buff = parser.current_school.buffs[self.bind_buff]
-        status_buffer = (self.bind_buff, 1)
-        parser.current_hidden_buffs.pop(status_buffer, None)
-        parser.current_status[status_buffer] = min(parser.current_status[status_buffer] + 1, buff.max_stack)
         end_frame = parser.current_frame + self.duration
-        parser.current_hidden_buffs[status_buffer] = end_frame
 class DotSkill(Skill):
-    def record(self, skill_level, critical, parser):
-        super().record(skill_level, critical, parser)
         bind_skill = self.bind_skill
         if not parser.current_ticks[bind_skill]:
             parser.current_stacks[bind_skill] = 0
         parser.current_ticks[bind_skill] = self.tick
         parser.current_stacks[bind_skill] = min(parser.current_stacks[bind_skill] + 1, self.max_stack)
-        parser.current_snapshot[bind_skill] = parser.current_status.copy()
 class DotConsumeSkill(Skill):
@@ -219,8 +219,8 @@ class DotConsumeSkill(Skill):
         )
         parser.current_ticks[skill_id] -= tick
-    def record(self, skill_level, critical, parser):
-        super().record(skill_level, critical, parser)
         if self.last_dot:
             self.consume_last(parser)
         else:
@@ -228,11 +228,11 @@ class DotConsumeSkill(Skill):
 class Damage(Skill):
-    def record(self, skill_level, critical, parser):
-        super().record(skill_level, critical, parser)
         skill_stack = parser.current_stacks[self.skill_id]
-        skill_tuple = (self.skill_id, skill_level, skill_stack)
-        status_tuple = parser.available_status(self.skill_id)
         parser.current_records[skill_tuple][status_tuple].append(
             (parser.current_frame - parser.start_frame, critical)
         )
@@ -240,21 +240,16 @@ class Damage(Skill):
 class PetDamage(Damage):
-    def record(self, skill_level, critical, parser):
-        skill_tuple, status_tuple = super().record(skill_level, critical, parser)
-        pet_status_tuple = parser.available_status(self.skill_id, parser.current_caster)
-        parser.current_records[skill_tuple][pet_status_tuple].append(
-            parser.current_records[skill_tuple][status_tuple].pop()
-        )
 class DotDamage(Damage):
-    def record(self, skill_level, critical, parser):
-        skill_tuple, status_tuple = super().record(skill_level, critical, parser)
         if tick := parser.current_next_dot.pop(self.skill_id, None):
             _, _, skill_stack = skill_tuple
-            parser.current_records[(self.skill_id, skill_level, skill_stack * tick)][status_tuple].append(
                 parser.current_records[skill_tuple][status_tuple].pop()
             )
             parser.current_ticks[self.skill_id] -= tick
@@ -314,7 +309,7 @@ class MagicalSkill(Skill):
             self.attack_power_cof, attribute.magical_attack_power,
             self.weapon_damage_cof, attribute.weapon_damage,
             self.surplus_cof, attribute.surplus
-        ) * self.skill_stack * self.global_damage_factor * attribute.global_damage_factor * attribute.global_damage_factor
         damage = damage_addition_result(damage, attribute.magical_damage_addition + self.skill_damage_addition)
         damage = overcome_result(damage, attribute.magical_overcome,

         else:
             self._skill_shield_gain = [skill_shield_gain]
+    def record(self, critical, parser):
         pass
     def __call__(self, attribute: Attribute):
 class BuffSkill(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 = self.bind_skill
         if not parser.current_ticks[bind_skill]:
             parser.current_stacks[bind_skill] = 0
         parser.current_ticks[bind_skill] = self.tick
         parser.current_stacks[bind_skill] = min(parser.current_stacks[bind_skill] + 1, self.max_stack)
+        parser.current_dot_snapshot[bind_skill] = parser.current_player_buffs.copy()
 class DotConsumeSkill(Skill):
         )
         parser.current_ticks[skill_id] -= tick
+    def record(self, critical, parser):
+        super().record(critical, parser)
         if self.last_dot:
             self.consume_last(parser)
         else:
 class Damage(Skill):
+    def record(self, critical, parser):
+        super().record(critical, parser)
         skill_stack = parser.current_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(
             (parser.current_frame - parser.start_frame, critical)
         )
 class PetDamage(Damage):
+    pass
 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
             self.attack_power_cof, attribute.magical_attack_power,
             self.weapon_damage_cof, attribute.weapon_damage,
             self.surplus_cof, attribute.surplus
+        ) * self.skill_stack * self.global_damage_factor * attribute.global_damage_factor
         damage = damage_addition_result(damage, attribute.magical_damage_addition + self.skill_damage_addition)
         damage = overcome_result(damage, attribute.magical_overcome,

general/buffs/__init__.py ADDED Viewed

	@@ -0,0 +1,6 @@

+from general.buffs import equipment, team
+GENERAL_BUFFS = {
+    **equipment.GENERAL_BUFFS,
+    **team.GENERAL_BUFFS
+}

general/{buffs.py → buffs/equipment.py} RENAMED Viewed

File without changes

general/buffs/team.py ADDED Viewed

	@@ -0,0 +1,105 @@

+from base.buff import Buff
+GENERAL_BUFFS = {
+    20938: {
+        "buff_name": "左旋右转",
+        "gain_attributes": {
+            "surplus_base": 54,
+        }
+    },
+    23573: {
+        "buff_name": "泠风解怀",
+        "gain_attributes": {
+            "all_damage_addition": 154
+        }
+    },
+    23107: {
+        "buff_name": "号令三军",
+        "gain_attributes": {
+            "strain_base": 500
+        }
+    },
+    6363: {
+        "buff_name": "激雷",
+        "gain_attributes": {
+            "physical_attack_power_gain": 205, "physical_overcome_gain": 205
+        }
+    },
+    10208: {
+        "buff_name": "弘法",
+        "gain_attributes": {
+            "strain_base": 500
+        }
+    },
+    24350: {
+        "buff_name": "皎素",
+        "gain_attributes": {
+            "all_critical_power_gain": 51
+        }
+    },
+    24742: {
+        "buff_name": "仙王蛊鼎",
+        "gain_attributes": {
+            "all_damage_addition": 123
+        }
+    },
+    4246: {
+        "buff_name": "朝圣",
+        "gain_attributes": {
+            "strain_base": 500
+        }
+    },
+    9744: {
+        "buff_name": "朝圣",
+        "gain_attributes": {
+            "strain_base": 875
+        }
+    },
+    8504: {
+        "buff_name": "振奋",
+        "gain_attributes": {
+            "physical_overcome_base": 60,
+            "magical_overcome_base": 60
+        }
+    },
+    10031: {
+        "buff_name": "寒啸千军",
+        "gain_attributes": {
+            "physical_overcome_gain": 204,
+            "magical_overcome_gain": 204
+        }
+    },
+    23543: {
+        "buff_name": "庄周梦",
+        "gain_attributes": {
+            "strain_base": 50
+        }
+    },
+    16911: {
+        "buff_name": "弄梅",
+        "gain_attributes": {
+            "physical_overcome_base": 700,
+            "magical_overcome_base": 700,
+            "all_shield_ignore": 205
+        }
+    },
+    11456: {
+        "buff_name": "疏狂",
+        "gain_attributes": {
+            "physical_attack_power_gain": 307,
+            "magical_attack_power_gain": 307
+        }
+    },
+    20877: {
+        "buff_name": "配伍",
+        "gain_attributes": {
+            "all_major_gain": 10
+        }
+    }
+}
+for buff_id, detail in GENERAL_BUFFS.items():
+    GENERAL_BUFFS[buff_id] = Buff(buff_id)
+    GENERAL_BUFFS[buff_id].activate = False
+    for attr, value in detail.items():
+        setattr(GENERAL_BUFFS[buff_id], attr, value)

general/gains/team.py CHANGED Viewed

@@ -1,5 +1,21 @@
 from base.attribute import Attribute
 from base.gain import Gain
 class TeamGain(Gain):
@@ -55,7 +71,7 @@ class 乘龙箭(TeamGain):
 class 号令三军(TeamGain):
-    gain_attributes = {"strain_base": (470 + 470 / 2) / 2}
 class 激雷(TeamGain):
@@ -70,7 +86,7 @@ class 立地成佛(TeamGain):
 class 舍身弘法(TeamGain):
-    gain_attributes = {"strain_base": 470}
 """ 万花 """
@@ -117,8 +133,8 @@ class 戒火(TeamGain):
 class 朝圣言(TeamGain):
-    gain_attributes = {"strain_base": 470}
-    variety_values = {"圣浴明心": 820 - 470}
 """ 丐帮 """
@@ -186,10 +202,10 @@ TEAM_GAIN_LIMIT = {
         "stack": 24
     },
     "振奋": {
-        "stack": 100
     },
     "庄周梦": {
-        "stack": 150
     }
 }
 TEAM_GAINS = {

+from typing import Dict
 from base.attribute import Attribute
+from base.buff import Buff
 from base.gain import Gain
+from general.buffs.team import GENERAL_BUFFS
+class RealTeamGain(Gain):
+    buff_ids = list(GENERAL_BUFFS)
+    def add_buffs(self, buffs: Dict[int, Buff]):
+        for buff_id in self.buff_ids:
+            buffs[buff_id].activate = True
+    def sub_buffs(self, buffs: Dict[int, Buff]):
+        for buff_id in self.buff_ids:
+            buffs[buff_id].activate = False
 class TeamGain(Gain):
 class 号令三军(TeamGain):
+    gain_attributes = {"strain_base": (500 + 500 / 2) / 2}
 class 激雷(TeamGain):
 class 舍身弘法(TeamGain):
+    gain_attributes = {"strain_base": 500}
 """ 万花 """
 class 朝圣言(TeamGain):
+    gain_attributes = {"strain_base": 500}
+    variety_values = {"圣浴明心": 875 - 500}
 """ 丐帮 """
         "stack": 24
     },
     "振奋": {
+        "stack": 125
     },
     "庄周梦": {
+        "stack": 200
     }
 }
 TEAM_GAINS = {

general/skills/__init__.py ADDED Viewed

	@@ -0,0 +1,6 @@

+from general.skills import equipment, team
+GENERAL_SKILLS = {
+    **equipment.GENERAL_SKILLS,
+    **team.GENERAL_SKILLS
+}

general/skills/equipment.py ADDED Viewed

	@@ -0,0 +1,92 @@

+from typing import Dict
+from base.skill import PhysicalDamage, MagicalDamage, Skill, PureDamage
+GENERAL_SKILLS: Dict[int, Skill | dict] = {
+    22160: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "昆吾·弦刃",
+        "damage_base": 40,
+        "damage_rand": 17,
+        "attack_power_cof": 75
+    },
+    22161: {
+        "skill_class": MagicalDamage,
+        "skill_name": "昆吾·弦刃",
+        "damage_base": 40,
+        "damage_rand": 17,
+        "attack_power_cof": 90
+    },
+    22162: {
+        "skill_class": MagicalDamage,
+        "skill_name": "昆吾·弦刃",
+        "damage_base": 40,
+        "damage_rand": 17,
+        "attack_power_cof": 90
+    },
+    22163: {
+        "skill_class": MagicalDamage,
+        "skill_name": "昆吾·弦刃",
+        "damage_base": 40,
+        "damage_rand": 17,
+        "attack_power_cof": 90
+    },
+    22164: {
+        "skill_class": MagicalDamage,
+        "skill_name": "昆吾·弦刃",
+        "damage_base": 40,
+        "damage_rand": 17,
+        "attack_power_cof": 90
+    },
+    33257: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "刃凌",
+        "damage_base": 40,
+        "damage_rand": 17,
+        "attack_power_cof": [60, 100, 60, 100, 100]
+    },
+    33258: {
+        "skill_class": MagicalDamage,
+        "skill_name": "刃凌",
+        "damage_base": 40,
+        "damage_rand": 17,
+        "attack_power_cof": [50, 100]
+    },
+    33259: {
+        "skill_class": MagicalDamage,
+        "skill_name": "刃凌",
+        "damage_base": 40,
+        "damage_rand": 17,
+        "attack_power_cof": [50, 100]
+    },
+    33260: {
+        "skill_class": MagicalDamage,
+        "skill_name": "刃凌",
+        "damage_base": 40,
+        "damage_rand": 17,
+        "attack_power_cof": [50, 100]
+    },
+    33261: {
+        "skill_class": MagicalDamage,
+        "skill_name": "刃凌",
+        "damage_base": 40,
+        "damage_rand": 17,
+        "attack_power_cof": [50, 100]
+    },
+    37562: {
+        "skill_class": PureDamage,
+        "skill_name": "昆吾·弦刃",
+        "damage_base": 145300
+    },
+    37561: {
+        "skill_class": PureDamage,
+        "skill_name": "刃凌",
+        "damage_base": 96900,
+    },
+}
+for skill_id, detail in GENERAL_SKILLS.items():
+    GENERAL_SKILLS[skill_id] = detail.pop('skill_class')(skill_id)
+    GENERAL_SKILLS[skill_id].activate = False
+    for attr, value in detail.items():
+        setattr(GENERAL_SKILLS[skill_id], attr, value)

general/skills/team.py ADDED Viewed

	@@ -0,0 +1,28 @@

+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
+    },
+    29536: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "逐云寒蕊",
+        "damage_base": 40,
+        "damage_rand": 17,
+        "attack_power_cof": [90, 200 * 1.2],
+        "skill_shield_gain": -1024
+    }
+}
+for skill_id, detail in GENERAL_SKILLS.items():
+    GENERAL_SKILLS[skill_id] = detail.pop('skill_class')(skill_id)
+    GENERAL_SKILLS[skill_id].activate = False
+    for attr, value in detail.items():
+        setattr(GENERAL_SKILLS[skill_id], attr, value)

get_assets.py CHANGED Viewed

@@ -180,11 +180,9 @@ def get_secondary_weapons():
 def get_equip_name(row):
     name = row['Name']
-    if "无封" in name:
-        name = f"{row['MagicKind']}{name}"
     attrs = " ".join([EQUIP_ATTR_MAP[attr] for attr in EQUIP_ATTR_MAP if attr in row['_Attrs']])
     level = row['Level']
-    return f"{name} ({attrs}) {level}"
 def get_equip_detail(row):

 def get_equip_name(row):
     name = row['Name']
     attrs = " ".join([EQUIP_ATTR_MAP[attr] for attr in EQUIP_ATTR_MAP if attr in row['_Attrs']])
     level = row['Level']
+    return f"{name}#{row['ID']}({attrs}) {level}"
 def get_equip_detail(row):

parse_new_school.py CHANGED Viewed

@@ -59,4 +59,4 @@ class Parser:
 if __name__ == '__main__':
     parser = Parser()
-    parser(r"hua_jian.jcl")

 if __name__ == '__main__':
     parser = Parser()
+    parser(r"new.jcl")

qt/assets/equipments/belt CHANGED Viewed