:sparkles:(features): add support for Zixiagong (#1)

.gitignore

@@ -0,0 +1,324 @@
+### JetBrains template
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# AWS User-specific
+.idea/**/aws.xml
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# SonarLint plugin
+.idea/sonarlint/
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### Qt template
+# C++ objects and libs
+*.slo
+*.lo
+*.o
+*.a
+*.la
+*.lai
+*.so
+*.so.*
+*.dll
+*.dylib
+
+# Qt-es
+object_script.*.Release
+object_script.*.Debug
+*_plugin_import.cpp
+/.qmake.cache
+/.qmake.stash
+*.pro.user
+*.pro.user.*
+*.qbs.user
+*.qbs.user.*
+*.moc
+moc_*.cpp
+moc_*.h
+qrc_*.cpp
+ui_*.h
+*.qmlc
+*.jsc
+Makefile*
+*build-*
+*.qm
+*.prl
+
+# Qt unit tests
+target_wrapper.*
+
+# QtCreator
+*.autosave
+
+# QtCreator Qml
+*.qmlproject.user
+*.qmlproject.user.*
+
+# QtCreator CMake
+CMakeLists.txt.user*
+
+# QtCreator 4.8< compilation database
+compile_commands.json
+
+# QtCreator local machine specific files for imported projects
+*creator.user*
+
+*_qmlcache.qrc
+
+### macOS template
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### Python template
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+

schools/__init__.py

@@ -9,7 +9,7 @@ from base.skill import Skill
 from schools import bei_ao_jue, gu_feng_jue
 from schools import shan_hai_xin_jue, ling_hai_jue, tai_xu_jian_yi, fen_shan_jing
 from schools import yi_jin_jing, tian_luo_gui_dao, hua_jian_you
-from schools import wu_fang, bing_xin_jue, mo_wen
+from schools import wu_fang, bing_xin_jue, mo_wen, zi_xia_gong
 
 
 @dataclass
@@ -100,6 +100,14 @@ SUPPORT_SCHOOL = {
         recipe_gains=yi_jin_jing.RECIPE_GAINS, recipes=yi_jin_jing.RECIPES,
         gains=yi_jin_jing.GAINS, display_attrs={"spunk": "元气", **MAGICAL_DISPLAY_ATTRS}
     ),
+    10014: School(
+        school="纯阳", major="根骨", kind="内功", attribute=zi_xia_gong.ZiXiaGong, formation="九宫八卦阵",
+        skills=zi_xia_gong.SKILLS, buffs=zi_xia_gong.BUFFS, prepare=zi_xia_gong.prepare,
+        talent_gains=zi_xia_gong.TALENT_GAINS, talents=zi_xia_gong.TALENTS,
+        talent_decoder=zi_xia_gong.TALENT_DECODER, talent_encoder=zi_xia_gong.TALENT_ENCODER,
+        recipe_gains=zi_xia_gong.RECIPE_GAINS, recipes=zi_xia_gong.RECIPES,
+        gains=zi_xia_gong.GAINS, display_attrs={"spirit": "根骨", **MAGICAL_DISPLAY_ATTRS}
+    ),
     10015: School(
         school="纯阳", major="身法", kind="外功", attribute=tai_xu_jian_yi.TaiXuJianYi, formation="北斗七星阵",
         skills=tai_xu_jian_yi.SKILLS, buffs=tai_xu_jian_yi.BUFFS, prepare=tai_xu_jian_yi.prepare,
@@ -188,4 +196,4 @@ SUPPORT_SCHOOL = {
         recipe_gains=shan_hai_xin_jue.RECIPE_GAINS, recipes=shan_hai_xin_jue.RECIPES,
         gains=shan_hai_xin_jue.GAINS, display_attrs={"agility": "身法", **PHYSICAL_DISPLAY_ATTRS}
     ),
-}
+}

schools/zi_xia_gong/__init__.py

@@ -0,0 +1,10 @@
+from schools.zi_xia_gong.skills import SKILLS
+from schools.zi_xia_gong.buffs import BUFFS
+from schools.zi_xia_gong.talents import TALENT_GAINS, TALENTS, TALENT_DECODER, TALENT_ENCODER
+from schools.zi_xia_gong.recipes import RECIPE_GAINS, RECIPES
+from schools.zi_xia_gong.gains import GAINS
+from schools.zi_xia_gong.attribute import ZiXiaGong
+
+
+def prepare(self, player_id):
+    self.status[player_id][(17918, 1)] = 1

schools/zi_xia_gong/attribute.py

@@ -0,0 +1,21 @@
+from base.attribute import MagicalAttribute
+from base.constant import BINARY_SCALE
+
+
+class ZiXiaGong(MagicalAttribute):
+    SPIRIT_TO_ATTACK_POWER = 1792 / BINARY_SCALE
+    SPIRIT_TO_CRITICAL_STRIKE = 573 / BINARY_SCALE
+
+    def __init__(self):
+        super().__init__()
+        self.magical_attack_power_base += 3725
+        self.magical_critical_strike_base += 1788
+        self.pve_addition += 51
+
+    @property
+    def extra_magical_attack_power(self):
+        return int(self.spirit * self.SPIRIT_TO_ATTACK_POWER)
+
+    @property
+    def extra_magical_critical_strike(self):
+        return int(self.spirit * self.SPIRIT_TO_CRITICAL_STRIKE)

schools/zi_xia_gong/buffs.py

@@ -0,0 +1,78 @@
+from typing import Dict
+
+from base.buff import Buff
+from general.buffs import GENERAL_BUFFS
+
+BUFFS: Dict[int, Buff | dict] = {
+    375: {
+        "buff_name": "破苍穹",
+        "gain_attributes": {
+            "magical_critical_strike_gain": [300, 350, 400, 450, 0, 600, 700, 800, 900, 500, 500, 1000, 500, 1000],
+            "magical_critical_power_gain": [61, 71, 81, 82, 102, 122, 143, 163, 184, 102, 102, 204, 102, 204],
+            "all_shield_ignore": [0] * 12 + [614] * 2
+        }
+    },
+    1439: {
+        "buff_name": "气涌",
+        "activate": False,
+        "gain_attributes": {
+            "magical_critical_strike_gain": 400,
+            "magical_critical_power_gain": 41
+        }
+    },
+    1908: {
+        "buff_name": "会神",
+        "gain_attributes": {
+            "magical_critical_power_gain": 204,
+        }
+    },
+    2757: {
+        "buff_name": "紫气东来",
+        "gain_attributes": {
+            "physical_attack_power_gain": [256, 256, 512, 256],
+            "magical_attack_power_gain": [256, 256, 512, 256],
+            "all_critical_strike_gain": 2500,
+            "all_critical_power_gain": 256
+        }
+    },
+    9966: {
+        "buff_name": "六合独尊加伤害实际表现",
+        "gain_skills": {
+            18670: {
+                "skill_damage_addition": [358, 716, 1075, 1433]
+            }
+        }
+    },
+    # 12550: {
+    #     "buff_name": "气剑提升四象轮回伤害",
+    #     "gain_skills": {
+    #         896: {
+    #             "skill_damage_addition": [40, 81, 122, 163, 204]
+    #         }
+    #     }
+    # },
+    # 12551: {
+    #     "buff_name": "气剑提升两仪化形伤害",
+    #     "gain_skills": {
+    #         skill_id: {
+    #             "skill_damage_addition": [40, 81, 122, 163, 204]
+    #         } for skill_id in (3439, 3440, 3441, 3442, 3443, 3444, 3445, 3446, 3447, 3448)
+    #     }
+    # },
+    17918: {
+        "buff_name": "镇山河",
+        "gain_skills": {
+            skill_id: {
+                "skill_pve_addition": 1331
+            } for skill_id in (18649, 18650, 18651, 18652, 18653, 22014)
+        }
+    }
+}
+
+for buff_id, detail in BUFFS.items():
+    BUFFS[buff_id] = Buff(buff_id)
+    for attr, value in detail.items():
+        setattr(BUFFS[buff_id], attr, value)
+
+for buff_id, buff in GENERAL_BUFFS.items():
+    BUFFS[buff_id] = buff

schools/zi_xia_gong/gains.py

@@ -0,0 +1,27 @@
+from base.recipe import damage_addition_recipe, critical_strike_recipe
+from general.gains.equipment import EQUIPMENT_GAINS, CriticalSet
+from base.gain import Gain
+
+GAINS = {
+    # 气涌4%双会套装
+    1914: CriticalSet(1439),
+    # 万世不竭10%套装
+    818: damage_addition_recipe([18649, 18650, 18651, 18652, 18653, 22014], 102),
+    # 无界套装
+    4602: Gain(),
+    # 四象轮回5%橙武
+    1520: damage_addition_recipe([896], 51),
+    # TODO 太极无极5%橙武
+    1521: Gain(),
+    # 四象轮回5%小橙武
+    1136: critical_strike_recipe([896], 500),
+    # 橙武特效
+    2418: Gain(),
+    # 四象轮回·神兵
+    1931: Gain(),
+    # 无界特效1
+    17300: Gain(),
+    # 无界特效2
+    17239: Gain(),
+    **EQUIPMENT_GAINS,
+}

schools/zi_xia_gong/recipes.py

@@ -0,0 +1,34 @@
+from typing import Dict, List
+
+from base.gain import Gain
+from base.recipe import damage_addition_recipe, critical_strike_recipe
+
+RECIPE_GAINS: Dict[str, Dict[str, Gain]] = {
+    "两仪化形": {
+        "5%伤害": damage_addition_recipe([3439, 3440, 3441, 3442, 3443, 3444, 3445, 3446, 3447, 3448], 51),
+        "4%伤害": damage_addition_recipe([3439, 3440, 3441, 3442, 3443, 3444, 3445, 3446, 3447, 3448], 41),
+        "3%伤害": damage_addition_recipe([3439, 3440, 3441, 3442, 3443, 3444, 3445, 3446, 3447, 3448], 31),
+        "4%会心": critical_strike_recipe([3439, 3440, 3441, 3442, 3443, 3444, 3445, 3446, 3447, 3448], 400),
+        "3%会心": critical_strike_recipe([3439, 3440, 3441, 3442, 3443, 3444, 3445, 3446, 3447, 3448], 300),
+        "2%会心": critical_strike_recipe([3439, 3440, 3441, 3442, 3443, 3444, 3445, 3446, 3447, 3448], 200),
+    },
+    "四象轮回": {
+        "5%伤害": damage_addition_recipe([896], 51),
+        "4%伤害": damage_addition_recipe([896], 41),
+        "3%伤害": damage_addition_recipe([896], 31),
+        "4%会心": critical_strike_recipe([896], 400),
+        "3%会心": critical_strike_recipe([896], 300),
+        "2%会心": critical_strike_recipe([896], 200),
+    },
+    "万世不竭": {
+        "5%伤害": damage_addition_recipe([18649, 18650, 18651, 18652, 18653, 22014], 51),
+        "4%伤害": damage_addition_recipe([18649, 18650, 18651, 18652, 18653, 22014], 41),
+        "3%伤害": damage_addition_recipe([18649, 18650, 18651, 18652, 18653, 22014], 31),
+    }
+}
+
+RECIPES: Dict[str, List[str]] = {
+    "两仪化形": ["5%伤害", "4%伤害", "4%会心", "3%伤害", "3%会心", "2%会心"],
+    "四象轮回": ["5%伤害", "4%伤害", "4%会心", "3%伤害", "3%会心", "2%会心"],
+    "万世不竭": ["5%伤害", "4%伤害", "3%伤害"]
+}

schools/zi_xia_gong/skills.py

@@ -0,0 +1,123 @@
+from typing import Dict
+
+from base.skill import Skill, DotSkill, PhysicalDamage, MagicalDamage, MagicalDotDamage
+from general.skills import GENERAL_SKILLS
+
+SKILLS: Dict[int, Skill | dict] = {
+    303: {
+        "skill_class": MagicalDamage,
+        "skill_name": "三才化生",
+        "damage_base": 780 * 0.1,
+        "damage_rand": 78 * 0.1,
+        "attack_power_cof": 16
+    },
+    **{
+        skill_id: {
+            "skill_class": MagicalDamage,
+            "skill_name": "五方行尽",
+            "damage_base": [(51 * i / 100) for i in range(1, 11)],
+            "attack_power_cof": [(8 * i * 1.4) for i in range(1, 11)],
+        } for skill_id in (327, 328, 329, 330, 331, 461, 462, 463, 464, 465)
+    },
+    896: {
+        "skill_class": MagicalDamage,
+        "skill_name": "四象轮回",
+        "damage_base": 1260 + 827 - 1907,
+        "damage_rand": 20,
+        "attack_power_cof": 170 * 1.1 * 1.1 * 0.95 * 0.9 * 1.05 * 1.05 * 1.1 * 2.07
+    },
+    **{
+        skill_id: {
+            "skill_class": MagicalDamage,
+            "skill_name": "两仪化形",
+            "damage_base": [(16526 + 10742 * i / 100) for i in range(1, 11)],
+            "damage_rand": [273 * i / 100 for i in range(1, 11)],
+            "attack_power_cof": [(22.5 * i * 0.85 * 1.1 * 1.1 * 1.05 * 0.9 * 1.05 * 1.05 * 1.1 * 1.1 * 1.32) for i in
+                                 range(1, 11)],
+        } for skill_id in (3439, 3440, 3441, 3442, 3443, 3444, 3445, 3446, 3447, 3448)
+    },
+    **{
+        skill_id: {
+            "skill_class": MagicalDamage,
+            "skill_name": "两仪化形",
+            "damage_base": 1298 * 2.1,
+            "damage_rand": 1298 * 2.1,
+            "attack_power_cof": [(14 * i * 0.8) for i in range(1, 11)],
+        } for skill_id in (6091, 6092, 6093, 6094, 6095, 6096, 6097, 6098, 6099, 6100)
+    },
+    6424: {
+        "skill_class": MagicalDotDamage,
+        "skill_name": "气竭(DOT)",
+        "damage_base": 10,
+        "attack_power_cof": 229 * 1.7,
+        "interval": 48
+    },
+    18121: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "三柴剑法",
+        "attack_power_cof": 16,
+        "weapon_damage_cof": 1024,
+        "skill_damage_addition": 205
+    },
+    **{
+        skill_id: {
+            "skill_class": MagicalDamage,
+            "skill_name": "飞剑",
+            "damage_base": 50,
+            "attack_power_cof": 40 * 0.75 * 1.15 * 1.1 * 1.45,
+        } for skill_id in (18649, 18650, 18651, 18652, 18653)
+    },
+    18670: {
+        "skill_class": MagicalDamage,
+        "skill_name": "六合独尊",
+        "damage_base": 1038 / 16,
+        "damage_rand": 104 / 2,
+        "attack_power_cof": 82 * 2
+    },
+    22014: {
+        "skill_class": MagicalDamage,
+        "skill_name": "万世不竭",
+        "damage_base": 1150,
+        "damage_rand": 78,
+        "attack_power_cof": 300 * 1.1 * 1.15 * 1.1 * 1.12
+    },
+    25770: {
+        "skill_class": MagicalDamage,
+        "skill_name": "四象轮回·神兵",
+        "damage_base": 20,
+        "damage_rand": 2,
+        "attack_power_cof": 65
+    },
+    32813: {
+        "skill_class": MagicalDamage,
+        "skill_name": "破",
+        "surplus_cof": [
+            1024 * 1024 * (0.06 - 1),
+            1024 * 1024 * (0.30 - 1),
+            1024 * 1024 * (0.83 - 1),
+            1024 * 1024 * (0.60 - 1)
+        ]
+    },
+    33592: {
+        "skill_class": DotSkill,
+        "skill_name": "气竭",
+        "bind_skill": 6424,
+        "max_stack": 3,
+        "tick": 10
+    },
+    36439: {
+        "skill_class": MagicalDamage,
+        "skill_name": "颠越苍穹击",
+        "damage_base": 1038,
+        "damage_rand": 104,
+        "attack_power_cof": 155 * 0.9
+    }
+}
+
+for skill_id, detail in SKILLS.items():
+    SKILLS[skill_id] = detail.pop('skill_class')(skill_id)
+    for attr, value in detail.items():
+        setattr(SKILLS[skill_id], attr, value)
+
+for skill_id, skill in GENERAL_SKILLS.items():
+    SKILLS[skill_id] = skill

schools/zi_xia_gong/talents.py

@@ -0,0 +1,92 @@
+from typing import Dict
+
+from base.gain import Gain
+from base.skill import Skill
+
+
+class 雾锁(Gain):
+    def add_skills(self, skills: Dict[int, Skill]):
+        skills[896].skill_damage_addition += 102
+
+    def sub_skills(self, skills: Dict[int, Skill]):
+        skills[896].skill_damage_addition -= 102
+
+
+class 白虹(Gain):
+    def add_skills(self, skills: Dict[int, Skill]):
+        skills[896].skill_critical_strike += 1000
+        skills[896].skill_critical_power += 102
+
+    def sub_skills(self, skills: Dict[int, Skill]):
+        skills[896].skill_critical_strike -= 1000
+        skills[896].skill_critical_power -= 102
+
+
+class 霜锋(Gain):
+    def add_skills(self, skills: Dict[int, Skill]):
+        for skill_id in (3439, 3440, 3441, 3442, 3443, 3444, 3445, 3446, 3447, 3448):
+            skills[skill_id].skill_damage_addition += 102
+        skills[18670].skill_damage_addition += 102
+
+    def sub_skills(self, skills: Dict[int, Skill]):
+        for skill_id in (3439, 3440, 3441, 3442, 3443, 3444, 3445, 3446, 3447, 3448):
+            skills[skill_id].skill_damage_addition -= 102
+        skills[18670].skill_damage_addition -= 102
+
+
+class 跬步(Gain):
+    def add_skills(self, skills: Dict[int, Skill]):
+        skills[896].skill_damage_addition += 204
+        for skill_id in (3439, 3440, 3441, 3442, 3443, 3444, 3445, 3446, 3447, 3448):
+            skills[skill_id].skill_damage_addition += 204
+
+    def sub_skills(self, skills: Dict[int, Skill]):
+        skills[896].skill_damage_addition -= 204
+        for skill_id in (3439, 3440, 3441, 3442, 3443, 3444, 3445, 3446, 3447, 3448):
+            skills[skill_id].skill_damage_addition -= 204
+
+
+class 重光(Gain):
+    def add_skills(self, skills: Dict[int, Skill]):
+        for i, skill_id in enumerate([18649, 18650, 18651, 18652, 18653]):
+            skills[skill_id].skill_damage_addition += int(i * 0.15 * 1024)
+
+    def sub_skills(self, skills: Dict[int, Skill]):
+        for i, skill_id in enumerate([18649, 18650, 18651, 18652, 18653]):
+            skills[skill_id].skill_damage_addition -= int(i * 0.15 * 1024)
+
+
+TALENT_GAINS: Dict[int, Gain] = {
+    5840: 雾锁("雾锁"),
+    5827: 白虹("白虹"),
+    5823: Gain("心固"),
+    5828: 霜锋("霜锋"),
+    357: Gain("化三清"),
+    5846: Gain("无形"),
+    23614: Gain("归元"),
+    5819: Gain("同尘"),
+    18695: 跬步("跬步"),
+    32411: Gain("正气"),
+    14834: Gain("抱阳"),
+    18679: Gain("浮生"),
+    24945: Gain("破势"),
+    18669: 重光("重光"),
+    14613: Gain("固本"),
+}
+
+TALENTS = [
+    [5840, 5827],
+    [5823, 5828],
+    [357, 5846],
+    [23614],
+    [5819],
+    [18695],
+    [32411],
+    [14834],
+    [18679],
+    [24945],
+    [18669],
+    [14613]
+]
+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/parser.py

@@ -4,17 +4,19 @@ from base.constant import FRAME_PER_SECOND
 from schools import *
 from utils.lua import parse
 
-FRAME_TYPE, PLAYER_ID_TYPE, PLAYER_NAME_TYPE, TARGET_ID_TYPE, PET_ID_TYPE = int, int, int, int, int
+FRAME_TYPE, PLAYER_ID_TYPE, PLAYER_NAME_TYPE, PET_ID_TYPE = int, int, int, int
 CASTER_ID_TYPE = PLAYER_ID_TYPE | PET_ID_TYPE
 SKILL_ID_TYPE, SKILL_LEVEL_TYPE, SKILL_STACK_TYPE, SKILL_CRITICAL_TYPE = int, int, int, bool
+SKILL_BUFFER_TYPE = Tuple[SKILL_ID_TYPE, SKILL_LEVEL_TYPE, SKILL_CRITICAL_TYPE]
 SKILL_TYPE = Tuple[SKILL_ID_TYPE, SKILL_LEVEL_TYPE, SKILL_STACK_TYPE]
 BUFF_ID_TYPE, BUFF_LEVEL_TYPE, BUFF_STACK_TYPE = int, int, int
 BUFF_TYPE = Tuple[BUFF_ID_TYPE, BUFF_LEVEL_TYPE]
+STATUS_TYPE = Tuple[BUFF_ID_TYPE, BUFF_LEVEL_TYPE, BUFF_STACK_TYPE]
 
-CURRENT_STATUS_TYPE, SNAPSHOT_STATUS_TYPE, TARGET_STATUS_TYPE = tuple, tuple, tuple
-STATUS_TUPLE = Tuple[CURRENT_STATUS_TYPE, SNAPSHOT_STATUS_TYPE, TARGET_STATUS_TYPE]
-TIMELINE_TYPE = Tuple[FRAME_TYPE, SKILL_CRITICAL_TYPE]
-SUB_RECORD_TYPE = Dict[STATUS_TUPLE, List[TIMELINE_TYPE]]
+SNAPSHOT_TYPE = Dict[SKILL_ID_TYPE | PET_ID_TYPE, Dict[BUFF_TYPE, BUFF_STACK_TYPE]]
+
+TIMELINE_TYPE = List[Tuple[FRAME_TYPE, SKILL_CRITICAL_TYPE]]
+SUB_RECORD_TYPE = Dict[Tuple[tuple, tuple], TIMELINE_TYPE]
 RECORD_TYPE = Dict[SKILL_TYPE, SUB_RECORD_TYPE]
 
 LABEL_MAPPING = {
@@ -33,33 +35,30 @@ LABEL_MAPPING = {
 }
 EMBED_MAPPING: Dict[tuple, int] = {(5, 24449 - i): 8 - i for i in range(8)}
 
+BUFFER_DELAY = 0
+
 
 class Parser:
     current_player: PLAYER_ID_TYPE
     current_caster: CASTER_ID_TYPE
-    current_target: TARGET_ID_TYPE
-    current_skill: SKILL_ID_TYPE
     current_frame: FRAME_TYPE
+    frames: List[FRAME_TYPE]
 
-    id2name: Dict[PLAYER_ID_TYPE | TARGET_ID_TYPE, PLAYER_NAME_TYPE]
-    name2id: Dict[PLAYER_NAME_TYPE, PLAYER_ID_TYPE | TARGET_ID_TYPE]
+    id2name: Dict[PLAYER_ID_TYPE, PLAYER_NAME_TYPE]
+    name2id: Dict[PLAYER_NAME_TYPE, PLAYER_ID_TYPE]
     pets: Dict[PET_ID_TYPE, PLAYER_ID_TYPE]
-    records: Dict[PLAYER_ID_TYPE, Dict[TARGET_ID_TYPE, RECORD_TYPE]]
-
-    shift_buffs: Dict[FRAME_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]]]
+    records: Dict[PLAYER_ID_TYPE, RECORD_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]]]
+    hidden_buffs: Dict[PLAYER_ID_TYPE, Dict[BUFF_TYPE, FRAME_TYPE]]
+    shift_status: Dict[FRAME_TYPE, Dict[PLAYER_ID_TYPE, Dict[BUFF_TYPE, BUFF_STACK_TYPE]]]
+    status: Dict[PLAYER_ID_TYPE, Dict[BUFF_TYPE, BUFF_STACK_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]]]
+    stacks: Dict[PLAYER_ID_TYPE, Dict[SKILL_ID_TYPE, int]]
+    ticks: Dict[PLAYER_ID_TYPE, Dict[SKILL_ID_TYPE, int]]
 
-    pet_snapshot: Dict[PET_ID_TYPE, Dict[BUFF_TYPE, BUFF_STACK_TYPE]]
-    dot_snapshot: Dict[TARGET_ID_TYPE, Dict[PLAYER_ID_TYPE, Dict[SKILL_ID_TYPE, 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]]]
+    snapshot: Dict[PLAYER_ID_TYPE, SNAPSHOT_TYPE]
+    last_dot: Dict[PLAYER_ID_TYPE, Dict[SKILL_ID_TYPE, Tuple[SKILL_TYPE, Tuple[tuple, tuple]]]]
+    next_dot: Dict[PLAYER_ID_TYPE, Dict[SKILL_ID_TYPE, int]]
 
     start_frame: FRAME_TYPE
     end_frame: FRAME_TYPE
@@ -67,59 +66,43 @@ class Parser:
     select_talents: Dict[PLAYER_ID_TYPE, List[int]]
     select_equipments: Dict[PLAYER_ID_TYPE, Dict[int, Dict[str, int | list]]]
 
-    players: Dict[PLAYER_ID_TYPE, School]
-    targets: Dict[PLAYER_ID_TYPE, List[TARGET_ID_TYPE]]
+    school: Dict[PLAYER_ID_TYPE, School]
 
     @property
     def current_school(self):
-        return self.players[self.current_player]
-
-    @property
-    def current_targets(self):
-        return self.targets[self.current_player]
+        return self.school[self.current_player]
 
     @property
     def current_records(self):
-        return self.records[self.current_player][self.current_target]
+        return self.records[self.current_player]
 
     @property
     def current_hidden_buffs(self):
-        return self.hidden_buffs[self.current_target][self.current_player]
-
-    @property
-    def current_player_buffs(self):
-        return self.player_buffs[self.current_player]
+        return self.hidden_buffs[self.current_player]
 
     @property
-    def current_target_buffs(self):
-        return self.target_buffs[self.current_target][self.current_player]
+    def current_status(self):
+        return self.status[self.current_player]
 
     @property
     def current_snapshot(self):
-        if self.current_caster in self.pet_snapshot:
-            return self.pet_snapshot[self.current_caster]
-        else:
-            return self.dot_snapshot[self.current_target][self.current_player].get(self.current_skill, {})
-
-    @property
-    def current_dot_snapshot(self):
-        return self.dot_snapshot[self.current_target][self.current_player]
+        return self.snapshot[self.current_player]
 
     @property
     def current_stacks(self):
-        return self.stacks[self.current_target][self.current_player]
+        return self.stacks[self.current_player]
 
     @property
     def current_ticks(self):
-        return self.ticks[self.current_target][self.current_player]
+        return self.ticks[self.current_player]
 
     @property
     def current_last_dot(self):
-        return self.last_dot[self.current_target][self.current_player]
+        return self.last_dot[self.current_player]
 
     @property
     def current_next_dot(self):
-        return self.next_dot[self.current_target][self.current_player]
+        return self.next_dot[self.current_player]
 
     @property
     def duration(self):
@@ -128,33 +111,29 @@ class Parser:
     def reset(self):
         self.current_frame = 0
 
+        self.frames = []
+
         self.id2name = {}
         self.name2id = {}
         self.pets = {}
 
-        self.records = defaultdict(lambda: defaultdict(lambda: defaultdict(lambda: defaultdict(list))))
-
-        self.hidden_buffs = defaultdict(lambda: defaultdict(dict))
-        self.shift_buffs = defaultdict(lambda: defaultdict(dict))
-
-        self.player_buffs = defaultdict(dict)
-        self.target_buffs = defaultdict(lambda: defaultdict(dict))
+        self.records = defaultdict(lambda: defaultdict(lambda: defaultdict(list)))
 
-        self.stacks = defaultdict(lambda: defaultdict(lambda: defaultdict(lambda: 1)))
-        self.ticks = defaultdict(lambda: defaultdict(lambda: defaultdict(lambda: 0)))
+        self.hidden_buffs = defaultdict(dict)
+        self.shift_status = defaultdict(lambda: defaultdict(dict))
+        self.status = defaultdict(lambda: defaultdict(int))
 
-        self.pet_snapshot = dict()
-        self.dot_snapshot = defaultdict(lambda: defaultdict(dict))
-        self.last_dot = defaultdict(lambda: defaultdict(dict))
-        self.next_dot = defaultdict(lambda: defaultdict(dict))
+        self.stacks = defaultdict(lambda: defaultdict(lambda: 1))
+        self.ticks = defaultdict(lambda: defaultdict(lambda: 0))
+        self.snapshot = defaultdict(dict)
+        self.last_dot = defaultdict(dict)
+        self.next_dot = defaultdict(dict)
 
         self.start_frame = 0
 
         self.select_talents = {}
         self.select_equipments = {}
-
-        self.players = {}
-        self.targets = defaultdict(list)
+        self.school = {}
 
     @staticmethod
     def parse_equipments(detail):
@@ -176,90 +155,70 @@ class Parser:
     def parse_talents(detail):
         return [row[1] for row in detail]
 
-    def parse_player(self, row):
+    def parse_info(self, row):
         detail = row.strip("{}").split(",")
         player_id, school_id = int(detail[0]), int(detail[3])
         if player_id in self.id2name or school_id not in SUPPORT_SCHOOL:
             return
-
-        if isinstance(detail := parse(row), list) and (school := SUPPORT_SCHOOL.get(detail[3])):
+        if isinstance(detail := parse(row), list):
             player_name = detail[1]
             self.id2name[player_id] = player_name
             self.name2id[player_name] = player_id
-            self.select_equipments[player_id] = self.parse_equipments(detail[5])
-            self.select_talents[player_id] = self.parse_talents(detail[6])
-            if any(talent not in school.talent_gains for talent in self.select_talents[player_id]):
-                return
-            self.players[player_id] = school
-
-    def parse_npc(self, row):
-        detail = row.strip("{}").split(",")
-        npc_id, player_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:
-            self.pets[npc_id] = player_id
-
-    def parse_pet(self, row):
-        detail = row.strip("{}").split(",")
-        pet_id, player_id = int(detail[0]), int(detail[3])
-        if pet_id in self.pets:
-            self.pet_snapshot[pet_id] = self.player_buffs[player_id].copy()
+            if school := SUPPORT_SCHOOL.get(detail[3]):
+                self.select_equipments[player_id] = self.parse_equipments(detail[5])
+                self.select_talents[player_id] = self.parse_talents(detail[6])
+                if any(talent not in school.talent_gains for talent in self.select_talents[player_id]):
+                    return
+                self.school[player_id] = school
 
     def parse_shift_buff(self, row):
         detail = row.strip("{}").split(",")
         player_id = int(detail[0])
-        if player_id not in self.players:
+        if player_id not in self.school:
             return
-
         buff_id, buff_stack, buff_level = int(detail[4]), int(detail[5]), int(detail[8])
-        if buff_id not in self.players[player_id].buffs:
+        if buff_id not in self.school[player_id].buffs:
             return
 
-        frame_shift = self.players[player_id].buffs[buff_id].frame_shift
+        frame_shift = self.school[player_id].buffs[buff_id].frame_shift
         if frame_shift:
-            self.shift_buffs[self.current_frame + frame_shift][player_id][(buff_id, buff_level)] = buff_stack
+            self.shift_status[self.current_frame + frame_shift][player_id][(buff_id, buff_level)] = buff_stack
 
     def parse_shift_status(self):
-        for frame in list(self.shift_buffs):
+        for frame in list(self.shift_status):
             if frame > self.current_frame:
                 break
-            for player_id, shift_buffs in self.shift_buffs.pop(frame).items():
-                for buff, buff_stack in shift_buffs.items():
+            for player_id, status_buffer in self.shift_status.pop(frame).items():
+                for buff, buff_stack in status_buffer.items():
                     if buff_stack:
-                        self.player_buffs[player_id][buff] = buff_stack
+                        self.status[player_id][buff] = buff_stack
                     else:
-                        self.player_buffs[player_id].pop(buff, None)
+                        self.status[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():
-                    if end_frame < self.current_frame:
-                        self.target_buffs[target_id][player_id].pop(buff, None)
+        for player_id, hidden_buffs in self.hidden_buffs.items():
+            for buff, end_frame in hidden_buffs.items():
+                if end_frame < self.current_frame:
+                    self.status[player_id].pop(buff, None)
 
-    def parse_buff(self, row):
+    def parse_status(self, row):
         detail = row.strip("{}").split(",")
         player_id = int(detail[0])
-        if player_id not in self.players:
+        if player_id not in self.school:
             return
 
         buff_id, buff_stack, buff_level = int(detail[4]), int(detail[5]), int(detail[8])
-        if buff_id not in self.players[player_id].buffs:
+        if buff_id not in self.school[player_id].buffs:
             return
 
-        frame_shift = self.players[player_id].buffs[buff_id].frame_shift
+        frame_shift = self.school[player_id].buffs[buff_id].frame_shift
         if frame_shift:
             return
 
         if buff_stack:
-            self.player_buffs[player_id][(buff_id, buff_level)] = buff_stack
+            self.status[player_id][(buff_id, buff_level)] = buff_stack
         else:
-            self.player_buffs[player_id].pop((buff_id, buff_level), None)
+            self.status[player_id].pop((buff_id, buff_level), None)
 
     def parse_skill(self, row):
         detail = row.strip("{}").split(",")
@@ -269,56 +228,51 @@ class Parser:
         else:
             player_id = caster_id
 
-        if player_id not in self.players:
+        if player_id not in self.school:
             return
 
         react, skill_id, skill_level, critical = int(detail[2]), int(detail[4]), int(detail[5]), detail[6] == "true"
-        if react or skill_id not in self.players[player_id].skills:
+        if react or skill_id not in self.school[player_id].skills:
             return
 
         if not self.start_frame:
-            self.start_frame = self.current_frame
+            self.start_frame = self.current_frame - 1
 
         self.current_player = player_id
         self.current_caster = caster_id
-        if target_id not in self.current_targets:
-            self.current_targets.append(target_id)
-        self.current_target = target_id
-        self.current_skill = skill_id
-        skill = self.players[player_id].skills[skill_id]
-        skill.skill_level = skill_level
-        skill.record(critical, self)
-
-    def status(self, skill_id):
+        skill = self.school[player_id].skills[skill_id]
+        skill.record(skill_level, critical, self)
+
+    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
+            self.snapshot[player_id][pet_id] = self.status[player_id].copy()
+
+    def available_status(self, skill_id, snapshot_id=None):
+        if not snapshot_id:
+            snapshot_id = 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_status.items():
             buff = self.current_school.buffs[buff_id]
             if buff.gain_attributes:
                 current_status.append((buff_id, buff_level, buff_stack))
             elif buff.gain_skills and skill_id in buff.gain_skills:
                 current_status.append((buff_id, buff_level, buff_stack))
 
-        self.current_skill = skill_id
         snapshot_status = []
-        for (buff_id, buff_level), buff_stack in self.current_snapshot.items():
+        for (buff_id, buff_level), buff_stack in self.current_snapshot.get(snapshot_id, {}).items():
             buff = self.current_school.buffs[buff_id]
             if buff.gain_attributes:
                 snapshot_status.append((buff_id, buff_level, buff_stack))
             elif buff.gain_skills and skill_id in buff.gain_skills:
                 snapshot_status.append((buff_id, buff_level, buff_stack))
 
-        target_status = []
-        for (buff_id, buff_level), buff_stack in self.current_target_buffs.items():
-            buff = self.current_school.buffs[buff_id]
-            if buff.gain_attributes:
-                target_status.append((buff_id, buff_level, buff_stack))
-            elif buff.gain_skills and skill_id in buff.gain_skills:
-                target_status.append((buff_id, buff_level, buff_stack))
-
-        return tuple(current_status), tuple(snapshot_status), tuple(target_status)
+        return tuple(current_status), tuple(snapshot_status)
 
     def __call__(self, file_name):
-        self.file_name = file_name
         self.reset()
         lines = open(file_name).readlines()
         rows = []
@@ -326,11 +280,9 @@ class Parser:
             row = line.split("\t")
             rows.append(row)
             if row[4] == "4":
-                self.parse_player(row[-1])
-            elif row[4] == "8":
-                self.parse_npc(row[-1])
+                self.parse_info(row[-1])
 
-        for player_id, school in self.players.items():
+        for player_id, school in self.school.items():
             school.prepare(self, player_id)
             for talent_id in self.select_talents[player_id]:
                 school.talent_gains[talent_id].add_skills(school.skills)
@@ -347,24 +299,16 @@ class Parser:
             if row[4] == "8":
                 self.parse_pet(row[-1])
             elif row[4] == "13":
-                self.parse_buff(row[-1])
+                self.parse_status(row[-1])
             elif row[4] == "21":
                 self.parse_skill(row[-1])
 
         self.end_frame = self.current_frame
 
-        for player_id, school in self.players.items():
+        for player_id, school in self.school.items():
             for talent_id in self.select_talents[player_id]:
                 school.talent_gains[talent_id].sub_skills(school.skills)
 
-        for player_id in self.records:
-            player_record = defaultdict(lambda: defaultdict(list))
-            for target_id, records in self.records[player_id].items():
-                for skill_tuple, status in records.items():
-                    for status_tuple, timeline in status.items():
-                        player_record[skill_tuple][status_tuple] += timeline
-            self.records[player_id][0] = player_record
-
 
 if __name__ == '__main__':
     parser = Parser()