04.08 commit

base/attribute.py

@@ -1,9 +1,96 @@
 from base.constant import *
 
 
-class Attribute:
-    level: int = 120
+class Target:
+    target_level: int = 124
+
+    _physical_shield_base: int = 0
+    _magical_shield_base: int = 0
+
+    _physical_shield_gain: int = 0
+    _magical_shield_gain: int = 0
+
+    _all_vulnerable: float = 0
+    _physical_vulnerable: float = 0
+    _magical_vulnerable: float = 0
+
+    @property
+    def shield_base(self):
+        raise NotImplementedError
+
+    @property
+    def physical_shield_base(self):
+        return SHIELD_BASE_MAP[self.target_level] + self._physical_shield_base
+
+    @physical_shield_base.setter
+    def physical_shield_base(self, physical_shield_base):
+        self._physical_shield_base = physical_shield_base
+
+    @property
+    def magical_shield_base(self):
+        return SHIELD_BASE_MAP[self.target_level] + self._magical_shield_base
+
+    @magical_shield_base.setter
+    def magical_shield_base(self, magical_shield_base):
+        self._magical_shield_base = magical_shield_base
+
+    @property
+    def shield_gain(self):
+        raise NotImplementedError
+
+    @property
+    def physical_shield_gain(self):
+        return self._physical_shield_gain / BINARY_SCALE
+
+    @physical_shield_gain.setter
+    def physical_shield_gain(self, physical_shield_gain):
+        self._physical_shield_gain = physical_shield_gain
+
+    @property
+    def magical_shield_gain(self):
+        return self._magical_shield_gain / BINARY_SCALE
+
+    @magical_shield_gain.setter
+    def magical_shield_gain(self, magical_shield_gain):
+        self._magical_shield_gain = magical_shield_gain
+
+    @property
+    def vulnerable(self):
+        raise NotImplementedError
+
+    @property
+    def all_vulnerable(self):
+        return self._all_vulnerable
+
+    @all_vulnerable.setter
+    def all_vulnerable(self, all_vulnerable):
+        residual = all_vulnerable - self._all_vulnerable
+        self.physical_vulnerable += residual
+        self.magical_vulnerable += residual
+        self._all_vulnerable = all_vulnerable
+
+    @property
+    def physical_vulnerable(self):
+        return self._physical_vulnerable / BINARY_SCALE
 
+    @physical_vulnerable.setter
+    def physical_vulnerable(self, physical_vulnerable):
+        self._physical_vulnerable = physical_vulnerable
+
+    @property
+    def magical_vulnerable(self):
+        return self._magical_vulnerable / BINARY_SCALE
+
+    @magical_vulnerable.setter
+    def magical_vulnerable(self, magical_vulnerable):
+        self._magical_vulnerable = magical_vulnerable
+
+    @property
+    def shield_constant(self):
+        return SHIELD_SCALE * (LEVEL_SCALE * self.target_level - LEVEL_CONSTANT)
+
+
+class Major:
     _all_major_base: int = 0
     _all_major_gain: int = 0
     _agility_base: int = 0
@@ -19,13 +106,6 @@ class Attribute:
     _spunk_gain: int = 0
     _spunk: int = 0
 
-    surplus: int = 0
-
-    _strain_base: int = 0
-    _strain_percent: float = 0
-    _strain_gain: int = 0
-    _strain: float = 0
-
     _physical_attack_power_base: int = 0
     _base_physical_attack_power: int = 0
     _physical_attack_power_gain: int = 0
@@ -53,18 +133,6 @@ class Attribute:
     _magical_critical_strike_gain: int = 0
     _magical_critical_strike: float = 0
 
-    _all_critical_power_base: int = 0
-    _all_critical_power_gain: int = 0
-
-    _physical_critical_power_base: int = 0
-    _physical_critical_power_percent: float = 0
-    _physical_critical_power_gain: int = 0
-    _physical_critical_power: float = 0
-    _magical_critical_power_base: int = 0
-    _magical_critical_power_percent: float = 0
-    _magical_critical_power_gain: int = 0
-    _magical_critical_power: float = 0
-
     _physical_overcome_base: int = 0
     _base_physical_overcome: int = 0
     _final_physical_overcome: int = 0
@@ -78,36 +146,8 @@ class Attribute:
     _extra_magical_overcome: int = 0
     _magical_overcome: float = 0
 
-    _weapon_damage_rand: int = 0
-    _weapon_damage_base: int = 0
-    _weapon_damage_gain: int = 0
-    _weapon_damage: int = 0
-
-    _all_shield_ignore: float = 0
-
-    _physical_shield_ignore: float = 0
-    _magical_shield_ignore: float = 0
-
-    _all_damage_addition: float = 0
-    _physical_damage_addition: float = 0
-    _magical_damage_addition: float = 0
-
-    _pve_addition: float = 0
-
-    target_level: int = 124
-
-    _physical_shield_gain: int = 0
-    _magical_shield_gain: int = 0
-
-    _all_vulnerable: float = 0
-    _physical_vulnerable: float = 0
-    _magical_vulnerable: float = 0
-
-    def __init__(self):
-        self.all_major_base += MAJOR_BASE
-
     """ Major Attr Function"""
-
+    
     @property
     def all_major_base(self):
         return self._all_major_base
@@ -250,43 +290,6 @@ class Attribute:
         self.base_magical_attack_power = self.magical_attack_power_base + spunk * SPUNK_TO_ATTACK_POWER
         self.base_magical_overcome = self.magical_overcome_base + spunk * SPUNK_TO_OVERCOME
 
-    """ Minor Function """
-
-    @property
-    def strain_base(self):
-        return self._strain_base
-
-    @strain_base.setter
-    def strain_base(self, strain_base):
-        self._strain_base = strain_base
-        self.strain_percent = strain_base / STRAIN_SCALE
-
-    @property
-    def strain_percent(self):
-        return self._strain_percent
-
-    @strain_percent.setter
-    def strain_percent(self, strain_percent):
-        self._strain_percent = strain_percent
-        self.strain = strain_percent + self.strain_gain
-
-    @property
-    def strain_gain(self):
-        return self._strain_gain / BINARY_SCALE
-
-    @strain_gain.setter
-    def strain_gain(self, strain_gain):
-        self._strain_gain = strain_gain
-        self.strain = self.strain_percent + self.strain_gain
-
-    @property
-    def strain(self):
-        return self._strain
-
-    @strain.setter
-    def strain(self, strain):
-        self._strain = strain
-
     """ Attack Power Function """
 
     @property
@@ -539,104 +542,6 @@ class Attribute:
     def magical_critical_strike(self, magical_critical_strike):
         self._magical_critical_strike = magical_critical_strike
 
-    """ Critical Power Function"""
-
-    @property
-    def critical_power(self):
-        raise NotImplementedError
-
-    @property
-    def all_critical_power_base(self):
-        return self._all_critical_power_base
-
-    @all_critical_power_base.setter
-    def all_critical_power_base(self, all_critical_power_base):
-        residual = all_critical_power_base - self._all_critical_power_base
-        self.physical_critical_power_base += residual
-        self.magical_critical_power_base += residual
-        self._all_critical_power_base = all_critical_power_base
-
-    @property
-    def all_critical_power_gain(self):
-        return self._all_critical_power_gain
-
-    @all_critical_power_gain.setter
-    def all_critical_power_gain(self, all_critical_power_gain):
-        residual = all_critical_power_gain - self._all_critical_power_gain
-        self.physical_critical_power_gain += residual
-        self.magical_critical_power_gain += residual
-        self._all_critical_power_gain = all_critical_power_gain
-
-    @property
-    def physical_critical_power_base(self):
-        return self._physical_critical_power_base
-
-    @physical_critical_power_base.setter
-    def physical_critical_power_base(self, physical_critical_power_base):
-        self._physical_critical_power_base = physical_critical_power_base
-        self.physical_critical_power_percent = self.physical_critical_power_base / CRITICAL_POWER_SCALE
-
-    @property
-    def physical_critical_power_percent(self):
-        return CRITICAL_POWER_BASE + self._physical_critical_power_percent
-
-    @physical_critical_power_percent.setter
-    def physical_critical_power_percent(self, physical_critical_power_percent):
-        self._physical_critical_power_percent = physical_critical_power_percent
-        self.physical_critical_power = self.physical_critical_power_percent + self.physical_critical_power_gain
-
-    @property
-    def physical_critical_power_gain(self):
-        return self._physical_critical_power_gain / BINARY_SCALE
-
-    @physical_critical_power_gain.setter
-    def physical_critical_power_gain(self, physical_critical_power_gain):
-        self._physical_critical_power_gain = physical_critical_power_gain
-        self.physical_critical_power = self.physical_critical_power_percent + self.physical_critical_power_gain
-
-    @property
-    def physical_critical_power(self):
-        return self._physical_critical_power
-
-    @physical_critical_power.setter
-    def physical_critical_power(self, physical_critical_power):
-        self._physical_critical_power = physical_critical_power
-
-    @property
-    def magical_critical_power_base(self):
-        return self._magical_critical_power_base
-
-    @magical_critical_power_base.setter
-    def magical_critical_power_base(self, magical_critical_power_base):
-        self._magical_critical_power_base = magical_critical_power_base
-        self.magical_critical_power_percent = self.magical_critical_power_base / CRITICAL_POWER_SCALE
-
-    @property
-    def magical_critical_power_percent(self):
-        return CRITICAL_POWER_BASE + self._magical_critical_power_percent
-
-    @magical_critical_power_percent.setter
-    def magical_critical_power_percent(self, magical_critical_power_percent):
-        self._magical_critical_power_percent = magical_critical_power_percent
-        self.magical_critical_power = self.magical_critical_power_percent + self.magical_critical_power_gain
-
-    @property
-    def magical_critical_power_gain(self):
-        return self._magical_critical_power_gain / BINARY_SCALE
-
-    @magical_critical_power_gain.setter
-    def magical_critical_power_gain(self, magical_critical_power_gain):
-        self._magical_critical_power_gain = magical_critical_power_gain
-        self.magical_critical_power = self.magical_critical_power_percent + self.magical_critical_power_gain
-
-    @property
-    def magical_critical_power(self):
-        return self._magical_critical_power
-
-    @magical_critical_power.setter
-    def magical_critical_power(self, magical_critical_power):
-        self._magical_critical_power = magical_critical_power
-
     """ Overcome Function"""
 
     @property
@@ -761,6 +666,178 @@ class Attribute:
     def magical_overcome(self, magical_overcome):
         self._magical_overcome = magical_overcome
 
+
+class Minor:
+    surplus: int = 0
+
+    _strain_base: int = 0
+    _strain_percent: float = 0
+    _strain_gain: int = 0
+    _strain: float = 0
+
+    _all_critical_power_base: int = 0
+    _all_critical_power_gain: int = 0
+
+    _physical_critical_power_base: int = 0
+    _physical_critical_power_percent: float = 0
+    _physical_critical_power_gain: int = 0
+    _physical_critical_power: float = 0
+    _magical_critical_power_base: int = 0
+    _magical_critical_power_percent: float = 0
+    _magical_critical_power_gain: int = 0
+    _magical_critical_power: float = 0
+
+    _weapon_damage_rand: int = 0
+    _weapon_damage_base: int = 0
+    _weapon_damage_gain: int = 0
+    _weapon_damage: int = 0
+
+    _all_shield_ignore: float = 0
+
+    _physical_shield_ignore: float = 0
+    _magical_shield_ignore: float = 0
+
+    _all_damage_addition: float = 0
+    _physical_damage_addition: float = 0
+    _magical_damage_addition: float = 0
+
+    _pve_addition: float = 0
+
+    """ Minor Function """
+
+    @property
+    def strain_base(self):
+        return self._strain_base
+
+    @strain_base.setter
+    def strain_base(self, strain_base):
+        self._strain_base = strain_base
+        self.strain_percent = strain_base / STRAIN_SCALE
+
+    @property
+    def strain_percent(self):
+        return self._strain_percent
+
+    @strain_percent.setter
+    def strain_percent(self, strain_percent):
+        self._strain_percent = strain_percent
+        self.strain = strain_percent + self.strain_gain
+
+    @property
+    def strain_gain(self):
+        return self._strain_gain / BINARY_SCALE
+
+    @strain_gain.setter
+    def strain_gain(self, strain_gain):
+        self._strain_gain = strain_gain
+        self.strain = self.strain_percent + self.strain_gain
+
+    @property
+    def strain(self):
+        return self._strain
+
+    @strain.setter
+    def strain(self, strain):
+        self._strain = strain
+
+    """ Critical Power Function"""
+
+    @property
+    def critical_power(self):
+        raise NotImplementedError
+
+    @property
+    def all_critical_power_base(self):
+        return self._all_critical_power_base
+
+    @all_critical_power_base.setter
+    def all_critical_power_base(self, all_critical_power_base):
+        residual = all_critical_power_base - self._all_critical_power_base
+        self.physical_critical_power_base += residual
+        self.magical_critical_power_base += residual
+        self._all_critical_power_base = all_critical_power_base
+
+    @property
+    def all_critical_power_gain(self):
+        return self._all_critical_power_gain
+
+    @all_critical_power_gain.setter
+    def all_critical_power_gain(self, all_critical_power_gain):
+        residual = all_critical_power_gain - self._all_critical_power_gain
+        self.physical_critical_power_gain += residual
+        self.magical_critical_power_gain += residual
+        self._all_critical_power_gain = all_critical_power_gain
+
+    @property
+    def physical_critical_power_base(self):
+        return self._physical_critical_power_base
+
+    @physical_critical_power_base.setter
+    def physical_critical_power_base(self, physical_critical_power_base):
+        self._physical_critical_power_base = physical_critical_power_base
+        self.physical_critical_power_percent = self.physical_critical_power_base / CRITICAL_POWER_SCALE
+
+    @property
+    def physical_critical_power_percent(self):
+        return CRITICAL_POWER_BASE + self._physical_critical_power_percent
+
+    @physical_critical_power_percent.setter
+    def physical_critical_power_percent(self, physical_critical_power_percent):
+        self._physical_critical_power_percent = physical_critical_power_percent
+        self.physical_critical_power = self.physical_critical_power_percent + self.physical_critical_power_gain
+
+    @property
+    def physical_critical_power_gain(self):
+        return self._physical_critical_power_gain / BINARY_SCALE
+
+    @physical_critical_power_gain.setter
+    def physical_critical_power_gain(self, physical_critical_power_gain):
+        self._physical_critical_power_gain = physical_critical_power_gain
+        self.physical_critical_power = self.physical_critical_power_percent + self.physical_critical_power_gain
+
+    @property
+    def physical_critical_power(self):
+        return self._physical_critical_power
+
+    @physical_critical_power.setter
+    def physical_critical_power(self, physical_critical_power):
+        self._physical_critical_power = physical_critical_power
+
+    @property
+    def magical_critical_power_base(self):
+        return self._magical_critical_power_base
+
+    @magical_critical_power_base.setter
+    def magical_critical_power_base(self, magical_critical_power_base):
+        self._magical_critical_power_base = magical_critical_power_base
+        self.magical_critical_power_percent = self.magical_critical_power_base / CRITICAL_POWER_SCALE
+
+    @property
+    def magical_critical_power_percent(self):
+        return CRITICAL_POWER_BASE + self._magical_critical_power_percent
+
+    @magical_critical_power_percent.setter
+    def magical_critical_power_percent(self, magical_critical_power_percent):
+        self._magical_critical_power_percent = magical_critical_power_percent
+        self.magical_critical_power = self.magical_critical_power_percent + self.magical_critical_power_gain
+
+    @property
+    def magical_critical_power_gain(self):
+        return self._magical_critical_power_gain / BINARY_SCALE
+
+    @magical_critical_power_gain.setter
+    def magical_critical_power_gain(self, magical_critical_power_gain):
+        self._magical_critical_power_gain = magical_critical_power_gain
+        self.magical_critical_power = self.magical_critical_power_percent + self.magical_critical_power_gain
+
+    @property
+    def magical_critical_power(self):
+        return self._magical_critical_power
+
+    @magical_critical_power.setter
+    def magical_critical_power(self, magical_critical_power):
+        self._magical_critical_power = magical_critical_power
+
     """ Weapon Damage Function """
 
     @property
@@ -870,73 +947,90 @@ class Attribute:
     def pve_addition(self, pve_addition):
         self._pve_addition = pve_addition
 
+
+class Attribute(Major, Minor, Target):
+    level: int = 120
+    grad_attrs: dict = None
+
+    def __init__(self):
+        self.all_major_base += MAJOR_BASE
+
     @property
-    def shield_base(self):
-        raise NotImplementedError
+    def level_reduction(self):
+        return LEVEL_REDUCTION * (self.target_level - self.level)
+
 
+class PhysicalAttribute(Attribute):
     @property
-    def physical_shield_base(self):
-        return SHIELD_BASE_MAP[self.target_level]
+    def attack_power(self):
+        return self.physical_attack_power
 
     @property
-    def magical_shield_base(self):
-        return SHIELD_BASE_MAP[self.target_level]
+    def critical_strike(self):
+        return self.physical_critical_strike
 
     @property
-    def shield_gain(self):
-        raise NotImplementedError
+    def critical_power(self):
+        return self.physical_critical_power
 
     @property
-    def physical_shield_gain(self):
-        return self._physical_shield_gain / BINARY_SCALE
+    def overcome(self):
+        return self.physical_overcome
 
-    @physical_shield_gain.setter
-    def physical_shield_gain(self, physical_shield_gain):
-        self._physical_shield_gain = physical_shield_gain
+    @property
+    def shield_ignore(self):
+        return self.physical_shield_ignore
 
     @property
-    def magical_shield_gain(self):
-        return self._magical_shield_gain / BINARY_SCALE
+    def damage_addition(self):
+        return self.physical_damage_addition
 
-    @magical_shield_gain.setter
-    def magical_shield_gain(self, magical_shield_gain):
-        self._magical_shield_gain = magical_shield_gain
+    @property
+    def shield_base(self):
+        return self.physical_shield_base
+
+    @property
+    def shield_gain(self):
+        return self.physical_shield_gain
 
     @property
     def vulnerable(self):
-        raise NotImplementedError
+        return self.physical_vulnerable
+
 
+class MagicalAttribute(Attribute):
     @property
-    def all_vulnerable(self):
-        return self._all_vulnerable
+    def attack_power(self):
+        return self.magical_attack_power
 
-    @all_vulnerable.setter
-    def all_vulnerable(self, all_vulnerable):
-        residual = all_vulnerable - self._all_vulnerable
-        self.physical_vulnerable += residual
-        self.magical_vulnerable += residual
-        self._all_vulnerable = all_vulnerable
+    @property
+    def critical_strike(self):
+        return self.magical_critical_strike
 
     @property
-    def physical_vulnerable(self):
-        return self._physical_vulnerable / BINARY_SCALE
+    def critical_power(self):
+        return self.magical_critical_power
 
-    @physical_vulnerable.setter
-    def physical_vulnerable(self, physical_vulnerable):
-        self._physical_vulnerable = physical_vulnerable
+    @property
+    def overcome(self):
+        return self.magical_overcome
 
     @property
-    def magical_vulnerable(self):
-        return self._magical_vulnerable / BINARY_SCALE
+    def shield_ignore(self):
+        return self.magical_shield_ignore
 
-    @magical_vulnerable.setter
-    def magical_vulnerable(self, magical_vulnerable):
-        self._magical_vulnerable = magical_vulnerable
+    @property
+    def damage_addition(self):
+        return self.magical_damage_addition
 
     @property
-    def level_reduction(self):
-        return LEVEL_REDUCTION * (self.target_level - self.level)
+    def shield_base(self):
+        return self.magical_shield_base
 
     @property
-    def shield_constant(self):
-        return SHIELD_SCALE * (LEVEL_SCALE * self.level - LEVEL_CONSTANT)
+    def shield_gain(self):
+        return self.magical_shield_gain
+
+    @property
+    def vulnerable(self):
+        return self.magical_vulnerable

base/calculator.py

@@ -2,30 +2,48 @@ from base.attribute import Attribute
 from parse import Parser
 
 
+def refresh_status(existed_buffs, buffs, attribute, parser: Parser):
+    for buff in [buff for buff in existed_buffs if buff not in buffs]:
+        existed_buffs.remove(buff)
+        buff_id, buff_level, buff_stack = buff
+        buff = parser.buffs[buff_id]
+        buff.buff_level = buff_level
+        for _ in range(buff_stack):
+            attribute, parser.skills = (attribute, parser.skills) - buff
+
+    for buff in [buff for buff in buffs if buff not in existed_buffs]:
+        existed_buffs.append(buff)
+        buff_id, buff_level, buff_stack = buff
+        buff = parser.buffs[buff_id]
+        buff.buff_level = buff_level
+        for _ in range(buff_stack):
+            attribute, parser.skills = (attribute, parser.skills) + buff
+
+
 def analyze_details(parser: Parser, attribute: Attribute):
     existed_buffs = []
-    for skill, status in parser.summary.items():
+    for skill, status in parser.records.items():
         skill_id, skill_level = skill
         skill = parser.skills[skill_id]
         skill.skill_level = skill_level
-        for buffs, count in status.items():
-            for buff in [buff for buff in existed_buffs if buff not in buffs]:
-                existed_buffs.remove(buff)
-                buff_id, buff_level, buff_stack = buff
-                buff = parser.buffs[buff_id]
-                buff.buff_level = buff_level
-                for _ in range(buff_stack):
-                    attribute, parser.skills = (attribute, parser.skills) - buff
-
-            for buff in [buff for buff in buffs if buff not in existed_buffs]:
-                existed_buffs.append(buff)
-                buff_id, buff_level, buff_stack = buff
-                buff = parser.buffs[buff_id]
-                buff.buff_level = buff_level
-                for _ in range(buff_stack):
-                    attribute, parser.skills = (attribute, parser.skills) + buff
+        for buffs, timeline in status.items():
+            refresh_status(existed_buffs, buffs, attribute, parser)
 
             damage, critical_damage, expected_damage = skill(attribute)
+
             status[buffs] = {
-                "damage": damage, "critical_damage": critical_damage, "expected_damage": expected_damage, "count": count
+                "damage": damage, "critical_damage": critical_damage, "expected_damage": expected_damage,
+                "timeline": [round(t / 1000, 2) for t in timeline],
+                "gradients": analyze_gradients(skill, attribute)
             }
+    refresh_status(existed_buffs, [], attribute, parser)
+
+
+def analyze_gradients(skill, attribute):
+    results = {}
+    for attr, value in attribute.grad_attrs.items():
+        origin_value = getattr(attribute, attr)
+        setattr(attribute, attr, origin_value + value)
+        _, _, results[attr] = skill(attribute)
+        setattr(attribute, attr, origin_value)
+    return results

base/skill.py

@@ -70,7 +70,10 @@ class Skill:
             cof = self._surplus_cof[self.skill_level - 1]
         else:
             cof = self._surplus_cof
-        return ((cof + int(cof < 0)) / BINARY_SCALE + BINARY_SCALE) / BINARY_SCALE * SURPLUS_SCALE
+        if cof:
+            return ((cof + int(cof < 0)) / BINARY_SCALE + BINARY_SCALE) / BINARY_SCALE * SURPLUS_SCALE
+        else:
+            return cof
 
     @surplus_cof.setter
     def surplus_cof(self, surplus_cof):

get_assets.py

@@ -0,0 +1,155 @@
+import json
+import os
+from functools import cache
+
+import requests
+from tqdm import tqdm
+
+from qt.constant import MAX_BASE_ATTR, MAX_MAGIC_ATTR, MAX_EMBED_ATTR, MAX_ENCHANT_ATTR, MAX_STONE_ATTR, \
+    MAX_STONE_LEVEL, ATTR_TYPE_MAP, ATTR_TYPE_TRANSLATE, STONE_ATTR
+from qt.constant import EQUIPMENTS_DIR, ENCHANTS_DIR, STONES_DIR
+
+EQUIP_ATTR_MAP = {
+    "Overcome": "破防",
+    "Critical": "会心",
+    "CriticalDamage": "会效",
+    "Haste": "加速",
+    "Surplus": "破招",
+    "Strain": "无双"
+}
+
+POSITION_MAP = {
+    "hat": 3,
+    "jacket": 2,
+    "belt": 6,
+    "wrist": 10,
+    "bottoms": 8,
+    "shoes": 9,
+    "necklace": 4,
+    "pendant": 7,
+    "ring": 5,
+    "tertiary_weapon": 1,
+    "primary_weapon": 0
+}
+
+SUFFIX_MAP = {
+    3: 'armor',
+    2: 'armor',
+    6: 'armor',
+    10: 'armor',
+    8: 'armor',
+    9: 'armor',
+    4: 'trinket',
+    7: 'trinket',
+    5: 'trinket',
+    1: 'weapon',
+    0: 'weapon'
+}
+SPECIAL_ENCHANT_MAP = {
+    "3": {
+        12800: "15436-11",
+        11500: "15436-10",
+        10600: "15436-9"
+    },
+    "2": {
+        12800: "22151-11",
+        11500: "22151-10",
+        10600: "22151-9"
+    },
+    "6": {
+        0: "22169"
+    },
+    "10": {
+        0: "22166"
+    },
+    "9": {
+        0: "33247"
+    },
+}
+
+equip_min_level = 11000
+equip_params = {
+    "client": "std",
+    "pv_type": 1,
+    "pz": 1,
+    "page": 1,
+    "per": 300,
+    "min_level": 9000,
+    "max_level": 15000
+}
+
+enchant_params = {
+    "client": "std",
+    "subtype": 1,
+    "latest_enhance": 1
+}
+
+
+# @cache
+def get_equips_list(position):
+    position_id = POSITION_MAP[position]
+    url = f"https://node.jx3box.com/equip/{SUFFIX_MAP[position_id]}"
+    params = equip_params.copy()
+    params['position'] = position_id
+    equips = []
+    res = requests.get(url, params=params).json()
+    equips.extend(res['list'])
+    while res['pages'] > params['page']:
+        params['page'] += 1
+        res = requests.get(url, params=params).json()
+        equips.extend(res['list'])
+    return equips
+
+
+@cache
+def get_enchants_list(position):
+    position_id = POSITION_MAP[position]
+    url = f"https://node.jx3box.com/enchant/primary"
+    params = enchant_params.copy()
+    params['position'] = position_id
+    res = requests.get(url, params=params)
+    enchants = [e for e in sorted(res.json(), key=lambda x: x['Score'], reverse=True) if
+                e['Attribute1ID'] in ATTR_TYPE_MAP]
+    return enchants
+
+
+def get_stones_list():
+    url = "https://node.jx3box.com/enchant/stone"
+
+    result = {}
+    for level in tqdm(range(MAX_STONE_LEVEL)):
+        level = level + 1
+        stones = []
+        params = {
+            "client": "std",
+            "level": level,
+            "page": 1,
+            "per": 100
+        }
+        res = requests.get(url, params=params).json()
+        stones.extend(res['list'])
+        while res['pages'] > params['page']:
+            params['page'] += 1
+            res = requests.get(url, params=params).json()
+            stones.extend(res['list'])
+
+    return result
+
+
+if __name__ == '__main__':
+    if not os.path.exists(EQUIPMENTS_DIR):
+        os.makedirs(EQUIPMENTS_DIR)
+    if not os.path.exists(ENCHANTS_DIR):
+        os.makedirs(ENCHANTS_DIR)
+
+    for pos in tqdm(POSITION_MAP):
+        json.dump(
+            get_equips_list(pos),
+            open(os.path.join(EQUIPMENTS_DIR, pos), "w", encoding="utf-8"), ensure_ascii=False
+        )
+        json.dump(
+            get_enchants_list(pos),
+            open(os.path.join(ENCHANTS_DIR, pos), "w", encoding="utf-8"), ensure_ascii=False
+        )
+
+    json.dump(get_stones_list(), open(STONES_DIR, "w", encoding="utf-8"), ensure_ascii=False)

parse.py

@@ -11,7 +11,7 @@ class Parser:
         self.skills = skills
         self.buffs = buffs
 
-        self.summary = {}
+        self.records = {}
         self.status = {}
 
         self.start_time = 0
@@ -19,9 +19,9 @@ class Parser:
 
     def parse_time(self, detail, timestamp):
         if detail[1]:
-            self.start_time = timestamp
+            self.start_time = int(timestamp)
         else:
-            self.end_time = timestamp
+            self.end_time = int(timestamp)
             return True
 
     def parse_buff(self, detail):
@@ -33,26 +33,27 @@ class Parser:
         else:
             self.status[(buff_id, buff_level)] = buff_stack
 
-    def parse_skill(self, detail):
+    def parse_skill(self, detail, timestamp):
         skill = detail[4], detail[5]
         if skill[0] not in self.skills:
             return
 
-        if skill not in self.summary:
-            self.summary[skill] = {}
+        if skill not in self.records:
+            self.records[skill] = {}
         status = tuple(
             (buff_id, buff_level, buff_stack) for (buff_id, buff_level), buff_stack in self.status.items()
         )
-        if status not in self.summary[skill]:
-            self.summary[skill][status] = 0
-        self.summary[skill][status] += 1
+        if status not in self.records[skill]:
+            self.records[skill][status] = []
+        self.records[skill][status].append(int(timestamp) - self.start_time)
 
-    def __call__(self, logs):
-        for row in logs:
+    def __call__(self, file_name):
+        for line in open(file_name):
+            row = line.split("\t")
             if row[4] == "5" and self.parse_time(unserialize(row[-1]), row[3]):
                 break
             elif row[4] == "13":
                 self.parse_buff(unserialize(row[-1]))
             elif row[4] == "21":
-                self.parse_skill(unserialize(row[-1]))
-        return self.summary
+                self.parse_skill(unserialize(row[-1]), row[3])
+        return self.records

schools/first/__init__.py

@@ -0,0 +1,2 @@
+from schools.first.skills import SKILLS
+from schools.first.buffs import BUFFS

schools/first/attribute.py

@@ -1,27 +1,27 @@
-from base.attribute import Attribute
+from base.attribute import PhysicalAttribute
 from base.constant import *
 
 
-class BeiAoJue(Attribute):
+class BeiAoJue(PhysicalAttribute):
     STRENGTH_TO_ATTACK_POWER = 1587 / BINARY_SCALE
     STRENGTH_TO_OVERCOME = 369 / BINARY_SCALE
 
     def __init__(self):
         super().__init__()
         self.physical_attack_power_base += 3725
-        self.pve_addition += 143 / BINARY_SCALE
+        self.pve_addition += 143
 
-        self.grad_attrs = [
-            "agility_base",
-            "strength_base",
-            "surplus",
-            "strain_base",
-            "physical_attack_power_base",
-            "physical_critical_strike_base",
-            "physical_critical_power_base",
-            "physical_overcome_base",
-            "weapon_damage_base"
-        ]
+        self.grad_attrs = {
+            "agility_base": MAJOR_DELTA,
+            "strength_base": MAJOR_DELTA,
+            "surplus": MINOR_DELTA,
+            "strain_base": MINOR_DELTA,
+            "physical_attack_power_base": PHYSICAL_DELTA,
+            "physical_critical_strike_base": MINOR_DELTA,
+            "physical_critical_power_base": MINOR_DELTA,
+            "physical_overcome_base": MINOR_DELTA,
+            "weapon_damage_base": WEAPON_DELTA
+        }
 
     @property
     def strength(self):
@@ -36,38 +36,3 @@ class BeiAoJue(Attribute):
         self._extra_physical_overcome = int(strength * self.STRENGTH_TO_OVERCOME)
         self.base_physical_overcome = self._physical_overcome_base + strength * STRENGTH_TO_OVERCOME
 
-    @property
-    def attack_power(self):
-        return self.physical_attack_power
-
-    @property
-    def critical_strike(self):
-        return self.physical_critical_strike
-
-    @property
-    def critical_power(self):
-        return self.physical_critical_power
-
-    @property
-    def overcome(self):
-        return self.physical_overcome
-
-    @property
-    def shield_ignore(self):
-        return self.physical_shield_ignore
-
-    @property
-    def damage_addition(self):
-        return self.physical_damage_addition
-
-    @property
-    def shield_base(self):
-        return self.physical_shield_base
-
-    @property
-    def shield_gain(self):
-        return self.physical_shield_gain
-
-    @property
-    def vulnerable(self):
-        return self.physical_vulnerable

schools/first/buffs.py

@@ -1,6 +1,6 @@
 from base.buff import Buff
 
-buffs = {
+BUFFS = {
     18384: {
         "buff_name": "含风",
         "gain_attributes": {
@@ -27,7 +27,7 @@ buffs = {
     }
 }
 
-for buff_id, detail in buffs.items():
-    buffs[buff_id] = Buff(buff_id, detail.pop("buff_name"))
+for buff_id, detail in BUFFS.items():
+    BUFFS[buff_id] = Buff(buff_id, detail.pop("buff_name"))
     for attr, value in detail.items():
-        setattr(buffs[buff_id], attr, value)
+        setattr(BUFFS[buff_id], attr, value)

schools/first/skills.py

@@ -1,6 +1,6 @@
 from base.skill import PhysicalDamage, PhysicalDotDamage
 
-skills = {
+SKILLS = {
     32823: {
         "skill_class": PhysicalDamage,
         "skill_name": "破",
@@ -282,7 +282,7 @@ skills = {
     }
 }
 
-for skill_id, detail in skills.items():
-    skills[skill_id] = detail.pop('skill_class')(skill_id, detail.pop('skill_name'))
+for skill_id, detail in SKILLS.items():
+    SKILLS[skill_id] = detail.pop('skill_class')(skill_id, detail.pop('skill_name'))
     for attr, value in detail.items():
-        setattr(skills[skill_id], attr, value)
+        setattr(SKILLS[skill_id], attr, value)

schools/first/test.py

@@ -1,8 +1,8 @@
 from base.calculator import analyze_details
 from parse import Parser
 from schools.first.attribute import BeiAoJue
-from schools.first.buffs import buffs
-from schools.first.skills import skills
+from schools.first.buffs import BUFFS
+from schools.first.skills import SKILLS
 
 
 if __name__ == '__main__':
@@ -17,7 +17,7 @@ if __name__ == '__main__':
     attribute.physical_overcome_base += 24303
     attribute.physical_critical_power_base += 7905
 
-    parser = Parser(skills, buffs)
-    summary = parser([line.split("\t") for line in open("logs.jcl")])
+    parser = Parser(SKILLS, BUFFS)
+    parser("logs.jcl")
     analyze_details(parser, attribute)
-    print(parser.summary)
+    print(parser.records)