first commit

base/attribute.py

@@ -0,0 +1,942 @@
+from base.constant import *
+
+
+class Attribute:
+    level: int = 120
+
+    _all_major_base: int = 0
+    _all_major_gain: int = 0
+    _agility_base: int = 0
+    _agility_gain: int = 0
+    _agility: int = 0
+    _strength_base: int = 0
+    _strength_gain: int = 0
+    _strength: int = 0
+    _spirit_base: int = 0
+    _spirit_gain: int = 0
+    _spirit: int = 0
+    _spunk_base: int = 0
+    _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
+    _extra_physical_attack_power: int = 0
+    _physical_attack_power: int = 0
+    _magical_attack_power_base: int = 0
+    _base_magical_attack_power: int = 0
+    _magical_attack_power_gain: int = 0
+    _extra_magical_attack_power: int = 0
+    _magical_attack_power: int = 0
+
+    _all_critical_strike_base: int = 0
+    _all_critical_strike_gain: int = 0
+
+    _physical_critical_strike_base: int = 0
+    _base_physical_critical_strike: int = 0
+    _extra_physical_critical_strike: int = 0
+    _physical_critical_strike_percent: float = 0
+    _physical_critical_strike_gain: int = 0
+    _physical_critical_strike: float = 0
+    _magical_critical_strike_base: int = 0
+    _base_magical_critical_strike: int = 0
+    _extra_magical_critical_strike: int = 0
+    _magical_critical_strike_percent: float = 0
+    _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
+    _physical_overcome_gain: int = 0
+    _extra_physical_overcome: int = 0
+    _physical_overcome: float = 0
+    _magical_overcome_base: int = 0
+    _base_magical_overcome: int = 0
+    _final_magical_overcome: int = 0
+    _magical_overcome_gain: int = 0
+    _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
+
+    @all_major_base.setter
+    def all_major_base(self, all_major_base):
+        residual = all_major_base - self._all_major_base
+        self.agility_base += residual
+        self.strength_base += residual
+        self.spirit_base += residual
+        self.spunk_base += residual
+        self._all_major_base = all_major_base
+
+    @property
+    def all_major_gain(self):
+        return self._all_major_gain
+
+    @all_major_gain.setter
+    def all_major_gain(self, all_major_gain):
+        residual = all_major_gain - self._all_major_gain
+        self.agility_gain += residual
+        self.strength_gain += residual
+        self.spirit_gain += residual
+        self.spunk_gain += residual
+        self._all_major_gain = all_major_gain
+
+    @property
+    def agility_base(self):
+        return self._agility_base
+
+    @agility_base.setter
+    def agility_base(self, agility_base):
+        self._agility_base = agility_base
+        self.agility = agility_base * (1 + self.agility_gain)
+
+    @property
+    def agility_gain(self):
+        return self._agility_gain / BINARY_SCALE
+
+    @agility_gain.setter
+    def agility_gain(self, agility_gain):
+        self._agility_gain = agility_gain
+        self.agility = self.agility_base * (1 + self.agility_gain)
+
+    @property
+    def agility(self):
+        return self._agility
+
+    @agility.setter
+    def agility(self, agility):
+        agility = int(agility)
+        self._agility = agility
+        self.base_physical_critical_strike = (self.physical_critical_strike_base + self.extra_physical_critical_strike
+                                              + agility * AGILITY_TO_CRITICAL_STRIKE)
+
+    @property
+    def strength_base(self):
+        return self._strength_base
+
+    @strength_base.setter
+    def strength_base(self, strength_base):
+        self._strength_base = strength_base
+        self.strength = strength_base * (1 + self.strength_gain)
+
+    @property
+    def strength_gain(self):
+        return self._strength_gain / BINARY_SCALE
+
+    @strength_gain.setter
+    def strength_gain(self, strength_gain):
+        self._strength_gain = strength_gain
+        self.strength = self.strength_base * (1 + self.strength_gain)
+
+    @property
+    def strength(self):
+        return self._strength
+
+    @strength.setter
+    def strength(self, strength):
+        strength = int(strength)
+        self._strength = strength
+        self.base_physical_attack_power = self.physical_attack_power_base + strength * STRENGTH_TO_ATTACK_POWER
+        self.base_physical_overcome = self.physical_overcome_base + strength * STRENGTH_TO_OVERCOME
+
+    @property
+    def spirit_base(self):
+        return self._spirit_base
+
+    @spirit_base.setter
+    def spirit_base(self, spirit_base):
+        self._spirit_base = spirit_base
+        self.spirit = spirit_base * (1 + self.spirit_gain)
+
+    @property
+    def spirit_gain(self):
+        return self._spirit_gain / BINARY_SCALE
+
+    @spirit_gain.setter
+    def spirit_gain(self, spirit_gain):
+        self._spirit_gain = spirit_gain
+        self.spirit = self.spirit_base * (1 + self.spirit_gain)
+
+    @property
+    def spirit(self):
+        return self._spirit
+
+    @spirit.setter
+    def spirit(self, spirit):
+        spirit = int(spirit)
+        self._spirit = spirit
+        self.base_magical_critical_strike = (self.magical_critical_strike_base + self.extra_magical_critical_strike
+                                             + spirit * SPIRIT_TO_CRITICAL_STRIKE)
+
+    @property
+    def spunk_base(self):
+        return self._spunk_base
+
+    @spunk_base.setter
+    def spunk_base(self, spunk_base):
+        self._spunk_base = spunk_base
+        self.spunk = spunk_base * (1 + self.spunk_gain)
+
+    @property
+    def spunk_gain(self):
+        return self._spunk_gain / BINARY_SCALE
+
+    @spunk_gain.setter
+    def spunk_gain(self, spunk_gain):
+        self._spunk_gain = spunk_gain
+        self.spunk = self.spunk_base * (1 + self.spunk_gain)
+
+    @property
+    def spunk(self):
+        return self._spunk
+
+    @spunk.setter
+    def spunk(self, spunk):
+        spunk = int(spunk)
+        self._spunk = spunk
+        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
+    def attack_power(self):
+        raise NotImplementedError
+
+    @property
+    def physical_attack_power_base(self):
+        return self._physical_attack_power_base
+
+    @physical_attack_power_base.setter
+    def physical_attack_power_base(self, physical_attack_power_base):
+        self._physical_attack_power_base = physical_attack_power_base
+        self.base_physical_attack_power = physical_attack_power_base + self.strength * STRENGTH_TO_ATTACK_POWER
+
+    @property
+    def base_physical_attack_power(self):
+        return self._base_physical_attack_power
+
+    @base_physical_attack_power.setter
+    def base_physical_attack_power(self, base_physical_attack_power):
+        base_physical_attack_power = int(base_physical_attack_power)
+        self._base_physical_attack_power = base_physical_attack_power
+        self.physical_attack_power = (self.base_physical_attack_power +
+                                      self.base_physical_attack_power * self.physical_attack_power_gain +
+                                      self.extra_physical_attack_power)
+
+    @property
+    def physical_attack_power_gain(self):
+        return self._physical_attack_power_gain / BINARY_SCALE
+
+    @physical_attack_power_gain.setter
+    def physical_attack_power_gain(self, physical_attack_power_gain):
+        self._physical_attack_power_gain = physical_attack_power_gain
+        self.physical_attack_power = (self.base_physical_attack_power +
+                                      self.base_physical_attack_power * self.physical_attack_power_gain +
+                                      self.extra_physical_attack_power)
+
+    @property
+    def extra_physical_attack_power(self):
+        return self._extra_physical_attack_power
+
+    @extra_physical_attack_power.setter
+    def extra_physical_attack_power(self, extra_physical_attack_power):
+        extra_physical_attack_power = int(extra_physical_attack_power)
+        self._extra_physical_attack_power = extra_physical_attack_power
+        self.physical_attack_power = (self.base_physical_attack_power +
+                                      self.base_physical_attack_power * self.physical_attack_power_gain +
+                                      self.extra_physical_attack_power)
+
+    @property
+    def physical_attack_power(self):
+        return self._physical_attack_power
+
+    @physical_attack_power.setter
+    def physical_attack_power(self, physical_attack_power):
+        self._physical_attack_power = int(physical_attack_power)
+
+    @property
+    def magical_attack_power_base(self):
+        return self._magical_attack_power_base
+
+    @magical_attack_power_base.setter
+    def magical_attack_power_base(self, magical_attack_power_base):
+        self._magical_attack_power_base = magical_attack_power_base
+        self.base_magical_attack_power = magical_attack_power_base + self.spunk_base * SPUNK_TO_ATTACK_POWER
+
+    @property
+    def base_magical_attack_power(self):
+        return self._base_magical_attack_power
+
+    @base_magical_attack_power.setter
+    def base_magical_attack_power(self, base_magical_attack_power):
+        base_magical_attack_power = int(base_magical_attack_power)
+        self._base_magical_attack_power = base_magical_attack_power
+        self.magical_attack_power = (self.base_magical_attack_power +
+                                     self.base_magical_attack_power * self.magical_attack_power_gain +
+                                     self.extra_magical_attack_power)
+
+    @property
+    def magical_attack_power_gain(self):
+        return self._magical_attack_power_gain / BINARY_SCALE
+
+    @magical_attack_power_gain.setter
+    def magical_attack_power_gain(self, magical_attack_power_gain):
+        self._magical_attack_power_gain = magical_attack_power_gain
+        self.magical_attack_power = (self.base_magical_attack_power +
+                                     self.base_magical_attack_power * self.magical_attack_power_gain +
+                                     self.extra_magical_attack_power)
+
+    @property
+    def extra_magical_attack_power(self):
+        return self._extra_magical_attack_power
+
+    @extra_magical_attack_power.setter
+    def extra_magical_attack_power(self, extra_magical_attack_power):
+        extra_magical_attack_power = int(extra_magical_attack_power)
+        self._extra_magical_attack_power = extra_magical_attack_power
+        self.magical_attack_power = (self.base_magical_attack_power +
+                                     self.base_magical_attack_power * self.magical_attack_power_gain +
+                                     self.extra_magical_attack_power)
+
+    @property
+    def magical_attack_power(self):
+        return self._magical_attack_power
+
+    @magical_attack_power.setter
+    def magical_attack_power(self, magical_attack_power):
+        self._magical_attack_power = int(magical_attack_power)
+
+    """ Critical Strike Function"""
+
+    @property
+    def critical_strike(self):
+        raise NotImplementedError
+
+    @property
+    def all_critical_strike_base(self):
+        return self._all_critical_strike_base
+
+    @all_critical_strike_base.setter
+    def all_critical_strike_base(self, all_critical_strike_base):
+        residual = all_critical_strike_base - self._all_critical_strike_base
+        self.physical_critical_strike_base += residual
+        self.magical_critical_strike_base += residual
+        self._all_critical_strike_base = all_critical_strike_base
+
+    @property
+    def all_critical_strike_gain(self):
+        return self._all_critical_strike_gain
+
+    @all_critical_strike_gain.setter
+    def all_critical_strike_gain(self, all_critical_strike_gain):
+        residual = all_critical_strike_gain - self._all_critical_strike_gain
+        self.physical_critical_strike_gain += residual
+        self.magical_critical_strike_gain += residual
+        self._all_critical_strike_gain = all_critical_strike_gain
+
+    @property
+    def physical_critical_strike_base(self):
+        return self._physical_critical_strike_base
+
+    @physical_critical_strike_base.setter
+    def physical_critical_strike_base(self, physical_critical_strike_base):
+        self._physical_critical_strike_base = physical_critical_strike_base
+        self.base_physical_critical_strike = (self.physical_critical_strike_base + self.extra_physical_critical_strike
+                                              + self.agility * AGILITY_TO_CRITICAL_STRIKE)
+
+    @property
+    def extra_physical_critical_strike(self):
+        return self._extra_physical_critical_strike
+
+    @extra_physical_critical_strike.setter
+    def extra_physical_critical_strike(self, extra_physical_critical_strike):
+        extra_physical_critical_strike = int(extra_physical_critical_strike)
+        self._extra_physical_critical_strike = extra_physical_critical_strike
+        self.base_physical_critical_strike = (self.physical_critical_strike_base + self.extra_physical_critical_strike
+                                              + self.agility * AGILITY_TO_CRITICAL_STRIKE)
+
+    @property
+    def base_physical_critical_strike(self):
+        return self._base_physical_critical_strike
+
+    @base_physical_critical_strike.setter
+    def base_physical_critical_strike(self, base_physical_critical_strike):
+        base_physical_critical_strike = int(base_physical_critical_strike)
+        self._base_physical_critical_strike = base_physical_critical_strike
+        self.physical_critical_strike_percent = self.base_physical_critical_strike / CRITICAL_STRIKE_SCALE
+
+    @property
+    def physical_critical_strike_percent(self):
+        return self._physical_critical_strike_percent
+
+    @physical_critical_strike_percent.setter
+    def physical_critical_strike_percent(self, physical_critical_strike_percent):
+        self._physical_critical_strike_percent = physical_critical_strike_percent
+        self.physical_critical_strike = self.physical_critical_strike_percent + self.physical_critical_strike_gain
+
+    @property
+    def physical_critical_strike_gain(self):
+        return self._physical_critical_strike_gain / DECIMAL_SCALE
+
+    @physical_critical_strike_gain.setter
+    def physical_critical_strike_gain(self, physical_critical_strike_gain):
+        self._physical_critical_strike_gain = physical_critical_strike_gain
+        self.physical_critical_strike = self.physical_critical_strike_percent + self.physical_critical_strike_gain
+
+    @property
+    def physical_critical_strike(self):
+        return self._physical_critical_strike
+
+    @physical_critical_strike.setter
+    def physical_critical_strike(self, physical_critical_strike):
+        self._physical_critical_strike = physical_critical_strike
+
+    @property
+    def magical_critical_strike_base(self):
+        return self._magical_critical_strike_base
+
+    @magical_critical_strike_base.setter
+    def magical_critical_strike_base(self, magical_critical_strike_base):
+        self._magical_critical_strike_base = magical_critical_strike_base
+        self.base_magical_critical_strike = (self.magical_critical_strike_base + self.extra_magical_critical_strike
+                                             + self.spirit * SPIRIT_TO_CRITICAL_STRIKE)
+
+    @property
+    def extra_magical_critical_strike(self):
+        return self._extra_magical_critical_strike
+
+    @extra_magical_critical_strike.setter
+    def extra_magical_critical_strike(self, extra_magical_critical_strike):
+        extra_magical_critical_strike = int(extra_magical_critical_strike)
+        self._extra_magical_critical_strike = extra_magical_critical_strike
+        self.base_magical_critical_strike = (self.magical_critical_strike_base + self.extra_magical_critical_strike
+                                             + self.spirit * SPIRIT_TO_CRITICAL_STRIKE)
+
+    @property
+    def base_magical_critical_strike(self):
+        return self._base_magical_critical_strike
+
+    @base_magical_critical_strike.setter
+    def base_magical_critical_strike(self, base_magical_critical_strike):
+        base_magical_critical_strike = int(base_magical_critical_strike)
+        self._base_magical_critical_strike = base_magical_critical_strike
+        self.magical_critical_strike_percent = self.base_magical_critical_strike / CRITICAL_STRIKE_SCALE
+
+    @property
+    def magical_critical_strike_percent(self):
+        return self._magical_critical_strike_percent
+
+    @magical_critical_strike_percent.setter
+    def magical_critical_strike_percent(self, magical_critical_strike_percent):
+        self._magical_critical_strike_percent = magical_critical_strike_percent
+        self.magical_critical_strike = self.magical_critical_strike_percent + self.magical_critical_strike_gain
+
+    @property
+    def magical_critical_strike_gain(self):
+        return self._magical_critical_strike_gain / DECIMAL_SCALE
+
+    @magical_critical_strike_gain.setter
+    def magical_critical_strike_gain(self, magical_critical_strike_gain):
+        self._magical_critical_strike_gain = magical_critical_strike_gain
+        self.magical_critical_strike = self.magical_critical_strike_percent + self.magical_critical_strike_gain
+
+    @property
+    def magical_critical_strike(self):
+        return self._magical_critical_strike
+
+    @magical_critical_strike.setter
+    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
+    def overcome(self):
+        raise NotImplementedError
+
+    @property
+    def physical_overcome_base(self):
+        return self._physical_overcome_base
+
+    @physical_overcome_base.setter
+    def physical_overcome_base(self, physical_overcome_base):
+        self._physical_overcome_base = physical_overcome_base
+        self.base_physical_overcome = self.physical_overcome_base + self.strength * STRENGTH_TO_OVERCOME
+
+    @property
+    def base_physical_overcome(self):
+        return self._base_physical_overcome
+
+    @base_physical_overcome.setter
+    def base_physical_overcome(self, base_physical_overcome):
+        base_physical_overcome = int(base_physical_overcome)
+        self._base_physical_overcome = base_physical_overcome
+        self.final_physical_overcome = (self.base_physical_overcome * (1 + self.physical_overcome_gain)
+                                        + self.extra_physical_overcome)
+
+    @property
+    def physical_overcome_gain(self):
+        return self._physical_overcome_gain / BINARY_SCALE
+
+    @physical_overcome_gain.setter
+    def physical_overcome_gain(self, physical_overcome_gain):
+        self._physical_overcome_gain = physical_overcome_gain
+        self.final_physical_overcome = (self.base_physical_overcome * (1 + self.physical_overcome_gain)
+                                        + self.extra_physical_overcome)
+
+    @property
+    def extra_physical_overcome(self):
+        return self._extra_physical_overcome
+
+    @extra_physical_overcome.setter
+    def extra_physical_overcome(self, extra_physical_overcome):
+        extra_physical_overcome = int(extra_physical_overcome)
+        self._extra_physical_overcome = extra_physical_overcome
+        self.final_physical_overcome = (self.base_physical_overcome * (1 + self.physical_overcome_gain)
+                                        + self.extra_physical_overcome)
+
+    @property
+    def final_physical_overcome(self):
+        return self._final_physical_overcome
+
+    @final_physical_overcome.setter
+    def final_physical_overcome(self, final_physical_overcome):
+        final_physical_overcome = int(final_physical_overcome)
+        self._final_physical_overcome = final_physical_overcome
+        self.physical_overcome = final_physical_overcome / OVERCOME_SCALE
+
+    @property
+    def physical_overcome(self):
+        return self._physical_overcome
+
+    @physical_overcome.setter
+    def physical_overcome(self, physical_overcome):
+        self._physical_overcome = physical_overcome
+
+    @property
+    def magical_overcome_base(self):
+        return self._magical_overcome_base
+
+    @magical_overcome_base.setter
+    def magical_overcome_base(self, magical_overcome_base):
+        self._magical_overcome_base = magical_overcome_base
+        self.base_magical_overcome = self.magical_overcome_base + self.spunk * SPUNK_TO_OVERCOME
+
+    @property
+    def base_magical_overcome(self):
+        return self._base_magical_overcome
+
+    @base_magical_overcome.setter
+    def base_magical_overcome(self, base_magical_overcome):
+        base_magical_overcome = int(base_magical_overcome)
+        self._base_magical_overcome = base_magical_overcome
+        self.final_magical_overcome = (self.base_magical_overcome * (1 + self.magical_overcome_gain)
+                                       + self.extra_magical_overcome)
+
+    @property
+    def magical_overcome_gain(self):
+        return self._magical_overcome_gain / BINARY_SCALE
+
+    @magical_overcome_gain.setter
+    def magical_overcome_gain(self, magical_overcome_gain):
+        self._magical_overcome_gain = magical_overcome_gain
+        self.final_magical_overcome = (self.base_magical_overcome * (1 + self.magical_overcome_gain)
+                                       + self.extra_magical_overcome)
+
+    @property
+    def extra_magical_overcome(self):
+        return self._extra_magical_overcome
+
+    @extra_magical_overcome.setter
+    def extra_magical_overcome(self, extra_magical_overcome):
+        extra_magical_overcome = int(extra_magical_overcome)
+        self._extra_magical_overcome = extra_magical_overcome
+        self.final_magical_overcome = (self.base_magical_overcome * (1 + self.magical_overcome_gain)
+                                       + self.extra_magical_overcome)
+
+    @property
+    def final_magical_overcome(self):
+        return self._final_magical_overcome
+
+    @final_magical_overcome.setter
+    def final_magical_overcome(self, final_magical_overcome):
+        final_magical_overcome = int(final_magical_overcome)
+        self._final_magical_overcome = final_magical_overcome
+        self.magical_overcome = final_magical_overcome / OVERCOME_SCALE
+
+    @property
+    def magical_overcome(self):
+        return self._magical_overcome
+
+    @magical_overcome.setter
+    def magical_overcome(self, magical_overcome):
+        self._magical_overcome = magical_overcome
+
+    """ Weapon Damage Function """
+
+    @property
+    def weapon_damage_rand(self):
+        return self._weapon_damage_rand
+
+    @weapon_damage_rand.setter
+    def weapon_damage_rand(self, weapon_damage_rand):
+        self._weapon_damage_rand = weapon_damage_rand
+        self.weapon_damage = self.weapon_damage_base * (1 + self.weapon_damage_gain) + self.weapon_damage_rand / 2
+
+    @property
+    def weapon_damage_base(self):
+        return self._weapon_damage_base
+
+    @weapon_damage_base.setter
+    def weapon_damage_base(self, weapon_damage_base):
+        self._weapon_damage_base = weapon_damage_base
+        self.weapon_damage = self.weapon_damage_base * (1 + self.weapon_damage_gain) + self.weapon_damage_rand / 2
+
+    @property
+    def weapon_damage_gain(self):
+        return self._weapon_damage_gain / BINARY_SCALE
+
+    @weapon_damage_gain.setter
+    def weapon_damage_gain(self, weapon_damage_gain):
+        self._weapon_damage_gain = weapon_damage_gain
+        self.weapon_damage = self.weapon_damage_base * (1 + self.weapon_damage_gain) + self.weapon_damage_rand / 2
+
+    @property
+    def weapon_damage(self):
+        return self._weapon_damage
+
+    @weapon_damage.setter
+    def weapon_damage(self, weapon_damage):
+        self._weapon_damage = int(weapon_damage)
+
+    """ Others """
+
+    @property
+    def shield_ignore(self):
+        raise NotImplementedError
+
+    @property
+    def all_shield_ignore(self):
+        return self._all_shield_ignore
+
+    @all_shield_ignore.setter
+    def all_shield_ignore(self, all_shield_ignore):
+        residual = all_shield_ignore - self._all_shield_ignore
+        self.physical_shield_ignore += residual
+        self.magical_shield_ignore += residual
+        self._all_shield_ignore = all_shield_ignore
+
+    @property
+    def physical_shield_ignore(self):
+        return self._physical_shield_ignore / BINARY_SCALE
+
+    @physical_shield_ignore.setter
+    def physical_shield_ignore(self, physical_shield_ignore):
+        self._physical_shield_ignore = physical_shield_ignore
+
+    @property
+    def magical_shield_ignore(self):
+        return self._magical_shield_ignore / BINARY_SCALE
+
+    @magical_shield_ignore.setter
+    def magical_shield_ignore(self, magical_shield_ignore):
+        self._magical_shield_ignore = magical_shield_ignore
+
+    @property
+    def damage_addition(self):
+        raise NotImplementedError
+
+    @property
+    def all_damage_addition(self):
+        return self._all_damage_addition
+
+    @all_damage_addition.setter
+    def all_damage_addition(self, all_damage_addition):
+        residual = all_damage_addition - self._all_damage_addition
+        self.physical_damage_addition += residual
+        self.magical_damage_addition += residual
+        self._all_damage_addition = all_damage_addition
+
+    @property
+    def physical_damage_addition(self):
+        return self._physical_damage_addition / BINARY_SCALE
+
+    @physical_damage_addition.setter
+    def physical_damage_addition(self, physical_damage_addition):
+        self._physical_damage_addition = physical_damage_addition
+
+    @property
+    def magical_damage_addition(self):
+        return self._magical_damage_addition / BINARY_SCALE
+
+    @magical_damage_addition.setter
+    def magical_damage_addition(self, magical_damage_addition):
+        self._magical_damage_addition = magical_damage_addition
+
+    @property
+    def pve_addition(self):
+        return self._pve_addition / BINARY_SCALE
+
+    @pve_addition.setter
+    def pve_addition(self, pve_addition):
+        self._pve_addition = pve_addition
+
+    @property
+    def shield_base(self):
+        raise NotImplementedError
+
+    @property
+    def physical_shield_base(self):
+        return SHIELD_BASE_MAP[self.target_level]
+
+    @property
+    def magical_shield_base(self):
+        return SHIELD_BASE_MAP[self.target_level]
+
+    @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 level_reduction(self):
+        return LEVEL_REDUCTION * (self.target_level - self.level)
+
+    @property
+    def shield_constant(self):
+        return SHIELD_SCALE * (LEVEL_SCALE * self.level - LEVEL_CONSTANT)

base/buff.py

@@ -0,0 +1,43 @@
+from dataclasses import dataclass
+from typing import Dict, List, Union, Tuple
+
+from base.attribute import Attribute
+from base.skill import Skill
+
+ATTR_DICT = Dict[str, Union[List[int], int]]
+
+
+@dataclass
+class Buff:
+    buff_id: int
+    buff_name: str
+    buff_level: int = 0
+
+    stack: int = 1
+
+    gain_skills: Dict[str, ATTR_DICT] = None
+    gain_attributes: ATTR_DICT = None
+
+    def __post_init__(self):
+        self.gain_skills = {}
+        self.gain_attributes = {}
+
+    def __radd__(self, other: Tuple[Attribute, Dict[str, Skill]]):
+        attribute, skills = other
+        for skill_id, gain in self.gain_skills.items():
+            skill = skills[skill_id]
+            for attr, value in gain.items():
+                setattr(skill, attr, getattr(skill, attr) + value)
+        for attr, value in self.gain_attributes.items():
+            setattr(attribute, attr, getattr(attribute, attr) + value)
+        return attribute, skills
+
+    def __rsub__(self, other: Tuple[Attribute, Dict[str, Skill]]):
+        attribute, skills = other
+        for skill_id, gain in self.gain_skills.items():
+            skill = skills[skill_id]
+            for attr, value in gain.items():
+                setattr(skill, attr, getattr(skill, attr) - value)
+        for attr, value in self.gain_attributes.items():
+            setattr(attribute, attr, getattr(attribute, attr) - value)
+        return attribute, skills

base/calculator.py

@@ -0,0 +1,31 @@
+from base.attribute import Attribute
+from parse import Parser
+
+
+def analyze_details(parser: Parser, attribute: Attribute):
+    existed_buffs = []
+    for skill, status in parser.summary.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
+
+            damage, critical_damage, expected_damage = skill(attribute)
+            status[buffs] = {
+                "damage": damage, "critical_damage": critical_damage, "expected_damage": expected_damage, "count": count
+            }

base/constant.py

@@ -0,0 +1,68 @@
+BINARY_SCALE = 1024
+DECIMAL_SCALE = 10000
+
+FRAME_PER_SECOND = 16
+
+LEVEL = 120
+LEVEL_SCALE = 450
+LEVEL_CONSTANT = 45750
+LEVEL_REDUCTION = 0.05
+
+DOT_DAMAGE_SCALE = 12
+PHYSICAL_DAMAGE_SCALE = 10
+MAGICAL_DAMAGE_SCALE = 12
+
+MAX_GCD_GROUP = 10
+
+CRITICAL_STRIKE_SCALE = 9.530 * (LEVEL_SCALE * LEVEL - LEVEL_CONSTANT)
+CRITICAL_POWER_SCALE = 3.335 * (LEVEL_SCALE * LEVEL - LEVEL_CONSTANT)
+OVERCOME_SCALE = 9.530 * (LEVEL_SCALE * LEVEL - LEVEL_CONSTANT)
+HASTE_SCALE = 11.695 * (LEVEL_SCALE * LEVEL - LEVEL_CONSTANT)
+STRAIN_SCALE = 9.189 * (LEVEL_SCALE * LEVEL - LEVEL_CONSTANT)
+SURPLUS_SCALE = 13.192
+
+SHIELD_SCALE = 5.091
+
+SHIELD_BASE_MAP = {
+    124: 27550,
+    123: 26317,
+    122: 15528,
+    121: 11073
+}
+
+MAJOR_BASE = 41
+CRITICAL_POWER_BASE = 1.75
+
+AGILITY_TO_CRITICAL_STRIKE = 655 / BINARY_SCALE
+STRENGTH_TO_ATTACK_POWER = 153 / BINARY_SCALE
+STRENGTH_TO_OVERCOME = 307 / BINARY_SCALE
+SPIRIT_TO_CRITICAL_STRIKE = 655 / BINARY_SCALE
+SPUNK_TO_ATTACK_POWER = 184 / BINARY_SCALE
+SPUNK_TO_OVERCOME = 307 / BINARY_SCALE
+
+DELTA_SCALE = 1
+MAJOR_DELTA = 198
+PHYSICAL_DELTA = 398
+MAGICAL_DELTA = 475
+MINOR_DELTA = 883
+WEAPON_DELTA = 597
+
+
+def PHYSICAL_ATTACK_POWER_COF(cof):
+    return cof / FRAME_PER_SECOND / PHYSICAL_DAMAGE_SCALE
+
+
+def PHYSICAL_DOT_ATTACK_POWER_COF(cof, interval):
+    return PHYSICAL_ATTACK_POWER_COF(cof * interval / FRAME_PER_SECOND / DOT_DAMAGE_SCALE)
+
+
+def MAGICAL_ATTACK_POWER_COF(cof):
+    return cof / FRAME_PER_SECOND / MAGICAL_DAMAGE_SCALE
+
+
+def MAGICAL_DOT_ATTACK_POWER_COF(cof, interval):
+    return MAGICAL_ATTACK_POWER_COF(cof * interval / FRAME_PER_SECOND / DOT_DAMAGE_SCALE)
+
+
+def WEAPON_DAMAGE_COF(cof):
+    return cof / BINARY_SCALE

base/damage.py

@@ -0,0 +1,84 @@
+from functools import cache
+
+
+@cache
+def defense(shield_base, shield_gain, shield_ignore, shield_constant):
+    shield = shield_base
+    shield += int(shield * shield_gain)
+    shield -= int(shield * shield_ignore)
+    return max(0, shield / (shield + shield_constant))
+
+
+@cache
+def base_result(damage_base, damage_rand, damage_gain):
+    damage = damage_base + damage_rand / 2
+    damage += damage * damage_gain
+    return int(damage)
+
+
+@cache
+def attack_power_result(attack_power_cof, attack_power_cof_gain, attack_power):
+    attack_power_cof += attack_power_cof * attack_power_cof_gain
+    damage = attack_power * attack_power_cof
+    return int(damage)
+
+
+@cache
+def weapon_damage_result(weapon_damage_cof, weapon_damage_cof_gain, weapon_damage):
+    weapon_damage_cof += weapon_damage_cof * weapon_damage_cof_gain
+    damage = weapon_damage * weapon_damage_cof
+    return int(damage)
+
+
+@cache
+def surplus_result(surplus_cof, surplus_cof_gain, surplus):
+    surplus_cof += surplus_cof * surplus_cof_gain
+    damage = surplus * surplus_cof
+    return int(damage)
+
+
+@cache
+def init_result(damage_base, damage_rand, damage_gain,
+                attack_power_cof, attack_power_cof_gain, attack_power,
+                weapon_damage_cof, weapon_damage_cof_gain, weapon_damage,
+                surplus_cof, surplus_cof_gain, surplus):
+    return (base_result(damage_base, damage_rand, damage_gain) +
+            attack_power_result(attack_power_cof, attack_power_cof_gain, attack_power) +
+            weapon_damage_result(weapon_damage_cof, weapon_damage_cof_gain, weapon_damage) +
+            surplus_result(surplus_cof, surplus_cof_gain, surplus))
+
+
+@cache
+def damage_addition_result(damage, damage_addition):
+    return int(damage * (1 + damage_addition))
+
+
+@cache
+def overcome_result(damage, overcome, shield_base, shield_gain, shield_ignore, shield_constant):
+    defense_reduction = defense(shield_base, shield_gain, shield_ignore, shield_constant)
+    return int(damage * (1 + overcome) * (1 - defense_reduction))
+
+
+@cache
+def critical_result(damage, critical_power):
+    return int(damage * critical_power)
+
+
+@cache
+def level_reduction_result(damage, level_reduction):
+    return int(damage * (1 - level_reduction))
+
+
+@cache
+def strain_result(damage, strain):
+    return int(damage * (1 + strain))
+
+
+@cache
+def pve_addition_result(damage, pve_addition):
+    return int(damage * (1 + pve_addition))
+
+
+@cache
+def vulnerable_result(damage, vulnerable):
+    return int(damage * (1 + vulnerable))

base/skill.py

@@ -0,0 +1,186 @@
+from base.attribute import Attribute
+from base.constant import *
+from base.damage import *
+
+from typing import List, Union
+from dataclasses import dataclass
+
+
+@dataclass
+class Skill:
+    skill_id: int
+    skill_name: str
+    skill_level: int = 0
+    
+    _damage_base: Union[List[int], int] = 0
+    _damage_rand: Union[List[int], int] = 0
+
+    _attack_power_cof: Union[List[float], float] = 0.
+    _surplus_cof: Union[List[float], float] = 0.
+    _weapon_damage_cof: Union[List[float], float] = 0.
+
+    interval: int = 0
+
+    damage_gain: float = 0.
+    attack_power_cof_gain: float = 0.
+    surplus_cof_gain: float = 0.
+    weapon_damage_cof_gain: float = 0.
+
+    _skill_damage_addition: int = 0
+    _skill_shield_gain: Union[List[int], int] = 0
+    _skill_critical_strike: int = 0
+    _skill_critical_power: int = 0
+
+    @property
+    def damage_base(self):
+        if isinstance(self._damage_base, list):
+            return self._damage_base[self.skill_level - 1]
+        else:
+            return self._damage_base
+
+    @damage_base.setter
+    def damage_base(self, damage_base):
+        self._damage_base = damage_base
+
+    @property
+    def damage_rand(self):
+        if isinstance(self._damage_rand, list):
+            return self._damage_rand[self.skill_level - 1]
+        else:
+            return self._damage_rand
+
+    @damage_rand.setter
+    def damage_rand(self, damage_rand):
+        self._damage_rand = damage_rand
+
+    @property
+    def attack_power_cof(self):
+        if isinstance(self._attack_power_cof, list):
+            return self._attack_power_cof[self.skill_level - 1]
+        else:
+            return self._attack_power_cof
+
+    @attack_power_cof.setter
+    def attack_power_cof(self, attack_power_cof):
+        self._attack_power_cof = attack_power_cof
+
+    @property
+    def surplus_cof(self):
+        if isinstance(self._surplus_cof, list):
+            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
+
+    @surplus_cof.setter
+    def surplus_cof(self, surplus_cof):
+        self._surplus_cof = surplus_cof
+
+    @property
+    def weapon_damage_cof(self):
+        if isinstance(self._weapon_damage_cof, list):
+            return self._weapon_damage_cof[self.skill_level - 1] / BINARY_SCALE
+        else:
+            return self._weapon_damage_cof / BINARY_SCALE
+
+    @weapon_damage_cof.setter
+    def weapon_damage_cof(self, weapon_damage_cof):
+        self._weapon_damage_cof = weapon_damage_cof
+
+    @property
+    def skill_damage_addition(self):
+        return self._skill_damage_addition / BINARY_SCALE
+
+    @skill_damage_addition.setter
+    def skill_damage_addition(self, skill_damage_addition):
+        self._skill_damage_addition = skill_damage_addition
+
+    @property
+    def skill_shield_gain(self):
+        if isinstance(self._skill_shield_gain, list):
+            return self._skill_shield_gain[self.skill_level - 1] / BINARY_SCALE
+        else:
+            return self._skill_shield_gain / BINARY_SCALE
+
+    @skill_shield_gain.setter
+    def skill_shield_gain(self, skill_shield_gain):
+        self._skill_shield_gain = skill_shield_gain
+
+    @property
+    def skill_critical_strike(self):
+        return self._skill_critical_strike / DECIMAL_SCALE
+
+    @skill_critical_strike.setter
+    def skill_critical_strike(self, skill_critical_strike):
+        self._skill_critical_strike = skill_critical_strike
+
+    @property
+    def skill_critical_power(self):
+        return self._skill_critical_power / BINARY_SCALE
+
+    @skill_critical_power.setter
+    def skill_critical_power(self, skill_critical_power):
+        self._skill_critical_power = skill_critical_power
+
+    def __call__(self, attribute: Attribute):
+        damage = init_result(
+            self.damage_base, self.damage_rand, self.damage_gain,
+            self.attack_power_cof, self.attack_power_cof_gain, attribute.attack_power,
+            self.weapon_damage_cof, self.weapon_damage_cof_gain, attribute.weapon_damage,
+            self.surplus_cof, self.surplus_cof_gain, attribute.surplus
+        )
+
+        damage = damage_addition_result(damage, attribute.damage_addition + self.skill_damage_addition)
+        damage = overcome_result(damage, attribute.overcome,
+                                 attribute.shield_base,
+                                 attribute.shield_gain + self.skill_shield_gain,
+                                 attribute.shield_ignore,
+                                 attribute.shield_constant)
+
+        critical_damage = critical_result(damage, attribute.critical_power + self.skill_critical_power)
+
+        damage = level_reduction_result(damage, attribute.level_reduction)
+        critical_damage = level_reduction_result(critical_damage, attribute.level_reduction)
+        damage = strain_result(damage, attribute.strain)
+        critical_damage = strain_result(critical_damage, attribute.strain)
+        damage = pve_addition_result(damage, attribute.pve_addition)
+        critical_damage = pve_addition_result(critical_damage, attribute.pve_addition)
+        damage = vulnerable_result(damage, attribute.vulnerable)
+        critical_damage = vulnerable_result(critical_damage, attribute.vulnerable)
+        critical_strike = min(1, attribute.critical_strike + self.skill_critical_strike)
+
+        expected_damage = critical_strike * critical_damage + (1 - critical_strike) * damage
+
+        return damage, critical_damage, expected_damage
+    
+    
+class PhysicalDamage(Skill):
+    @property
+    def attack_power_cof(self):
+        return PHYSICAL_ATTACK_POWER_COF(super().attack_power_cof + self.interval)
+
+    @attack_power_cof.setter
+    def attack_power_cof(self, attack_power_cof):
+        self._attack_power_cof = attack_power_cof
+
+
+class MagicalDamage(Skill):
+    @property
+    def attack_power_cof(self):
+        return MAGICAL_ATTACK_POWER_COF(super().attack_power_cof + self.interval)
+
+
+class PhysicalDotDamage(Skill):
+    @property
+    def attack_power_cof(self):
+        return PHYSICAL_DOT_ATTACK_POWER_COF(super().attack_power_cof, self.interval)
+
+    @attack_power_cof.setter
+    def attack_power_cof(self, attack_power_cof):
+        self._attack_power_cof = attack_power_cof
+
+
+class MagicalDotDamage(Skill):
+    @property
+    def attack_power_cof(self):
+        return MAGICAL_DOT_ATTACK_POWER_COF(super().attack_power_cof, self.interval)

parse.py

@@ -0,0 +1,58 @@
+from typing import Dict
+
+from luadata import unserialize
+
+from base.buff import Buff
+from base.skill import Skill
+
+
+class Parser:
+    def __init__(self, skills: Dict[str, Skill], buffs: Dict[str, Buff]):
+        self.skills = skills
+        self.buffs = buffs
+
+        self.summary = {}
+        self.status = {}
+
+        self.start_time = 0
+        self.end_time = 0
+
+    def parse_time(self, detail, timestamp):
+        if detail[1]:
+            self.start_time = timestamp
+        else:
+            self.end_time = timestamp
+            return True
+
+    def parse_buff(self, detail):
+        buff_id, buff_stack, buff_level = detail[4], detail[5], detail[8]
+        if buff_id not in self.buffs:
+            return
+        if not buff_stack:
+            self.status.pop((buff_id, buff_level))
+        else:
+            self.status[(buff_id, buff_level)] = buff_stack
+
+    def parse_skill(self, detail):
+        skill = detail[4], detail[5]
+        if skill[0] not in self.skills:
+            return
+
+        if skill not in self.summary:
+            self.summary[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
+
+    def __call__(self, logs):
+        for row in logs:
+            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

schools/first/attribute.py

@@ -0,0 +1,73 @@
+from base.attribute import Attribute
+from base.constant import *
+
+
+class BeiAoJue(Attribute):
+    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.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"
+        ]
+
+    @property
+    def strength(self):
+        return self._strength
+
+    @strength.setter
+    def strength(self, strength):
+        strength = int(strength)
+        self._strength = strength
+        self._extra_physical_attack_power = int(strength * self.STRENGTH_TO_ATTACK_POWER)
+        self.base_physical_attack_power = self._physical_attack_power_base + strength * STRENGTH_TO_ATTACK_POWER
+        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

@@ -0,0 +1,33 @@
+from base.buff import Buff
+
+buffs = {
+    18384: {
+        "buff_name": "含风",
+        "gain_attributes": {
+            "physical_critical_strike_gain": 1000,
+            "physical_critical_power_gain": 102
+        }
+    },
+    23066: {
+        "buff_name": "含风",
+        "gain_skills": {
+            16787: {
+                "skill_damage_addition": 102,
+            },
+            16610: {
+                "skill_damage_addition": 102,
+            }
+        }
+    },
+    14972: {
+        "buff_name": "爆体",
+        "gain_attributes": {
+            "all_damage_addition": 205
+        }
+    }
+}
+
+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)

schools/first/skills.py

@@ -0,0 +1,288 @@
+from base.skill import PhysicalDamage, PhysicalDotDamage
+
+skills = {
+    32823: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "破",
+        "surplus_cof": [
+            1048576 * (0.875 - 1),
+            1048576 * (0.1375 - 1),
+            1048576 * (0.275 - 1),
+            1048576 * (0.4375 * 1.2 - 1)
+        ]
+    },
+    16419: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "霜风刀法",
+        "attack_power_cof": 16,
+        "weapon_damage_cof": 1024
+    },
+    16820: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "霜风刀法",
+        "attack_power_cof": 16,
+        "weapon_damage_cof": 1024
+    },
+    16822: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "霜风刀法",
+        "attack_power_cof": 16,
+        "weapon_damage_cof": 1024
+    },
+    16631: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "雷走风切",
+        "damage_base": [35, 45, 55, 70, 85, 100, 115, 130, 145, 175],
+        "damage_rand": [5, 5, 5, 5, 5, 10, 10, 10, 10, 15],
+        "attack_power_cof": [45 * 0.8 * 0.7] +
+                            [(16 + (i - 1) * 17) * 0.8 * 0.7 for i in range(2, 10)] +
+                            [224 * 0.8 * 0.7],
+    },
+    16599: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "雷走风切",
+        "damage_base": [35, 45, 55, 70, 85, 100, 115, 130, 145, 175],
+        "damage_rand": [5, 5, 5, 5, 5, 10, 10, 10, 10, 15],
+        "attack_power_cof": [45 * 0.8 * 0.7] +
+                            [(16 + (i - 1) * 17) * 0.8 * 0.7 for i in range(2, 10)] +
+                            [224 * 0.8 * 0.7],
+    },
+    11447: {
+        "skill_class": PhysicalDotDamage,
+        "skill_name": "闹须弥(DOT)",
+        "damage_base": [25, 28, 31, 34, 37, 40, 43, 46, 49, 52],
+        "attack_power_cof": [50] +
+                            [50 + (i - 1) * 25 for i in range(2, 10)] +
+                            [280],
+        "interval": 48
+    },
+    16933: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "惊燕式",
+        "damage_base": [30, 35, 40, 45, 50, 55, 60, 65, 70, 80],
+        "damage_rand": [5, 5, 5, 5, 5, 10, 10, 10, 10, 10],
+        "attack_power_cof": [16 * 1.3 * 1.2] +
+                            [(16 + (i - 1) * 8) * 1.3 * 1.2 for i in range(2, 10)] +
+                            [64 * 1.3 * 1.2],
+        "weapon_damage_cof": 1024
+    },
+    16934: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "惊燕式",
+        "damage_base": [30, 35, 40, 45, 50, 55, 60, 65, 70, 80],
+        "damage_rand": [5, 5, 5, 5, 5, 10, 10, 10, 10, 10],
+        "attack_power_cof": [20 * 1.3 * 1.2] +
+                            [(20 + (i - 1) * 8) * 1.3 * 1.2 for i in range(2, 10)] +
+                            [80 * 1.3 * 1.2],
+        "weapon_damage_cof": 1024
+    },
+    16935: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "逐鹰式",
+        "damage_base": [30, 35, 40, 45, 50, 55, 60, 65, 70, 80],
+        "damage_rand": [5, 5, 5, 5, 5, 10, 10, 10, 10, 10],
+        "attack_power_cof": [16 * 1.3 * 1.2] +
+                            [(16 + (i - 1) * 8) * 1.3 * 1.2 for i in range(2, 10)] +
+                            [64 * 1.3 * 1.2],
+        "weapon_damage_cof": 1024
+    },
+    16936: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "逐鹰式",
+        "damage_base": [30, 35, 40, 45, 50, 55, 60, 65, 70, 80],
+        "damage_rand": [5, 5, 5, 5, 5, 10, 10, 10, 10, 10],
+        "attack_power_cof": [16 * 1.3 * 1.2] +
+                            [(16 + (i - 1) * 8) * 1.3 * 1.2 for i in range(2, 10)] +
+                            [96 * 1.3 * 1.2],
+        "weapon_damage_cof": 1024
+    },
+    16937: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "控鹤式",
+        "damage_base": [30, 35, 40, 45, 50, 55, 60, 65, 70, 80],
+        "damage_rand": [5, 5, 5, 5, 5, 10, 10, 10, 10, 10],
+        "attack_power_cof": [16 * 1.3 * 1.2] +
+                            [(16 + (i - 1) * 8) * 1.3 * 1.2 for i in range(2, 10)] +
+                            [80 * 1.3 * 1.2],
+        "weapon_damage_cof": 1024
+    },
+    16938: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "控鹤式",
+        "damage_base": [30, 35, 40, 45, 50, 55, 60, 65, 70, 80],
+        "damage_rand": [5, 5, 5, 5, 5, 10, 10, 10, 10, 10],
+        "attack_power_cof": [20 * 1.3 * 1.2] +
+                            [(20 + (i - 1) * 8) * 1.3 * 1.2 for i in range(2, 10)] +
+                            [104 * 1.3 * 1.2],
+        "weapon_damage_cof": 1024
+    },
+    16787: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "坚壁清野",
+        "damage_base": [150, 170, 190, 210, 230, 250, 270, 290, 310, 330, 350, 370, 390, 410, 430],
+        "damage_rand": [5, 5, 5, 5, 5, 10, 10, 10, 10, 15, 15, 15, 20, 20, 20],
+        "attack_power_cof": [60 * 1.2 * 0.7 * 1.1] +
+                            [(60 + (i - 1) * 16) * 1.2 * 0.7 * 1.1 for i in range(2, 15)] +
+                            [288 * 1.2 * 0.7 * 1.1],
+    },
+    16794: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "坚壁清野",
+        "damage_base": [55, 70, 85, 100, 115, 130, 145, 160, 175, 190, 205, 220, 235, 240, 250],
+        "damage_rand": [5, 5, 5, 5, 5, 10, 10, 10, 10, 15, 15, 15, 20, 20, 20],
+        "attack_power_cof": [32 * 1.1] +
+                            [32 + (i - 1) * 9 * 1.1 for i in range(2, 15)] +
+                            [160 * 1.1],
+    },
+    16610: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "刀啸风吟",
+        "damage_base": [100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 205, 220, 235, 240, 250],
+        "damage_rand": [5, 5, 5, 5, 5, 10, 10, 10, 10, 15, 15, 15, 20, 20, 20],
+        "attack_power_cof": [50 * 1.2 * 1.05 * 1.1 * 1.1 * 1.05] +
+                            [(50 + (i - 1) * 14) * 1.2 * 1.05 * 1.1 * 1.1 * 1.05 for i in range(2, 15)] +
+                            [256 * 1.2 * 1.05 * 1.1 * 1.1 * 1.05],
+    },
+    16760: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "项王击鼎",
+        "damage_base": [35, 45, 55, 70, 85, 100, 115, 130, 145, 175, 190, 205, 220, 235, 250],
+        "damage_rand": [5, 5, 5, 5, 5, 10, 10, 10, 10, 15, 15, 15, 15, 15, 15],
+        "attack_power_cof": [40 * 1.2 * 0.9 * 1.1 * 1.1] +
+                            [(40 + (i - 1) * 11) * 1.2 * 0.9 * 1.1 * 1.1 for i in range(2, 15)] +
+                            [200 * 1.2 * 0.9 * 1.1 * 1.1],
+        "weapon_damage_cof": 1024
+    },
+    16382: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "项王击鼎",
+        "damage_base": [50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190],
+        "damage_rand": [5, 5, 5, 5, 5, 10, 10, 10, 10, 15, 15, 15, 15, 15, 15],
+        "attack_power_cof": [16 * 0.9 * 1.1] +
+                            [(16 + (i - 1) * 7) * 0.9 * 1.1 for i in range(2, 15)] +
+                            [128 * 0.9 * 1.1],
+        "weapon_damage_cof": 1024
+    },
+    20991: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "破釜沉舟",
+        "damage_base": [90, 86, 110, 130, 150, 170, 190, 210, 230, 250, 270, 290, 310, 330, 350],
+        "damage_rand": [5, 5, 5, 5, 5, 10, 10, 10, 10, 15, 15, 15, 15, 15, 20],
+        "attack_power_cof": [80 * 0.9 * 0.95 * 1.1 * 1.15] +
+                            [(80 + (i - 1) * 22) * 0.9 * 0.95 * 1.1 * 1.15 for i in range(2, 15)] +
+                            [400 * 0.9 * 0.95 * 1.1 * 1.15],
+        "weapon_damage_cof": 2048
+    },
+    16803: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "上将军印",
+        "damage_base": [100, 140, 160, 180, 200, 220, 240, 260, 280, 300],
+        "damage_rand": [10, 10, 10, 10, 10, 15, 15, 15, 15, 15],
+        "attack_power_cof": [60 * 0.9 * 1.1 * 1.05] +
+                            [(60 + (i - 1) * 10) * 0.9 * 1.1 * 1.05 for i in range(2, 10)] +
+                            [160 * 0.9 * 1.1 * 1.05],
+        "weapon_damage_cof": 1024
+    },
+    16802: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "上将军印",
+        "damage_base": [int(e * 1.15) for e in [100, 140, 160, 180, 200, 220, 240, 260, 280, 300]],
+        "damage_rand": [int(e * 1.15) for e in [10, 10, 10, 10, 10, 15, 15, 15, 15, 15]],
+        "attack_power_cof": [60 * 1.15 * 0.9 * 1.1 * 1.05] +
+                            [(60 + (i - 1) * 10) * 1.15 * 0.9 * 1.1 * 1.05 for i in range(2, 10)] +
+                            [160 * 1.15 * 0.9 * 1.1 * 1.05],
+        "weapon_damage_cof": 1024 * 1.15
+    },
+    16801: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "上将军印",
+        "damage_base": [int(e * 1.3) for e in [100, 140, 160, 180, 200, 220, 240, 260, 280, 300]],
+        "damage_rand": [int(e * 1.3) for e in [10, 10, 10, 10, 10, 15, 15, 15, 15, 15]],
+        "attack_power_cof": [60 * 1.3 * 0.9 * 1.1 * 1.05] +
+                            [(60 + (i - 1) * 10) * 1.3 * 0.9 * 1.1 * 1.05 for i in range(2, 10)] +
+                            [160 * 1.3 * 0.9 * 1.1 * 1.05],
+        "weapon_damage_cof": 1024 * 1.3
+    },
+    16800: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "上将军印",
+        "damage_base": [int(e * 1.45) for e in [100, 140, 160, 180, 200, 220, 240, 260, 280, 300]],
+        "damage_rand": [int(e * 1.45) for e in [10, 10, 10, 10, 10, 15, 15, 15, 15, 15]],
+        "attack_power_cof": [60 * 1.45 * 0.9 * 1.1 * 1.05] +
+                            [(60 + (i - 1) * 10) * 1.45 * 0.9 * 1.1 * 1.05 for i in range(2, 10)] +
+                            [160 * 1.45 * 0.9 * 1.1 * 1.05],
+        "weapon_damage_cof": 1024 * 1.45
+    },
+    17043: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "上将军印",
+        "damage_base": [int(e * 1.6) for e in [100, 140, 160, 180, 200, 220, 240, 260, 280, 300]],
+        "damage_rand": [int(e * 1.6) for e in [10, 10, 10, 10, 10, 15, 15, 15, 15, 15]],
+        "attack_power_cof": [60 * 1.6 * 0.9 * 1.1 * 1.05] +
+                            [(60 + (i - 1) * 10) * 1.6 * 0.9 * 1.1 * 1.05 for i in range(2, 10)] +
+                            [160 * 1.6 * 0.9 * 1.1 * 1.05],
+        "weapon_damage_cof": 1024 * 1.6
+    },
+    19423: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "上将军印",
+        "damage_base": [int(e * 1.75) for e in [100, 140, 160, 180, 200, 220, 240, 260, 280, 300]],
+        "damage_rand": [int(e * 1.75) for e in [10, 10, 10, 10, 10, 15, 15, 15, 15, 15]],
+        "attack_power_cof": [60 * 1.75 * 0.9 * 1.1 * 1.05] +
+                            [(60 + (i - 1) * 10) * 1.75 * 0.9 * 1.1 * 1.05 for i in range(2, 10)] +
+                            [160 * 1.75 * 0.9 * 1.1 * 1.05],
+        "weapon_damage_cof": 1024 * 1.6
+    },
+    19424: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "上将军印",
+        "damage_base": [int(e * 1.9) for e in [100, 140, 160, 180, 200, 220, 240, 260, 280, 300]],
+        "damage_rand": [int(e * 1.9) for e in [10, 10, 10, 10, 10, 15, 15, 15, 15, 15]],
+        "attack_power_cof": [60 * 1.9 * 0.9 * 1.1 * 1.05] +
+                            [(60 + (i - 1) * 10) * 1.9 * 0.9 * 1.1 * 1.05 for i in range(2, 10)] +
+                            [160 * 1.9 * 0.9 * 1.1 * 1.05],
+        "weapon_damage_cof": 1024 * 1.6
+    },
+    36486: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "楚歌",
+        "damage_base": [55, 70],
+        "damage_rand": 5,
+        "attack_power_cof": [240 * 0.9, 1200 * 0.8],
+    },
+    30645: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "降麒",
+        "damage_base": [50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190],
+        "damage_rand": [5, 5, 5, 5, 5, 10, 10, 10, 10, 15, 15, 15, 15, 15, 15],
+        "attack_power_cof": 60 * 2,
+        "weapon_damage_cof": 1024
+    },
+    34585: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "绝期",
+        "damage_base": [55, 70, 85, 100, 115, 130, 145, 160, 175, 190, 205, 220, 235, 240, 250],
+        "damage_rand": [5, 5, 5, 5, 5, 10, 10, 10, 10, 15, 15, 15, 20, 20, 20],
+        "attack_power_cof": 120,
+    },
+    32859: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "上将军印·见尘",
+        "damage_base": [int(e * 1.45 * 0.5) for e in [100, 140, 160, 180, 200, 220, 240, 260, 280, 300]],
+        "damage_rand": [int(e * 1.45 * 0.5) for e in [10, 10, 10, 10, 10, 15, 15, 15, 15, 15]],
+        "attack_power_cof": [60 * 1.45 * 1.1 * 0.7] +
+                            [(60 + (i - 1) * 10) * 1.45 * 1.1 * 0.7 for i in range(2, 10)] +
+                            [160 * 1.45 * 0.9 * 1.1 * 0.7],
+        "weapon_damage_cof": 1024 * 1.45 * 0.25
+    },
+    37458: {
+        "skill_class": PhysicalDamage,
+        "skill_name": "掠关",
+        "attack_power_cof": 1.4375 * 10 * 16 * 1.3
+    }
+}
+
+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)

schools/first/talents.py

@@ -0,0 +1,60 @@
+from base.buff import Buff
+
+talents = {
+    "26904": {
+        "buff_name": "冥鼔",
+        "gain_skills": {
+            **{
+                skill_id: {
+                    "physical_damage_addition": 205,
+                    "physical_shield_gain": -512
+                } for skill_id in ["16760", "16382", "20991"]
+            },
+            "32823": {
+                "physical_shield_gain": [0, 0, -512, -512]
+            },
+        }
+    },
+    "17042": {
+        "buff_name": "阳关",
+        "gain_skills": {
+            **{
+                skill_id: {
+                    "physical_damage_addition": 154,
+                    "physical_shield_gain": -205
+                } for skill_id in ["16803", "16802", "16801", "16800", "17043", "19423", "19424"]
+            },
+            "32859": {
+                "physical_damage_addition": 154,
+            },
+        }
+    },
+    "16728": {
+        "buff_name": "星火",
+        "gain_attributes": {
+            "strength_gain": 102
+        }
+    },
+    "34677": {
+        "buff_name": "绝河",
+        "gain_skills": {
+            "20991": {
+                "physical_damage_addition": 307
+            }
+        }
+    },
+    "17056": {
+        "buff_name": "绝期",
+        "gain_skills": {
+            "11447": {
+                "attack_power_cof_gain": 0.7
+            }
+        }
+    }
+}
+
+for talent_id, detail in talents.items():
+    talents[talent_id] = Buff(talent_id, detail.pop("buff_name"))
+    for attr, value in detail.items():
+        setattr(talents[talent_id], attr, value)
+print(len(talents))

schools/first/test.py

@@ -0,0 +1,23 @@
+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
+
+
+if __name__ == '__main__':
+    attribute = BeiAoJue()
+    attribute.strength_base += 6665
+    attribute.weapon_damage_base += 3291
+    attribute.weapon_damage_rand += 2194
+    attribute.surplus += 29401
+    attribute.strain_base += 15598
+    attribute.physical_attack_power_base += 28964
+    attribute.physical_critical_strike_base += 30507
+    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")])
+    analyze_details(parser, attribute)
+    print(parser.summary)